feat(app): move background work to session summary (#44068)

Signed-off-by: Major Hayden <major@mhtx.net>
Co-authored-by: Major Hayden <major@mhtx.net>

.changeset/device-authorization-url.md

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

.github/workflows/test.yml

@@ -50,6 +50,14 @@ jobs:
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
 
+      - name: Test Effect simplification rules
+        if: runner.os == 'Linux'
+        run: bun run test:effect-simplification-rules
+
+      - name: Check Effect simplifications
+        if: runner.os == 'Linux'
+        run: bun run lint:effect-simplifications
+
       - name: Configure git identity
         run: |
           git config --global user.email "bot@opencode.ai"

.opencode/tui.json

@@ -1,19 +1,3 @@
 {
-  "$schema": "https://opencode.ai/tui.json",
-  "plugin": [
-    [
-      "./plugins/tui-smoke.tsx",
-      {
-        "enabled": false,
-        "label": "workspace",
-        "keybinds": {
-          "smoke_modal": "ctrl+alt+m",
-          "smoke_screen": "ctrl+alt+o",
-          "smoke_screen_home": "escape,ctrl+shift+h",
-          "smoke_screen_modal": "ctrl+alt+m",
-          "smoke_dialog_close": "escape,q"
-        }
-      }
-    ]
-  ]
+  "$schema": "https://opencode.ai/tui.json"
 }

AGENTS.md

@@ -1,5 +1,5 @@
 - After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`. Do not edit generated client files directly.
-- Keep runtime dependencies directed from Schema to Core and Protocol, then from Core and Protocol to Server. Client runtime code may depend on Schema and Protocol but never Core or Server; `sdk-next` composes Client, Core, and Server.
+- Keep runtime dependencies directed from Schema to Core and Protocol, then from Core and Protocol to Server. Client runtime code may depend on Schema and Protocol but never Core or Server; `sdk` composes Client, Core, and Server.
 - Current implementation changes belong in `packages/core`, `packages/cli`, `packages/server`, `packages/protocol`, `packages/schema`, and related generated client surfaces when required.
 - The default branch in this repo is `v2`.
 - Base all new branches and worktrees on `v2`, or `origin/v2` when the local `v2` ref is unavailable. Do not base them on `dev`.

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-8pRvkbUX2aZhFTFtFuUM6mPqZZhfC4mFd1+BXVMzEJk=",
-    "aarch64-linux": "sha256-df25TWdjjLKeLZJEfrDpgVaV8ZAZhHWPoV2IPIQ4U2w=",
-    "aarch64-darwin": "sha256-VjbOx7Zi9eTiPxqpKN3+EQWweBfJHf7y36sGSN1peg0=",
-    "x86_64-darwin": "sha256-q7nW4AR2OnepnDcPDtYECgcsXI+JRHOCWhPsAX8t7q0="
+    "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="
   }
 }

package.json

@@ -18,13 +18,16 @@
     "bench:devex": "bun run --cwd packages/app test:bench:devex",
     "lint": "oxlint",
     "lint:effect-patterns": "ast-grep scan -c script/ast-grep/sgconfig.yml packages/util/src packages/core/src packages/server/src packages/protocol/src packages/cli/src",
+    "lint:effect-simplifications": "ast-grep scan -c script/ast-grep/effect-simplifications/sgconfig.yml --off=unused-suppression packages",
     "test:lint-rules": "ast-grep test -c script/ast-grep/sgconfig.yml",
+    "test:effect-simplification-rules": "ast-grep test -c script/ast-grep/effect-simplifications/sgconfig.yml",
     "typecheck": "bun turbo typecheck --concurrency=3",
     "typecheck:profile": "bun script/profile-typecheck.ts",
     "typecheck:profile:packages": "bun script/profile-typecheck-packages.ts",
     "upgrade-opentui": "bun run script/upgrade-opentui.ts",
     "postinstall": "bun run --cwd packages/core fix-node-pty",
     "prepare": "husky",
+    "reserve-packages": "bun script/reserve-package-names.ts",
     "random": "echo 'Random script'",
     "sso": "aws sso login --sso-session=opencode --no-browser",
     "test": "echo 'do not run tests from root' && exit 1"
@@ -33,8 +36,7 @@
     "packages": [
       "packages/*",
       "packages/console/*",
-      "packages/stats/*",
-      "packages/slack"
+      "packages/stats/*"
     ],
     "catalog": {
       "@effect/opentelemetry": "4.0.0-rc.110",
@@ -127,7 +129,6 @@
     "@aws-sdk/client-s3": "3.933.0",
     "@opencode-ai/plugin": "workspace:*",
     "@opencode-ai/script": "workspace:*",
-    "@opencode-ai/sdk": "1.18.5",
     "heap-snapshot-toolkit": "1.1.3",
     "typescript": "catalog:"
   },
@@ -174,6 +175,6 @@
     "@pierre/trees@1.0.0-beta.4": "patches/@pierre%2Ftrees@1.0.0-beta.4.patch",
     "@modelcontextprotocol/sdk@1.29.0": "patches/@modelcontextprotocol%2Fsdk@1.29.0.patch",
     "@tanstack/virtual-core@3.17.3": "patches/@tanstack%2Fvirtual-core@3.17.3.patch",
-    "@ff-labs/fff-bun@0.10.1": "patches/@ff-labs%2Ffff-bun@0.10.1.patch"
+    "@ff-labs/fff-bun@0.10.5": "patches/@ff-labs%2Ffff-bun@0.10.5.patch"
   }
 }

packages/ai/script/setup-recording-env.ts

@@ -370,7 +370,7 @@ const responseError = Effect.fn("RecordingEnv.responseError")(function* (
   response: HttpClientResponse.HttpClientResponse,
 ) {
   if (response.status >= 200 && response.status < 300) return undefined
-  const body = yield* response.text.pipe(Effect.catch(() => Effect.succeed("")))
+  const body = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
   return `${response.status}${body ? `: ${body.slice(0, 180)}` : ""}`
 })
 

packages/ai/src/protocols/gemini.ts

@@ -37,6 +37,10 @@ const requiresThoughtSignatureFallback = (modelID: string) => {
   return !/(^|\/)gemini-robotics-er-1\.5(?:[.-]|$)/i.test(modelID)
 }
 
+// Gemini 3 accepts media nested inside function responses; matched Gemini 2.5 variants reject it,
+// so their tool-result attachments lower as a separate user turn instead.
+const routesLegacyToolMedia = (modelID: string) => /gemini-2[.-]5(?:[.-]|$)/i.test(modelID)
+
 export interface OptionsInput {
   readonly [key: string]: unknown
   readonly cachedContent?: string
@@ -208,11 +212,11 @@ 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
   readonly reasoningSignature?: string
+  readonly textSignature?: string
 }
 
 // =============================================================================
@@ -284,8 +288,16 @@ const lowerToolCall = (part: ToolCallPart) => ({
 
 const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMRequest) {
   const contents: GeminiContent[] = []
+  const legacyToolMedia = routesLegacyToolMedia(request.model.id)
+  let pendingMedia: GeminiInlineDataPart[] | undefined
+  const flushMedia = () => {
+    if (!pendingMedia) return
+    contents.push({ role: "user", parts: [{ text: "Attached media from tool result:" }, ...pendingMedia] })
+    pendingMedia = undefined
+  }
 
   for (const message of request.messages) {
+    if (message.role !== "tool") flushMedia()
     if (message.role === "system") {
       const part = yield* ProviderShared.wrappedSystemUpdate("Gemini", message)
       const previous = contents.at(-1)
@@ -316,7 +328,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
         if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call"]))
           return yield* ProviderShared.unsupportedContent("Gemini", "assistant", ["text", "reasoning", "tool-call"])
         if (part.type === "text") {
-          parts.push({ text: part.text })
+          parts.push({ text: part.text, thoughtSignature: thoughtSignature(part.providerMetadata) })
           continue
         }
         if (part.type === "reasoning") {
@@ -367,6 +379,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
         const value = ProviderShared.normalizeToolFile(item)
         media.push({ inlineData: { mimeType: value.mime, data: value.base64 } })
       }
+      if (legacyToolMedia && media.length > 0) (pendingMedia ??= []).push(...media)
       parts.push({
         functionResponse: {
           id: functionCallId(part.providerMetadata),
@@ -375,7 +388,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
             name: part.name,
             content: text.join("\n"),
           },
-          parts: media.length > 0 ? media : undefined,
+          parts: legacyToolMedia || media.length === 0 ? undefined : media,
         },
       })
     }
@@ -387,6 +400,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
     else contents.push({ role: "user", parts })
   }
 
+  flushMedia()
   return contents
 })
 
@@ -526,14 +540,16 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
   if (finishReason === undefined && state.usage === undefined) return []
 
   const events: LLMEvent[] = []
-  const lifecycle = state.reasoningSignature
-    ? Lifecycle.reasoningEnd(
-        state.lifecycle,
-        events,
-        "reasoning-0",
-        googleMetadata({ thoughtSignature: state.reasoningSignature }),
-      )
-    : state.lifecycle
+  let lifecycle = state.lifecycle
+  if (state.reasoningSignature !== undefined)
+    lifecycle = Lifecycle.reasoningEnd(
+      lifecycle,
+      events,
+      "reasoning-0",
+      googleMetadata({ thoughtSignature: state.reasoningSignature }),
+    )
+  if (state.textSignature !== undefined)
+    lifecycle = Lifecycle.textEnd(lifecycle, events, "text-0", googleMetadata({ thoughtSignature: state.textSignature }))
   Lifecycle.finish(lifecycle, events, {
     reason: {
       normalized:
@@ -563,12 +579,15 @@ 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
 
   for (const part of candidate.content.parts) {
-    if ("thoughtSignature" in part && part.thoughtSignature && "thought" in part && part.thought)
-      reasoningSignature = part.thoughtSignature
+    const signature = "thoughtSignature" in part && part.thoughtSignature ? part.thoughtSignature : undefined
+    // Gemini attaches replay signatures to thought parts, visible text, or function calls;
+    // each block kind must retain the signature attached to its own parts.
+    if (signature !== undefined && "thought" in part && part.thought) reasoningSignature = signature
+    else if (signature !== undefined && "text" in part) textSignature = signature
     if ("text" in part && part.text.length > 0) {
       if (part.thought) {
         lifecycle = Lifecycle.reasoningDelta(
@@ -576,7 +595,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
           events,
           "reasoning-0",
           part.text,
-          part.thoughtSignature ? googleMetadata({ thoughtSignature: part.thoughtSignature }) : undefined,
+          signature ? googleMetadata({ thoughtSignature: signature }) : undefined,
         )
         continue
       }
@@ -586,13 +605,22 @@ const step = (state: ParserState, event: GeminiEvent) => {
         "reasoning-0",
         reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined,
       )
-      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", part.text)
+      lifecycle = Lifecycle.textDelta(
+        lifecycle,
+        events,
+        "text-0",
+        part.text,
+        textSignature ? googleMetadata({ thoughtSignature: textSignature }) : undefined,
+      )
+      textSignature = undefined
       continue
     }
 
     if ("functionCall" in part) {
       const input = part.functionCall.args === undefined ? {} : part.functionCall.args
-      const id = `tool_${nextToolCallId++}`
+      // 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 metadata = {
         ...(part.functionCall.id === undefined ? {} : { functionCallId: part.functionCall.id }),
         ...(part.thoughtSignature === undefined ? {} : { thoughtSignature: part.thoughtSignature }),
@@ -621,8 +649,8 @@ const step = (state: ParserState, event: GeminiEvent) => {
       ...nextState,
       hasToolCalls,
       lifecycle,
-      nextToolCallId,
       reasoningSignature,
+      textSignature,
       finishReason: candidate.finishReason ?? nextState.finishReason,
     },
     events,
@@ -644,7 +672,7 @@ export const protocol = Protocol.make({
   },
   stream: {
     event: Protocol.jsonEvent(GeminiEvent),
-    initial: () => ({ hasToolCalls: false, nextToolCallId: 0, lifecycle: Lifecycle.initial() }),
+    initial: () => ({ hasToolCalls: false, 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.succeed(undefined)
+        return Effect.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.succeed(undefined)
+  if (!url.startsWith("data:")) return Effect.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/src/protocols/utils/lifecycle.ts

@@ -21,9 +21,15 @@ export const textStart = (state: State, events: LLMEvent[], id: string, provider
   return { ...stepped, text: new Set([...stepped.text, id]) }
 }
 
-export const textDelta = (state: State, events: LLMEvent[], id: string, text: string): State => {
+export const textDelta = (
+  state: State,
+  events: LLMEvent[],
+  id: string,
+  text: string,
+  providerMetadata?: ProviderMetadata,
+): State => {
   const started = textStart(state, events, id)
-  events.push(LLMEvent.textDelta({ id, text }))
+  events.push(LLMEvent.textDelta({ id, text, providerMetadata }))
   return started
 }
 

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

@@ -328,14 +328,18 @@ describe("Gemini route", () => {
               functionResponse: {
                 name: "read",
                 response: { name: "read", content: "Image read successfully" },
-                parts: [
-                  { inlineData: { mimeType: "image/png", data: "AAECAw==" } },
-                  { inlineData: { mimeType: "application/pdf", data: "JVBERi0xLjQ=" } },
-                ],
               },
             },
           ],
         },
+        {
+          role: "user",
+          parts: [
+            { text: "Attached media from tool result:" },
+            { inlineData: { mimeType: "image/png", data: "AAECAw==" } },
+            { inlineData: { mimeType: "application/pdf", data: "JVBERi0xLjQ=" } },
+          ],
+        },
       ])
       expect(JSON.stringify(prepared.body.contents)).not.toContain('"content":"AAECAw=="')
     }),
@@ -368,11 +372,161 @@ describe("Gemini route", () => {
               functionResponse: {
                 name: "read",
                 response: { name: "read", content: "" },
-                parts: [{ inlineData: { mimeType: "image/jpeg", data: "/9j/" } }],
               },
             },
           ],
         },
+        {
+          role: "user",
+          parts: [
+            { text: "Attached media from tool result:" },
+            { inlineData: { mimeType: "image/jpeg", data: "/9j/" } },
+          ],
+        },
+      ])
+    }),
+  )
+
+  it.effect("nests media inside function responses for gemini 3", () =>
+    Effect.gen(function* () {
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model: gemini3,
+          messages: [
+            Message.assistant([
+              ToolCallPart.make({
+                id: "call_image",
+                name: "read",
+                input: { path: "pixel.png" },
+                providerMetadata: { google: { thoughtSignature: "sig_1" } },
+              }),
+            ]),
+            Message.tool({
+              id: "call_image",
+              name: "read",
+              result: {
+                type: "content",
+                value: [
+                  { type: "text", text: "Image read successfully" },
+                  { type: "file", uri: "data:image/png;base64,AAECAw==", mime: "image/png", name: "pixel.png" },
+                ],
+              },
+            }),
+          ],
+        }),
+      )
+
+      expect(prepared.body.contents).toEqual([
+        {
+          role: "model",
+          parts: [{ functionCall: { name: "read", args: { path: "pixel.png" } }, thoughtSignature: "sig_1" }],
+        },
+        {
+          role: "user",
+          parts: [
+            {
+              functionResponse: {
+                name: "read",
+                response: { name: "read", content: "Image read successfully" },
+                parts: [{ inlineData: { mimeType: "image/png", data: "AAECAw==" } }],
+              },
+            },
+          ],
+        },
+      ])
+    }),
+  )
+
+  it.effect("flushes pending media before system update text", () =>
+    Effect.gen(function* () {
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model,
+          messages: [
+            Message.assistant([ToolCallPart.make({ id: "call_1", name: "shot", input: {} })]),
+            Message.tool({
+              id: "call_1",
+              name: "shot",
+              result: {
+                type: "content",
+                value: [{ type: "file", uri: "data:image/png;base64,AAEC", mime: "image/png" }],
+              },
+            }),
+            Message.system("Update."),
+          ],
+        }),
+      )
+
+      expect(prepared.body.contents).toEqual([
+        { role: "model", parts: [{ functionCall: { name: "shot", args: {} } }] },
+        {
+          role: "user",
+          parts: [{ functionResponse: { name: "shot", response: { name: "shot", content: "" } } }],
+        },
+        {
+          role: "user",
+          parts: [
+            { text: "Attached media from tool result:" },
+            { inlineData: { mimeType: "image/png", data: "AAEC" } },
+            { text: "<system-update>\nUpdate.\n</system-update>" },
+          ],
+        },
+      ])
+    }),
+  )
+
+  it.effect("collects legacy tool media into one turn after merged responses", () =>
+    Effect.gen(function* () {
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model,
+          messages: [
+            Message.assistant([
+              ToolCallPart.make({ id: "call_1", name: "shot", input: {} }),
+              ToolCallPart.make({ id: "call_2", name: "shot", input: {} }),
+            ]),
+            Message.tool({
+              id: "call_1",
+              name: "shot",
+              result: {
+                type: "content",
+                value: [{ type: "file", uri: "data:image/png;base64,AAEC", mime: "image/png" }],
+              },
+            }),
+            Message.tool({
+              id: "call_2",
+              name: "shot",
+              result: {
+                type: "content",
+                value: [{ type: "text", text: "no image here" }],
+              },
+            }),
+          ],
+        }),
+      )
+
+      expect(prepared.body.contents).toEqual([
+        {
+          role: "model",
+          parts: [
+            { functionCall: { name: "shot", args: {} } },
+            { functionCall: { name: "shot", args: {} } },
+          ],
+        },
+        {
+          role: "user",
+          parts: [
+            { functionResponse: { name: "shot", response: { name: "shot", content: "" } } },
+            { functionResponse: { name: "shot", response: { name: "shot", content: "no image here" } } },
+          ],
+        },
+        {
+          role: "user",
+          parts: [
+            { text: "Attached media from tool result:" },
+            { inlineData: { mimeType: "image/png", data: "AAEC" } },
+          ],
+        },
       ])
     }),
   )
@@ -694,7 +848,7 @@ describe("Gemini route", () => {
         providerMetadata: { google: { thoughtSignature: "thought_sig" } },
       })
       expect(toolCall).toMatchObject({
-        id: "tool_0",
+        id: "provider_call",
         providerMetadata: { google: { functionCallId: "provider_call", thoughtSignature: "tool_sig" } },
       })
       expect(response.events.findIndex((event) => event.type === "reasoning-end")).toBeLessThan(
@@ -708,14 +862,14 @@ describe("Gemini route", () => {
             Message.assistant([
               { type: "reasoning", text: "thinking", providerMetadata: reasoningEnd?.providerMetadata },
               ToolCallPart.make({
-                id: "tool_0",
+                id: "provider_call",
                 name: "lookup",
                 input: { query: "weather" },
                 providerMetadata: toolCall?.providerMetadata,
               }),
             ]),
             Message.tool({
-              id: "tool_0",
+              id: "provider_call",
               name: "lookup",
               result: "done",
               resultType: "text",
@@ -751,6 +905,61 @@ describe("Gemini route", () => {
     }),
   )
 
+  it.effect("preserves thoughtSignature on visible text parts", () =>
+    Effect.gen(function* () {
+      const body = sseEvents({
+        candidates: [
+          {
+            content: { role: "model", parts: [{ text: "All done.", thoughtSignature: "text_sig" }] },
+            finishReason: "STOP",
+          },
+        ],
+      })
+      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
+      const delta = response.events.find((event) => event.type === "text-delta")
+      expect(delta).toMatchObject({
+        id: "text-0",
+        text: "All done.",
+        providerMetadata: { google: { thoughtSignature: "text_sig" } },
+      })
+
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model,
+          messages: [Message.assistant([{ type: "text", text: "All done.", providerMetadata: delta?.providerMetadata }])],
+        }),
+      )
+      expect(prepared.body.contents).toEqual([
+        { role: "model", parts: [{ text: "All done.", thoughtSignature: "text_sig" }] },
+      ])
+    }),
+  )
+
+  it.effect("flushes a trailing empty signed text part at block close", () =>
+    Effect.gen(function* () {
+      const body = sseEvents({
+        candidates: [
+          {
+            content: {
+              role: "model",
+              parts: [{ text: "Working." }, { text: "", thoughtSignature: "tail_sig" }],
+            },
+            finishReason: "STOP",
+          },
+        ],
+      })
+      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
+      const delta = response.events.find((event) => event.type === "text-delta")
+      const end = response.events.find((event) => event.type === "text-end")
+
+      expect(delta).toMatchObject({ id: "text-0", text: "Working.", providerMetadata: undefined })
+      expect(end).toMatchObject({
+        id: "text-0",
+        providerMetadata: { google: { thoughtSignature: "tail_sig" } },
+      })
+    }),
+  )
+
   it.effect("replays unsigned Gemini 3 tool calls with the validator bypass sentinel", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
@@ -892,21 +1101,17 @@ describe("Gemini route", () => {
         providerMetadata: { google: { promptTokenCount: 5, candidatesTokenCount: 1 } },
       })
 
-      expect(response.toolCalls).toEqual([
-        {
-          type: "tool-call",
-          id: "tool_0",
-          name: "lookup",
-          input: { query: "weather" },
-          providerExecuted: undefined,
-          providerMetadata: undefined,
-        },
-      ])
+      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.events).toEqual([
         { type: "step-start", index: 0 },
         {
           type: "tool-call",
-          id: "tool_0",
+          id: response.toolCalls[0].id,
           name: "lookup",
           input: { query: "weather" },
           providerExecuted: undefined,
@@ -949,7 +1154,8 @@ describe("Gemini route", () => {
         ),
       )
 
-      expect(response.toolCalls).toEqual([{ type: "tool-call", id: "tool_0", name: "ping", input: {} }])
+      expect(response.toolCalls[0].id).toMatch(/^tool_[0-9a-zA-Z]+$/)
+      expect(response.toolCalls).toMatchObject([{ type: "tool-call", name: "ping", input: {} }])
     }),
   )
 
@@ -989,7 +1195,7 @@ describe("Gemini route", () => {
             content: {
               role: "model",
               parts: [
-                { functionCall: { id: "tool_0", name: "lookup", args: { query: "weather" } } },
+                { functionCall: { id: "call_0", name: "lookup", args: { query: "weather" } } },
                 { functionCall: { name: "lookup", args: { query: "news" } } },
               ],
             },
@@ -1003,16 +1209,20 @@ describe("Gemini route", () => {
         }),
       ).pipe(Effect.provide(fixedResponse(body)))
 
-      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.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.events.at(-1)).toMatchObject({
         type: "finish",
         reason: { normalized: "tool-calls", raw: "STOP" },
@@ -1020,6 +1230,31 @@ 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/regression/session-timeline-notices.spec.ts

@@ -81,7 +81,25 @@ 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)
-  await expect(page.locator('[data-action="session-background-toggle"]')).toContainText("Move 1 subagent to background")
+  const hint = page.locator('[data-component="session-background-hint"]')
+  const hintPrefix = hint.locator('[data-slot="session-background-hint-prefix"]')
+  const thinking = page.locator('[data-slot="session-turn-thinking"]')
+  await expect(hint).toBeVisible()
+  await expect
+    .poll(async () => {
+      const [cardBox, hintBox, prefixBox, thinkingBox] = await Promise.all([
+        card.boundingBox(),
+        hint.boundingBox(),
+        hintPrefix.boundingBox(),
+        thinking.boundingBox(),
+      ])
+      if (!cardBox || !hintBox || !prefixBox || !thinkingBox) return undefined
+      return {
+        aligned: Math.abs(cardBox.x - prefixBox.x) < 2,
+        ordered: cardBox.y < hintBox.y && hintBox.y < thinkingBox.y,
+      }
+    })
+    .toEqual({ aligned: true, ordered: true })
 
   const request = page.waitForRequest(
     (request) =>
@@ -104,10 +122,10 @@ test("navigates from a running subagent card and hides background controls in th
     sessionStatus: { [sessionID]: { type: "busy" }, [childID]: { type: "busy" } },
   })
 
-  await expect(page.locator('[data-action="session-background-toggle"]')).toContainText("Move 1 subagent to background")
+  await expect(page.getByText(/move running work to the background/i)).toBeVisible()
   await page.locator('[data-component="task-tool-card"]').click()
   await expect(page).toHaveURL(new RegExp(`/session/${childID}$`))
-  await expect(page.locator('[data-component="session-background-dock"]')).toHaveCount(0)
+  await expect(page.getByText(/move running work to the background/i)).toHaveCount(0)
 })
 
 test("shows a badge for active background work", async ({ page }) => {
@@ -118,7 +136,14 @@ test("shows a badge for active background work", async ({ page }) => {
     sessionStatus: { [childID]: { type: "busy" } },
   })
 
-  await expect(page.locator('[data-component="session-background-dock"]')).toContainText("1 subagent in background")
+  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()
 })
 
 test("separates blocking and already-backgrounded work into two rows", async ({ page }) => {
@@ -193,10 +218,15 @@ 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(dock).toContainText("Move 1 subagent to background")
-  await expect(dock.getByText("Running 1 shell and 1 subagent in background", { exact: true })).toBeVisible()
+  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(backgroundCard).toContainText("Background task (background)")
   await expect(backgroundCard.locator('[data-component="session-progress-indicator-v2"]')).toBeVisible()
   await expect(

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

@@ -127,19 +127,16 @@ test("labels skill tools from IDs and result metadata", async ({ page }) => {
     ],
   })
 
-  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]) {
+  for (const [id, name] of [
+    [pending, "sample-skill"],
+    [completed, "OpenCode"],
+  ] as const) {
     const skill = page.locator(`[data-timeline-part-id="${id}"]`)
-    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()
+    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)
   }
 })
 

packages/app/src/composer/composer.stories.tsx

@@ -7,6 +7,7 @@ import type { ComposerModel } from "./model"
 import { createComposerEditor } from "./editor/interaction"
 import type { ComposerPersistedState, ComposerSuggestion } from "./types"
 import { buildPromptRequest } from "./request"
+import { promptLength } from "./prompt-parts"
 import { SessionPreview } from "@/session/story-model"
 import { Skill } from "@opencode-ai/schema/skill"
 import { resolveSessionComposerSelection } from "@/session/composer/selection"
@@ -57,7 +58,7 @@ function ComposerStory(props: {
 }) {
   const [draft, setDraft] = createStore<ComposerPersistedState>({
     prompt: props.prompt ?? [{ type: "text", content: "", start: 0, end: 0 }],
-    cursor: props.prompt?.reduce((length, part) => length + ("content" in part ? part.content.length : 0), 0) ?? 0,
+    cursor: props.prompt ? promptLength(props.prompt) : 0,
     model: { providerID: STORY_MODEL.providerID, modelID: STORY_MODEL.id, variant: STORY_MODEL.variant },
     context: { items: props.comments ?? [] },
   })

packages/app/src/composer/editor/actions.ts

@@ -7,6 +7,7 @@ import type {
   ComposerPersistedState,
   ComposerPrompt,
 } from "../types"
+import { promptLength } from "../prompt-parts"
 
 export type ComposerStateStore = [
   Store<ComposerPersistedState> | Accessor<Store<ComposerPersistedState>>,
@@ -134,7 +135,3 @@ function withOffsets(prompt: ComposerPrompt): ComposerPrompt {
     return next
   })
 }
-
-function promptLength(prompt: ComposerPrompt) {
-  return prompt.reduce((length, part) => length + ("content" in part ? part.content.length : 0), 0)
-}

packages/app/src/composer/editor/interaction.ts

@@ -18,6 +18,7 @@ import {
   type ComposerInteractionCommand,
   type ComposerInteractionEvent,
 } from "../suggestions/machine"
+import { clonePrompt, promptLength } from "../prompt-parts"
 
 export type ComposerSelectControl = {
   options: Accessor<ComposerOption[]>
@@ -434,16 +435,6 @@ function canNavigateHistory(direction: "up" | "down", text: string, cursor: numb
   return position === text.length
 }
 
-function clonePrompt(prompt: ComposerPersistedState["prompt"]): ComposerPersistedState["prompt"] {
-  return prompt.map((part) =>
-    part.type === "file" ? { ...part, selection: part.selection ? { ...part.selection } : undefined } : { ...part },
-  )
-}
-
-function promptLength(prompt: ComposerPersistedState["prompt"]) {
-  return prompt.reduce((length, part) => length + ("content" in part ? part.content.length : 0), 0)
-}
-
 function editorCursor(editor: HTMLElement) {
   const selection = window.getSelection()
   if (!selection?.rangeCount || !editor.contains(selection.anchorNode)) return editor.textContent?.length ?? 0

packages/app/src/composer/history/entry.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { Prompt } from "@/composer/state"
-import { clonePromptParts, prependHistoryEntry, promptLength, type PromptHistoryComment } from "./entry"
+import { prependHistoryEntry, type PromptHistoryComment } from "./entry"
 import { upgradeHistoryState } from "./store"
 
 const DEFAULT_PROMPT: Prompt = [{ type: "text", content: "", start: 0, end: 0 }]
@@ -34,31 +34,32 @@ describe("Composer history", () => {
     expect(dedupedComments).toBe(commentsOnly)
   })
 
+  test("insertion isolates canonical entries from source mutations", () => {
+    const prompt: Prompt = [
+      {
+        type: "file",
+        path: "src/a.ts",
+        content: "@src/a.ts",
+        start: 0,
+        end: 9,
+        selection: { startLine: 1, startChar: 0, endLine: 2, endChar: 0 },
+      },
+    ]
+    const comments = [comment("c1")]
+    const entries = prependHistoryEntry([], prompt, comments)
+    const stored = entries[0]
+
+    if (prompt[0]?.type !== "file" || stored?.prompt[0]?.type !== "file") throw new Error("expected file")
+    prompt[0].selection!.startLine = 9
+    comments[0].selection.start = 9
+
+    expect(stored.prompt[0].selection?.startLine).toBe(1)
+    expect(stored.comments[0]?.selection.start).toBe(2)
+  })
+
   test("upgrades stored prompt arrays once at the persistence boundary", () => {
     expect(upgradeHistoryState({ entries: [text("stored")] })).toEqual({
       entries: [{ prompt: text("stored"), comments: [] }],
     })
   })
-
-  test("helpers clone prompt and count text content length", () => {
-    const original: Prompt = [
-      { type: "text", content: "one", start: 0, end: 3 },
-      {
-        type: "file",
-        path: "src/a.ts",
-        content: "@src/a.ts",
-        start: 3,
-        end: 12,
-        selection: { startLine: 1, startChar: 1, endLine: 2, endChar: 1 },
-      },
-      { type: "image", id: "1", filename: "img.png", mime: "image/png", blob: { id: "blob", url: "blob:test" } },
-    ]
-    const copy = clonePromptParts(original)
-    expect(copy).not.toBe(original)
-    expect(promptLength(copy)).toBe(12)
-    if (copy[1]?.type !== "file") throw new Error("expected file")
-    copy[1].selection!.startLine = 9
-    if (original[1]?.type !== "file") throw new Error("expected file")
-    expect(original[1].selection?.startLine).toBe(1)
-  })
 })

packages/app/src/composer/history/entry.ts

@@ -1,5 +1,6 @@
 import type { Prompt } from "@/composer/state"
 import type { SelectedLineRange } from "@/workspaces/files/model"
+import { clonePrompt } from "../prompt-parts"
 
 export const MAX_HISTORY = 100
 
@@ -20,19 +21,6 @@ export type PromptHistoryEntry = {
 
 export type PromptHistoryStoredEntry = PromptHistoryEntry
 
-export function clonePromptParts(prompt: Prompt): Prompt {
-  return prompt.map((part) => {
-    if (part.type === "text") return { ...part }
-    if (part.type === "image") return { ...part }
-    if (part.type === "agent") return { ...part }
-    if (part.type === "skill") return { ...part }
-    return {
-      ...part,
-      selection: part.selection ? { ...part.selection } : undefined,
-    }
-  })
-}
-
 function cloneSelection(selection: SelectedLineRange): SelectedLineRange {
   return {
     start: selection.start,
@@ -49,17 +37,6 @@ export function clonePromptHistoryComments(comments: PromptHistoryComment[]) {
   }))
 }
 
-export function normalizePromptHistoryEntry(entry: PromptHistoryStoredEntry): PromptHistoryEntry {
-  return {
-    prompt: clonePromptParts(entry.prompt),
-    comments: clonePromptHistoryComments(entry.comments),
-  }
-}
-
-export function promptLength(prompt: Prompt) {
-  return prompt.reduce((len, part) => len + ("content" in part ? part.content.length : 0), 0)
-}
-
 export function prependHistoryEntry(
   entries: PromptHistoryStoredEntry[],
   prompt: Prompt,
@@ -75,7 +52,7 @@ export function prependHistoryEntry(
   if (!text && !hasImages && !hasComments) return entries
 
   const entry = {
-    prompt: clonePromptParts(prompt),
+    prompt: clonePrompt(prompt),
     comments: clonePromptHistoryComments(comments),
   } satisfies PromptHistoryEntry
   const last = entries[0]
@@ -96,9 +73,7 @@ function isCommentEqual(commentA: PromptHistoryComment, commentB: PromptHistoryC
   )
 }
 
-function isPromptEqual(promptA: PromptHistoryStoredEntry, promptB: PromptHistoryStoredEntry) {
-  const entryA = normalizePromptHistoryEntry(promptA)
-  const entryB = normalizePromptHistoryEntry(promptB)
+function isPromptEqual(entryA: PromptHistoryStoredEntry, entryB: PromptHistoryStoredEntry) {
   if (entryA.prompt.length !== entryB.prompt.length) return false
   for (let i = 0; i < entryA.prompt.length; i++) {
     const partA = entryA.prompt[i]

packages/app/src/composer/history/store.ts

@@ -3,11 +3,11 @@ import type { Prompt } from "@/composer/state"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import {
   clonePromptHistoryComments,
-  clonePromptParts,
   prependHistoryEntry,
   type PromptHistoryComment,
   type PromptHistoryStoredEntry,
 } from "./entry"
+import { clonePrompt } from "../prompt-parts"
 
 export type ComposerHistoryStore = {
   entries: (mode: "normal" | "shell") => PromptHistoryStoredEntry[]
@@ -23,7 +23,7 @@ export function upgradeHistoryState(value: unknown) {
   return {
     ...value,
     entries: entries.flatMap((entry): PromptHistoryStoredEntry[] => {
-      if (Array.isArray(entry)) return [{ prompt: clonePromptParts(entry as Prompt), comments: [] }]
+      if (Array.isArray(entry)) return [{ prompt: clonePrompt(entry as Prompt), comments: [] }]
       if (!entry || typeof entry !== "object" || !("prompt" in entry) || !Array.isArray(entry.prompt)) return []
       if (!("comments" in entry) || !Array.isArray(entry.comments)) return []
       return [entry as PromptHistoryStoredEntry]
@@ -64,7 +64,7 @@ export function createComposerHistory() {
     add(prompt: Prompt, mode: "normal" | "shell", comments: PromptHistoryComment[]) {
       const ready = mode === "shell" ? shellInit : normalInit
       if (!(ready instanceof Promise)) return history.add(prompt, mode, comments)
-      const saved = clonePromptParts(prompt)
+      const saved = clonePrompt(prompt)
       const metadata = clonePromptHistoryComments(comments)
       void ready.then(() => history.add(saved, mode, metadata))
     },

packages/app/src/composer/model.ts

@@ -18,7 +18,7 @@ import { formatServerError } from "@/runtime/server/errors"
 import { Skill } from "@opencode-ai/schema/skill"
 import type { ComposerAdapter, ComposerControls } from "./adapter"
 import type { ImageAttachmentPart } from "./state"
-import { normalizePromptHistoryEntry, type PromptHistoryComment } from "./history/entry"
+import type { PromptHistoryComment } from "./history/entry"
 import { createComposerHistory } from "./history/store"
 import { composerPlaceholder } from "./placeholder"
 import { createComposerSubmit } from "./submit"
@@ -284,11 +284,7 @@ export function createComposerModel(adapter: ComposerAdapter): ComposerModel {
     store: prompt.store,
     state: interaction,
     history: {
-      entries: (mode) =>
-        history.entries(mode).map((value) => {
-          const entry = normalizePromptHistoryEntry(value)
-          return { prompt: entry.prompt, metadata: entry.comments }
-        }),
+      entries: (mode) => history.entries(mode).map((entry) => ({ prompt: entry.prompt, metadata: entry.comments })),
       add: (value, mode) => history.add(value, mode, mode === "shell" ? [] : historyComments()),
       capture: historyComments,
       restore: (metadata) => restoreHistoryComments(metadata as PromptHistoryComment[]),

packages/app/src/composer/prompt-parts.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test"
+import type { Prompt } from "./state"
+import { clonePrompt, promptLength } from "./prompt-parts"
+
+describe("composer prompt parts", () => {
+  test("clones parts shallowly and copies file selections", () => {
+    const original: Prompt = [
+      { type: "text", content: "one", start: 0, end: 3 },
+      {
+        type: "file",
+        path: "src/a.ts",
+        content: "@src/a.ts",
+        start: 3,
+        end: 12,
+        selection: { startLine: 1, startChar: 1, endLine: 2, endChar: 1 },
+      },
+      { type: "image", id: "1", filename: "img.png", mime: "image/png", blob: { id: "blob", url: "blob:test" } },
+    ]
+
+    const copy = clonePrompt(original)
+
+    expect(copy).not.toBe(original)
+    expect(copy[0]).not.toBe(original[0])
+    expect(copy[1]).not.toBe(original[1])
+    expect(copy[2]).not.toBe(original[2])
+    if (copy[1]?.type !== "file" || original[1]?.type !== "file") throw new Error("expected file parts")
+    if (copy[2]?.type !== "image" || original[2]?.type !== "image") throw new Error("expected image parts")
+    expect(copy[2].blob).toBe(original[2].blob)
+    expect(copy[1].selection).not.toBe(original[1].selection)
+    copy[1].selection!.startLine = 9
+    expect(original[1].selection?.startLine).toBe(1)
+  })
+
+  test("counts the content of text and mention parts", () => {
+    const prompt: Prompt = [
+      { type: "text", content: "one", start: 0, end: 3 },
+      { type: "agent", content: "@build", start: 3, end: 9, name: "build" },
+      { type: "image", id: "1", filename: "img.png", mime: "image/png", blob: { id: "blob", url: "blob:test" } },
+    ]
+
+    expect(promptLength(prompt)).toBe(9)
+  })
+})

packages/app/src/composer/prompt-parts.ts

@@ -0,0 +1,11 @@
+import type { Prompt } from "./state"
+
+export function clonePrompt(prompt: Prompt): Prompt {
+  return prompt.map((part) =>
+    part.type === "file" ? { ...part, selection: part.selection ? { ...part.selection } : undefined } : { ...part },
+  )
+}
+
+export function promptLength(prompt: Prompt) {
+  return prompt.reduce((length, part) => length + ("content" in part ? part.content.length : 0), 0)
+}

packages/app/src/composer/state.ts

@@ -8,6 +8,7 @@ import type { BlobReference } from "@/runtime/persistence/drafts"
 import type { Platform } from "@/runtime/platform/platform"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import { Skill } from "@opencode-ai/schema/skill"
+import { clonePrompt } from "./prompt-parts"
 
 interface PartBase {
   content: string
@@ -108,26 +109,6 @@ type InitialPrompt = {
   model?: PromptModel
 }
 
-function cloneSelection(selection?: FileSelection) {
-  if (!selection) return undefined
-  return { ...selection }
-}
-
-function clonePart(part: ContentPart): ContentPart {
-  if (part.type === "text") return { ...part }
-  if (part.type === "image") return { ...part }
-  if (part.type === "agent") return { ...part }
-  if (part.type === "skill") return { ...part }
-  return {
-    ...part,
-    selection: cloneSelection(part.selection),
-  }
-}
-
-function clonePrompt(prompt: Prompt): Prompt {
-  return prompt.map(clonePart)
-}
-
 function contextItemKey(item: ContextItem) {
   if (item.type !== "file") return item.type
   const start = item.selection?.startLine

packages/app/src/composer/submit.ts

@@ -1,8 +1,9 @@
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import { Event } from "@opencode-ai/schema/event"
 import type { Accessor } from "solid-js"
-import { clonePromptParts, type PromptHistoryComment } from "./history/entry"
+import type { PromptHistoryComment } from "./history/entry"
 import type { ImageAttachmentPart, Prompt } from "./state"
+import { clonePrompt, promptLength } from "./prompt-parts"
 import type { ComposerAdapter, ComposerSelection, ComposerSession } from "./adapter"
 import { createComposerSubmission } from "./submission-state"
 import { buildPromptRequest } from "./request"
@@ -48,7 +49,7 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
 
     const submission = createComposerSubmission({
       target: input.adapter.state,
-      prompt: clonePromptParts(input.adapter.state.current()),
+      prompt: clonePrompt(input.adapter.state.current()),
       context: input.adapter.state.context.items().map((item) => ({
         ...item,
         selection: item.selection ? { ...item.selection } : undefined,
@@ -317,7 +318,3 @@ function failSubmission(
   restore()
   input.notify.failed(kind, error)
 }
-
-function promptLength(prompt: Prompt) {
-  return prompt.reduce((length, part) => length + ("content" in part ? part.content.length : 0), 0)
-}

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

@@ -544,7 +544,6 @@ 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",
@@ -657,6 +656,10 @@ 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/runtime/server/global-sync/bootstrap.ts

@@ -53,22 +53,6 @@ function runAll(list: Array<() => Promise<unknown>>) {
   return Promise.allSettled(list.map((item) => item()))
 }
 
-function showErrors(input: {
-  errors: unknown[]
-  title: string
-  translate: (key: string, vars?: Record<string, string | number>) => string
-  formatMoreCount: (count: number) => string
-}) {
-  if (input.errors.length === 0) return
-  const message = formatServerError(input.errors[0], input.translate)
-  const more = input.errors.length > 1 ? input.formatMoreCount(input.errors.length - 1) : ""
-  showToast({
-    variant: "error",
-    title: input.title,
-    description: message + more,
-  })
-}
-
 export const loadGlobalConfigQuery = (scope: ServerScope) =>
   queryOptions({
     queryKey: [scope, "config"],
@@ -126,9 +110,6 @@ export async function bootstrapGlobal(input: {
     readonly worktree: WorktreeApi
   }
   scope: ServerScope
-  requestFailedTitle: string
-  translate: (key: string, vars?: Record<string, string | number>) => string
-  formatMoreCount: (count: number) => string
   setGlobalStore: SetStoreFunction<GlobalStore>
   queryClient: QueryClient
 }) {
@@ -141,12 +122,6 @@ export async function bootstrapGlobal(input: {
         .then((data) => input.setGlobalStore("project", data)),
   ]
   await runAll(slow)
-  // showErrors({
-  //   errors: errors(),
-  //   title: input.requestFailedTitle,
-  //   translate: input.translate,
-  //   formatMoreCount: input.formatMoreCount,
-  // })
 }
 
 function projectID(directory: string, projects: Project[]) {

packages/app/src/runtime/server/sync.tsx

@@ -97,9 +97,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) {
       await bootstrapGlobal({
         serverAPI: serverSDK.api,
         scope: serverSDK.scope,
-        requestFailedTitle: language.t("common.requestFailed"),
-        translate: language.t,
-        formatMoreCount: (count) => language.t("common.moreCountSuffix", { count }),
         setGlobalStore: setBootStore,
         queryClient,
       })

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

@@ -10,7 +10,7 @@ import { createComposerModel } from "@/composer/model"
 import { useComposerState } from "@/composer/persistence"
 import { createComposerControls } from "@/composer/selection"
 import { setCursorPosition } from "@/composer/editor/dom"
-import { promptLength } from "@/composer/history/entry"
+import { promptLength } from "@/composer/prompt-parts"
 import { useCommand } from "@/shell/commands/command"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useLocal } from "@/providers/models/selection"

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

@@ -2,15 +2,12 @@ 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,
@@ -32,9 +29,6 @@ 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}
@@ -81,22 +75,10 @@ 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/requests/model.ts

@@ -63,6 +63,7 @@ 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,
         },
@@ -93,11 +94,13 @@ 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

@@ -1,83 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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,6 +72,7 @@ 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

@@ -0,0 +1,23 @@
+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,15 +29,20 @@ 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,
+  sessionID: () => string | undefined,
   sessions: () => SessionStore<T>,
   options?: { children?: boolean },
 ) {
-  const cached = createMemo(() => sessions().get(sessionID()))
+  const cached = createMemo(() => {
+    const id = sessionID()
+    if (!id) return
+    return sessions().get(id)
+  })
   const [status, setStatus] = createSignal<Resolution<T>>()
 
   createEffect(
     on([sessionID, sessions] as const, ([id, store]) => {
+      if (!id) return
       let stale = false
       onCleanup(() => {
         stale = true
@@ -60,10 +65,11 @@ export function createSessionResolution<T>(
 
   return createMemo(() => {
     const id = sessionID()
+    if (!id) return
     const value = cached()
     if (value) return value
     const state = status()
-    if (state?.id !== id || state.store !== sessions()) return undefined
+    if (!state || 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,7 +84,6 @@ 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[] }
 }
@@ -196,13 +195,6 @@ 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

@@ -0,0 +1,36 @@
+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,11 +1,14 @@
-import { createEffect, createMemo, createSignal, on, Show, type Accessor } from "solid-js"
+import { createEffect, createMemo, createSignal, For, 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"
@@ -15,7 +18,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 } from "@opencode-ai/session-ui/timeline/projection"
+import { Timeline, TimelineRow } 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"
@@ -24,6 +27,98 @@ 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>
+  )
+}
+
+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"
@@ -94,6 +189,7 @@ function SessionSummaryPanel(props: {
   moveDismissed: boolean
   onMoveDismiss: () => void
   onReview: () => void
+  backgroundTasks: BackgroundTask[]
 }) {
   const language = useLanguage()
   const location = () => {
@@ -168,6 +264,9 @@ 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
@@ -186,6 +285,7 @@ function SessionSummaryPanel(props: {
 
 type MessageTimelineProps = {
   session: TimelineSessionSource
+  background: SessionBackground
   actions?: SessionUserActions
   scroll: { overflow: boolean; jump: boolean }
   onResumeScroll: () => void
@@ -350,6 +450,18 @@ 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
@@ -359,7 +471,23 @@ function MessageTimelineView(
         const content = Timeline.resolveContent(messageByID().get(row.group.ref.messageID), row.group.ref.partID)
         return content?.type === "tool" && ["edit", "write", "patch"].includes(content.name)
       }}
-      renderRow={(row, onSizeChange) => <rowRenderer.Row row={row} onSizeChange={onSizeChange} />}
+      renderRow={(row, onSizeChange) => (
+        <>
+          <rowRenderer.Row row={row} onSizeChange={onSizeChange} />
+          <Show when={backgroundHint(row())}>
+            <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 class={`flex h-10 items-start pt-4 ${turnPadding()}`}>
+                <BackgroundMoveHint />
+              </div>
+            </div>
+          </Show>
+        </>
+      )}
       header={
         <div
           data-session-title
@@ -485,6 +613,7 @@ function MessageTimelineView(
                                 setSummary(false)
                                 props.onReview()
                               }}
+                              backgroundTasks={props.background.tasks()}
                             />
                           </Popover.Content>
                         </Popover.Portal>

packages/app/src/settings/general/general.tsx

@@ -16,12 +16,9 @@ import {
   createPermissionScopeController,
   createShellOptions,
   createShellSettingsController,
-  createSoundSettingsController,
-  soundOptions,
   type AppearanceSettingsController,
   type PermissionScopeController,
   type ShellSettingsController,
-  type SoundSettingsController,
 } from "./controllers"
 import "@/settings/settings.css"
 import { ServerConnection } from "@/runtime/server/registry"
@@ -50,24 +47,6 @@ const fontSettings = {
     input: "setTerminal",
   },
 } as const
-const soundSettings = {
-  agent: {
-    action: "settings-sounds-agent",
-    title: "settings.general.sounds.agent.title",
-    description: "settings.general.sounds.agent.description",
-  },
-  permissions: {
-    action: "settings-sounds-permissions",
-    title: "settings.general.sounds.permissions.title",
-    description: "settings.general.sounds.permissions.description",
-  },
-  errors: {
-    action: "settings-sounds-errors",
-    title: "settings.general.sounds.errors.title",
-    description: "settings.general.sounds.errors.description",
-  },
-} as const
-
 const PermissionScopeSetting: Component<{ controller: PermissionScopeController }> = (props) => {
   const language = useLanguage()
   return (
@@ -228,43 +207,6 @@ const FontSetting: Component<{
   )
 }
 
-const SoundsSection: Component<{ controller: SoundSettingsController }> = (props) => {
-  const language = useLanguage()
-  return (
-    <div class="settings-section">
-      <h3 class="settings-section-title">{language.t("settings.general.section.sounds")}</h3>
-      <SettingsList>
-        <SoundSetting kind="agent" channel={props.controller.agent} />
-        <SoundSetting kind="permissions" channel={props.controller.permissions} />
-        <SoundSetting kind="errors" channel={props.controller.errors} />
-      </SettingsList>
-    </div>
-  )
-}
-
-const SoundSetting: Component<{
-  kind: "agent" | "permissions" | "errors"
-  channel: SoundSettingsController["agent"]
-}> = (props) => {
-  const language = useLanguage()
-  const config = () => soundSettings[props.kind]
-  return (
-    <SettingsRow title={language.t(config().title)} description={language.t(config().description)}>
-      <Select
-        data-action={config().action}
-        options={soundOptions}
-        current={props.channel.current()}
-        value={(option) => option.id}
-        label={(option) => language.t(option.label)}
-        onHighlight={props.channel.highlight}
-        onSelect={props.channel.select}
-        placement="bottom-end"
-        gutter={6}
-      />
-    </SettingsRow>
-  )
-}
-
 const LanguageSetting = () => {
   const language = useLanguage()
   const options = createMemo(() =>

packages/app/src/shell/status/body.tsx

@@ -1,6 +1,6 @@
 import { Switch } from "@opencode-ai/ui/switch"
 import { Tabs } from "@opencode-ai/ui/tabs"
-import { createMemo, createResource, For, type JSXElement, Show } from "solid-js"
+import { createMemo, createResource, For, Index, type JSXElement, Show } from "solid-js"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useMcpToggle } from "@/providers/connect/mcp"
 import { useWorkspaceLocation } from "@/workspaces/location"
@@ -27,14 +27,12 @@ export function StatusPopoverBody(props: { shown: boolean }) {
   const language = useLanguage()
 
   const toggleMcp = useMcpToggle(() => sdk().directory)
-  const mcp = () => data.location.mcp.server.list({ directory: sdk().directory }) ?? []
-  const mcpNames = createMemo(() =>
-    mcp()
-      .map((server) => server.name)
-      .sort((a, b) => a.localeCompare(b)),
+  const mcpServers = createMemo(() =>
+    (data.location.mcp.server.list({ directory: sdk().directory }) ?? []).toSorted((a, b) =>
+      a.name.localeCompare(b.name),
+    ),
   )
-  const mcpStatus = (name: string) => mcp().find((server) => server.name === name)?.status.status
-  const mcpConnected = createMemo(() => mcpNames().filter((name) => mcpStatus(name) === "connected").length)
+  const mcpConnected = createMemo(() => mcpServers().filter((server) => server.status.status === "connected").length)
   const [pluginList] = createResource(
     () => (props.shown ? sdk().directory : undefined),
     (directory) => serverSDK.api.plugin.list({ location: { directory } }).then((result) => result.data),
@@ -58,26 +56,25 @@ export function StatusPopoverBody(props: { shown: boolean }) {
             {language.t("status.popover.tab.mcp")}
           </Tabs.Trigger>
           {/* TODO: Restore LSP status when V2 exposes it. */}
-          <Show when={true}>
-            <Tabs.Trigger value="plugins" data-slot="tab" class="text-12-regular">
-              {pluginCount() > 0 ? `${pluginCount()} ` : ""}
-              {language.t("status.popover.tab.plugins")}
-            </Tabs.Trigger>
-          </Show>
+          <Tabs.Trigger value="plugins" data-slot="tab" class="text-12-regular">
+            {pluginCount() > 0 ? `${pluginCount()} ` : ""}
+            {language.t("status.popover.tab.plugins")}
+          </Tabs.Trigger>
         </Tabs.List>
 
         <Tabs.Content value="mcp">
           <div class="flex flex-col px-2 pb-2">
             <div class="flex flex-col p-3 bg-background-base rounded-sm min-h-14">
               <Show
-                when={mcpNames().length > 0}
+                when={mcpServers().length > 0}
                 fallback={
                   <div class="text-14-regular text-text-base text-center my-auto">{language.t("dialog.mcp.empty")}</div>
                 }
               >
-                <For each={mcpNames()}>
-                  {(name) => {
-                    const status = () => mcpStatus(name)
+                <Index each={mcpServers()}>
+                  {(server) => {
+                    const name = () => server().name
+                    const status = () => server().status.status
                     const enabled = () => status() === "connected"
                     return (
                       <button
@@ -85,9 +82,9 @@ export function StatusPopoverBody(props: { shown: boolean }) {
                         class="flex items-center gap-2 w-full min-h-8 pl-3 pr-2 py-1 rounded-md hover:bg-surface-raised-base-hover transition-colors text-left"
                         onClick={() => {
                           if (toggleMcp.isPending) return
-                          toggleMcp.mutate(name)
+                          toggleMcp.mutate(name())
                         }}
-                        disabled={toggleMcp.isPending && toggleMcp.variables === name}
+                        disabled={toggleMcp.isPending && toggleMcp.variables === name()}
                       >
                         <div
                           classList={{
@@ -100,7 +97,7 @@ export function StatusPopoverBody(props: { shown: boolean }) {
                         />
                         <span class="flex flex-col min-w-0 flex-1">
                           <span class="flex items-center gap-2 min-w-0">
-                            <span class="text-14-regular text-text-base truncate">{name}</span>
+                            <span class="text-14-regular text-text-base truncate">{name()}</span>
                           </span>
                           <Show when={status() === "needs_auth"}>
                             <span class="text-11-regular text-text-weaker truncate">
@@ -112,43 +109,41 @@ export function StatusPopoverBody(props: { shown: boolean }) {
                           <Switch
                             appearance="standard"
                             checked={enabled()}
-                            disabled={toggleMcp.isPending && toggleMcp.variables === name}
+                            disabled={toggleMcp.isPending && toggleMcp.variables === name()}
                             onChange={() => {
                               if (toggleMcp.isPending) return
-                              toggleMcp.mutate(name)
+                              toggleMcp.mutate(name())
                             }}
                           />
                         </div>
                       </button>
                     )
                   }}
-                </For>
+                </Index>
               </Show>
             </div>
           </div>
         </Tabs.Content>
 
-        <Show when={true}>
-          <Tabs.Content value="plugins">
-            <div class="flex flex-col px-2 pb-2">
-              <div class="flex flex-col p-3 bg-background-base rounded-sm min-h-14">
-                <Show
-                  when={plugins().length > 0}
-                  fallback={<div class="text-14-regular text-text-base text-center my-auto">{pluginEmpty()}</div>}
-                >
-                  <For each={plugins()}>
-                    {(plugin) => (
-                      <div class="flex items-center gap-2 w-full px-2 py-1">
-                        <div class="size-1.5 rounded-full shrink-0 bg-icon-success-base" />
-                        <span class="text-14-regular text-text-base truncate">{plugin}</span>
-                      </div>
-                    )}
-                  </For>
-                </Show>
-              </div>
+        <Tabs.Content value="plugins">
+          <div class="flex flex-col px-2 pb-2">
+            <div class="flex flex-col p-3 bg-background-base rounded-sm min-h-14">
+              <Show
+                when={plugins().length > 0}
+                fallback={<div class="text-14-regular text-text-base text-center my-auto">{pluginEmpty()}</div>}
+              >
+                <For each={plugins()}>
+                  {(plugin) => (
+                    <div class="flex items-center gap-2 w-full px-2 py-1">
+                      <div class="size-1.5 rounded-full shrink-0 bg-icon-success-base" />
+                      <span class="text-14-regular text-text-base truncate">{plugin}</span>
+                    </div>
+                  )}
+                </For>
+              </Show>
             </div>
-          </Tabs.Content>
-        </Show>
+          </div>
+        </Tabs.Content>
       </Tabs>
     </div>
   )

packages/cli/package.json

@@ -58,11 +58,11 @@
     "@lydell/node-pty-linux-x64": "1.2.0-beta.12",
     "@lydell/node-pty-win32-arm64": "1.2.0-beta.12",
     "@lydell/node-pty-win32-x64": "1.2.0-beta.12",
-    "@ff-labs/fff-bin-darwin-arm64": "0.10.1",
-    "@ff-labs/fff-bin-linux-arm64-gnu": "0.10.1",
-    "@ff-labs/fff-bin-linux-x64-gnu": "0.10.1",
-    "@ff-labs/fff-bin-win32-arm64": "0.10.1",
-    "@ff-labs/fff-bin-win32-x64": "0.10.1",
+    "@ff-labs/fff-bin-darwin-arm64": "0.10.5",
+    "@ff-labs/fff-bin-linux-arm64-gnu": "0.10.5",
+    "@ff-labs/fff-bin-linux-x64-gnu": "0.10.5",
+    "@ff-labs/fff-bin-win32-arm64": "0.10.5",
+    "@ff-labs/fff-bin-win32-x64": "0.10.5",
     "@yuuang/ffi-rs-darwin-arm64": "1.3.2",
     "@yuuang/ffi-rs-linux-arm64-gnu": "1.3.2",
     "@yuuang/ffi-rs-linux-x64-gnu": "1.3.2",

packages/cli/src/commands/handlers/auth/list.ts

@@ -3,7 +3,7 @@ import { Effect, Option } from "effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { createClient, loadIntegrations } from "./shared"
-import { errorMessage } from "../../../ui/prompt"
+import { errorMessage } from "../../../util/error"
 
 export default Runtime.handler(Commands.commands.auth.commands.list, (input) =>
   list(input).pipe(

packages/cli/src/commands/handlers/console/login.ts

@@ -6,6 +6,7 @@ import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { ServiceConfig } from "../../../services/service-config"
 import { createTimelineHost, type TimelineHost } from "../../../ui/timeline"
+import { errorMessage } from "../../../util/error"
 
 const integrationID = "opencode"
 const location = { directory: process.cwd() }
@@ -24,9 +25,9 @@ export default Runtime.handler(
     if (Exit.isSuccess(exit)) return
 
     const cancelled = timeline.signal.aborted
-    yield* request(() => timeline.failure(cancelled ? "Authorization cancelled" : errorMessage(exit.cause))).pipe(
-      Effect.ignore,
-    )
+    yield* request(() =>
+      timeline.failure(cancelled ? "Authorization cancelled" : errorMessage(Cause.squash(exit.cause))),
+    ).pipe(Effect.ignore)
     process.exitCode = cancelled ? 130 : 1
   }),
 )
@@ -107,12 +108,3 @@ function request<A>(task: (signal: AbortSignal) => Promise<A>) {
 function required<A>(value: A | null | undefined, message: string) {
   return value === null || value === undefined ? Effect.fail(new Error(message)) : Effect.succeed(value)
 }
-
-function errorMessage(cause: Cause.Cause<unknown>) {
-  const error = Cause.squash(cause)
-  if (error instanceof Error) return error.message
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
-    return error.message
-  }
-  return String(error)
-}

packages/cli/src/commands/handlers/debug/agents.ts

@@ -9,9 +9,7 @@ import { ServiceConfig } from "../../../services/service-config"
 export default Runtime.handler(
   Commands.commands.debug.commands.agents,
   Effect.fn("cli.debug.agents")(function* () {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const endpoint = found ?? (yield* Service.ensure(options))
+    const endpoint = yield* Service.ensure(yield* ServiceConfig.options())
     const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
     const response = yield* Effect.promise(() => client.agent.list({ location: { directory: process.cwd() } }))
     process.stdout.write(

packages/cli/src/commands/handlers/debug/config.ts

@@ -9,9 +9,7 @@ import { ServiceConfig } from "../../../services/service-config"
 export default Runtime.handler(
   Commands.commands.debug.commands.config,
   Effect.fn("cli.debug.config")(function* () {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const endpoint = found ?? (yield* Service.ensure(options))
+    const endpoint = yield* Service.ensure(yield* ServiceConfig.options())
     const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
     const entries = yield* Effect.promise(() => client.config.get({ location: { directory: process.cwd() } }))
     process.stdout.write(JSON.stringify(entries, null, 2) + EOL)

packages/cli/src/commands/handlers/export.ts

@@ -6,7 +6,7 @@ import { EOL } from "node:os"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
 import { ServerConnection } from "../../services/server-connection"
-import { errorMessage } from "../../ui/prompt"
+import { errorMessage } from "../../util/error"
 
 export default Runtime.handler(
   Commands.commands.export,

packages/cli/src/commands/handlers/mcp/auth.ts

@@ -17,9 +17,7 @@ const location = { directory: process.cwd() }
 export default Runtime.handler(
   Commands.commands.mcp.commands.auth,
   Effect.fn("cli.mcp.auth")(function* (input) {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const endpoint = found ?? (yield* Service.ensure(options))
+    const endpoint = yield* Service.ensure(yield* ServiceConfig.options())
     const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
 
     const integration = yield* resolveIntegration(client, input.name, location)

packages/cli/src/commands/handlers/mcp/list.ts

@@ -9,9 +9,7 @@ import { ServiceConfig } from "../../../services/service-config"
 export default Runtime.handler(
   Commands.commands.mcp.commands.list,
   Effect.fn("cli.mcp.list")(function* () {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const endpoint = found ?? (yield* Service.ensure(options))
+    const endpoint = yield* Service.ensure(yield* ServiceConfig.options())
     const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
     const response = yield* Effect.promise(() => client.mcp.list({ location: { directory: process.cwd() } }))
     const servers = response.data.toSorted((a, b) => a.name.localeCompare(b.name))

packages/cli/src/commands/handlers/mcp/logout.ts

@@ -12,9 +12,7 @@ const location = { directory: process.cwd() }
 export default Runtime.handler(
   Commands.commands.mcp.commands.logout,
   Effect.fn("cli.mcp.logout")(function* (input) {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const endpoint = found ?? (yield* Service.ensure(options))
+    const endpoint = yield* Service.ensure(yield* ServiceConfig.options())
     const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
 
     const integration = yield* resolveIntegration(client, input.name, location)

packages/cli/src/commands/handlers/plugin/list.ts

@@ -12,9 +12,7 @@ import { discoverTuiPlugins, tuiPluginDirectories } from "@opencode-ai/tui/plugi
 export default Runtime.handler(
   Commands.commands.plugin.commands.list,
   Effect.fn("cli.plugin.list")(function* (input) {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const endpoint = found ?? (yield* Service.ensure(options))
+    const endpoint = yield* Service.ensure(yield* ServiceConfig.options())
     const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
     const response = yield* Effect.promise(() => client.plugin.list({ location: { directory: process.cwd() } }))
     const config = yield* Config.Service

packages/cli/src/config/config.ts

@@ -31,7 +31,7 @@ export const layer = Layer.effect(
     const file = path.join(global.config, "cli.json")
 
     const readJson = Effect.fnUntraced(function* () {
-      const text = yield* fs.readFileString(file).pipe(Effect.catch(() => Effect.succeed(undefined)))
+      const text = yield* fs.readFileString(file).pipe(Effect.orElseSucceed(() => undefined))
       if (text === undefined) return undefined
       const errors: ParseError[] = []
       const value: any = parse(text, errors, { allowTrailingComma: true })
@@ -87,7 +87,7 @@ export const layer = Layer.effect(
           const next = produce(current, update)
           const edits = changes(current, next)
           if (!edits.length) return current
-          const text = yield* fs.readFileString(file).pipe(Effect.catch(() => Effect.succeed("{}")))
+          const text = yield* fs.readFileString(file).pipe(Effect.orElseSucceed(() => "{}"))
           const updated = edits.reduce(
             (text, edit) =>
               applyEdits(

packages/cli/src/config/migrate.ts

@@ -258,7 +258,7 @@ export function migrateV1(legacy: TuiConfigV1.Info | undefined, kv: Record<strin
 
 const readJson = Effect.fnUntraced(function* (target: string) {
   const fs = yield* FileSystem.FileSystem
-  const text = yield* fs.readFileString(target).pipe(Effect.catch(() => Effect.succeed(undefined)))
+  const text = yield* fs.readFileString(target).pipe(Effect.orElseSucceed(() => undefined))
   if (text === undefined) return undefined
   const errors: ParseError[] = []
   const value: any = parse(text, errors, { allowTrailingComma: true })

packages/cli/src/run/run.ts

@@ -10,6 +10,7 @@ import { toolInlineInfo } from "@opencode-ai/tui/mini/tool"
 import { runNonInteractivePrompt } from "./noninteractive"
 import { UI } from "./ui"
 import { Env } from "../env"
+import { errorMessage } from "../util/error"
 
 export type RunCommandInput = {
   server: ServerConnection.Resolved
@@ -243,13 +244,6 @@ async function renderToolError(part: SessionMessageAssistantTool, directory: str
   UI.println(UI.Style.TEXT_NORMAL + "✗", UI.Style.TEXT_NORMAL + `${info.title} failed`)
 }
 
-function errorMessage(error: unknown) {
-  if (error instanceof Error) return error.message
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string")
-    return error.message
-  return String(error)
-}
-
 /** @internal Used by the V1 command boundary before a Session exists. */
 export function reportRunError(input: Pick<RunCommandInput, "format">, message: string, sessionID?: string) {
   process.exitCode = 1

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

@@ -119,7 +119,7 @@ export const read = Effect.fn("cli.service-config.read")(function* () {
   if (legacyConfigFile) yield* migrateConfig(legacyConfigFile, configFile)
   return yield* fs.readFileString(configFile).pipe(
     Effect.flatMap(decodeInfo),
-    Effect.catch(() => Effect.succeed({} as Info)),
+    Effect.orElseSucceed(() => ({}) as Info),
   )
 })
 

packages/cli/src/services/updater.ts

@@ -44,7 +44,7 @@ export const layer = Layer.effect(
       const values = yield* Effect.forEach(["config.json", "opencode.json", "opencode.jsonc"], (name) =>
         fs.readFileString(path.join(global.config, name)).pipe(
           Effect.map(decodePolicy),
-          Effect.catch(() => Effect.succeed(undefined)),
+          Effect.orElseSucceed(() => undefined),
         ),
       )
       return values.findLast((value) => value !== undefined) ?? true
@@ -63,7 +63,7 @@ export const layer = Layer.effect(
             stdout: result.stdout.toString("utf8"),
             stderr: result.stderr.toString("utf8"),
           })),
-          Effect.catch(() => Effect.succeed({ code: 1, stdout: "", stderr: "" })),
+          Effect.orElseSucceed(() => ({ code: 1, stdout: "", stderr: "" })),
         )
     })
 

packages/cli/src/ui/prompt.ts

@@ -1,5 +1,6 @@
 import { cancel, isCancel, log, outro } from "@clack/prompts"
 import { Effect } from "effect"
+import { errorMessage } from "../util/error"
 
 const cancelled = Symbol("cancelled")
 
@@ -38,11 +39,3 @@ export function handlePromptErrors<A, E, R>(effect: Effect.Effect<A, E, R>) {
     ),
   )
 }
-
-export function errorMessage(error: unknown) {
-  if (error instanceof Error) return error.message
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
-    return error.message
-  }
-  return String(error)
-}

packages/cli/src/util/error.ts

@@ -0,0 +1,7 @@
+export function errorMessage(error: unknown) {
+  if (error instanceof Error) return error.message
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message
+  }
+  return String(error)
+}

packages/cli/test/debug-config.test.ts

@@ -33,12 +33,14 @@ describe("debug config command", () => {
       },
     ]
     let requested: URL | undefined
+    let healthProbes = 0
     const authorization: Array<string | null> = []
     const server = Bun.serve({
       port: 0,
       fetch(request) {
         const url = new URL(request.url)
         if (url.pathname === "/api/health") {
+          healthProbes += 1
           return Response.json({ healthy: true, version: OPENCODE_VERSION, pid: process.pid })
         }
         requested = url
@@ -60,6 +62,7 @@ describe("debug config command", () => {
       expect(requested?.pathname).toBe("/api/config")
       expect(requested?.searchParams.get("location[directory]")).toBe(project)
       expect(authorization).toEqual([`Basic ${btoa("opencode:secret")}`])
+      expect(healthProbes).toBe(1)
     } finally {
       server.stop(true)
       await fs.rm(root, { recursive: true, force: true })

packages/cli/test/import-boundaries.test.ts

@@ -35,7 +35,9 @@ describe("CLI frontend import boundaries", () => {
   test("keeps run and Mini on separate evaluation graphs", async () => {
     const run = await bundleInputs("packages/cli/src/commands/handlers/run.ts")
     expect(run).toContain("packages/cli/src/run/run.ts")
+    expect(run).toContain("packages/cli/src/util/error.ts")
     expect(run).toContain("packages/tui/src/mini/tool.ts")
+    expect(run).not.toContain("packages/cli/src/ui/prompt.ts")
     expect(run).not.toContain("packages/tui/src/mini/runtime.ts")
     expect(run).not.toContain("packages/tui/src/mini/runtime.lifecycle.ts")
     expect(run).not.toContain("packages/tui/src/mini/footer.ts")

packages/client/src/effect/service.ts

@@ -28,7 +28,10 @@ export type Info = import("../service.js").Info
 // Never spawns; escalation to ensure() is the caller's policy.
 /** Discover a healthy, compatible local service without starting one. */
 export const discover = Effect.fn("service.discover")(function* (options: DiscoverOptions = {}) {
-  return (yield* discoverLocal(options))?.endpoint
+  const found = (yield* registered(options.file)).service
+  if (found?.state !== "ready") return undefined
+  if (!matchesVersion(found.version, options)) return undefined
+  return found.endpoint
 })
 
 /** Recognize an authenticated compatible service bound to an expected URL, including while it starts or fails. */
@@ -42,13 +45,6 @@ export const incumbent = Effect.fn("service.incumbent")(function* (
   return { endpoint: found.endpoint, state: found.state }
 })
 
-const discoverLocal = Effect.fnUntraced(function* (options: DiscoverOptions) {
-  const found = (yield* registered(options.file)).service
-  if (found?.state !== "ready") return undefined
-  if (!matchesVersion(found.version, options)) return undefined
-  return found
-})
-
 // Idempotent ensure-running: reuses a healthy compatible server, replaces a
 // version-mismatched one, and otherwise spawns small contenders until a server
 // becomes discoverable. A contender is never killed merely for slow startup.

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

@@ -80,6 +80,8 @@ import type {
   SessionMessageOutput,
   SessionEnvironmentInput,
   SessionEnvironmentOutput,
+  SessionViewInput,
+  SessionViewOutput,
   MessageListInput,
   MessageListOutput,
   ModelListInput,
@@ -898,6 +900,18 @@ 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,6 +263,8 @@ 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
@@ -324,6 +326,16 @@ export type SessionRenamed = {
   data: { sessionID: string; title: string }
 }
 
+export type SessionViewed = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.viewed"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string; idle: number }
+}
+
 export type SessionDeleted = {
   id: string
   created: number
@@ -334,16 +346,6 @@ 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
@@ -1087,7 +1089,7 @@ export type PtyUpdated = {
   data: { info: Pty }
 }
 
-export type SessionStatus2 = {
+export type SessionStatusUpdated = {
   id: string
   created: number
   metadata?: { [x: string]: any }
@@ -1302,6 +1304,22 @@ 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
@@ -1664,7 +1682,8 @@ export type SessionInfo = {
   model?: ModelRef
   cost: MoneyUSD
   tokens: TokenUsageInfo
-  time: { created: number; updated: number; archived?: number }
+  outcome?: "succeeded" | "failed" | "interrupted"
+  time: { created: number; updated: number; idle?: number; viewed?: number; archived?: number }
   title?: string
   location: LocationRef
   subpath?: string
@@ -1949,6 +1968,7 @@ export type SessionEventDurable =
   | SessionModelSelected
   | SessionMoved
   | SessionRenamed
+  | SessionViewed
   | SessionDeleted
   | SessionForked
   | SessionInboxDelivered
@@ -2034,6 +2054,7 @@ export type V2Event =
   | SessionModelSelected
   | SessionMoved
   | SessionRenamed
+  | SessionViewed
   | SessionUsageUpdated
   | SessionDeleted
   | SessionForked
@@ -2096,7 +2117,7 @@ export type V2Event =
   | FormReplied
   | FormCancelled
   | WebsearchUpdated
-  | SessionStatus2
+  | SessionStatusUpdated
   | SessionIdle
   | TuiPromptAppend
   | TuiCommandExecute
@@ -2510,7 +2531,14 @@ export type SessionImportInput = {
         readonly reasoning: number
         readonly cache: { readonly read: number; readonly write: number }
       }
-      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
+      readonly outcome?: "succeeded" | "failed" | "interrupted"
+      readonly time: {
+        readonly created: number
+        readonly updated: number
+        readonly idle?: number
+        readonly viewed?: number
+        readonly archived?: number
+      }
       readonly title?: string
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
@@ -2778,7 +2806,14 @@ export type SessionImportInput = {
         readonly reasoning: number
         readonly cache: { readonly read: number; readonly write: number }
       }
-      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
+      readonly outcome?: "succeeded" | "failed" | "interrupted"
+      readonly time: {
+        readonly created: number
+        readonly updated: number
+        readonly idle?: number
+        readonly viewed?: number
+        readonly archived?: number
+      }
       readonly title?: string
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
@@ -3046,7 +3081,14 @@ export type SessionImportInput = {
         readonly reasoning: number
         readonly cache: { readonly read: number; readonly write: number }
       }
-      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
+      readonly outcome?: "succeeded" | "failed" | "interrupted"
+      readonly time: {
+        readonly created: number
+        readonly updated: number
+        readonly idle?: number
+        readonly viewed?: number
+        readonly archived?: number
+      }
       readonly title?: string
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
@@ -3980,6 +4022,13 @@ 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/promise/service.ts

@@ -22,14 +22,10 @@ export * from "../service.js"
 
 /** Discover a healthy, compatible local service without starting one. */
 export async function discover(options: DiscoverOptions = {}) {
-  return (await discoverLocal(options))?.endpoint
-}
-
-async function discoverLocal(options: DiscoverOptions) {
   const found = (await registered(options.file)).service
   if (found?.state !== "ready") return undefined
   if (!matchesVersion(found.version, options)) return undefined
-  return found
+  return found.endpoint
 }
 
 /** Ensure a healthy, compatible local service is running. */
@@ -144,10 +140,6 @@ type LocalService = {
   readonly legacy: boolean
 }
 
-async function probe(info: Info, allowLegacy = false): Promise<LocalService | undefined> {
-  return (await probeResult(info, allowLegacy)).service
-}
-
 async function probeResult(info: Info, allowLegacy = false, timeout = defaultEnsureTiming.requestTimeout) {
   const endpoint = {
     url: info.url,

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. 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.
+// 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.
 
 import type {
   AgentInfo,
@@ -13,6 +13,7 @@ import type {
   McpResource,
   McpServer,
   ModelInfo,
+  ModelRef,
   PermissionSavedInfo,
   PermissionRequest,
   PermissionReplyInput,
@@ -34,6 +35,7 @@ import type {
   WebSearchProvider,
 } from "../promise"
 import { Worktree } from "@opencode-ai/schema/worktree"
+import { SessionID } from "@opencode-ai/schema/session-id"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import { isPermissionNotFoundError, type SessionPromptInput } from "../promise"
 import { createStore, produce, reconcile } from "solid-js/store"
@@ -118,32 +120,46 @@ function locationQuery(ref?: LocationRef) {
 }
 
 function createSync() {
-  const state = new Map<string, true | Promise<void>>()
+  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
+  }
   return {
     run(key: string, load: () => Promise<void>) {
       const active = state.get(key)
       if (active === true) return Promise.resolve()
-      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
+      if (!active) return start(key, load)
+      if (!active.invalidated) return active.promise
+      return start(key, load, active.promise)
     },
     complete(key: string) {
       if (state.has(key)) return
       state.set(key, true)
     },
+    has(key: string) {
+      return state.has(key)
+    },
     invalidate(key?: string) {
       if (key) {
-        state.delete(key)
+        const active = state.get(key)
+        if (active === true) state.delete(key)
+        if (active !== undefined && active !== true) active.invalidated = true
         return
       }
-      state.clear()
+      state.forEach((active, current) => {
+        if (active === true) state.delete(current)
+        if (active !== true) active.invalidated = true
+      })
     },
   }
 }
@@ -226,6 +242,33 @@ export function createData(config: CreateDataInput) {
   // rollback — not on POST success, which typically precedes the echo.
   const outbox = new Set<string>()
 
+  // Session IDs of optimistic create admissions still awaiting acknowledgement
+  // (the session.created echo or the create response itself). A failed create
+  // only rolls back a session the server never acknowledged. Unlike
+  // `creating`, this clears on the echo rather than request settlement.
+  const sessionOutbox = new Set<string>()
+
+  // In-flight optimistic creates by session ID. prompt() gates its POST on
+  // this so a prompt sent to a still-creating session waits for the session
+  // to exist server-side instead of failing with "not found".
+  const creating = new Map<string, Promise<unknown>>()
+
+  // Per-session send chain: prompts must be admitted in submission order,
+  // and HTTP gives no ordering across concurrent POSTs. Each prompt waits
+  // for the previous prompt's POST (settled, so one failure does not block
+  // the next) before sending its own.
+  const sending = new Map<string, Promise<unknown>>()
+
+  // Register `promise` under `key` until it settles. A later registration
+  // replaces an earlier one; settlement only clears its own entry.
+  function track(map: Map<string, Promise<unknown>>, key: string, promise: Promise<unknown>) {
+    map.set(key, promise)
+    const settle = () => {
+      if (map.get(key) === promise) map.delete(key)
+    }
+    void promise.then(settle, settle)
+  }
+
   // Upsert an admitted inbox item into pending, input, and (for user and
   // synthetic items) the visible transcript. Used by the inbox.enqueued
   // handler and by optimistic prompt admission; the upsert is what reconciles
@@ -385,6 +428,7 @@ export function createData(config: CreateDataInput) {
     store.session.pending[sessionID]?.forEach((item) => outbox.delete(item.id))
     messageIndex.delete(sessionID)
     sync.invalidate(`session:${sessionID}`)
+    sync.invalidate(`session.family:${sessionID}`)
     sync.invalidate(`session.pending:${sessionID}`)
     sync.invalidate(`session.message:${sessionID}`)
     sync.invalidate(`session.permission:${sessionID}`)
@@ -434,6 +478,7 @@ export function createData(config: CreateDataInput) {
         void result.project.sync().catch((error) => console.error("Failed to preload projects", error))
         return
       case "session.created":
+        sessionOutbox.delete(event.data.sessionID)
         result.session.invalidate(event.data.sessionID)
         void result.session.sync(event.data.sessionID)
         // Band-aid: a newly created session starts empty, so live events can be its source of truth.
@@ -851,6 +896,16 @@ 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])
@@ -1110,46 +1165,117 @@ export function createData(config: CreateDataInput) {
           sync.invalidate(`session.pending:${sessionID}`)
         },
       },
+      // Optimistic session creation: admit a local record under a
+      // client-minted ID so a session view can mount immediately, then create
+      // the session on the server. The session.created echo re-syncs the
+      // record by ID, so the durable payload replaces the client's guess.
+      // Returns the ID synchronously along with the in-flight request:
+      // callers gate session-dependent sends on the request (prompt() gates
+      // itself on any in-flight create of its session automatically).
+      create(input: {
+        id?: string
+        title?: string
+        agent?: string
+        model?: ModelRef
+        location?: LocationRef
+        projectID?: string
+      }) {
+        const { projectID, ...payload } = input
+        const id = payload.id ?? SessionID.create()
+        const location = payload.location ?? defaultLocation()
+        const fresh = !store.session.info[id]
+        if (fresh) {
+          const now = Date.now()
+          sessionOutbox.add(id)
+          result.session.remember({
+            id,
+            projectID: projectID ?? store.location[locationKey(location)]?.info?.project.id ?? "",
+            agent: payload.agent,
+            model: payload.model,
+            cost: 0,
+            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+            time: { created: now, updated: now },
+            title: payload.title,
+            location,
+          })
+          // A mounted optimistic session must not fetch its empty collections
+          // before creation settles. The session.created echo re-syncs info.
+          sync.complete(`session.family:${id}`)
+          sync.complete(`session.pending:${id}`)
+          sync.complete(`session.message:${id}`)
+        }
+        // Wrapped so even a synchronous client failure reaches the rollback.
+        const request = Promise.resolve()
+          .then(() => api().session.create({ ...payload, id, location }))
+          .then((info) => {
+            sessionOutbox.delete(id)
+            result.session.remember(info)
+            return info
+          })
+          .catch((error) => {
+            // Roll back only a record this call admitted and neither the echo
+            // nor the response has acknowledged: anything else is server state.
+            if (fresh && sessionOutbox.delete(id)) removeSession(id)
+            throw error
+          })
+        if (fresh) track(creating, id, request)
+        return { id, request }
+      },
       // Optimistic prompt admission: render the prompt immediately under a
       // client-minted ID, send it, and let the durable inbox.enqueued echo
       // upsert that same ID with the server's payload. Server admission is
       // idempotent per ID, so retrying with the identical payload cannot
       // double-admit.
-      prompt(input: SessionPromptInput) {
-        const id = input.id ?? SessionMessage.ID.create()
+      prompt(input: SessionPromptInput & { gate?: Promise<unknown> }) {
+        const { gate, ...request } = input
+        const id = request.id ?? SessionMessage.ID.create()
         // A retry may reuse an ID that is already rendered — and possibly
         // already durable. Admit optimistically only for new IDs so a failed
         // retry cannot roll back acknowledged state.
         const fresh =
-          !messageIndex.get(input.sessionID)?.has(id) &&
-          !store.session.pending[input.sessionID]?.some((item) => item.id === id)
+          !messageIndex.get(request.sessionID)?.has(id) &&
+          !store.session.pending[request.sessionID]?.some((item) => item.id === id)
         if (fresh) {
           outbox.add(id)
           admitLocal({
             id,
-            sessionID: input.sessionID,
+            sessionID: request.sessionID,
             timeCreated: Date.now(),
             type: "user",
-            delivery: input.delivery ?? "steer",
+            delivery: request.delivery ?? "steer",
             // Files and skills stay off the optimistic row: their durable
             // forms are server-loaded (content, mime, resolution), so they
             // fill in when the echo upserts the row.
             payload: {
-              text: input.text,
-              agents: input.agents?.map((agent) => ({ ...agent })),
-              metadata: input.metadata,
+              text: request.text,
+              agents: request.agents?.map((agent) => ({ ...agent })),
+              metadata: request.metadata,
             },
           })
         }
         // Wrapped so even a synchronous client failure reaches the rollback.
-        return Promise.resolve()
-          .then(() => api().session.prompt({ ...input, id }))
-          .catch((error) => {
-            // Roll back only rows this call admitted and the echo has not
-            // acknowledged: anything else is server state.
-            if (fresh && outbox.delete(id)) retractLocal(input.sessionID, id)
-            throw error
-          })
+        // The POST additionally waits for the caller's gate, for any
+        // in-flight optimistic create of this session, and for the previous
+        // prompt's POST: the row renders now, the send happens once the
+        // session exists server-side and earlier prompts are admitted.
+        const previous = sending.get(request.sessionID)
+        const send = Promise.resolve()
+          .then(() => Promise.all([gate, creating.get(request.sessionID), previous]))
+          .then(() => api().session.prompt({ ...request, id }))
+        track(
+          sending,
+          request.sessionID,
+          send.then(
+            () => undefined,
+            () => undefined,
+          ),
+        )
+        return send.catch((error) => {
+          // Roll back only rows this call admitted and the echo has not
+          // acknowledged: anything else is server state.
+          if (fresh && outbox.delete(id)) retractLocal(request.sessionID, id)
+          throw error
+        })
       },
       sync(sessionID: string, options?: { children?: boolean }) {
         return sync.run(options?.children ? `session.family:${sessionID}` : `session:${sessionID}`, async () => {

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 Endpoint5_5Output = Session.Info")
-  expect(source).toContain("export type Endpoint19_0Output = OpenCodeEvent")
+  expect(source).toContain("export type SessionGetOutput = Session.Info")
+  expect(source).toContain("export type EventSubscribeOutput = OpenCodeEvent")
   expect(source).not.toContain("HttpApiClient.ForApi")
 })
 

packages/client/test/effect.test.ts

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

packages/client/test/promise.test.ts

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

packages/client/test/solid-data.test.ts

@@ -0,0 +1,81 @@
+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.succeed(undefined)
+      if (value.asynchronous && !allowAsync) return Effect.undefined
       return Effect.succeed({
         iterator: value,
         next: new GeneratorMethodReference(value, "next"),
         asynchronous: value.asynchronous,
       })
     }
-    if (!isRecord(value) || isRuntimeReference(value)) return Effect.succeed(undefined)
+    if (!isRecord(value) || isRuntimeReference(value)) return Effect.undefined
     const asyncMethod = allowAsync ? Reflect.get(value, AsyncIteratorSymbol) : undefined
     const method = asyncMethod ?? Reflect.get(value, IteratorSymbol)
-    if (method === undefined || method === null) return Effect.succeed(undefined)
+    if (method === undefined || method === null) return Effect.undefined
     const self = this
     return Effect.map(
       this.invokeCallable(this.requireIteratorMethod(method, "Iterator method", node), [], node),

packages/core/package.json

@@ -80,7 +80,6 @@
     "@types/bun": "catalog:",
     "@types/node": "catalog:",
     "@types/which": "3.0.4",
-    "@opencode-ai/shell-scan": "workspace:*",
     "@parcel/watcher-darwin-arm64": "2.5.1",
     "@parcel/watcher-darwin-x64": "2.5.1",
     "@parcel/watcher-linux-arm64-glibc": "2.5.1",
@@ -113,8 +112,8 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@lydell/node-pty": "catalog:",
     "@modelcontextprotocol/sdk": "1.29.0",
-    "@ff-labs/fff-bun": "0.10.1",
-    "@ff-labs/fff-node": "0.10.1",
+    "@ff-labs/fff-bun": "0.10.5",
+    "@ff-labs/fff-node": "0.10.5",
     "@opencode-ai/codemode": "workspace:*",
     "@opencode-ai/ai": "workspace:*",
     "@opencode-ai/schema": "workspace:*",

packages/core/schema.json

@@ -1,8 +1,8 @@
 {
   "version": "7",
   "dialect": "sqlite",
-  "id": "dcde8e6b-4bf4-4f6b-b2be-4030c2c3e936",
-  "prevIds": ["5c1aa56b-c3ee-4283-9a84-c0bf626dc604"],
+  "id": "3fb67508-0196-4bae-b2bd-c08ece7583fd",
+  "prevIds": ["dcde8e6b-4bf4-4f6b-b2be-4030c2c3e936"],
   "ddl": [
     {
       "name": "account_state",
@@ -1350,6 +1350,36 @@
       "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/script/build.ts

@@ -20,16 +20,6 @@ const result = await Bun.build({
   format: "esm",
   packages: "external",
   external: ["#sqlite", "#pty", "#fff", "#photon-wasm", "#shell-parser-wasm", "#process-lock-ffi", "#v1-migration"],
-  plugins: [
-    {
-      name: "bundle-shell-scan",
-      setup(build) {
-        build.onResolve({ filter: /^@opencode-ai\/shell-scan$/ }, () => ({
-          path: path.resolve("../shell-scan/src/index.ts"),
-        }))
-      },
-    },
-  ],
   splitting: true,
   loader: {
     ".txt": "text",

packages/core/src/aisdk.ts

@@ -127,7 +127,7 @@ function prepareOptions(model: Info, pkg: string) {
       options.timeout !== undefined && options.timeout !== null && options.timeout !== false
         ? AbortSignal.timeout(options.timeout)
         : undefined,
-    ].filter((item): item is AbortSignal | AbortController => Boolean(item))
+    ].filter((item): item is AbortSignal | AbortController => item !== undefined && item !== null)
     const chunkAbortCtl = signals.find((item): item is AbortController => item instanceof AbortController)
     const abortSignals = signals.map((item) => (item instanceof AbortController ? item.signal : item))
     if (abortSignals.length === 1) opts.signal = abortSignals[0]
@@ -346,8 +346,7 @@ function gatewayProviderOptions(modelID: ID, settings: Readonly<Record<string, u
   const prefix = separator > 0 ? modelID.slice(0, separator) : undefined
   if (prefix)
     return { ...(gateway === undefined ? {} : { gateway }), [prefix === "amazon" ? "bedrock" : prefix]: model }
-  if (typeof gateway === "object" && gateway !== null && !Array.isArray(gateway))
-    return { gateway: { ...gateway, ...model } }
+  if (gateway !== undefined) return { gateway: { ...gateway, ...model } }
   return { gateway: model }
 }
 

packages/core/src/bus.ts

@@ -227,7 +227,7 @@ export function configured(options?: Options) {
           commit?: (seq: number) => Effect.Effect<void>,
         ) {
           return Effect.gen(function* () {
-            const durable = definition?.durable
+            const durable = definition.durable
             if (durable) {
               const aggregateID = (event.data as Record<string, unknown>)[durable.aggregate]
               if (typeof aggregateID !== "string") {
@@ -391,14 +391,14 @@ export function configured(options?: Options) {
           commit?: PublishOptions["commit"],
         ) {
           return Effect.gen(function* () {
-            if (!definition?.durable && commit)
+            if (!definition.durable && commit)
               return yield* Effect.die(
                 new InvalidDurableEventError({
                   type: event.type,
                   message: "Local commit hooks require a durable event",
                 }),
               )
-            if (definition?.durable) {
+            if (definition.durable) {
               const aggregateID = (event.data as Record<string, unknown>)[definition.durable.aggregate]
               if (typeof aggregateID !== "string")
                 return yield* commitDurableEvent(definition, event as Event.Payload, undefined, commit).pipe(
@@ -610,37 +610,35 @@ export function configured(options?: Options) {
         ) {
           return Effect.gen(function* () {
             const definition = Durable.get(event.type)
-            if (!definition?.durable) {
-              yield* Effect.die(
+            if (!definition?.durable)
+              return yield* Effect.die(
                 new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` }),
               )
