feat(tui): surface plugin failures

bun.lock

@@ -345,6 +345,9 @@
     "packages/core": {
       "name": "@opencode-ai/core",
       "version": "1.18.4",
+      "bin": {
+        "opencode": "./bin/opencode",
+      },
       "dependencies": {
         "@ai-sdk/alibaba": "1.0.17",
         "@ai-sdk/amazon-bedrock": "4.0.112",
@@ -364,6 +367,8 @@
         "@ai-sdk/togetherai": "2.0.41",
         "@ai-sdk/vercel": "2.0.39",
         "@aws-sdk/credential-providers": "3.1057.0",
+        "@effect/platform-node": "catalog:",
+        "@effect/sql-sqlite-bun": "catalog:",
         "@ff-labs/fff-bun": "0.10.1",
         "@ff-labs/fff-node": "0.10.1",
         "@lydell/node-pty": "catalog:",
@@ -399,8 +404,6 @@
         "zod": "catalog:",
       },
       "devDependencies": {
-        "@effect/platform-node": "catalog:",
-        "@effect/sql-sqlite-bun": "catalog:",
         "@opencode-ai/http-recorder": "workspace:*",
         "@parcel/watcher-darwin-arm64": "2.5.1",
         "@parcel/watcher-darwin-x64": "2.5.1",

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

@@ -573,10 +573,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
         cache_control: cacheControl(breakpoints, part.cache),
       })
     }
-    const previous = messages.at(-1)
-    if (previous?.role === "user" && previous.content.every((block) => block.type === "tool_result"))
-      messages[messages.length - 1] = { role: "user", content: [...previous.content, ...content] }
-    else messages.push({ role: "user", content })
+    messages.push({ role: "user", content })
   }
 
   return messages

packages/ai/src/route/executor.ts

@@ -1,4 +1,4 @@
-import { Cause, Context, Effect, Layer, Option, Schema, Stream } from "effect"
+import { Cause, Context, Effect, Layer, Option, Schema } from "effect"
 import {
   FetchHttpClient,
   Headers,
@@ -297,86 +297,44 @@ export const classifyHttpFailure = (input: {
   })
 }
 
-type HttpOperation = "request" | "read"
-
-const NativeTransportFailure = Schema.Struct({
-  message: Schema.String,
-  code: Schema.optionalKey(Schema.String),
-  cause: Schema.optionalKey(Schema.Unknown),
-})
-const decodeNativeTransportFailure = Schema.decodeUnknownOption(NativeTransportFailure)
-
-const nativeTransportFailure = (error: unknown) => {
-  const failure = Option.getOrUndefined(decodeNativeTransportFailure(error))
-  if (!failure) return undefined
-  if (failure.code !== undefined) return failure
-  const cause = Option.getOrUndefined(decodeNativeTransportFailure(failure.cause))
-  if (cause?.code !== undefined) return cause
-  return failure
-}
-
-const httpError = (input: {
-  readonly error: unknown
-  readonly request: HttpClientRequest.HttpClientRequest
-  readonly operation: HttpOperation
-  readonly redactedNames: ReadonlyArray<string | RegExp>
-}) => {
-  const request = HttpClientError.isHttpClientError(input.error) ? input.error.request : input.request
-  const transportError = (failure: { readonly message: string; readonly code?: string | undefined }) =>
+const toHttpError = (redactedNames: ReadonlyArray<string | RegExp>) => (error: unknown) => {
+  const transportError = (input: {
+    readonly message: string
+    readonly kind?: string | undefined
+    readonly request?: HttpClientRequest.HttpClientRequest | undefined
+  }) =>
     new AIError({
       module: "RequestExecutor",
-      method: input.operation,
+      method: "execute",
       reason: new TransportReason({
-        message: failure.message,
-        transport: "http",
-        operation: input.operation,
-        code: failure.code,
-        url: redactUrl(request.url),
-        http: new HttpContext({ request: requestDetails(request, input.redactedNames) }),
+        message: input.message,
+        kind: input.kind,
+        url: input.request ? redactUrl(input.request.url) : undefined,
+        http: input.request ? new HttpContext({ request: requestDetails(input.request, redactedNames) }) : undefined,
       }),
     })
 
-  const source =
-    HttpClientError.isHttpClientError(input.error) && "cause" in input.error.reason
-      ? input.error.reason.cause
-      : input.error
-  const native = nativeTransportFailure(source)
-  const code = native?.code
-  const raw = native?.message ?? (input.error instanceof Error ? input.error.message : undefined)
-  const detail = raw ? redactBody(raw, secretValues(request)) : undefined
-  const message = code && detail && !detail.includes(code) ? `${code}: ${detail}` : detail
-
-  if (Cause.isTimeoutError(input.error) || Cause.isTimeoutError(source))
-    return transportError({ message: message ?? "HTTP transport timed out", code: code ?? "Timeout" })
-  if (!HttpClientError.isHttpClientError(input.error))
-    return transportError({ message: message ?? "HTTP transport failed", code })
-  if (input.error.reason._tag === "TransportError") {
+  if (Cause.isTimeoutError(error)) {
+    return transportError({ message: error.message, kind: "Timeout" })
+  }
+  if (!HttpClientError.isHttpClientError(error)) {
+    return transportError({ message: error instanceof Error ? error.message : "HTTP transport failed" })
+  }
+  const request = "request" in error ? error.request : undefined
+  if (error.reason._tag === "TransportError") {
     return transportError({
-      message: message ?? input.error.reason.description ?? "HTTP transport failed",
-      code: code ?? input.error.reason._tag,
+      message: error.reason.description ?? "HTTP transport failed",
+      kind: error.reason._tag,
+      request,
     })
   }
   return transportError({
-    message: message ?? `HTTP transport failed: ${input.error.reason._tag}`,
-    code: code ?? input.error.reason._tag,
+    message: `HTTP transport failed: ${error.reason._tag}`,
+    kind: error.reason._tag,
+    request,
   })
 }
 
-export const stream = (
-  executor: Interface,
-  request: HttpClientRequest.HttpClientRequest,
-  middleware?: HttpMiddleware,
-): Stream.Stream<Uint8Array, AIError> =>
-  Stream.unwrap(
-    Effect.gen(function* () {
-      const redactedNames = yield* Headers.CurrentRedactedNames
-      const response = yield* executor.execute(request, middleware)
-      return response.stream.pipe(
-        Stream.mapError((error) => httpError({ error, request: response.request, operation: "read", redactedNames })),
-      )
-    }),
-  )
-
 export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.effect(
   Service,
   Effect.gen(function* () {
@@ -385,16 +343,15 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
       Effect.gen(function* () {
         const redactedNames = yield* Headers.CurrentRedactedNames
         if (!middleware)
-          return yield* http.execute(request).pipe(
-            Effect.mapError((error) => httpError({ error, request, operation: "request", redactedNames })),
-            Effect.flatMap(statusError(request, redactedNames)),
-          )
+          return yield* http
+            .execute(request)
+            .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)))
 
         const response = yield* middleware(request, (input) =>
           http
             .execute(input)
             .pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause))))),
-        ).pipe(Effect.mapError((error) => httpError({ error, request, operation: "request", redactedNames })))
+        ).pipe(Effect.mapError(toHttpError(redactedNames)))
         return yield* statusError(response.request, redactedNames)(response)
       })
     return Service.of({

packages/ai/src/route/transport/http.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect"
+import { Effect, Stream } from "effect"
 import { Headers, HttpClientRequest } from "effect/unstable/http"
 import { Auth } from "../auth.js"
 import { render as renderEndpoint } from "../endpoint.js"
@@ -6,7 +6,6 @@ import { Framing } from "../framing.js"
 import type { HttpMiddleware, Transport, TransportPrepareInput } from "./index.js"
 import * as ProviderShared from "../../protocols/shared.js"
 import { mergeJsonRecords, type LLMRequest } from "../../schema/index.js"
-import { RequestExecutor } from "../executor.js"
 
 export type JsonRequestInput<Body> = TransportPrepareInput<Body>
 
@@ -87,8 +86,26 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
         middleware: prepareInput.middleware,
       }
     }),
-  frames: (prepared, _request, runtime) =>
-    prepared.framing.frame(RequestExecutor.stream(runtime.http, prepared.request, prepared.middleware)),
+  frames: (prepared, request, runtime) =>
+    Stream.unwrap(
+      runtime.http
+        .execute(prepared.request, prepared.middleware)
+        .pipe(
+          Effect.map((response) =>
+            prepared.framing.frame(
+              response.stream.pipe(
+                Stream.mapError((error) =>
+                  ProviderShared.eventError(
+                    `${request.model.provider}/${request.model.route.id}`,
+                    `Failed to read ${request.model.provider}/${request.model.route.id} stream`,
+                    ProviderShared.errorText(error),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+    ),
 })
 
 export const sseJson = {

packages/ai/src/route/transport/websocket.ts

@@ -1,6 +1,6 @@
 import { Cause, Context, Effect, Layer, Queue, Stream } from "effect"
 import { Headers } from "effect/unstable/http"
-import { AIError, TransportReason, type TransportOperation } from "../../schema/index.js"
+import { AIError, TransportReason } from "../../schema/index.js"
 import * as HttpTransport from "./http.js"
 import type { Transport } from "./index.js"
 
@@ -29,18 +29,12 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/AI
 const transportError = (
   method: string,
   message: string,
-  input: { readonly operation: TransportOperation; readonly url?: string; readonly code?: string },
+  input: { readonly url?: string; readonly kind?: string } = {},
 ) =>
   new AIError({
     module: "WebSocketExecutor",
     method,
-    reason: new TransportReason({
-      message,
-      transport: "websocket",
-      operation: input.operation,
-      url: input.url,
-      code: input.code,
-    }),
+    reason: new TransportReason({ message, url: input.url, kind: input.kind }),
   })
 
 const eventMessage = (event: Event) => {
@@ -61,8 +55,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
     return Effect.fail(
       transportError("open", `WebSocket closed before opening (state ${ws.readyState})`, {
         url: input.url,
-        operation: "request",
-        code: "closed",
+        kind: "open",
       }),
     )
   }
@@ -86,10 +79,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
       cleanup()
       resume(
         Effect.fail(
-          transportError("open", `Failed to open WebSocket: ${eventMessage(event)}`, {
-            url: input.url,
-            operation: "request",
-          }),
+          transportError("open", `Failed to open WebSocket: ${eventMessage(event)}`, { url: input.url, kind: "open" }),
         ),
       )
     }
@@ -99,8 +89,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
         Effect.fail(
           transportError("open", `WebSocket closed before opening with code ${event.code}`, {
             url: input.url,
-            operation: "request",
-            code: String(event.code),
+            kind: "open",
           }),
         ),
       )
@@ -129,8 +118,7 @@ const webSocketUrl = (value: string) =>
     catch: (error) =>
       transportError("prepare", error instanceof Error ? error.message : "Invalid WebSocket URL", {
         url: value,
-        operation: "request",
-        code: "invalid-url",
+        kind: "websocket",
       }),
   })
 
@@ -141,7 +129,7 @@ export const open = (input: WebSocketRequest) =>
     catch: (error) =>
       transportError("open", error instanceof Error ? error.message : "Failed to construct WebSocket", {
         url: input.url,
-        operation: "request",
+        kind: "open",
       }),
   }).pipe(Effect.flatMap((ws) => fromWebSocket(ws, input)))
 
@@ -162,10 +150,7 @@ export const fromWebSocket = (
       Queue.failCauseUnsafe(
         messages,
         Cause.fail(
-          transportError("message", "Unsupported WebSocket message payload", {
-            url: input.url,
-            operation: "read",
-          }),
+          transportError("message", "Unsupported WebSocket message payload", { url: input.url, kind: "message" }),
         ),
       )
     }
@@ -173,10 +158,7 @@ export const fromWebSocket = (
       Queue.failCauseUnsafe(
         messages,
         Cause.fail(
-          transportError("message", `WebSocket error: ${eventMessage(event)}`, {
-            url: input.url,
-            operation: "read",
-          }),
+          transportError("message", `WebSocket error: ${eventMessage(event)}`, { url: input.url, kind: "message" }),
         ),
       )
     }
@@ -185,11 +167,7 @@ export const fromWebSocket = (
       Queue.failCauseUnsafe(
         messages,
         Cause.fail(
-          transportError("message", `WebSocket closed with code ${event.code}`, {
-            url: input.url,
-            operation: "read",
-            code: String(event.code),
-          }),
+          transportError("message", `WebSocket closed with code ${event.code}`, { url: input.url, kind: "close" }),
         ),
       )
     }
@@ -210,7 +188,7 @@ export const fromWebSocket = (
           catch: (error) =>
             transportError("sendText", error instanceof Error ? error.message : "Failed to send WebSocket message", {
               url: input.url,
-              operation: "write",
+              kind: "write",
             }),
         }),
       messages: Stream.fromQueue(messages),
@@ -265,8 +243,7 @@ export const json = <Body, Message>(input: JsonInput<Body, Message>): JsonTransp
       return Stream.fail(
         transportError("json", "WebSocket JSON transport requires WebSocketExecutor.Service", {
           url: prepared.url,
-          operation: "request",
-          code: "unavailable",
+          kind: "websocket",
         }),
       )
     }

packages/ai/src/schema/errors.ts

@@ -92,18 +92,10 @@ export class ProviderInternalReason extends Schema.Class<ProviderInternalReason>
   http: Schema.optional(HttpContext),
 }) {}
 
-export const TransportType = Schema.Literals(["http", "websocket"])
-export type TransportType = typeof TransportType.Type
-
-export const TransportOperation = Schema.Literals(["request", "read", "write"])
-export type TransportOperation = typeof TransportOperation.Type
-
 export class TransportReason extends Schema.Class<TransportReason>("AI.Error.Transport")({
   _tag: Schema.tag("Transport"),
   message: Schema.String,
-  transport: TransportType,
-  operation: TransportOperation,
-  code: Schema.optional(Schema.String),
+  kind: Schema.optional(Schema.String),
   url: Schema.optional(Schema.String),
   http: Schema.optional(HttpContext),
 }) {}

packages/ai/test/executor.test.ts

@@ -1,10 +1,10 @@
 import { describe, expect } from "bun:test"
