chore: update nix node_modules hashes

packages/ai/src/protocols/anthropic-messages.ts

@@ -205,11 +205,8 @@ const AnthropicTool = Schema.Struct({
 type AnthropicTool = Schema.Schema.Type<typeof AnthropicTool>
 
 const AnthropicToolChoice = Schema.Union([
-  Schema.Struct({
-    type: Schema.Literals(["auto", "any", "none"]),
-    disable_parallel_tool_use: Schema.optional(Schema.Boolean),
-  }),
-  Schema.Struct({ type: Schema.tag("tool"), name: Schema.String, disable_parallel_tool_use: Schema.optional(Schema.Boolean) }),
+  Schema.Struct({ type: Schema.Literals(["auto", "any", "none"]) }),
+  Schema.Struct({ type: Schema.tag("tool"), name: Schema.String }),
 ])
 
 const AnthropicThinking = Schema.Union([
@@ -373,26 +370,10 @@ const lowerTool = (breakpoints: Cache.Breakpoints, tool: ToolDefinition, inputSc
 
 const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
   ProviderShared.matchToolChoice("Anthropic Messages", toolChoice, {
-    auto: () => ({
-      type: "auto" as const,
-      ...(toolChoice.disableParallelToolUse === undefined
-        ? {}
-        : { disable_parallel_tool_use: toolChoice.disableParallelToolUse }),
-    }),
+    auto: () => ({ type: "auto" as const }),
     none: () => ({ type: "none" as const }),
-    required: () => ({
-      type: "any" as const,
-      ...(toolChoice.disableParallelToolUse === undefined
-        ? {}
-        : { disable_parallel_tool_use: toolChoice.disableParallelToolUse }),
-    }),
-    tool: (name) => ({
-      type: "tool" as const,
-      name,
-      ...(toolChoice.disableParallelToolUse === undefined
-        ? {}
-        : { disable_parallel_tool_use: toolChoice.disableParallelToolUse }),
-    }),
+    required: () => ({ type: "any" as const }),
+    tool: (name) => ({ type: "tool" as const, name }),
   })
 
 const scrubToolCallID = (id: string) => id.replace(/[^a-zA-Z0-9_-]/g, "_")
@@ -1083,10 +1064,7 @@ export const route = Route.make({
   provider: "anthropic",
   providerMetadataKey: "anthropic",
   protocol,
-  endpoint: Endpoint.path(
-    (input) => (input.request.model.provider === "anthropic" ? `${PATH}?beta=true` : PATH),
-    { baseURL: DEFAULT_BASE_URL },
-  ),
+  endpoint: Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL }),
   auth: Auth.none,
   framing,
   headers: () => ({ "anthropic-version": "2023-06-01" }),

packages/ai/src/protocols/open-responses.ts

@@ -759,7 +759,7 @@ const TERMINAL_TYPES = new Set(["error", "response.completed", "response.incompl
 export const terminal = (event: Event) => TERMINAL_TYPES.has(event.type)
 
 const onOutputTextDelta = (state: ParserState, event: Event, id: string): StepResult => {
-  if (!event.delta || !state.messageItems.has(id)) return [state, NO_EVENTS]
+  if (!event.delta) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
   const phase = state.messagePhases[id]
   const metadata = providerMetadata(state, { itemId: id, ...(phase === undefined ? {} : { phase }) })
@@ -777,9 +777,10 @@ const onOutputTextDone = (state: ParserState, event: Event, id: string): StepRes
 }
 
 export const onReasoningDelta = (state: ParserState, event: Event, itemID: string): StepResult => {
-  if (!event.delta || !state.reasoningItems[itemID]) return [state, NO_EVENTS]
+  if (!event.delta) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
-  const id = `${itemID}:${event.summary_index ?? 0}`
+  const id =
+    event.summary_index !== undefined || state.reasoningItems[itemID] ? `${itemID}:${event.summary_index ?? 0}` : itemID
   return [
     {
       ...state,
@@ -857,9 +858,27 @@ const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
 
 const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResult => {
   if (!event.item_id || event.summary_index === undefined) return [state, NO_EVENTS]
-  const item = state.reasoningItems[event.item_id]
-  if (!item) return [state, NO_EVENTS]
-  if (event.summary_index === 0) return [state, NO_EVENTS]
+  const item = state.reasoningItems[event.item_id] ?? { encryptedContent: undefined, summaryParts: {} }
+  if (event.summary_index === 0) {
+    if (state.reasoningItems[event.item_id]) return [state, NO_EVENTS]
+    const events: LLMEvent[] = []
+    return [
+      {
+        ...state,
+        lifecycle: Lifecycle.reasoningStart(
+          state.lifecycle,
+          events,
+          `${event.item_id}:0`,
+          providerMetadata(state, { itemId: event.item_id, reasoningEncryptedContent: null }),
+        ),
+        reasoningItems: {
+          ...state.reasoningItems,
+          [event.item_id]: { ...item, summaryParts: { 0: "active" } },
+        },
+      },
+      events,
+    ]
+  }
 
   const events: LLMEvent[] = []
   const closed = Object.entries(item.summaryParts)
@@ -938,7 +957,7 @@ const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgu
   state: ParserState,
   event: Event,
 ) {
-  if (!event.item_id || !event.delta || !state.tools[event.item_id]) return [state, NO_EVENTS] satisfies StepResult
+  if (!event.item_id || !event.delta) return [state, NO_EVENTS] satisfies StepResult
   const result = ToolStream.appendExisting(
     state.id,
     state.tools,
@@ -1146,10 +1165,7 @@ export const step = (state: ParserState, event: Event) => {
       return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
     return Effect.succeed(onOutputItemAdded(state, event))
   }
-  if (event.type === "response.function_call_arguments.delta")
-    return event.item_id
-      ? onFunctionCallArgumentsDelta(state, event)
-      : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
+  if (event.type === "response.function_call_arguments.delta") return onFunctionCallArgumentsDelta(state, event)
   if (event.type === "response.output_item.done") {
     if (event.item?.type === "message" && !event.item.id)
       return ProviderShared.eventError(state.id, `${event.type} message is missing id`)

packages/ai/src/schema/messages.ts

@@ -255,7 +255,6 @@ export namespace ToolDefinition {
 export class ToolChoice extends Schema.Class<ToolChoice>("LLM.ToolChoice")({
   type: Schema.Literals(["auto", "none", "required", "tool"]),
   name: Schema.optional(Schema.String),
-  disableParallelToolUse: Schema.optional(Schema.Boolean),
 }) {}
 
 export namespace ToolChoice {

packages/ai/test/provider/google-vertex.test.ts

@@ -237,7 +237,6 @@ describe("Google Vertex providers", () => {
               })
               return input.respond(
                 sseEvents(
-                  { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
                   { type: "response.output_text.delta", item_id: "msg_1", delta: "Hello." },
                   { type: "response.completed", response: { id: "resp_1" } },
                 ),

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

@@ -321,10 +321,6 @@ describe("OpenAI Responses route", () => {
               }),
             messages: Stream.fromArray([
               ProviderShared.encodeJson({ type: "response.created", response: { id: "resp_ws" } }),
-              ProviderShared.encodeJson({
-                type: "response.output_item.added",
-                item: { type: "message", id: "msg_1" },
-              }),
               ProviderShared.encodeJson({ type: "response.output_text.delta", item_id: "msg_1", delta: "Hi" }),
               ProviderShared.encodeJson({ type: "response.completed", response: { id: "resp_ws" } }),
             ]),
@@ -1669,7 +1665,6 @@ describe("OpenAI Responses route", () => {
   it.effect("parses text and usage stream fixtures", () =>
     Effect.gen(function* () {
       const body = sseEvents(
-        { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
         { type: "response.output_text.delta", item_id: "msg_1", delta: "Hello" },
         { type: "response.output_text.delta", item_id: "msg_1", delta: "!" },
         {
@@ -1931,67 +1926,6 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("ignores deltas without a matching output item", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "response.output_text.delta", item_id: "msg_missing", delta: "orphaned text" },
-              { type: "response.refusal.delta", item_id: "refusal_missing", delta: "orphaned refusal" },
-              {
-                type: "response.reasoning_summary_text.delta",
-                item_id: "rs_missing",
-                summary_index: 0,
-                delta: "orphaned reasoning",
-              },
-              {
-                type: "response.reasoning_summary_part.added",
-                item_id: "rs_still_missing",
-                summary_index: 0,
-              },
-              {
-                type: "response.reasoning_summary_text.delta",
-                item_id: "rs_still_missing",
-                summary_index: 0,
-                delta: "still orphaned reasoning",
-              },
-              {
-                type: "response.function_call_arguments.delta",
-                item_id: "fc_missing",
-                delta: '{"orphaned":true}',
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("")
-      expect(response.message.content).toEqual([])
-      expect(response.events.some(LLMEvent.is.toolCall)).toBeFalse()
-    }),
-  )
-
-  it.effect("rejects function argument deltas without the spec-required item id", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "response.function_call_arguments.delta", delta: "{}" },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(error.message).toContain("response.function_call_arguments.delta is missing item_id")
-    }),
-  )
-
   it.effect("rejects reasoning events without the spec-required item id", () =>
     Effect.gen(function* () {
       const events = [
@@ -2047,10 +1981,8 @@ describe("OpenAI Responses route", () => {
         Effect.provide(
           fixedResponse(
             sseEvents(
-              { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
               { type: "response.output_text.delta", item_id: "msg_1", delta: "First" },
-              { type: "response.output_item.done", item: { type: "message", id: "msg_1" } },
-              { type: "response.output_item.added", item: { type: "message", id: "msg_2" } },
+              { type: "response.output_text.done", item_id: "msg_1" },
               { type: "response.output_text.delta", item_id: "msg_2", delta: "Second" },
               { type: "response.output_item.done", item: { type: "message", id: "msg_2" } },
               { type: "response.completed", response: { id: "resp_1" } },
@@ -2061,10 +1993,10 @@ describe("OpenAI Responses route", () => {
 
       expect(response.events.filter((event) => event.type.startsWith("text-"))).toEqual([
         { type: "text-start", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
-        { type: "text-delta", id: "msg_1", text: "First", providerMetadata: undefined },
-        { type: "text-end", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
+        { type: "text-delta", id: "msg_1", text: "First" },
+        { type: "text-end", id: "msg_1", providerMetadata: undefined },
         { type: "text-start", id: "msg_2", providerMetadata: { openai: { itemId: "msg_2" } } },
-        { type: "text-delta", id: "msg_2", text: "Second", providerMetadata: undefined },
+        { type: "text-delta", id: "msg_2", text: "Second" },
         { type: "text-end", id: "msg_2", providerMetadata: { openai: { itemId: "msg_2" } } },
       ])
     }),
@@ -2073,9 +2005,7 @@ describe("OpenAI Responses route", () => {
   it.effect("parses reasoning summary stream fixtures", () =>
     Effect.gen(function* () {
       const body = sseEvents(
-        { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1" } },
         { type: "response.reasoning_summary_text.delta", item_id: "rs_1", delta: "thinking" },
-        { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
         { type: "response.output_text.delta", item_id: "msg_1", delta: "Hello" },
         { type: "response.reasoning_summary_text.done", item_id: "rs_1" },
         { type: "response.completed", response: { id: "resp_1" } },
@@ -2087,22 +2017,18 @@ describe("OpenAI Responses route", () => {
       expect(response.text).toBe("Hello")
       expect(response.events).toMatchObject([
         { type: "step-start", index: 0 },
-        { type: "reasoning-start", id: "rs_1:0" },
-        { type: "reasoning-delta", id: "rs_1:0", text: "thinking" },
+        { type: "reasoning-start", id: "rs_1" },
+        { type: "reasoning-delta", id: "rs_1", text: "thinking" },
         { type: "text-start", id: "msg_1" },
         { type: "text-delta", id: "msg_1", text: "Hello" },
-        { type: "reasoning-end", id: "rs_1:0" },
+        { type: "reasoning-end", id: "rs_1" },
         { type: "text-end", id: "msg_1" },
         { type: "step-finish", index: 0, reason: { normalized: "stop", raw: undefined } },
         { type: "finish", reason: { normalized: "stop", raw: undefined } },
       ])
       expect(response.events.filter((event) => event.type === "finish")).toHaveLength(1)
       expect(response.message.content).toEqual([
-        {
-          type: "reasoning",
-          text: "thinking",
-          providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: null } },
-        },
+        { type: "reasoning", text: "thinking" },
         { type: "text", text: "Hello", providerMetadata: { openai: { itemId: "msg_1" } } },
       ])
     }),
@@ -2114,7 +2040,6 @@ describe("OpenAI Responses route", () => {
         Effect.provide(
           fixedResponse(
             sseEvents(
-              { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1" } },
               { type: "response.reasoning_summary_text.delta", item_id: "rs_1", delta: "thinking" },
               {
                 type: "response.output_item.done",
@@ -2134,7 +2059,7 @@ describe("OpenAI Responses route", () => {
       expect(response.events).toContainEqual(
         expect.objectContaining({
           type: "reasoning-end",
-          id: "rs_1:0",
+          id: "rs_1",
           providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
         }),
       )
@@ -2275,7 +2200,6 @@ describe("OpenAI Responses route", () => {
               })
               return input.respond(
                 sseEvents(
-                  { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
                   { type: "response.output_text.delta", item_id: "msg_1", delta: "Parser now round-trips reasoning." },
                   { type: "response.completed", response: { id: "resp_1" } },
                 ),

packages/ai/test/provider/xai-responses.test.ts

@@ -30,10 +30,6 @@ describe("xAI Responses route", () => {
         Effect.provide(
           fixedResponse(
             sseEvents(
-              {
-                type: "response.output_item.added",
-                item: { type: "reasoning", id: "reasoning_1" },
-              },
               { type: "response.reasoning_text.delta", item_id: "reasoning_1", delta: "Considering." },
               { type: "response.reasoning_text.done", item_id: "reasoning_1" },
               {

packages/app/src/app.tsx

@@ -105,16 +105,14 @@ export function AppInterface(props: {
   // providers beneath it.
   const Root = (rootProps: ParentProps) => (
     <TabsProvider>
-      <GlobalProvider>
-        <BodyTypography />
-        <CommandProvider>
-          <DesktopCommands />
-          <HighlightsProvider>
-            {props.children}
-            {rootProps.children}
-          </HighlightsProvider>
-        </CommandProvider>
-      </GlobalProvider>
+      <BodyTypography />
+      <CommandProvider>
+        <DesktopCommands />
+        <HighlightsProvider>
+          {props.children}
+          {rootProps.children}
+        </HighlightsProvider>
+      </CommandProvider>
     </TabsProvider>
   )
 
@@ -125,9 +123,11 @@ export function AppInterface(props: {
       servers={props.servers}
     >
       <SettingsProvider>
-        <Dynamic component={props.router ?? Router} root={Root}>
-          <AppRoutes />
-        </Dynamic>
+        <GlobalProvider>
+          <Dynamic component={props.router ?? Router} root={Root}>
+            <AppRoutes />
+          </Dynamic>
+        </GlobalProvider>
       </SettingsProvider>
     </ServersProvider>
   )

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

@@ -10,7 +10,6 @@ import { createData } from "@opencode-ai/client/solid"
 import type { ServerScope } from "@/runtime/server/scope"
 import { createServerPermissionState } from "@/session/requests/server-permission"
 import { createServerNotificationState } from "@/shell/notifications/notification"
-import { createNotificationCoordinator } from "@/shell/notifications/coordinator"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 
 export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext({
@@ -27,7 +26,6 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
       },
     })
     const models = createGlobalModels()
-    const notificationCoordinator = createNotificationCoordinator()
 
     const settingsServer = createMemo(() => {
       const list = server.list
@@ -52,7 +50,7 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
       if (existing) return existing
       const serverCtx = createRoot((dispose) => {
         serverCtxDisposers.set(key, dispose)
-        return createServerController(conn, server.scope(key), server.projects.forServer(key), notificationCoordinator)
+        return createServerController(conn, server.scope(key), server.projects.forServer(key))
       }, owner)
       serverCtxs.set(key, serverCtx)
       return serverCtx
@@ -133,7 +131,6 @@ function createServerController(
   conn: ServerConnection.Any,
   scope: ServerScope,
   projects: ReturnType<typeof createServerProjects>,
-  notificationCoordinator: ReturnType<typeof createNotificationCoordinator>,
 ) {
   const connKey = ServerConnection.key(conn)
   const sdk = createServerSdkContext(conn, scope)
@@ -148,7 +145,7 @@ function createServerController(
   })
   const sync = createServerSyncContext(sdk, data)
   const permission = createServerPermissionState({ sdk, sync, data })
-  const notification = createServerNotificationState({ sdk, data, key: connKey, coordinator: notificationCoordinator })
+  const notification = createServerNotificationState({ sdk, data, key: connKey })
 
   function enrich(project: { worktree: string; expanded: boolean }) {
     const [childStore] = sync.child(project.worktree, { bootstrap: false })

packages/app/src/shell/notifications/coordinator.ts

@@ -1,93 +0,0 @@
-import { onCleanup } from "solid-js"
-
-const FOCUS_LOCK = "opencode:notification-focus"
-const MAX_CLAIMED = 500
-
-export function createNotificationCoordinator() {
-  const locks = typeof navigator === "undefined" ? undefined : navigator.locks
-  const claimed = new Set<string>()
-  const focus = { pending: false, release: undefined as (() => void) | undefined }
-
-  const updateFocus = () => {
-    if (typeof document === "undefined" || !document.hasFocus()) {
-      focus.release?.()
-      return
-    }
-    if (!locks || focus.pending || focus.release) return
-
-    focus.pending = true
-    void locks
-      .request(FOCUS_LOCK, { mode: "shared" }, async () => {
-        focus.pending = false
-        if (!document.hasFocus()) return
-        await new Promise<void>((resolve) => {
-          focus.release = resolve
-        })
-        focus.release = undefined
-      })
-      .catch(() => {
-        focus.pending = false
-      })
-  }
-
-  if (typeof window !== "undefined") {
-    window.addEventListener("focus", updateFocus)
-    window.addEventListener("blur", updateFocus)
-    document.addEventListener("visibilitychange", updateFocus)
-    updateFocus()
-    onCleanup(() => {
-      window.removeEventListener("focus", updateFocus)
-      window.removeEventListener("blur", updateFocus)
-      document.removeEventListener("visibilitychange", updateFocus)
-      focus.release?.()
-    })
-  }
-
-  const once = async (kind: "sound" | "system", eventID: string, run: () => Promise<unknown> | void) => {
-    const key = `${kind}:${eventID}`
-    const execute = async () => {
-      if (!claim(kind, key, claimed)) return
-      await run()
-    }
-    if (!locks) return execute()
-    await locks.request(`opencode:notification:${key}`, execute)
-  }
-
-  return {
-    sound(eventID: string, run: () => Promise<unknown> | void) {
-      return once("sound", eventID, run)
-    },
-    system(eventID: string, run: () => Promise<unknown> | void) {
-      return once("system", eventID, async () => {
-        if (typeof document !== "undefined" && document.hasFocus()) return
-        if (!locks) return run()
-        await locks.request(FOCUS_LOCK, { mode: "exclusive", ifAvailable: true }, async (lock) => {
-          if (!lock) return
-          await run()
-        })
-      })
-    },
-  }
-}
-
-function claim(kind: "sound" | "system", eventID: string, claimed: Set<string>) {
-  if (claimed.has(eventID)) return false
-
-  if (typeof localStorage !== "undefined") {
-    try {
-      const storageKey = `opencode:notification-${kind}`
-      const value: unknown = JSON.parse(localStorage.getItem(storageKey) ?? "[]")
-      const events = Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
-      if (events.includes(eventID)) {
-        claimed.add(eventID)
-        return false
-      }
-      localStorage.setItem(storageKey, JSON.stringify([...events, eventID].slice(-MAX_CLAIMED)))
-    } catch {
-      // The in-memory claim still prevents duplicates in this renderer when storage is unavailable.
-    }
-  }
-
-  claimed.add(eventID)
-  return true
-}

packages/app/src/shell/notifications/notification.tsx

@@ -10,10 +10,9 @@ import { useSettings } from "@/settings/model"
 import { decode64 } from "@/runtime/persistence/base64"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import { playSoundById } from "@/shell/notifications/sound"
-import type { createNotificationCoordinator } from "@/shell/notifications/coordinator"
 import { useGlobal } from "@/runtime/server/runtime"
 import { ServerConnection, useServers } from "@/runtime/server/registry"
-import { sessionIDHasOpenTab, useTabs } from "@/shell/tabs/tabs"
+import { type DraftTab, useTabs } from "@/shell/tabs/tabs"
 import { requireServerKey, sessionHref } from "@/shell/routes/session"
 import type { ServerScope } from "@/runtime/server/scope"
 import { useServer } from "@/runtime/server/current"
@@ -109,16 +108,10 @@ function buildNotificationIndex(list: Notification[]) {
   return index
 }
 
-export function createServerNotificationState(input: {
-  sdk: ServerSDK
-  data: Data
-  key: ServerConnection.Key
-  coordinator: ReturnType<typeof createNotificationCoordinator>
-}) {
+export function createServerNotificationState(input: { sdk: ServerSDK; data: Data; key: ServerConnection.Key }) {
   const platform = usePlatform()
   const settings = useSettings()
   const language = useLanguage()
-  const tabs = useTabs()
   const empty: Notification[] = []
 
   const [store, setStore, _, ready] = persisted(
@@ -222,17 +215,14 @@ export function createServerNotificationState(input: {
     dispatchEvent(new PopStateEvent("popstate"))
   }
 
-  const handleSessionIdle = (sessionID: string, eventID: string, time: number) => {
+  const handleSessionIdle = (sessionID: string, time: number) => {
     void lookup(sessionID).then((session) => {
       if (meta.disposed) return
       if (!session) return
       if (session.parentID) return
 
-      if (
-        sessionIDHasOpenTab(tabs.store, input.key, sessionID) &&
-        settings.sounds.agentEnabled()
-      ) {
-        void input.coordinator.sound(`${input.key}\0${eventID}`, () => playSoundById(settings.sounds.agent()))
+      if (settings.sounds.agentEnabled()) {
+        void playSoundById(settings.sounds.agent())
       }
 
       append({
@@ -245,10 +235,8 @@ export function createServerNotificationState(input: {
 
       const href = sessionHref(input.key, sessionID)
       if (settings.notifications.agent()) {
-        void input.coordinator.system(`${input.key}\0${eventID}`, () =>
-          platform.notify(language.t("notification.session.responseReady.title"), session.title ?? sessionID, () =>
-            navigate(href),
-          ),
+        void platform.notify(language.t("notification.session.responseReady.title"), session.title ?? sessionID, () =>
+          navigate(href),
         )
       }
     })
@@ -257,18 +245,14 @@ export function createServerNotificationState(input: {
   const handleSessionError = (
     sessionID: string,
     error: ErrorNotification["error"],
-    eventID: string,
     time: number,
   ) => {
     void lookup(sessionID).then((session) => {
       if (meta.disposed) return
       if (session?.parentID) return
 
-      if (
-        sessionIDHasOpenTab(tabs.store, input.key, sessionID) &&
-        settings.sounds.errorsEnabled()
-      ) {
-        void input.coordinator.sound(`${input.key}\0${eventID}`, () => playSoundById(settings.sounds.errors()))
+      if (settings.sounds.errorsEnabled()) {
+        void playSoundById(settings.sounds.errors())
       }
 
       append({
@@ -284,9 +268,7 @@ export function createServerNotificationState(input: {
         (typeof error === "string" ? error : language.t("notification.session.error.fallbackDescription"))
       const href = sessionHref(input.key, sessionID)
       if (settings.notifications.errors()) {
-        void input.coordinator.system(`${input.key}\0${eventID}`, () =>
-          platform.notify(language.t("notification.session.error.title"), description, () => navigate(href)),
-        )
+        void platform.notify(language.t("notification.session.error.title"), description, () => navigate(href))
       }
     })
   }
@@ -296,10 +278,10 @@ export function createServerNotificationState(input: {
 
     const time = Date.now()
     if (event.type === "session.execution.failed") {
-      handleSessionError(event.data.sessionID, event.data.error, event.id, time)
+      handleSessionError(event.data.sessionID, event.data.error, time)
       return
     }
-    handleSessionIdle(event.data.sessionID, event.id, time)
+    handleSessionIdle(event.data.sessionID, time)
   })
   onCleanup(() => {
     meta.disposed = true

packages/app/src/shell/tabs/tabs.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test"
 import { createRoot, getOwner, onCleanup } from "solid-js"
 import { createTabMemory } from "./memory"
 import { nextTabAfterClose, pushClosedTab, removeClosedTabs, takeClosedTab, type ClosedTab } from "./closed"
-import { sessionIDHasOpenTab, tabHref, tabKey, type SessionTab, type Tab } from "./tabs"
+import { tabHref, tabKey, type SessionTab, type Tab } from "./tabs"
 import { migrateTabs } from "./migration"
 import type { ServerConnection } from "@/runtime/server/registry"
 
@@ -47,15 +47,6 @@ test("session tab identity stays rooted while its href follows the child route",
   expect(tabHref(child)).toContain("/session/child")
 })
 
-test("finds open root and routed session tabs", () => {
-  const tabs = [{ ...sessionTab("root"), routeSessionId: "child" }]
-
-  expect(sessionIDHasOpenTab(tabs, server, "root")).toBe(true)
-  expect(sessionIDHasOpenTab(tabs, server, "child")).toBe(true)
-  expect(sessionIDHasOpenTab(tabs, server, "closed")).toBe(false)
-  expect(sessionIDHasOpenTab(tabs, "other" as ServerConnection.Key, "root")).toBe(false)
-})
-
 describe("tab memory", () => {
   test("keeps state until its tab is removed", () => {
     createRoot((dispose) => {

packages/app/src/shell/tabs/tabs.tsx

@@ -51,15 +51,11 @@ export const tabKey = (tab: Tab) =>
   tab.type === "draft" ? `draft:${tab.draftID}` : `${tab.server}\n${sessionHref(tab.server, tab.sessionId)}`
 
 export function sessionHasOpenTab(tabs: Tab[], server: ServerConnection.Key, session: SessionInfo) {
-  return sessionIDHasOpenTab(tabs, server, session.id)
-}
-
-export function sessionIDHasOpenTab(tabs: Tab[], server: ServerConnection.Key, sessionID: string) {
   return tabs.some(
     (tab) =>
       tab.type === "session" &&
       tab.server === server &&
-      (tab.sessionId === sessionID || tab.routeSessionId === sessionID),
+      (tab.sessionId === session.id || tab.routeSessionId === session.id),
   )
 }
 

packages/desktop/src/main/storage/drafts.test.ts

@@ -14,16 +14,3 @@ test("flushes the latest buffered draft and stores blobs", () => {
   expect(store.getBlob(id)).toEqual(bytes)
   store.close()
 })
-
-test("allows repeated flushes until closing", () => {
-  const store = createDesktopDraftStore(":memory:")
-  store.set("prompt", "first")
-  store.flush()
-  store.set("prompt", "draft")
-  store.flush()
-  expect(store.get("prompt")).toBe("draft")
-  store.close()
-
-  expect(() => store.flush()).not.toThrow()
-  expect(() => store.close()).not.toThrow()
-})

packages/desktop/src/main/storage/drafts.ts

@@ -36,14 +36,11 @@ export function createDesktopDraftStore(filename: string) {
     .forEach(({ id }) => db.delete(blobs).where(eq(blobs.id, id)).run())
   const pending = new Map<string, string | null>()
   let timer: ReturnType<typeof setTimeout> | undefined
-  let closed = false
   const flush = () => {
     if (timer) clearTimeout(timer)
     timer = undefined
-    if (closed) return
     const writes = [...pending]
     pending.clear()
-    if (!writes.length) return
     db.transaction((tx) => {
       writes.forEach(([key, value]) => {
         if (value === null) tx.delete(documents).where(eq(documents.key, key)).run()
@@ -78,9 +75,7 @@ export function createDesktopDraftStore(filename: string) {
     getBlob: (id: string) => db.select({ data: blobs.data }).from(blobs).where(eq(blobs.id, id)).get()?.data ?? null,
     flush,
     close() {
-      if (closed) return
       flush()
-      closed = true
       native.close()
     },
   }