-            } else {
-              yield* durableLocks.withLock(event.aggregateID)(
-                Effect.gen(function* () {
-                  const payload = {
-                    id: event.id,
-                    created: event.created ?? 0,
-                    type: definition.type,
-                    data: Schema.decodeUnknownSync(definition.data)(event.data),
-                  } as Event.Payload
-                  const committed = yield* commitDurableEvent(definition, payload, {
-                    seq: event.seq,
-                    aggregateID: event.aggregateID,
-                    ownerID: options?.ownerID,
-                    strictOwner: options?.strictOwner,
-                  })
-                  if (committed && options?.publish) {
-                    yield* notify(
-                      {
-                        ...payload,
-                        durable: envelope(committed.aggregateID, committed.seq, definition.durable.version),
-                      },
-                      true,
-                    )
-                  }
-                }),
-              )
-            }
+            yield* durableLocks.withLock(event.aggregateID)(
+              Effect.gen(function* () {
+                const payload = {
+                  id: event.id,
+                  created: event.created ?? 0,
+                  type: definition.type,
+                  data: Schema.decodeUnknownSync(definition.data)(event.data),
+                } as Event.Payload
+                const committed = yield* commitDurableEvent(definition, payload, {
+                  seq: event.seq,
+                  aggregateID: event.aggregateID,
+                  ownerID: options?.ownerID,
+                  strictOwner: options?.strictOwner,
+                })
+                if (committed && options?.publish) {
+                  yield* notify(
+                    {
+                      ...payload,
+                      durable: envelope(committed.aggregateID, committed.seq, definition.durable.version),
+                    },
+                    true,
+                  )
+                }
+              }),
+            )
           })
         }
 

