fix(tui): keep closed tabs closed

packages/ai/AGENTS.md

@@ -10,7 +10,7 @@
 
 ## Conventions
 
-Per-type constructors live on the type, not as top-level re-exports. Use `Message.system(...)`, `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `LanguageModel.make(...)`, `ToolDefinition.make(...)`, `ToolCallPart.make(...)`, `ToolResultPart.make(...)`, `ToolChoice.make(...)`, `ToolChoice.named(...)`, `SystemPart.make(...)`, and `GenerationOptions.make(...)` directly. The top-level `LLM` namespace is reserved for request-shaped call APIs: `LLM.request`, `LLM.generate`, `LLM.stream`, and `LLM.generateObject`. Use `LLMRequest.update(...)` when deriving canonical request data; do not add a duplicate `LLM.updateRequest(...)` path. Two ways to construct the same thing is one too many.
+Per-type constructors live on the type, not as top-level re-exports. Use `Message.system(...)`, `Message.user(...)`, `Message.assistant(...)`, `Message.tool(...)`, `LanguageModel.make(...)`, `ToolDefinition.make(...)`, `ToolCallPart.make(...)`, `ToolResultPart.make(...)`, `ToolChoice.make(...)`, `ToolChoice.named(...)`, `SystemPart.make(...)`, and `GenerationOptions.make(...)` directly. The top-level `LLM` namespace is reserved for request-shaped call APIs: `LLM.request`, `LLM.generate`, `LLM.stream`, `LLM.updateRequest`, and `LLM.generateObject`. Two ways to construct the same thing is one too many.
 
 - Keep provider-defined string enums forward-compatible. Expose known values for autocomplete while accepting future values with `Known | (string & {})`; use `Schema.String` at runtime unless rejecting unknown values is required for correctness.
 

packages/ai/README.md

@@ -3,9 +3,8 @@
 Schema-first AI primitives for opencode. Provider quirks live in adapters, not in calling code.
 
 ```ts
-import { Effect, Layer } from "effect"
+import { Effect } from "effect"
 import { LLM, LLMClient } from "@opencode-ai/ai"
-import { RequestExecutor } from "@opencode-ai/ai/route"
 import { OpenAI } from "@opencode-ai/ai/providers"
 
 const model = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).responses("gpt-4o-mini")
@@ -21,10 +20,6 @@ const program = Effect.gen(function* () {
   const response = yield* LLMClient.generate(request)
   console.log(response.text)
 })
-
-const llmLayer = LLMClient.layer.pipe(Layer.provide(RequestExecutor.fetchLayer))
-
-await Effect.runPromise(program.pipe(Effect.provide(llmLayer)))
 ```
 
 Run `LLMClient.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.
@@ -205,30 +200,6 @@ The hosted result is represented as a provider-executed tool call and tool resul
 - **`Image.generate({...})`** — generate images through a provider-neutral image request and response model.
 - **`ImageClient`** — Effect service and layer for image execution, parallel to `LLMClient`.
 
-## Testing
-
-Use the deterministic test client from `@opencode-ai/ai/testing` to script provider-neutral responses and inspect
-the requests sent by code under test:
-
-```ts
-import { Effect } from "effect"
-import { TestLLM } from "@opencode-ai/ai/testing"
-
-const testLLM = TestLLM.layerWithClient({
-  fallback: TestLLM.text("Hello from the test model"),
-})
-
-const programWithTestClient = Effect.gen(function* () {
-  const result = yield* program
-  console.log(yield* TestLLM.requests)
-  return result
-}).pipe(Effect.provide(testLLM))
-```
-
-`TestLLM.push(...)` scripts one-shot responses, `TestLLM.always(...)` changes the fallback, and
-`TestLLM.wait(...)` lets concurrent tests wait until a request has arrived. Every received canonical request is
-available from `TestLLM.requests`.
-
 ## Caching
 
 Prompt caching is **on by default**. Every `LLMRequest` resolves to `cache: "auto"` unless the caller opts out with `cache: "none"`. Each protocol translates `CacheHint`s to its wire format (`cache_control` on Anthropic, `cachePoint` on Bedrock; OpenAI and Gemini do implicit caching server-side and don't need inline markers — auto is a no-op there).

packages/ai/src/image-client.ts

@@ -15,11 +15,11 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Im
 
 export const generate = <Options extends ImageOptions>(
   request: ImageRequestFor<Options>,
-): Effect.Effect<ImageResponse, AIError, Service> =>
+): Effect.Effect<ImageResponse, AIError> =>
   Effect.gen(function* () {
     const client = yield* Service
     return yield* client.generate(request)
-  })
+  }) as Effect.Effect<ImageResponse, AIError>
 
 export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
   Service,