-import { Effect, Layer, Ref, Stream } from "effect"
-import { Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { Effect, Layer, Ref } from "effect"
+import { Headers, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import { LLM, AIError } from "../src/index.js"
 import { LLMClient, RequestExecutor } from "../src/route.js"
 import * as OpenAIChat from "../src/protocols/openai-chat.js"
-import { dynamicResponse, systemError } from "./lib/http.js"
+import { dynamicResponse } from "./lib/http.js"
 import { deltaChunk } from "./lib/openai-chunks.js"
 import { sseRaw } from "./lib/sse.js"
 import { it } from "./lib/effect.js"
@@ -67,62 +67,6 @@ const expectAIError = (error: unknown) => {
 const errorHttp = (error: AIError) => ("http" in error.reason ? error.reason.http : undefined)
 
 describe("RequestExecutor", () => {
-  it.effect("parses response body failures at the executor seam", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* RequestExecutor.stream(executor, secretRequest).pipe(Stream.runDrain, Effect.flip)
-
-      expectAIError(error)
-      expect(error.reason).toMatchObject({
-        _tag: "Transport",
-        message: "ECONNRESET: disconnected <redacted> <redacted>",
-        transport: "http",
-        operation: "read",
-        code: "ECONNRESET",
-        url: "https://provider.test/v1/chat?api_key=%3Credacted%3E&debug=1",
-      })
-    }).pipe(
-      Effect.provide(
-        responsesLayer([
-          new Response(
-            new ReadableStream({
-              start(controller) {
-                controller.error(systemError("ECONNRESET", "disconnected query-secret-123 header-secret-456"))
-              },
-            }),
-          ),
-        ]),
-      ),
-    ),
-  )
-
-  it.effect("unwraps native transport failure causes", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* RequestExecutor.stream(executor, secretRequest).pipe(Stream.runDrain, Effect.flip)
-
-      expectAIError(error)
-      expect(error.reason).toMatchObject({
-        _tag: "Transport",
-        message: "ECONNRESET: socket closed",
-        operation: "read",
-        code: "ECONNRESET",
-      })
-    }).pipe(
-      Effect.provide(
-        responsesLayer([
-          new Response(
-            new ReadableStream({
-              pull(controller) {
-                controller.error(new TypeError("fetch failed", { cause: systemError("ECONNRESET", "socket closed") }))
-              },
-            }),
-          ),
-        ]),
-      ),
-    ),
-  )
-
   it.effect("preserves middleware error messages", () =>
     Effect.gen(function* () {
       const executor = yield* RequestExecutor.Service
@@ -135,48 +79,6 @@ describe("RequestExecutor", () => {
     }).pipe(Effect.provide(responsesLayer([]))),
   )
 
-  it.effect("reports the request sent by middleware", () =>
-    Effect.gen(function* () {
-      const executor = yield* RequestExecutor.Service
-      const error = yield* executor
-        .execute(request, (original, handler) =>
-          handler(
-            original.pipe(
-              HttpClientRequest.setUrl("https://proxy.test/v1/chat?api_key=proxy-secret"),
-              HttpClientRequest.setHeader("authorization", "Bearer proxy-secret"),
-            ),
-          ),
-        )
-        .pipe(Effect.flip)
-
-      expectAIError(error)
-      expect(error.reason).toMatchObject({
-        _tag: "Transport",
-        message: "ECONNRESET: proxy disconnected <redacted>",
-        url: "https://proxy.test/v1/chat?api_key=%3Credacted%3E",
-        http: {
-          request: {
-            url: "https://proxy.test/v1/chat?api_key=%3Credacted%3E",
-            headers: { authorization: "<redacted>" },
-          },
-        },
-      })
-    }).pipe(
-      Effect.provide(
-        dynamicResponse((input) =>
-          Effect.fail(
-            new HttpClientError.HttpClientError({
-              reason: new HttpClientError.TransportError({
-                request: input.request,
-                cause: systemError("ECONNRESET", "proxy disconnected proxy-secret"),
-              }),
-            }),
-          ),
-        ),
-      ),
-    ),
-  )
-
   it.effect("classifies context overflow responses", () =>
     Effect.gen(function* () {
       const executor = yield* RequestExecutor.Service

packages/ai/test/lib/http.ts

@@ -1,5 +1,5 @@
 import { Effect, Layer, Ref } from "effect"
-import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import { LLMClient, RequestExecutor, WebSocketExecutor } from "../../src/route.js"
 import type { Service as LLMClientService } from "../../src/route/client.js"
 import type { Service as RequestExecutorService } from "../../src/route/executor.js"
@@ -14,9 +14,7 @@ export type HandlerInput = {
   ) => HttpClientResponse.HttpClientResponse
 }
 
-export type Handler = (
-  input: HandlerInput,
-) => Effect.Effect<HttpClientResponse.HttpClientResponse, HttpClientError.HttpClientError>
+export type Handler = (input: HandlerInput) => Effect.Effect<HttpClientResponse.HttpClientResponse>
 
 const handlerLayer = (handler: Handler): Layer.Layer<HttpClient.HttpClient> =>
   Layer.succeed(
@@ -36,12 +34,6 @@ const handlerLayer = (handler: Handler): Layer.Layer<HttpClient.HttpClient> =>
 
 export type RuntimeEnv = RequestExecutorService | WebSocketExecutorService | LLMClientService
 
-export interface SystemError extends Error {
-  readonly code: string
-}
-
-export const systemError = (code: string, message: string): SystemError => Object.assign(new Error(message), { code })
-
 export const runtimeLayer = (layer: Layer.Layer<HttpClient.HttpClient>): Layer.Layer<RuntimeEnv> => {
   const requestExecutorLayer = RequestExecutor.layer.pipe(Layer.provide(layer))
   const deps = Layer.mergeAll(requestExecutorLayer, WebSocketExecutor.layer)
@@ -71,20 +63,14 @@ export const dynamicResponse = (handler: Handler) => runtimeLayer(handlerLayer(h
  * Layer that emits the supplied SSE chunks and then aborts mid-stream. Used to
  * exercise transport errors that surface during parsing.
  */
-export const truncatedStream = (chunks: ReadonlyArray<string>, error: Error = new Error("connection reset")) =>
+export const truncatedStream = (chunks: ReadonlyArray<string>) =>
   dynamicResponse((input) =>
     Effect.sync(() => {
       const encoder = new TextEncoder()
-      let index = 0
       const stream = new ReadableStream({
-        pull(controller) {
-          const chunk = chunks[index]
-          if (chunk !== undefined) {
-            index++
-            controller.enqueue(encoder.encode(chunk))
-            return
-          }
-          controller.error(error)
+        start(controller) {
+          for (const chunk of chunks) controller.enqueue(encoder.encode(chunk))
+          controller.error(new Error("connection reset"))
         },
       })
       return input.respond(stream, { headers: SSE_HEADERS })

packages/ai/test/provider/anthropic-messages.test.ts

@@ -271,47 +271,6 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("batches parallel tool results into one Anthropic user message", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.user("Check both cities."),
-            Message.assistant([
-              { type: "text", text: "I'll check both." },
-              ToolCallPart.make({ id: "call_paris", name: "weather", input: { city: "Paris" } }),
-              ToolCallPart.make({ id: "call_london", name: "weather", input: { city: "London" } }),
-            ]),
-            Message.tool({ id: "call_paris", name: "weather", result: { temperature: 22 } }),
-            Message.tool({ id: "call_london", name: "weather", result: { temperature: 18 } }),
-          ],
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body.messages).toMatchObject([
-        { role: "user", content: [{ type: "text", text: "Check both cities." }] },
-        {
-          role: "assistant",
-          content: [
-            { type: "text", text: "I'll check both." },
-            { type: "tool_use", id: "call_paris", name: "weather", input: { city: "Paris" } },
-            { type: "tool_use", id: "call_london", name: "weather", input: { city: "London" } },
-          ],
-        },
-        {
-          role: "user",
-          content: [
-            { type: "tool_result", tool_use_id: "call_paris", content: '{"temperature":22}' },
-            { type: "tool_result", tool_use_id: "call_london", content: '{"temperature":18}' },
-          ],
-        },
-      ])
-      expect(prepared.body.messages).toHaveLength(3)
-    }),
-  )
-
   it.effect("keeps tools and sends tool_choice none", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
@@ -956,54 +915,6 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("assembles and persists multiple tool calls from one Anthropic response", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              {
-                type: "content_block_start",
-                index: 0,
-                content_block: { type: "tool_use", id: "call_paris", name: "weather", input: {} },
-              },
-              {
-                type: "content_block_delta",
-                index: 0,
-                delta: { type: "input_json_delta", partial_json: '{"city":"Paris"}' },
-              },
-              { type: "content_block_stop", index: 0 },
-              {
-                type: "content_block_start",
-                index: 1,
-                content_block: { type: "tool_use", id: "call_london", name: "weather", input: {} },
-              },
-              {
-                type: "content_block_delta",
-                index: 1,
-                delta: { type: "input_json_delta", partial_json: '{"city":"London"}' },
-              },
-              { type: "content_block_stop", index: 1 },
-              { type: "message_delta", delta: { stop_reason: "tool_use" }, usage: { output_tokens: 2 } },
-              { type: "message_stop" },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.toolCalls).toMatchObject([
-        { id: "call_paris", name: "weather", input: { city: "Paris" } },
-        { id: "call_london", name: "weather", input: { city: "London" } },
-      ])
-      expect(response.message.content).toMatchObject([
-        { type: "tool-call", id: "call_paris", name: "weather", input: { city: "Paris" } },
-        { type: "tool-call", id: "call_london", name: "weather", input: { city: "London" } },
-      ])
-      expect(response.finishReason).toEqual({ normalized: "tool-calls", raw: "tool_use" })
-    }),
-  )
-
   it.effect("keeps malformed server tool input terminal", () =>
     Effect.gen(function* () {
       const body = sseEvents(

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

@@ -1,5 +1,5 @@
 import { describe, expect } from "bun:test"
-import { Effect, Ref, Schema, Stream } from "effect"
+import { Effect, Schema, Stream } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import {
   HttpOptions,
@@ -22,7 +22,7 @@ import { ProviderShared } from "../../src/protocols/shared.js"
 import { Auth, LLMClient } from "../../src/route.js"
 import { compileRequest } from "../../src/route/client.js"
 import { it } from "../lib/effect.js"
-import { dynamicResponse, fixedResponse, systemError, truncatedStream } from "../lib/http.js"
+import { dynamicResponse, fixedResponse, truncatedStream } from "../lib/http.js"
 import { deltaChunk, usageChunk } from "../lib/openai-chunks.js"
 import { sseEvents } from "../lib/sse.js"
 
@@ -1221,44 +1221,12 @@ describe("OpenAI Chat route", () => {
 
   it.effect("surfaces transport errors that occur mid-stream", () =>
     Effect.gen(function* () {
-      const layer = truncatedStream(
-        [`data: ${JSON.stringify(deltaChunk({ role: "assistant", content: "Hello" }))}\n\n`],
-        systemError("ECONNRESET", "socket closed unexpectedly"),
-      )
-      const events = yield* Ref.make<ReadonlyArray<LLMEvent>>([])
-      const error = yield* LLMClient.stream(request).pipe(
-        Stream.tap((event) => Ref.update(events, (current) => [...current, event])),
-        Stream.runDrain,
-        Effect.provide(layer),
-        Effect.flip,
-      )
+      const layer = truncatedStream([
+        `data: ${JSON.stringify(deltaChunk({ role: "assistant", content: "Hello" }))}\n\n`,
+      ])
+      const error = yield* LLMClient.generate(request).pipe(Effect.provide(layer), Effect.flip)
 
-      expect((yield* Ref.get(events)).some((event) => event.type === "text-delta")).toBeTrue()
-      expect(error.reason).toMatchObject({
-        _tag: "Transport",
-        message: "ECONNRESET: socket closed unexpectedly",
-        transport: "http",
-        operation: "read",
-        code: "ECONNRESET",
-        url: "https://api.openai.test/v1/chat/completions",
-      })
-    }),
-  )
-
-  it.effect("surfaces transport errors before the first stream frame", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(request).pipe(
-        Effect.provide(truncatedStream([], systemError("ECONNRESET", "socket closed before output"))),
-        Effect.flip,
-      )
-
-      expect(error.reason).toMatchObject({
-        _tag: "Transport",
-        message: "ECONNRESET: socket closed before output",
-        transport: "http",
-        operation: "read",
-        code: "ECONNRESET",
-      })
+      expect(error.message).toContain("Failed to read openai/openai-chat stream")
     }),
   )
 

packages/app/e2e/smoke/session-timeline.spec.ts

@@ -189,12 +189,7 @@ test.describe("smoke: session timeline", () => {
                 .querySelector<HTMLElement>('[data-timeline-row="bottom-spacer"]')
                 ?.getBoundingClientRect()
               samples.push({ ids: visible, last: visible.includes(last), bottomError: bottom?.bottom - view.bottom })
-              if (
-                !firstPaint &&
-                visible.includes(last) &&
-                Math.abs((bottom?.bottom ?? Infinity) - view.bottom) <= 1 &&
-                !root.querySelector('[data-markdown-key="initial"]')
-              ) {
+              if (!firstPaint && visible.includes(last) && Math.abs((bottom?.bottom ?? Infinity) - view.bottom) <= 1) {
                 firstPaint = true
                 root.querySelectorAll<HTMLElement>("[data-timeline-key]").forEach((row) => {
                   const rect = row.getBoundingClientRect()
@@ -209,16 +204,10 @@ test.describe("smoke: session timeline", () => {
         }
         ;(
           window as Window & {
-            __sessionTabPaint?: {
-              samples: typeof samples
-              painted: () => boolean
-              removed: () => number
-              stop: () => void
-            }
+            __sessionTabPaint?: { samples: typeof samples; removed: () => number; stop: () => void }
           }
         ).__sessionTabPaint = {
           samples,
-          painted: () => firstPaint,
           removed: () => removedFirstPaintNodes,
           stop: () => {
             running = false
@@ -230,19 +219,17 @@ test.describe("smoke: session timeline", () => {
     )
 
     await switchTitlebarSession(page, fixture.targetID, fixture.expected.targetTitle)
-    await page.waitForFunction(() => {
-      const probe = (
-        window as Window & { __sessionTabPaint?: { samples: Array<{ ids: string[] }>; painted: () => boolean } }
-      ).__sessionTabPaint
-      return probe?.painted() && probe.samples.some((sample) => sample.ids.length > 0)
-    })
+    await page.waitForFunction(() =>
+      (
+        window as Window & { __sessionTabPaint?: { samples: Array<{ ids: string[] }> } }
+      ).__sessionTabPaint?.samples.some((sample) => sample.ids.length > 0),
+    )
     await page.waitForTimeout(200)
     const first = await page.evaluate(() => {
       const probe = (
         window as Window & {
           __sessionTabPaint?: {
             samples: Array<{ ids: string[]; last: boolean; bottomError?: number }>
-            painted: () => boolean
             removed: () => number
             stop: () => void
           }

packages/cli/src/config/config.ts

@@ -1,8 +1,7 @@
 export * as Config from "./config"
 
 import { Global } from "@opencode-ai/util/global"
-import { Flock } from "@opencode-ai/util/flock"
-import { Context, Effect, FileSystem, Layer, Option, Schema } from "effect"
+import { Context, Effect, FileSystem, Layer, Option, Schema, Semaphore } from "effect"
 import { produce, type Draft } from "immer"
 import { applyEdits, modify, parse, type ParseError } from "jsonc-parser"
 import path from "path"
@@ -29,6 +28,7 @@ export const layer = Layer.effect(
     const fs = yield* FileSystem.FileSystem
     const global = yield* Global.Service
     const file = path.join(global.config, "cli.json")
+    const lock = yield* Semaphore.make(1)
 
     const readJson = Effect.fnUntraced(function* () {
       const text = yield* fs.readFileString(file).pipe(Effect.catch(() => Effect.succeed(undefined)))
@@ -49,60 +49,38 @@ export const layer = Layer.effect(
     const migrate = ConfigMigration.run({ file, config: global.config, state: global.state }).pipe(
       Effect.provideService(FileSystem.FileSystem, fs),
     )
-    const withLock = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-      Effect.scoped(
-        Effect.uninterruptibleMask((restore) =>
-          Effect.gen(function* () {
-            const lock = yield* restore(
-              Effect.promise((signal) => Flock.acquire(file, { dir: path.join(global.state, "locks"), signal })),
-            )
-            yield* Effect.addFinalizer(() => Effect.promise(() => lock.release()))
-            return yield* restore(effect)
-          }),
-        ),
-      )
 
-    const get = Effect.fn("cli.config.get")(() =>
-      withLock(
-        Effect.gen(function* () {
-          const migration = yield* migrate.pipe(
-            Effect.catchCause((cause) =>
-              Effect.logWarning("failed to migrate cli config", { cause }).pipe(Effect.as(undefined)),
-            ),
-          )
-          if (migration?.cause)
-            yield* Effect.logWarning("failed to persist migrated cli config", { cause: migration.cause })
-          if (migration?.info) return migration.info
-          return Option.getOrElse(decode(yield* readJson()), () => empty)
-        }),
-      ),
-    )
+    const get = Effect.fn("cli.config.get")(function* () {
+      yield* migrate.pipe(Effect.catchCause((cause) => Effect.logWarning("failed to migrate cli config", { cause })))
+      return Option.getOrElse(decode(yield* readJson()), () => empty)
+    })
 
     const update = Effect.fn("cli.config.update")((update: (draft: Draft<Info>) => void) =>
-      withLock(
-        Effect.gen(function* () {
-          const migration = yield* migrate
-          if (migration?.cause) return yield* Effect.failCause(migration.cause)
-          const current = migration?.info ?? Option.getOrElse(decode(yield* readJson()), () => empty)
-          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 updated = edits.reduce(
-            (text, edit) =>
-              applyEdits(
-                text,
-                modify(text, edit.path, edit.value, { formattingOptions: { tabSize: 2, insertSpaces: true } }),
-              ),
-            text,
-          )
-          const errors: ParseError[] = []
-          const config = Option.getOrUndefined(decode(parse(updated, errors, { allowTrailingComma: true })))
-          if (errors.length || config === undefined) return yield* Effect.fail(new Error("Invalid CLI config update"))
-          yield* write(updated.endsWith("\n") ? updated : updated + "\n")
-          return config
-        }),
-      ).pipe(Effect.mapError((cause) => new Error("Failed to update CLI config", { cause }))),
+      lock
+        .withPermits(1)(
+          Effect.gen(function* () {
+            yield* migrate
+            const current = Option.getOrElse(decode(yield* readJson()), () => empty)
+            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 updated = edits.reduce(
+              (text, edit) =>
+                applyEdits(
+                  text,
+                  modify(text, edit.path, edit.value, { formattingOptions: { tabSize: 2, insertSpaces: true } }),
+                ),
+              text,
+            )
+            const errors: ParseError[] = []
+            const config = Option.getOrUndefined(decode(parse(updated, errors, { allowTrailingComma: true })))
+            if (errors.length || config === undefined) return yield* Effect.fail(new Error("Invalid CLI config update"))
+            yield* write(updated.endsWith("\n") ? updated : updated + "\n")
+            return config
+          }),
+        )
+        .pipe(Effect.mapError((cause) => new Error("Failed to update CLI config", { cause }))),
     )
 
     return Service.of({ path: file, get, update })

packages/cli/src/config/migrate.ts

@@ -1,18 +1,13 @@
 export * as ConfigMigration from "./migrate"
 
 import { TuiConfigV1 } from "@opencode-ai/tui/config/v1"
-import { TuiKeybind } from "@opencode-ai/tui/config/v1/keybind"
-import { Definitions } from "@opencode-ai/tui/config/keybind"
 import { Effect, FileSystem, Option, Schema } from "effect"
-import { randomUUID } from "crypto"
-import { createScanner, parse, parseTree, type Node, type ParseError } from "jsonc-parser"
+import { parse, type ParseError } from "jsonc-parser"
 import path from "path"
-import { Info } from "./schema"
+import type { Info } from "./schema"
 
 const decodeV1 = Schema.decodeUnknownOption(TuiConfigV1.Info)
-const decodeInfo = Schema.decodeUnknownOption(Info)
 const decodeRecord = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema.Any))
-const LegacyKeybindTargets = new Set<string>(Object.values(TuiKeybind.CommandMap))
 
 export const run = Effect.fn("cli.config.migrate")(function* (input: {
   readonly file: string
@@ -20,60 +15,7 @@ export const run = Effect.fn("cli.config.migrate")(function* (input: {
   readonly state: string
 }) {
   const fs = yield* FileSystem.FileSystem
-  const persist = Effect.fnUntraced(function* (text: string, info: Info) {
-    const temp = `${input.file}.${process.pid}.${randomUUID()}.tmp`
-    const cause = yield* Effect.gen(function* () {
-      yield* fs.makeDirectory(path.dirname(input.file), { recursive: true })
-      yield* fs.writeFileString(temp, text, { mode: 0o600 })
-      yield* fs.rename(temp, input.file)
-    }).pipe(
-      Effect.as(undefined),
-      Effect.catchCause((cause) => Effect.succeed(cause)),
-      Effect.ensuring(fs.remove(temp).pipe(Effect.ignore)),
-    )
-    return cause === undefined ? { info } : { info, cause }
-  })
-
-  if (yield* fs.exists(input.file).pipe(Effect.orElseSucceed(() => false))) {
-    const text = yield* fs.readFileString(input.file)
-    const errors: ParseError[] = []
-    const value: any = parse(text, errors, { allowTrailingComma: true })
-    if (errors.length) return
-    const config = Option.getOrUndefined(decodeRecord(value))
-    if (config === undefined) return
-    const keybinds = Option.getOrUndefined(decodeRecord(config.keybinds))
-    if (keybinds === undefined) return
-    const deduped = findKeybindObjects(text)
-      .slice(0, -1)
-      .reduce((text) => {
-        const property = findKeybindObjects(text)[0]
-        return property === undefined ? text : removeProperty(text, property)
-      }, text)
-    const updated = Object.keys(keybinds).reduce((text, name) => {
-      const target =
-        TuiKeybind.CommandMap[name as keyof typeof TuiKeybind.CommandMap] ??
-        (name in Definitions || LegacyKeybindTargets.has(name) ? name : undefined)
-      if (target === undefined) return text
-      const properties = findKeybindProperties(text, name)
-      if (!properties.length) return text
-      const remove = !(target in Definitions) || (target !== name && target in keybinds)
-      // The parser gives the final duplicate precedence, so remove earlier properties before renaming it.
-      const updated = properties.slice(0, remove ? properties.length : -1).reduce((text) => {
-        const property = findKeybindProperties(text, name)[0]
-        return property === undefined ? text : removeProperty(text, property)
-      }, text)
-      if (remove) return updated
-      if (target === name) return updated
-      const key = findKeybindProperties(updated, name)[0]?.children?.[0]
-      if (key === undefined) return text
-      return updated.slice(0, key.offset) + JSON.stringify(target) + updated.slice(key.offset + key.length)
-    }, deduped)
-    if (updated === text) return
-    const updatedErrors: ParseError[] = []
-    const info = Option.getOrUndefined(decodeInfo(parse(updated, updatedErrors, { allowTrailingComma: true })))
-    if (updatedErrors.length || info === undefined) return
-    return yield* persist(updated, info)
-  }
+  if (yield* fs.exists(input.file).pipe(Effect.orElseSucceed(() => false))) return
 
   const legacyValue = yield* readJson(path.join(input.config, "tui.json"))
   const legacy = Option.getOrUndefined(decodeV1(legacyValue))
@@ -81,59 +23,19 @@ export const run = Effect.fn("cli.config.migrate")(function* (input: {
   const migrated = migrateV1(legacy, kv ?? {})
   if (!Object.keys(migrated).length) return
 
-  const result = yield* persist(JSON.stringify(migrated, null, 2) + "\n", migrated)
-  if (result.cause === undefined)
-    yield* Effect.logInfo("migrated cli config", {
-      from: [
-        legacyValue === undefined ? undefined : path.join(input.config, "tui.json"),
-        kv === undefined ? undefined : path.join(input.state, "kv.json"),
-      ].filter(Boolean),
-      to: input.file,
-    })
-  return result
+  const temp = input.file + ".tmp"
+  yield* fs.makeDirectory(path.dirname(input.file), { recursive: true })
+  yield* fs.writeFileString(temp, JSON.stringify(migrated, null, 2) + "\n", { mode: 0o600 })
+  yield* fs.rename(temp, input.file)
+  yield* Effect.logInfo("migrated cli config", {
+    from: [
+      legacyValue === undefined ? undefined : path.join(input.config, "tui.json"),
+      kv === undefined ? undefined : path.join(input.state, "kv.json"),
+    ].filter(Boolean),
+    to: input.file,
+  })
 })
 
-function findKeybindProperties(text: string, name: string) {
-  const keybinds = findKeybindObjects(text).at(-1)?.children?.[1]
-  return keybinds?.children?.filter((property) => property.children?.[0]?.value === name) ?? []
-}
-
-function findKeybindObjects(text: string) {
-  const tree = parseTree(text)
-  if (tree === undefined) return []
-  return tree.children?.filter((property) => property.children?.[0]?.value === "keybinds") ?? []
-}
-
-function removeProperty(text: string, property: Node) {
-  const properties = property.parent?.children ?? []
-  const index = properties.indexOf(property)
-  const end = property.offset + property.length
-  const next = properties[index + 1]
-  if (next) {
-    const comma = findComma(text, end, next.offset)
-    if (comma !== undefined) return text.slice(0, property.offset) + text.slice(end, comma) + text.slice(comma + 1)
-  }
-  const previous = properties[index - 1]
-  if (previous) {
-    const comma = findComma(text, previous.offset + previous.length, property.offset)
-    if (comma !== undefined) return text.slice(0, comma) + text.slice(comma + 1, property.offset) + text.slice(end)
-  }
-  const comma = findComma(text, end, (property.parent?.offset ?? 0) + (property.parent?.length ?? 0))
-  if (comma !== undefined) return text.slice(0, property.offset) + text.slice(end, comma) + text.slice(comma + 1)
-  return text.slice(0, property.offset) + text.slice(end)
-}
-
-function findComma(text: string, start: number, end: number) {
-  const scanner = createScanner(text, false)
-  scanner.setPosition(start)
-  while (true) {
-    scanner.scan()
-    const offset = scanner.getTokenOffset()
-    if (scanner.getTokenLength() === 0 || offset >= end) return
-    if (text[offset] === ",") return offset
-  }
-}
-
 export function migrateV1(legacy: TuiConfigV1.Info | undefined, kv: Record<string, any>): Info {
   const plugins = [
     ...(legacy?.plugin?.map((plugin) =>
@@ -147,16 +49,6 @@ export function migrateV1(legacy: TuiConfigV1.Info | undefined, kv: Record<strin
   const diffView = kv.diff_viewer_view ?? (legacy?.diff_style === "stacked" ? "unified" : undefined)
   const thinking =
     kv.thinking_mode ?? (kv.thinking_visibility === undefined ? undefined : kv.thinking_visibility ? "show" : "hide")
-  const keybinds =
-    legacy?.keybinds === undefined
-      ? undefined
-      : Object.fromEntries(
-          Object.entries(legacy.keybinds).flatMap(([name, value]) => {
-            const target = TuiKeybind.CommandMap[name as keyof typeof TuiKeybind.CommandMap] ?? name
-            if (!(target in Definitions)) return []
-            return [[target, value]]
-          }),
-        )
 
   return {
     ...(themeName !== undefined || themeMode !== undefined
@@ -167,7 +59,7 @@ export function migrateV1(legacy: TuiConfigV1.Info | undefined, kv: Record<strin
           },
         }
       : {}),
-    ...(keybinds === undefined ? {} : { keybinds }),
+    ...(legacy?.keybinds === undefined ? {} : { keybinds: legacy.keybinds }),
     ...(plugins.length ? { plugins } : {}),
     ...(legacy?.leader_timeout === undefined ? {} : { leader: { timeout: legacy.leader_timeout } }),
     ...(legacy?.scroll_speed === undefined && legacy?.scroll_acceleration?.enabled === undefined

packages/cli/test/config.test.ts

@@ -1,9 +1,7 @@
 import { NodeFileSystem } from "@effect/platform-node"
-import { Flock } from "@opencode-ai/util/flock"
 import { Global } from "@opencode-ai/util/global"
-import { Effect, FileSystem, Option } from "effect"
+import { Effect } from "effect"
 import { expect, test } from "bun:test"
-import { parse } from "jsonc-parser"
 import path from "path"
 import { Config } from "../src/config"
 
@@ -23,14 +21,7 @@ test("migrates tui and kv config into cli.json", async () => {
     path.join(directory, "tui.json"),
     JSON.stringify({
       theme: "legacy",
-      keybinds: {
-        leader: "ctrl+o",
-        app_exit: "ctrl+q",
-        app_heap_snapshot: "ctrl+h",
-        input_paste: { key: "ctrl+v", preventDefault: false },
-        session_delete: false,
-        "dialog.select.next": "ctrl+n",
-      },
+      keybinds: { leader: "ctrl+o" },
       plugin: [["example", { mode: "safe" }]],
       plugin_enabled: { disabled: false },
       leader_timeout: 500,
@@ -74,13 +65,7 @@ test("migrates tui and kv config into cli.json", async () => {
 
     expect(config).toMatchObject({
       theme: { name: "legacy", mode: "light" },
-      keybinds: {
-        leader: "ctrl+o",
-        "app.exit": "ctrl+q",
-        "prompt.paste": { key: "ctrl+v", preventDefault: false },
-        "session.delete": false,
-        "dialog.select.next": "ctrl+n",
-      },
+      keybinds: { leader: "ctrl+o" },
       plugins: [{ package: "example", options: { mode: "safe" } }, "-disabled"],
       leader: { timeout: 500 },
       scroll: { speed: 2, acceleration: true },
@@ -95,13 +80,7 @@ test("migrates tui and kv config into cli.json", async () => {
     expect(config).not.toHaveProperty("skipped_version")
     expect(config).not.toHaveProperty("which_key")
     expect(config).not.toHaveProperty("hints")
-    expect((await Bun.file(path.join(directory, "cli.json")).json()).keybinds).toEqual({
-      leader: "ctrl+o",
-      "app.exit": "ctrl+q",
-      "prompt.paste": { key: "ctrl+v", preventDefault: false },
-      "session.delete": false,
-      "dialog.select.next": "ctrl+n",
-    })
+    expect((await Bun.file(path.join(directory, "cli.json")).json()).keybinds).toEqual({ leader: "ctrl+o" })
     expect(await Bun.file(path.join(directory, "cli.json")).exists()).toBe(true)
     expect(await Bun.file(path.join(directory, "tui.json")).exists()).toBe(true)
     expect(await Bun.file(path.join(directory, "kv.json")).exists()).toBe(true)
@@ -162,257 +141,6 @@ test("preserves legacy cursor settings", async () => {
   }
 })
 
-test("migrates legacy keybind names in an existing cli.json", async () => {
-  const directory = await Bun.$`mktemp -d`.text().then((value) => value.trim())
-  const file = path.join(directory, "cli.json")
-  await Bun.write(
-    file,
-    `{
-  // Preserve this comment
-  "keybinds": {
-    // Session list shortcut
-    "session_list": "ctrl+l",
-    "app_heap_snapshot": "ctrl+h",
-    // Legacy delete shortcut
-    "session_delete": "ctrl+d",
-    // Canonical delete shortcut
-    "session.delete": "ctrl+x",
-    "app.heap_snapshot": "ctrl+shift+h"
-  }
-}
-`,
-  )
-
-  try {
-    const config = await run(
-      directory,
-      Effect.gen(function* () {
-        const service = yield* Config.Service
-        return yield* service.get()
-      }),
-    )
-
-    expect(config.keybinds).toEqual({
-      "session.list": "ctrl+l",
-      "session.delete": "ctrl+x",
-    })
-    const text = await Bun.file(file).text()
-    expect(text).toContain("// Preserve this comment")
-    expect(text).toContain("// Session list shortcut")
-    expect(text).toContain("// Legacy delete shortcut")
-    expect(text).toContain("// Canonical delete shortcut")
-    expect(parse(text).keybinds).toEqual({
-      "session.list": "ctrl+l",
-      "session.delete": "ctrl+x",
-    })
-  } finally {
-    await Bun.$`rm -rf ${directory}`
-  }
-})
-
-test("uses migrated keybinds when persistence fails", async () => {
-  const directory = await Bun.$`mktemp -d`.text().then((value) => value.trim())
-  const file = path.join(directory, "cli.json")
-  await Bun.write(file, `{"keybinds":{"session_list":"ctrl+l"}}`)
-  const node = await Effect.runPromise(FileSystem.FileSystem.pipe(Effect.provide(NodeFileSystem.layer)))
-  const fs = new Proxy(node, {
-    get(target, property, receiver) {
-      if (property === "rename") return () => Effect.die(new Error("read-only config"))
-      return Reflect.get(target, property, receiver)
-    },
-  })
-
-  try {
-    const config = await Effect.runPromise(
-      Effect.gen(function* () {
-        const service = yield* Config.Service
-        return yield* service.get()
-      }).pipe(
-        Effect.provide(Config.layer),
-        Effect.provide(Global.layerWith({ config: directory, state: directory })),
-        Effect.provideService(FileSystem.FileSystem, fs),
-      ),
-    )
-
-    expect(config.keybinds).toEqual({ "session.list": "ctrl+l" })
-    expect(await Bun.file(file).json()).toEqual({ keybinds: { session_list: "ctrl+l" } })
-    expect(await Array.fromAsync(new Bun.Glob("*.tmp").scan(directory))).toEqual([])
-  } finally {
-    await Bun.$`rm -rf ${directory}`
-  }
-})
-
-test("preserves the effective value when migrating duplicate legacy keybinds", async () => {
-  const directory = await Bun.$`mktemp -d`.text().then((value) => value.trim())
-  const file = path.join(directory, "cli.json")
-  await Bun.write(file, `{"keybinds":{"session_delete":"ctrl+a","session_delete":"ctrl+b"}}`)
-
-  try {
-    const config = await run(
-      directory,
-      Effect.gen(function* () {
-        const service = yield* Config.Service
-        return yield* service.get()
-      }),
-    )
-
-    expect(config.keybinds).toEqual({ "session.delete": "ctrl+b" })
-    expect(parse(await Bun.file(file).text()).keybinds).toEqual({ "session.delete": "ctrl+b" })
-  } finally {
-    await Bun.$`rm -rf ${directory}`
-  }
-})
-
-test("migrates and updates the effective duplicate top-level keybinds", async () => {
-  const directory = await Bun.$`mktemp -d`.text().then((value) => value.trim())
-  const file = path.join(directory, "cli.json")
-  await Bun.write(file, `{"keybinds":{"session_delete":"first"},"keybinds":{"session_delete":"last"}}`)
-
-  try {
-    const config = await run(
-      directory,
-      Effect.gen(function* () {
-        const service = yield* Config.Service
-        expect((yield* service.get()).keybinds).toEqual({ "session.delete": "last" })
-        return yield* service.update((draft) => {
-          draft.keybinds = { ...draft.keybinds, "session.delete": "changed" }
-        })
-      }),
-    )
-
-    expect(config.keybinds).toEqual({ "session.delete": "changed" })
-    expect(parse(await Bun.file(file).text()).keybinds).toEqual({ "session.delete": "changed" })
-  } finally {
-    await Bun.$`rm -rf ${directory}`
-  }
-})
-
-test("serializes migration and updates across processes", async () => {
-  const directory = await Bun.$`mktemp -d`.text().then((value) => value.trim())
-  const file = path.join(directory, "cli.json")
-  const started = path.join(directory, "started")
-  const release = path.join(directory, "release")
-  const migrateReady = path.join(directory, "migrate-ready")
-  const updateReady = path.join(directory, "update-ready")
-  await Bun.write(file, `{"keybinds":{"session_delete":"ctrl+d"}}`)
-  const worker = path.join(import.meta.dir, "fixture/config-concurrency.ts")
-  const migrate = Bun.spawn([process.execPath, worker, "migrate", directory, started, release, migrateReady], {
-    stdout: "ignore",
-    stderr: "pipe",
-  })
-
-  try {
-    await waitForFile(started, migrate.exited)
-    const update = Bun.spawn([process.execPath, worker, "update", directory, started, release, updateReady], {
-      stdout: "ignore",
-      stderr: "pipe",
-    })
-    try {
-      await waitForFile(updateReady, update.exited)
-      expect(await Promise.race([update.exited.then(() => true), Bun.sleep(500).then(() => false)])).toBe(false)
-      await Bun.write(release, "")
-      const [migrateCode, updateCode] = await Promise.all([migrate.exited, update.exited])
-      expect(await new Response(migrate.stderr).text()).toBe("")
-      expect(await new Response(update.stderr).text()).toBe("")
-      expect([migrateCode, updateCode]).toEqual([0, 0])
-      expect(await Bun.file(file).json()).toEqual({ keybinds: { "session.delete": "ctrl+d" }, mouse: false })
-    } finally {
-      update.kill()
-      await update.exited
-    }
-  } finally {
-    await Bun.write(release, "")
-    migrate.kill()
-    await migrate.exited
-    await Bun.$`rm -rf ${directory}`
-  }
-})
-
-test("config reads remain interruptible while waiting for the file lock", async () => {
-  const directory = await Bun.$`mktemp -d`.text().then((value) => value.trim())
-  const file = path.join(directory, "cli.json")
-  const locks = path.join(directory, "locks")
-  const held = await Flock.acquire(file, { dir: locks })
-
-  try {
-    const service = await Effect.runPromise(
-      Config.Service.pipe(
-        Effect.provide(Config.layer),
-        Effect.provide(Global.layerWith({ config: directory, state: directory })),
-        Effect.provide(NodeFileSystem.layer),
-      ),
-    )
-    const result = Effect.runPromise(service.get().pipe(Effect.timeoutOption("50 millis")))
-    expect(await Promise.race([result, Bun.sleep(250).then(() => "blocked" as const)])).toEqual(Option.none())
-  } finally {
-    await held.release()
-    await Bun.$`rm -rf ${directory}`
-  }
-})
-
-test("updates effective duplicate canonical keybinds", async () => {
-  const directory = await Bun.$`mktemp -d`.text().then((value) => value.trim())
-  const file = path.join(directory, "cli.json")
-  await Bun.write(
-    file,
-    `{"keybinds":{"session.delete":"first","session.delete":"last","permission.mode":"off","permission.mode":"on"}}`,
-  )
-
-  try {
-    const config = await run(
-      directory,
-      Effect.gen(function* () {
-        const service = yield* Config.Service
-        expect((yield* service.get()).keybinds).toEqual({ "session.delete": "last", "permission.mode": "on" })
-        return yield* service.update((draft) => {
-          draft.keybinds = { ...draft.keybinds, "session.delete": "changed", "permission.mode": "changed" }
-        })
-      }),
-    )
-
-    expect(config.keybinds).toEqual({ "session.delete": "changed", "permission.mode": "changed" })
-    expect(parse(await Bun.file(file).text()).keybinds).toEqual({
-      "session.delete": "changed",
-      "permission.mode": "changed",
-    })
-  } finally {
-    await Bun.$`rm -rf ${directory}`
-  }
-})
-
-test("removes orphaned keybinds without deleting trailing comments", async () => {
-  const directory = await Bun.$`mktemp -d`.text().then((value) => value.trim())
-  const file = path.join(directory, "cli.json")
-  await Bun.write(
-    file,
-    `{
-  "keybinds": {
-    "app_heap_snapshot": "ctrl+h" /* Keep legacy explanation */,
-    "app.heap_snapshot": "ctrl+shift+h" /* Keep canonical explanation */,
-  },
-}
-`,
-  )
-
-  try {
-    const config = await run(
-      directory,
-      Effect.gen(function* () {
-        const service = yield* Config.Service
-        return yield* service.get()
-      }),
-    )
-
-    expect(config.keybinds).toEqual({})
-    const text = await Bun.file(file).text()
-    expect(text).toContain("/* Keep legacy explanation */")
-    expect(text).toContain("/* Keep canonical explanation */")
-    expect(parse(text).keybinds).toEqual({})
-  } finally {
-    await Bun.$`rm -rf ${directory}`
-  }
-})
-
 test("updates a config draft while preserving JSONC comments", async () => {
   const directory = await Bun.$`mktemp -d`.text().then((value) => value.trim())
   await Bun.write(path.join(directory, "cli.json"), '{\n  // Keep this comment\n  "animations": true\n}\n')
@@ -439,15 +167,3 @@ test("updates a config draft while preserving JSONC comments", async () => {
     await Bun.$`rm -rf ${directory}`
   }
 })
-
-async function waitForFile(file: string, exited: Promise<number>) {
-  const found = await Promise.race([
-    (async () => {
-      while (!(await Bun.file(file).exists())) await Bun.sleep(10)
-      return true
-    })(),
-    exited.then(() => false),
-    Bun.sleep(5000).then(() => false),
-  ])
-  if (!found) throw new Error(`timed out waiting for ${file}`)
-}

packages/cli/test/fixture/config-concurrency.ts

@@ -1,42 +0,0 @@
-import { NodeFileSystem } from "@effect/platform-node"
-import { Global } from "@opencode-ai/util/global"
-import { Effect, FileSystem } from "effect"
-import { Config } from "../../src/config"
-
-const [mode, directory, started, release, ready] = process.argv.slice(2)
-if (!mode || !directory || !started || !release || !ready) throw new Error("missing config concurrency arguments")
-if (mode !== "migrate" && mode !== "update") throw new Error(`unknown mode: ${mode}`)
-
-const node = await Effect.runPromise(FileSystem.FileSystem.pipe(Effect.provide(NodeFileSystem.layer)))
-const state = { writes: 0 }
-const writeFileString: FileSystem.FileSystem["writeFileString"] = (target, data, options) => {
-  state.writes++
-  if (mode !== "migrate" || state.writes !== 1) return node.writeFileString(target, data, options)
-  return Effect.gen(function* () {
-    yield* Effect.promise(() => Bun.write(started, ""))
-    while (!(yield* Effect.promise(() => Bun.file(release).exists()))) yield* Effect.sleep("10 millis")
-    yield* node.writeFileString(target, data, options)
-  })
-}
-const fs = new Proxy(node, {
-  get(target, property, receiver) {
-    if (property === "writeFileString") return writeFileString
-    return Reflect.get(target, property, receiver)
-  },
-})
-const service = await Effect.runPromise(
-  Config.Service.pipe(
-    Effect.provide(Config.layer),
-    Effect.provide(Global.layerWith({ config: directory, state: directory })),
-    Effect.provideService(FileSystem.FileSystem, fs),
-  ),
-)
-
-await Bun.write(ready, "")
-if (mode === "migrate") await Effect.runPromise(service.get())
-if (mode === "update")
-  await Effect.runPromise(
-    service.update((draft) => {
-      draft.mouse = false
-    }),
-  )

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

@@ -1,69 +0,0 @@
-import { NodeFileSystem } from "@effect/platform-node"
-import { Global } from "@opencode-ai/util/global"
-import { Effect, Option } from "effect"
-import { expect, mock, test } from "bun:test"
-import { mkdir, rm } from "node:fs/promises"
-import path from "node:path"
-import { Config } from "../src/config"
-import type { MiniCommandInput } from "../src/mini"
-import { OPENCODE_VERSION } from "../src/version"
-
-test("mini handler passes resolved CLI keybinds to the runtime", async () => {
-  const root = await Bun.$`mktemp -d`.text().then((value) => value.trim())
-  const configDirectory = path.join(root, "config")
-  const stateDirectory = path.join(root, "state")
-  await mkdir(configDirectory, { recursive: true })
-  await Bun.write(
-    path.join(configDirectory, "cli.json"),
-    JSON.stringify({
-      keybinds: { "composer.subagent.interrupt": "ctrl+i" },
-      leader: { timeout: 321 },
-    }),
-  )
-  let received: MiniCommandInput["tuiConfig"]
-  const mini = await import("../src/mini")
-  mock.module("../src/mini", () => ({
-    ...mini,
-    validateMiniTerminal() {},
-    runMini(input: Pick<MiniCommandInput, "tuiConfig">) {
-      received = input.tuiConfig
-      return Promise.resolve()
-    },
-  }))
-  const handler = (await import("../src/commands/handlers/mini")).default
-  const server = Bun.serve({
-    port: 0,
-    fetch: () => Response.json({ healthy: true, version: OPENCODE_VERSION, pid: process.pid }),
-  })
-
-  try {
-    await Effect.runPromise(
-      handler({
-        server: Option.some(server.url.toString()),
-        standalone: false,
-        continue: false,
-        session: Option.none(),
-        fork: false,
-        replay: true as never,
-        replayLimit: Option.none(),
-        model: Option.none(),
-        agent: Option.none(),
-        prompt: Option.none(),
-        demo: false,
-      }).pipe(
-        Effect.provide(Config.layer),
-        Effect.provide(Global.layerWith({ config: configDirectory, state: stateDirectory })),
-        Effect.provide(NodeFileSystem.layer),
-        Effect.scoped,
-      ),
-    )
-
-    const config = await received
-    expect(config?.leader.timeout).toBe(321)
-    expect(config?.keybinds.get("composer.subagent.interrupt")).toMatchObject([{ key: "ctrl+i" }])
-  } finally {
-    server.stop(true)
-    mock.restore()
-    await rm(root, { recursive: true, force: true })
-  }
-})

packages/client/src/effect/service.ts

@@ -10,7 +10,6 @@ import {
   spawnServiceContender,
 } from "../service-contender.js"
 import { defaultEnsureTiming, ensureTiming, type EnsureTiming } from "../service-timing.js"
-import { matchesVersion } from "../service-version.js"
 
 export * from "../service.js"
 /** Contents of the local service registration file. */
@@ -38,14 +37,14 @@ export const incumbent = Effect.fn("service.incumbent")(function* (
   const info = yield* read(options.file)
   const found = info === undefined ? undefined : yield* probe({ ...info, url: options.url })
   if (found === undefined || found.legacy) return undefined
-  if (!matchesVersion(found.version, options)) return undefined
+  if (options.version !== undefined && found.version !== options.version) return undefined
   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
+  if (options.version !== undefined && found.version !== options.version) return undefined
   return found
 })
 
@@ -94,7 +93,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
     } else timeouts = undefined
     if (service !== undefined) {
       spawnDelay = timing.spawnDelay
-      const compatible = !service.legacy && matchesVersion(service.version, options)
+      const compatible = !service.legacy && (options.version === undefined || service.version === options.version)
       if (compatible && service.state === "ready") return Option.some(service)
       if (compatible && service.state === "failed")
         return yield* Effect.fail(new Error("Background service failed to start"))

packages/client/src/promise/service.ts

@@ -9,7 +9,6 @@ import {
   spawnServiceContender,
 } from "../service-contender.js"
 import { defaultEnsureTiming, ensureTiming, type EnsureTiming } from "../service-timing.js"
-import { matchesVersion } from "../service-version.js"
 import type { ServiceHealth, ServiceStopResponse } from "./generated/types.js"
 
 export * from "../service.js"
@@ -28,7 +27,7 @@ export async function discover(options: DiscoverOptions = {}) {
 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
+  if (options.version !== undefined && found.version !== options.version) return undefined
   return found
 }
 
@@ -77,7 +76,7 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
       if (registration.service !== undefined) {
         spawnDelay = timing.spawnDelay
         const service = registration.service
-        const compatible = !service.legacy && matchesVersion(service.version, options)
+        const compatible = !service.legacy && (options.version === undefined || service.version === options.version)
         if (compatible && service.state === "ready") return service.endpoint
         if (compatible && service.state === "failed") throw new Error("Background service failed to start")
         if (!compatible) {

packages/client/src/service-version.ts

@@ -1,8 +0,0 @@
-import type { DiscoverOptions } from "./service.js"
-
-export function matchesVersion(version: string | undefined, options: DiscoverOptions) {
-  if (options.version === undefined) return true
-  if (version === undefined) return false
-  if (typeof options.version === "function") return options.version(version)
-  return version === options.version
-}

packages/client/src/service.ts

@@ -17,8 +17,8 @@ export type Endpoint = {
 export type DiscoverOptions = {
   /** Absolute registration file path. Defaults to the XDG state directory. */
   readonly file?: string
-  /** Required exact service version or compatibility predicate. */
-  readonly version?: string | ((version: string) => boolean)
+  /** Required service version. */
+  readonly version?: string
 }
 
 /** Reason ensuring the service requires a new process. */

packages/client/test/api.types.ts

@@ -1,7 +1,6 @@
 import { Effect } from "effect"
 import { OpenCode as EffectOpenCode, type AppApi as EffectApi } from "../src/effect"
 import type { Session } from "@opencode-ai/schema/session"
-import type { DiscoverOptions } from "../src/service"
 
 type EffectClient = Effect.Success<ReturnType<typeof EffectOpenCode.make>>
 type PromiseClient = ReturnType<typeof import("../src/promise").OpenCode.make>
@@ -9,9 +8,6 @@ type PromiseClient = ReturnType<typeof import("../src/promise").OpenCode.make>
 declare const effectClient: EffectClient
 declare const promiseClient: PromiseClient
 
-const exactVersion: DiscoverOptions = { version: "2.0.0" }
-const compatibleVersion: DiscoverOptions = { version: (version) => version.startsWith("2.") }
-
 const effectApi: EffectApi<unknown> = effectClient
 
 const effectSession: Effect.Effect<Session.Info, unknown> = effectClient.session.get({
@@ -46,14 +42,4 @@ const promiseRemove: Promise<void> = promiseClient.session.instructions.entry.re
   key: "review-notes",
 })
 
-void [
-  effectSession,
-  effectList,
-  effectPut,
-  effectRemove,
-  promiseList,
-  promisePut,
-  promiseRemove,
-  exactVersion,
-  compatibleVersion,
-]
+void [effectSession, effectList, effectPut, effectRemove, promiseList, promisePut, promiseRemove]

packages/client/test/fixture/service.ts

@@ -27,10 +27,7 @@ if (mode === "delayed" || mode === "delayed-failed" || mode === "coordinated" ||
 }
 
 let requests = 0
-let version = "test"
-if (mode === "old" || mode === "reject-stop") version = "old"
-if (mode === "incompatible") version = "1.9.0"
-if (mode === "compatible" || mode === "delayed-compatible") version = "2.1.0-next.1"
+const version = mode === "old" || mode === "reject-stop" ? "old" : "test"
 const id = crypto.randomUUID()
 const server = Bun.serve({
   port: 0,

packages/client/test/promise-service.test.ts

@@ -25,19 +25,6 @@ test("discovers a registered service", async () => {
   expect(await Service.discover({ file: registration, version: "other" })).toBeUndefined()
 })
 
-test("discovers a compatible registered service", async () => {
-  const registration = await setup("compatible")
-
-  expect(await Service.discover({ file: registration, version: "2.1.0" })).toBeUndefined()
-  expect(await Service.discover({ file: registration, version: "2.1.0-next.1" })).toEqual(
-    expect.objectContaining({ url: expect.stringMatching(/^http:\/\//) }),
-  )
-  expect(await Service.discover({ file: registration, version: (version) => version.startsWith("2.") })).toEqual(
-    expect.objectContaining({ url: expect.stringMatching(/^http:\/\//) }),
-  )
-  expect(await Service.discover({ file: registration, version: (version) => version.startsWith("3.") })).toBeUndefined()
-})
-
 test("ensures a missing service with native promises", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")

packages/client/test/service.test.ts

@@ -47,52 +47,6 @@ test("a concurrent same-version start cannot invalidate a resolved endpoint", as
   expect(await health(resolved.url)).toEqual({ healthy: true, version: "test", pid: original.pid })
 })
 
-test("reuses a compatible registered service", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  const existing = spawn(registration, "compatible")
-  await waitForFile(registration)
-
-  const starts: EnsureReason[] = []
-  const endpoint = await run(
-    ensure({
-      file: registration,
-      version: (version) => version.startsWith("2."),
-      command: [],
-      onStart: (reason) => starts.push(reason),
-    }),
-  )
-
-  expect(endpoint.url).toBe((await Bun.file(registration).json()).url)
-  expect(starts).toEqual([])
-  expect(existing.exitCode).toBe(null)
-})
-
-test("replaces an incompatible registered service", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  const existing = spawn(registration, "incompatible")
-  await waitForFile(registration)
-
-  const starts: EnsureReason[] = []
-  const endpoint = await run(
-    ensure({
-      file: registration,
-      version: (version) => version.startsWith("2."),
-      command: [process.execPath, fixture, registration, "delayed-compatible", "10"],
-      onStart: (reason) => starts.push(reason),
-    }),
-  )
-  const replacement = await Bun.file(registration).json()
-
-  expect(await existing.exited).toBe(0)
-  expect(replacement.version).toBe("2.1.0-next.1")
-  expect(endpoint.url).toBe(replacement.url)
-  expect(starts).toEqual(["version-mismatch"])
-  process.kill(replacement.pid, "SIGTERM")
-  await waitForExit(replacement.pid)
-})
-
 test("waits for a registered service to finish starting", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")

packages/core/README.md

@@ -1,3 +0,0 @@
-# @opencode-ai/core
-
-Core runtime services for OpenCode.

packages/core/package.json

@@ -4,28 +4,24 @@
   "name": "@opencode-ai/core",
   "type": "module",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/anomalyco/opencode.git",
-    "directory": "packages/core"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ],
+  "private": true,
   "scripts": {
     "db": "bun drizzle-kit",
     "migration": "bun run script/migration.ts",
     "fix-node-pty": "bun run script/fix-node-pty.ts",
     "benchmark:location": "bun run script/benchmark-location.ts",
-    "build": "bun run script/build.ts",
     "update-models-snapshot": "bun run script/update-models-snapshot.ts",
     "test": "bun test --only-failures",
     "typecheck": "tsgo -b tsconfig.json tsconfig.tests.json"
   },
+  "bin": {
+    "opencode": "./bin/opencode"
+  },
   "exports": {
+    "./environment": "./src/environment/index.ts",
+    "./testing/environment-conformance": "./test/lib/environment-conformance.ts",
+    "./session/runner": "./src/session/runner/index.ts",
+    "./instructions": "./src/instructions/index.ts",
     "./*": "./src/*.ts"
   },
   "imports": {
@@ -59,18 +55,9 @@
       "bun": "./src/util/process-lock-ffi.bun.ts",
       "node": "./src/util/process-lock-ffi.node.ts",
       "default": "./src/util/process-lock-ffi.bun.ts"
-    },
-    "#v1-migration": {
-      "types": "./src/database/v1-migration.bun.ts",
-      "bun": "./src/database/v1-migration.bun.ts",
-      "node": "./src/database/v1-migration.noop.ts",
-      "workerd": "./src/database/v1-migration.noop.ts",
-      "default": "./src/database/v1-migration.noop.ts"
     }
   },
   "devDependencies": {
-    "@effect/platform-node": "catalog:",
-    "@effect/sql-sqlite-bun": "catalog:",
     "@tsconfig/bun": "catalog:",
     "@types/bun": "catalog:",
     "@types/node": "catalog:",
@@ -106,6 +93,8 @@
     "@ai-sdk/togetherai": "2.0.41",
     "@ai-sdk/vercel": "2.0.39",
     "@aws-sdk/credential-providers": "3.1057.0",
+    "@effect/platform-node": "catalog:",
+    "@effect/sql-sqlite-bun": "catalog:",
     "@lydell/node-pty": "catalog:",
     "@modelcontextprotocol/sdk": "1.29.0",
     "@ff-labs/fff-bun": "0.10.1",
@@ -139,5 +128,8 @@
     "web-tree-sitter": "0.25.10",
     "which": "6.0.1",
     "zod": "catalog:"
+  },
+  "overrides": {
+    "drizzle-orm": "catalog:"
   }
 }

packages/core/script/build.ts

@@ -1,34 +0,0 @@
-#!/usr/bin/env bun
-
-import { $ } from "bun"
-import { rm } from "node:fs/promises"
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-
-process.chdir(fileURLToPath(new URL("..", import.meta.url)))
-
-await rm("dist", { recursive: true, force: true })
-await $`bun tsc -p tsconfig.build.json`
-
-const root = path.resolve("src")
-const files = await Array.fromAsync(new Bun.Glob("**/*.ts").scan({ cwd: root, absolute: true }))
-const result = await Bun.build({
-  entrypoints: files.filter((file) => !file.endsWith(".d.ts")),
-  root,
-  outdir: "dist",
-  target: "node",
-  format: "esm",
-  packages: "external",
-  external: ["#sqlite", "#pty", "#fff", "#photon-wasm", "#shell-parser-wasm", "#process-lock-ffi", "#v1-migration"],
-  splitting: true,
-  loader: {
-    ".txt": "text",
-    ".md": "text",
-  },
-  naming: {
-    entry: "[dir]/[name].[ext]",
-    chunk: "chunks/[name]-[hash].[ext]",
-    asset: "assets/[name]-[hash].[ext]",
-  },
-})
-if (!result.success) throw new AggregateError(result.logs, "Failed to build Core")

packages/core/script/publish.ts

@@ -1,50 +0,0 @@
-#!/usr/bin/env bun
-
-import { Script } from "@opencode-ai/script"
-import { $ } from "bun"
-import { rm } from "node:fs/promises"
-import { fileURLToPath } from "node:url"
-
-process.chdir(fileURLToPath(new URL("..", import.meta.url)))
-
-const originalText = await Bun.file("package.json").text()
-const pkg = JSON.parse(originalText) as {
-  name: string
-  version: string
-  exports: Record<string, string | { import: string; types: string }>
-  imports: Record<string, Record<string, string>>
-}
-const tarball = `${pkg.name.replace("@", "").replace("/", "-")}-${pkg.version}.tgz`
-const output = (value: string, types = false) =>
-  value.replace("./src/", types ? "./dist/types/" : "./dist/").replace(/\.ts$/, types ? ".d.ts" : ".js")
-
-if ((await $`npm view ${pkg.name}@${pkg.version} version`.nothrow()).exitCode === 0) {
-  console.log(`already published ${pkg.name}@${pkg.version}`)
-  process.exit(0)
-}
-
-try {
-  await $`bun run typecheck`
-  await $`bun run build`
-  pkg.exports = Object.fromEntries(
-    Object.entries(pkg.exports).map(([key, value]) => {
-      if (typeof value !== "string") return [key, value]
-      return [key, { import: output(value), types: output(value, true) }]
-    }),
-  )
-  pkg.imports = Object.fromEntries(
-    Object.entries(pkg.imports).map(([key, conditions]) => [
-      key,
-      Object.fromEntries(
-        Object.entries(conditions).map(([condition, value]) => [condition, output(value, condition === "types")]),
-      ),
-    ]),
-  )
-  await Bun.write("package.json", JSON.stringify(pkg, null, 2) + "\n")
-  await rm(tarball, { force: true })
-  await $`bun pm pack`
-  await $`npm publish ${tarball} --tag ${Script.channel} --access public`
-} finally {
-  await Bun.write("package.json", originalText)
-  await rm(tarball, { force: true })
-}

packages/core/src/aisdk.ts

@@ -763,9 +763,7 @@ function apiCallErrorReason(error: APICallError) {
   if (error.statusCode !== undefined || !error.isRetryable) return reason
   return new TransportReason({
     message: reason.message,
-    transport: "http",
-    operation: "request",
-    code: error.name,
+    kind: error.name,
     url: error.url,
     http: "http" in reason ? reason.http : undefined,
   })

packages/core/src/codemode/tool.ts

@@ -75,9 +75,7 @@ export const create = (
               const outputFileParts = outputFiles(content)
               if (outputFileParts.length > 0)
                 yield* Ref.update(files, (items) => [...items, { index, files: outputFileParts }])
-              if (executed.output !== undefined) return executed.output
-              const text = content.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("\n")
-              return text === "" ? null : text
+              return executed.output
             }),
           {
             onToolCallStart: ({ index, name, input }) => {
@@ -157,7 +155,7 @@ function runtime(
     tools[path] = Tool.make({
       description: child.description,
       input: child.inputSchema,
-      output: child.outputSchema ?? Schema.NullOr(Schema.String),
+      output: child.outputSchema,
       execute: (input) => executeTool(name, registration, input),
     })
   }

packages/core/src/database/sqlite.bun.ts

@@ -1,4 +1,5 @@
 import { Database, type SQLQueryBindings } from "bun:sqlite"
+import { drizzle } from "drizzle-orm/bun-sqlite"
 import { Context, Effect, Layer } from "effect"
 import { Reactivity } from "effect/unstable/reactivity"
 import { SqlClient } from "effect/unstable/sql"
@@ -97,7 +98,16 @@ const nativeLayer = (config: Config) =>
 
 const clientLayer = (config: Config) => Layer.effect(SqlClient.SqlClient, make(config))
 
+const drizzleLayer = Layer.effect(
+  Sqlite.Drizzle,
+  Effect.gen(function* () {
+    return drizzle({ client: (yield* Sqlite.Native) as Database })
+  }),
+)
+
 export const sqliteLayer = (config: Config) => {
   const native = nativeLayer(config)
-  return Layer.merge(native, clientLayer(config).pipe(Layer.provide(native))).pipe(Layer.provide(Reactivity.layer))
+  return Layer.merge(native, Layer.merge(clientLayer(config), drizzleLayer).pipe(Layer.provide(native))).pipe(
+    Layer.provide(Reactivity.layer),
+  )
 }

packages/core/src/database/sqlite.node.ts

@@ -1,4 +1,5 @@
 import { DatabaseSync, type SQLInputValue } from "node:sqlite"
+import { drizzle } from "drizzle-orm/node-sqlite"
 import { Context, Effect, Layer } from "effect"
 import { Reactivity } from "effect/unstable/reactivity"
 import { SqlClient } from "effect/unstable/sql"
@@ -94,7 +95,16 @@ const nativeLayer = (config: Config) =>
 
 const clientLayer = (config: Config) => Layer.effect(SqlClient.SqlClient, make(config))
 
+const drizzleLayer = Layer.effect(
+  Sqlite.Drizzle,
+  Effect.gen(function* () {
+    return drizzle({ client: (yield* Sqlite.Native) as DatabaseSync }) as unknown as Sqlite.DrizzleClient
+  }),
+)
+
 export const sqliteLayer = (config: Config) => {
   const native = nativeLayer(config)
-  return Layer.merge(native, clientLayer(config).pipe(Layer.provide(native))).pipe(Layer.provide(Reactivity.layer))
+  return Layer.merge(native, Layer.merge(clientLayer(config), drizzleLayer).pipe(Layer.provide(native))).pipe(
+    Layer.provide(Reactivity.layer),
+  )
 }

packages/core/src/database/sqlite.ts

@@ -5,8 +5,11 @@ import { identity } from "effect/Function"
 import { SqlClient, Statement } from "effect/unstable/sql"
 import type { Connection } from "effect/unstable/sql/SqlConnection"
 import type { SqlError } from "effect/unstable/sql/SqlError"
+import type { drizzle } from "drizzle-orm/bun-sqlite"
 
+export type DrizzleClient = ReturnType<typeof drizzle>
 export class Native extends Context.Service<Native, unknown>()("@opencode-ai/core/database/SqliteNative") {}
+export class Drizzle extends Context.Service<Drizzle, DrizzleClient>()("@opencode-ai/core/database/SqliteDrizzle") {}
 
 export interface ClientConfig {
   readonly spanAttributes?: Record<string, unknown>

packages/core/src/database/sqlite.workerd.ts

@@ -1,3 +1,4 @@
+import { drizzle } from "drizzle-orm/durable-sqlite"
 import { Context, Effect, Exit, Fiber, Layer, Scope, Semaphore, Stream } from "effect"
 import { identity } from "effect/Function"
 import { Reactivity } from "effect/unstable/reactivity"
@@ -237,7 +238,17 @@ const nativeLayer = (config: Config) =>
 
 const clientLayer = (config: Config) => Layer.effect(SqlClient.SqlClient, make(config))
 
+const drizzleLayer = Layer.effect(
+  Sqlite.Drizzle,
+  Effect.gen(function* () {
+    const native = (yield* Sqlite.Native) as DurableObjectStorage
+    return drizzle(native) as unknown as Sqlite.DrizzleClient
+  }),
+)
+
 export const sqliteLayer = (config: Config) => {
   const native = nativeLayer(config)
-  return Layer.merge(native, clientLayer(config).pipe(Layer.provide(native))).pipe(Layer.provide(Reactivity.layer))
+  return Layer.merge(native, Layer.merge(clientLayer(config), drizzleLayer).pipe(Layer.provide(native))).pipe(
+    Layer.provide(Reactivity.layer),
+  )
 }

packages/core/src/database/v1-migration.bun.ts

@@ -1,997 +0,0 @@
-export * as V1Migration from "./v1-migration.js"
-
-import { Cause, Effect, Layer, Option, Schema, Semaphore } from "effect"
-import { Database } from "./database.js"
-import { SessionMessageTable, SessionTable } from "../session/sql.js"
-import { SessionV1 } from "@opencode-ai/schema/session-v1"
-import { SessionMessage } from "../session/message.js"
-import { SessionSchema } from "../session/schema.js"
-import { KVTable } from "../kv/sql.js"
-import { EventSequenceTable } from "../event/sql.js"
-import { eq, sql } from "drizzle-orm"
-import { Global } from "@opencode-ai/util/global"
-import { existsSync } from "node:fs"
-import path from "node:path"
-import type { Database as SQLiteDatabase } from "bun:sqlite"
-import { Project } from "@opencode-ai/schema/project"
-
-export type SourceMessage = {
-  readonly id: string
-  readonly session_id: string
-  readonly time_created: number
-  readonly time_updated: number
-  readonly data: string
-}
-
-export type SourcePart = {
-  readonly id: string
-  readonly message_id: string
-  readonly session_id: string
-  readonly time_created: number
-  readonly time_updated: number
-  readonly data: string
-}
-
-export type TransformInput = {
-  readonly session: typeof SessionTable.$inferSelect
-  readonly messages: ReadonlyArray<SourceMessage>
-  readonly parts: ReadonlyArray<SourcePart>
-}
-
-export type Warning = {
-  readonly reason: string
-  readonly sessionID: string
-  readonly messageID?: string
-  readonly partID?: string
-  readonly observedType?: string
-}
-
-export type TransformResult = {
-  readonly messages: ReadonlyArray<{
-    readonly id: string
-    readonly session_id: string
-    readonly type: SessionMessage.Type
-    readonly seq: number
-    readonly time_created: number
-    readonly time_updated: number
-    readonly data: Record<string, unknown>
-  }>
-  readonly session: Pick<
-    typeof SessionTable.$inferInsert,
-    | "agent"
-    | "model"
-    | "cost"
-    | "tokens_input"
-    | "tokens_output"
-    | "tokens_reasoning"
-    | "tokens_cache_read"
-    | "tokens_cache_write"
-    | "revert"
-    | "time_compacting"
-  >
-  readonly watermark: number
-  readonly warnings: ReadonlyArray<Warning>
-}
-
-type Progress = {
-  readonly label: string
-  readonly numerator?: number
-  readonly denominator?: number
-}
-
-export type Status =
-  | { readonly status: "required" | "completed" }
-  | { readonly status: "running"; readonly progress: Progress }
-  | { readonly status: "error"; readonly error: string }
-
-type RunResult = {
-  readonly status: "completed"
-}
-
-type Options = {
-  readonly nextDatabasePath?: string
-}
-
-type MigrationState = { readonly phase: "sessions"; readonly cursor?: string } | { readonly phase: "completed" }
-
-type RuntimeState =
-  | { readonly status: "idle" }
-  | { readonly status: "running"; readonly progress: Progress }
-  | { readonly status: "error"; readonly error: string }
-
-type NextProject = {
-  readonly id: string
-  readonly worktree: string
-  readonly vcs: string | null
-  readonly name: string | null
-  readonly icon_url: string | null
-  readonly icon_url_override: string | null
-  readonly icon_color: string | null
-  readonly time_created: number
-  readonly time_updated: number
-  readonly time_initialized: number | null
-  readonly sandboxes: string
-  readonly commands: string | null
-}
-
-type NextSession = {
-  readonly id: string
-  readonly project_id: string
-  readonly workspace_id: string | null
-  readonly parent_id: string | null
-  readonly fork_session_id: string | null
-  readonly fork_boundary: string | null
-  readonly slug: string
-  readonly directory: string
-  readonly path: string | null
-  readonly title: string | null
-  readonly version: string
-  readonly share_url: string | null
-  readonly summary_additions: number | null
-  readonly summary_deletions: number | null
-  readonly summary_files: number | null
-  readonly summary_diffs: string | null
-  readonly metadata: string | null
-  readonly cost: number
-  readonly tokens_input: number
-  readonly tokens_output: number
-  readonly tokens_reasoning: number
-  readonly tokens_cache_read: number
-  readonly tokens_cache_write: number
-  readonly revert: string | null
-  readonly permission: string | null
-  readonly agent: string | null
-  readonly model: string | null
-  readonly time_created: number
-  readonly time_updated: number
-  readonly time_compacting: number | null
-  readonly time_archived: number | null
-  readonly time_suspended: number | null
-}
-
-type NextMessage = {
-  readonly id: string
-  readonly session_id: string
-  readonly type: string
-  readonly seq: number
-  readonly time_created: number
-  readonly time_updated: number
-  readonly data: string
-}
-
-const lock = Semaphore.makeUnsafe(1)
-const MIGRATION_STATE_KEY = "migration.v1-v2"
-const EVENT_DELETE_BATCH_SIZE = 1_000
-const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
-const decodeMessage = Schema.decodeUnknownOption(SessionV1.Info)
-const decodePart = Schema.decodeUnknownOption(SessionV1.Part)
-let runtimeState: RuntimeState = { status: "idle" }
-
-export function transformSession(input: TransformInput): TransformResult {
-  const warnings: Warning[] = []
-  const messages = input.messages
-    .map((row) => {
-      const value = Option.getOrUndefined(decodeJson(row.data))
-      const decoded =
-        value && typeof value === "object"
-          ? Option.getOrUndefined(decodeMessage({ ...value, id: row.id, sessionID: row.session_id }))
-          : undefined
-      if (decoded) return { row, value: decoded }
-      warnings.push({ reason: "invalid-message", sessionID: input.session.id, messageID: row.id })
-      return undefined
-    })
-    .filter((item): item is NonNullable<typeof item> => item !== undefined)
-    .sort((a, b) => a.row.time_created - b.row.time_created || a.row.id.localeCompare(b.row.id))
-  const messageIDs = new Set(input.messages.map((row) => row.id))
-  const parts = input.parts
-    .map((row) => {
-      const value = Option.getOrUndefined(decodeJson(row.data))
-      const observedType = value && typeof value === "object" && "type" in value ? String(value.type) : undefined
-      if (!messageIDs.has(row.message_id)) {
-        warnings.push({
-          reason: "orphan-part",
-          sessionID: input.session.id,
-          messageID: row.message_id,
-          partID: row.id,
-          observedType,
-        })
-        return undefined
-      }
-      const decoded =
-        value && typeof value === "object"
-          ? Option.getOrUndefined(
-              decodePart({ ...value, id: row.id, messageID: row.message_id, sessionID: row.session_id }),
-            )
-          : undefined
-      if (decoded) return { row, value: decoded }
-      warnings.push({
-        reason: "invalid-part",
-        sessionID: input.session.id,
-        messageID: row.message_id,
-        partID: row.id,
-        observedType,
-      })
-      return undefined
-    })
-    .filter((item): item is NonNullable<typeof item> => item !== undefined)
-    .sort((a, b) => a.row.id.localeCompare(b.row.id))
-  const byMessage = Map.groupBy(parts, (item) => item.row.message_id)
-  const paired = new Set<string>()
-  const used = new Set(messages.map((item) => item.row.id))
-  const projected = messages
-    .flatMap((item) => {
-      if (paired.has(item.row.id)) return []
-      const owned = byMessage.get(item.row.id)?.map((part) => part.value) ?? []
-      if (item.value.role === "user") {
-        const compaction = owned.find((part) => part.type === "compaction")
-        if (compaction?.type === "compaction") {
-          const pairedSummary = messages.find(
-            (candidate) =>
-              candidate.value.role === "assistant" &&
-              candidate.value.parentID === item.row.id &&
-              candidate.value.summary,
-          )
-          if (!pairedSummary || pairedSummary.value.role !== "assistant") return []
-          paired.add(pairedSummary.row.id)
-          if (pairedSummary.value.error || pairedSummary.value.time.completed === undefined) return []
-          const summary = pairedSummary
-          const summaryText = (byMessage.get(summary.row.id) ?? [])
-            .map((part) => part.value)
-            .filter((part) => part.type === "text" && part.text.length > 0)
-            .map((part) => (part.type === "text" ? part.text : ""))
-            .join("\n\n")
-          const tailIndex = compaction.tail_start_id
-            ? messages.findIndex((candidate) => candidate.row.id === compaction.tail_start_id)
-            : -1
-          const compactionIndex = messages.findIndex((candidate) => candidate.row.id === item.row.id)
-          const tail = tailIndex < 0 ? [] : messages.slice(tailIndex, compactionIndex)
-          return [
-            row(
-              { ...item.row, time_updated: Math.max(item.row.time_updated, summary.row.time_updated) },
-              {
-                id: item.row.id,
-                type: "compaction",
-                status: "completed",
-                reason: compaction.auto ? "auto" : "manual",
-                summary: summaryText,
-                recent: serializeRecent(tail, byMessage),
-                time: { created: item.row.time_created },
-              },
-            ),
-          ]
-        }
-        const subtasks = owned.filter((part) => part.type === "subtask")
-        const visible = owned.filter((part) => part.type === "text" && !part.ignored)
-        const files = owned.filter((part) => part.type === "file")
-        const agents = owned.filter((part) => part.type === "agent")
-        if (subtasks.length > 0 && visible.length === 0 && files.length === 0 && agents.length === 0) return []
-        const ordinary = visible.filter((part) => part.type === "text" && !part.synthetic)
-        const synthetic = visible.filter((part) => part.type === "text" && part.synthetic)
-        const attachments = files.flatMap((part) => (part.type === "file" ? migrateFile(part) : []))
-        const unavailable = files.flatMap((part) =>
-          part.type === "file" && !part.url.startsWith("data:") ? [unavailableFile(part)] : [],
-        )
-        const text = owned
-          .flatMap((part) => {
-            if (part.type === "text" && !part.ignored && !part.synthetic) return [part.text]
-            if (part.type === "file" && !part.url.startsWith("data:")) return [unavailableFile(part)]
-            return []
-          })
-          .join("\n\n")
-        const agentAttachments = agents.map((part) =>
-          part.type === "agent"
-            ? {
-                name: part.name,
-                ...(part.source
-                  ? { mention: { text: part.source.value, start: part.source.start, end: part.source.end } }
-                  : {}),
-              }
-            : { name: "" },
-        )
-        if (
-          ordinary.length === 0 &&
-          unavailable.length === 0 &&
-          synthetic.length > 0 &&
-          attachments.length === 0 &&
-          agentAttachments.length === 0
-        )
-          return [
-            row(item.row, {
-              id: item.row.id,
-              type: "synthetic",
-              text: synthetic.map((part) => (part.type === "text" ? part.text : "")).join("\n\n"),
-              time: { created: item.row.time_created },
-            }),
-          ]
-        const user = row(item.row, {
-          id: item.row.id,
-          type: "user",
-          text,
-          ...(attachments.length ? { files: attachments } : {}),
-          ...(agentAttachments.length ? { agents: agentAttachments } : {}),
-          time: { created: item.row.time_created },
-        })
-        if (synthetic.length === 0) return [user]
-        return [
-          user,
-          row(item.row, {
-            id: syntheticID(item.row.id, used),
-            type: "synthetic",
-            text: synthetic.map((part) => (part.type === "text" ? part.text : "")).join("\n\n"),
-            time: { created: item.row.time_created },
-          }),
-        ]
-      }
-      if (item.value.role !== "assistant") return []
-      const assistant = item.value
-      const parent = messages.find((candidate) => candidate.row.id === assistant.parentID)
-      const parentParts = parent ? (byMessage.get(parent.row.id)?.map((part) => part.value) ?? []) : []
-      if (
-        parentParts.some((part) => part.type === "subtask") &&
-        owned.some((part) => part.type === "tool" && part.tool === "task")
-      )
-        return []
-      const content = owned.flatMap((part): Array<Record<string, unknown>> => {
-        if (part.type === "text")
-          return [{ type: "text", text: part.text, ...(part.metadata ? { state: part.metadata } : {}) }]
-        if (part.type === "reasoning")
-          return [
-            {
-              type: "reasoning",
-              text: part.text,
-              ...(part.metadata ? { state: part.metadata } : {}),
-              time: { created: part.time.start, ...(part.time.end === undefined ? {} : { completed: part.time.end }) },
-            },
-          ]
-        if (part.type !== "tool") return []
-        return [migrateTool(part, item.row.time_created)]
-      })
-      const start =
-        owned.flatMap((part) => (part.type === "step-start" && part.snapshot ? [part.snapshot] : []))[0] ??
-        owned.flatMap((part) => (part.type === "snapshot" ? [part.snapshot] : []))[0] ??
-        owned.flatMap((part) => (part.type === "patch" ? [part.hash] : []))[0]
-      const end = owned.flatMap((part) => (part.type === "step-finish" && part.snapshot ? [part.snapshot] : [])).at(-1)
-      const snapshotFiles = Array.from(new Set(owned.flatMap((part) => (part.type === "patch" ? part.files : []))))
-      const finish = normalizeFinish(assistant.finish)
-      return [
-        row(item.row, {
-          id: item.row.id,
-          type: "assistant",
-          agent: assistant.agent,
-          model: {
-            providerID: assistant.providerID,
-            id: assistant.modelID,
-            variant: assistant.variant ?? "default",
-          },
-          content,
-          ...(start || end || snapshotFiles.length
-            ? {
-                snapshot: {
-                  ...(start ? { start } : {}),
-                  ...(end ? { end } : {}),
-                  ...(snapshotFiles.length ? { files: snapshotFiles } : {}),
-                },
-              }
-            : {}),
-          ...(finish ? { finish } : {}),
-          cost: assistant.cost,
-          tokens: {
-            input: assistant.tokens.input,
-            output: assistant.tokens.output,
-            reasoning: assistant.tokens.reasoning,
-            cache: assistant.tokens.cache,
-          },
-          ...(assistant.error ? { error: migrateError(assistant.error) } : {}),
-          time: {
-            created: item.row.time_created,
-            ...(assistant.time.completed === undefined ? {} : { completed: item.row.time_updated }),
-          },
-        }),
-      ]
-    })
-    .map((item, seq) => ({ ...item, seq }))
-  const assistants = messages
-    .filter((item) => item.value.role === "assistant")
-    .map((item) => item.value)
-    .filter((item): item is SessionV1.Assistant => item.role === "assistant")
-  const latestUser = messages.findLast((item) => {
-    if (item.value.role !== "user") return false
-    const owned = byMessage.get(item.row.id) ?? []
-    if (owned.some((part) => part.value.type === "compaction")) return false
-    return !owned.some((part) => part.value.type === "subtask") || !owned.every((part) => part.value.type === "subtask")
-  })
-  return {
-    messages: projected,
-    session: {
-      agent: input.session.agent ?? (latestUser?.value.role === "user" ? latestUser.value.agent : null),
-      model:
-        input.session.model ??
-        (latestUser?.value.role === "user"
-          ? {
-              id: latestUser.value.model.modelID,
-              providerID: latestUser.value.model.providerID,
-              variant: latestUser.value.model.variant ?? "default",
-            }
-          : null),
-      cost: assistants.reduce((total, item) => total + item.cost, 0),
-      tokens_input: assistants.reduce((total, item) => total + item.tokens.input, 0),
-      tokens_output: assistants.reduce((total, item) => total + item.tokens.output, 0),
-      tokens_reasoning: assistants.reduce((total, item) => total + item.tokens.reasoning, 0),
-      tokens_cache_read: assistants.reduce((total, item) => total + item.tokens.cache.read, 0),
-      tokens_cache_write: assistants.reduce((total, item) => total + item.tokens.cache.write, 0),
-      revert: null,
-      time_compacting: null,
-    },
-    watermark: projected.length - 1,
-    warnings,
-  }
-}
-
-export function status(): Effect.Effect<Status, never, Database.Service> {
-  return Effect.gen(function* () {
-    const { db } = yield* Database.Service
-    if (!(yield* hasLegacySessions(db))) return { status: "completed" as const }
-    const state = yield* readState(db)
-    if (runtimeState.status === "running") return runtimeState
-    if (runtimeState.status === "error") return runtimeState
-    if (state?.phase === "completed") return { status: "completed" as const }
-    return { status: "required" as const }
-  }).pipe(Effect.orDie)
-}
-
-export const layer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    runtimeState = { status: "running", progress: { label: "Clearing old events" } }
-    yield* run().pipe(
-      Effect.matchCauseEffect({
-        onFailure: (cause) =>
-          Effect.sync(() => {
-            runtimeState = { status: "error", error: errorText(Cause.squash(cause)) }
-          }).pipe(Effect.andThen(Effect.logError("V1 migration failed", { cause }))),
-        onSuccess: () =>
-          Effect.sync(() => {
-            runtimeState = { status: "idle" }
-          }),
-      }),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-  }),
-)
-
-function errorText(input: unknown): string {
-  if (!(input instanceof Error)) return String(input)
-  const cause = input.cause
-  return cause === undefined ? input.message : `${input.message}\nCaused by: ${errorText(cause)}`
-}
-
-function updateProgress(progress: Progress) {
-  if (runtimeState.status === "running") runtimeState = { status: "running", progress }
-}
-
-export function run(options: Options = {}): Effect.Effect<RunResult, never, Database.Service | Global.Service> {
-  return lock.withPermit(
-    Effect.gen(function* () {
-      const { db } = yield* Database.Service
-      const global = yield* Global.Service
-      const state = yield* readState(db)
-      if (state?.phase === "completed") return { status: "completed" as const }
-      if (!(yield* hasLegacySessions(db))) return { status: "completed" as const }
-      const migrate = Effect.gen(function* () {
-        const now = Date.now()
-        yield* db.run(sql`
-          INSERT OR IGNORE INTO project (id, worktree, time_created, time_updated, sandboxes)
-          VALUES (${Project.ID.global}, ${path.parse(global.data).root}, ${now}, ${now}, '[]')
-        `)
-        if (state === undefined)
-          yield* db
-            .transaction((tx) =>
-              Effect.gen(function* () {
-                while (true) {
-                  yield* tx.run(sql`
-                    DELETE FROM event
-                    WHERE rowid IN (SELECT rowid FROM event LIMIT ${EVENT_DELETE_BATCH_SIZE})
-                  `)
-                  const deleted = (yield* tx.get<{ value: number }>(sql`SELECT changes() AS value`))?.value ?? 0
-                  if (deleted < EVENT_DELETE_BATCH_SIZE) break
-                  yield* Effect.yieldNow
-                }
-                yield* tx
-                  .insert(KVTable)
-                  .values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions" } })
-                  .run()
-              }),
-            )
-            .pipe(Effect.orDie)
-        const sourceTotal = yield* countNextSessions(nextPath(options, global.data))
-        const legacyTotal = (yield* db.get<{ value: number }>(sql`SELECT COUNT(*) AS value FROM session`))?.value ?? 0
-        const cursor = state?.phase === "sessions" ? state.cursor : undefined
-        const migrated =
-          cursor !== undefined
-            ? ((yield* db.get<{ value: number }>(sql`SELECT COUNT(*) AS value FROM session WHERE id >= ${cursor}`))
-                ?.value ?? 0)
-            : 0
-        const denominator = sourceTotal + legacyTotal
-        updateProgress({ label: "Migrating sessions", numerator: migrated, denominator })
-        yield* importNextDatabase(db, nextPath(options, global.data), (completed) => {
-          updateProgress({ label: "Migrating sessions", numerator: migrated + completed, denominator })
-        })
-        updateProgress({ label: "Migrating sessions", numerator: migrated + sourceTotal, denominator })
-        const projects = new Set(
-          (yield* db.all<{ id: string }>(sql`SELECT id FROM project`)).map((project) => project.id),
-        )
-        while (true) {
-          const state = yield* readState(db)
-          const cursorValue = state?.phase === "sessions" ? state.cursor : undefined
-          const nextID = yield* db.get<{ id: string; project_id: string }>(
-            cursorValue === undefined
-              ? sql`SELECT id, project_id FROM session ORDER BY id DESC LIMIT 1`
-              : sql`SELECT id, project_id FROM session WHERE id < ${cursorValue} ORDER BY id DESC LIMIT 1`,
-          )
-          if (!nextID) break
-          yield* db
-            .transaction((tx) =>
-              Effect.gen(function* () {
-                yield* tx
-                  .insert(KVTable)
-                  .values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions", cursor: nextID.id } })
-                  .onConflictDoUpdate({
-                    target: KVTable.key,
-                    set: { value: { phase: "sessions", cursor: nextID.id }, time_updated: Date.now() },
-                  })
-                  .run()
-                const projectID = projects.has(nextID.project_id) ? nextID.project_id : Project.ID.global
-                if (projectID !== nextID.project_id)
-                  yield* Effect.logWarning("Reassigned V1 session with missing project", {
-                    sessionID: nextID.id,
-                    projectID: nextID.project_id,
-                  })
-                yield* tx.run(sql`
-                  INSERT OR IGNORE INTO session_v2 (
-                    id, project_id, workspace_id, parent_id, slug, directory, path, title, version, share_url,
-                    summary_additions, summary_deletions, summary_files, summary_diffs, metadata, cost,
-                    tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write,
-                    revert, permission, agent, model, time_created, time_updated, time_compacting, time_archived
-                  )
-                  SELECT
-                    id, ${projectID}, workspace_id, parent_id, slug, directory, path, title, version, share_url,
-                    summary_additions, summary_deletions, summary_files, summary_diffs, metadata, cost,
-                    tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write,
-                    revert, permission, agent, model, time_created, time_updated, time_compacting, time_archived
-                  FROM session
-                  WHERE id = ${nextID.id}
-                `)
-                const next = yield* tx
-                  .select()
-                  .from(SessionTable)
-                  .where(eq(SessionTable.id, SessionSchema.ID.make(nextID.id)))
-                  .get()
-                if (!next) return yield* Effect.die(new Error(`Failed to copy V1 session ${nextID.id}`))
-                const sourceMessages = yield* tx.all<SourceMessage>(
-                  sql`SELECT id, session_id, time_created, time_updated, data FROM message WHERE session_id = ${next.id}`,
-                )
-                const sourceParts = yield* tx.all<SourcePart>(
-                  sql`SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE session_id = ${next.id}`,
-                )
-                const transformed = transformSession({ session: next, messages: sourceMessages, parts: sourceParts })
-                yield* Effect.forEach(transformed.warnings, (warning) =>
-                  Effect.logWarning("Skipped V1 migration row", warning),
-                )
-                yield* tx.delete(SessionMessageTable).where(eq(SessionMessageTable.session_id, next.id)).run()
-                yield* Effect.forEach(transformed.messages, (message) =>
-                  tx
-                    .insert(SessionMessageTable)
-                    .values({
-                      id: SessionMessage.ID.make(message.id),
-                      session_id: SessionSchema.ID.make(message.session_id),
-                      type: message.type,
-                      seq: message.seq,
-                      time_created: message.time_created,
-                      time_updated: message.time_updated,
-                      data: sql`${JSON.stringify(message.data)}`,
-                    })
-                    .run(),
-                )
-                yield* tx
-                  .update(SessionTable)
-                  .set({ ...transformed.session, time_updated: next.time_updated })
-                  .where(eq(SessionTable.id, next.id))
-                  .run()
-                yield* tx
-                  .insert(EventSequenceTable)
-                  .values({ aggregate_id: next.id, seq: transformed.watermark })
-                  .onConflictDoUpdate({
-                    target: EventSequenceTable.aggregate_id,
-                    set: { seq: transformed.watermark, owner_id: null },
-                  })
-                  .run()
-              }),
-            )
-            .pipe(Effect.orDie)
-          if (runtimeState.status === "running")
-            runtimeState = {
-              status: "running",
-              progress: {
-                label: "Migrating sessions",
-                numerator: (runtimeState.progress.numerator ?? 0) + 1,
-                denominator,
-              },
-            }
-          yield* Effect.yieldNow
-        }
-        yield* db
-          .transaction((tx) =>
-            Effect.gen(function* () {
-              yield* tx
-                .insert(KVTable)
-                .values({ key: MIGRATION_STATE_KEY, value: { phase: "completed" } })
-                .onConflictDoUpdate({
-                  target: KVTable.key,
-                  set: { value: { phase: "completed" }, time_updated: Date.now() },
-                })
-                .run()
-            }),
-          )
-          .pipe(Effect.orDie)
-        return { status: "completed" as const }
-      })
-      return yield* migrate
-    }).pipe(Effect.orDie),
-  )
-}
-
-function nextPath(options: Options, data: string) {
-  if (options.nextDatabasePath) return options.nextDatabasePath
-  if (process.env.OPENCODE_DB === ":memory:") return undefined
-  return path.join(data, "opencode-next.db")
-}
-
-function openNextDatabase(sourcePath: string) {
-  return Effect.acquireRelease(
-    Effect.gen(function* () {
-      const sqlite = yield* Effect.promise(() => import("bun:sqlite"))
-      return new sqlite.Database(sourcePath, { readonly: true, strict: true })
-    }),
-    (source) => Effect.sync(() => source.close()),
-  )
-}
-
-function countNextSessions(sourcePath: string | undefined) {
-  if (!sourcePath || !existsSync(sourcePath)) return Effect.succeed(0)
-  return Effect.scoped(
-    Effect.gen(function* () {
-      const source = yield* openNextDatabase(sourcePath)
-      if (!isNextDatabase(source)) return 0
-      return source.query<{ value: number }, []>("SELECT COUNT(*) AS value FROM session").get()?.value ?? 0
-    }),
-  ).pipe(Effect.orElseSucceed(() => 0))
-}
-
-function importNextDatabase(
-  db: Database.Interface["db"],
-  sourcePath: string | undefined,
-  onProgress: (completed: number) => void,
-): Effect.Effect<void, unknown> {
-  if (!sourcePath || !existsSync(sourcePath)) return Effect.void
-  return Effect.scoped(
-    Effect.gen(function* () {
-      const source = yield* openNextDatabase(sourcePath)
-      if (!isNextDatabase(source)) {
-        yield* Effect.logWarning("Skipped incompatible opencode-next.db", { path: sourcePath })
-        return
-      }
-      source.run("BEGIN")
-      yield* Effect.addFinalizer(() =>
-        Effect.sync(() => {
-          if (source.inTransaction) source.run("ROLLBACK")
-        }),
-      )
-      const projects = new Map(
-        source
-          .query<NextProject, []>("SELECT * FROM project")
-          .all()
-          .map((project) => [project.id, project]),
-      )
-      const sessions = source.query<NextSession, []>("SELECT * FROM session ORDER BY id DESC").all()
-      for (const [index, session] of sessions.entries()) {
-        const project = projects.get(session.project_id)
-        const projectID = project ? session.project_id : Project.ID.global
-        if (!project) {
-          yield* Effect.logWarning("Reassigned previous V2 session with missing project", {
-            sessionID: session.id,
-            projectID: session.project_id,
-          })
-        }
-        const messages = source
-          .query<
-            NextMessage,
-            [string]
-          >("SELECT id, session_id, type, seq, time_created, time_updated, data FROM session_message WHERE session_id = ? ORDER BY seq")
-          .all(session.id)
-        yield* db
-          .transaction((tx) =>
-            Effect.gen(function* () {
-              if (project)
-                yield* tx.run(sql`
-                  INSERT OR IGNORE INTO project (
-                    id, worktree, vcs, name, icon_url, icon_url_override, icon_color,
-                    time_created, time_updated, time_initialized, sandboxes, commands
-                  ) VALUES (
-                    ${project.id}, ${project.worktree}, ${project.vcs}, ${project.name}, ${project.icon_url},
-                    ${project.icon_url_override}, ${project.icon_color}, ${project.time_created}, ${project.time_updated},
-                    ${project.time_initialized}, ${project.sandboxes}, ${project.commands}
-                  )
-                `)
-              const existing = yield* tx
-                .select({ id: SessionTable.id })
-                .from(SessionTable)
-                .where(eq(SessionTable.id, SessionSchema.ID.make(session.id)))
-                .get()
-              if (existing) return
-              yield* tx.run(sql`
-                INSERT INTO session_v2 (
-                  id, project_id, workspace_id, parent_id, fork_session_id, fork_boundary, slug, directory,
-                  path, title, version, share_url, summary_additions, summary_deletions, summary_files,
-                  summary_diffs, metadata, cost, tokens_input, tokens_output, tokens_reasoning, tokens_cache_read,
-                  tokens_cache_write, revert, permission, agent, model, time_created, time_updated, time_compacting,
-                  time_archived, time_suspended
-                ) VALUES (
-                  ${session.id}, ${projectID}, ${session.workspace_id}, ${session.parent_id},
-                  ${session.fork_session_id}, ${session.fork_boundary}, ${session.slug}, ${session.directory},
-                  ${session.path}, ${session.title}, ${session.version}, ${session.share_url},
-                  ${session.summary_additions}, ${session.summary_deletions}, ${session.summary_files},
-                  ${session.summary_diffs}, ${session.metadata}, ${session.cost}, ${session.tokens_input},
-                  ${session.tokens_output}, ${session.tokens_reasoning}, ${session.tokens_cache_read},
-                  ${session.tokens_cache_write}, ${session.revert}, ${session.permission}, ${session.agent},
-                  ${session.model}, ${session.time_created}, ${session.time_updated}, ${session.time_compacting},
-                  ${session.time_archived}, ${session.time_suspended}
-                )
-              `)
-              yield* Effect.forEach(messages, (message) =>
-                tx
-                  .insert(SessionMessageTable)
-                  .values({
-                    id: SessionMessage.ID.make(message.id),
-                    session_id: SessionSchema.ID.make(message.session_id),
-                    type: message.type as SessionMessage.Type,
-                    seq: message.seq,
-                    time_created: message.time_created,
-                    time_updated: message.time_updated,
-                    data: sql`${message.data}`,
-                  })
-                  .run(),
-              )
-              yield* tx
-                .insert(EventSequenceTable)
-                .values({ aggregate_id: session.id, seq: messages.at(-1)?.seq ?? -1 })
-                .onConflictDoUpdate({
-                  target: EventSequenceTable.aggregate_id,
-                  set: { seq: messages.at(-1)?.seq ?? -1, owner_id: null },
-                })
-                .run()
-            }),
-          )
-          .pipe(Effect.orDie)
-        onProgress(index + 1)
-        yield* Effect.yieldNow
-      }
-      source.run("COMMIT")
-    }),
-  )
-}
-
-function isNextDatabase(source: SQLiteDatabase) {
-  const tables = new Set(
-    source
-      .query<{ name: string }, []>("SELECT name FROM sqlite_master WHERE type = 'table'")
-      .all()
-      .map((table) => table.name),
-  )
-  return tables.has("project") && tables.has("session") && tables.has("session_message")
-}
-
-function row(
-  source: SourceMessage,
-  message: {
-    readonly id: string
-    readonly type: SessionMessage.Type
-    readonly time: { readonly created: number }
-    readonly [key: string]: unknown
-  },
-): TransformResult["messages"][number] {
-  const { id, type, ...data } = message
-  return {
-    id,
-    session_id: source.session_id,
-    type,
-    seq: 0,
-    time_created: source.time_created,
-    time_updated: source.time_updated,
-    data,
-  }
-}
-
-function migrateTool(part: typeof SessionV1.ToolPart.Type, fallback: number) {
-  const base = {
-    type: "tool" as const,
-    id: part.callID,
-    name: part.tool,
-    ...(part.metadata ? { providerState: part.metadata } : {}),
-  }
-  if (part.state.status === "completed")
-    return {
-      ...base,
-      state: {
-        status: "completed",
-        input: part.state.input,
-        content:
-          part.state.time.compacted === undefined
-            ? [
-                { type: "text", text: part.state.output },
-                ...(part.state.attachments ?? []).map((file) => ({
-                  type: "file" as const,
-                  uri: file.url,
-                  mime: file.mime,
-                  ...(file.filename ? { name: file.filename } : {}),
-                })),
-              ]
-            : [{ type: "text", text: "[Old tool result content cleared]" }],
-        metadata: part.state.metadata,
-      },
-      time: { created: part.state.time.start, completed: part.state.time.end },
-    }
-  if (part.state.status === "error")
-    return {
-      ...base,
-      state: {
-        status: "error",
-        input: part.state.input,
-        error: { type: "tool.execution", message: part.state.error },
-        ...(typeof part.state.metadata?.output === "string"
-          ? { content: [{ type: "text", text: part.state.metadata.output }] }
-          : {}),
-        ...(part.state.metadata ? { metadata: part.state.metadata } : {}),
-      },
-      time: { created: part.state.time.start, completed: part.state.time.end },
-    }
-  return {
-    ...base,
-    state: {
-      status: "error",
-      input: part.state.input,
-      error: { type: "tool.interrupted", message: "Tool execution was interrupted before V2 migration" },
-      ...(part.state.status === "running" && part.state.metadata ? { metadata: part.state.metadata } : {}),
-    },
-    time: { created: part.state.status === "running" ? part.state.time.start : fallback },
-  }
-}
-
-function migrateError(error: NonNullable<(typeof SessionV1.Assistant.Type)["error"]>) {
-  const message =
-    "message" in error.data
-      ? error.data.message
-      : error.name === "MessageOutputLengthError"
-        ? "The model exceeded its output limit"
-        : error.name
-  const type =
-    error.name === "ProviderAuthError"
-      ? "provider.auth"
-      : error.name === "ContentFilterError"
-        ? "provider.content-filter"
-        : error.name === "ContextOverflowError"
-          ? "provider.invalid-request"
-          : error.name === "StructuredOutputError" || error.name === "MessageOutputLengthError"
-            ? "provider.invalid-output"
-            : error.name === "MessageAbortedError"
-              ? "aborted"
-              : error.name === "APIError"
-                ? "provider.error"
-                : "unknown"
-  return { type, message }
-}
-
-function normalizeFinish(finish: string | undefined) {
-  if (!finish) return undefined
-  return (
-    (["stop", "length", "tool-calls", "content-filter", "error", "unknown"] as const).find(
-      (value) => value === finish,
-    ) ?? "unknown"
-  )
-}
-
-function migrateFile(part: SessionV1.FilePart) {
-  if (!part.url.startsWith("data:")) return []
-  const comma = part.url.indexOf(",")
-  if (comma < 0) return []
-  const header = part.url.slice(0, comma)
-  const payload = part.url.slice(comma + 1)
-  const data = header.endsWith(";base64")
-    ? Buffer.from(payload, "base64").toString("base64")
-    : Buffer.from(decodeURIComponent(payload)).toString("base64")
-  return [
-    {
-      data,
-      mime: part.mime,
-      source:
-        part.source?.type === "resource" ? { type: "uri" as const, uri: part.source.uri } : { type: "inline" as const },
-      ...(part.filename ? { name: part.filename } : {}),
-      ...(part.source
-        ? { mention: { text: part.source.text.value, start: part.source.text.start, end: part.source.text.end } }
-        : {}),
-    },
-  ]
-}
-
-function unavailableFile(part: SessionV1.FilePart) {
-  const label = part.filename ?? (part.source?.type === "resource" ? part.source.uri : part.url)
-  return `[Attachment unavailable after migration: ${label} (${part.mime})]`
-}
-
-function syntheticID(source: string, used: Set<string>) {
-  const prefix = source.slice(0, 16)
-  const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-  for (let salt = 0; ; salt++) {
-    const hex = new Bun.CryptoHasher("sha256").update(`v1-synthetic:${source}${salt ? `:${salt}` : ""}`).digest("hex")
-    let value = BigInt(`0x${hex}`)
-    let suffix = ""
-    while (suffix.length < 14) {
-      suffix = alphabet[Number(value % 62n)] + suffix
-      value /= 62n
-    }
-    const id = prefix + suffix
-    if (used.has(id)) continue
-    used.add(id)
-    return id
-  }
-}
-
-function serializeRecent(
-  messages: ReadonlyArray<{ row: SourceMessage; value: typeof SessionV1.Info.Type }>,
-  parts: Map<string, Array<{ row: SourcePart; value: typeof SessionV1.Part.Type }>>,
-) {
-  return messages
-    .flatMap((message) => {
-      const owned = parts.get(message.row.id)?.map((part) => part.value) ?? []
-      if (message.value.role === "user")
-        return [
-          `[User]: ${owned
-            .filter((part) => part.type === "text" && !part.ignored)
-            .map((part) => (part.type === "text" ? part.text : ""))
-            .join("\n\n")}`,
-        ]
-      return owned.flatMap((part) =>
-        part.type === "text"
-          ? [`[Assistant]: ${part.text}`]
-          : part.type === "reasoning" && part.text
-            ? [`[Assistant reasoning]: ${part.text}`]
-            : [],
-      )
-    })
-    .join("\n\n")
-}
-
-function readState(db: Database.Interface["db"]): Effect.Effect<MigrationState | undefined> {
-  return db
-    .select({ value: KVTable.value })
-    .from(KVTable)
-    .where(eq(KVTable.key, MIGRATION_STATE_KEY))
-    .get()
-    .pipe(
-      Effect.map((row) => parseState(row?.value)),
-      Effect.orDie,
-    )
-}
-
-function parseState(input: unknown): MigrationState | undefined {
-  if (!input || typeof input !== "object" || !("phase" in input)) return
-  if (input.phase === "completed") return { phase: "completed" }
-  if (input.phase !== "sessions") return
-  if (!("cursor" in input) || input.cursor === undefined) return { phase: "sessions" }
-  if (typeof input.cursor === "string") return { phase: "sessions", cursor: input.cursor }
-}
-
-function hasLegacySessions(db: Database.Interface["db"]) {
-  return db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'session'`).pipe(
-    Effect.map((row) => row !== undefined),
-    Effect.orDie,
-  )
-}

packages/core/src/database/v1-migration.noop.ts

@@ -1,11 +0,0 @@
-import { Effect, Layer } from "effect"
-
-export type Status = { readonly status: "completed" }
-
-export const layer = Layer.empty
-export function status() {
-  return Effect.succeed({ status: "completed" } as const)
-}
-export function run() {
-  return Effect.succeed({ status: "completed" } as const)
-}

packages/core/src/database/v1-migration.ts

@@ -1,2 +1,997 @@
-export * as V1Migration from "#v1-migration"
-export * from "#v1-migration"
+export * as V1Migration from "./v1-migration.js"
+
+import { Cause, Effect, Layer, Option, Schema, Semaphore } from "effect"
+import { Database } from "./database.js"
+import { SessionMessageTable, SessionTable } from "../session/sql.js"
+import { SessionV1 } from "@opencode-ai/schema/session-v1"
+import { SessionMessage } from "../session/message.js"
+import { SessionSchema } from "../session/schema.js"
+import { KVTable } from "../kv/sql.js"
+import { EventSequenceTable } from "../event/sql.js"
+import { eq, sql } from "drizzle-orm"
+import { Global } from "@opencode-ai/util/global"
+import { existsSync } from "node:fs"
+import path from "node:path"
+import type { Database as SQLiteDatabase } from "bun:sqlite"
+import { Project } from "@opencode-ai/schema/project"
+
+export type SourceMessage = {
+  readonly id: string
+  readonly session_id: string
+  readonly time_created: number
+  readonly time_updated: number
+  readonly data: string
+}
+
+export type SourcePart = {
+  readonly id: string
+  readonly message_id: string
+  readonly session_id: string
+  readonly time_created: number
+  readonly time_updated: number
+  readonly data: string
+}
+
+export type TransformInput = {
+  readonly session: typeof SessionTable.$inferSelect
+  readonly messages: ReadonlyArray<SourceMessage>
+  readonly parts: ReadonlyArray<SourcePart>
+}
+
+export type Warning = {
+  readonly reason: string
+  readonly sessionID: string
+  readonly messageID?: string
+  readonly partID?: string
+  readonly observedType?: string
+}
+
+export type TransformResult = {
+  readonly messages: ReadonlyArray<{
+    readonly id: string
+    readonly session_id: string
+    readonly type: SessionMessage.Type
+    readonly seq: number
+    readonly time_created: number
+    readonly time_updated: number
+    readonly data: Record<string, unknown>
+  }>
+  readonly session: Pick<
+    typeof SessionTable.$inferInsert,
+    | "agent"
+    | "model"
+    | "cost"
+    | "tokens_input"
+    | "tokens_output"
+    | "tokens_reasoning"
+    | "tokens_cache_read"
+    | "tokens_cache_write"
+    | "revert"
+    | "time_compacting"
+  >
+  readonly watermark: number
+  readonly warnings: ReadonlyArray<Warning>
+}
+
+type Progress = {
+  readonly label: string
+  readonly numerator?: number
+  readonly denominator?: number
+}
+
+export type Status =
+  | { readonly status: "required" | "completed" }
+  | { readonly status: "running"; readonly progress: Progress }
+  | { readonly status: "error"; readonly error: string }
+
+type RunResult = {
+  readonly status: "completed"
+}
+
+type Options = {
+  readonly nextDatabasePath?: string
+}
+
+type MigrationState = { readonly phase: "sessions"; readonly cursor?: string } | { readonly phase: "completed" }
+
+type RuntimeState =
+  | { readonly status: "idle" }
+  | { readonly status: "running"; readonly progress: Progress }
+  | { readonly status: "error"; readonly error: string }
+
+type NextProject = {
+  readonly id: string
+  readonly worktree: string
+  readonly vcs: string | null
+  readonly name: string | null
+  readonly icon_url: string | null
+  readonly icon_url_override: string | null
+  readonly icon_color: string | null
+  readonly time_created: number
+  readonly time_updated: number
+  readonly time_initialized: number | null
+  readonly sandboxes: string
+  readonly commands: string | null
+}
+
+type NextSession = {
+  readonly id: string
+  readonly project_id: string
+  readonly workspace_id: string | null
+  readonly parent_id: string | null
+  readonly fork_session_id: string | null
+  readonly fork_boundary: string | null
+  readonly slug: string
+  readonly directory: string
+  readonly path: string | null
+  readonly title: string | null
+  readonly version: string
+  readonly share_url: string | null
+  readonly summary_additions: number | null
+  readonly summary_deletions: number | null
+  readonly summary_files: number | null
+  readonly summary_diffs: string | null
+  readonly metadata: string | null
+  readonly cost: number
+  readonly tokens_input: number
+  readonly tokens_output: number
+  readonly tokens_reasoning: number
+  readonly tokens_cache_read: number
+  readonly tokens_cache_write: number
+  readonly revert: string | null
+  readonly permission: string | null
+  readonly agent: string | null
+  readonly model: string | null
+  readonly time_created: number
+  readonly time_updated: number
+  readonly time_compacting: number | null
+  readonly time_archived: number | null
+  readonly time_suspended: number | null
+}
+
+type NextMessage = {
+  readonly id: string
+  readonly session_id: string
+  readonly type: string
+  readonly seq: number
+  readonly time_created: number
+  readonly time_updated: number
+  readonly data: string
+}
+
+const lock = Semaphore.makeUnsafe(1)
+const MIGRATION_STATE_KEY = "migration.v1-v2"
+const EVENT_DELETE_BATCH_SIZE = 1_000
+const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
+const decodeMessage = Schema.decodeUnknownOption(SessionV1.Info)
+const decodePart = Schema.decodeUnknownOption(SessionV1.Part)
+let runtimeState: RuntimeState = { status: "idle" }
+
+export function transformSession(input: TransformInput): TransformResult {
+  const warnings: Warning[] = []
+  const messages = input.messages
+    .map((row) => {
+      const value = Option.getOrUndefined(decodeJson(row.data))
+      const decoded =
+        value && typeof value === "object"
+          ? Option.getOrUndefined(decodeMessage({ ...value, id: row.id, sessionID: row.session_id }))
+          : undefined
+      if (decoded) return { row, value: decoded }
+      warnings.push({ reason: "invalid-message", sessionID: input.session.id, messageID: row.id })
+      return undefined
+    })
+    .filter((item): item is NonNullable<typeof item> => item !== undefined)
+    .sort((a, b) => a.row.time_created - b.row.time_created || a.row.id.localeCompare(b.row.id))
+  const messageIDs = new Set(input.messages.map((row) => row.id))
+  const parts = input.parts
+    .map((row) => {
+      const value = Option.getOrUndefined(decodeJson(row.data))
+      const observedType = value && typeof value === "object" && "type" in value ? String(value.type) : undefined
+      if (!messageIDs.has(row.message_id)) {
+        warnings.push({
+          reason: "orphan-part",
+          sessionID: input.session.id,
+          messageID: row.message_id,
+          partID: row.id,
+          observedType,
+        })
+        return undefined
+      }
+      const decoded =
+        value && typeof value === "object"
+          ? Option.getOrUndefined(
+              decodePart({ ...value, id: row.id, messageID: row.message_id, sessionID: row.session_id }),
+            )
+          : undefined
+      if (decoded) return { row, value: decoded }
+      warnings.push({
+        reason: "invalid-part",
+        sessionID: input.session.id,
+        messageID: row.message_id,
+        partID: row.id,
+        observedType,
+      })
+      return undefined
+    })
+    .filter((item): item is NonNullable<typeof item> => item !== undefined)
+    .sort((a, b) => a.row.id.localeCompare(b.row.id))
+  const byMessage = Map.groupBy(parts, (item) => item.row.message_id)
+  const paired = new Set<string>()
+  const used = new Set(messages.map((item) => item.row.id))
+  const projected = messages
+    .flatMap((item) => {
+      if (paired.has(item.row.id)) return []
+      const owned = byMessage.get(item.row.id)?.map((part) => part.value) ?? []
+      if (item.value.role === "user") {
+        const compaction = owned.find((part) => part.type === "compaction")
+        if (compaction?.type === "compaction") {
+          const pairedSummary = messages.find(
+            (candidate) =>
+              candidate.value.role === "assistant" &&
+              candidate.value.parentID === item.row.id &&
+              candidate.value.summary,
+          )
+          if (!pairedSummary || pairedSummary.value.role !== "assistant") return []
+          paired.add(pairedSummary.row.id)
+          if (pairedSummary.value.error || pairedSummary.value.time.completed === undefined) return []
+          const summary = pairedSummary
+          const summaryText = (byMessage.get(summary.row.id) ?? [])
+            .map((part) => part.value)
+            .filter((part) => part.type === "text" && part.text.length > 0)
+            .map((part) => (part.type === "text" ? part.text : ""))
+            .join("\n\n")
+          const tailIndex = compaction.tail_start_id
+            ? messages.findIndex((candidate) => candidate.row.id === compaction.tail_start_id)
+            : -1
+          const compactionIndex = messages.findIndex((candidate) => candidate.row.id === item.row.id)
+          const tail = tailIndex < 0 ? [] : messages.slice(tailIndex, compactionIndex)
+          return [
+            row(
+              { ...item.row, time_updated: Math.max(item.row.time_updated, summary.row.time_updated) },
+              {
+                id: item.row.id,
+                type: "compaction",
+                status: "completed",
+                reason: compaction.auto ? "auto" : "manual",
+                summary: summaryText,
+                recent: serializeRecent(tail, byMessage),
+                time: { created: item.row.time_created },
+              },
+            ),
+          ]
+        }
+        const subtasks = owned.filter((part) => part.type === "subtask")
+        const visible = owned.filter((part) => part.type === "text" && !part.ignored)
+        const files = owned.filter((part) => part.type === "file")
+        const agents = owned.filter((part) => part.type === "agent")
+        if (subtasks.length > 0 && visible.length === 0 && files.length === 0 && agents.length === 0) return []
+        const ordinary = visible.filter((part) => part.type === "text" && !part.synthetic)
+        const synthetic = visible.filter((part) => part.type === "text" && part.synthetic)
+        const attachments = files.flatMap((part) => (part.type === "file" ? migrateFile(part) : []))
+        const unavailable = files.flatMap((part) =>
+          part.type === "file" && !part.url.startsWith("data:") ? [unavailableFile(part)] : [],
+        )
+        const text = owned
+          .flatMap((part) => {
+            if (part.type === "text" && !part.ignored && !part.synthetic) return [part.text]
+            if (part.type === "file" && !part.url.startsWith("data:")) return [unavailableFile(part)]
+            return []
+          })
+          .join("\n\n")
+        const agentAttachments = agents.map((part) =>
+          part.type === "agent"
+            ? {
+                name: part.name,
+                ...(part.source
+                  ? { mention: { text: part.source.value, start: part.source.start, end: part.source.end } }
+                  : {}),
+              }
+            : { name: "" },
+        )
+        if (
+          ordinary.length === 0 &&
+          unavailable.length === 0 &&
+          synthetic.length > 0 &&
+          attachments.length === 0 &&
+          agentAttachments.length === 0
+        )
+          return [
+            row(item.row, {
+              id: item.row.id,
+              type: "synthetic",
+              text: synthetic.map((part) => (part.type === "text" ? part.text : "")).join("\n\n"),
+              time: { created: item.row.time_created },
+            }),
+          ]
+        const user = row(item.row, {
+          id: item.row.id,
+          type: "user",
+          text,
+          ...(attachments.length ? { files: attachments } : {}),
+          ...(agentAttachments.length ? { agents: agentAttachments } : {}),
+          time: { created: item.row.time_created },
+        })
+        if (synthetic.length === 0) return [user]
+        return [
+          user,
+          row(item.row, {
+            id: syntheticID(item.row.id, used),
+            type: "synthetic",
+            text: synthetic.map((part) => (part.type === "text" ? part.text : "")).join("\n\n"),
+            time: { created: item.row.time_created },
+          }),
+        ]
+      }
+      if (item.value.role !== "assistant") return []
+      const assistant = item.value
+      const parent = messages.find((candidate) => candidate.row.id === assistant.parentID)
+      const parentParts = parent ? (byMessage.get(parent.row.id)?.map((part) => part.value) ?? []) : []
+      if (
+        parentParts.some((part) => part.type === "subtask") &&
+        owned.some((part) => part.type === "tool" && part.tool === "task")
+      )
+        return []
+      const content = owned.flatMap((part): Array<Record<string, unknown>> => {
+        if (part.type === "text")
+          return [{ type: "text", text: part.text, ...(part.metadata ? { state: part.metadata } : {}) }]
+        if (part.type === "reasoning")
+          return [
+            {
+              type: "reasoning",
+              text: part.text,
+              ...(part.metadata ? { state: part.metadata } : {}),
+              time: { created: part.time.start, ...(part.time.end === undefined ? {} : { completed: part.time.end }) },
+            },
+          ]
+        if (part.type !== "tool") return []
+        return [migrateTool(part, item.row.time_created)]
+      })
+      const start =
+        owned.flatMap((part) => (part.type === "step-start" && part.snapshot ? [part.snapshot] : []))[0] ??
+        owned.flatMap((part) => (part.type === "snapshot" ? [part.snapshot] : []))[0] ??
+        owned.flatMap((part) => (part.type === "patch" ? [part.hash] : []))[0]
+      const end = owned.flatMap((part) => (part.type === "step-finish" && part.snapshot ? [part.snapshot] : [])).at(-1)
+      const snapshotFiles = Array.from(new Set(owned.flatMap((part) => (part.type === "patch" ? part.files : []))))
+      const finish = normalizeFinish(assistant.finish)
+      return [
+        row(item.row, {
+          id: item.row.id,
+          type: "assistant",
+          agent: assistant.agent,
+          model: {
+            providerID: assistant.providerID,
+            id: assistant.modelID,
+            variant: assistant.variant ?? "default",
+          },
+          content,
+          ...(start || end || snapshotFiles.length
+            ? {
+                snapshot: {
+                  ...(start ? { start } : {}),
+                  ...(end ? { end } : {}),
+                  ...(snapshotFiles.length ? { files: snapshotFiles } : {}),
+                },
+              }
+            : {}),
+          ...(finish ? { finish } : {}),
+          cost: assistant.cost,
+          tokens: {
+            input: assistant.tokens.input,
+            output: assistant.tokens.output,
+            reasoning: assistant.tokens.reasoning,
+            cache: assistant.tokens.cache,
+          },
+          ...(assistant.error ? { error: migrateError(assistant.error) } : {}),
+          time: {
+            created: item.row.time_created,
+            ...(assistant.time.completed === undefined ? {} : { completed: item.row.time_updated }),
+          },
+        }),
+      ]
+    })
+    .map((item, seq) => ({ ...item, seq }))
+  const assistants = messages
+    .filter((item) => item.value.role === "assistant")
+    .map((item) => item.value)
+    .filter((item): item is SessionV1.Assistant => item.role === "assistant")
+  const latestUser = messages.findLast((item) => {
+    if (item.value.role !== "user") return false
+    const owned = byMessage.get(item.row.id) ?? []
+    if (owned.some((part) => part.value.type === "compaction")) return false
+    return !owned.some((part) => part.value.type === "subtask") || !owned.every((part) => part.value.type === "subtask")
+  })
+  return {
+    messages: projected,
+    session: {
+      agent: input.session.agent ?? (latestUser?.value.role === "user" ? latestUser.value.agent : null),
+      model:
+        input.session.model ??
+        (latestUser?.value.role === "user"
+          ? {
+              id: latestUser.value.model.modelID,
+              providerID: latestUser.value.model.providerID,
+              variant: latestUser.value.model.variant ?? "default",
+            }
+          : null),
+      cost: assistants.reduce((total, item) => total + item.cost, 0),
+      tokens_input: assistants.reduce((total, item) => total + item.tokens.input, 0),
+      tokens_output: assistants.reduce((total, item) => total + item.tokens.output, 0),
+      tokens_reasoning: assistants.reduce((total, item) => total + item.tokens.reasoning, 0),
+      tokens_cache_read: assistants.reduce((total, item) => total + item.tokens.cache.read, 0),
+      tokens_cache_write: assistants.reduce((total, item) => total + item.tokens.cache.write, 0),
+      revert: null,
+      time_compacting: null,
+    },
+    watermark: projected.length - 1,
+    warnings,
+  }
+}
+
+export function status(): Effect.Effect<Status, never, Database.Service> {
+  return Effect.gen(function* () {
+    const { db } = yield* Database.Service
+    if (!(yield* hasLegacySessions(db))) return { status: "completed" as const }
+    const state = yield* readState(db)
+    if (runtimeState.status === "running") return runtimeState
+    if (runtimeState.status === "error") return runtimeState
+    if (state?.phase === "completed") return { status: "completed" as const }
+    return { status: "required" as const }
+  }).pipe(Effect.orDie)
+}
+
+export const layer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    runtimeState = { status: "running", progress: { label: "Clearing old events" } }
+    yield* run().pipe(
+      Effect.matchCauseEffect({
+        onFailure: (cause) =>
+          Effect.sync(() => {
+            runtimeState = { status: "error", error: errorText(Cause.squash(cause)) }
+          }).pipe(Effect.andThen(Effect.logError("V1 migration failed", { cause }))),
+        onSuccess: () =>
+          Effect.sync(() => {
+            runtimeState = { status: "idle" }
+          }),
+      }),
+      Effect.forkScoped({ startImmediately: true }),
+    )
+  }),
+)
+
+function errorText(input: unknown): string {
+  if (!(input instanceof Error)) return String(input)
+  const cause = input.cause
+  return cause === undefined ? input.message : `${input.message}\nCaused by: ${errorText(cause)}`
+}
+
+function updateProgress(progress: Progress) {
+  if (runtimeState.status === "running") runtimeState = { status: "running", progress }
+}
+
+export function run(options: Options = {}): Effect.Effect<RunResult, never, Database.Service | Global.Service> {
+  return lock.withPermit(
+    Effect.gen(function* () {
+      const { db } = yield* Database.Service
+      const global = yield* Global.Service
+      const state = yield* readState(db)
+      if (state?.phase === "completed") return { status: "completed" as const }
+      if (!(yield* hasLegacySessions(db))) return { status: "completed" as const }
+      const migrate = Effect.gen(function* () {
+        const now = Date.now()
+        yield* db.run(sql`
+          INSERT OR IGNORE INTO project (id, worktree, time_created, time_updated, sandboxes)
+          VALUES (${Project.ID.global}, ${path.parse(global.data).root}, ${now}, ${now}, '[]')
+        `)
+        if (state === undefined)
+          yield* db
+            .transaction((tx) =>
+              Effect.gen(function* () {
+                while (true) {
+                  yield* tx.run(sql`
+                    DELETE FROM event
+                    WHERE rowid IN (SELECT rowid FROM event LIMIT ${EVENT_DELETE_BATCH_SIZE})
+                  `)
+                  const deleted = (yield* tx.get<{ value: number }>(sql`SELECT changes() AS value`))?.value ?? 0
+                  if (deleted < EVENT_DELETE_BATCH_SIZE) break
+                  yield* Effect.yieldNow
+                }
+                yield* tx
+                  .insert(KVTable)
+                  .values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions" } })
+                  .run()
+              }),
+            )
+            .pipe(Effect.orDie)
+        const sourceTotal = yield* countNextSessions(nextPath(options, global.data))
+        const legacyTotal = (yield* db.get<{ value: number }>(sql`SELECT COUNT(*) AS value FROM session`))?.value ?? 0
+        const cursor = state?.phase === "sessions" ? state.cursor : undefined
+        const migrated =
+          cursor !== undefined
+            ? ((yield* db.get<{ value: number }>(sql`SELECT COUNT(*) AS value FROM session WHERE id >= ${cursor}`))
+                ?.value ?? 0)
+            : 0
+        const denominator = sourceTotal + legacyTotal
+        updateProgress({ label: "Migrating sessions", numerator: migrated, denominator })
+        yield* importNextDatabase(db, nextPath(options, global.data), (completed) => {
+          updateProgress({ label: "Migrating sessions", numerator: migrated + completed, denominator })
+        })
+        updateProgress({ label: "Migrating sessions", numerator: migrated + sourceTotal, denominator })
+        const projects = new Set(
+          (yield* db.all<{ id: string }>(sql`SELECT id FROM project`)).map((project) => project.id),
+        )
+        while (true) {
+          const state = yield* readState(db)
+          const cursorValue = state?.phase === "sessions" ? state.cursor : undefined
+          const nextID = yield* db.get<{ id: string; project_id: string }>(
+            cursorValue === undefined
+              ? sql`SELECT id, project_id FROM session ORDER BY id DESC LIMIT 1`
+              : sql`SELECT id, project_id FROM session WHERE id < ${cursorValue} ORDER BY id DESC LIMIT 1`,
+          )
+          if (!nextID) break
+          yield* db
+            .transaction((tx) =>
+              Effect.gen(function* () {
+                yield* tx
+                  .insert(KVTable)
+                  .values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions", cursor: nextID.id } })
+                  .onConflictDoUpdate({
+                    target: KVTable.key,
+                    set: { value: { phase: "sessions", cursor: nextID.id }, time_updated: Date.now() },
+                  })
+                  .run()
+                const projectID = projects.has(nextID.project_id) ? nextID.project_id : Project.ID.global
+                if (projectID !== nextID.project_id)
+                  yield* Effect.logWarning("Reassigned V1 session with missing project", {
+                    sessionID: nextID.id,
+                    projectID: nextID.project_id,
+                  })
+                yield* tx.run(sql`
+                  INSERT OR IGNORE INTO session_v2 (
+                    id, project_id, workspace_id, parent_id, slug, directory, path, title, version, share_url,
+                    summary_additions, summary_deletions, summary_files, summary_diffs, metadata, cost,
+                    tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write,
+                    revert, permission, agent, model, time_created, time_updated, time_compacting, time_archived
+                  )
+                  SELECT
+                    id, ${projectID}, workspace_id, parent_id, slug, directory, path, title, version, share_url,
+                    summary_additions, summary_deletions, summary_files, summary_diffs, metadata, cost,
+                    tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write,
+                    revert, permission, agent, model, time_created, time_updated, time_compacting, time_archived
+                  FROM session
+                  WHERE id = ${nextID.id}
+                `)
+                const next = yield* tx
+                  .select()
+                  .from(SessionTable)
+                  .where(eq(SessionTable.id, SessionSchema.ID.make(nextID.id)))
+                  .get()
+                if (!next) return yield* Effect.die(new Error(`Failed to copy V1 session ${nextID.id}`))
+                const sourceMessages = yield* tx.all<SourceMessage>(
+                  sql`SELECT id, session_id, time_created, time_updated, data FROM message WHERE session_id = ${next.id}`,
+                )
+                const sourceParts = yield* tx.all<SourcePart>(
+                  sql`SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE session_id = ${next.id}`,
+                )
+                const transformed = transformSession({ session: next, messages: sourceMessages, parts: sourceParts })
+                yield* Effect.forEach(transformed.warnings, (warning) =>
+                  Effect.logWarning("Skipped V1 migration row", warning),
+                )
+                yield* tx.delete(SessionMessageTable).where(eq(SessionMessageTable.session_id, next.id)).run()
+                yield* Effect.forEach(transformed.messages, (message) =>
+                  tx
+                    .insert(SessionMessageTable)
+                    .values({
+                      id: SessionMessage.ID.make(message.id),
+                      session_id: SessionSchema.ID.make(message.session_id),
+                      type: message.type,
+                      seq: message.seq,
+                      time_created: message.time_created,
+                      time_updated: message.time_updated,
+                      data: sql`${JSON.stringify(message.data)}`,
+                    })
+                    .run(),
+                )
+                yield* tx
+                  .update(SessionTable)
+                  .set({ ...transformed.session, time_updated: next.time_updated })
+                  .where(eq(SessionTable.id, next.id))
+                  .run()
+                yield* tx
+                  .insert(EventSequenceTable)
+                  .values({ aggregate_id: next.id, seq: transformed.watermark })
+                  .onConflictDoUpdate({
+                    target: EventSequenceTable.aggregate_id,
+                    set: { seq: transformed.watermark, owner_id: null },
+                  })
+                  .run()
+              }),
+            )
+            .pipe(Effect.orDie)
+          if (runtimeState.status === "running")
+            runtimeState = {
+              status: "running",
+              progress: {
+                label: "Migrating sessions",
+                numerator: (runtimeState.progress.numerator ?? 0) + 1,
+                denominator,
+              },
+            }
+          yield* Effect.yieldNow
+        }
+        yield* db
+          .transaction((tx) =>
+            Effect.gen(function* () {
+              yield* tx
+                .insert(KVTable)
+                .values({ key: MIGRATION_STATE_KEY, value: { phase: "completed" } })
+                .onConflictDoUpdate({
+                  target: KVTable.key,
+                  set: { value: { phase: "completed" }, time_updated: Date.now() },
+                })
+                .run()
+            }),
+          )
+          .pipe(Effect.orDie)
+        return { status: "completed" as const }
+      })
+      return yield* migrate
+    }).pipe(Effect.orDie),
+  )
+}
+
+function nextPath(options: Options, data: string) {
+  if (options.nextDatabasePath) return options.nextDatabasePath
+  if (process.env.OPENCODE_DB === ":memory:") return undefined
+  return path.join(data, "opencode-next.db")
+}
+
+function openNextDatabase(sourcePath: string) {
+  return Effect.acquireRelease(
+    Effect.gen(function* () {
+      const sqlite = yield* Effect.promise(() => import("bun:sqlite"))
+      return new sqlite.Database(sourcePath, { readonly: true, strict: true })
+    }),
+    (source) => Effect.sync(() => source.close()),
+  )
+}
+
+function countNextSessions(sourcePath: string | undefined) {
+  if (!sourcePath || !existsSync(sourcePath)) return Effect.succeed(0)
+  return Effect.scoped(
+    Effect.gen(function* () {
+      const source = yield* openNextDatabase(sourcePath)
+      if (!isNextDatabase(source)) return 0
+      return source.query<{ value: number }, []>("SELECT COUNT(*) AS value FROM session").get()?.value ?? 0
+    }),
+  ).pipe(Effect.orElseSucceed(() => 0))
+}
+
+function importNextDatabase(
+  db: Database.Interface["db"],
+  sourcePath: string | undefined,
+  onProgress: (completed: number) => void,
+): Effect.Effect<void, unknown> {
+  if (!sourcePath || !existsSync(sourcePath)) return Effect.void
+  return Effect.scoped(
+    Effect.gen(function* () {
+      const source = yield* openNextDatabase(sourcePath)
+      if (!isNextDatabase(source)) {
+        yield* Effect.logWarning("Skipped incompatible opencode-next.db", { path: sourcePath })
+        return
+      }
+      source.run("BEGIN")
+      yield* Effect.addFinalizer(() =>
+        Effect.sync(() => {
+          if (source.inTransaction) source.run("ROLLBACK")
+        }),
+      )
+      const projects = new Map(
+        source
+          .query<NextProject, []>("SELECT * FROM project")
+          .all()
+          .map((project) => [project.id, project]),
+      )
+      const sessions = source.query<NextSession, []>("SELECT * FROM session ORDER BY id DESC").all()
+      for (const [index, session] of sessions.entries()) {
+        const project = projects.get(session.project_id)
+        const projectID = project ? session.project_id : Project.ID.global
+        if (!project) {
+          yield* Effect.logWarning("Reassigned previous V2 session with missing project", {
+            sessionID: session.id,
+            projectID: session.project_id,
+          })
+        }
+        const messages = source
+          .query<
+            NextMessage,
+            [string]
+          >("SELECT id, session_id, type, seq, time_created, time_updated, data FROM session_message WHERE session_id = ? ORDER BY seq")
+          .all(session.id)
+        yield* db
+          .transaction((tx) =>
+            Effect.gen(function* () {
+              if (project)
+                yield* tx.run(sql`
+                  INSERT OR IGNORE INTO project (
+                    id, worktree, vcs, name, icon_url, icon_url_override, icon_color,
+                    time_created, time_updated, time_initialized, sandboxes, commands
+                  ) VALUES (
+                    ${project.id}, ${project.worktree}, ${project.vcs}, ${project.name}, ${project.icon_url},
+                    ${project.icon_url_override}, ${project.icon_color}, ${project.time_created}, ${project.time_updated},
+                    ${project.time_initialized}, ${project.sandboxes}, ${project.commands}
+                  )
+                `)
+              const existing = yield* tx
+                .select({ id: SessionTable.id })
+                .from(SessionTable)
+                .where(eq(SessionTable.id, SessionSchema.ID.make(session.id)))
+                .get()
+              if (existing) return
+              yield* tx.run(sql`
+                INSERT INTO session_v2 (
+                  id, project_id, workspace_id, parent_id, fork_session_id, fork_boundary, slug, directory,
+                  path, title, version, share_url, summary_additions, summary_deletions, summary_files,
+                  summary_diffs, metadata, cost, tokens_input, tokens_output, tokens_reasoning, tokens_cache_read,
+                  tokens_cache_write, revert, permission, agent, model, time_created, time_updated, time_compacting,
+                  time_archived, time_suspended
+                ) VALUES (
+                  ${session.id}, ${projectID}, ${session.workspace_id}, ${session.parent_id},
+                  ${session.fork_session_id}, ${session.fork_boundary}, ${session.slug}, ${session.directory},
+                  ${session.path}, ${session.title}, ${session.version}, ${session.share_url},
+                  ${session.summary_additions}, ${session.summary_deletions}, ${session.summary_files},
+                  ${session.summary_diffs}, ${session.metadata}, ${session.cost}, ${session.tokens_input},
+                  ${session.tokens_output}, ${session.tokens_reasoning}, ${session.tokens_cache_read},
+                  ${session.tokens_cache_write}, ${session.revert}, ${session.permission}, ${session.agent},
+                  ${session.model}, ${session.time_created}, ${session.time_updated}, ${session.time_compacting},
+                  ${session.time_archived}, ${session.time_suspended}
+                )
+              `)
+              yield* Effect.forEach(messages, (message) =>
+                tx
+                  .insert(SessionMessageTable)
+                  .values({
+                    id: SessionMessage.ID.make(message.id),
+                    session_id: SessionSchema.ID.make(message.session_id),
+                    type: message.type as SessionMessage.Type,
+                    seq: message.seq,
+                    time_created: message.time_created,
+                    time_updated: message.time_updated,
+                    data: sql`${message.data}`,
+                  })
+                  .run(),
+              )
+              yield* tx
+                .insert(EventSequenceTable)
+                .values({ aggregate_id: session.id, seq: messages.at(-1)?.seq ?? -1 })
+                .onConflictDoUpdate({
+                  target: EventSequenceTable.aggregate_id,
+                  set: { seq: messages.at(-1)?.seq ?? -1, owner_id: null },
+                })
+                .run()
+            }),
+          )
+          .pipe(Effect.orDie)
+        onProgress(index + 1)
+        yield* Effect.yieldNow
+      }
+      source.run("COMMIT")
+    }),
+  )
+}
+
+function isNextDatabase(source: SQLiteDatabase) {
+  const tables = new Set(
+    source
+      .query<{ name: string }, []>("SELECT name FROM sqlite_master WHERE type = 'table'")
+      .all()
+      .map((table) => table.name),
+  )
+  return tables.has("project") && tables.has("session") && tables.has("session_message")
+}
+
+function row(
+  source: SourceMessage,
+  message: {
+    readonly id: string
+    readonly type: SessionMessage.Type
+    readonly time: { readonly created: number }
+    readonly [key: string]: unknown
+  },
+): TransformResult["messages"][number] {
+  const { id, type, ...data } = message
+  return {
+    id,
+    session_id: source.session_id,
+    type,
+    seq: 0,
+    time_created: source.time_created,
+    time_updated: source.time_updated,
+    data,
+  }
+}
+
+function migrateTool(part: typeof SessionV1.ToolPart.Type, fallback: number) {
+  const base = {
+    type: "tool" as const,
+    id: part.callID,
+    name: part.tool,
+    ...(part.metadata ? { providerState: part.metadata } : {}),
+  }
+  if (part.state.status === "completed")
+    return {
+      ...base,
+      state: {
+        status: "completed",
+        input: part.state.input,
+        content:
+          part.state.time.compacted === undefined
+            ? [
+                { type: "text", text: part.state.output },
+                ...(part.state.attachments ?? []).map((file) => ({
+                  type: "file" as const,
+                  uri: file.url,
+                  mime: file.mime,
+                  ...(file.filename ? { name: file.filename } : {}),
+                })),
+              ]
+            : [{ type: "text", text: "[Old tool result content cleared]" }],
+        metadata: part.state.metadata,
+      },
+      time: { created: part.state.time.start, completed: part.state.time.end },
+    }
+  if (part.state.status === "error")
+    return {
+      ...base,
+      state: {
+        status: "error",
+        input: part.state.input,
+        error: { type: "tool.execution", message: part.state.error },
+        ...(typeof part.state.metadata?.output === "string"
+          ? { content: [{ type: "text", text: part.state.metadata.output }] }
+          : {}),
+        ...(part.state.metadata ? { metadata: part.state.metadata } : {}),
+      },
+      time: { created: part.state.time.start, completed: part.state.time.end },
+    }
+  return {
+    ...base,
+    state: {
+      status: "error",
+      input: part.state.input,
+      error: { type: "tool.interrupted", message: "Tool execution was interrupted before V2 migration" },
+      ...(part.state.status === "running" && part.state.metadata ? { metadata: part.state.metadata } : {}),
+    },
+    time: { created: part.state.status === "running" ? part.state.time.start : fallback },
+  }
+}
+
+function migrateError(error: NonNullable<(typeof SessionV1.Assistant.Type)["error"]>) {
+  const message =
+    "message" in error.data
+      ? error.data.message
+      : error.name === "MessageOutputLengthError"
+        ? "The model exceeded its output limit"
+        : error.name
+  const type =
+    error.name === "ProviderAuthError"
+      ? "provider.auth"
+      : error.name === "ContentFilterError"
+        ? "provider.content-filter"
+        : error.name === "ContextOverflowError"
+          ? "provider.invalid-request"
+          : error.name === "StructuredOutputError" || error.name === "MessageOutputLengthError"
+            ? "provider.invalid-output"
+            : error.name === "MessageAbortedError"
+              ? "aborted"
+              : error.name === "APIError"
+                ? "provider.error"
+                : "unknown"
+  return { type, message }
+}
+
+function normalizeFinish(finish: string | undefined) {
+  if (!finish) return undefined
+  return (
+    (["stop", "length", "tool-calls", "content-filter", "error", "unknown"] as const).find(
+      (value) => value === finish,
+    ) ?? "unknown"
+  )
+}
+
+function migrateFile(part: SessionV1.FilePart) {
+  if (!part.url.startsWith("data:")) return []
+  const comma = part.url.indexOf(",")
+  if (comma < 0) return []
+  const header = part.url.slice(0, comma)
+  const payload = part.url.slice(comma + 1)
+  const data = header.endsWith(";base64")
+    ? Buffer.from(payload, "base64").toString("base64")
+    : Buffer.from(decodeURIComponent(payload)).toString("base64")
+  return [
+    {
+      data,
+      mime: part.mime,
+      source:
+        part.source?.type === "resource" ? { type: "uri" as const, uri: part.source.uri } : { type: "inline" as const },
+      ...(part.filename ? { name: part.filename } : {}),
+      ...(part.source
+        ? { mention: { text: part.source.text.value, start: part.source.text.start, end: part.source.text.end } }
+        : {}),
+    },
+  ]
+}
+
+function unavailableFile(part: SessionV1.FilePart) {
+  const label = part.filename ?? (part.source?.type === "resource" ? part.source.uri : part.url)
+  return `[Attachment unavailable after migration: ${label} (${part.mime})]`
+}
+
+function syntheticID(source: string, used: Set<string>) {
+  const prefix = source.slice(0, 16)
+  const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+  for (let salt = 0; ; salt++) {
+    const hex = new Bun.CryptoHasher("sha256").update(`v1-synthetic:${source}${salt ? `:${salt}` : ""}`).digest("hex")
+    let value = BigInt(`0x${hex}`)
+    let suffix = ""
+    while (suffix.length < 14) {
+      suffix = alphabet[Number(value % 62n)] + suffix
+      value /= 62n
+    }
+    const id = prefix + suffix
+    if (used.has(id)) continue
+    used.add(id)
+    return id
+  }
+}
+
+function serializeRecent(
+  messages: ReadonlyArray<{ row: SourceMessage; value: typeof SessionV1.Info.Type }>,
+  parts: Map<string, Array<{ row: SourcePart; value: typeof SessionV1.Part.Type }>>,
+) {
+  return messages
+    .flatMap((message) => {
+      const owned = parts.get(message.row.id)?.map((part) => part.value) ?? []
+      if (message.value.role === "user")
+        return [
+          `[User]: ${owned
+            .filter((part) => part.type === "text" && !part.ignored)
+            .map((part) => (part.type === "text" ? part.text : ""))
+            .join("\n\n")}`,
+        ]
+      return owned.flatMap((part) =>
+        part.type === "text"
+          ? [`[Assistant]: ${part.text}`]
+          : part.type === "reasoning" && part.text
+            ? [`[Assistant reasoning]: ${part.text}`]
+            : [],
+      )
+    })
+    .join("\n\n")
+}
+
+function readState(db: Database.Interface["db"]): Effect.Effect<MigrationState | undefined> {
+  return db
+    .select({ value: KVTable.value })
+    .from(KVTable)
+    .where(eq(KVTable.key, MIGRATION_STATE_KEY))
+    .get()
+    .pipe(
+      Effect.map((row) => parseState(row?.value)),
+      Effect.orDie,
+    )
+}
+
+function parseState(input: unknown): MigrationState | undefined {
+  if (!input || typeof input !== "object" || !("phase" in input)) return
+  if (input.phase === "completed") return { phase: "completed" }
+  if (input.phase !== "sessions") return
+  if (!("cursor" in input) || input.cursor === undefined) return { phase: "sessions" }
+  if (typeof input.cursor === "string") return { phase: "sessions", cursor: input.cursor }
+}
+
+function hasLegacySessions(db: Database.Interface["db"]) {
+  return db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'session'`).pipe(
+    Effect.map((row) => row !== undefined),
+    Effect.orDie,
+  )
+}

packages/core/src/plugin/system-prompt.ts

@@ -23,11 +23,7 @@ export const GooglePlugin = make("google", (id) => (id.includes("gemini-") ? PRO
 export const AnthropicPlugin = make("anthropic", (id) => (id.includes("claude") ? PROMPT_ANTHROPIC : undefined))
 export const KimiPlugin = make("kimi", (id) => (id.includes("kimi") ? PROMPT_KIMI : undefined))
 export const ArceePlugin = make("arcee", (id) => (id.includes("trinity") ? PROMPT_TRINITY : undefined))
-export const MetaPlugin = make("meta", (id) => {
-  if (!id.includes("muse")) return
-  const name = id.includes("muse-glimmer") ? "Muse Glimmer" : "Muse Spark"
-  return PROMPT_META.replaceAll("{{MODEL_NAME}}", name)
-})
+export const MetaPlugin = make("meta", (id) => (id.includes("muse-spark") ? PROMPT_META : undefined))
 
 export const Plugins = [OpenAIPlugin, GooglePlugin, AnthropicPlugin, KimiPlugin, ArceePlugin, MetaPlugin] as const
 

packages/core/src/plugin/system-prompt/meta.txt

@@ -1,4 +1,4 @@
-You are OpenCode, a coding agent that helps users with software engineering tasks. You are powered by {{MODEL_NAME}}, a large language model trained by Meta MSL.
+You are OpenCode, a coding agent that helps users with software engineering tasks. You are powered by Muse Spark, a large language model trained by Meta MSL.
 
 Use the instructions below and the tools available to assist the user.
 
@@ -55,5 +55,5 @@ Use the instructions below and the tools available to assist the user.
 - NEVER use comments as a place for long-winded chain-of-thought. Long thinking texts must be generated as private reasoning. Comments in code must be appropriately concise.
 
 # User Help & Feedback
-- Users can give feedback or report issues at https://github.com/anomalyco/opencode and mention that they are using Meta {{MODEL_NAME}}.
+- Users can give feedback or report issues at https://github.com/anomalyco/opencode and mention that they are using Meta Muse Spark.
 - When users ask directly about OpenCode (eg. "can OpenCode do...", "are you able to do...") or its features (eg. implement a hook, write a slash command, or install an MCP server), use the `webfetch` tool to gather information to answer the question from the V2 OpenCode docs at https://opencode.ai/v2/docs/.

packages/core/src/session/runner/llm.ts

@@ -113,8 +113,8 @@ const layer = Layer.effect(
     const compaction = yield* SessionCompaction.Service
     const title = yield* SessionTitle.Service
     const toolOutput = yield* ToolOutput.Service
-    // Title generation starts once input is visible and must not delay model execution.
-    // The in-flight set coalesces overlapping prompts while title presence records success durably.
+    // Title generation is a side effect of a successful step; it must not delay continuation.
+    // The in-flight set coalesces overlapping steps while title presence records success durably.
     const titlesRunning = new Set<SessionSchema.ID>()
     const forkTitle = yield* FiberSet.makeRuntime<never, void, never>()
     /**
@@ -144,6 +144,7 @@ const layer = Layer.effect(
       let step = 1
       while (true) {
         const result = yield* runStep(sessionID, promotable, step)
+        if (step === 1) yield* startTitle(sessionID)
         yield* runPendingCompaction(sessionID)
         if (!result.needsContinuation && !(yield* SessionPending.has(db, sessionID, "steer"))) return
         promotable = "steer"
@@ -235,7 +236,6 @@ const layer = Layer.effect(
       // a blocked first step leaves pending inputs untouched.
       yield* InstructionState.prepare(db, bus, selected.instructions, selected.session.id)
       const promoted = promotable ? yield* SessionPending.promote(db, bus, selected.session.id, promotable) : 0
-      if (promoted > 0) yield* startTitle(sessionID)
       // Promoted input opens a fresh step allowance.
       const currentStep = promoted > 0 ? 1 : step
       const loaded = yield* context.load(selected)

packages/core/src/session/runner/retry.ts

@@ -48,12 +48,10 @@ export const schedule = (
   assistantMessageID: () => SessionMessage.ID,
 ) =>
   Schedule.max([Schedule.exponential("2 seconds"), Schedule.recurs(4)]).pipe(
-    Schedule.jittered,
     Schedule.setInputType<RetryableFailure>(),
     Schedule.modifyDelay(({ input: failure, duration: delay }) => {
       const minimum = retryAfter(failure)
-      const duration = minimum === undefined ? delay : Duration.max(delay, Duration.millis(minimum))
-      return Effect.succeed(Duration.millis(Math.ceil(Duration.toMillis(duration))))
+      return Effect.succeed(minimum === undefined ? delay : Duration.max(delay, Duration.millis(minimum)))
     }),
     Schedule.tap((metadata) =>
       bus.publish(SessionEvent.RetryScheduled, {

packages/core/src/session/runner/to-llm-message.ts

@@ -1,6 +1,5 @@
 import { Message, ToolCallPart, ToolResultPart, type ContentPart, type ProviderMetadata } from "@opencode-ai/ai"
 import { Option, Schema } from "effect"
-import { fileURLToPath } from "url"
 import type { Model } from "../../model.js"
 import { SessionMessage } from "../message.js"
 import type { FileAttachment } from "@opencode-ai/schema/prompt"
@@ -15,17 +14,6 @@ const media = (file: FileAttachment): ContentPart => ({
   metadata: file.description === undefined ? undefined : { description: file.description },
 })
 
-const attachmentLocation = (file: FileAttachment) => {
-  if (file.source.type !== "uri") return undefined
-  const url = URL.parse(file.source.uri)
-  if (url?.protocol !== "file:") return undefined
-  try {
-    return fileURLToPath(url)
-  } catch {
-    return undefined
-  }
-}
-
 const textAttachment = (file: FileAttachment): ContentPart => ({
   type: "text",
   text: `\n\n${[
@@ -48,7 +36,7 @@ const textAttachment = (file: FileAttachment): ContentPart => ({
 const directoryAttachment = (file: FileAttachment): ContentPart => ({
   type: "text",
   text: `\n\n${[
-    `Attached directory: ${attachmentLocation(file) ?? file.name ?? (file.source.type === "uri" ? file.source.uri : "directory")}`,
+    `Attached directory: ${file.name ?? (file.source.type === "uri" ? file.source.uri : "directory")}`,
     file.description === undefined ? undefined : `Description: ${file.description}`,
     file.data.length === 0 ? undefined : "",
     file.data.length === 0 ? undefined : Buffer.from(file.data, "base64").toString("utf8"),
@@ -67,10 +55,7 @@ const directoryAttachment = (file: FileAttachment): ContentPart => ({
 const attachmentContent = (file: FileAttachment): ContentPart[] => {
   if (file.mime === "text/plain") return [textAttachment(file)]
   if (file.mime === "application/x-directory") return [directoryAttachment(file)]
-  if (imageMimes.has(file.mime)) {
-    const location = attachmentLocation(file)
-    return [...(location === undefined ? [] : [Message.text(`Attached file: ${location}`)]), media(file)]
-  }
+  if (imageMimes.has(file.mime)) return [media(file)]
   return []
 }
 

packages/core/test/aisdk.test.ts

@@ -49,9 +49,7 @@ const client = LLMClient.layer.pipe(
   Layer.provide(
     Layer.succeed(
       RequestExecutor.Service,
-      RequestExecutor.Service.of({
-        execute: () => Effect.die("Unexpected HTTP request"),
-      }),
+      RequestExecutor.Service.of({ execute: () => Effect.die("Unexpected HTTP request") }),
     ),
   ),
 )
@@ -544,12 +542,7 @@ it.effect("retries status-less AI SDK transport failures", () =>
         isRetryable: true,
       }),
     )
-    expect(error.reason).toMatchObject({
-      _tag: "Transport",
-      transport: "http",
-      operation: "request",
-      code: "AI_APICallError",
-    })
+    expect(error.reason).toMatchObject({ _tag: "Transport", kind: "AI_APICallError" })
     expect(SessionRunnerRetry.isRetryable(error)).toBeTrue()
     expect("http" in error.reason ? error.reason.http?.request.url : undefined).toBe("https://api.example.com/chat")
   }),

packages/core/test/file-mutation.test.ts

@@ -5,7 +5,7 @@ import { Deferred, Effect, Fiber, Layer } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FileMutation } from "@opencode-ai/core/file-mutation"
-import { Environment } from "@opencode-ai/core/environment/index"
+import { Environment } from "@opencode-ai/core/environment"
 import { Location } from "@opencode-ai/core/location"
 import { LocationMutation } from "@opencode-ai/core/location-mutation"
 import { AbsolutePath } from "@opencode-ai/core/schema"

packages/core/test/fixture/environment.ts

@@ -1,5 +1,5 @@
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Environment } from "@opencode-ai/core/environment/index"
+import { Environment } from "@opencode-ai/core/environment"
 import { Location } from "@opencode-ai/core/location"
 import { Effect, Layer } from "effect"
 

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

@@ -7,7 +7,7 @@ import { Bus } from "@opencode-ai/core/bus"
 import { ConfigInstructionPlugin } from "@opencode-ai/core/config/plugin/instruction"
 import { Watcher } from "@opencode-ai/core/filesystem/watcher"
 import { InstructionDiscovery } from "@opencode-ai/core/instruction-discovery"
-import { Instructions } from "@opencode-ai/core/instructions/index"
+import { Instructions } from "@opencode-ai/core/instructions"
 import { Location } from "@opencode-ai/core/location"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { FSUtil } from "@opencode-ai/util/fs-util"

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

@@ -7,7 +7,7 @@ import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Bus } from "@opencode-ai/core/bus"
 import { Event } from "@opencode-ai/schema/event"
 import { EventTable } from "@opencode-ai/core/event/sql"
-import { Instructions } from "@opencode-ai/core/instructions/index"
+import { Instructions } from "@opencode-ai/core/instructions"
 import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"

packages/core/test/instructions/index.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Cause, Effect, Exit, Option, Schema } from "effect"
-import { Instructions } from "@opencode-ai/core/instructions/index"
+import { Instructions } from "@opencode-ai/core/instructions"
 import { it } from "../lib/effect"
 
 const key = (value: string) => Instructions.Key.make(value)

packages/core/test/lib/environment-conformance.ts

@@ -1,6 +1,7 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { Failed, NotFound, WrongKind, type Files } from "@opencode-ai/core/environment/index"
+import { Failed, NotFound, WrongKind, type Files } from "../../src/environment/index"
+import { it } from "./effect"
 
 export interface EnvironmentHarness {
   readonly files: Files
@@ -15,21 +16,17 @@ export const environmentConformance = <E>(
   skip = false,
 ) => {
   const check = <A, E2>(title: string, body: (harness: EnvironmentHarness) => Effect.Effect<A, E2>) =>
-    test(title, () =>
-      Effect.runPromise(
-        Effect.scoped(
+    it.live(title, () =>
+      Effect.gen(function* () {
+        const harness = yield* Effect.acquireRelease(makeHarness(), (harness) =>
           Effect.gen(function* () {
-            const harness = yield* Effect.acquireRelease(makeHarness(), (harness) =>
-              Effect.gen(function* () {
-                yield* Effect.ignore(harness.files.remove(harness.root))
-                if (harness.dispose) yield* harness.dispose
-              }),
-            )
-            yield* harness.files.mkdir(harness.root)
-            return yield* body(harness)
+            yield* Effect.ignore(harness.files.remove(harness.root))
+            if (harness.dispose) yield* harness.dispose
           }),
-        ),
-      ),
+        )
+        yield* harness.files.mkdir(harness.root)
+        return yield* body(harness)
+      }),
     )
 
   const bytes = (value: string) => new TextEncoder().encode(value)

packages/core/test/lib/instructions.ts

@@ -1,5 +1,5 @@
 import { Effect, Option, Schema } from "effect"
-import { Instructions } from "@opencode-ai/core/instructions/index"
+import { Instructions } from "@opencode-ai/core/instructions"
 
 export interface State {
   readonly values: Readonly<Record<string, Schema.Json>>

packages/core/test/mcp.test.ts

@@ -248,12 +248,6 @@ const mcp = Layer.mock(MCP.Service, {
           required: ["ok"],
         },
       }),
-      new MCP.Tool({
-        server: MCP.ServerName.make("demo"),
-        name: "status",
-        description: "Status",
-        inputSchema: { type: "object", properties: {} },
-      }),
       new MCP.Tool({
         server: MCP.ServerName.make("direct"),
         name: "lookup",
@@ -296,13 +290,6 @@ const mcp = Layer.mock(MCP.Service, {
             { type: "media", data: "aGVsbG8=", mimeType: "image/png" },
           ],
         })
-      if (input.name === "status")
-        return new MCP.ToolResult({
-          server: MCP.ServerName.make(input.server),
-          tool: input.name,
-          isError: false,
-          content: [{ type: "text", text: "hello" }],
-        })
       return new MCP.ToolResult({
         server: MCP.ServerName.make(input.server),
         tool: input.name,
@@ -997,31 +984,6 @@ it.effect("advertises MCP output schemas to Code Mode", () =>
   }),
 )
 
-it.effect("returns content-only MCP results through Code Mode", () =>
-  Effect.gen(function* () {
-    assertion = yield* Deferred.make<Permission.AssertInput>()
-    decision = Effect.void
-    const registry = yield* Tool.Service
-    const toolSet = yield* waitForCodeModeTool(registry, "demo.status")
-
-    const execution = yield* toolSet.execute({
-      sessionID: Session.ID.make("ses_mcp_content_only"),
-      ...toolIdentity,
-      call: {
-        type: "tool-call",
-        id: "call_mcp_content_only",
-        name: "execute",
-        input: { code: "return await tools.demo.status({})" },
-      },
-    })
-
-    expect(execution).toMatchObject({
-      output: { output: "hello", toolCalls: [{ tool: "demo.status", status: "completed" }] },
-      content: [{ type: "text", text: "hello" }],
-    })
-  }),
-)
-
 it.effect("advertises MCP tools directly when Code Mode is disabled for the server", () =>
   Effect.gen(function* () {
     const registry = yield* Tool.Service

packages/core/test/plugin/promise.test.ts

@@ -393,45 +393,4 @@ describe("fromPromise", () => {
       expect(progress).toEqual([{ phase: "greeting" }])
     }),
   )
-
-  it.effect("returns content-only plugin results through Code Mode", () =>
-    Effect.gen(function* () {
-      const plugins = yield* Plugin.Service
-      const registry = yield* Tool.Service
-      const host = yield* PluginHost.make(plugins)
-      const promisePlugin = define({
-        id: "content-only-tool",
-        setup: async (ctx) => {
-          await ctx.tool.transform((tools) => {
-            tools.add({
-              name: "demo_status",
-              description: "Returns a status string",
-              input: Schema.Struct({}),
-              execute: async () => ({ content: [{ type: "text", text: "hello" }] }),
-              options: { codemode: true },
-            })
-          })
-        },
-      })
-
-      yield* PluginPromise.fromPromise(promisePlugin).effect(host)
-
-      const toolSet = yield* registry.snapshot()
-      const throughCodeMode = yield* toolSet.execute({
-        sessionID: Session.ID.make("ses_content_only_tool"),
-        agent: Agent.ID.make("build"),
-        messageID: SessionMessage.ID.make("msg_content_only_tool"),
-        call: {
-          type: "tool-call",
-          id: "call_content_only_tool",
-          name: "execute",
-          input: { code: "return await tools.demo_status({})" },
-        },
-      })
-      expect(throughCodeMode).toMatchObject({
-        output: { output: "hello", toolCalls: [{ tool: "demo_status", status: "completed" }] },
-        content: [{ type: "text", text: "hello" }],
-      })
-    }),
-  )
 })

packages/core/test/plugin/system-prompt.test.ts

@@ -90,36 +90,6 @@ describe("SystemPromptPlugin", () => {
     }),
   )
 
-  it.effect("selects the Meta prompt for Muse family model IDs", () =>
-    Effect.gen(function* () {
-      const hooks = yield* PluginHooks.Service
-      const pluginHost = yield* makeHost
-      yield* SystemPromptPlugin.MetaPlugin.effect(pluginHost)
-
-      yield* Effect.forEach(
-        [
-          ["meta/muse-spark-preview", "Muse Spark"],
-          ["muse-spark-1.2", "Muse Spark"],
-          ["meta/muse-glimmer-30b", "Muse Glimmer"],
-          ["muse-glimmer-30b", "Muse Glimmer"],
-        ] as const,
-        ([id, name]) => {
-          const event = context(id)
-          return hooks.trigger("session", "context", event).pipe(
-            Effect.tap(() =>
-              Effect.sync(() => {
-                expect(event.system[0]?.text).toContain(`powered by ${name},`)
-                expect(event.system[0]?.text).toContain(`using Meta ${name}.`)
-                expect(event.system[0]?.text).not.toContain("{{MODEL_NAME}}")
-              }),
-            ),
-          )
-        },
-        { discard: true },
-      )
-    }),
-  )
-
   it.effect("preserves an explicit agent system prompt", () =>
     Effect.gen(function* () {
       const agents = yield* Agent.Service

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

@@ -39,9 +39,7 @@ describe("toSessionError", () => {
     )
     expect(toSessionError(llm(new QuotaExceededReason({ message: "quota" }))).type).toBe("provider.quota")
     expect(toSessionError(llm(new ContentPolicyReason({ message: "blocked" }))).type).toBe("provider.content-filter")
-    expect(
-      toSessionError(llm(new TransportReason({ message: "transport", transport: "http", operation: "request" }))).type,
-    ).toBe("provider.transport")
+    expect(toSessionError(llm(new TransportReason({ message: "transport" }))).type).toBe("provider.transport")
     expect(toSessionError(llm(new ProviderInternalReason({ message: "internal", status: 500 }))).type).toBe(
       "provider.internal",
     )
@@ -113,7 +111,7 @@ describe("toSessionError", () => {
     const eligible = [
       llm(new RateLimitReason({ message: "rate" })),
       llm(new ProviderInternalReason({ message: "internal", status: 500 })),
-      llm(new TransportReason({ message: "transport", transport: "http", operation: "request" })),
+      llm(new TransportReason({ message: "transport" })),
     ]
     const ineligible = [
       llm(new AuthenticationReason({ message: "auth", kind: "invalid" })),

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

@@ -14,7 +14,7 @@ import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionRestart } from "@opencode-ai/core/session/execution/restart"
 import { UserInterruptedError } from "@opencode-ai/core/session/error"
 import { SessionEvent } from "@opencode-ai/core/session/event"
-import { SessionRunner } from "@opencode-ai/core/session/runner/index"
+import { SessionRunner } from "@opencode-ai/core/session/runner"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
 import { Context, Deferred, Effect, Exit, Fiber, Layer, LayerMap, Scope } from "effect"
@@ -32,7 +32,7 @@ describe("SessionExecution lifecycle", () => {
           new AIError({
             module: "test",
             method: "stream",
-            reason: new TransportReason({ message: "Disconnected", transport: "http", operation: "request" }),
+            reason: new TransportReason({ message: "Disconnected" }),
           }),
         ),
       ),

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

@@ -17,7 +17,7 @@ import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Bus } from "@opencode-ai/core/bus"
 import { EventTable } from "@opencode-ai/core/event/sql"
 import { InstructionDiscovery } from "@opencode-ai/core/instruction-discovery"
-import { Instructions } from "@opencode-ai/core/instructions/index"
+import { Instructions } from "@opencode-ai/core/instructions"
 import { InstructionBuiltIns } from "@opencode-ai/core/instructions/builtins"
 import { Location } from "@opencode-ai/core/location"
 import { McpInstructions } from "@opencode-ai/core/mcp/instructions"

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

@@ -11,8 +11,6 @@ import { Shell } from "@opencode-ai/schema/shell"
 import { Location } from "@opencode-ai/schema/location"
 import { AbsolutePath } from "@opencode-ai/schema/schema"
 import { DateTime } from "effect"
-import path from "path"
-import { pathToFileURL } from "url"
 
 const created = DateTime.makeUnsafe(0)
 const id = (value: string) => SessionMessage.ID.make(`msg_${value}`)
@@ -269,13 +267,12 @@ Recent work
     ])
   })
 
-  test("exposes admitted reference directory source paths in model context", () => {
-    const location = path.resolve("/references/harness-engineering")
+  test("lowers directory attachments as directory context", () => {
     const directory = FileAttachment.make({
       data: Base64.make(Buffer.from("lib/\nindex.ts").toString("base64")),
       mime: "application/x-directory",
-      source: { type: "uri", uri: pathToFileURL(location).href },
-      name: "harness-engineering",
+      source: { type: "uri", uri: "file:///project/src" },
+      name: "src/",
     })
     const messages = toLLMMessages(
       [
@@ -298,15 +295,14 @@ Recent work
         { type: "text", text: "Review this directory" },
         {
           type: "text",
-          text: `\n\nAttached directory: ${location}\n\nlib/\nindex.ts`,
-          metadata: { attachment: { source: directory.source, name: "harness-engineering" } },
+          text: "\n\nAttached directory: src/\n\nlib/\nindex.ts",
+          metadata: { attachment: { source: directory.source, name: "src/" } },
         },
       ],
     })
   })
 
   test("preserves attachment order after the prompt", () => {
-    const directory = path.resolve("/project/src")
     const messages = toLLMMessages(
       [
         SessionMessage.User.make({
@@ -317,7 +313,7 @@ Recent work
             FileAttachment.make({
               data: Base64.make(Buffer.from("index.ts").toString("base64")),
               mime: "application/x-directory",
-              source: { type: "uri", uri: pathToFileURL(directory).href },
+              source: { type: "uri", uri: "file:///project/src" },
               name: "src/",
             }),
             FileAttachment.make({
@@ -336,13 +332,12 @@ Recent work
     expect(messages).toHaveLength(1)
     expect(messages[0]?.content.map((part) => (part.type === "text" ? part.text : part.type))).toEqual([
       "Review these attachments",
-      `\n\nAttached directory: ${directory}\n\nindex.ts`,
+      "\n\nAttached directory: src/\n\nindex.ts",
       "\n\nAttached file: main.ts\n\nexport const value = 1",
     ])
   })
 
   test("omits empty prompt text before an attachment", () => {
-    const directory = path.resolve("/project/src")
     const messages = toLLMMessages(
       [
         SessionMessage.User.make({
@@ -353,7 +348,7 @@ Recent work
             FileAttachment.make({
               data: Base64.make(Buffer.from("index.ts").toString("base64")),
               mime: "application/x-directory",
-              source: { type: "uri", uri: pathToFileURL(directory).href },
+              source: { type: "uri", uri: "file:///project/src" },
               name: "src/",
             }),
           ],
@@ -364,9 +359,7 @@ Recent work
     )
 
     expect(messages).toHaveLength(1)
-    expect(messages[0]?.content).toMatchObject([
-      { type: "text", text: `\n\nAttached directory: ${directory}\n\nindex.ts` },
-    ])
+    expect(messages[0]?.content).toMatchObject([{ type: "text", text: "\n\nAttached directory: src/\n\nindex.ts" }])
   })
 
   test("uses materialized image data as provider media and drops unsupported attachments", () => {
@@ -398,108 +391,6 @@ Recent work
     ])
   })
 
-  test("exposes admitted local image source paths before provider media", () => {
-    const data = Base64.make("AAECAw==")
-    const location = path.resolve("/project/IMG_3480.JPG")
-    const image = FileAttachment.make({
-      data,
-      mime: "image/png",
-      source: { type: "uri", uri: pathToFileURL(location).href },
-      name: "IMG_3480.JPG",
-    })
-
-    const messages = toLLMMessages(
-      [
-        SessionMessage.User.make({
-          id: id("user-local-image-path"),
-          type: "user",
-          text: "Inspect this image",
-          files: [image],
-          time: { created },
-        }),
-      ],
-      model,
-    )
-
-    expect(messages[0]?.content).toEqual([
-      { type: "text", text: "Inspect this image" },
-      { type: "text", text: `Attached file: ${location}` },
-      { type: "media", mediaType: "image/png", data, filename: "IMG_3480.JPG" },
-    ])
-  })
-
-  test("falls back to attachment names for invalid local source paths", () => {
-    const data = Base64.make("AAECAw==")
-    const messages = toLLMMessages(
-      [
-        SessionMessage.User.make({
-          id: id("user-invalid-local-paths"),
-          type: "user",
-          text: "Inspect these attachments",
-          files: [
-            FileAttachment.make({
-              data: Base64.make(Buffer.from("index.ts").toString("base64")),
-              mime: "application/x-directory",
-              source: { type: "uri", uri: "file:///project/src%2Flib" },
-              name: "src/",
-            }),
-            FileAttachment.make({
-              data,
-              mime: "image/png",
-              source: { type: "uri", uri: "file:///project/image%2Fpreview.png" },
-              name: "preview.png",
-            }),
-          ],
-          time: { created },
-        }),
-      ],
-      model,
-    )
-
-    expect(messages[0]?.content).toEqual([
-      { type: "text", text: "Inspect these attachments" },
-      {
-        type: "text",
-        text: "\n\nAttached directory: src/\n\nindex.ts",
-        metadata: {
-          attachment: {
-            source: { type: "uri", uri: "file:///project/src%2Flib" },
-            name: "src/",
-          },
-        },
-      },
-      { type: "media", mediaType: "image/png", data, filename: "preview.png" },
-    ])
-  })
-
-  test("does not add attachment location text for non-local provider media", () => {
-    const data = Base64.make("AAECAw==")
-    const messages = toLLMMessages(
-      [
-        SessionMessage.User.make({
-          id: id("user-remote-image"),
-          type: "user",
-          text: "Inspect this image",
-          files: [
-            FileAttachment.make({
-              data,
-              mime: "image/png",
-              source: { type: "uri", uri: "https://example.com/image.png" },
-              name: "image.png",
-            }),
-          ],
-          time: { created },
-        }),
-      ],
-      model,
-    )
-
-    expect(messages[0]?.content).toEqual([
-      { type: "text", text: "Inspect this image" },
-      { type: "media", mediaType: "image/png", data, filename: "image.png" },
-    ])
-  })
-
   test("deduplicates provider media while preserving durable attachment references", () => {
     const data = Base64.make("AAECAw==")
     const messages = toLLMMessages(
@@ -577,7 +468,7 @@ Recent work
             FileAttachment.make({
               data,
               mime: "image/png",
-              source: { type: "uri", uri: pathToFileURL(path.resolve("/project/image.png")).href },
+              source: { type: "uri", uri: "file:///project/image.png" },
               name: "image.png",
               mention: { start: 0, end: 9, text: "[Image 1]" },
             }),

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

@@ -22,7 +22,7 @@ import { SessionTitle } from "@opencode-ai/core/session/title"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionRunCoordinator } from "@opencode-ai/core/session/run-coordinator"
-import { SessionRunner } from "@opencode-ai/core/session/runner/index"
+import { SessionRunner } from "@opencode-ai/core/session/runner"
 import * as SessionRunnerLLM from "@opencode-ai/core/session/runner/llm"
 import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
 import { Tool } from "@opencode-ai/core/tool"
@@ -31,7 +31,7 @@ import { SessionStore } from "@opencode-ai/core/session/store"
 import { Location } from "@opencode-ai/core/location"
 import { InstructionBuiltIns } from "@opencode-ai/core/instructions/builtins"
 import { InstructionDiscovery } from "@opencode-ai/core/instruction-discovery"
-import { Instructions } from "@opencode-ai/core/instructions/index"
+import { Instructions } from "@opencode-ai/core/instructions"
 import { SkillInstructions } from "@opencode-ai/core/skill/instructions"
 import { ReferenceInstructions } from "@opencode-ai/core/reference/instructions"
 import { McpInstructions } from "@opencode-ai/core/mcp/instructions"

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

@@ -38,7 +38,7 @@ import { Money } from "@opencode-ai/schema/money"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionRunCoordinator } from "@opencode-ai/core/session/run-coordinator"
-import { SessionRunner } from "@opencode-ai/core/session/runner/index"
+import { SessionRunner } from "@opencode-ai/core/session/runner"
 import * as SessionRunnerLLM from "@opencode-ai/core/session/runner/llm"
 import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
 import { PromptCacheDiagnostics } from "@opencode-ai/core/session/prompt-cache-diagnostics"
@@ -61,7 +61,7 @@ import {
 } from "@opencode-ai/core/session/sql"
 import { InstructionEntry } from "@opencode-ai/core/session/instruction-entry"
 import { SessionStore } from "@opencode-ai/core/session/store"
-import { Instructions } from "@opencode-ai/core/instructions/index"
+import { Instructions } from "@opencode-ai/core/instructions"
 import { InstructionBuiltIns } from "@opencode-ai/core/instructions/builtins"
 import { InstructionDiscovery } from "@opencode-ai/core/instruction-discovery"
 import { SkillInstructions } from "@opencode-ai/core/skill/instructions"
@@ -515,11 +515,7 @@ const providerUnavailable = () =>
   new AIError({
     module: "test",
     method: "stream",
-    reason: new TransportReason({
-      message: "Provider unavailable",
-      transport: "http",
-      operation: "request",
-    }),
+    reason: new TransportReason({ message: "Provider unavailable" }),
   })
 
 const incompleteStream = () =>
@@ -816,7 +812,7 @@ const verifyPartialFlushOnInterruption = (kind: FragmentKind) =>
   })
 
 describe("SessionRunnerLLM", () => {
-  it.effect("generates the title while the first model step is still running", () =>
+  it.effect("retries title generation from the first prompt after execution and title failures", () =>
     Effect.gen(function* () {
       const session = yield* setup
       const agents = yield* Agent.Service
@@ -831,48 +827,16 @@ describe("SessionRunnerLLM", () => {
       )
 
       yield* admit(session, "First prompt")
-      yield* TestLLM.push(TestLLM.text("Generated title", "text-title"), Stream.never)
-      const bus = yield* Bus.Service
-      const renamed = yield* bus.subscribe(SessionEvent.Renamed).pipe(
-        Stream.filter((event) => event.data.sessionID === sessionID),
-        Stream.take(1),
-        Stream.runDrain,
-        Effect.forkScoped({ startImmediately: true }),
-      )
-      const runner = yield* SessionRunner.Service
-      const fiber = yield* runner.drain({ sessionID, force: true }).pipe(Effect.forkChild)
-      yield* Fiber.join(renamed)
-
-      expect((yield* session.get(sessionID)).title).toBe("Generated title")
-      yield* Fiber.interrupt(fiber)
-    }),
-  )
-
-  it.effect("retries title generation from the first prompt after title and execution failures", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      const agents = yield* Agent.Service
-      const { db } = yield* Database.Service
-      yield* db.update(SessionTable).set({ title: null }).where(eq(SessionTable.id, sessionID)).run().pipe(Effect.orDie)
-      yield* agents.transform((draft) =>
-        draft.update(Agent.ID.make("title"), (agent) => {
-          agent.mode = "primary"
-          agent.hidden = true
-          agent.system = "Generate a title."
-        }),
-      )
-
-      yield* admit(session, "First prompt")
-      yield* TestLLM.push(Stream.fail(invalidRequest()), Stream.fail(invalidRequest()))
+      yield* TestLLM.push(Stream.fail(invalidRequest()))
       expect((yield* session.resume(sessionID).pipe(Effect.exit))._tag).toBe("Failure")
 
       yield* admit(session, "Second prompt")
       const titleFailed = yield* Deferred.make<void>()
       yield* TestLLM.push(
+        TestLLM.text("Recovered", "text-recovered"),
         Stream.make(LLMEvent.providerError({ message: "Title provider unavailable" })).pipe(
           Stream.ensuring(Deferred.succeed(titleFailed, undefined)),
         ),
-        TestLLM.text("Recovered", "text-recovered"),
       )
       yield* session.resume(sessionID)
       yield* Deferred.await(titleFailed)
@@ -888,13 +852,13 @@ describe("SessionRunnerLLM", () => {
       )
       yield* admit(session, "Third prompt")
       yield* TestLLM.push(
-        TestLLM.text("Generated title", "text-title"),
         TestLLM.text("Recovered again", "text-recovered-again"),
+        TestLLM.text("Generated title", "text-title"),
       )
       yield* session.resume(sessionID)
       yield* Fiber.join(renamed)
 
-      expect(requests).toHaveLength(6)
+      expect(requests).toHaveLength(5)
       expect(requests[2]?.messages).toContainEqual(Message.user("First prompt"))
       expect(requests[4]?.messages).toContainEqual(Message.user("First prompt"))
       expect((yield* session.get(sessionID)).title).toBe("Generated title")
@@ -3983,7 +3947,7 @@ describe("SessionRunnerLLM", () => {
     }),
   )
 
-  it.effect("bounds jittered exponential backoff for eligible pre-output failures", () =>
+  it.effect("retries eligible pre-output failures after exponential backoff", () =>
     Effect.gen(function* () {
       const session = yield* setup
       yield* admit(session, "Retry transport")
@@ -3992,9 +3956,9 @@ describe("SessionRunnerLLM", () => {
 
       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
       yield* TestLLM.wait(1)
-      yield* TestClock.adjust("1599 millis")
+      yield* TestClock.adjust("1999 millis")
       expect(requests).toHaveLength(1)
-      yield* TestClock.adjust("801 millis")
+      yield* TestClock.adjust("1 millis")
       yield* Fiber.join(run)
 
       expect(requests).toHaveLength(2)
@@ -4019,7 +3983,7 @@ describe("SessionRunnerLLM", () => {
 
       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
       yield* TestLLM.wait(1)
-      yield* TestClock.adjust("2400 millis")
+      yield* TestClock.adjust("2 seconds")
       yield* Fiber.join(run)
 
       expect(requests).toHaveLength(2)
@@ -4064,7 +4028,7 @@ describe("SessionRunnerLLM", () => {
 
       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
       yield* TestLLM.wait(1)
-      yield* TestClock.adjust("2400 millis")
+      yield* TestClock.adjust("2 seconds")
       yield* Fiber.join(run)
 
       expect(requests).toHaveLength(2)
@@ -4121,7 +4085,7 @@ describe("SessionRunnerLLM", () => {
 
       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
       yield* TestLLM.wait(1)
-      yield* TestClock.adjust("2400 millis")
+      yield* TestClock.adjust("2 seconds")
       yield* Fiber.join(run)
 
       expect(requests[1]?.messages.at(-2)).toMatchObject({
@@ -4162,7 +4126,7 @@ describe("SessionRunnerLLM", () => {
       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
       yield* TestLLM.wait(1)
       while (!(yield* recordedEventTypes(sessionID)).includes("session.retry.scheduled.1")) yield* Effect.yieldNow
-      yield* TestClock.adjust("2400 millis")
+      yield* TestClock.adjust("2 seconds")
       yield* Fiber.join(run)
 
       expect(executions).toEqual(["settled"])
@@ -4201,7 +4165,7 @@ describe("SessionRunnerLLM", () => {
       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
       yield* TestLLM.wait(1)
       while (!(yield* recordedEventTypes(sessionID)).includes("session.retry.scheduled.1")) yield* Effect.yieldNow
-      yield* TestClock.adjust("2400 millis")
+      yield* TestClock.adjust("2 seconds")
       yield* Fiber.join(run)
 
       expect(messageRoles(requests[1])).toEqual(["user", "assistant", "tool", "user"])
@@ -4239,7 +4203,7 @@ describe("SessionRunnerLLM", () => {
 
       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
       yield* TestLLM.wait(1)
-      for (const [index, delay] of [2_400, 4_800, 9_600, 19_200].entries()) {
+      for (const [index, delay] of [2_000, 4_000, 8_000, 16_000].entries()) {
         yield* TestClock.adjust(delay)
         yield* TestLLM.wait(index + 2)
       }
@@ -4260,7 +4224,7 @@ describe("SessionRunnerLLM", () => {
 
       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
       yield* TestLLM.wait(1)
-      for (const [index, delay] of [2_400, 4_800, 9_600, 19_200].entries()) {
+      for (const [index, delay] of [2_000, 4_000, 8_000, 16_000].entries()) {
         yield* TestClock.adjust(delay)
         yield* TestLLM.wait(index + 2)
       }
@@ -4275,15 +4239,12 @@ describe("SessionRunnerLLM", () => {
         .orderBy(asc(EventTable.seq))
         .all()
         .pipe(Effect.orDie)
-      for (const [index, range] of [
-        [1_600, 2_400],
-        [4_800, 7_200],
-        [11_200, 16_800],
-        [24_000, 36_000],
-      ].entries()) {
-        expect(retries[index]?.data.at).toBeGreaterThanOrEqual(range[0]!)
-        expect(retries[index]?.data.at).toBeLessThanOrEqual(range[1]!)
-      }
+      expect(retries.map((event) => event.data)).toMatchObject([
+        { attempt: 2, at: 2_000 },
+        { attempt: 3, at: 6_000 },
+        { attempt: 4, at: 14_000 },
+        { attempt: 5, at: 30_000 },
+      ])
       expect((yield* recordedEventTypes(sessionID)).filter((type) => type === "session.step.started.1")).toHaveLength(5)
       const assistant = requireAssistant(yield* session.context(sessionID))
       expect(yield* recordedStepSettlementEvents(sessionID, assistant.id)).toMatchObject([
@@ -4313,7 +4274,7 @@ describe("SessionRunnerLLM", () => {
 
       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
       yield* TestLLM.wait(1)
-      yield* TestClock.adjust("2400 millis")
+      yield* TestClock.adjust("2 seconds")
       yield* Fiber.join(run)
 
       expect(requests).toHaveLength(3)

packages/core/test/snapshot.test.ts

@@ -143,47 +143,44 @@ describe("Snapshot", () => {
     ),
   )
 
-  testEffect(Layer.empty).live(
-    "isolates snapshot indexes by canonical Git worktree",
-    () =>
-      Effect.acquireUseRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) =>
-          Effect.gen(function* () {
-            const project = path.join(tmp.path, "project")
-            const linked = path.join(tmp.path, "linked")
-            yield* Effect.promise(async () => {
-              await fs.mkdir(project)
-              await fs.writeFile(path.join(project, "tracked.txt"), "main\n")
-              await initGit(project, true)
-              await $`git -c core.fsmonitor=false worktree add --detach ${linked} HEAD`.cwd(project).quiet()
-            })
+  testEffect(Layer.empty).live("isolates snapshot indexes by canonical Git worktree", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) =>
+        Effect.gen(function* () {
+          const project = path.join(tmp.path, "project")
+          const linked = path.join(tmp.path, "linked")
+          yield* Effect.promise(async () => {
+            await fs.mkdir(project)
+            await fs.writeFile(path.join(project, "tracked.txt"), "main\n")
+            await initGit(project, true)
+            await $`git -c core.fsmonitor=false worktree add --detach ${linked} HEAD`.cwd(project).quiet()
+          })
 
-            const capture = (directory: string) =>
-              Effect.gen(function* () {
-                const snapshot = yield* Snapshot.Service
-                return yield* snapshot.capture()
-              }).pipe(Effect.provide(snapshotLayer(tmp.path, directory)))
-            expect(yield* capture(project)).toBeDefined()
-            expect(yield* capture(linked)).toBeDefined()
+          const capture = (directory: string) =>
+            Effect.gen(function* () {
+              const snapshot = yield* Snapshot.Service
+              return yield* snapshot.capture()
+            }).pipe(Effect.provide(snapshotLayer(tmp.path, directory)))
+          expect(yield* capture(project)).toBeDefined()
+          expect(yield* capture(linked)).toBeDefined()
 
-            const projectID = yield* Effect.gen(function* () {
-              return (yield* Location.Service).project.id
-            }).pipe(
-              Effect.provide(
-                AppNodeBuilder.build(Location.boundNode(Location.Ref.make({ directory: AbsolutePath.make(project) }))),
-              ),
-            )
-            expect(
-              yield* Effect.promise(() => fs.stat(path.join(tmp.path, "snapshot", projectID, Hash.fast(project)))),
-            ).toBeDefined()
-            expect(
-              yield* Effect.promise(() => fs.stat(path.join(tmp.path, "snapshot", projectID, Hash.fast(linked)))),
-            ).toBeDefined()
-          }),
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-      ),
-    { timeout: 15_000 },
+          const projectID = yield* Effect.gen(function* () {
+            return (yield* Location.Service).project.id
+          }).pipe(
+            Effect.provide(
+              AppNodeBuilder.build(Location.boundNode(Location.Ref.make({ directory: AbsolutePath.make(project) }))),
+            ),
+          )
+          expect(
+            yield* Effect.promise(() => fs.stat(path.join(tmp.path, "snapshot", projectID, Hash.fast(project)))),
+          ).toBeDefined()
+          expect(
+            yield* Effect.promise(() => fs.stat(path.join(tmp.path, "snapshot", projectID, Hash.fast(linked)))),
+          ).toBeDefined()
+        }),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ),
   )
 })
 

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

@@ -4,7 +4,7 @@ import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Environment } from "@opencode-ai/core/environment/index"
+import { Environment } from "@opencode-ai/core/environment"
 import { FileMutation } from "@opencode-ai/core/file-mutation"
 import { Formatter } from "@opencode-ai/core/formatter"
 import { Location } from "@opencode-ai/core/location"

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

@@ -4,7 +4,7 @@ import { describe, expect } from "bun:test"
 import { Effect, Exit, Layer, Schema } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Environment } from "@opencode-ai/core/environment/index"
+import { Environment } from "@opencode-ai/core/environment"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Formatter } from "@opencode-ai/core/formatter"
 import { FileMutation } from "@opencode-ai/core/file-mutation"

packages/core/test/tool-read-filesystem.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
-import { Environment } from "@opencode-ai/core/environment/index"
+import { Environment } from "@opencode-ai/core/environment"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { ReadToolFileSystem } from "@opencode-ai/core/tool/read-filesystem"
 import { CrossSpawnSpawner } from "@opencode-ai/util/cross-spawn-spawner"

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

@@ -21,7 +21,7 @@ import { ReadTool } from "@opencode-ai/core/tool/plugin/read"
 import { ReadToolFileSystem } from "@opencode-ai/core/tool/read-filesystem"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { SessionInstructions } from "@opencode-ai/core/session/instructions"
-import { Environment } from "@opencode-ai/core/environment/index"
+import { Environment } from "@opencode-ai/core/environment"
 import { testEffect } from "./lib/effect"
 import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "./lib/tool"
 

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

@@ -5,7 +5,7 @@ import { Effect, Layer } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Environment } from "@opencode-ai/core/environment/index"
+import { Environment } from "@opencode-ai/core/environment"
 import { FileSystem } from "@opencode-ai/core/filesystem"
 import { Location } from "@opencode-ai/core/location"
 import { LocationMutation } from "@opencode-ai/core/location-mutation"

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

@@ -12,7 +12,7 @@ import { filesystem } from "@opencode-ai/util/effect/app-node-platform"
 import { Database } from "@opencode-ai/core/database/database"
 import { Bus } from "@opencode-ai/core/bus"
 import { Config } from "@opencode-ai/core/config"
-import { Environment } from "@opencode-ai/core/environment/index"
+import { Environment } from "@opencode-ai/core/environment"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
 import { Location } from "@opencode-ai/core/location"
@@ -387,63 +387,57 @@ describe("ShellTool", () => {
     ),
   )
 
-  it.live(
-    "approves an explicit external workdir before shell execution",
-    () =>
-      Effect.acquireUseRelease(
-        Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
-        ([active, outside]) => {
-          reset()
-          return withSession(active.path, (registry) =>
-            executeTool(registry, call({ command: cwdCommand, workdir: outside.path })),
-          ).pipe(
-            Effect.andThen(
-              Effect.sync(() => {
-                expect(assertions.map((item) => item.action)).toEqual(["external_directory", "shell"])
-                expect(assertions[0]).toMatchObject({
-                  resources: [path.join(realpathSync(outside.path), "*").replaceAll("\\", "/")],
-                })
-              }),
-            ),
-          )
-        },
-        ([active, outside]) =>
-          Effect.promise(() =>
-            Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
+  it.live("approves an explicit external workdir before shell execution", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
+      ([active, outside]) => {
+        reset()
+        return withSession(active.path, (registry) =>
+          executeTool(registry, call({ command: cwdCommand, workdir: outside.path })),
+        ).pipe(
+          Effect.andThen(
+            Effect.sync(() => {
+              expect(assertions.map((item) => item.action)).toEqual(["external_directory", "shell"])
+              expect(assertions[0]).toMatchObject({
+                resources: [path.join(realpathSync(outside.path), "*").replaceAll("\\", "/")],
+              })
+            }),
           ),
-      ),
-    { timeout: 15_000 },
+        )
+      },
+      ([active, outside]) =>
+        Effect.promise(() =>
+          Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
+        ),
+    ),
   )
 
-  it.live(
-    "approves an external directory used by a directory-change command",
-    () =>
-      Effect.acquireUseRelease(
-        Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
-        ([active, outside]) => {
-          reset()
-          const command = isWindows
-            ? `Set-Location -LiteralPath '${outside.path}'; (Get-Location).Path`
-            : `cd '${outside.path}' && pwd`
-          return withSession(active.path, (registry) =>
-            executeTool(registry, call({ command }, "call-external-cd")),
-          ).pipe(
-            Effect.andThen(
-              Effect.sync(() => {
-                expect(assertions.map((item) => item.action)).toEqual(["external_directory", "shell"])
-                expect(assertions[0]).toMatchObject({
-                  resources: [path.join(realpathSync(outside.path), "*").replaceAll("\\", "/")],
-                })
-              }),
-            ),
-          )
-        },
-        ([active, outside]) =>
-          Effect.promise(() =>
-            Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
+  it.live("approves an external directory used by a directory-change command", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
+      ([active, outside]) => {
+        reset()
+        const command = isWindows
+          ? `Set-Location -LiteralPath '${outside.path}'; (Get-Location).Path`
+          : `cd '${outside.path}' && pwd`
+        return withSession(active.path, (registry) =>
+          executeTool(registry, call({ command }, "call-external-cd")),
+        ).pipe(
+          Effect.andThen(
+            Effect.sync(() => {
+              expect(assertions.map((item) => item.action)).toEqual(["external_directory", "shell"])
+              expect(assertions[0]).toMatchObject({
+                resources: [path.join(realpathSync(outside.path), "*").replaceAll("\\", "/")],
+              })
+            }),
           ),
-      ),
-    { timeout: 15_000 },
+        )
+      },
+      ([active, outside]) =>
+        Effect.promise(() =>
+          Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
+        ),
+    ),
   )
 
   it.live("approves an expanded external home directory", () =>
@@ -465,31 +459,28 @@ describe("ShellTool", () => {
     ),
   )
 
-  it.live(
-    "does not execute after external-directory or shell denial",
-    () =>
-      Effect.acquireUseRelease(
-        Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
-        ([active, outside]) =>
-          Effect.gen(function* () {
-            reset()
-            denyAction = "external_directory"
-            yield* withSession(active.path, (registry) =>
-              executeTool(registry, call({ command: cwdCommand, workdir: outside.path })),
-            )
-            expect(assertions.map((item) => item.action)).toEqual(["external_directory"])
+  it.live("does not execute after external-directory or shell denial", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
+      ([active, outside]) =>
+        Effect.gen(function* () {
+          reset()
+          denyAction = "external_directory"
+          yield* withSession(active.path, (registry) =>
+            executeTool(registry, call({ command: cwdCommand, workdir: outside.path })),
+          )
+          expect(assertions.map((item) => item.action)).toEqual(["external_directory"])
 
-            reset()
-            denyAction = "shell"
-            yield* withSession(active.path, (registry) => executeTool(registry, call({ command: cwdCommand })))
-            expect(assertions.map((item) => item.action)).toEqual(["shell"])
-          }),
-        ([active, outside]) =>
-          Effect.promise(() =>
-            Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
-          ),
-      ),
-    { timeout: 15_000 },
+          reset()
+          denyAction = "shell"
+          yield* withSession(active.path, (registry) => executeTool(registry, call({ command: cwdCommand })))
+          expect(assertions.map((item) => item.action)).toEqual(["shell"])
+        }),
+      ([active, outside]) =>
+        Effect.promise(() =>
+          Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
+        ),
+    ),
   )
 
   it.live("keeps non-zero exits useful", () =>
@@ -628,7 +619,7 @@ describe("ShellTool", () => {
         },
         (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
       ),
-    { timeout: 15_000 },
+    { timeout: 10_000 },
   )
 
   it.live(
@@ -639,7 +630,7 @@ describe("ShellTool", () => {
         (tmp) => {
           reset()
           return withSession(tmp.path, (registry) =>
-            executeTool(registry, call({ command: timeoutOutputCommand, timeout: isWindows ? 3_000 : 500 })),
+            executeTool(registry, call({ command: timeoutOutputCommand, timeout: isWindows ? 3_000 : 50 })),
           ).pipe(
             Effect.andThen((settled) =>
               Effect.sync(() => {

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

@@ -6,7 +6,7 @@ import { FileMutation } from "@opencode-ai/core/file-mutation"
 import { Formatter } from "@opencode-ai/core/formatter"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Environment } from "@opencode-ai/core/environment/index"
+import { Environment } from "@opencode-ai/core/environment"
 import { Location } from "@opencode-ai/core/location"
 import { LocationMutation } from "@opencode-ai/core/location-mutation"
 import { Permission } from "@opencode-ai/core/permission"

packages/core/test/workspace.test.ts

@@ -1,7 +1,7 @@
 import { beforeEach, expect } from "bun:test"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Database } from "@opencode-ai/core/database/database"
-import { makeMemoryDriver } from "@opencode-ai/core/environment/index"
+import { makeMemoryDriver } from "@opencode-ai/core/environment"
 import { Workspace } from "@opencode-ai/core/workspace"
 import { WorkspaceDriver } from "@opencode-ai/core/workspace/driver"
 import { WorkspaceTable } from "@opencode-ai/core/workspace/sql"

packages/core/tsconfig.build.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "composite": false,
-    "incremental": false,
-    "outDir": "dist/types",
-    "tsBuildInfoFile": null
-  },
-  "include": ["src"]
-}

packages/protocol/openapi.json

@@ -13083,9 +13083,6 @@
           },
           "text": {
             "type": "string"
-          },
-          "description": {
-            "type": "string"
           }
         },
         "required": ["id", "time", "type", "text"],

packages/server/src/fetch.ts

@@ -7,6 +7,15 @@ import { isAllowedCorsOrigin } from "./cors"
 import { createRoutes } from "./routes"
 import type { ServerOptions } from "./options"
 
+export interface BootOptions {
+  /**
+   * Resumes execution-journaled Sessions once the application layer boots. Pair with
+   * `SessionExecution.configured({ suspendOnStart: true })` on runtimes that can die without
+   * teardown, so turns orphaned by a hard death replay on the next boot.
+   */
+  readonly resumeSuspendedSessions?: boolean
+}
+
 /**
  * Builds a web-standard fetch handler — `(request: Request) => Promise<Response>` — serving the
  * same HttpApi routes as the Node server process without binding a port, owning a listener, or
@@ -23,17 +32,13 @@ import type { ServerOptions } from "./options"
  * Auth follows `createRoutes` semantics: `options.password` enforces Basic auth; omitting it
  * serves unauthenticated, so an embedder without a password must front the handler with its own
  * access control.
- *
- * Sessions whose execution claim was never released resume once the layer is built, exactly as
- * the Node server process does: a runtime that dies without teardown — an evicted Durable
- * Object leaves the same durable signature as a killed process — replays orphaned turns on the
- * next boot, and the sweep is a no-op when nothing is suspended.
  */
-export const make = Effect.fn("ServerFetch.make")(function* (options: ServerOptions = {}) {
+export const make = Effect.fn("ServerFetch.make")(function* (options: ServerOptions = {}, boot: BootOptions = {}) {
   const context = yield* Layer.build(createRoutes(options, () => []).pipe(Layer.provide(HttpServer.layerServices)))
   // Forked so the returned handler is never delayed; resumed drains are already
   // logged and durably recorded by the execution layer.
-  yield* Effect.forkDetach(Context.get(context, SessionRestart.Service).resumeSuspendedSessions)
+  if (boot.resumeSuspendedSessions)
+    yield* Effect.forkDetach(Context.get(context, SessionRestart.Service).resumeSuspendedSessions)
   return Context.get(context, HttpRouter.HttpRouter)
     .asHttpEffect()
     .pipe(

packages/server/src/workspace/modal.ts

@@ -2,7 +2,7 @@ import { Effect, Sink, Stream } from "effect"
 import { systemError } from "effect/PlatformError"
 import type { Command, KillOptions } from "effect/unstable/process/ChildProcess"
 import { ExitCode, make, makeHandle, ProcessId } from "effect/unstable/process/ChildProcessSpawner"
-import type { Driver } from "@opencode-ai/core/environment/index"
+import type { Driver } from "@opencode-ai/core/environment"
 import type { App, Image, ModalClient, ModalClientParams, Sandbox, SandboxCreateParams } from "modal"
 
 const INNER_WRAPPER = `

packages/server/test/environment-modal.test.ts

@@ -4,8 +4,8 @@ import path from "node:path"
 import { afterAll, expect, test } from "bun:test"
 import { Effect } from "effect"
 import { ChildProcess } from "effect/unstable/process"
-import { Failed, makeFiles } from "@opencode-ai/core/environment/index"
-import { environmentConformance } from "../../core/test/lib/environment-conformance.js"
+import { Failed, makeFiles } from "@opencode-ai/core/environment"
+import { environmentConformance } from "@opencode-ai/core/testing/environment-conformance"
 import { createModalSandbox } from "../src/workspace/modal"
 
 const enabled =

packages/server/test/workspace-modal.test.ts

@@ -3,7 +3,7 @@ import os from "node:os"
 import path from "node:path"
 import { expect, test } from "bun:test"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { makeFiles } from "@opencode-ai/core/environment/index"
+import { makeFiles } from "@opencode-ai/core/environment"
 import { Workspace } from "@opencode-ai/core/workspace"
 import { WorkspaceDriver } from "@opencode-ai/core/workspace/driver"
 import { Effect, Layer } from "effect"

packages/tui/src/app.tsx

@@ -38,7 +38,6 @@ import {
   TuiStartupProvider,
   TuiTerminalEnvironmentProvider,
   useTuiApp,
-  useTuiPaths,
   useTuiStartup,
   type TuiApp,
 } from "./context/runtime"
@@ -86,7 +85,6 @@ import { ArgsProvider, useArgs, type Args } from "./context/args"
 import open from "open"
 import { PromptRefProvider, usePromptRef } from "./context/prompt"
 import { Config, ConfigProvider, useConfig } from "./config"
-import { newSessionLocation } from "./config/new-session-location"
 import { PluginProvider, usePlugin, type PackageResolver } from "./plugin/context"
 import { tuiPluginDirectories } from "./plugin/discovery"
 import { PluginRoute, Slot } from "./plugin/render"
@@ -150,7 +148,6 @@ const appBindingCommands = [
   "variant.cycle",
   "variant.list",
   "provider.connect",
-  "opencode.settings",
   "opencode.status",
   "server.pair",
   "service.restart",
@@ -169,7 +166,6 @@ const appBindingCommands = [
   "app.toggle.file_context",
   "app.toggle.diffwrap",
   "app.toggle.paste_summary",
-  "permission.mode",
 ] as const
 
 export type TuiInput = {
@@ -457,7 +453,6 @@ function App(props: { pair?: DialogPairCredentials }) {
   const log = useLog({ component: "app" })
   const app = useTuiApp()
   const startup = useTuiStartup()
-  const paths = useTuiPaths()
   const config = useConfig()
   const devtools = createMemo(() => config.data.debug?.devtools ?? app.channel === "local")
   const route = useRoute()
@@ -664,13 +659,10 @@ function App(props: { pair?: DialogPairCredentials }) {
         run: () => {
           route.navigate({
             type: "home",
-            location: newSessionLocation(
-              config.data.session.new_location,
-              paths.cwd,
+            location:
               route.data.type === "session"
                 ? (data.session.get(route.data.sessionID)?.location ?? location.ref)
                 : undefined,
-            ),
           })
           dialog.clear()
         },

packages/tui/src/component/devtools-bar.tsx

@@ -384,18 +384,16 @@ export function DevToolsBar() {
               >
                 {turnTokens() ? "[x]" : "[ ]"} Turn token usage
               </Action>
-              <Show when={Boolean(turnTokens())}>
-                <Action
-                  onClick={() =>
-                    void config.update((draft) => {
-                      draft.debug = { ...draft.debug, turn_tokens: verboseTurnTokens() ? true : "verbose" }
-                    })
-                  }
-                  hoverBackground
-                >
-                  {verboseTurnTokens() ? "[x]" : "[ ]"} Turn token usage (verbose)
-                </Action>
-              </Show>
+              <Action
+                onClick={() =>
+                  void config.update((draft) => {
+                    draft.debug = { ...draft.debug, turn_tokens: verboseTurnTokens() ? true : "verbose" }
+                  })
+                }
+                hoverBackground
+              >
+                {verboseTurnTokens() ? "[x]" : "[ ]"} Turn token usage (verbose)
+              </Action>
             </box>
             <For each={groups()}>
               {(group) => (

packages/tui/src/component/dialog-config.tsx

@@ -93,15 +93,6 @@ export const settings: Setting[] = [
     labels: ["off", "on"],
     keywords: ["attachments", "images", "tool output"],
   },
-  {
-    title: "New session location",
-    category: "Session",
-    path: ["session", "new_location"],
-    default: "launch",
-    values: ["launch", "inherit"],
-    labels: ["launch directory", "active session"],
-    keywords: ["directory", "cwd", "inherit"],
-  },
   {
     title: "Enabled",
     category: "Tabs",

packages/tui/src/component/dialog-error-details.tsx

@@ -1,6 +1,6 @@
-import { CliRenderEvents, TextAttributes, type ScrollBoxRenderable } from "@opentui/core"
-import { useKeyboard, useRenderer, useTerminalDimensions } from "@opentui/solid"
-import { createEffect, createMemo, createSignal, onCleanup, onMount } from "solid-js"
+import { TextAttributes, type ScrollBoxRenderable } from "@opentui/core"
+import { useKeyboard, useTerminalDimensions } from "@opentui/solid"
+import { createMemo, createSignal, onMount } from "solid-js"
 import { useConfig } from "../config"
 import { useClipboard } from "../context/clipboard"
 import { Keymap } from "../context/keymap"
@@ -15,33 +15,14 @@ export function DialogErrorDetails(props: { title: string; error: string; onBack
   const toast = useToast()
   const theme = useTheme("elevated")
   const overlayTheme = useTheme("overlay")
-  const renderer = useRenderer()
   const dimensions = useTerminalDimensions()
   const config = useConfig().data
   const [copied, setCopied] = createSignal(false)
-  const [scrollable, setScrollable] = createSignal(false)
   const height = createMemo(() => Math.max(3, Math.floor(dimensions().height / 2) - 5))
   let scroll: ScrollBoxRenderable | undefined
-  let measure: (() => void) | undefined
 
   onMount(() => dialog.setSize("large"))
 
-  createEffect(() => {
-    dimensions()
-    props.error
-    if (measure) renderer.off(CliRenderEvents.FRAME, measure)
-    measure = () => {
-      measure = undefined
-      setScrollable(Boolean(scroll && scroll.scrollHeight > scroll.viewport.height))
-    }
-    renderer.once(CliRenderEvents.FRAME, measure)
-    renderer.requestRender()
-  })
-
-  onCleanup(() => {
-    if (measure) renderer.off(CliRenderEvents.FRAME, measure)
-  })
-
   const copy = () => {
     void clipboard
       .write(props.error)
@@ -51,14 +32,11 @@ export function DialogErrorDetails(props: { title: string; error: string; onBack
 
   Keymap.createLayer(() => ({
     mode: "modal",
-    commands: [
-      { bind: "escape", title: "Back", group: "Dialog", run: props.onBack },
-      { bind: "c", title: "Copy details", group: "Dialog", run: copy },
-    ],
+    commands: [{ bind: "escape", title: "Back", group: "Dialog", run: props.onBack }],
   }))
 
   useKeyboard((event) => {
-    if (!scrollable()) return
+    if (event.name === "c") return copy()
     if (event.name === "up") return scroll?.scrollBy(-1)
     if (event.name === "down") return scroll?.scrollBy(1)
     if (event.name === "pageup") return scroll?.scrollBy(-height())
@@ -74,7 +52,7 @@ export function DialogErrorDetails(props: { title: string; error: string; onBack
           {props.title}
         </text>
         <text fg={theme.text.subdued} onMouseUp={props.onBack}>
-          esc
+          esc back
         </text>
       </box>
       <text fg={theme.text.feedback.error.default}>✗ Failed</text>
@@ -97,17 +75,9 @@ export function DialogErrorDetails(props: { title: string; error: string; onBack
         </scrollbox>
       </box>
       <box flexDirection="row" justifyContent="space-between">
-        <text>
-          <span style={{ fg: theme.text.default }}>
-            <b>{scrollable() ? "↑/↓" : ""}</b>
-          </span>
-          <span style={{ fg: theme.text.subdued }}>{scrollable() ? " scroll" : ""}</span>
-        </text>
-        <text onMouseUp={copy}>
-          <span style={{ fg: copied() ? theme.text.feedback.success.default : theme.text.default }}>
-            <b>{copied() ? "✓ copied" : "c"}</b>
-          </span>
-          <span style={{ fg: theme.text.subdued }}>{copied() ? "" : " copy details"}</span>
+        <text fg={theme.text.subdued}>↑↓ scroll</text>
+        <text fg={theme.text.subdued} onMouseUp={copy}>
+          {copied() ? "✓ copied" : "c copy details"}
         </text>
       </box>
     </box>

packages/tui/src/component/dialog-open.tsx

@@ -151,7 +151,6 @@ export function DialogOpen() {
       options={options()}
       current={currentSessionID() ? ({ type: "session", sessionID: currentSessionID()! } as OpenTarget) : undefined}
       focusCurrent={false}
-      sectionNavigation={true}
       preserveSelection={selectionMoved()}
       onMove={() => setSelectionMoved(true)}
       onFilter={setFilter}

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

@@ -23,12 +23,10 @@ import { TabPulse, unreadGlowIntensity } from "./tab-pulse"
 import { tint } from "../theme/color"
 import { SESSION_SIDEBAR_WIDTH } from "../ui/layout"
 import { projectName } from "../util/project"
-import { marqueeCycleWidth, marqueeText } from "../util/marquee"
+import { marqueeText } from "../util/marquee"
 
 // A long title fades out over its last cells instead of cutting hard.
 const FADE_WIDTH = 4
-// The add button renders as " + " at the end of the strip, so the tab layout leaves it room.
-const ADD_TAB_WIDTH = 3
 const MARQUEE_DELAY = 600
 const MARQUEE_INTERVAL = 100
 
@@ -44,7 +42,6 @@ export const EMPTY_SESSION_TAB_STATUS: SessionTabsStatus = {
 }
 export type SessionTabsController = Pick<ContextController, "tabs" | "current" | "select" | "close" | "move"> & {
   newTab?: () => boolean
-  add?: () => void
   status(sessionID: string): SessionTabsStatus
 }
 
@@ -60,98 +57,27 @@ function fadeTitleColor(color: RGBA, background: RGBA, index: number, length: nu
   return opacity === 0 ? color : tint(color, background, opacity)
 }
 
-function createMarquee(animations: () => boolean) {
+function createMarquee(hovered: () => string | undefined, animations: () => boolean) {
   const [offset, setOffset] = createSignal(0)
-  const [active, setActive] = createSignal<string>()
   const leading = createAnimatable({ opacity: 0 }, { enabled: animations, transition: tween({ duration: 0.25 }) })
-  let delay: ReturnType<typeof setTimeout> | undefined
-  let interval: ReturnType<typeof setInterval> | undefined
-  let cycleWidth = 0
-  let returning = false
 
-  const clear = () => {
-    if (delay) clearTimeout(delay)
-    if (interval) clearInterval(interval)
-    delay = undefined
-    interval = undefined
-  }
-  const scroll = () => {
-    interval = setInterval(() => setOffset((value) => (value + 1) % cycleWidth), MARQUEE_INTERVAL)
-  }
-  const enter = (sessionID: string, title: string, width: number) => {
-    if (active() === sessionID && !returning) return
-    clear()
-    if (active() === sessionID) {
-      returning = false
-      return scroll()
-    }
-    if (stringWidth(title) <= width) return
-    cycleWidth = marqueeCycleWidth(title)
-    setActive(sessionID)
+  createEffect(() => {
     setOffset(0)
-    returning = false
     leading.jump({ opacity: 0 })
-    delay = setTimeout(() => {
+    if (!hovered()) return
+    let interval: ReturnType<typeof setInterval> | undefined
+    const delay = setTimeout(() => {
       setOffset(1)
       leading.animate({ opacity: 1 })
-      scroll()
+      interval = setInterval(() => setOffset((value) => value + 1), MARQUEE_INTERVAL)
     }, MARQUEE_DELAY)
-  }
-  const leave = (sessionID: string) => {
-    if (active() !== sessionID) return
-    clear()
-    if (offset() === 0) {
-      setActive(undefined)
-      return
-    }
-    returning = true
-    interval = setInterval(() => {
-      setOffset((value) => {
-        const next = (value + 1) % cycleWidth
-        if (next !== 0) return next
-        clear()
-        returning = false
-        setActive(undefined)
-        leading.animate({ opacity: 0 })
-        return 0
-      })
-    }, MARQUEE_INTERVAL)
-  }
-  const reset = () => {
-    clear()
-    returning = false
-    setActive(undefined)
-    setOffset(0)
-    leading.jump({ opacity: 0 })
-  }
-  onCleanup(clear)
-
-  return { offset, active, enter, leave, reset, leading: () => leading.value().opacity }
-}
-
-function createTabMarquee(animations: () => boolean) {
-  const [hovered, setHovered] = createSignal<string>()
-  const marquee = createMarquee(animations)
-  let hoverClear: ReturnType<typeof setTimeout> | undefined
-
-  const enter = (sessionID: string, title: string, width: number) => {
-    if (hoverClear) clearTimeout(hoverClear)
-    setHovered(sessionID)
-    marquee.enter(sessionID, title, width)
-  }
-  const leave = (sessionID: string) => {
-    if (hoverClear) clearTimeout(hoverClear)
-    hoverClear = setTimeout(() => {
-      if (hovered() !== sessionID) return
-      setHovered(undefined)
-      marquee.leave(sessionID)
+    onCleanup(() => {
+      clearTimeout(delay)
+      if (interval) clearInterval(interval)
     })
-  }
-  onCleanup(() => {
-    if (hoverClear) clearTimeout(hoverClear)
   })
 
-  return { ...marquee, hovered, enter, leave }
+  return { offset, leading: () => leading.value().opacity }
 }
 
 export function SessionTabs(
@@ -176,28 +102,23 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
   const idleNumber = () => tint(theme.text.subdued, theme.background.default, 0.35)
   const separatorUpperPulseColor = createMemo(() => tint(theme.background.default, theme.text.default, 0.04))
   const separatorLowerPulseColor = createMemo(() => tint(theme.background.default, theme.text.default, 0.05))
-  const [addHovered, setAddHovered] = createSignal(false)
-  const marquee = createTabMarquee(animations)
-  const hovered = marquee.hovered
+  const [hovered, setHovered] = createSignal<string>()
+  const marquee = createMarquee(hovered, animations)
   const [dragging, setDragging] = createSignal<string>()
   const [preview, setPreview] = createSignal<{ sessionID: string; index: number }>()
   const newTab = () => tabs.newTab?.() ?? false
-  const activeID = createMemo(() => (newTab() ? undefined : tabs.current()))
+  const activeID = createMemo(() => (newTab() ? NEW_SESSION_TAB.sessionID : tabs.current()))
   const ordered = createMemo(() => {
     const pending = preview()
     if (!pending) return tabs.tabs()
     return moveSessionTab(tabs.tabs(), pending.sessionID, pending.index)
   })
-  const items = ordered
-  createEffect(() => {
-    const active = marquee.active()
-    if (active && !items().some((tab) => tab.sessionID === active)) marquee.reset()
-  })
+  const items = createMemo(() => (newTab() ? [...ordered(), NEW_SESSION_TAB] : ordered()))
   const statuses = createMemo(
     () =>
       new Map(
         items().map((tab) => {
-          const status = tabs.status(tab.sessionID)
+          const status = tab === NEW_SESSION_TAB ? EMPTY_SESSION_TAB_STATUS : tabs.status(tab.sessionID)
           return [
             tab.sessionID,
             {
@@ -224,8 +145,6 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
 
   createEffect(() => {
     if (!scroll) return
-    // The promoted new-session slot sits below the list, so bring the rail's bottom into view.
-    if (newTab()) return scroll.scrollTo(Math.max(0, items().length * 3 + 1 - scroll.viewport.height))
     const index = items().findIndex((tab) => tab.sessionID === activeID())
     if (index === -1) return
     const top = index * 3
@@ -252,7 +171,7 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               const selected = () => activeID() === tab.sessionID
               const status = createMemo(() => itemStatus(tab))
               const [sweepLevel, setSweepLevel] = createSignal(0)
-              const session = createMemo(() => data.session.get(tab.sessionID))
+              const session = createMemo(() => (tab === NEW_SESSION_TAB ? undefined : data.session.get(tab.sessionID)))
               const project = createMemo(() => {
                 const value = session()
                 return value ? data.project.get(value.projectID) : undefined
@@ -260,7 +179,7 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               const numberWidth = () => 2
               const titleWidth = () => Math.max(1, width() - numberWidth() - 2 - (hovered() === tab.sessionID ? 1 : 0))
               const title = () => tab.title ?? "Untitled session"
-              const scrolling = () => marquee.active() === tab.sessionID && marquee.offset() > 0
+              const scrolling = () => hovered() === tab.sessionID && marquee.offset() > 0
               const visibleTitle = createMemo(() =>
                 scrolling()
                   ? marqueeText(title(), titleWidth(), marquee.offset())
@@ -269,6 +188,7 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               const visibleTitleParts = createMemo(() => Locale.graphemes(visibleTitle()))
               const titleFades = createMemo(() => stringWidth(title()) >= titleWidth() && titleWidth() > FADE_WIDTH)
               const detail = createMemo(() => {
+                if (tab === NEW_SESSION_TAB) return Locale.takeWidth("Start a new session", titleWidth())
                 const value = session()
                 return Locale.takeWidth(projectName(project(), value?.location.directory) ?? "", titleWidth())
               })
@@ -340,7 +260,7 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
                 setDragging(undefined)
                 const pending = preview()
                 if (pending?.sessionID === tab.sessionID) tabs.move(pending.sessionID, pending.index)
-                tabs.select(tab.sessionID)
+                if (tab !== NEW_SESSION_TAB) tabs.select(tab.sessionID)
               }
               return (
                 <box
@@ -349,15 +269,15 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
                   position="relative"
                   flexDirection="column"
                   backgroundColor={background()}
-                  onMouseOver={() => marquee.enter(tab.sessionID, title(), titleWidth())}
-                  onMouseOut={() => marquee.leave(tab.sessionID)}
+                  onMouseOver={() => setHovered(tab.sessionID)}
+                  onMouseOut={() => setHovered(undefined)}
                   onMouseDown={() => {
-                    marquee.enter(tab.sessionID, title(), titleWidth())
+                    setHovered(tab.sessionID)
                     setDragging(tab.sessionID)
                   }}
                   onMouseUp={release}
                   onMouseDrag={(event) => {
-                    if (!rail) return
+                    if (!rail || tab === NEW_SESSION_TAB) return
                     const target = Math.max(
                       0,
                       Math.min(
@@ -466,7 +386,7 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
                         onMouseUp={(event) => {
                           if (hovered() !== tab.sessionID) return
                           event.stopPropagation()
-                          tabs.close(tab.sessionID)
+                          tabs.close(tab === NEW_SESSION_TAB ? undefined : tab.sessionID)
                         }}
                       >
                         {hovered() === tab.sessionID ? "×" : ""}
@@ -497,63 +417,6 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               )
             }}
           </For>
-          {/* One slot with two states: a subdued affordance that promotes in place into the
-              active new-session tab, instead of spawning a separate pseudo tab above itself. */}
-          <Show when={tabs.add || newTab()}>
-            <box
-              height={1}
-              width="100%"
-              position="relative"
-              flexDirection="row"
-              paddingLeft={1}
-              backgroundColor={
-                newTab()
-                  ? theme.background.action.primary.selected
-                  : addHovered()
-                    ? theme.background.action.primary.hovered
-                    : theme.background.default
-              }
-              onMouseOver={() => setAddHovered(true)}
-              onMouseOut={() => setAddHovered(false)}
-              onMouseUp={() => {
-                if (!newTab()) tabs.add?.()
-              }}
-            >
-              <text
-                width={2}
-                fg={newTab() ? activeNumber() : addHovered() ? theme.text.default : idleNumber()}
-                selectable={false}
-                attributes={newTab() ? TextAttributes.BOLD : undefined}
-              >
-                +
-              </text>
-              <text
-                fg={newTab() || addHovered() ? theme.text.default : theme.text.subdued}
-                wrapMode="none"
-                selectable={false}
-                attributes={newTab() ? TextAttributes.BOLD : undefined}
-              >
-                {NEW_SESSION_TAB_TITLE}
-              </text>
-              <Show when={newTab()}>
-                <text
-                  position="absolute"
-                  right={1}
-                  zIndex={2}
-                  width={1}
-                  fg={theme.text.subdued}
-                  selectable={false}
-                  onMouseUp={(event) => {
-                    if (!addHovered()) return
-                    event.stopPropagation()
-                    tabs.close()
-                  }}
-                >
-                  {addHovered() ? "×" : ""}
-                </text>
-              </Show>
-            </box>
-          </Show>
         </box>
       </scrollbox>
     </box>
@@ -567,9 +430,8 @@ function HorizontalSessionTabs(props: { controller?: SessionTabsController; anim
   const { mode } = useThemes()
   const config = useConfig().data
   const animations = () => props.animations ?? config.animations ?? true
-  const [addHovered, setAddHovered] = createSignal(false)
-  const marquee = createTabMarquee(animations)
-  const hovered = marquee.hovered
+  const [hovered, setHovered] = createSignal<string>()
+  const marquee = createMarquee(hovered, animations)
   const [dragging, setDragging] = createSignal<string>()
   // A drag reorders a local preview and persists one move on release instead of writing
   // per slot crossing; the preview holds after release until the store reflects the move,
@@ -587,10 +449,7 @@ function HorizontalSessionTabs(props: { controller?: SessionTabsController; anim
     if (!pending) return tabs.tabs()
     return moveSessionTab(tabs.tabs(), pending.sessionID, pending.index)
   })
-  // The promoted new-session slot joins the strip as the active tab; the idle plus affordance
-  // and the promoted slot are mutually exclusive states of one control.
   const items = createMemo(() => (newTab() ? [...ordered(), NEW_SESSION_TAB] : ordered()))
-  const showPlus = () => Boolean(tabs.add) && !newTab()
   createEffect(() => {
     const pending = preview()
     if (!pending || dragging()) return
@@ -598,17 +457,8 @@ function HorizontalSessionTabs(props: { controller?: SessionTabsController; anim
     if (index === -1 || index === Math.min(pending.index, tabs.tabs().length - 1)) setPreview(undefined)
   })
   const layout = createMemo((previous: ReturnType<typeof adaptiveSessionTabLayout> | undefined) =>
-    adaptiveSessionTabLayout(
-      items(),
-      activeID(),
-      dimensions().width - (showPlus() ? ADD_TAB_WIDTH : 0),
-      previous?.start,
-    ),
+    adaptiveSessionTabLayout(items(), activeID(), dimensions().width, previous?.start),
   )
-  createEffect(() => {
-    const active = marquee.active()
-    if (active && !layout().tabs.some((tab) => tab.sessionID === active)) marquee.reset()
-  })
   const statuses = createMemo(
     () =>
       new Map(
@@ -761,7 +611,7 @@ function HorizontalSessionTabs(props: { controller?: SessionTabsController; anim
           // Hovering reveals the close mark, so the title's right bound shifts left of it.
           const availableTitleWidth = () =>
             Math.max(1, width() - 1 - numberWidth() - (hovered() === tab.sessionID ? 2 : 0))
-          const scrolling = () => marquee.active() === tab.sessionID && marquee.offset() > 0
+          const scrolling = () => hovered() === tab.sessionID && marquee.offset() > 0
           const visibleTitle = createMemo(() =>
             scrolling()
               ? marqueeText(title(), availableTitleWidth(), marquee.offset())
@@ -820,10 +670,10 @@ function HorizontalSessionTabs(props: { controller?: SessionTabsController; anim
               position="relative"
               flexDirection="row"
               backgroundColor={background()}
-              onMouseOver={() => marquee.enter(tab.sessionID, title(), availableTitleWidth())}
-              onMouseOut={() => marquee.leave(tab.sessionID)}
+              onMouseOver={() => setHovered(tab.sessionID)}
+              onMouseOut={() => setHovered(undefined)}
               onMouseDown={() => {
-                marquee.enter(tab.sessionID, title(), availableTitleWidth())
+                setHovered(tab.sessionID)
                 setDragging(tab.sessionID)
               }}
               onMouseUp={release}
@@ -854,7 +704,7 @@ function HorizontalSessionTabs(props: { controller?: SessionTabsController; anim
                   {" "}
                 </text>
                 <text width={numberWidth()} fg={numberColor()} selectable={false} attributes={bold()}>
-                  {tab === NEW_SESSION_TAB ? "+" : sessionTabShortcutLabel(tabNumber() - 1)}
+                  {sessionTabShortcutLabel(tabNumber() - 1)}
                 </text>
                 <text
                   width={availableTitleWidth()}
@@ -896,19 +746,6 @@ function HorizontalSessionTabs(props: { controller?: SessionTabsController; anim
           {" " + layout().after}›
         </text>
       </Show>
-      <Show when={showPlus()}>
-        <text
-          width={ADD_TAB_WIDTH}
-          fg={addHovered() ? theme.text.default : theme.text.subdued}
-          bg={addHovered() ? theme.background.action.primary.hovered : undefined}
-          selectable={false}
-          onMouseOver={() => setAddHovered(true)}
-          onMouseOut={() => setAddHovered(false)}
-          onMouseUp={() => tabs.add?.()}
-        >
-          {" + "}
-        </text>
-      </Show>
     </box>
   )
 }

packages/tui/src/config/index.tsx

@@ -137,9 +137,6 @@ export const Info = Schema.Struct({
       markdown: Schema.optional(Schema.Literals(["source", "rendered"])).annotate({
         description: "Show Markdown syntax markers or conceal them in rendered transcript content",
       }),
-      new_location: Schema.optional(Schema.Literals(["launch", "inherit"])).annotate({
-        description: "Start new sessions in the TUI launch directory or inherit the active session location",
-      }),
     }),
   ).annotate({ description: "Session transcript presentation settings" }),
   tabs: Schema.optional(
@@ -205,7 +202,7 @@ export const Info = Schema.Struct({
 })
 export type Info = Schema.Schema.Type<typeof Info>
 
-export type Resolved = Omit<Info, "attention" | "cursor" | "keybinds" | "leader" | "mouse" | "session" | "tabs"> & {
+export type Resolved = Omit<Info, "attention" | "cursor" | "keybinds" | "leader" | "mouse" | "tabs"> & {
   attention: {
     enabled: boolean
     notifications: boolean
@@ -221,9 +218,6 @@ export type Resolved = Omit<Info, "attention" | "cursor" | "keybinds" | "leader"
     style: "block" | "underline" | "line" | "default"
     blinking: boolean
   }
-  session: Omit<NonNullable<Info["session"]>, "new_location"> & {
-    new_location: "launch" | "inherit"
-  }
   tabs: {
     enabled: boolean
     scope: "global" | "cwd"
@@ -234,10 +228,10 @@ export type Resolved = Omit<Info, "attention" | "cursor" | "keybinds" | "leader"
 export function resolve(input: Info, options: { terminalSuspend: boolean }): Resolved {
   const keybinds: TuiKeybind.KeybindOverrides = { ...input.keybinds }
   if (!options.terminalSuspend) {
-    keybinds["terminal.suspend"] = "none"
-    if (keybinds["input.undo"] === undefined) {
-      const inputUndo = TuiKeybind.defaultValue("input.undo")
-      keybinds["input.undo"] = ["ctrl+z", ...(typeof inputUndo === "string" ? inputUndo.split(",") : [])]
+    keybinds.terminal_suspend = "none"
+    if (keybinds.input_undo === undefined) {
+      const inputUndo = TuiKeybind.defaultValue("input_undo")
+      keybinds.input_undo = ["ctrl+z", ...(typeof inputUndo === "string" ? inputUndo.split(",") : [])]
         .filter((value, index, values) => values.indexOf(value) === index)
         .join(",")
     }
@@ -254,6 +248,7 @@ export function resolve(input: Info, options: { terminalSuspend: boolean }): Res
       sounds: input.attention?.sounds ?? {},
     },
     keybinds: createBindingLookup(TuiKeybind.toBindingConfig(TuiKeybind.parse(keybinds)), {
+      commandMap: TuiKeybind.CommandMap,
       bindingDefaults: TuiKeybind.bindingDefaults(),
     }),
     leader: { timeout: input.leader?.timeout ?? 2000 },
@@ -264,10 +259,6 @@ export function resolve(input: Info, options: { terminalSuspend: boolean }): Res
           blinking: input.cursor.blinking ?? true,
         }
       : undefined,
-    session: {
-      ...input.session,
-      new_location: input.session?.new_location ?? "launch",
-    },
     tabs: {
       ...input.tabs,
       enabled: input.tabs?.enabled ?? true,

packages/tui/src/config/keybind.ts

@@ -1,336 +1,2 @@
-export * as TuiKeybind from "./keybind"
-
-import type { KeyEvent, Renderable } from "@opentui/core"
-import type { Binding } from "@opentui/keymap"
-import type { BindingConfig, BindingDefaults } from "@opentui/keymap/extras"
-import { Schema } from "effect"
-
-const KeyStroke = Schema.Struct({
-  name: Schema.String,
-  ctrl: Schema.optional(Schema.Boolean),
-  shift: Schema.optional(Schema.Boolean),
-  meta: Schema.optional(Schema.Boolean),
-  super: Schema.optional(Schema.Boolean),
-  hyper: Schema.optional(Schema.Boolean),
-})
-
-const BindingObject = Schema.StructWithRest(
-  Schema.Struct({
-    key: Schema.Union([Schema.String, KeyStroke]),
-    event: Schema.optional(Schema.Literals(["press", "release"])),
-    preventDefault: Schema.optional(Schema.Boolean),
-    fallthrough: Schema.optional(Schema.Boolean),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
-
-const BindingItem = Schema.Union([Schema.String, KeyStroke, BindingObject])
-export const BindingValueSchema = Schema.Union([
-  Schema.Literal(false),
-  Schema.Literal("none"),
-  BindingItem,
-  Schema.Array(BindingItem),
-])
-export type BindingValueSchema = Schema.Schema.Type<typeof BindingValueSchema>
-
-type Definition = {
-  default: BindingValueSchema
-  description: string
-}
-
-export const LeaderDefault = "ctrl+x"
-
-const keybind = (value: Definition["default"], description: string): Definition => ({ default: value, description })
-
-export const Definitions = {
-  leader: keybind(LeaderDefault, "Leader key for keybind combinations"),
-
-  "app.exit": keybind("ctrl+c,ctrl+d,<leader>q", "Exit the application"),
-  "app.debug": keybind("none", "Toggle debug panel"),
-  "app.console": keybind("none", "Toggle console"),
-  "app.scrap": keybind("none", "Open scrap screen"),
-  "app.toggle.animations": keybind("none", "Toggle animations"),
-  "app.toggle.file_context": keybind("none", "Toggle file context"),
-  "app.toggle.diffwrap": keybind("none", "Toggle diff wrapping"),
-  "app.toggle.paste_summary": keybind("none", "Toggle paste summary"),
-  "command.palette.show": keybind("ctrl+p", "List available commands"),
-  "help.show": keybind("none", "Open help dialog"),
-  "docs.open": keybind("none", "Open documentation"),
-  "opencode.settings": keybind("none", "Open settings"),
-  "server.pair": keybind("none", "Pair device"),
-  "service.restart": keybind("none", "Restart service"),
-  "permission.mode": keybind("none", "Toggle auto-approve permissions"),
-  "diff.open": keybind("none", "Open diff viewer"),
-  "diff.close": keybind("escape,q", "Close diff viewer"),
-  "diff.down": keybind("j,down", "Move diff viewer down"),
-  "diff.up": keybind("k,up", "Move diff viewer up"),
-  "diff.page.down": keybind("pagedown,ctrl+f", "Page diff viewer down"),
-  "diff.page.up": keybind("pageup,ctrl+b", "Page diff viewer up"),
-  "diff.toggle": keybind("enter,space", "Toggle diff viewer item"),
-  "diff.expand": keybind("right", "Expand diff viewer item"),
-  "diff.expand_all": keybind("E", "Expand all diff viewer folders"),
-  "diff.collapse": keybind("left", "Collapse diff viewer item"),
-  "diff.switch_focus": keybind("tab", "Switch diff viewer focus"),
-  "diff.next_hunk": keybind("]", "Jump to next diff hunk"),
-  "diff.previous_hunk": keybind("[", "Jump to previous diff hunk"),
-  "diff.next_file": keybind("n", "Jump to next diff file"),
-  "diff.previous_file": keybind("p", "Jump to previous diff file"),
-  "diff.toggle_file_tree": keybind("b", "Toggle diff viewer file tree"),
-  "diff.single_patch": keybind("s", "Toggle single patch view"),
-  "diff.switch_source": keybind("d", "Switch diff viewer source"),
-  "diff.toggle_view": keybind("v", "Toggle diff viewer split or unified view"),
-  "diff.mark_reviewed": keybind("m", "Toggle selected diff file reviewed"),
-  "diff.help": keybind("?", "Show more diff viewer shortcuts"),
-
-  "prompt.editor": keybind("<leader>e", "Open external editor"),
-  "theme.switch": keybind("<leader>t", "List available themes"),
-  "theme.switch_mode": keybind("none", "Switch between light and dark theme mode"),
-  "theme.mode.lock": keybind("none", "Lock or unlock theme mode"),
-  "session.sidebar.toggle": keybind("<leader>b", "Toggle sidebar"),
-  "session.toggle.scrollbar": keybind("none", "Toggle session scrollbar"),
-  "opencode.status": keybind("<leader>s", "View status"),
-  "opencode.debug": keybind("none", "View debug info"),
-
-  "session.export": keybind("<leader>x", "Export session to editor"),
-  "session.copy": keybind("none", "Copy session transcript"),
-  "session.move": keybind("none", "Move session"),
-  "session.new": keybind("<leader>n", "Create a new session"),
-  "session.list": keybind("<leader>l", "List all sessions"),
-  "open.menu": keybind("ctrl+o", "Open recent sessions and projects"),
-  "session.tab.next": keybind("ctrl+tab,alt+down", "Switch to next open session tab"),
-  "session.tab.previous": keybind("ctrl+shift+tab,alt+up", "Switch to previous open session tab"),
-  "session.tab.history.back": keybind("none", "Go back in session tab history"),
-  "session.tab.history.forward": keybind("ctrl+i", "Go forward in session tab history"),
-  "session.tab.next_unread": keybind("alt+shift+down", "Switch to next unread session tab"),
-  "session.tab.previous_unread": keybind("alt+shift+up", "Switch to previous unread session tab"),
-  "session.tab.close": keybind("<leader>w", "Close current session tab"),
-  "session.tab.reopen": keybind("ctrl+shift+t", "Reopen last closed session tab"),
-  "session.timeline": keybind("<leader>g", "Show session timeline"),
-  "session.fork": keybind("none", "Fork session from message"),
-  "session.rename": keybind("ctrl+r", "Rename session"),
-  "session.delete": keybind("ctrl+d", "Delete session"),
-  "session.share": keybind("none", "Share current session"),
-  "session.unshare": keybind("none", "Unshare current session"),
-  "session.interrupt": keybind("escape", "Interrupt current session"),
-  "session.background": keybind("ctrl+b", "Background blocking session tools"),
-  "session.compact": keybind("<leader>c", "Compact the session"),
-  "session.cd": keybind("none", "Change working directory"),
-  "session.queued_prompts": keybind("<leader>q", "Manage queued prompts"),
-  "queued_prompt.delete": keybind("ctrl+d", "Delete queued prompt"),
-  "session.toggle.exploration_grouping": keybind("none", "Toggle related tool call grouping"),
-  "session.child.first": keybind("down", "Toggle subagent picker"),
-  "session.child.next": keybind("right", "Go to next child session"),
-  "session.child.previous": keybind("left", "Go to previous child session"),
-  "session.parent": keybind("up", "Go to parent session"),
-  "session.pin.toggle": keybind("ctrl+f", "Pin or unpin session in the session list"),
-  "session.quick_switch.1": keybind("<leader>1", "Switch to session in quick slot 1"),
-  "session.quick_switch.2": keybind("<leader>2", "Switch to session in quick slot 2"),
-  "session.quick_switch.3": keybind("<leader>3", "Switch to session in quick slot 3"),
-  "session.quick_switch.4": keybind("<leader>4", "Switch to session in quick slot 4"),
-  "session.quick_switch.5": keybind("<leader>5", "Switch to session in quick slot 5"),
-  "session.quick_switch.6": keybind("<leader>6", "Switch to session in quick slot 6"),
-  "session.quick_switch.7": keybind("<leader>7", "Switch to session in quick slot 7"),
-  "session.quick_switch.8": keybind("<leader>8", "Switch to session in quick slot 8"),
-  "session.quick_switch.9": keybind("<leader>9", "Switch to session in quick slot 9"),
-  "session.tab.select.1": keybind("<leader>1,ctrl+1", "Switch to session tab 1"),
-  "session.tab.select.2": keybind("<leader>2,ctrl+2", "Switch to session tab 2"),
-  "session.tab.select.3": keybind("<leader>3,ctrl+3", "Switch to session tab 3"),
-  "session.tab.select.4": keybind("<leader>4,ctrl+4", "Switch to session tab 4"),
-  "session.tab.select.5": keybind("<leader>5,ctrl+5", "Switch to session tab 5"),
-  "session.tab.select.6": keybind("<leader>6,ctrl+6", "Switch to session tab 6"),
-  "session.tab.select.7": keybind("<leader>7,ctrl+7", "Switch to session tab 7"),
-  "session.tab.select.8": keybind("<leader>8,ctrl+8", "Switch to session tab 8"),
-  "session.tab.select.9": keybind("<leader>9,ctrl+9", "Switch to session tab 9"),
-  "session.tab.select.10": keybind("<leader>0,ctrl+0", "Switch to session tab 10"),
-
-  "stash.delete": keybind("ctrl+d", "Delete stash entry"),
-  "model.dialog.provider": keybind("ctrl+a", "Open provider list from model dialog"),
-  "model.dialog.favorite": keybind("ctrl+f", "Toggle model favorite status"),
-  "model.list": keybind("<leader>m", "List available models"),
-  "model.cycle_recent": keybind("f2", "Next recently used model"),
-  "model.cycle_recent_reverse": keybind("shift+f2", "Previous recently used model"),
-  "model.cycle_favorite": keybind("none", "Next favorite model"),
-  "model.cycle_favorite_reverse": keybind("none", "Previous favorite model"),
-  "mcp.list": keybind("none", "List MCP servers"),
-  "provider.connect": keybind("none", "Connect integration"),
-  "agent.list": keybind("<leader>a", "List agents"),
-  "agent.cycle": keybind("shift+tab", "Next agent"),
-  "agent.cycle.reverse": keybind("none", "Previous agent"),
-  "variant.cycle": keybind("ctrl+t", "Cycle model variants"),
-  "variant.list": keybind("none", "List model variants"),
-
-  "session.page.up": keybind("pageup,ctrl+alt+b", "Scroll messages up by one page"),
-  "session.page.down": keybind("pagedown,ctrl+alt+f", "Scroll messages down by one page"),
-  "session.line.up": keybind("ctrl+alt+y", "Scroll messages up by one line"),
-  "session.line.down": keybind("ctrl+alt+e", "Scroll messages down by one line"),
-  "session.half.page.up": keybind("ctrl+alt+u", "Scroll messages up by half page"),
-  "session.half.page.down": keybind("ctrl+alt+d", "Scroll messages down by half page"),
-  "session.first": keybind("ctrl+g,home,alt+home", "Navigate to first message"),
-  "session.last": keybind("ctrl+alt+g,end", "Navigate to last message"),
-  "session.message.next": keybind("none", "Navigate to next message"),
-  "session.message.previous": keybind("none", "Navigate to previous message"),
-  "session.message.user.next": keybind("none", "Navigate to next user message"),
-  "session.message.user.previous": keybind("none", "Navigate to previous user message"),
-  "session.messages_last_user": keybind("alt+end", "Navigate to last user message"),
-  "messages.copy": keybind("<leader>y", "Copy message"),
-  "session.undo": keybind("<leader>u", "Undo message"),
-  "session.redo": keybind("<leader>r", "Redo message"),
-  "session.toggle.thinking": keybind("none", "Toggle thinking blocks visibility"),
-
-  "prompt.submit": keybind("none", "Submit prompt"),
-  "prompt.queue": keybind("alt+return", "Queue prompt"),
-  "prompt.editor_context.clear": keybind("none", "Clear editor context"),
-  "prompt.images.view": keybind("<leader>i", "View image attachments"),
-  "prompt.skills": keybind("none", "Open skill selector"),
-  "prompt.stash": keybind("none", "Stash prompt"),
-  "prompt.stash.pop": keybind("none", "Pop stashed prompt"),
-  "prompt.stash.list": keybind("none", "List stashed prompts"),
-
-  "prompt.clear": keybind("ctrl+c", "Clear input field"),
-  "prompt.paste": keybind({ key: "ctrl+v", preventDefault: false }, "Paste from clipboard"),
-  "input.submit": keybind("return", "Submit input"),
-  "input.newline": keybind("shift+return,ctrl+return,ctrl+j", "Insert newline in input"),
-  "input.move.left": keybind("left,ctrl+b", "Move cursor left in input"),
-  "input.move.right": keybind("right,ctrl+f", "Move cursor right in input"),
-  "input.move.up": keybind("up", "Move cursor up in input"),
-  "input.move.down": keybind("down", "Move cursor down in input"),
-  "input.select.left": keybind("shift+left", "Select left in input"),
-  "input.select.right": keybind("shift+right", "Select right in input"),
-  "input.select.up": keybind("shift+up", "Select up in input"),
-  "input.select.down": keybind("shift+down", "Select down in input"),
-  "input.line.home": keybind("ctrl+a", "Move to start of line in input"),
-  "input.line.end": keybind("ctrl+e", "Move to end of line in input"),
-  "input.select.line.home": keybind("ctrl+shift+a", "Select to start of line in input"),
-  "input.select.line.end": keybind("ctrl+shift+e", "Select to end of line in input"),
-  "input.visual.line.home": keybind("alt+a", "Move to start of visual line in input"),
-  "input.visual.line.end": keybind("alt+e", "Move to end of visual line in input"),
-  "input.select.visual.line.home": keybind("alt+shift+a", "Select to start of visual line in input"),
-  "input.select.visual.line.end": keybind("alt+shift+e", "Select to end of visual line in input"),
-  "input.buffer.home": keybind("none", "Move to start of buffer in input"),
-  "input.buffer.end": keybind("none", "Move to end of buffer in input"),
-  "input.select.buffer.home": keybind("shift+home", "Select to start of buffer in input"),
-  "input.select.buffer.end": keybind("shift+end", "Select to end of buffer in input"),
-  "input.delete.line": keybind("ctrl+shift+d", "Delete line in input"),
-  "input.delete.to.line.end": keybind("ctrl+k", "Delete to end of line in input"),
-  "input.delete.to.line.start": keybind("ctrl+u", "Delete to start of line in input"),
-  "input.backspace": keybind("backspace,shift+backspace", "Backspace in input"),
-  "input.delete": keybind("ctrl+d,delete,shift+delete", "Delete character in input"),
-  "input.undo": keybind("ctrl+-,super+z", "Undo in input"),
-  "input.redo": keybind("ctrl+.,super+shift+z", "Redo in input"),
-  "input.word.forward": keybind("alt+f,alt+right,ctrl+right", "Move word forward in input"),
-  "input.word.backward": keybind("alt+b,alt+left,ctrl+left", "Move word backward in input"),
-  "input.select.word.forward": keybind("alt+shift+f,alt+shift+right", "Select word forward in input"),
-  "input.select.word.backward": keybind("alt+shift+b,alt+shift+left", "Select word backward in input"),
-  "input.delete.word.forward": keybind("alt+d,alt+delete,ctrl+delete", "Delete word forward in input"),
-  "input.delete.word.backward": keybind("ctrl+w,ctrl+backspace,alt+backspace", "Delete word backward in input"),
-  "input.select.all": keybind("super+a", "Select all in input"),
-  "prompt.history.previous": keybind("up", "Previous history item"),
-  "prompt.history.next": keybind("down", "Next history item"),
-
-  "composer.subagent.up": keybind("up", "Previous subagent"),
-  "composer.subagent.down": keybind("down", "Next subagent"),
-  "composer.subagent.select": keybind("return", "Navigate to subagent"),
-  "composer.subagent.interrupt": keybind("ctrl+d", "Interrupt subagent"),
-  "composer.shell.up": keybind("up", "Previous shell"),
-  "composer.shell.down": keybind("down", "Next shell"),
-  "composer.shell.kill": keybind("ctrl+d", "Kill shell command"),
-
-  "dialog.select.prev": keybind("up,ctrl+p", "Move to previous dialog item"),
-  "dialog.select.next": keybind("down,ctrl+n", "Move to next dialog item"),
-  "dialog.select.page_up": keybind("pageup", "Move up one page in dialog"),
-  "dialog.select.page_down": keybind("pagedown", "Move down one page in dialog"),
-  "dialog.select.home": keybind("home", "Move to first dialog item"),
-  "dialog.select.end": keybind("end", "Move to last dialog item"),
-  "dialog.select.submit": keybind("return", "Submit selected dialog item"),
-  "dialog.prompt.submit": keybind("return", "Submit dialog prompt"),
-  "dialog.project_copy.generate": keybind("tab", "Generate project copy name"),
-  "dialog.move_session.new": keybind("ctrl+m", "New project copy"),
-  "dialog.move_session.delete": keybind("ctrl+d", "Delete project copy"),
-  "dialog.move_session.refresh": keybind("ctrl+r", "Refresh project copies"),
-  "prompt.autocomplete.prev": keybind("up,ctrl+p", "Move to previous autocomplete item"),
-  "prompt.autocomplete.next": keybind("down,ctrl+n", "Move to next autocomplete item"),
-  "prompt.autocomplete.hide": keybind("escape", "Hide autocomplete"),
-  "prompt.autocomplete.select": keybind("return", "Select autocomplete item"),
-  "prompt.autocomplete.complete": keybind("tab", "Complete autocomplete item"),
-  "permission.prompt.fullscreen": keybind("ctrl+f", "Toggle permission prompt fullscreen"),
-  "plugins.toggle": keybind("space", "Toggle plugin"),
-  "dialog.mcp.toggle": keybind("space", "Toggle MCP server"),
-  "dialog.plugins.install": keybind("shift+i", "Install plugin from plugin dialog"),
-
-  "terminal.suspend": keybind("ctrl+z", "Suspend terminal"),
-  "terminal.title.toggle": keybind("none", "Toggle terminal title"),
-  "plugins.list": keybind("none", "Open plugin manager dialog"),
-  "plugins.install": keybind("none", "Install plugin"),
-
-  "which-key.toggle": keybind("ctrl+alt+k", "Toggle which-key panel"),
-  "which-key.layout.toggle": keybind("ctrl+alt+shift+k", "Switch which-key layout"),
-  "which-key.pending.toggle": keybind("ctrl+alt+shift+p", "Toggle which-key pending preview"),
-  "which-key.group.previous": keybind("ctrl+alt+left,ctrl+alt+[", "Previous which-key group"),
-  "which-key.group.next": keybind("ctrl+alt+right,ctrl+alt+]", "Next which-key group"),
-  "which-key.scroll.up": keybind("ctrl+alt+up,ctrl+alt+p", "Scroll which-key up"),
-  "which-key.scroll.down": keybind("ctrl+alt+down,ctrl+alt+n", "Scroll which-key down"),
-  "which-key.page.up": keybind("ctrl+alt+pageup", "Page which-key up"),
-  "which-key.page.down": keybind("ctrl+alt+pagedown", "Page which-key down"),
-  "which-key.home": keybind("ctrl+alt+home", "Jump to first which-key binding"),
-  "which-key.end": keybind("ctrl+alt+end", "Jump to last which-key binding"),
-} satisfies Record<string, Definition>
-
-type KeybindName = keyof typeof Definitions
-const KeybindNames = new Set<string>(Object.keys(Definitions))
-
-export const KeybindOverrides = Schema.Struct(
-  Object.fromEntries(
-    Object.entries(Definitions).map(([name, item]) => [
-      name,
-      Schema.optional(BindingValueSchema).annotate({ description: item.description }),
-    ]),
-  ),
-).annotate({ description: "TUI keybinding overrides" })
-export const Descriptions = Object.fromEntries(
-  Object.entries(Definitions).map(([name, item]) => [name, item.description]),
-) as Record<KeybindName, string>
-
-export type Keybinds = { [K in KeybindName]: BindingValueSchema }
-export type KeybindOverrides = Partial<Keybinds>
-export type BindingLookupView = {
-  readonly bindings: readonly Binding<Renderable, KeyEvent>[]
-  get(command: string): readonly Binding<Renderable, KeyEvent>[]
-  has(command: string): boolean
-  gather(name: string, commands: readonly string[]): readonly Binding<Renderable, KeyEvent>[]
-  pick(name: string, commands: readonly string[]): Binding<Renderable, KeyEvent>[]
-  omit(name: string, commands: readonly string[]): Binding<Renderable, KeyEvent>[]
-}
-
-export function toBindingConfig(keybinds: Keybinds): BindingConfig<Renderable, KeyEvent> {
-  return Object.fromEntries(Object.entries(keybinds)) as BindingConfig<Renderable, KeyEvent>
-}
-
-const decodeBindingValue = Schema.decodeUnknownSync(BindingValueSchema)
-
-export function defaultValue(name: KeybindName) {
-  return Definitions[name].default
-}
-
-export function parse(keybinds: KeybindOverrides): Keybinds {
-  const invalid = unknownKeys(keybinds)
-  if (invalid.length) throw new Error(`Unrecognized keybind${invalid.length === 1 ? "" : "s"}: ${invalid.join(", ")}`)
-  return Object.fromEntries(
-    Object.entries(Definitions).map(([name, item]) => [
-      name,
-      decodeBindingValue(keybinds[name as KeybindName] ?? item.default),
-    ]),
-  ) as Keybinds
-}
-
-export const Keybinds = { parse }
-
-export function unknownKeys(input: object) {
-  return Object.keys(input).filter((key) => !KeybindNames.has(key))
-}
-
-export function bindingDefaults(): BindingDefaults<Renderable, KeyEvent> {
-  return ({ command, binding }) => {
-    if (binding.desc !== undefined) return
-    return { desc: Descriptions[command as KeybindName] }
-  }
-}
+export * from "./v1/keybind"
+export * as TuiKeybind from "./v1/keybind"

packages/tui/src/config/new-session-location.ts

@@ -1,10 +0,0 @@
-import type { LocationRef } from "@opencode-ai/client/promise"
-
-export function newSessionLocation(
-  mode: "launch" | "inherit",
-  launchDirectory: string,
-  current?: LocationRef,
-): LocationRef {
-  if (mode === "inherit" && current) return current
-  return { directory: launchDirectory }
-}

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

@@ -7,7 +7,6 @@ import { withTimestampedFallback } from "@opencode-ai/util/session-title-fallbac
 import { useEvent } from "./event"
 import { useRoute } from "./route"
 import { useConfig } from "../config"
-import { useLocation } from "./location"
 import { useStorage } from "./storage"
 import { useTuiPaths } from "./runtime"
 import {
@@ -49,7 +48,6 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     const data = useData()
     const event = useEvent()
     const config = useConfig().data
-    const location = useLocation()
     const paths = useTuiPaths()
     const enabled = () => config.tabs.enabled
     // Keyed reconcile keeps tab object identity across reorders, so strip rows move instead of
@@ -251,14 +249,6 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
         if (!enabled()) return
         route.navigate({ type: "session", sessionID: root(sessionID) })
       },
-      add() {
-        if (!enabled()) return
-        const sessionID = current()
-        route.navigate({
-          type: "home",
-          location: (sessionID ? data.session.get(sessionID)?.location : undefined) ?? location.ref,
-        })
-      },
       close(sessionID?: string) {
         if (!enabled()) return
         const target = sessionID ? root(sessionID) : current()

packages/tui/src/feature-plugins/home/footer.tsx

@@ -3,17 +3,7 @@ import { createMemo, Match, Show, Switch } from "solid-js"
 import { useTerminalDimensions } from "@opentui/solid"
 import { usePlugin } from "../../plugin/context"
 
-export function homeFooterVisibility(width: number) {
-  return {
-    mcpCommand: width >= 64,
-    pluginCommand: width >= 80,
-    version: width >= 64,
-  }
-}
-
 function Mcp(props: { context: Plugin.Context }) {
-  const dimensions = useTerminalDimensions()
-  const visibility = createMemo(() => homeFooterVisibility(dimensions().width))
   const list = createMemo(() => props.context.data.location.mcp.server.list(props.context.location) ?? [])
   const failed = createMemo(() => list().filter((item) => item.status.status === "failed").length)
   const count = createMemo(() => list().filter((item) => item.status.status === "connected").length)
@@ -40,17 +30,13 @@ function Mcp(props: { context: Plugin.Context }) {
             </Match>
           </Switch>
         </text>
-        <Show when={visibility().mcpCommand}>
-          <text fg={props.context.theme.text.subdued}>/mcps</text>
-        </Show>
+        <text fg={props.context.theme.text.subdued}>/mcps</text>
       </box>
     </Show>
   )
 }
 
 function Plugins(props: { context: Plugin.Context }) {
-  const dimensions = useTerminalDimensions()
-  const visibility = createMemo(() => homeFooterVisibility(dimensions().width))
   const plugins = usePlugin()
   const failed = createMemo(() => plugins.list().filter((item) => item.status === "failed").length)
 
@@ -61,9 +47,7 @@ function Plugins(props: { context: Plugin.Context }) {
           <span style={{ fg: props.context.theme.text.feedback.error.default }}>⊙ </span>
           {failed()} plugin{failed() === 1 ? "" : "s"} failed
         </text>
-        <Show when={visibility().pluginCommand}>
-          <text fg={props.context.theme.text.subdued}>/plugins</text>
-        </Show>
+        <text fg={props.context.theme.text.subdued}>/plugins</text>
       </box>
     </Show>
   )
@@ -71,7 +55,6 @@ function Plugins(props: { context: Plugin.Context }) {
 
 function View(props: { context: Plugin.Context }) {
   const dimensions = useTerminalDimensions()
-  const visibility = createMemo(() => homeFooterVisibility(dimensions().width))
 
   return (
     <Show when={dimensions().height >= 12 && dimensions().width >= 44}>
@@ -88,11 +71,9 @@ function View(props: { context: Plugin.Context }) {
         <Mcp context={props.context} />
         <Plugins context={props.context} />
         <box flexGrow={1} />
-        <Show when={visibility().version}>
-          <box flexShrink={0}>
-            <text fg={props.context.theme.text.subdued}>{props.context.app.version}</text>
-          </box>
-        </Show>
+        <box flexShrink={0}>
+          <text fg={props.context.theme.text.subdued}>{props.context.app.version}</text>
+        </box>
       </box>
     </Show>
   )

packages/tui/src/feature-plugins/system/diff-viewer.tsx

@@ -427,6 +427,7 @@ function DiffViewer(props: { context: Plugin.Context }) {
       id: "diff.down",
       title: "Move diff viewer down",
       group: "VCS",
+      bind: "j,down",
       run: focusRunner({
         files() {
           moveFileSelection(1)
@@ -441,6 +442,7 @@ function DiffViewer(props: { context: Plugin.Context }) {
       id: "diff.up",
       title: "Move diff viewer up",
       group: "VCS",
+      bind: "k,up",
       run: focusRunner({
         files() {
           moveFileSelection(-1)
@@ -455,6 +457,7 @@ function DiffViewer(props: { context: Plugin.Context }) {
       id: "diff.page.down",
       title: "Page diff viewer down",
       group: "VCS",
+      bind: "pagedown,ctrl+f",
       run: focusRunner({
         files() {
           moveFileSelection(8)
@@ -469,6 +472,7 @@ function DiffViewer(props: { context: Plugin.Context }) {
       id: "diff.page.up",
       title: "Page diff viewer up",
       group: "VCS",
+      bind: "pageup,ctrl+b",
       run: focusRunner({
         files() {
           moveFileSelection(-8)
@@ -574,6 +578,7 @@ function DiffViewer(props: { context: Plugin.Context }) {
       id: "diff.mark_reviewed",
       title: "Toggle selected diff file reviewed",
       group: "VCS",
+      bind: "m",
       run() {
         toggleSelectedFileReviewed()
       },

packages/tui/src/feature-plugins/system/plugins.tsx

@@ -34,38 +34,35 @@ function View(props: { context: Plugin.Context; plugins: ReturnType<typeof usePl
           ),
         }),
       )
-    const external = props.plugins
-      .list()
-      .filter((plugin) => plugin.status !== "unsupported")
-      .map(
-        (plugin): DialogSelectOption<string> => ({
-          title: plugin.id ?? plugin.target,
-          value: plugin.id ?? plugin.target,
-          category: "External",
-          searchText: plugin.target,
-          footer: (
-            <span
-              style={{
-                fg:
-                  plugin.status === "active"
-                    ? props.context.theme.text.feedback.success.default
-                    : plugin.status === "failed"
-                      ? props.context.theme.text.feedback.error.default
-                      : props.context.theme.text.subdued,
-              }}
-            >
-              {plugin.status}
-            </span>
-          ),
-        }),
-      )
+    const external = props.plugins.list().map(
+      (plugin): DialogSelectOption<string> => ({
+        title: "id" in plugin ? plugin.id : plugin.target,
+        value: "id" in plugin ? plugin.id : plugin.target,
+        category: "External",
+        searchText: plugin.target,
+        footer: (
+          <span
+            style={{
+              fg:
+                plugin.status === "active"
+                  ? props.context.theme.text.feedback.success.default
+                  : plugin.status === "failed"
+                    ? props.context.theme.text.feedback.error.default
+                    : props.context.theme.text.subdued,
+            }}
+          >
+            {plugin.status}
+          </span>
+        ),
+      }),
+    )
     return [...builtins, ...external].sort((a, b) => a.title.localeCompare(b.title))
   })
 
   const failure = (value: string | undefined) =>
     props.plugins.list().find((plugin) => {
       if (plugin.status !== "failed") return false
-      return (plugin.id ?? plugin.target) === value
+      return ("id" in plugin ? plugin.id : plugin.target) === value
     })
 
   createEffect(() => {
@@ -115,10 +112,7 @@ function View(props: { context: Plugin.Context; plugins: ReturnType<typeof usePl
               {
                 title: "toggle",
                 command: "plugins.toggle",
-                disabled: (option) => {
-                  const failed = failure(option?.value)
-                  return Boolean(failed && !("id" in failed && failed.id))
-                },
+                disabled: (option) => Boolean(failure(option?.value)),
                 onTrigger: toggle,
               },
             ]}

packages/tui/src/feature-plugins/system/storybook/session-tabs.tsx

@@ -105,21 +105,9 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
     }
   }
 
-  const addTab = () => {
-    const next = FIXTURE_TABS.find((fixture) => !tabs().some((tab) => tab.sessionID === fixture.sessionID))
-    if (!next) {
-      setLastEvent("all fixture tabs are open")
-      return
-    }
-    setItems([...tabs().map((tab) => ({ ...tab })), { sessionID: next.sessionID }])
-    select(next.sessionID)
-    setLastEvent(`tab ${number(next.sessionID)} opened untitled; run it to earn its title`)
-  }
-
   const controller = {
     tabs,
     current: active,
-    add: addTab,
     status(sessionID) {
       return statuses()[sessionID] ?? EMPTY_SESSION_TAB_STATUS
     },
@@ -295,7 +283,21 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
           startRun(current)
         },
       },
-      { bind: "t", title: "Add tab", group: "Storybook", run: addTab },
+      {
+        bind: "t",
+        title: "Add tab",
+        group: "Storybook",
+        run() {
+          const next = FIXTURE_TABS.find((fixture) => !tabs().some((tab) => tab.sessionID === fixture.sessionID))
+          if (!next) {
+            setLastEvent("all fixture tabs are open")
+            return
+          }
+          setItems([...tabs().map((tab) => ({ ...tab })), { sessionID: next.sessionID }])
+          select(next.sessionID)
+          setLastEvent(`tab ${number(next.sessionID)} opened untitled; run it to earn its title`)
+        },
+      },
       { bind: "d", title: "Close tab", group: "Storybook", run: () => controller.close() },
       {
         bind: "r",

packages/tui/src/mini/footer.view.tsx

@@ -191,7 +191,7 @@ export function RunFooterView(props: RunFooterViewProps) {
   const subagentShortcut = () => shortcut("session.child.first")
   const queuedShortcut = () => shortcut("session.queued_prompts")
   const backgroundShortcut = () => shortcut("session.background")
-  const subagentInterruptShortcut = () => shortcut("composer.subagent.interrupt")
+  const subagentInterruptShortcut = () => shortcut("subagent.interrupt")
   const interrupt = () => shortcut("session.interrupt")
   const variantCycle = () => monoShortcut(shortcuts.all("variant.cycle") ?? "", props.mono)
   const clearShortcut = () => shortcut("prompt.clear")
@@ -610,9 +610,10 @@ export function RunFooterView(props: RunFooterViewProps) {
     priority: 1,
     commands: [
       {
-        id: "composer.subagent.interrupt",
+        id: "subagent.interrupt",
         title: "Interrupt subagent",
         group: "Session",
+        bind: "ctrl+d",
         run: () => {
           const current = selectedTab()
           if (current?.status !== "running") {

packages/tui/src/mini/runtime.ts

@@ -11,7 +11,6 @@
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import type { LocationRef } from "@opencode-ai/client/promise"
 import type { Config } from "../config"
-import { newSessionLocation } from "../config/new-session-location"
 import { loadRunAgents, loadRunCommands, loadRunReferences } from "./catalog.shared"
 import {
   resolveMiniSettings,
@@ -49,7 +48,6 @@ type Reconnect = (signal: AbortSignal) => Promise<RunInput["sdk"]>
 
 type RunRuntimeInput = {
   host: MiniHost
-  directory: string
   boot: () => Promise<BootContext>
   resolveSession: (sdk: RunInput["sdk"], signal: AbortSignal) => Promise<ResolvedSession>
   createSession?: CreateSession
@@ -943,11 +941,7 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
               const created = await createSession(
                 state.sdk,
                 {
-                  location: newSessionLocation(
-                    (await tuiConfigTask).session.new_location,
-                    input.directory,
-                    state.location,
-                  ),
+                  location: state.location,
                   agent: state.agent,
                   model: state.model,
                   variant: state.activeVariant,
@@ -1105,7 +1099,6 @@ export async function runInteractiveDeferredMode(input: RunDeferredInput, deps?:
   return runInteractiveRuntime(
     {
       host: input.host,
-      directory: input.directory,
       files: input.files,
       initialInput: input.initialInput,
       thinking: input.thinking,

packages/tui/src/mini/types.ts

@@ -392,7 +392,7 @@ export type FormCancel = {
   location?: LocationRef
 }
 
-export type RunTuiConfig = Pick<Config.Resolved, "keybinds" | "leader" | "theme" | "mini" | "session">
+export type RunTuiConfig = Pick<Config.Resolved, "keybinds" | "leader" | "theme" | "mini">
 
 export type MiniSettings = {
   thinking: "show" | "hide"

packages/tui/src/plugin/context.tsx

@@ -34,7 +34,7 @@ export interface PackageResolver {
 type State =
   | { readonly target: string; readonly id: string; readonly status: "active" | "inactive" }
   | { readonly target: string; readonly status: "unsupported" }
-  | { readonly target: string; readonly id?: string; readonly status: "failed"; readonly error: string }
+  | { readonly target: string; readonly status: "failed"; readonly error: string }
 
 type RegisteredPlugin = {
   readonly id: string
@@ -271,7 +271,6 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
         if (!local && !previous) npmFailures.set(target, resolved.error)
         failures.push({
           target,
-          id: previous?.plugin.id,
           status: "failed",
           error: previous?.active ? `${resolved.error} (previous version still active)` : resolved.error,
         })
@@ -377,7 +376,7 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
         // A failed reload keeps this item running; the failure entry covers it.
         if (failedTargets.has(item.target)) return []
         const error = errors.get(item.plugin.id)
-        if (error) return [{ target: item.target, id: item.plugin.id, status: "failed", error }]
+        if (error) return [{ target: item.target, status: "failed", error }]
         const status = store.registrations[item.plugin.id]?.active ? "active" : "inactive"
         return [{ target: item.target, id: item.plugin.id, status }]
       }),

packages/tui/src/routes/session/composer/shell-tab.tsx

@@ -55,6 +55,7 @@ export function ShellTab(props: { sessionID: string }) {
         id: "composer.shell.up",
         title: "Previous shell",
         group: "Composer",
+        bind: "up",
         run() {
           if (store.selected === 0) {
             composer.close()
@@ -67,6 +68,7 @@ export function ShellTab(props: { sessionID: string }) {
         id: "composer.shell.down",
         title: "Next shell",
         group: "Composer",
+        bind: "down",
         run() {
           const list = entries()
           if (list.length === 0) return
@@ -77,6 +79,7 @@ export function ShellTab(props: { sessionID: string }) {
         id: "composer.shell.kill",
         title: "Kill shell command",
         group: "Composer",
+        bind: "ctrl+d",
         run() {
           const entry = selectedEntry()
           if (!entry) return

packages/tui/src/routes/session/composer/subagents-tab.tsx

@@ -169,6 +169,7 @@ export function SubagentsTab(props: { sessionID: string }) {
         id: "composer.subagent.up",
         title: "Previous subagent",
         group: "Composer",
+        bind: "up",
         run() {
           if (store.selected === 0) {
             composer.close()
@@ -181,6 +182,7 @@ export function SubagentsTab(props: { sessionID: string }) {
         id: "composer.subagent.down",
         title: "Next subagent",
         group: "Composer",
+        bind: "down",
         run() {
           const list = entries()
           if (list.length === 0) return
@@ -191,6 +193,7 @@ export function SubagentsTab(props: { sessionID: string }) {
         id: "composer.subagent.select",
         title: "Navigate to subagent",
         group: "Composer",
+        bind: "return",
         run() {
           const entry = entries()[store.selected]
           if (entry) navigate({ type: "session", sessionID: entry.sessionID })
@@ -210,6 +213,7 @@ export function SubagentsTab(props: { sessionID: string }) {
         id: "composer.subagent.interrupt",
         title: "Interrupt subagent",
         group: "Composer",
+        bind: "ctrl+d",
         run() {
           const entry = selectedEntry()
           if (!entry || entry.status !== "running") return

packages/tui/src/routes/session/index.tsx

@@ -1222,11 +1222,6 @@ function TurnTokenUsage(props: {
 }) {
   const config = useConfig()
   const theme = useTheme()
-  const renderer = useRenderer()
-  // Collapsed by default: one summary line for the whole turn. Click to
-  // open the full per-step table, click again to close.
-  const [expanded, setExpanded] = createSignal(false)
-  const [hover, setHover] = createSignal(false)
   const verbose = () => config.data.debug?.turn_tokens === "verbose"
   const steps = createMemo(() => {
     let previousCache = props.previousCache
@@ -1262,78 +1257,49 @@ function TurnTokenUsage(props: {
     cached: Math.max("Cached".length, ...steps().map((item) => item.cached.toLocaleString().length)),
     total: Math.max("Total".length, ...steps().map((item) => item.total.toLocaleString().length)),
   }))
-  const summary = createMemo(() => {
-    const items = steps()
-    const last = items[items.length - 1]
-    return {
-      count: items.length,
-      newTokens: items.reduce((sum, item) => sum + item.newTokens, 0),
-      cached: last?.cached ?? 0,
-      total: last?.total ?? 0,
-      reuseDrops: items.filter((item) => item.reuseDrop !== undefined).length,
-    }
-  })
   return (
     <Show when={Boolean(config.data.debug?.turn_tokens) && steps().length > 0}>
       <box paddingLeft={3} flexDirection="column">
-        <box
-          flexDirection="row"
-          onMouseOver={() => setHover(true)}
-          onMouseOut={() => setHover(false)}
-          onMouseUp={() => {
-            if (renderer.getSelection()?.getSelectedText()) return
-            setExpanded((value) => !value)
-          }}
-        >
-          <text fg={hover() ? theme.text.default : theme.text.subdued} wrapMode="none">
-            <span>{expanded() ? "- " : "+ "}</span>
-            <span style={{ attributes: TextAttributes.BOLD }}>Tokens</span>
-            <span>
-              : {summary().count} {summary().count === 1 ? "step" : "steps"} · {summary().newTokens.toLocaleString()}{" "}
-              new · {summary().cached.toLocaleString()} cached · {summary().total.toLocaleString()} total
-            </span>
-            <Show when={summary().reuseDrops > 0}>
-              <span style={{ fg: theme.text.feedback.warning.default }}>
-                {" "}
-                · ! {summary().reuseDrops} likely cache {summary().reuseDrops === 1 ? "bust" : "busts"}
-              </span>
-            </Show>
+        <box flexDirection="row">
+          <text width={INLINE_TOOL_ICON_WIDTH} fg={theme.text.subdued}>
+            ◈
+          </text>
+          <text fg={theme.text.subdued} attributes={TextAttributes.BOLD}>
+            Tokens
           </text>
         </box>
-        <Show when={expanded()}>
-          <box paddingLeft={INLINE_TOOL_ICON_WIDTH}>
-            <text fg={theme.text.subdued} attributes={TextAttributes.ITALIC}>
-              {"Step".padEnd(columns().step + 2)}
-              {"New".padStart(columns().newTokens)}
-              {"  "}
-              {"Cached".padStart(columns().cached)}
-              {"  "}
-              {"Total".padStart(columns().total)}
-            </text>
-          </box>
-          <For each={steps()}>
-            {(item) => (
-              <box paddingLeft={INLINE_TOOL_ICON_WIDTH} flexDirection="column">
-                <text fg={verbose() && item.finish === "tool-call" ? undefined : theme.text.subdued}>
-                  {item.finish.padEnd(columns().step + 2)}
-                  <span style={{ attributes: TextAttributes.BOLD }}>
-                    {item.newTokens.toLocaleString().padStart(columns().newTokens)}
-                  </span>
-                  {"  "}
-                  {item.cached.toLocaleString().padStart(columns().cached)}
-                  {"  "}
-                  {item.total.toLocaleString().padStart(columns().total)}
+        <box paddingLeft={INLINE_TOOL_ICON_WIDTH}>
+          <text fg={theme.text.subdued} attributes={TextAttributes.ITALIC}>
+            {"Step".padEnd(columns().step + 2)}
+            {"New".padStart(columns().newTokens)}
+            {"  "}
+            {"Cached".padStart(columns().cached)}
+            {"  "}
+            {"Total".padStart(columns().total)}
+          </text>
+        </box>
+        <For each={steps()}>
+          {(item) => (
+            <box paddingLeft={INLINE_TOOL_ICON_WIDTH} flexDirection="column">
+              <text fg={verbose() && item.finish === "tool-call" ? undefined : theme.text.subdued}>
+                {item.finish.padEnd(columns().step + 2)}
+                <span style={{ attributes: TextAttributes.BOLD }}>
+                  {item.newTokens.toLocaleString().padStart(columns().newTokens)}
+                </span>
+                {"  "}
+                {item.cached.toLocaleString().padStart(columns().cached)}
+                {"  "}
+                {item.total.toLocaleString().padStart(columns().total)}
+              </text>
+              <TurnTokenToolCalls tools={item.tools} />
+              <Show when={item.reuseDrop !== undefined}>
+                <text fg={theme.text.feedback.warning.default}>
+                  ! Likely cache bust: {item.reuseDrop?.toLocaleString()} fewer cached tokens than the previous step
                 </text>
-                <TurnTokenToolCalls tools={item.tools} />
-                <Show when={item.reuseDrop !== undefined}>
-                  <text fg={theme.text.feedback.warning.default}>
-                    ! Likely cache bust: {item.reuseDrop?.toLocaleString()} fewer cached tokens than the previous step
-                  </text>
-                </Show>
-              </box>
-            )}
-          </For>
-        </Show>
+              </Show>
+            </box>
+          )}
+        </For>
       </box>
     </Show>
   )
@@ -1814,7 +1780,7 @@ function CompactionMessage(props: { message: Extract<SessionMessageInfo, { type:
             streaming={true}
             internalBlockMode="top-level"
             content={content()}
-            tableOptions={{ style: "grid", cellPaddingX: 1 }}
+            tableOptions={{ style: "grid" }}
             conceal={ctx.markdownMode() === "rendered"}
             fg={theme.markdown.text}
             bg={theme.background.default}
@@ -1983,7 +1949,6 @@ function UserMessage(props: { message: SessionMessageUser }) {
         border={["left"]}
         borderColor={delivery() ? theme.border.default : color()}
         customBorderChars={SplitBorder.customBorderChars}
-        backgroundColor={theme.background.default}
       >
         <SessionImages images={images()} paddingLeft={2} />
         <box
@@ -2265,7 +2230,7 @@ function TextPart(props: { last: boolean; part: SessionMessageAssistantText }) {
           streaming={true}
           internalBlockMode="top-level"
           content={props.part.text.trim()}
-          tableOptions={{ style: "grid", cellPaddingX: 1 }}
+          tableOptions={{ style: "grid" }}
           conceal={ctx.markdownMode() === "rendered"}
           fg={theme.markdown.text}
           bg={theme.background.default}

packages/tui/src/ui/dialog-prompt.tsx

@@ -40,6 +40,7 @@ export function DialogPrompt(props: DialogPromptProps) {
       {
         id: "dialog.prompt.submit",
         title: "Submit dialog prompt",
+        bind: "return",
         group: "Dialog",
         run: confirm,
       },

packages/tui/src/ui/dialog-select.tsx

@@ -40,7 +40,6 @@ export interface DialogSelectProps<T> {
   bindings?: readonly KeymapCommand[]
   current?: T
   focusCurrent?: boolean
-  sectionNavigation?: boolean
 }
 
 type DialogSelectActionBase<T> = {
@@ -328,15 +327,6 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
     moveTo(moveSelection(store.selected, { count: flat().length, delta: direction, policy: "wrap" }), true)
   }
 
-  function moveSection(direction: 1 | -1) {
-    if (props.locked) return
-    const sections = grouped().filter(([_, options]) => options.length > 0)
-    if (sections.length === 0) return
-    const current = sections.findIndex(([category]) => category === selected()?.category)
-    const section = sections[(current + direction + sections.length) % sections.length]
-    moveTo(flat().indexOf(section[1][0]), true)
-  }
-
   function moveTo(next: number, center = false, preserve = true) {
     setFocusedAction(undefined)
     setStore("selected", next)
@@ -498,22 +488,6 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
             ]
           : []),
         ...(props.bindings ?? []),
-        ...(props.sectionNavigation
-          ? [
-              {
-                bind: "alt+up",
-                title: "Previous section",
-                group: "Dialog",
-                run: () => moveSection(-1),
-              },
-              {
-                bind: "alt+down",
-                title: "Next section",
-                group: "Dialog",
-                run: () => moveSection(1),
-              },
-            ]
-          : []),
       ],
     }
   })

packages/tui/src/util/marquee.ts

@@ -1,18 +1,14 @@
 import { Locale } from "./locale"
 import { stringWidth } from "./string-width"
 
-const GAP = " · "
-
-export function marqueeCycleWidth(value: string) {
-  return stringWidth(value + GAP)
-}
+const GAP = "    "
 
 export function marqueeText(value: string, width: number, offset: number) {
   if (width <= 0) return ""
   if (stringWidth(value) <= width || offset <= 0) return Locale.takeWidth(value, width)
 
   const loop = value + GAP
-  const cursor = offset % marqueeCycleWidth(value)
+  const cursor = offset % stringWidth(loop)
   const segments = Locale.graphemes(loop + loop)
   const start = segments.reduce(
     (state, segment, index) =>

packages/tui/test/app-lifecycle.test.tsx

@@ -294,63 +294,3 @@ test("session startup prompt is submitted exactly once", async () => {
     await server.stop()
   }
 })
-
-test("configured app bindings execute settings and permission commands", async () => {
-  const setup = await createTestRenderer({ width: 100, height: 30, useThread: false, kittyKeyboard: true })
-  setup.renderer.start()
-  const ready = Promise.withResolvers<void>()
-  const events = createEventStream()
-  const calls = createFetch(undefined, events)
-  const server = Bun.serve({ port: 0, fetch: (request) => calls.fetch(request) })
-
-  try {
-    const { run } = await import("../src/app")
-    const task = Effect.runPromise(
-      run({
-        app: { name: "test", version: "test", channel: "test" },
-        server: { endpoint: { url: server.url.toString() } },
-        config: {
-          get: async () => ({
-            animations: false,
-            keybinds: { "opencode.settings": "f6", "permission.mode": "f7" },
-          }),
-          update: async () => ({}),
-        },
-        packages: { resolve: async () => undefined },
-        args: {},
-        terminalHandoff: async () => ({ renderer: setup.renderer, mode: "dark", complete: ready.resolve }),
-        log: () => {},
-      }).pipe(Effect.provide(AppNodeBuilder.build(Global.node)), Effect.provide(FileSystem.layerNoop({}))),
-    )
-    await ready.promise
-    await setup.waitForFrame((frame) => frame.includes("commands"))
-
-    setup.mockInput.pressKey("F6")
-    const settings = await setup.waitForFrame((frame) => frame.includes("Settings"))
-    expect(settings).toContain("Color mode")
-    expect(settings).toContain("Animations")
-
-    setup.mockInput.pressEscape()
-    await setup.waitForFrame((frame) => !frame.includes("Settings"))
-    setup.mockInput.pressKey("F7")
-    await setup.renderOnce()
-    setup.mockInput.pressKey("p", { ctrl: true })
-    await setup.waitForFrame((frame) => frame.includes("Commands"))
-    setup.mockInput.pressKey("END")
-    const commands = await setup.waitForFrame(
-      (frame) => {
-        if (frame.includes("Disable auto-approve permissions")) return true
-        setup.mockInput.pressArrow("up")
-        return false
-      },
-      { maxPasses: 100 },
-    )
-    expect(commands).not.toContain("Enable auto-approve permissions")
-
-    setup.renderer.destroy()
-    await task
-  } finally {
-    if (!setup.renderer.isDestroyed) setup.renderer.destroy()
-    await server.stop()
-  }
-})

packages/tui/test/cli/tui/composer-keymap.test.tsx

@@ -1,190 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { testRender } from "@opentui/solid"
-import { expect, test } from "bun:test"
-import { onMount } from "solid-js"
-import { ConfigProvider } from "../../../src/config"
-import type { TuiKeybind } from "../../../src/config/keybind"
-import { ClientProvider } from "../../../src/context/client"
-import { DataProvider, useData } from "../../../src/context/data"
-import { Keymap } from "../../../src/context/keymap"
-import { LocationProvider } from "../../../src/context/location"
-import { RouteProvider, useRoute } from "../../../src/context/route"
-import { ThemeProvider } from "../../../src/context/theme"
-import { Composer } from "../../../src/routes/session/composer"
-import { createApi, createEventStream, createFetch, directory, json } from "../../fixture/tui-client"
-import { TestTuiContexts } from "../../fixture/tui-environment"
-import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
-
-const sessions = {
-  parent: session("parent", "Parent"),
-  "child-a": session("child-a", "First", "parent"),
-  "child-b": session("child-b", "Second", "parent"),
-}
-
-const shells = [shell("sh-a", "bun test"), shell("sh-b", "bun dev")]
-
-async function renderComposer(defaultTab: "subagents" | "shell", keybinds: Partial<TuiKeybind.Keybinds>) {
-  const events = createEventStream()
-  const interrupted: string[] = []
-  const removed: string[] = []
-  const ready = Promise.withResolvers<void>()
-  let closed = 0
-  let dispatch!: ReturnType<typeof Keymap.use>["dispatch"]
-  let route!: ReturnType<typeof useRoute>
-  const calls = createFetch((url, request) => {
-    if (url.pathname === "/api/session/active")
-      return json({ data: { "child-a": { type: "running" }, "child-b": { type: "running" } } })
-    const sessionID = url.pathname.match(/^\/api\/session\/([^/]+)$/)?.[1]
-    if (sessionID && sessionID in sessions) return json({ data: sessions[sessionID as keyof typeof sessions] })
-    const interruptID = url.pathname.match(/^\/api\/session\/([^/]+)\/interrupt$/)?.[1]
-    if (interruptID && request.method === "POST") {
-      interrupted.push(interruptID)
-      return new Response(null, { status: 204 })
-    }
-    if (url.pathname === "/api/shell" && request.method === "GET") {
-      const requestDirectory = url.searchParams.get("location[directory]") ?? directory
-      return json({
-        location: { directory: requestDirectory, project: { id: "proj_test", directory: requestDirectory } },
-        data: shells,
-      })
-    }
-    const shellID = url.pathname.match(/^\/api\/shell\/([^/]+)$/)?.[1]
-    if (shellID && request.method === "DELETE") {
-      removed.push(shellID)
-      return new Response(null, { status: 204 })
-    }
-  }, events)
-
-  function Content() {
-    const data = useData()
-    route = useRoute()
-    dispatch = Keymap.use().dispatch
-    onMount(() => {
-      void Promise.all([
-        data.session.sync("parent"),
-        data.session.sync("child-a"),
-        data.session.sync("child-b"),
-        data.shell.sync(),
-      ])
-        .then(() => wait(() => data.session.status("child-a") === "running"))
-        .then(() => ready.resolve(), ready.reject)
-    })
-    return <Composer sessionID="parent" open={true} defaultTab={defaultTab} onClose={() => closed++} />
-  }
-
-  const app = await testRender(
-    () => (
-      <TestTuiContexts directory={directory}>
-        <ConfigProvider config={createTuiResolvedConfig({ keybinds })}>
-          <Keymap.Provider>
-            <ClientProvider api={createApi(calls.fetch)}>
-              <DataProvider>
-                <LocationProvider>
-                  <RouteProvider initialRoute={{ type: "session", sessionID: "parent" }}>
-                    <ThemeProvider mode="dark" source={{ discover: async () => ({}) }}>
-                      <Content />
-                    </ThemeProvider>
-                  </RouteProvider>
-                </LocationProvider>
-              </DataProvider>
-            </ClientProvider>
-          </Keymap.Provider>
-        </ConfigProvider>
-      </TestTuiContexts>
-    ),
-    { width: 100, height: 20, kittyKeyboard: true },
-  )
-  await ready.promise
-  await app.renderOnce()
-  return {
-    app,
-    interrupted,
-    removed,
-    route: () => route.data,
-    dispatch: (command: string) => dispatch(command),
-    closed: () => closed,
-  }
-}
-
-test("disabled subagent bindings have no component fallbacks", async () => {
-  const composer = await renderComposer("subagents", {
-    "composer.subagent.up": "none",
-    "composer.subagent.down": "none",
-    "composer.subagent.select": "none",
-    "composer.subagent.interrupt": "none",
-  })
-  try {
-    expect(composer.app.captureCharFrame()).toContain("First")
-    composer.app.mockInput.pressArrow("up")
-    composer.app.mockInput.pressEnter()
-    composer.app.mockInput.pressKey("d", { ctrl: true })
-    await composer.app.renderOnce()
-    expect(composer.closed()).toBe(0)
-    expect(composer.route()).toMatchObject({ type: "session", sessionID: "parent" })
-    expect(composer.interrupted).toEqual([])
-
-    composer.app.mockInput.pressArrow("down")
-    composer.dispatch("composer.subagent.select")
-    expect(composer.route()).toMatchObject({ type: "session", sessionID: "child-a" })
-  } finally {
-    composer.app.renderer.destroy()
-  }
-})
-
-test("disabled shell bindings have no component fallbacks", async () => {
-  const composer = await renderComposer("shell", {
-    "composer.shell.up": "none",
-    "composer.shell.down": "none",
-    "composer.shell.kill": "none",
-  })
-  try {
-    expect(composer.app.captureCharFrame()).toContain("bun test")
-    composer.app.mockInput.pressArrow("up")
-    composer.app.mockInput.pressKey("d", { ctrl: true })
-    await composer.app.renderOnce()
-    expect(composer.closed()).toBe(0)
-    expect(composer.removed).toEqual([])
-
-    composer.app.mockInput.pressArrow("down")
-    composer.dispatch("composer.shell.kill")
-    await wait(() => composer.removed.length === 1)
-    expect(composer.removed).toEqual(["sh-a"])
-  } finally {
-    composer.app.renderer.destroy()
-  }
-})
-
-function session(id: string, title: string, parentID?: string) {
-  return {
-    id,
-    projectID: "proj_test",
-    title,
-    agent: "build",
-    location: { directory },
-    cost: 0,
-    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-    time: { created: 0, updated: 0 },
-    ...(parentID ? { parentID } : {}),
-  }
-}
-
-function shell(id: string, command: string) {
-  return {
-    id,
-    status: "running" as const,
-    command,
-    cwd: directory,
-    shell: "/bin/sh",
-    file: `/tmp/${id}`,
-    metadata: { sessionID: "parent" },
-    time: { started: 1 },
-  }
-}
-
-async function wait(fn: () => boolean, timeout = 2000) {
-  const start = Date.now()
-  while (!fn()) {
-    if (Date.now() - start > timeout) throw new Error("timed out waiting for condition")
-    await Bun.sleep(10)
-  }
-}