packages/core/src/catalog.ts

@@ -134,7 +134,7 @@ const layer = Layer.effect(
         }
         return result
       },
-      finalize: Effect.fn("Catalog.finalize")(function* (catalog) {
+      finalize: Effect.fn("Catalog.finalize")(function* () {
         yield* bus.publish(Catalog.Event.Updated, {})
       }),
     })

packages/core/src/codemode/tool.ts

@@ -112,15 +112,15 @@ export const create = (
           files: collected,
           ...(result.ok ? {} : { error: true }),
         }
-        const content: Array<Content> = [{ type: "text", text: value.output }]
-        content.push(
+        const content: Array<Content> = [
+          { type: "text", text: value.output },
           ...value.files.map((file) => ({
             type: "file" as const,
             uri: `data:${file.mime};base64,${file.data}`,
             mime: file.mime,
             ...(file.name === undefined ? {} : { name: file.name }),
           })),
-        )
+        ]
         const metadata: Metadata = {
           toolCalls: value.toolCalls,
           ...(value.error ? { error: true } : {}),

packages/core/src/config.ts

@@ -17,6 +17,7 @@ import {
   Event,
 } from "@opencode-ai/schema/config"
 import { Integration } from "@opencode-ai/schema/integration"
+import { isRecord } from "@opencode-ai/ai/utils/record"
 import { Credential } from "./credential.js"
 import { Bus } from "./bus.js"
 import { Watcher } from "./filesystem/watcher.js"
@@ -29,9 +30,8 @@ import { ConfigNormalize } from "./config/normalize.js"
 import { WellKnown } from "./wellknown.js"
 
 export function latest<K extends keyof Info>(entries: readonly Entry[], key: K): Info[K] | undefined {
-  return entries
-    .filter((entry): entry is Document => entry.type === "document")
-    .findLast((entry) => entry.info[key] !== undefined)?.info[key]
+  return entries.findLast((entry): entry is Document => entry.type === "document" && entry.info[key] !== undefined)
+    ?.info[key]
 }
 
 export interface Interface {
@@ -156,6 +156,37 @@ export const layer = (options?: Options) =>
         return new Document({ type: "document", path: AbsolutePath.make(filepath), info })
       })
 