packages/ai/src/llm.ts

@@ -1,5 +1,5 @@
 import { Effect, JsonSchema, Schema } from "effect"
-import { LLMClient, Service } from "./route/client"
+import { LLMClient } from "./route/client"
 import {
   GenerationOptions,
   HttpOptions,
@@ -151,10 +151,10 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (
  */
 export function generateObject<const SelectedLanguageModel extends LanguageModel, S extends ToolSchema<any>>(
   options: GenerateObjectOptions<S, SelectedLanguageModel>,
-): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, AIError, Service>
+): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, AIError>
 export function generateObject<const SelectedLanguageModel extends LanguageModel>(
   options: GenerateObjectDynamicOptions<SelectedLanguageModel>,
-): Effect.Effect<GenerateObjectResponse<unknown>, AIError, Service>
+): Effect.Effect<GenerateObjectResponse<unknown>, AIError>
 export function generateObject(options: GenerateObjectOptions<ToolSchema<any>> | GenerateObjectDynamicOptions) {
   if ("schema" in options) {
     const { schema, ...rest } = options

packages/ai/src/route/client.ts

@@ -422,18 +422,18 @@ const generateWith = (stream: Interface["stream"]) =>
     )
   })
 
-export function stream(request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError, Service> {
+export function stream(request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError> {
   return Stream.unwrap(
     Effect.gen(function* () {
       return (yield* Service).stream(request, options)
     }),
-  )
+  ) as Stream.Stream<LLMEvent, AIError>
 }
 
-export function generate(request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service> {
+export function generate(request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError> {
   return Effect.gen(function* () {
     return yield* (yield* Service).generate(request, options)
-  })
+  }) as Effect.Effect<LLMResponse, AIError>
 }
 
 export const streamRequest = (request: LLMRequest, options?: StreamOptions) =>

packages/ai/src/testing.ts

@@ -53,7 +53,7 @@ const textEvents = (value: string, id: string) => [
   LLMEvent.textEnd({ id }),
 ]
 
-export const text = (value: string, id = "text-0") => stop(...textEvents(value, id))
+export const text = (value: string, id: string) => stop(...textEvents(value, id))
 
 export const textWithUsage = (value: string, id: string, inputTokens: number) =>
   complete(
@@ -147,10 +147,6 @@ export const clientLayer = Layer.effect(
   Effect.map(Service, (service) => service.client),
 )
 
-export const layerWithClient = (options: LayerOptions = {}) => clientLayer.pipe(Layer.provideMerge(layer(options)))
-
-export const requests = Service.use((service) => Effect.succeed(service.requests))
-
 export const push = (...responses: readonly Response[]) => Service.use((service) => service.push(...responses))
 
 export const always = (response: Response) => Service.use((service) => service.always(response))

packages/ai/test/exports.test.ts

@@ -32,8 +32,6 @@ describe("public exports", () => {
     expect(Provider.make).toBeFunction()
     expect(ProviderSubpath.make).toBe(Provider.make)
     expect(TestLLM.layer).toBeFunction()
-    expect(TestLLM.layerWithClient).toBeFunction()
-    expect(TestLLM.requests).toBeDefined()
   })
 
   test("route barrel exposes route-authoring APIs", () => {

packages/ai/test/image.types.ts

@@ -1,7 +1,5 @@
-import { Effect } from "effect"
 import {
   Image,
-  ImageClient,
   ImageInput,
   ImageModel,
   type ImageModelOptions,
@@ -9,13 +7,8 @@ import {
   type ImageRequestFor,
   type ImageRoute,
 } from "../src"
-import type { Service } from "../src/image-client"
 import { Google, OpenAI, XAI, ZAI } from "../src/providers"
 
-type Requirements<T> = T extends Effect.Effect<infer _A, infer _E, infer R> ? R : never
-type Equal<A, B> = [A, B] extends [B, A] ? true : false
-type Assert<T extends true> = T
-
 type GoogleLikeOptions = {
   readonly aspectRatio?: "1:1" | "16:9"
   readonly imageSize?: "1K" | "2K"
@@ -153,9 +146,6 @@ const request = Image.request({
 })
 const typedRequest: ImageRequestFor<GoogleLikeOptions> = request
 void typedRequest
-const generated = ImageClient.generate(request)
-type GenerateRequirements = Assert<Equal<Requirements<typeof generated>, Service>>
-void (true satisfies GenerateRequirements)
 
 // @ts-expect-error Image requests no longer expose a common count option.
 Image.generate({ model: openai, prompt: "A lighthouse", count: 2 })

packages/ai/test/llm-option-types.types.ts

@@ -1,11 +1,5 @@
-import { Effect, Schema, Stream } from "effect"
-import {
-  LLM,
-  type LLMClientService,
-  type LanguageModel,
-  type LanguageModelProviderOptions,
-  type ProviderOptions,
-} from "../src"
+import { Schema } from "effect"
+import { LLM, type LanguageModel, type LanguageModelProviderOptions, type ProviderOptions } from "../src"
 import { OpenAIChat } from "../src/protocols"
 
 interface ExampleOptions {
@@ -21,19 +15,9 @@ const model = OpenAIChat.route
   .with({ endpoint: { baseURL: "https://example.com/v1" } })
   .model<ExampleProviderOptions>({ id: "example" })
 
-type Requirements<T> = T extends Effect.Effect<infer _A, infer _E, infer R> ? R : never
-type StreamRequirements<T> = T extends Stream.Stream<infer _A, infer _E, infer R> ? R : never
-type Equal<A, B> = [A, B] extends [B, A] ? true : false
-type Assert<T extends true> = T
-
 LLM.request({ model, prompt: "Hello", providerOptions: { example: { mode: "fast" } } })
 LLM.request({ model, prompt: "Hello", providerOptions: { future: { option: true } } })
 
-const generated = LLM.generate(LLM.request({ model, prompt: "Hello" }))
-type GenerateRequirements = Assert<Equal<Requirements<typeof generated>, LLMClientService>>
-const streamed = LLM.stream(LLM.request({ model, prompt: "Hello" }))
-type StreamClientRequirements = Assert<Equal<StreamRequirements<typeof streamed>, LLMClientService>>
-
 LLM.request({
   model,
   prompt: "Hello",
@@ -41,20 +25,12 @@ LLM.request({
   providerOptions: { example: { mode: "slow" } },
 })
 
-const generatedObject = LLM.generateObject({
+LLM.generateObject({
   model,
   prompt: "Hello",
   schema: Schema.Struct({ answer: Schema.String }),
   providerOptions: { example: { mode: "thorough" } },
 })
-type GenerateObjectRequirements = Assert<Equal<Requirements<typeof generatedObject>, LLMClientService>>
-
-const generatedDynamicObject = LLM.generateObject({
-  model,
-  prompt: "Hello",
-  jsonSchema: { type: "object" },
-})
-type GenerateDynamicObjectRequirements = Assert<Equal<Requirements<typeof generatedDynamicObject>, LLMClientService>>
 
 LLM.generateObject({
   model,
@@ -68,8 +44,4 @@ declare const generic: LanguageModel
 LLM.request({ model: generic, prompt: "Hello", providerOptions: { arbitrary: { option: true } } })
 
 const options: LanguageModelProviderOptions<typeof model> = { example: { mode: "fast" } }
-void (options satisfies LanguageModelProviderOptions<typeof model>)
-void (true satisfies GenerateRequirements)
-void (true satisfies StreamClientRequirements)
-void (true satisfies GenerateObjectRequirements)
-void (true satisfies GenerateDynamicObjectRequirements)
+void options

packages/ai/test/testing.test.ts

@@ -1,19 +0,0 @@
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM, LLMClient, LLMEvent } from "../src"
-import { OpenAIChat } from "../src/protocols"
-import { TestLLM } from "../src/testing"
-import { testEffect } from "./lib/effect"
-
-const model = OpenAIChat.route.model({ id: "test" })
-const it = testEffect(TestLLM.layerWithClient({ fallback: TestLLM.text("Hello") }))
-
-it.effect("provides a client and exposes received requests", () =>
-  Effect.gen(function* () {
-    const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Say hello" }))
-
-    expect(response.text).toBe("Hello")
-    expect(response.events.filter(LLMEvent.is.textDelta)).toEqual([{ type: "text-delta", id: "text-0", text: "Hello" }])
-    expect(yield* TestLLM.requests).toHaveLength(1)
-  }),
-)

packages/core/test/generate.test.ts

@@ -65,7 +65,7 @@ const aisdk = Layer.mock(AISDK.Service, {
   },
   model: () => Effect.succeed(runtime),
 })
-const client = TestLLM.layerWithClient({ fallback: TestLLM.text("OK") })
+const client = TestLLM.clientLayer.pipe(Layer.provide(TestLLM.layer({ fallback: TestLLM.text("OK", "generate") })))
 
 const resolver = ModelResolver.layer.pipe(Layer.provide(Layer.mergeAll(catalog, integrations, npm, aisdk)))
 const it = testEffect(Generate.layer.pipe(Layer.provide(Layer.merge(resolver, client))))

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

@@ -1,4 +1,4 @@
-import { createEffect, createMemo, createSignal, onCleanup } from "solid-js"
+import { createEffect, createMemo, createSignal, on, onCleanup } from "solid-js"
 import { isDeepEqual } from "remeda"
 import { createSimpleContext } from "./helper"
 import { useClient } from "./client"
@@ -126,22 +126,40 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       })
     }
 
+    createEffect(
+      on(
+        [
+          () => (enabled() && route.data.type === "session" ? route.data.sessionID : undefined),
+          () => config.tabs?.scope,
+          () => paths.cwd,
+        ],
+        ([routed]) => {
+          if (!routed || routed === "dummy") return
+          const sessionID = root(routed)
+          history = recordSessionTabHistory(history, sessionID)
+          const fallback = newTab() ? NEW_SESSION_TAB_TITLE : undefined
+          update((draft) => {
+            draft.tabs = openSessionTab(draft.tabs, {
+              sessionID,
+              title: title(sessionID, draft.tabs.find((tab) => tab.sessionID === sessionID)?.title, fallback),
+            })
+            delete draft.unread[sessionID]
+          })
+        },
+      ),
+    )
+
     createEffect(() => {
-      if (!enabled()) return
-      if (route.data.type !== "session" || route.data.sessionID === "dummy") return
+      if (!enabled() || route.data.type !== "session" || route.data.sessionID === "dummy") return
       const sessionID = root(route.data.sessionID)
-      history = recordSessionTabHistory(history, sessionID)
-      const fallback = newTab() ? NEW_SESSION_TAB_TITLE : undefined
-      const tabs = openSessionTab(state().tabs, {
-        sessionID,
-        title: title(sessionID, state().tabs.find((tab) => tab.sessionID === sessionID)?.title, fallback),
-      })
-      if (tabs === state().tabs && !state().unread[sessionID]) return
+      const tab = state().tabs.find((tab) => tab.sessionID === sessionID)
+      if (!tab) return
+      const nextTitle = title(sessionID, tab.title)
+      if ((!nextTitle || nextTitle === tab.title) && !state().unread[sessionID]) return
       update((draft) => {
-        draft.tabs = openSessionTab(draft.tabs, {
-          sessionID,
-          title: title(sessionID, draft.tabs.find((tab) => tab.sessionID === sessionID)?.title, fallback),
-        })
+        const tab = draft.tabs.find((tab) => tab.sessionID === sessionID)
+        if (!tab) return
+        draft.tabs = openSessionTab(draft.tabs, { sessionID, title: title(sessionID, tab.title) })
         delete draft.unread[sessionID]
       })
     })

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

@@ -170,6 +170,31 @@ test("concurrent TUIs do not alternate shared tab titles from divergent session
   }
 })
 
+test("closing a tab is not undone by another TUI viewing the same session", async () => {
+  const state = stateDir("opencode-session-tabs-shared-close-")
+  const first = await renderSessionTabs("shared", { state })
+  const second = await renderSessionTabs("shared", { state })
+
+  try {
+    await wait(() => first.tabs.tabs().some((tab) => tab.sessionID === "shared"))
+    await wait(() => second.tabs.tabs().some((tab) => tab.sessionID === "shared"))
+    first.tabs.close()
+    await wait(() => first.route.data.type === "home")
+    await wait(() => !second.tabs.tabs().some((tab) => tab.sessionID === "shared"))
+    await Bun.sleep(50)
+
+    expect(first.tabs.tabs().some((tab) => tab.sessionID === "shared")).toBe(false)
+
+    second.route.navigate({ type: "home" })
+    await wait(() => second.route.data.type === "home")
+    second.route.navigate({ type: "session", sessionID: "shared" })
+    await wait(() => first.tabs.tabs().some((tab) => tab.sessionID === "shared"))
+  } finally {
+    first.destroy()
+    second.destroy()
+  }
+})
+
 test("user prompt admissions pulse an already-busy background tab", async () => {
   const setup = await renderSessionTabs("background")
   const admitted = (sessionID: string, inputID: string): OpenCodeEvent => ({