+      const loadWellknownEntry = Effect.fnUntraced(function* (entry: WellKnown.Entry) {
+        const auth = entry.manifest.auth
+        if (!auth) return []
+        const credential = (yield* credentials.list(entry.integrationID)).findLast(
+          (credential) => credential.value.type === "key",
+        )
+        if (!credential || credential.value.type !== "key") return []
+        const variables = { [auth.env]: credential.value.key }
+        const configs = yield* wellknown
+          .resolve(entry, variables)
+          .pipe(
+            Effect.catch(() =>
+              Effect.logWarning("failed to load wellknown config", { source: entry.origin }).pipe(
+                Effect.as([] as const),
+              ),
+            ),
+          )
+        return yield* Effect.forEach(configs, (config) =>
+          ConfigVariable.substitute({
+            type: "virtual",
+            source: entry.origin,
+            dir: entry.origin,
+            text: JSON.stringify(config),
+            env: variables,
+          }).pipe(
+            Effect.flatMap((text) => parseInfo(text, entry.origin)),
+            Effect.map((info) => (info ? new Document({ type: "document", info }) : undefined)),
+          ),
+        ).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)))
+      })
+
       const loadWellknown = Effect.fn("Config.loadWellknown")(function* () {
         const entries = yield* wellknown
           .entries()
@@ -164,38 +195,7 @@ export const layer = (options?: Options) =>
               Effect.logWarning("failed to discover wellknown config", { error }).pipe(Effect.as([] as const)),
             ),
           )
-        return yield* Effect.forEach(entries, (entry) =>
-          Effect.gen(function* () {
-            const auth = entry.manifest.auth
-            if (!auth) return []
-            const credential = (yield* credentials.list(entry.integrationID)).findLast(
-              (credential) => credential.value.type === "key",
-            )
-            if (!credential || credential.value.type !== "key") return []
-            const variables = { [auth.env]: credential.value.key }
-            const configs = yield* wellknown
-              .resolve(entry, variables)
-              .pipe(
-                Effect.catch(() =>
-                  Effect.logWarning("failed to load wellknown config", { source: entry.origin }).pipe(
-                    Effect.as([] as const),
-                  ),
-                ),
-              )
-            return yield* Effect.forEach(configs, (config) =>
-              ConfigVariable.substitute({
-                type: "virtual",
-                source: entry.origin,
-                dir: entry.origin,
-                text: JSON.stringify(config),
-                env: variables,
-              }).pipe(
-                Effect.flatMap((text) => parseInfo(text, entry.origin)),
-                Effect.map((info) => (info ? new Document({ type: "document", info }) : undefined)),
-              ),
-            ).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)))
-          }),
-        ).pipe(Effect.map((documents) => documents.flat()))
+        return yield* Effect.forEach(entries, loadWellknownEntry).pipe(Effect.map((documents) => documents.flat()))
       })
 
       const loadDirectory = Effect.fnUntraced(function* (directory: AbsolutePath) {
@@ -347,7 +347,7 @@ export const layer = (options?: Options) =>
         Stream.filterEffect((event) =>
           wellknown.entries().pipe(
             Effect.map((entries) => entries.some((entry) => entry.integrationID === event.data.integrationID)),
-            Effect.catch(() => Effect.succeed(false)),
+            Effect.orElseSucceed(() => false),
           ),
         ),
         Stream.runForEach(() =>
@@ -449,20 +449,11 @@ type Edit = { readonly path: (string | number)[]; readonly value: unknown }
 
 function changes(before: unknown, after: unknown, path: (string | number)[] = []): Edit[] {
   if (Object.is(before, after)) return []
-  if (
-    before !== null &&
-    after !== null &&
-    typeof before === "object" &&
-    typeof after === "object" &&
-    !Array.isArray(before) &&
-    !Array.isArray(after)
-  ) {
-    const previous = before as Record<string, unknown>
-    const next = after as Record<string, unknown>
-    return [...new Set([...Object.keys(previous), ...Object.keys(next)])].flatMap((key) => {
-      if (!(key in next)) return [{ path: [...path, key], value: undefined }]
-      if (!(key in previous)) return [{ path: [...path, key], value: next[key] }]
-      return changes(previous[key], next[key], [...path, key])
+  if (isRecord(before) && isRecord(after)) {
+    return [...new Set([...Object.keys(before), ...Object.keys(after)])].flatMap((key) => {
+      if (!(key in after)) return [{ path: [...path, key], value: undefined }]
+      if (!(key in before)) return [{ path: [...path, key], value: after[key] }]
+      return changes(before[key], after[key], [...path, key])
     })
   }
   return [{ path, value: after }]

packages/core/src/config/normalize.ts

@@ -793,7 +793,7 @@ function isPlainRecord(value: unknown): value is Record<string, unknown> {
 }
 
 function own(value: Record<string, unknown>, key: string) {
-  return Object.prototype.hasOwnProperty.call(value, key)
+  return Object.hasOwn(value, key)
 }
 
 function setOwn(value: Record<string, unknown>, key: string, item: unknown) {

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

@@ -52,22 +52,19 @@ export const Plugin = define({
     const config = yield* Config.Service
     const fs = yield* FSUtil.Service
     const global = yield* Global.Service
+    const loadEntry = Effect.fnUntraced(function* (entry: Entry) {
+      if (entry.type === "document") return [entry]
+      if (entry.type !== "directory") return []
+      const files = yield* discover(fs, entry.path)
+      return yield* Effect.forEach(files, (file) =>
+        fs.readFileStringSafe(file.filepath).pipe(
+          Effect.map((content) => (content ? decode(file, content) : undefined)),
+          Effect.orElseSucceed(() => undefined),
+        ),
+      ).pipe(Effect.map((documents) => documents.filter((document): document is Document => document !== undefined)))
+    })
     const load = Effect.fn("ConfigAgentPlugin.load")(function* () {
-      return yield* Effect.forEach(yield* config.entries(), (entry) => {
-        if (entry.type === "document") return Effect.succeed([entry])
-        if (entry.type !== "directory") return Effect.succeed([])
-        return Effect.gen(function* () {
-          const files = yield* discover(fs, entry.path)
-          return yield* Effect.forEach(files, (file) =>
-            fs.readFileStringSafe(file.filepath).pipe(
-              Effect.map((content) => (content ? decode(file, content) : undefined)),
-              Effect.catch(() => Effect.succeed(undefined)),
-            ),
-          ).pipe(
-            Effect.map((documents) => documents.filter((document): document is Document => document !== undefined)),
-          )
-        })
-      }).pipe(Effect.map((documents) => documents.flat()))
+      return yield* Effect.forEach(yield* config.entries(), loadEntry).pipe(Effect.map((documents) => documents.flat()))
     })
     const loaded = { documents: [] as Document[] }
     const reload = load().pipe(
@@ -160,8 +157,7 @@ function isPathAction(action: string): action is PathAction {
 }
 
 function expandHome(resource: string, home: string) {
-  if (resource === "~") return home
-  if (resource === "$HOME") return home
+  if (resource === "~" || resource === "$HOME") return home
   const relative = resource.startsWith("~/")
     ? resource.slice(2)
     : resource.startsWith("$HOME/") || resource.startsWith("$HOME\\")
@@ -180,7 +176,7 @@ function discover(fs: FSUtil.Interface, directory: string) {
       ),
   ).pipe(
     Effect.map((files) => files.flat()),
-    Effect.catch(() => Effect.succeed([])),
+    Effect.orElseSucceed(() => []),
   )
 }
 

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

@@ -17,16 +17,14 @@ export const Plugin = define({
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
     const fs = yield* FSUtil.Service
+    const loadEntry = Effect.fnUntraced(function* (entry: Entry) {
+      if (entry.type === "document") return [{ commands: entry.info.commands }]
+      if (entry.type !== "directory") return []
+      const commands = yield* loadDirectory(fs, entry.path)
+      return [{ commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) }]
+    })
     const load = Effect.fn("ConfigCommandPlugin.load")(function* () {
-      return yield* Effect.forEach(yield* config.entries(), (entry) => {
-        if (entry.type === "document") return Effect.succeed([{ commands: entry.info.commands }])
-        if (entry.type !== "directory") return Effect.succeed([])
-        return loadDirectory(fs, entry.path).pipe(
-          Effect.map((commands) => [
-            { commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) },
-          ]),
-        )
-      }).pipe(Effect.map((documents) => documents.flat()))
+      return yield* Effect.forEach(yield* config.entries(), loadEntry).pipe(Effect.map((documents) => documents.flat()))
     })
     const loaded = { documents: [] as { commands: Info["commands"] }[] }
     const reload = load().pipe(
@@ -88,11 +86,11 @@ function loadDirectory(fs: FSUtil.Interface, directory: string) {
   return Effect.gen(function* () {
     const files = yield* fs
       .scan("{command,commands}/**/*.md", { cwd: directory, absolute: true, dot: true, symlink: true })
-      .pipe(Effect.catch(() => Effect.succeed([] as string[])))
+      .pipe(Effect.orElseSucceed(() => [] as string[]))
     return yield* Effect.forEach(files.toSorted(), (filepath) =>
       fs.readFileStringSafe(filepath).pipe(
         Effect.map((content) => (content === undefined ? undefined : decode(directory, filepath, content))),
-        Effect.catch(() => Effect.succeed(undefined)),
+        Effect.orElseSucceed(() => undefined),
       ),
     ).pipe(
       Effect.map((commands) =>

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

@@ -1,35 +1,24 @@
 export * as ConfigCompactionPlugin from "./compaction.js"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config.js"
 import { SessionCompaction } from "../../session/compaction.js"
+import { ConfigEntryObserver } from "./entry-observer.js"
 
 export const Plugin = define({
   id: "opencode.config.compaction",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
     const compaction = yield* SessionCompaction.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(compaction.reload()),
-    )
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    loaded.entries = yield* config.entries()
+    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, compaction.reload())
     yield* compaction.transform((draft) => {
       for (const entry of loaded.entries) {
         if (entry.type !== "document" || !entry.info.compaction) continue
         draft.configure({
           ...(entry.info.compaction.auto === undefined ? {} : { auto: entry.info.compaction.auto }),
           ...(entry.info.compaction.buffer === undefined ? {} : { buffer: entry.info.compaction.buffer }),
-          ...(entry.info.compaction.keep?.tokens === undefined
-            ? {}
-            : { tokens: entry.info.compaction.keep.tokens }),
+          ...(entry.info.compaction.keep?.tokens === undefined ? {} : { tokens: entry.info.compaction.keep.tokens }),
         })
       }
     })

packages/core/src/config/plugin/entry-observer.ts

@@ -0,0 +1,25 @@
+export * as ConfigEntryObserver from "./entry-observer.js"
+
+import type { EventDomain } from "@opencode-ai/plugin/effect/event"
+import { Effect, Stream } from "effect"
+import { Config } from "../../config.js"
+
+export const observe = Effect.fnUntraced(function* (
+  config: Config.Interface,
+  event: EventDomain,
+  reload: Effect.Effect<void>,
+) {
+  const loaded = { entries: yield* config.entries() }
+  const refresh = config.entries().pipe(
+    Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
+    Effect.andThen(reload),
+  )
+  yield* event.subscribe().pipe(
+    Stream.filter((event) => event.type === "config.updated"),
+    Stream.runForEach(() => refresh),
+    Effect.forkScoped({ startImmediately: true }),
+  )
+  // Close the race between the first read and establishing the subscription.
+  loaded.entries = yield* config.entries()
+  return loaded
+})

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

@@ -5,11 +5,12 @@ import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
 import { Npm } from "@opencode-ai/util/npm"
 import { AppProcess } from "@opencode-ai/util/process"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config.js"
 import { Formatter } from "../../formatter.js"
 import { make, type Info } from "../../formatter/builtins.js"
 import { Location } from "../../location.js"
+import { ConfigEntryObserver } from "./entry-observer.js"
 
 export const Plugin = define({
   id: "opencode.config.formatter",
@@ -21,20 +22,7 @@ export const Plugin = define({
     const location = yield* Location.Service
     const npm = yield* Npm.Service
     const processes = yield* AppProcess.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(formatter.reload()),
-    )
-
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    // Refetch after subscribing so a config update between the first read and
-    // the live subscription cannot leave the transform on a stale snapshot.
-    loaded.entries = yield* config.entries()
+    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, formatter.reload())
 
     yield* formatter.transform((draft) => {
       const configured = Config.latest(loaded.entries, "formatter")

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

@@ -1,28 +1,17 @@
 export * as ConfigImagePlugin from "./image.js"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config.js"
 import { Image } from "../../image.js"
+import { ConfigEntryObserver } from "./entry-observer.js"
 
 export const Plugin = define({
   id: "opencode.config.image",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
     const image = yield* Image.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(image.reload()),
-    )
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    // Refetch after subscribing so a config update between the first read and
-    // the live subscription cannot leave the transform on a stale snapshot.
-    loaded.entries = yield* config.entries()
+    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, image.reload())
     yield* image.transform((draft) => {
       for (const entry of loaded.entries) {
         if (entry.type !== "document") continue

packages/core/src/config/plugin/location-watcher.ts

@@ -1,26 +1,17 @@
 export * as ConfigLocationWatcherPlugin from "./location-watcher.js"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config.js"
 import { LocationWatcherPolicy } from "../../filesystem/location-watcher-policy.js"
+import { ConfigEntryObserver } from "./entry-observer.js"
 
 export const Plugin = define({
   id: "opencode.config.location-watcher",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
     const policy = yield* LocationWatcherPolicy.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(policy.reload()),
-    )
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    loaded.entries = yield* config.entries()
+    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, policy.reload())
     yield* policy.transform((draft) => {
       for (const entry of loaded.entries) {
         if (entry.type !== "document" || !entry.info.watcher?.ignore) continue

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

@@ -2,15 +2,16 @@ export * as ConfigPolicyPlugin from "./policy.js"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
 import { Document } from "@opencode-ai/schema/config"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config.js"
 import { Wildcard } from "../../util/wildcard.js"
+import { ConfigEntryObserver } from "./entry-observer.js"
 
 export const Plugin = define({
   id: "opencode.config.policy",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
-    const loaded = { entries: yield* config.entries() }
+    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, ctx.catalog.reload())
     yield* ctx.catalog.transform((catalog) => {
       // User-global policy takes priority over policy authored by a repository.
       const policies = loaded.entries
@@ -22,15 +23,5 @@ export const Plugin = define({
         if (policy?.effect === "deny") catalog.provider.remove(record.provider.id)
       }
     })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() =>
-        config.entries().pipe(
-          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-          Effect.andThen(ctx.catalog.reload()),
-        ),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
-    )
   }),
 })

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

@@ -3,15 +3,20 @@ export * as ConfigProviderPlugin from "./provider.js"
 import { define } from "@opencode-ai/plugin/effect/plugin"
 import { Document, type Entry } from "@opencode-ai/schema/config"
 import { Money } from "@opencode-ai/schema/money"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config.js"
 import { Provider } from "../../provider.js"
+import { ConfigEntryObserver } from "./entry-observer.js"
 
 export const Plugin = define({
   id: "opencode.config.provider",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
-    const loaded = { entries: yield* config.entries() }
+    const loaded = yield* ConfigEntryObserver.observe(
+      config,
+      ctx.event,
+      ctx.integration.reload().pipe(Effect.andThen(ctx.catalog.reload())),
+    )
     yield* ctx.integration.transform((integrations) => {
       for (const [id, provider] of configuredProviders(loaded.entries)) {
         const integrationID = id
@@ -97,17 +102,6 @@ export const Plugin = define({
         }
       }
     })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() =>
-        config.entries().pipe(
-          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-          Effect.andThen(ctx.integration.reload()),
-          Effect.andThen(ctx.catalog.reload()),
-        ),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
-    )
   }),
 })
 

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

@@ -4,12 +4,13 @@ import { define } from "@opencode-ai/plugin/effect/plugin"
 import { Document } from "@opencode-ai/schema/config"
 import { ConfigReference } from "@opencode-ai/schema/config/reference"
 import path from "path"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config.js"
 import { Reference } from "../../reference.js"
 import { AbsolutePath } from "../../schema.js"
 import { Global } from "@opencode-ai/util/global"
 import { Location } from "../../location.js"
+import { ConfigEntryObserver } from "./entry-observer.js"
 
 export const Plugin = define({
   id: "opencode.config.reference",
@@ -17,7 +18,7 @@ export const Plugin = define({
     const config = yield* Config.Service
     const location = yield* Location.Service
     const global = yield* Global.Service
-    const loaded = { entries: yield* config.entries() }
+    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, ctx.reference.reload())
     yield* ctx.reference.transform((draft) => {
       const entries = new Map<string, Reference.Source>()
       for (const doc of loaded.entries.filter((entry): entry is Document => entry.type === "document")) {
@@ -49,16 +50,6 @@ export const Plugin = define({
       }
       for (const [name, source] of entries) draft.add(name, source)
     })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() =>
-        config.entries().pipe(
-          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-          Effect.andThen(ctx.reference.reload()),
-        ),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
-    )
   }),
 })
 

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

@@ -1,26 +1,17 @@
 export * as ConfigShellPlugin from "./shell.js"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config.js"
 import { ShellSelect } from "../../shell/select.js"
+import { ConfigEntryObserver } from "./entry-observer.js"
 
 export const Plugin = define({
   id: "opencode.config.shell",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
     const shell = yield* ShellSelect.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(shell.reload()),
-    )
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    loaded.entries = yield* config.entries()
+    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, shell.reload())
     yield* shell.transform((draft) => {
       const configured = Config.latest(loaded.entries, "shell")
       if (configured) draft.configure(configured)

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.succeed(undefined)
+      if (parent === target) return Effect.undefined
       return fs.isDir(parent).pipe(Effect.flatMap((exists) => (exists ? Effect.succeed(target) : firstMissing(parent))))
     }
 
@@ -54,7 +54,7 @@ export const Plugin = define({
       "ConfigSkillPlugin.watchDirectory",
     )(function* (directory: string) {
       const target = path.resolve(directory)
-      const resolved = yield* fs.realPath(directory).pipe(Effect.catch(() => Effect.succeed(undefined)))
+      const resolved = yield* fs.realPath(directory).pipe(Effect.orElseSucceed(() => undefined))
       if (resolved) {
         yield* watch(resolved, "directory")
         if (resolved !== target) yield* watch(target, "file")
@@ -65,7 +65,7 @@ export const Plugin = define({
       if (
         yield* fs.realPath(directory).pipe(
           Effect.as(true),
-          Effect.catch(() => Effect.succeed(false)),
+          Effect.orElseSucceed(() => false),
         )
       ) {
         if (missing) yield* FiberMap.remove(watches, `file:${path.resolve(missing)}`)
@@ -124,11 +124,11 @@ export const Plugin = define({
       for (const directory of directories) {
         const files = yield* fs
           .scan("{*.md,**/SKILL.md}", { cwd: directory, absolute: true, include: "file", symlink: true, dot: true })
-          .pipe(Effect.catch(() => Effect.succeed([] as string[])))
+          .pipe(Effect.orElseSucceed(() => [] as string[]))
         for (const filepath of files.toSorted()) {
-          const resolved = yield* fs.realPath(filepath).pipe(Effect.catch(() => Effect.succeed(filepath)))
+          const resolved = yield* fs.realPath(filepath).pipe(Effect.orElseSucceed(() => filepath))
           if (!roots.some((root) => FSUtil.contains(root, resolved))) yield* watch(path.dirname(resolved), "directory")
-          const content = yield* fs.readFileStringSafe(filepath).pipe(Effect.catch(() => Effect.succeed(undefined)))
+          const content = yield* fs.readFileStringSafe(filepath).pipe(Effect.orElseSucceed(() => undefined))
           if (!content) continue
           const parsed = SkillFile.parse(directory, filepath, content)
           if (parsed._tag === "Skipped") {

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

@@ -1,26 +1,17 @@
 export * as ConfigSnapshotPlugin from "./snapshot.js"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config.js"
 import { Snapshot } from "../../snapshot.js"
+import { ConfigEntryObserver } from "./entry-observer.js"
 
 export const Plugin = define({
   id: "opencode.config.snapshot",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
     const snapshot = yield* Snapshot.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(snapshot.reload()),
-    )
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    loaded.entries = yield* config.entries()
+    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, snapshot.reload())
     yield* snapshot.transform((draft) => {
       const configured = Config.latest(loaded.entries, "snapshots")
       if (configured === undefined) return

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

@@ -148,7 +148,7 @@ const scan = Effect.fn("ConfigPluginSource.scan")(function* (
         ...operation,
         mtime: Option.getOrElse(info.mtime, () => new Date(0)).getTime(),
       })),
-      Effect.catch(() => Effect.succeed(operation)),
+      Effect.orElseSucceed(() => operation),
     )
   })
 })

packages/core/src/config/plugin/tool-output.ts

@@ -1,26 +1,17 @@
 export * as ConfigToolOutputPlugin from "./tool-output.js"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config.js"
 import { ToolOutput } from "../../tool-output.js"
+import { ConfigEntryObserver } from "./entry-observer.js"
 
 export const Plugin = define({
   id: "opencode.config.tool-output",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
     const output = yield* ToolOutput.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(output.reload()),
-    )
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    loaded.entries = yield* config.entries()
+    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, output.reload())
     yield* output.transform((draft) => {
       const configured = Config.latest(loaded.entries, "tool_output")
       if (!configured) return

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

@@ -1,28 +1,19 @@
 export * as ConfigWebSearchPlugin from "./websearch.js"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
+import { Effect } from "effect"
 import { Config } from "../../config.js"
+import { ConfigEntryObserver } from "./entry-observer.js"
 
 export const Plugin = define({
   id: "opencode.config.websearch",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
-    const loaded = { entries: yield* config.entries() }
+    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, ctx.websearch.reload())
     yield* ctx.websearch.transform((websearch) => {
       const selection = Config.latest(loaded.entries, "websearch")
       if (selection === false) websearch.default.set(false)
       if (selection) websearch.default.set(selection.provider)
     })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() =>
-        config.entries().pipe(
-          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-          Effect.andThen(ctx.websearch.reload()),
-        ),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
-    )
   }),
 })

packages/core/src/config/variable.ts

@@ -37,11 +37,10 @@ const substituteFiles = Effect.fnUntraced(function* (input: SubstituteInput, tex
   const fs = yield* FSUtil.Service
   const configDir = input.type === "path" ? path.dirname(input.path) : input.dir
   const configSource = input.type === "path" ? input.path : input.source
-  const matches = Array.from(text.matchAll(/\{file:[^}]+\}/g))
   let out = ""
   let cursor = 0
 
-  for (const match of matches) {
+  for (const match of text.matchAll(/\{file:[^}]+\}/g)) {
     const token = match[0]
     const index = match.index
     out += text.slice(cursor, index)
@@ -54,7 +53,7 @@ const substituteFiles = Effect.fnUntraced(function* (input: SubstituteInput, tex
       continue
     }
 
-    const filePath = token.replace(/^\{file:/, "").replace(/\}$/, "")
+    const filePath = token.slice("{file:".length, -1)
     const expandedPath = filePath.startsWith("~/") ? path.join(os.homedir(), filePath.slice(2)) : filePath
     const resolvedPath = path.isAbsolute(expandedPath) ? expandedPath : path.resolve(configDir, expandedPath)
     const fileContent = yield* fs.readFileString(resolvedPath).pipe(