fix(tui): center prose measure on shared spine

packages/ai/src/protocols/bedrock-converse.ts

@@ -348,10 +348,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
           continue
         }
       }
-      const previous = messages.at(-1)
-      if (previous?.role === "user")
-        messages[messages.length - 1] = { role: "user", content: [...previous.content, ...content] }
-      else messages.push({ role: "user", content })
+      messages.push({ role: "user", content })
       continue
     }
 
@@ -395,10 +392,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
       const cachePoint = BedrockCache.block(breakpoints, part.cache)
       if (cachePoint) content.push(cachePoint)
     }
-    const previous = messages.at(-1)
-    if (previous?.role === "user")
-      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/test/fixtures/recordings/bedrock-converse/continues-after-parallel-tool-results.json

@@ -1,36 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:bedrock-converse",
-      "provider:amazon-bedrock",
-      "protocol:bedrock-converse",
-      "tool",
-      "tool-loop",
-      "parallel"
-    ],
-    "name": "bedrock-converse/continues-after-parallel-tool-results",
-    "recordedAt": "2026-08-11T16:41:46.482Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://bedrock-runtime.us-east-1.amazonaws.com/model/us.amazon.nova-micro-v1%3A0/converse-stream",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"modelId\":\"us.amazon.nova-micro-v1:0\",\"messages\":[{\"role\":\"user\",\"content\":[{\"text\":\"Compare the weather in Paris and London.\"}]},{\"role\":\"assistant\",\"content\":[{\"toolUse\":{\"toolUseId\":\"weather_paris\",\"name\":\"get_weather\",\"input\":{\"city\":\"Paris\"}}},{\"toolUse\":{\"toolUseId\":\"weather_london\",\"name\":\"get_weather\",\"input\":{\"city\":\"London\"}}}]},{\"role\":\"user\",\"content\":[{\"toolResult\":{\"toolUseId\":\"weather_paris\",\"content\":[{\"json\":{\"temperature\":22,\"condition\":\"sunny\"}}],\"status\":\"success\"}},{\"toolResult\":{\"toolUseId\":\"weather_london\",\"content\":[{\"json\":{\"temperature\":14,\"condition\":\"rainy\"}}],\"status\":\"success\"}}]}],\"system\":[{\"text\":\"After receiving both tool results, reply exactly: Paris is sunny; London is rainy.\"}],\"inferenceConfig\":{\"maxTokens\":40,\"temperature\":0},\"toolConfig\":{\"tools\":[{\"toolSpec\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"inputSchema\":{\"json\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}}}]}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "application/vnd.amazon.eventstream"
-        },
-        "body": "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",
-        "bodyEncoding": "base64"
-      }
-    }
-  ]
-}

packages/ai/test/provider/bedrock-converse.test.ts

@@ -255,57 +255,6 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
-  it.effect("merges parallel tool results into one user message", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          id: "req_parallel_history",
-          model,
-          messages: [
-            Message.user("Compare the weather."),
-            Message.assistant([
-              ToolCallPart.make({ id: "tool_paris", name: "lookup", input: { city: "Paris" } }),
-              ToolCallPart.make({ id: "tool_london", name: "lookup", input: { city: "London" } }),
-            ]),
-            Message.tool({ id: "tool_paris", name: "lookup", result: { forecast: "sunny" } }),
-            Message.tool({ id: "tool_london", name: "lookup", result: { forecast: "rainy" } }),
-          ],
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        { role: "user", content: [{ text: "Compare the weather." }] },
-        {
-          role: "assistant",
-          content: [
-            { toolUse: { toolUseId: "tool_paris", name: "lookup", input: { city: "Paris" } } },
-            { toolUse: { toolUseId: "tool_london", name: "lookup", input: { city: "London" } } },
-          ],
-        },
-        {
-          role: "user",
-          content: [
-            {
-              toolResult: {
-                toolUseId: "tool_paris",
-                content: [{ json: { forecast: "sunny" } }],
-                status: "success",
-              },
-            },
-            {
-              toolResult: {
-                toolUseId: "tool_london",
-                content: [{ json: { forecast: "rainy" } }],
-                status: "success",
-              },
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
   it.effect("lowers image content in tool-result messages", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
@@ -1216,39 +1165,4 @@ describe("Bedrock Converse recorded", () => {
       )
     }),
   )
-
-  recorded.effect.with("continues after parallel tool results", { tags: ["tool", "tool-loop", "parallel"] }, () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({
-          id: "recorded_bedrock_parallel_tool_results",
-          model: recordedModel(),
-          system: "After receiving both tool results, reply exactly: Paris is sunny; London is rainy.",
-          messages: [
-            Message.user("Compare the weather in Paris and London."),
-            Message.assistant([
-              ToolCallPart.make({ id: "weather_paris", name: weatherToolName, input: { city: "Paris" } }),
-              ToolCallPart.make({ id: "weather_london", name: weatherToolName, input: { city: "London" } }),
-            ]),
-            Message.tool({
-              id: "weather_paris",
-              name: weatherToolName,
-              result: { temperature: 22, condition: "sunny" },
-            }),
-            Message.tool({
-              id: "weather_london",
-              name: weatherToolName,
-              result: { temperature: 14, condition: "rainy" },
-            }),
-          ],
-          tools: [weatherTool],
-          cache: "none",
-          generation: { maxTokens: 40, temperature: 0 },
-        }),
-      )
-
-      expect(response.text.trim()).toBe("Paris is sunny; London is rainy.")
-      expect(response.finishReason?.normalized).toBe("stop")
-    }),
-  )
 })

packages/app/src/context/server-session-v2-reducer.test.ts

@@ -69,63 +69,6 @@ describe("v2 session reducer", () => {
     })
   })
 
-  test("prefers durable selection predecessors and derives them for older events", () => {
-    const source: SessionMessageInfo[] = [
-      { id: "msg_previous_agent", type: "agent-switched", agent: "build", time: { created: 1 } },
-      {
-        id: "msg_previous_model",
-        type: "model-switched",
-        model: { id: "old", providerID: "provider" },
-        time: { created: 1 },
-      },
-    ]
-    const reducer = createV2SessionReducer()
-
-    const agent = reducer.reduce(
-      source,
-      event({
-        ...base,
-        id: "evt_agent",
-        type: "session.agent.selected",
-        data: { sessionID: "ses_1", agent: "plan", previous: "review" },
-      }),
-    )
-    const model = reducer.reduce(
-      source,
-      event({
-        ...base,
-        id: "evt_model",
-        type: "session.model.selected",
-        data: {
-          sessionID: "ses_1",
-          model: { id: "new", providerID: "provider" },
-          previous: { id: "durable", providerID: "provider" },
-        },
-      }),
-    )
-    const legacyAgent = reducer.reduce(
-      source,
-      event({
-        ...base,
-        id: "evt_legacy_agent",
-        type: "session.agent.selected",
-        data: { sessionID: "ses_1", agent: "plan" },
-      }),
-    )
-
-    expect(agent?.messages.at(-1)).toMatchObject({ type: "agent-switched", agent: "plan", previous: "review" })
-    expect(model?.messages.at(-1)).toMatchObject({
-      type: "model-switched",
-      model: { id: "new" },
-      previous: { id: "durable" },
-    })
-    expect(legacyAgent?.messages.at(-1)).toMatchObject({
-      type: "agent-switched",
-      agent: "plan",
-      previous: "build",
-    })
-  })
-
   test("folds tool, retry, and completion events", () => {
     const reducer = createV2SessionReducer()
     let messages: SessionMessageInfo[] = []

packages/app/src/context/server-session-v2-reducer.ts

@@ -61,12 +61,6 @@ export function createV2SessionReducer() {
           type: "agent-switched",
           metadata: event.metadata,
           agent: event.data.agent,
-          previous:
-            event.data.previous ??
-            source.findLast(
-              (item): item is Extract<SessionMessageInfo, { type: "agent-switched" | "assistant" }> =>
-                item.type === "agent-switched" || item.type === "assistant",
-            )?.agent,
           time: { created: event.created },
         })
       case "session.model.selected":
@@ -75,12 +69,10 @@ export function createV2SessionReducer() {
           type: "model-switched",
           metadata: event.metadata,
           model: event.data.model,
-          previous:
-            event.data.previous ??
-            source.findLast(
-              (item): item is Extract<SessionMessageInfo, { type: "model-switched" | "assistant" }> =>
-                item.type === "model-switched" || item.type === "assistant",
-            )?.model,
+          previous: source.findLast(
+            (item): item is Extract<SessionMessageInfo, { type: "model-switched" | "assistant" }> =>
+              item.type === "model-switched" || item.type === "assistant",
+          )?.model,
           time: { created: event.created },
         })
       case "session.synthetic":

packages/cli/src/acp/service.ts

@@ -422,7 +422,8 @@ async function loadCatalog(client: OpenCodeClient, cwd: string): Promise<Catalog
         defaultModel: {
           providerID: defaultModel.providerID,
           id: defaultModel.id,
-          variant: defaultModel.variants.find((variant) => variant.id === "default")?.id,
+          variant:
+            defaultModel.variants.find((variant) => variant.id === "default")?.id ?? defaultModel.variants[0]?.id,
         },
         modes: agents.map((agent) => ({ id: agent.id, name: agent.name, description: agent.description })),
         defaultModeID: defaultAgent.id,

packages/cli/test/acp/service-lifecycle.test.ts

@@ -3,38 +3,6 @@ import type { SessionConfigOption } from "@agentclientprotocol/sdk"
 import { makeACPFixture, makeSession, secondModel } from "./service-fixture"
 
 describe("acp service lifecycle", () => {
-  test("does not persist the first catalog variant when no explicit default exists", async () => {
-    const model = { ...secondModel, variants: [{ id: "none" }, { id: "high" }] }
-    await using fixture = makeACPFixture({
-      models: [model],
-      defaultModel: model,
-      fetch(request) {
-        if (request.method === "POST" && request.path === "/api/session") {
-          return Response.json({
-            data: makeSession("ses_default_variant", {
-              model: { providerID: model.providerID, id: model.id },
-            }),
-          })
-        }
-        return undefined
-      },
-    })
-
-    const created = await fixture.service.newSession({ cwd: "/workspace", mcpServers: [] })
-
-    expect(fixture.requests).toContainEqual({
-      method: "POST",
-      path: "/api/session",
-      query: {},
-      body: {
-        location: { directory: "/workspace" },
-        agent: "build",
-        model: { providerID: "test", id: "second-model" },
-      },
-    })
-    expect(currentValue(created, "effort")).toBe("none")
-  })
-
   test("loads and forks with paginated replay while resume does not replay", async () => {
     await using fixture = makeACPFixture({
       fetch(request) {

packages/client/src/effect/api/api.ts

@@ -339,11 +339,7 @@ export type Endpoint5_31Output =
           readonly type: "session.agent.selected"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
           readonly location?: Location.Ref | undefined
-          readonly data: {
-            readonly sessionID: Session.ID
-            readonly agent: Agent.ID
-            readonly previous?: Agent.ID | undefined
-          }
+          readonly data: { readonly sessionID: Session.ID; readonly agent: Agent.ID }
         }
       | {
           readonly id: Event.ID
@@ -352,11 +348,7 @@ export type Endpoint5_31Output =
           readonly type: "session.model.selected"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
           readonly location?: Location.Ref | undefined
-          readonly data: {
-            readonly sessionID: Session.ID
-            readonly model: Model.Ref
-            readonly previous?: Model.Ref | undefined
-          }
+          readonly data: { readonly sessionID: Session.ID; readonly model: Model.Ref }
         }
       | {
           readonly id: Event.ID

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

@@ -436,7 +436,7 @@ export type SessionAgentSelected = {
   type: "session.agent.selected"
   durable: { aggregateID: string; seq: number; version: 1 }
   location?: LocationRef
-  data: { sessionID: string; agent: string; previous?: string }
+  data: { sessionID: string; agent: string }
 }
 
 export type SessionModelSelected = {
@@ -446,7 +446,7 @@ export type SessionModelSelected = {
   type: "session.model.selected"
   durable: { aggregateID: string; seq: number; version: 1 }
   location?: LocationRef
-  data: { sessionID: string; model: ModelRef; previous?: ModelRef }
+  data: { sessionID: string; model: ModelRef }
 }
 
 export type SessionMoved = {

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

@@ -4,7 +4,7 @@ import { Directory, Document, type Entry } from "@opencode-ai/schema/config"
 import { ConfigPlugin } from "@opencode-ai/schema/config/plugin"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Effect, Layer, Option, Predicate, PubSub, Schema, Scope, Stream } from "effect"
+import { Context, Effect, Layer, Option, PubSub, Scope, Stream } from "effect"
 import path from "path"
 import { fileURLToPath } from "url"
 import { Config } from "../../config"
@@ -154,67 +154,19 @@ const scan = Effect.fn("ConfigPluginSource.scan")(function* (
 })
 
 const sourceDirectories = ["plugin", "plugins"] as const
-const Package = Schema.Struct({
-  exports: Schema.optional(Schema.Unknown),
-  module: Schema.optional(Schema.Unknown),
-  main: Schema.optional(Schema.Unknown),
-})
-const decodePackage = Schema.decodeUnknownOption(Package)
 
 function discoverDirectory(fs: FSUtil.Interface, directory: string) {
   return Effect.gen(function* () {
-    const children = (yield* Effect.forEach(sourceDirectories, (source) =>
-      fs.readDirectoryEntries(path.join(directory, source)).pipe(
-        Effect.orElseSucceed(() => []),
-        Effect.map((entries) =>
-          entries.map((entry) => ({ ...entry, target: path.join(directory, source, entry.name) })),
-        ),
-      ),
-    ))
-      .flat()
-      .sort((a, b) => (a.target < b.target ? -1 : a.target > b.target ? 1 : 0))
-    const targets = yield* Effect.forEach(children, (entry) => discoverChild(fs, entry))
-    return targets.flatMap(Option.toArray).map((target): Operation => ({ type: "add", target, options: {} }))
-  })
-}
-
-function discoverChild(fs: FSUtil.Interface, entry: FSUtil.DirEntry & { target: string }) {
-  return Effect.gen(function* () {
-    const source = entry.target.endsWith(".ts") || entry.target.endsWith(".js")
-    if (entry.type === "file" && source) return Option.some(entry.target)
-    if (entry.type === "directory") return yield* discoverPackage(fs, entry.target)
-    if (entry.type !== "symlink") return Option.none<string>()
-    if (source && (yield* fs.isFile(entry.target))) return Option.some(entry.target)
-    if (yield* fs.isDir(entry.target)) return yield* discoverPackage(fs, entry.target)
-    return Option.none<string>()
-  })
-}
-
-function discoverPackage(fs: FSUtil.Interface, directory: string) {
-  return Effect.gen(function* () {
-    const root = yield* fs.resolve(directory)
-    const manifest = yield* fs
-      .readJson(path.join(directory, "package.json"))
-      .pipe(Effect.map(decodePackage), Effect.orElseSucceed(Option.none))
-    const configured = Option.isSome(manifest)
-      ? [manifest.value.exports, manifest.value.module, manifest.value.main].filter(Predicate.isString)
-      : []
-    return yield* Effect.findFirst(
-      [...configured, "index.ts", "index.js"]
-        .filter((entry) => !path.isAbsolute(entry))
-        .map((entry) => path.resolve(directory, entry))
-        .filter((entry) => FSUtil.contains(directory, entry)),
-      (entry) =>
-        fs
-          .isFile(entry)
-          .pipe(
-            Effect.flatMap((exists) =>
-              exists
-                ? fs.resolve(entry).pipe(Effect.map((resolved) => FSUtil.contains(root, resolved)))
-                : Effect.succeed(false),
-            ),
-          ),
-    )
+    const files = yield* fs
+      .scan(`{${sourceDirectories.join(",")}}/*.{ts,js}`, {
+        cwd: directory,
+        absolute: true,
+        include: "file",
+        dot: true,
+        symlink: true,
+      })
+      .pipe(Effect.orElseSucceed(() => []))
+    return files.sort().map((target): Operation => ({ type: "add", target, options: {} }))
   })
 }
 

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

@@ -1,32 +1,58 @@
-import { Database, type SQLQueryBindings } from "bun:sqlite"
+import { Database } from "bun:sqlite"
 import { drizzle } from "drizzle-orm/bun-sqlite"
-import { Context, Effect, Layer } from "effect"
+import { Context, Effect, Fiber, Layer, Scope, Semaphore, Stream } from "effect"
+import { identity } from "effect/Function"
 import { Reactivity } from "effect/unstable/reactivity"
-import { SqlClient } from "effect/unstable/sql"
+import { SqlClient, Statement } from "effect/unstable/sql"
+import type { Connection } from "effect/unstable/sql/SqlConnection"
 import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError"
 import { Sqlite } from "./sqlite"
 
-const TypeId = "~@opencode-ai/core/database/SqliteBun" as const
+const ATTR_DB_SYSTEM_NAME = "db.system.name"
 
-interface Config extends Sqlite.ClientConfig {
+const TypeId = "~@opencode-ai/core/database/SqliteBun" as const
+type TypeId = typeof TypeId
+
+interface SqliteClient extends SqlClient.SqlClient {
+  readonly [TypeId]: TypeId
+  readonly config: Config
+  readonly export: Effect.Effect<Uint8Array, SqlError>
+  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
+  readonly updateValues: never
+}
+
+interface Config {
   readonly filename: string
   readonly readonly?: boolean
   readonly create?: boolean
   readonly readwrite?: boolean
   readonly disableWAL?: boolean
+  readonly spanAttributes?: Record<string, unknown>
+  readonly transformResultNames?: (str: string) => string
+  readonly transformQueryNames?: (str: string) => string
+}
+
+interface SqliteConnection extends Connection {
+  readonly export: Effect.Effect<Uint8Array, SqlError>
+  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
 }
 
 const make = (options: Config) =>
   Effect.gen(function* () {
     const native = (yield* Sqlite.Native) as Database
 
+    const compiler = Statement.makeCompilerSqlite(options.transformQueryNames)
+    const transformRows = options.transformResultNames
+      ? Statement.defaultTransforms(options.transformResultNames).array
+      : undefined
+
     const run = (query: string, params: ReadonlyArray<unknown> = []) =>
       Effect.withFiber<Array<Record<string, unknown>>, SqlError>((fiber) => {
-        const statement = native.query<Record<string, unknown>, SQLQueryBindings[]>(query)
+        const statement = native.query(query)
         // @ts-ignore bun-types missing safeIntegers method, fixed in https://github.com/oven-sh/bun/pull/26627
         statement.safeIntegers(Context.get(fiber.context, SqlClient.SafeIntegers))
         try {
-          return Effect.succeed(statement.all(...(params as SQLQueryBindings[])) ?? [])
+          return Effect.succeed((statement.all(...(params as any)) ?? []) as Array<Record<string, unknown>>)
         } catch (cause) {
           return Effect.fail(
             new SqlError({
@@ -38,11 +64,11 @@ const make = (options: Config) =>
 
     const runValues = (query: string, params: ReadonlyArray<unknown> = []) =>
       Effect.withFiber<Array<unknown[]>, SqlError>((fiber) => {
-        const statement = native.query<unknown, SQLQueryBindings[]>(query)
+        const statement = native.query(query)
         // @ts-ignore bun-types missing safeIntegers method, fixed in https://github.com/oven-sh/bun/pull/26627
         statement.safeIntegers(Context.get(fiber.context, SqlClient.SafeIntegers))
         try {
-          return Effect.succeed(statement.values(...(params as SQLQueryBindings[])) ?? [])
+          return Effect.succeed((statement.values(...(params as any)) ?? []) as Array<unknown[]>)
         } catch (cause) {
           return Effect.fail(
             new SqlError({
@@ -52,7 +78,25 @@ const make = (options: Config) =>
         }
       })
 
-    const connection = Sqlite.makeConnection(run, runValues, {
+    const connection = identity<SqliteConnection>({
+      execute(query, params, transformRows) {
+        return transformRows ? Effect.map(run(query, params), transformRows) : run(query, params)
+      },
+      executeRaw(query, params) {
+        return run(query, params)
+      },
+      executeValues(query, params) {
+        return runValues(query, params)
+      },
+      executeValuesUnprepared(query, params) {
+        return runValues(query, params)
+      },
+      executeUnprepared(query, params, transformRows) {
+        return this.execute(query, params, transformRows)
+      },
+      executeStream() {
+        return Stream.die("executeStream not implemented")
+      },
       export: Effect.try({
         try: () => native.serialize(),
         catch: (cause) =>
@@ -60,7 +104,7 @@ const make = (options: Config) =>
             reason: classifySqliteError(cause, { message: "Failed to export database", operation: "export" }),
           }),
       }),
-      loadExtension: (path: string) =>
+      loadExtension: (path) =>
         Effect.try({
           try: () => native.loadExtension(path),
           catch: (cause) =>
@@ -70,10 +114,37 @@ const make = (options: Config) =>
         }),
     })
 
-    return yield* Sqlite.makeClient(options, connection, TypeId, (acquirer) => ({
-      export: Effect.flatMap(acquirer, (_) => _.export),
-      loadExtension: (path: string) => Effect.flatMap(acquirer, (_) => _.loadExtension(path)),
-    }))
+    const semaphore = yield* Semaphore.make(1)
+    const acquirer = semaphore.withPermits(1)(Effect.succeed(connection))
+    const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
+      const fiber = Fiber.getCurrent()!
+      const scope = Context.getUnsafe(fiber.context, Scope.Scope)
+      return Effect.as(
+        Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))),
+        connection,
+      )
+    })
+
+    const client = Object.assign(
+      (yield* SqlClient.make({
+        acquirer,
+        compiler,
+        transactionAcquirer,
+        spanAttributes: [
+          ...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
+          [ATTR_DB_SYSTEM_NAME, "sqlite"],
+        ],
+        transformRows,
+      })) as SqliteClient,
+      {
+        [TypeId]: TypeId,
+        config: options,
+        export: Effect.flatMap(acquirer, (_) => _.export),
+        loadExtension: (path: string) => Effect.flatMap(acquirer, (_) => _.loadExtension(path)),
+      },
+    )
+
+    return client
   })
 
 const nativeLayer = (config: Config) =>

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

@@ -1,14 +1,26 @@
 import { DatabaseSync, type SQLInputValue } from "node:sqlite"
 import { drizzle } from "drizzle-orm/node-sqlite"
-import { Context, Effect, Layer } from "effect"
+import { Context, Effect, Fiber, Layer, Scope, Semaphore, Stream } from "effect"
+import { identity } from "effect/Function"
 import { Reactivity } from "effect/unstable/reactivity"
-import { SqlClient } from "effect/unstable/sql"
+import { SqlClient, Statement } from "effect/unstable/sql"
+import type { Connection } from "effect/unstable/sql/SqlConnection"
 import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError"
 import { Sqlite } from "./sqlite"
 
-const TypeId = "~@opencode-ai/core/database/SqliteNode" as const
+const ATTR_DB_SYSTEM_NAME = "db.system.name"
 
-interface Config extends Sqlite.ClientConfig {
+const TypeId = "~@opencode-ai/core/database/SqliteNode" as const
+type TypeId = typeof TypeId
+
+interface SqliteClient extends SqlClient.SqlClient {
+  readonly [TypeId]: TypeId
+  readonly config: Config
+  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
+  readonly updateValues: never
+}
+
+interface Config {
   readonly filename: string
   readonly readonly?: boolean
   readonly create?: boolean
@@ -16,12 +28,24 @@ interface Config extends Sqlite.ClientConfig {
   readonly disableWAL?: boolean
   readonly timeout?: number
   readonly allowExtension?: boolean
+  readonly spanAttributes?: Record<string, unknown>
+  readonly transformResultNames?: (str: string) => string
+  readonly transformQueryNames?: (str: string) => string
+}
+
+interface SqliteConnection extends Connection {
+  readonly loadExtension: (path: string) => Effect.Effect<void, SqlError>
 }
 
 const make = (options: Config) =>
   Effect.gen(function* () {
     const native = (yield* Sqlite.Native) as DatabaseSync
 
+    const compiler = Statement.makeCompilerSqlite(options.transformQueryNames)
+    const transformRows = options.transformResultNames
+      ? Statement.defaultTransforms(options.transformResultNames).array
+      : undefined
+
     const run = (query: string, params: ReadonlyArray<unknown> = []) =>
       Effect.withFiber<Array<Record<string, unknown>>, SqlError>((fiber) => {
         const statement = native.prepare(query)
@@ -55,8 +79,26 @@ const make = (options: Config) =>
         }
       })
 
-    const connection = Sqlite.makeConnection(run, runValues, {
-      loadExtension: (path: string) =>
+    const connection = identity<SqliteConnection>({
+      execute(query, params, transformRows) {
+        return transformRows ? Effect.map(run(query, params), transformRows) : run(query, params)
+      },
+      executeRaw(query, params) {
+        return run(query, params)
+      },
+      executeValues(query, params) {
+        return runValues(query, params)
+      },
+      executeValuesUnprepared(query, params) {
+        return runValues(query, params)
+      },
+      executeUnprepared(query, params, transformRows) {
+        return this.execute(query, params, transformRows)
+      },
+      executeStream() {
+        return Stream.die("executeStream not implemented")
+      },
+      loadExtension: (path) =>
         Effect.try({
           try: () => native.loadExtension(path),
           catch: (cause) =>
@@ -66,9 +108,36 @@ const make = (options: Config) =>
         }),
     })
 
-    return yield* Sqlite.makeClient(options, connection, TypeId, (acquirer) => ({
-      loadExtension: (path: string) => Effect.flatMap(acquirer, (_) => _.loadExtension(path)),
-    }))
+    const semaphore = yield* Semaphore.make(1)
+    const acquirer = semaphore.withPermits(1)(Effect.succeed(connection))
+    const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
+      const fiber = Fiber.getCurrent()!
+      const scope = Context.getUnsafe(fiber.context, Scope.Scope)
+      return Effect.as(
+        Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))),
+        connection,
+      )
+    })
+
+    const client = Object.assign(
+      (yield* SqlClient.make({
+        acquirer,
+        compiler,
+        transactionAcquirer,
+        spanAttributes: [
+          ...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
+          [ATTR_DB_SYSTEM_NAME, "sqlite"],
+        ],
+        transformRows,
+      })) as SqliteClient,
+      {
+        [TypeId]: TypeId,
+        config: options,
+        loadExtension: (path: string) => Effect.flatMap(acquirer, (_) => _.loadExtension(path)),
+      },
+    )
+
+    return client
   })
 
 const nativeLayer = (config: Config) =>

packages/core/src/database/sqlite.ts

@@ -1,100 +1,8 @@
 export * as Sqlite from "./sqlite"
 
-import { Context, Effect, Fiber, Scope, Semaphore, Stream } from "effect"
-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 { Context } from "effect"
 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>
-  readonly transformResultNames?: (str: string) => string
-  readonly transformQueryNames?: (str: string) => string
-}
-
-type Run = (
-  query: string,
-  params?: ReadonlyArray<unknown>,
-) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, SqlError>
-
-type RunValues = (
-  query: string,
-  params?: ReadonlyArray<unknown>,
-) => Effect.Effect<ReadonlyArray<ReadonlyArray<unknown>>, SqlError>
-
-export const makeConnection = <Extensions extends object>(run: Run, runValues: RunValues, extensions: Extensions) =>
-  identity<Connection & Extensions>({
-    execute(query, params, transformRows) {
-      return transformRows ? Effect.map(run(query, params), transformRows) : run(query, params)
-    },
-    executeRaw(query, params) {
-      return run(query, params)
-    },
-    executeValues(query, params) {
-      return runValues(query, params)
-    },
-    executeValuesUnprepared(query, params) {
-      return runValues(query, params)
-    },
-    executeUnprepared(query, params, transformRows) {
-      return this.execute(query, params, transformRows)
-    },
-    executeStream() {
-      return Stream.die("executeStream not implemented")
-    },
-    ...extensions,
-  })
-
-export const makeClient = <
-  Config extends ClientConfig,
-  SqliteConnection extends Connection,
-  const TypeId extends string,
-  Extensions extends object,
->(
-  options: Config,
-  connection: SqliteConnection,
-  typeId: TypeId,
-  extensions: (acquirer: Effect.Effect<SqliteConnection, SqlError, Scope.Scope>) => Extensions,
-) =>
-  Effect.gen(function* () {
-    const semaphore = yield* Semaphore.make(1)
-    const acquirer = semaphore.withPermits(1)(Effect.succeed(connection))
-    const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
-      const fiber = Fiber.getCurrent()!
-      const scope = Context.getUnsafe(fiber.context, Scope.Scope)
-      return Effect.as(
-        Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))),
-        connection,
-      )
-    })
-    const transformRows = options.transformResultNames
-      ? Statement.defaultTransforms(options.transformResultNames).array
-      : undefined
-
-    return Object.assign(
-      yield* SqlClient.make({
-        acquirer,
-        compiler: Statement.makeCompilerSqlite(options.transformQueryNames),
-        transactionAcquirer,
-        spanAttributes: [
-          ...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
-          ["db.system.name", "sqlite"],
-        ],
-        transformRows,
-      }),
-      {
-        [typeId]: typeId,
-        config: options,
-        ...extensions(acquirer),
-      },
-    ) as SqlClient.SqlClient &
-      Record<TypeId, TypeId> & {
-        readonly config: Config
-        readonly updateValues: never
-      } & Extensions
-  })

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

@@ -7,7 +7,7 @@ import { SessionV1 } from "@opencode-ai/schema/session-v1"
 import { SessionMessage } from "../session/message"
 import { SessionSchema } from "../session/schema"
 import { KVTable } from "../kv/sql"
-import { EventSequenceTable } from "../event/sql"
+import { EventSequenceTable, EventTable } from "../event/sql"
 import { eq, sql } from "drizzle-orm"
 import { Global } from "@opencode-ai/util/global"
 import { existsSync } from "node:fs"
@@ -161,7 +161,6 @@ type NextMessage = {
 
 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)
@@ -486,15 +485,7 @@ export function run(options: Options = {}): Effect.Effect<RunResult, never, Data
           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.delete(EventTable).run()
                 yield* tx
                   .insert(KVTable)
                   .values({ key: MIGRATION_STATE_KEY, value: { phase: "sessions" } })

packages/core/src/plugin/internal.ts

@@ -17,7 +17,6 @@ import { ConfigProviderPlugin } from "../config/plugin/provider"
 import { ConfigPolicyPlugin } from "../config/plugin/policy"
 import { ConfigReferencePlugin } from "../config/plugin/reference"
 import { ConfigSkillPlugin } from "../config/plugin/skill"
-import { ConfigPluginSource } from "../config/plugin/source"
 import { ConfigWebSearchPlugin } from "../config/plugin/websearch"
 import { Bus } from "../bus"
 import { Environment } from "../environment"
@@ -77,7 +76,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
   const command = yield* Command.Service
   const config = yield* Config.Service
   const credential = yield* Credential.Service
-  const pluginSources = yield* ConfigPluginSource.Service
   const bus = yield* Bus.Service
   const environment = yield* Environment.Service
   const mutation = yield* FileMutation.Service
@@ -114,7 +112,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
     Context.make(Command.Service, command),
     Context.make(Config.Service, config),
     Context.make(Credential.Service, credential),
-    Context.make(ConfigPluginSource.Service, pluginSources),
     Context.make(Bus.Service, bus),
     Context.make(Environment.Service, environment),
     Context.make(FileMutation.Service, mutation),
@@ -158,7 +155,6 @@ export const requirements = LayerNode.group([
   Command.node,
   Config.node,
   Credential.node,
-  ConfigPluginSource.node,
   Bus.node,
   Environment.node,
   FileMutation.node,

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

@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"
 
-export const AlibabaPlugin = createProviderPlugin({
+export const AlibabaPlugin = define({
   id: "opencode.provider.alibaba",
-  package: "@ai-sdk/alibaba",
-  load: async (options) => {
-    const { createAlibaba } = await import("@ai-sdk/alibaba")
-    return createAlibaba(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/alibaba") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/alibaba"))
+        evt.sdk = mod.createAlibaba(evt.options)
+      }),
+    )
+  }),
 })

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

@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"
 
-export const CoherePlugin = createProviderPlugin({
+export const CoherePlugin = define({
   id: "opencode.provider.cohere",
-  package: "@ai-sdk/cohere",
-  load: async (options) => {
-    const { createCohere } = await import("@ai-sdk/cohere")
-    return createCohere(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/cohere") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/cohere"))
+        evt.sdk = mod.createCohere(evt.options)
+      }),
+    )
+  }),
 })

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

@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"
 
-export const DeepInfraPlugin = createProviderPlugin({
+export const DeepInfraPlugin = define({
   id: "opencode.provider.deepinfra",
-  package: "@ai-sdk/deepinfra",
-  load: async (options) => {
-    const { createDeepInfra } = await import("@ai-sdk/deepinfra")
-    return createDeepInfra(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/deepinfra") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/deepinfra"))
+        evt.sdk = mod.createDeepInfra(evt.options)
+      }),
+    )
+  }),
 })

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

@@ -1,22 +0,0 @@
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import type { AISDKHooks } from "@opencode-ai/plugin/effect/aisdk"
-import { Effect } from "effect"
-
-export function createProviderPlugin(input: {
-  readonly id: string
-  readonly package: string
-  readonly load: (options: AISDKHooks["sdk"]["options"]) => Promise<unknown>
-}) {
-  return define({
-    id: input.id,
-    effect: Effect.fn(function* (ctx) {
-      yield* ctx.aisdk.hook(
-        "sdk",
-        Effect.fn(function* (evt) {
-          if (evt.package !== input.package) return
-          evt.sdk = yield* Effect.promise(() => input.load(evt.options))
-        }),
-      )
-    }),
-  })
-}

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

@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"
 
-export const GatewayPlugin = createProviderPlugin({
+export const GatewayPlugin = define({
   id: "opencode.provider.gateway",
-  package: "@ai-sdk/gateway",
-  load: async (options) => {
-    const { createGateway } = await import("@ai-sdk/gateway")
-    return createGateway(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/gateway") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/gateway"))
+        evt.sdk = mod.createGateway(evt.options)
+      }),
+    )
+  }),
 })

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

@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"
 
-export const GroqPlugin = createProviderPlugin({
+export const GroqPlugin = define({
   id: "opencode.provider.groq",
-  package: "@ai-sdk/groq",
-  load: async (options) => {
-    const { createGroq } = await import("@ai-sdk/groq")
-    return createGroq(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/groq") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/groq"))
+        evt.sdk = mod.createGroq(evt.options)
+      }),
+    )
+  }),
 })

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

@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"
 
-export const MistralPlugin = createProviderPlugin({
+export const MistralPlugin = define({
   id: "opencode.provider.mistral",
-  package: "@ai-sdk/mistral",
-  load: async (options) => {
-    const { createMistral } = await import("@ai-sdk/mistral")
-    return createMistral(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/mistral") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/mistral"))
+        evt.sdk = mod.createMistral(evt.options)
+      }),
+    )
+  }),
 })

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

@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"
 
-export const PerplexityPlugin = createProviderPlugin({
+export const PerplexityPlugin = define({
   id: "opencode.provider.perplexity",
-  package: "@ai-sdk/perplexity",
-  load: async (options) => {
-    const { createPerplexity } = await import("@ai-sdk/perplexity")
-    return createPerplexity(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/perplexity") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/perplexity"))
+        evt.sdk = mod.createPerplexity(evt.options)
+      }),
+    )
+  }),
 })

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

@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"
 
-export const TogetherAIPlugin = createProviderPlugin({
+export const TogetherAIPlugin = define({
   id: "opencode.provider.togetherai",
-  package: "@ai-sdk/togetherai",
-  load: async (options) => {
-    const { createTogetherAI } = await import("@ai-sdk/togetherai")
-    return createTogetherAI(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "@ai-sdk/togetherai") return
+        const mod = yield* Effect.promise(() => import("@ai-sdk/togetherai"))
+        evt.sdk = mod.createTogetherAI(evt.options)
+      }),
+    )
+  }),
 })

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

@@ -1,10 +1,16 @@
-import { createProviderPlugin } from "./factory"
+import { Effect } from "effect"
+import { define } from "@opencode-ai/plugin/effect/plugin"
 
-export const VenicePlugin = createProviderPlugin({
+export const VenicePlugin = define({
   id: "opencode.provider.venice",
-  package: "venice-ai-sdk-provider",
-  load: async (options) => {
-    const { createVenice } = await import("venice-ai-sdk-provider")
-    return createVenice(options)
-  },
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook(
+      "sdk",
+      Effect.fn(function* (evt) {
+        if (evt.package !== "venice-ai-sdk-provider") return
+        const mod = yield* Effect.promise(() => import("venice-ai-sdk-provider"))
+        evt.sdk = mod.createVenice(evt.options)
+      }),
+    )
+  }),
 })

packages/core/src/plugin/skill.ts

@@ -6,8 +6,12 @@ import { define, type Context } from "@opencode-ai/plugin/effect/plugin"
 import { Effect } from "effect"
 import { AbsolutePath } from "../schema"
 import { Skill } from "../skill"
-import { ConfigPluginSource } from "../config/plugin/source"
+import { Config } from "../config"
+import { Location } from "../location"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import os from "os"
+import path from "path"
+import { fileURLToPath } from "url"
 import opencodeContent from "./skill/opencode.md" with { type: "text" }
 import reportContent from "./skill/report.md" with { type: "text" }
 
@@ -68,10 +72,32 @@ const reportContentWithDiagnostics = Effect.fn("SkillPlugin.reportContentWithDia
 })
 
 const configuredPlugins = Effect.fn("SkillPlugin.configuredPlugins")(function* () {
-  const sources = yield* ConfigPluginSource.Service
-  return (yield* sources.operations())
-    .map((operation) => (operation.type === "remove" ? `-${operation.target}` : operation.target))
-    .toSorted()
+  const config = yield* Config.Service
+  const fs = yield* FSUtil.Service
+  const location = yield* Location.Service
+  return yield* Effect.forEach(yield* config.entries(), (entry) => {
+    if (entry.type === "document") {
+      const directory = entry.path ? path.dirname(entry.path) : location.directory
+      return Effect.succeed(
+        (entry.info.plugins ?? []).map((item) => {
+          const ref = typeof item === "string" ? { package: item } : item
+          if (ref.package.startsWith("file://")) return fileURLToPath(ref.package)
+          if (ref.package.startsWith("./") || ref.package.startsWith("../")) return path.resolve(directory, ref.package)
+          return ref.package
+        }),
+      )
+    }
+    if (entry.type !== "directory") return Effect.succeed([])
+    return fs
+      .scan("{plugin,plugins}/*.{ts,js}", {
+        cwd: entry.path,
+        absolute: true,
+        include: "file",
+        dot: true,
+        symlink: true,
+      })
+      .pipe(Effect.orElseSucceed(() => []))
+  }).pipe(Effect.map((items) => items.flat().toSorted()))
 })
 
 function terminal() {

packages/core/src/project.ts

@@ -2,7 +2,7 @@ export * as Project from "./project"
 
 import { Context, Effect, Layer, Schema } from "effect"
 import { ChildProcess } from "effect/unstable/process"
-import { asc, desc } from "drizzle-orm"
+import { asc, desc, isNotNull, isNull, ne, or } from "drizzle-orm"
 import path from "path"
 import { AbsolutePath } from "./schema"
 import { Database } from "./database/database"
@@ -13,7 +13,7 @@ import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { Hash } from "@opencode-ai/util/hash"
 import { ProjectDirectories } from "./project/directories"
 import { ProjectSchema } from "./project/schema"
-import { ProjectTable, upsertProject } from "./project/sql"
+import { ProjectTable } from "./project/sql"
 
 export const ID = ProjectSchema.ID
 export type ID = ProjectSchema.ID
@@ -98,7 +98,19 @@ const layer = Layer.effect(
       yield* db
         .transaction((tx) =>
           Effect.gen(function* () {
-            yield* upsertProject(tx, project)
+            const vcs = project.vcs?.type
+            yield* tx
+              .insert(ProjectTable)
+              .values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] })
+              .onConflictDoUpdate({
+                target: ProjectTable.id,
+                set: { worktree: project.canonical, vcs: vcs ?? null },
+                setWhere: or(
+                  ne(ProjectTable.worktree, project.canonical),
+                  vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs),
+                ),
+              })
+              .run()
             if (!project.vcs) return
             yield* projectDirectories.create({ projectID: project.id, directory: project.canonical }, tx)
             if (project.directory === project.canonical) return

packages/core/src/project/sql.ts

@@ -1,14 +1,8 @@
-import type { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
-import { isNotNull, isNull, ne, or } from "drizzle-orm"
 import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core"
 import { absoluteArrayColumn, absoluteColumn } from "../database/path"
 import { Timestamps } from "../database/schema.sql"
-import type { AbsolutePath } from "../schema"
 import { ProjectSchema } from "./schema"
 
-type DatabaseClient = EffectDrizzleSqlite.EffectSQLiteDatabase
-type Transaction = Parameters<Parameters<DatabaseClient["transaction"]>[0]>[0]
-
 export const ProjectTable = sqliteTable("project", {
   id: text().$type<ProjectSchema.ID>().primaryKey(),
   worktree: absoluteColumn().notNull(),
@@ -39,22 +33,3 @@ export const ProjectDirectoryTable = sqliteTable(
   },
   (table) => [primaryKey({ columns: [table.project_id, table.directory] })],
 )
-
-export function upsertProject(
-  db: DatabaseClient | Transaction,
-  project: { readonly id: ProjectSchema.ID; readonly canonical: AbsolutePath; readonly vcs?: ProjectSchema.Vcs },
-) {
-  const vcs = project.vcs?.type
-  return db
-    .insert(ProjectTable)
-    .values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] })
-    .onConflictDoUpdate({
-      target: ProjectTable.id,
-      set: { worktree: project.canonical, vcs: vcs ?? null },
-      setWhere: or(
-        ne(ProjectTable.worktree, project.canonical),
-        vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs),
-      ),
-    })
-    .run()
-}

packages/core/src/session.ts

@@ -3,7 +3,7 @@ export * from "./session/schema"
 
 import { Effect, Layer, Schema, Context, Stream, Scope } from "effect"
 import { ListAnchor } from "@opencode-ai/schema/session"
-import { and, asc, desc, eq, gt, isNull, like, lt, or, type SQL } from "drizzle-orm"
+import { and, asc, desc, eq, gt, isNotNull, isNull, like, lt, ne, or, type SQL } from "drizzle-orm"
 import { Project } from "./project"
 import { Workspace } from "./workspace"
 import { Model } from "./model"
@@ -21,7 +21,7 @@ import { Agent } from "./agent"
 import { Money } from "@opencode-ai/schema/money"
 import { App } from "./app"
 import { Slug } from "./util/slug"
-import { upsertProject } from "./project/sql"
+import { ProjectTable } from "./project/sql"
 import path from "path"
 import { fromRow } from "./session/info"
 import { SessionRunner } from "./session/runner/index"
@@ -309,7 +309,22 @@ const layer = Layer.effect(
     const shellLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
     const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Info)
     const isDurableSessionEvent = Schema.is(SessionEvent.Durable)
-    const persistProject = (project: Project.Resolved) => upsertProject(db, project).pipe(Effect.orDie)
+    const persistProject = (project: Project.Resolved) => {
+      const vcs = project.vcs?.type
+      return db
+        .insert(ProjectTable)
+        .values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] })
+        .onConflictDoUpdate({
+          target: ProjectTable.id,
+          set: { worktree: project.canonical, vcs: vcs ?? null },
+          setWhere: or(
+            ne(ProjectTable.worktree, project.canonical),
+            vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs),
+          ),
+        })
+        .run()
+        .pipe(Effect.orDie)
+    }
     const decode = (row: typeof SessionMessageTable.$inferSelect) =>
       decodeMessage({ ...row.data, id: row.id, type: row.type }).pipe(
         Effect.mapError(
@@ -701,11 +716,10 @@ const layer = Layer.effect(
             .pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid)
       }),
       switchAgent: Effect.fn("Session.switchAgent")(function* (input) {
-        const session = yield* result.get(input.sessionID)
+        yield* result.get(input.sessionID)
         yield* bus.publish(SessionEvent.AgentSelected, {
           sessionID: input.sessionID,
           agent: input.agent,
-          previous: session.agent,
         })
       }),
       switchModel: Effect.fn("Session.switchModel")(function* (input) {
@@ -719,7 +733,6 @@ const layer = Layer.effect(
         yield* bus.publish(SessionEvent.ModelSelected, {
           sessionID: input.sessionID,
           model: input.model,
-          previous: session.model,
         })
       }),
       rename: Effect.fn("Session.rename")(function* (input) {

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

@@ -61,7 +61,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       "session.usage.recorded": () => Effect.void,
       "session.agent.selected": (event) => {
         return Effect.gen(function* () {
-          const previous = event.data.previous ?? (yield* adapter.getAgent())
+          const previous = yield* adapter.getAgent()
           yield* adapter.appendMessage(
             SessionMessage.AgentSelected.make({
               id: SessionMessage.ID.fromEvent(event.id),
@@ -76,7 +76,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       },
       "session.model.selected": (event) => {
         return Effect.gen(function* () {
-          const previous = event.data.previous ?? (yield* adapter.getModel())
+          const previous = yield* adapter.getModel()
           yield* adapter.appendMessage(
             SessionMessage.ModelSelected.make({
               id: SessionMessage.ID.fromEvent(event.id),

packages/core/src/session/transfer.ts

@@ -3,7 +3,7 @@ export * as SessionTransfer from "./transfer"
 import { SessionTransfer } from "@opencode-ai/schema/session-transfer"
 import { Tool } from "@opencode-ai/schema/tool"
 import { Skill } from "@opencode-ai/schema/skill"
-import { eq } from "drizzle-orm"
+import { eq, isNotNull, isNull, ne, or } from "drizzle-orm"
 import { Context, DateTime, Effect, Layer, Schema } from "effect"
 import path from "path"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
@@ -12,7 +12,7 @@ import { Bus } from "../bus"
 import { Database } from "../database/database"
 import { Location } from "../location"
 import { Project } from "../project"
-import { upsertProject } from "../project/sql"
+import { ProjectTable } from "../project/sql"
 import { AbsolutePath, RelativePath } from "../schema"
 import { Session } from "../session"
 import { Slug } from "../util/slug"
@@ -49,7 +49,22 @@ const layer = Layer.effect(
     const sessions = yield* Session.Service
     const encodeMessage = Schema.encodeSync(SessionMessage.Info)
 
-    const persistProject = (project: Project.Resolved) => upsertProject(db, project).pipe(Effect.orDie)
+    const persistProject = (project: Project.Resolved) => {
+      const vcs = project.vcs?.type
+      return db
+        .insert(ProjectTable)
+        .values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] })
+        .onConflictDoUpdate({
+          target: ProjectTable.id,
+          set: { worktree: project.canonical, vcs: vcs ?? null },
+          setWhere: or(
+            ne(ProjectTable.worktree, project.canonical),
+            vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs),
+          ),
+        })
+        .run()
+        .pipe(Effect.orDie)
+    }
 
     return Service.of({
       export: Effect.fn("SessionTransfer.export")(function* (input) {

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

@@ -21,7 +21,7 @@ Usage notes:
 - If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label`
 
 export const Input = Schema.Struct({
-  questions: Schema.Array(Question.Prompt).check(Schema.isNonEmpty()).annotate({ description: "Questions to ask" }),
+  questions: Schema.NonEmptyArray(Question.Prompt).annotate({ description: "Questions to ask" }),
 })
 
 export const Output = Schema.Struct({

packages/core/test/config/plugin.test.ts

@@ -168,75 +168,6 @@ describe("PluginSupervisor config", () => {
     ),
   )
 
-  it.live("loads auto-discovered plugin package entrypoints in order", () =>
-    withLocation(
-      undefined,
-      Effect.gen(function* () {
-        yield* ready()
-        const plugins = yield* Plugin.Service
-        const ids = (yield* plugins.list()).map((plugin) => String(plugin.id))
-        expect(ids).toContain("package-exports")
-        expect(ids).toContain("package-module")
-        expect(ids).toContain("package-main")
-        expect(ids).toContain("package-index")
-      }),
-      false,
-      async (directory) => {
-        await Promise.all([
-          writeDiscoveredPackage(directory, "exports", { exports: "./entry.ts" }, { "entry.ts": "package-exports" }),
-          writeDiscoveredPackage(
-            directory,
-            "module",
-            { exports: "./missing.js", module: "./entry.js" },
-            { "entry.js": "package-module" },
-          ),
-          writeDiscoveredPackage(
-            directory,
-            "main",
-            { exports: { import: "./missing.js" }, module: "./missing.js", main: "./entry.js" },
-            { "entry.js": "package-main" },
-          ),
-          writeDiscoveredPackage(directory, "index", undefined, { "index.js": "package-index" }),
-        ])
-      },
-    ),
-  )
-
-  it.live("keeps auto-discovered package entrypoints inside the package directory", () =>
-    withLocation(
-      undefined,
-      Effect.gen(function* () {
-        yield* ready()
-        const plugins = yield* Plugin.Service
-        const ids = (yield* plugins.list()).map((plugin) => String(plugin.id))
-        expect(ids).toContain("contained-fallback")
-        expect(ids).toContain("symlink-fallback")
-        expect(ids).not.toContain("escaped-entrypoint")
-      }),
-      false,
-      async (directory) => {
-        await fs.mkdir(path.join(directory, ".opencode"), { recursive: true })
-        await fs.writeFile(path.join(directory, ".opencode", "escape.js"), discoveredPlugin("escaped-entrypoint"))
-        await writeDiscoveredPackage(
-          directory,
-          "contained",
-          { exports: "../../escape.js" },
-          { "index.js": "contained-fallback" },
-        )
-        await writeDiscoveredPackage(
-          directory,
-          "symlink",
-          { exports: "./entry.js" },
-          { "index.js": "symlink-fallback" },
-        )
-        await fs.symlink(
-          path.join(directory, ".opencode", "escape.js"),
-          path.join(directory, ".opencode", "plugins", "symlink", "entry.js"),
-        )
-      },
-    ),
-  )
-
   staticIt.live("uses only internal and SDK plugins when the static source is wired", () =>
     Effect.gen(function* () {
       const sdk = yield* SdkPlugins.Service
@@ -458,21 +389,3 @@ export default Plugin.define({
 })
 `
 }
-
-function discoveredPlugin(id: string) {
-  return `export default { id: ${JSON.stringify(id)}, setup() {} }`
-}
-
-async function writeDiscoveredPackage(
-  directory: string,
-  name: string,
-  manifest: Record<string, unknown> | undefined,
-  files: Record<string, string>,
-) {
-  const plugin = path.join(directory, ".opencode", "plugins", name)
-  await fs.mkdir(plugin, { recursive: true })
-  await Promise.all([
-    ...(manifest ? [fs.writeFile(path.join(plugin, "package.json"), JSON.stringify(manifest))] : []),
-    ...Object.entries(files).map(([file, id]) => fs.writeFile(path.join(plugin, file), discoveredPlugin(id))),
-  ])
-}

packages/core/test/plugin/skill.test.ts

@@ -1,18 +1,18 @@
 import { describe, expect } from "bun:test"
+import { NodeFileSystem } from "@effect/platform-node"
+import { Config } from "@opencode-ai/core/config"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { ConfigPluginSource } from "@opencode-ai/core/config/plugin/source"
-import { Effect, Layer, Stream } from "effect"
+import { FSUtil } from "@opencode-ai/util/fs-util"
+import { Location } from "@opencode-ai/core/location"
+import { Effect, Stream } from "effect"
 import { SkillPlugin } from "@opencode-ai/core/plugin/skill"
+import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Skill } from "@opencode-ai/core/skill"
+import { location } from "../fixture/location"
 import { testEffect } from "../lib/effect"
 import { host } from "./host"
 
 const it = testEffect(AppNodeBuilder.build(Skill.node))
-const sources = (operations: readonly ConfigPluginSource.Operation[] = []) =>
-  Layer.succeed(
-    ConfigPluginSource.Service,
-    ConfigPluginSource.Service.of({ operations: () => Effect.succeed(operations), changes: () => Stream.never }),
-  )
 
 describe("SkillPlugin.Plugin", () => {
   it.effect("registers built-in skills", () =>
@@ -27,7 +27,15 @@ describe("SkillPlugin.Plugin", () => {
             reload: skill.reload,
           },
         }),
-      ).pipe(Effect.provide(sources()))
+      ).pipe(
+        Effect.provide(Config.testLayer()),
+        Effect.provideService(
+          Location.Service,
+          Location.Service.of(location({ directory: AbsolutePath.make(import.meta.dir) })),
+        ),
+        Effect.provide(AppNodeBuilder.build(FSUtil.node)),
+        Effect.provide(NodeFileSystem.layer),
+      )
       const skills = yield* skill.list()
       const report = skills.find((item) => item.id === "report")
 
@@ -50,30 +58,4 @@ describe("SkillPlugin.Plugin", () => {
       expect(report?.content).toContain("- install/channel: beta")
     }),
   )
-
-  it.effect("reports canonical configured plugin sources with existing labels and ordering", () =>
-    Effect.gen(function* () {
-      const skill = yield* Skill.Service
-      yield* SkillPlugin.Plugin.effect(
-        host({
-          skill: {
-            list: () => Effect.die("unused skill.list"),
-            transform: skill.transform,
-            reload: skill.reload,
-          },
-        }),
-      )
-      const report = (yield* skill.list()).find((item) => item.id === "report")
-      expect(report?.content).toContain("- Active plugins: -disabled, local.ts, package-plugin, package-plugin")
-    }).pipe(
-      Effect.provide(
-        sources([
-          { type: "add", target: "package-plugin", options: {} },
-          { type: "remove", target: "disabled" },
-          { type: "add", target: "local.ts", options: {}, mtime: 1 },
-          { type: "add", target: "package-plugin", options: { enabled: true } },
-        ]),
-      ),
-    ),
-  )
 })

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

@@ -654,7 +654,7 @@ describe("Session.create", () => {
       expect(yield* session.get(created.id)).toMatchObject({ agent: "plan" })
       expect(
         Array.from(yield* logEvents(session, created.id, true).pipe(Stream.drop(1), Stream.take(1), Stream.runCollect)),
-      ).toMatchObject([{ type: "session.agent.selected", data: { agent: "plan", previous: "build" } }])
+      ).toMatchObject([{ type: "session.agent.selected", data: { agent: "plan" } }])
       expect(yield* session.messages({ sessionID: created.id, order: "asc" })).toMatchObject([
         { type: "agent-switched", agent: "plan", previous: "build" },
       ])
@@ -678,12 +678,7 @@ describe("Session.create", () => {
   it.effect("switches the selected model through the durable Session event", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service
-      const previous = Model.Ref.make({
-        id: Model.ID.make("haiku"),
-        providerID: Provider.ID.anthropic,
-        variant: Model.VariantID.make("default"),
-      })
-      const created = yield* session.create({ location, model: previous })
+      const created = yield* session.create({ location })
       const model = Model.Ref.make({
         id: Model.ID.make("sonnet"),
         providerID: Provider.ID.anthropic,
@@ -697,10 +692,7 @@ describe("Session.create", () => {
         yield* logEvents(session, created.id, true).pipe(Stream.drop(1), Stream.take(1), Stream.runCollect),
       )
       expect(bus).toMatchObject([{ type: "session.model.selected" }])
-      expect(bus[0]?.data).toEqual({ sessionID: created.id, model, previous })
-      expect(yield* session.messages({ sessionID: created.id, order: "asc" })).toMatchObject([
-        { type: "model-switched", model, previous },
-      ])
+      expect(bus[0]?.data).toEqual({ sessionID: created.id, model })
     }),
   )
 

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

@@ -89,30 +89,6 @@ const it = testEffect(
 )
 
 describe("QuestionTool", () => {
-  it.effect("emits one item schema for the nonempty questions array", () =>
-    Effect.gen(function* () {
-      captured = undefined
-      const registry = yield* Tool.Service
-      const definition = (yield* toolDefinitions(registry)).find((tool) => tool.name === QuestionTool.name)
-
-      expect(definition?.inputSchema).toHaveProperty("properties.questions.type", "array")
-      expect(definition?.inputSchema).toHaveProperty("properties.questions.minItems", 1)
-      expect(definition?.inputSchema).toHaveProperty("properties.questions.items")
-      expect(definition?.inputSchema).not.toHaveProperty("properties.questions.prefixItems")
-      expect(
-        yield* executeTool(registry, {
-          sessionID,
-          ...toolIdentity,
-          call: { type: "tool-call", id: "call-question-empty", name: QuestionTool.name, input: { questions: [] } },
-        }),
-      ).toMatchObject({
-        status: "error",
-        error: { type: "tool.execution", message: expect.stringContaining("Invalid tool input") },
-      })
-      expect(capturedInput()).toBeUndefined()
-    }),
-  )
-
   it.effect("omits a catalog-denied question and enforces its leaf permission", () =>
     Effect.gen(function* () {
       captured = undefined

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

@@ -11,7 +11,7 @@ import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Global } from "@opencode-ai/util/global"
-import { Effect, Fiber, Layer, Logger, Schedule, Schema, Scope } from "effect"
+import { Effect, Layer, Logger, Schedule, Schema, Scope } from "effect"
 import { eq, sql } from "drizzle-orm"
 import type { SqlClient } from "effect/unstable/sql/SqlClient"
 import { tmpdir } from "./fixture/tmpdir"
@@ -798,35 +798,6 @@ describe("V1Migration database workflow", () => {
     )
   })
 
-  test("yields while clearing stale events in batches", async () => {
-    await database(
-      Effect.gen(function* () {
-        const { db } = yield* Database.Service
-        yield* db.run(sql`INSERT INTO event_sequence (aggregate_id, seq) VALUES ('stale', 2500)`)
-        yield* db.run(sql`
-          WITH RECURSIVE rows(value) AS (
-            VALUES(1)
-            UNION ALL
-            SELECT value + 1 FROM rows WHERE value < 2500
-          )
-          INSERT INTO event (id, aggregate_id, seq, created, type, data)
-          SELECT printf('event_%04d', value), 'stale', value, 1, 'session.renamed.1', '{}'
-          FROM rows
-        `)
-        let yielded = false
-        const heartbeat = yield* Effect.yieldNow.pipe(
-          Effect.andThen(Effect.sync(() => (yielded = true))),
-          Effect.forkChild({ startImmediately: true }),
-        )
-
-        expect(yield* V1Migration.run()).toEqual({ status: "completed" })
-        expect(yielded).toBe(true)
-        yield* Fiber.join(heartbeat)
-        expect(yield* db.get<{ value: number }>(sql`SELECT COUNT(*) AS value FROM event`)).toEqual({ value: 0 })
-      }),
-    )
-  })
-
   test("imports previous V2 sessions and messages as part of the migration", async () => {
     await using tmp = await tmpdir()
     const filename = path.join(tmp.path, "opencode-next.db")

packages/desktop/src/main/background-cli.ts

@@ -37,7 +37,6 @@ export async function startBackgroundCli(logger: Logger) {
     url: service.url,
     username: service.auth.username,
     password: service.auth.password,
-    version,
   }
 }
 

packages/desktop/src/main/index.ts

@@ -134,10 +134,10 @@ const main = Effect.gen(function* () {
   initCrashReporter()
 
   const wslServers = createWslServersController(
-    CHANNEL === "beta" ? null : app.getVersion(),
-    async (distro, version, channel) => {
+    app.getVersion(),
+    async (distro) => {
       logger.log("spawning wsl sidecar", { distro })
-      return spawnWslSidecar(distro, version, channel, {
+      return spawnWslSidecar(distro, {
         onLine: (line) => logger.log("wsl sidecar", { distro, stream: line.stream, text: line.text }),
       })
     },
@@ -146,7 +146,6 @@ const main = Effect.gen(function* () {
         log: (message, meta) => logger.log(message, meta),
         error: (message, meta) => logger.error(message, meta),
       },
-      channel: CHANNEL,
     },
   )
   const stopSidecars = async () => wslServers.stopAll()
@@ -312,7 +311,6 @@ const main = Effect.gen(function* () {
 
     logger.log("starting v2 background service")
     const sidecar = yield* Effect.promise(() => startBackgroundCli(logger))
-    if (CHANNEL === "beta") wslServers.setCliVersion(sidecar.version)
     yield* Deferred.succeed(serverReady, {
       url: sidecar.url,
       username: sidecar.username,

packages/desktop/src/main/wsl/runtime.ts

@@ -264,22 +264,18 @@ export async function installWslDistro(name: string, opts?: RunWslOptions) {
   )
 }
 
-export async function installWslOpencode(version: string, channel: string, distro: string, opts?: RunWslOptions) {
+export async function installWslOpencode(version: string, distro: string, opts?: RunWslOptions) {
   return runInteractiveCommand(
     resolveSystem32Command("wsl.exe"),
-    wslArgs(["bash", "-lc", wslOpencodeInstallCommand(version, channel)], distro),
+    wslArgs(
+      ["bash", "-lc", `curl -fsSL https://opencode.ai/install | bash -s -- --version ${shellEscape(version)}`],
+      distro,
+    ),
     withTimeout(opts, DEFAULT_WSL_INSTALL_TIMEOUT_MS),
     DEFAULT_WSL_INSTALL_TIMEOUT_MS,
   )
 }
 
-export function wslOpencodeInstallCommand(version: string, channel: string) {
-  if (channel === "beta") {
-    return `npm install --global --no-audit --no-fund ${shellEscape(`@opencode-ai/cli@${version}`)}`
-  }
-  return `curl -fsSL https://opencode.ai/install | bash -s -- --version ${shellEscape(version)}`
-}
-
 export async function probeWslDistro(name: string, opts?: RunWslOptions): Promise<WslDistroProbe> {
   const executable = await runWslInDistro(["/bin/true"], name, opts).catch((error) => ({
     code: 1,
@@ -311,22 +307,11 @@ export async function probeWslDistro(name: string, opts?: RunWslOptions): Promis
   }
 }
 
-export async function resolveWslOpencode(distro: string, channel: string, opts?: RunWslOptions) {
-  if (channel !== "beta") {
-    return firstLine(
-      (
-        await runWslSh(
-          'if [ -x "$HOME/.opencode/bin/opencode" ]; then printf "%s\\n" "$HOME/.opencode/bin/opencode"; fi',
-          distro,
-          opts,
-        )
-      ).stdout,
-    )
-  }
+export async function resolveWslOpencode(distro: string, opts?: RunWslOptions) {
   return firstLine(
     (
       await runWslSh(
-        'PATH=$(awk -v RS=: -v ORS=: \'$0 !~ /^\\/mnt\\//\' <<<"$PATH" | sed "s/:$//"); export PATH; command -v opencode2 || true',
+        'if [ -x "$HOME/.opencode/bin/opencode" ]; then printf "%s\\n" "$HOME/.opencode/bin/opencode"; fi',
         distro,
         opts,
       )
@@ -336,13 +321,7 @@ export async function resolveWslOpencode(distro: string, channel: string, opts?:
 
 export async function readWslCommandVersion(command: string, distro: string, opts?: RunWslOptions) {
   const result = await runWslSh(`${shellEscape(command)} --version 2>/dev/null || true`, distro, opts)
-  return parseWslOpencodeVersion(firstLine(result.stdout))
-}
-
-export function parseWslOpencodeVersion(output: string | null) {
-  if (!output) return null
-  const marker = output.lastIndexOf(" v")
-  return marker === -1 ? output : output.slice(marker + 2)
+  return firstLine(result.stdout)
 }
 
 export function openWslTerminal(distro?: string | null) {

packages/desktop/src/main/wsl/servers.test.ts

@@ -13,10 +13,6 @@ import {
   wslServerIdsToStartOnInitialize,
 } from "./startup"
 import { createWslServersController, type WslServerConfig } from "./servers"
-import {
-  parseWslOpencodeVersion,
-  wslOpencodeInstallCommand,
-} from "./runtime"
 
 let persistedServers: WslServerConfig[] = []
 let releaseOpencodeResolve: (() => void) | undefined
@@ -37,51 +33,6 @@ test("rejects an update that did not install the desktop version", () => {
   )
 })
 
-test("installs the exact V2 CLI package through npm", () => {
-  const version = "0.0.0-next-17181"
-  const command = wslOpencodeInstallCommand(version, "beta")
-
-  expect(command).toBe("npm install --global --no-audit --no-fund '@opencode-ai/cli@0.0.0-next-17181'")
-  expect(command).not.toContain("@next")
-  expect(command).not.toContain("https://opencode.ai/install")
-})
-
-test("keeps the curl installer outside the beta channel", () => {
-  expect(wslOpencodeInstallCommand("1.18.16", "prod")).toBe(
-    "curl -fsSL https://opencode.ai/install | bash -s -- --version '1.18.16'",
-  )
-  expect(wslOpencodeInstallCommand("1.18.16", "dev")).toBe(
-    "curl -fsSL https://opencode.ai/install | bash -s -- --version '1.18.16'",
-  )
-})
-
-test("reads the version reported by the V2 binary", () => {
-  expect(parseWslOpencodeVersion("opencode2 v0.0.0-next-17181")).toBe("0.0.0-next-17181")
-  expect(parseWslOpencodeVersion("1.18.16")).toBe("1.18.16")
-})
-
-test("installs the bundled CLI version instead of the Desktop release version", async () => {
-  persistedServers = []
-  let requested: { version: string; channel: string; distro: string } | undefined
-  const controller = createWslServersController(null, async () => new Promise<never>(() => undefined), {
-    channel: "beta",
-    readServers: () => persistedServers,
-    writeServers: () => undefined,
-    resolveOpencode: async () => "/home/me/.npm/bin/opencode2",
-    readCommandVersion: async () => "0.0.0-next-17181",
-    installOpencode: async (version, channel, distro) => {
-      requested = { version, channel, distro }
-      return { code: 0, signal: null, stdout: "", stderr: "" }
-    },
-  })
-  controller.setCliVersion("0.0.0-next-17181")
-
-  await controller.installOpencode("Debian")
-
-  expect(requested).toEqual({ version: "0.0.0-next-17181", channel: "beta", distro: "Debian" })
-  expect(controller.getState().opencodeChecks.Debian?.matchesDesktop).toBe(true)
-})
-
 test("restarts an existing distro server after updating OpenCode", () => {
   expect(
     wslServerIdToRestart(
@@ -104,7 +55,7 @@ test("clears cached distro probes when removing a WSL server", () => {
       {
         Debian: {
           distro: "Debian",
-          resolvedPath: "/home/luke/.local/share/opencode/desktop/beta/1.16.2/opencode2",
+          resolvedPath: "/home/luke/.opencode/bin/opencode",
           version: "1.16.2",
           expectedVersion: "1.16.2",
           matchesDesktop: true,
@@ -213,7 +164,7 @@ test("probes addable distros in parallel before checking OpenCode", async () =>
     },
     resolveOpencode: async (distro) => {
       opencode.push(distro)
-      return "/home/me/.local/share/opencode/desktop/dev/1.16.2/opencode2"
+      return "/home/me/.opencode/bin/opencode"
     },
   })
 
@@ -244,7 +195,7 @@ test("does not check OpenCode in addable distros that cannot execute commands",
     }),
     resolveOpencode: async (distro) => {
       opencode.push(distro)
-      return "/home/me/.local/share/opencode/desktop/dev/1.16.2/opencode2"
+      return "/home/me/.opencode/bin/opencode"
     },
   })
 
@@ -274,7 +225,7 @@ function testControllerOptions() {
       await new Promise<void>((resolve) => {
         releaseOpencodeResolve = resolve
       })
-      return "/home/me/.local/share/opencode/desktop/dev/1.16.2/opencode2"
+      return "/home/me/.opencode/bin/opencode"
     },
   }
 }

packages/desktop/src/main/wsl/servers.ts

@@ -37,7 +37,7 @@ type RunningSidecar = {
   password: string
 }
 
-type SpawnSidecar = (distro: string, version: string, channel: string) => Promise<RunningSidecar>
+type SpawnSidecar = (distro: string) => Promise<RunningSidecar>
 
 type ControllerLogger = {
   log: (message: string, meta?: unknown) => void
@@ -51,8 +51,6 @@ type WslServersControllerOptions = {
   probeDistro?: typeof probeWslDistro
   resolveOpencode?: typeof resolveWslOpencode
   readCommandVersion?: typeof readWslCommandVersion
-  installOpencode?: typeof installWslOpencode
-  channel?: string
 }
 
 export type WslServersController = ReturnType<typeof createWslServersController>
@@ -62,7 +60,7 @@ export function wslServerIdForDistro(distro: string) {
 }
 
 export function createWslServersController(
-  initialCliVersion: string | null,
+  appVersion: string,
   spawnSidecar: SpawnSidecar,
   options?: WslServersControllerOptions,
 ) {
@@ -71,17 +69,10 @@ export function createWslServersController(
   const sidecars = new Map<string, RunningSidecar>()
   const startAttempts = new Map<string, number>()
   let jobAbort: AbortController | undefined
-  let cliVersion = initialCliVersion
   const logger = options?.logger
   const readServers = options?.readServers ?? readPersistedServers
   const writeServers = options?.writeServers ?? writePersistedServers
   const probeDistro = options?.probeDistro ?? probeWslDistro
-  const channel = options?.channel ?? "dev"
-
-  const expectedVersion = () => {
-    if (cliVersion) return cliVersion
-    throw new Error(nativeT("desktop.wsl.error.opencodeCannotRun"))
-  }
 
   const emit = () => {
     for (const listener of listeners) listener({ type: "state", state })
@@ -141,12 +132,11 @@ export function createWslServersController(
   }
 
   const checkOpencode = async (distro: string, opts?: { signal?: AbortSignal }) => {
-    const version = expectedVersion()
-    const resolved = await (options?.resolveOpencode ?? resolveWslOpencode)(distro, channel, opts)
-    const installed = resolved
+    const resolved = await (options?.resolveOpencode ?? resolveWslOpencode)(distro, opts)
+    const version = resolved
       ? await (options?.readCommandVersion ?? readWslCommandVersion)(resolved, distro, opts)
       : null
-    return opencodeCheck(distro, resolved, installed, version)
+    return opencodeCheck(distro, resolved, version, appVersion)
   }
 
   const refreshOpencodeCheck = async (distro: string, opts?: { signal?: AbortSignal }) => {
@@ -239,7 +229,7 @@ export function createWslServersController(
     setRuntime(id, { kind: "starting" })
     logger?.log("wsl sidecar starting", { id, distro: item.config.distro })
     try {
-      const sidecar = await spawnSidecar(item.config.distro, expectedVersion(), channel)
+      const sidecar = await spawnSidecar(item.config.distro)
       if (!isCurrentStartAttempt(id, attempt)) {
         try {
           sidecar.listener.stop()
@@ -304,10 +294,6 @@ export function createWslServersController(
   }
 
   return {
-    setCliVersion(version: string) {
-      cliVersion = version
-    },
-
     getState() {
       return state
     },
@@ -376,15 +362,12 @@ export function createWslServersController(
 
     async installOpencode(name: string) {
       await runJob({ kind: "install-opencode", distro: name, startedAt: Date.now() }, async (abort) => {
-        const version = expectedVersion()
-        const result = await (options?.installOpencode ?? installWslOpencode)(version, channel, name, {
-          signal: abort.signal,
-        })
+        const result = await installWslOpencode(appVersion, name, { signal: abort.signal })
         if (result.code !== 0) {
           throw new Error(summarize(result.stderr || result.stdout) || nativeT("desktop.wsl.error.installOpencode"))
         }
         await refreshOpencodeCheck(name, { signal: abort.signal })
-        expectOpencodeVersion(state.opencodeChecks[name]?.version ?? null, version, name)
+        expectOpencodeVersion(state.opencodeChecks[name]?.version ?? null, appVersion, name)
         const id = wslServerIdToRestart(state.servers, name)
         if (id) await startServer(id)
       })

packages/desktop/src/main/wsl/sidecar.ts

@@ -3,7 +3,7 @@ import { randomUUID } from "node:crypto"
 import { createServer } from "node:net"
 import { app } from "electron"
 import { checkHealth } from "../server"
-import { type WslCommandLine, readWslCommandVersion, resolveWslOpencode, shellEscape, wslArgs } from "./runtime"
+import { type WslCommandLine, resolveWslOpencode, shellEscape, wslArgs } from "./runtime"
 import { pollWslHealth } from "./startup"
 import { nativeT } from "../native-translations"
 
@@ -16,22 +16,10 @@ export type WslSidecar = {
 
 export async function spawnWslSidecar(
   distro: string,
-  version: string,
-  channel: string,
   opts: { onLine?: (line: WslCommandLine) => void; healthTimeoutMs?: number } = {},
 ): Promise<WslSidecar> {
-  const opencode = await resolveWslOpencode(distro, channel)
+  const opencode = await resolveWslOpencode(distro)
   if (!opencode) throw new Error(nativeT("desktop.wsl.error.opencodeNotInstalled", { distro }))
-  const installed = await readWslCommandVersion(opencode, distro)
-  if (installed !== version) {
-    throw new Error(
-      nativeT("desktop.wsl.error.updateVersion", {
-        distro,
-        installed: installed ?? nativeT("desktop.wsl.error.noVersion"),
-        expected: version,
-      }),
-    )
-  }
 
   const port = await allocatePort()
   const password = randomUUID()

packages/merman/src/markdown.ts

@@ -1,5 +1,6 @@
 import {
   TextRenderable,
+  BoxRenderable,
   RenderableEvents,
   createMarkdownCodeBlockRenderer,
   parseColor,
@@ -33,6 +34,7 @@ interface PreparedDiagram {
   readonly source: string
   readonly text: StyledText
   readonly height: number
+  readonly width: number
 }
 
 export interface MermaidMarkdownRendererOptions {
@@ -55,16 +57,23 @@ function color(value: ColorInput | undefined): RGBA | undefined {
   return value === undefined ? undefined : parseColor(value)
 }
 
-class StaticDiagramRenderable extends TextRenderable {
+class StaticDiagramRenderable extends BoxRenderable {
   constructor(ctx: RenderContext, prepared: PreparedDiagram) {
     super(ctx, {
-      content: prepared.text,
       width: "100%",
+      alignItems: "flex-start",
+      flexShrink: 0,
+      marginTop: 1,
+    })
+    const diagram = new TextRenderable(ctx, {
+      content: prepared.text,
+      width: prepared.width,
+      maxWidth: "100%",
       height: prepared.height,
       wrapMode: "none",
       selectable: false,
-      marginTop: 1,
     })
+    this.add(diagram)
     let dragX: number | undefined
     this.onMouseDown = (event: MouseEvent) => {
       if (event.button !== 0) return
@@ -79,7 +88,7 @@ class StaticDiagramRenderable extends TextRenderable {
       if (dragX === undefined) return
       const dx = event.x - dragX
       dragX = event.x
-      if (dx) this.scrollX -= dx
+      if (dx) diagram.scrollX -= dx
     }
     this.onMouseDragEnd = (event: MouseEvent) => {
       dragX = undefined
@@ -121,6 +130,7 @@ function prepareDiagram(kind: DiagramKind, source: string, options: MermaidMarkd
           }),
         ),
         height: size.height,
+        width: size.width,
       }
     }
     case "sequence": {
@@ -144,6 +154,7 @@ function prepareDiagram(kind: DiagramKind, source: string, options: MermaidMarkd
           }),
         ),
         height: size.height,
+        width: size.width,
       }
     }
     case "state": {
@@ -168,6 +179,7 @@ function prepareDiagram(kind: DiagramKind, source: string, options: MermaidMarkd
           }),
         ),
         height: size.height,
+        width: size.width,
       }
     }
   }

packages/merman/src/test/markdown.test.ts

@@ -2,7 +2,7 @@ import { afterAll, afterEach, beforeAll, expect, test } from "bun:test"
 import { mkdir } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
-import { CodeRenderable, MarkdownRenderable, RGBA, SyntaxStyle, TreeSitterClient } from "@opentui/core"
+import { CodeRenderable, MarkdownRenderable, RGBA, SyntaxStyle, TextRenderable, TreeSitterClient } from "@opentui/core"
 import { createTestRenderer } from "@opentui/core/testing"
 import { createMermaidMarkdownRenderer } from "../markdown.js"
 
@@ -78,6 +78,31 @@ flowchart LR
   expect(markdown.getChildren()[0]?.marginTop).toBe(1)
 })
 
+test("leaves Mermaid alignment to its containing layout", async () => {
+  const testRenderer = await createTestRenderer({ width: 80, height: 14 })
+  renderer = testRenderer.renderer
+  const markdown = new MarkdownRenderable(renderer, {
+    id: "markdown-centered-mermaid",
+    content: `\`\`\`mermaid
+flowchart LR
+  A[Start] --> B[Done]
+\`\`\``,
+    syntaxStyle,
+    treeSitterClient,
+    renderNode: createMermaidMarkdownRenderer(renderer),
+  })
+
+  renderer.root.add(markdown)
+  await renderMarkdown(markdown, testRenderer.renderOnce)
+
+  const line = testRenderer
+    .captureCharFrame()
+    .split("\n")
+    .find((value) => value.includes("Start"))
+  if (!line) throw new Error("Expected the rendered diagram")
+  expect(line.indexOf("Start")).toBeLessThan(10)
+})
+
 test("recognizes normalized Mermaid fence info strings", async () => {
   const testRenderer = await createTestRenderer({ width: 80, height: 14 })
   renderer = testRenderer.renderer
@@ -235,17 +260,19 @@ sequenceDiagram
   renderer.root.add(markdown)
   await renderMarkdown(markdown, testRenderer.renderOnce)
 
-  const diagram = markdown.getChildren()[0] as CodeRenderable
+  const wrapper = markdown.getChildren()[0]
+  if (!wrapper) throw new Error("Expected the rendered diagram wrapper")
+  const diagram = wrapper.getChildren()[0] as TextRenderable
   expect(diagram.scrollWidth).toBeGreaterThan(diagram.width)
   expect(diagram.scrollX).toBe(0)
 
-  await testRenderer.mockMouse.drag(diagram.x + 20, diagram.y + 2, diagram.x + 5, diagram.y + 2)
+  await testRenderer.mockMouse.drag(wrapper.x + 20, wrapper.y + 2, wrapper.x + 5, wrapper.y + 2)
   await testRenderer.renderOnce()
   expect(diagram.scrollX).toBeGreaterThan(0)
   expect(diagram.hasSelection()).toBe(false)
 
   diagram.scrollX = 0
-  await testRenderer.mockMouse.scroll(diagram.x + 20, diagram.y + 2, "right")
+  await testRenderer.mockMouse.scroll(wrapper.x + 20, wrapper.y + 2, "right")
   await testRenderer.renderOnce()
   expect(diagram.scrollX).toBeGreaterThan(0)
 })

packages/protocol/openapi.json

@@ -14373,9 +14373,6 @@
               },
               "agent": {
                 "type": "string"
-              },
-              "previous": {
-                "type": "string"
               }
             },
             "required": ["sessionID", "agent"],
@@ -14444,9 +14441,6 @@
               },
               "model": {
                 "$ref": "#/components/schemas/Model.Ref"
-              },
-              "previous": {
-                "$ref": "#/components/schemas/Model.Ref"
               }
             },
             "required": ["sessionID", "model"],

packages/schema/src/session-event.ts

@@ -69,7 +69,6 @@ export const AgentSelected = Event.durable({
   schema: {
     ...Base,
     agent: Agent.ID,
-    previous: Agent.ID.pipe(optional),
   },
 })
 export type AgentSelected = typeof AgentSelected.Type
@@ -80,7 +79,6 @@ export const ModelSelected = Event.durable({
   schema: {
     ...Base,
     model: Model.Ref,
-    previous: Model.Ref.pipe(optional),
   },
 })
 export type ModelSelected = typeof ModelSelected.Type

packages/server/src/handlers/model.ts

@@ -12,19 +12,6 @@ export const ModelHandler = HttpApiBuilder.group(Api, "server.model", (handlers)
       .handle(
         "model.list",
         Effect.fn(function* () {
-          const plugins = yield* PluginSupervisor.Service
-          yield* plugins.flush.pipe(
-            Effect.timeoutOrElse({
-              duration: "5 seconds",
-              orElse: () =>
-                Effect.fail(
-                  new ServiceUnavailableError({
-                    message: "Model catalog initialization timed out",
-                    service: "model.catalog",
-                  }),
-                ),
-            }),
-          )
           const catalog = yield* Catalog.Service
           return yield* response(catalog.model.available())
         }),

packages/server/test/model.test.ts

@@ -1,57 +0,0 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { HttpServer } from "effect/unstable/http"
-import { tmpdir } from "../../core/test/fixture/tmpdir"
-import { it } from "../../core/test/lib/effect"
-import { ServerProcess } from "../src/process"
-
-it.live("waits for plugin initialization before listing models", () =>
-  Effect.acquireUseRelease(
-    Effect.promise(() => tmpdir("opencode-model-endpoint-")),
-    (tmp) =>
-      Effect.gen(function* () {
-        yield* Effect.promise(() =>
-          fs.writeFile(
-            path.join(tmp.path, "opencode.json"),
-            JSON.stringify({
-              providers: {
-                custom: {
-                  package: "aisdk:@ai-sdk/openai-compatible",
-                  settings: { apiKey: "secret" },
-                  models: { chat: {} },
-                },
-              },
-            }),
-          ),
-        )
-        const server = yield* ServerProcess.start<never, never>({
-          hostname: "127.0.0.1",
-          port: 0,
-          password: "secret",
-          app: { version: "test-version" },
-          database: { path: ":memory:" },
-          config: { directory: tmp.path },
-          fs: { filewatcher: false },
-        })
-        const url = new URL("/api/model", HttpServer.formatAddress(server.address))
-        url.searchParams.set("location[directory]", tmp.path)
-        const response = yield* Effect.promise(() =>
-          fetch(url, { headers: { authorization: `Basic ${btoa("opencode:secret")}` } }),
-        )
-
-        expect(response.status).toBe(200)
-        const body: unknown = yield* Effect.promise(() => response.json())
-        if (!isRecord(body) || !Array.isArray(body["data"])) throw new Error("Expected a model list response")
-        expect(
-          body["data"].some((model) => isRecord(model) && model["providerID"] === "custom" && model["id"] === "chat"),
-        ).toBeTrue()
-      }),
-    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  ),
-)
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}

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

@@ -60,6 +60,15 @@ export const settings: Setting[] = [
     labels: ["off", "on"],
     keywords: ["scroll bar"],
   },
+  {
+    title: "Reading width",
+    category: "Session",
+    path: ["session", "max_width"],
+    default: "auto",
+    values: ["auto", 66, 72, 80],
+    labels: ["auto", "66 columns", "72 columns", "80 columns"],
+    keywords: ["transcript", "composer", "centered", "max width", "prose"],
+  },
   {
     title: "Thinking",
     category: "Session",

packages/tui/src/config/index.tsx

@@ -125,6 +125,11 @@ export const Info = Schema.Struct({
         description: "Session sidebar visibility; 'auto' shows it when space permits",
       }),
       scrollbar: Schema.optional(Schema.Boolean).annotate({ description: "Show the session transcript scrollbar" }),
+      max_width: Schema.optional(
+        Schema.Union([Schema.Int.check(Schema.isGreaterThan(4)), Schema.Literal("auto")]),
+      ).annotate({
+        description: "Session prose and composer max width, or 'auto' to use the available width",
+      }),
       thinking: Schema.optional(Schema.Literals(["show", "hide"])).annotate({
         description: "Show or hide model reasoning by default",
       }),

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

@@ -68,7 +68,7 @@ import { errorMessage } from "../../util/error"
 import { useToast } from "../../ui/toast"
 import stripAnsi from "strip-ansi"
 import { usePromptRef } from "../../context/prompt"
-import { sessionTabsFitVertically, SESSION_SIDEBAR_WIDTH } from "../../ui/layout"
+import { sessionLaneLayout, sessionTabsFitVertically, SESSION_SIDEBAR_WIDTH } from "../../ui/layout"
 import { projectedPromptInput } from "../../prompt/codec"
 import { deduplicateVisibleImages } from "../../prompt/attachment"
 import { useEpilogue } from "../../context/epilogue"
@@ -108,13 +108,13 @@ import { createSingleFlight } from "../../util/single-flight"
 import type { SessionPending } from "@opencode-ai/schema/session-pending"
 import { generateThinkingSyntax } from "./thinking-syntax"
 import { createDelayedPresence } from "../../util/delayed-presence"
+import { markdownLaneMarginTop, markdownLanes } from "./markdown-lanes"
 
 addDefaultParsers(parsers.parsers)
 
 // Exclude temporary bottom space when measuring the real transcript height.
 const NAVIGATION_SLACK_ID = "session-navigation-slack"
 const BACKGROUND_TOOL_HINT_DELAY = 1_000
-
 // Tail-first transcript mounting: rows mounted with the session, then backfill cadence.
 // The tail comfortably overfills a tall viewport; backfill drains a 200-message transcript
 // in a few hundred milliseconds without a perceptible pause.
@@ -1084,55 +1084,57 @@ export function Session() {
                 {(height) => <box id={NAVIGATION_SLACK_ID} height={height()} flexShrink={0} />}
               </Show>
             </scrollbox>
-            <box flexShrink={0}>
-              <Show when={!composer.open && !disabled() && queuedPrompts().length > 0}>
-                <QueuedPromptDock prompts={queuedPrompts()} onOpen={openQueuedPrompts} />
-              </Show>
-              <PluginSlot name="session.composer.top" input={{ sessionID: route.sessionID }} mode="all" />
-              <Composer
-                sessionID={route.sessionID}
-                open={composer.open || (!!session()?.parentID && forms().length === 0)}
-                defaultTab={composer.tab ?? (session()?.parentID ? "subagents" : undefined)}
-                onClose={() => setComposer("open", false)}
-              />
-              <Switch>
-                <Match when={composer.open || (!!session()?.parentID && forms().length === 0)}>{null}</Match>
-                <Match when={promptedPermissions().length > 0}>
-                  <Show when={promptedPermissions()[0]?.id} keyed>
-                    {(_) => {
-                      const request = promptedPermissions()[0]
-                      return request ? (
-                        <PermissionPrompt request={request} directory={session()?.location.directory} />
-                      ) : null
-                    }}
-                  </Show>
-                </Match>
-                <Match when={forms().length > 0}>
-                  <Show when={forms()[0]?.id} keyed>
-                    {(_) => {
-                      const form = forms()[0]
-                      return form ? <FormPrompt form={form} /> : null
-                    }}
-                  </Show>
-                </Match>
-                <Match when={!disabled()}>
-                  <Prompt
-                    visible={true}
-                    ref={bind}
-                    disabled={false}
-                    onSubmit={() => {
-                      toBottom()
-                    }}
-                    onEmptySubmit={async () => {
-                      const next = queuedPrompts()[0]
-                      if (!next) return false
-                      return mutatePending("steer", next.id)
-                    }}
-                    sessionID={route.sessionID}
-                  />
-                </Match>
-              </Switch>
-            </box>
+            <SessionContentLane width="readable">
+              <box flexShrink={0}>
+                <Show when={!composer.open && !disabled() && queuedPrompts().length > 0}>
+                  <QueuedPromptDock prompts={queuedPrompts()} onOpen={openQueuedPrompts} />
+                </Show>
+                <PluginSlot name="session.composer.top" input={{ sessionID: route.sessionID }} mode="all" />
+                <Composer
+                  sessionID={route.sessionID}
+                  open={composer.open || (!!session()?.parentID && forms().length === 0)}
+                  defaultTab={composer.tab ?? (session()?.parentID ? "subagents" : undefined)}
+                  onClose={() => setComposer("open", false)}
+                />
+                <Switch>
+                  <Match when={composer.open || (!!session()?.parentID && forms().length === 0)}>{null}</Match>
+                  <Match when={promptedPermissions().length > 0}>
+                    <Show when={promptedPermissions()[0]?.id} keyed>
+                      {(_) => {
+                        const request = promptedPermissions()[0]
+                        return request ? (
+                          <PermissionPrompt request={request} directory={session()?.location.directory} />
+                        ) : null
+                      }}
+                    </Show>
+                  </Match>
+                  <Match when={forms().length > 0}>
+                    <Show when={forms()[0]?.id} keyed>
+                      {(_) => {
+                        const form = forms()[0]
+                        return form ? <FormPrompt form={form} /> : null
+                      }}
+                    </Show>
+                  </Match>
+                  <Match when={!disabled()}>
+                    <Prompt
+                      visible={true}
+                      ref={bind}
+                      disabled={false}
+                      onSubmit={() => {
+                        toBottom()
+                      }}
+                      onEmptySubmit={async () => {
+                        const next = queuedPrompts()[0]
+                        if (!next) return false
+                        return mutatePending("steer", next.id)
+                      }}
+                      sessionID={route.sessionID}
+                    />
+                  </Match>
+                </Switch>
+              </box>
+            </SessionContentLane>
           </Show>
         </box>
         <Show when={sidebarVisible()}>
@@ -1176,22 +1178,30 @@ function SessionRowView(props: SessionRowViewProps) {
           )}
         </Match>
         <Match when={props.row.type === "compaction-queued"}>
-          <CompactionQueued />
+          <SessionContentLane width="readable">
+            <CompactionQueued />
+          </SessionContentLane>
         </Match>
         <Match when={props.row.type === "part" ? props.row : undefined}>
           {(row) => <SessionPartView partRef={row().ref} message={props.message} />}
         </Match>
         <Match when={props.row.type === "group" && props.row.kind === "reasoning" ? props.row : undefined}>
-          {(row) => <SessionReasoningGroupView refs={row().refs} completed={row().completed} message={props.message} />}
+          {(row) => (
+            <SessionContentLane width="readable">
+              <SessionReasoningGroupView refs={row().refs} completed={row().completed} message={props.message} />
+            </SessionContentLane>
+          )}
         </Match>
         <Match when={props.row.type === "group" && props.row.kind === "exploration" ? props.row : undefined}>
           {(row) => (
-            <SessionGroupView
-              refs={row().refs}
-              pending={row().pending}
-              completed={row().completed}
-              message={props.message}
-            />
+            <SessionContentLane width="readable">
+              <SessionGroupView
+                refs={row().refs}
+                pending={row().pending}
+                completed={row().completed}
+                message={props.message}
+              />
+            </SessionContentLane>
           )}
         </Match>
         <Match when={props.row.type === "assistant-footer" ? props.row : undefined}>
@@ -1199,7 +1209,9 @@ function SessionRowView(props: SessionRowViewProps) {
             <Show when={props.message(row().messageID)}>
               {(message) => (
                 <Show when={message().type === "assistant"}>
-                  <AssistantFooter message={message() as SessionMessageAssistant} />
+                  <SessionContentLane width="readable">
+                    <AssistantFooter message={message() as SessionMessageAssistant} />
+                  </SessionContentLane>
                 </Show>
               )}
             </Show>
@@ -1207,7 +1219,13 @@ function SessionRowView(props: SessionRowViewProps) {
         </Match>
         <Match when={props.row.type === "turn-usage" ? props.row : undefined}>
           {(row) => (
-            <TurnTokenUsage messageIDs={row().messageIDs} previousCache={row().previousCache} message={props.message} />
+            <SessionContentLane width="technical">
+              <TurnTokenUsage
+                messageIDs={row().messageIDs}
+                previousCache={row().previousCache}
+                message={props.message}
+              />
+            </SessionContentLane>
           )}
         </Match>
       </Switch>
@@ -1215,6 +1233,42 @@ function SessionRowView(props: SessionRowViewProps) {
   )
 }
 
+function SessionContentLane(props: { children: JSX.Element; width: "readable" | "technical" }) {
+  const ctx = use()
+  const readable = () => ctx.config.session?.max_width ?? "auto"
+  const layout = createMemo(() => {
+    const width = readable()
+    return width === "auto" ? undefined : sessionLaneLayout(ctx.width, width)
+  })
+  return (
+    <Show when={layout()} fallback={props.children}>
+      {(value) => (
+        <box width="100%" paddingLeft={value().inset} flexShrink={0}>
+          <box width={value()[props.width]} flexShrink={0}>
+            {props.children}
+          </box>
+        </box>
+      )}
+    </Show>
+  )
+}
+
+function SessionBreakoutLane(props: { children: JSX.Element }) {
+  const ctx = use()
+  const readable = () => ctx.config.session?.max_width ?? "auto"
+  const inset = createMemo(() => {
+    const width = readable()
+    return width === "auto" ? undefined : sessionLaneLayout(ctx.width, width).inset
+  })
+  return (
+    <Show when={inset() !== undefined} fallback={props.children}>
+      <box width="100%" paddingLeft={inset()} flexShrink={0}>
+        {props.children}
+      </box>
+    </Show>
+  )
+}
+
 function TurnTokenUsage(props: {
   messageIDs: string[]
   previousCache?: CacheUsage
@@ -1377,20 +1431,35 @@ function SessionMessageView(props: { message: SessionMessageInfo }) {
         <UserMessage message={props.message as SessionMessageUser} />
       </Match>
       <Match when={props.message.type === "shell"}>
-        <ShellMessage message={props.message as Extract<SessionMessageInfo, { type: "shell" }>} />
+        <SessionContentLane width="technical">
+          <ShellMessage message={props.message as Extract<SessionMessageInfo, { type: "shell" }>} />
+        </SessionContentLane>
       </Match>
       <Match when={props.message.type === "agent-switched" || props.message.type === "model-switched"}>
-        <SessionSwitchMessageV2 message={props.message} />
+        <SessionContentLane width="readable">
+          <SessionSwitchMessageV2 message={props.message} />
+        </SessionContentLane>
       </Match>
       <Match
         when={props.message.type === "system" || props.message.type === "synthetic" || props.message.type === "skill"}
       >
-        <Show when={props.message.type === "skill"} fallback={<SessionNoticeMessageV2 message={props.message} />}>
-          <SessionSkillMessage message={props.message as Extract<SessionMessageInfo, { type: "skill" }>} />
+        <Show
+          when={props.message.type === "skill"}
+          fallback={
+            <SessionContentLane width="readable">
+              <SessionNoticeMessageV2 message={props.message} />
+            </SessionContentLane>
+          }
+        >
+          <SessionContentLane width="readable">
+            <SessionSkillMessage message={props.message as Extract<SessionMessageInfo, { type: "skill" }>} />
+          </SessionContentLane>
         </Show>
       </Match>
       <Match when={props.message.type === "compaction"}>
-        <CompactionMessage message={props.message as Extract<SessionMessageInfo, { type: "compaction" }>} />
+        <SessionContentLane width="readable">
+          <CompactionMessage message={props.message as Extract<SessionMessageInfo, { type: "compaction" }>} />
+        </SessionContentLane>
       </Match>
     </Switch>
   )
@@ -1411,11 +1480,13 @@ function SessionPartView(props: { partRef: PartRef; message: (messageID: string)
             <TextPart part={item() as SessionMessageAssistantText} last={false} />
           </Match>
           <Match when={item().type === "reasoning"}>
-            <ReasoningPart
-              part={item() as SessionMessageAssistantReasoning}
-              message={message() as SessionMessageAssistant}
-              last={false}
-            />
+            <SessionContentLane width="readable">
+              <ReasoningPart
+                part={item() as SessionMessageAssistantReasoning}
+                message={message() as SessionMessageAssistant}
+                last={false}
+              />
+            </SessionContentLane>
           </Match>
           <Match when={item().type === "tool"}>
             <ToolPart part={item() as SessionMessageAssistantTool} />
@@ -1938,79 +2009,56 @@ function UserMessage(props: { message: SessionMessageUser }) {
 
   return (
     <Show when={props.message.text.trim() || files().length || skills().length}>
-      <box
-        border={["left"]}
-        borderColor={delivery() ? theme.border.default : color()}
-        customBorderChars={SplitBorder.customBorderChars}
-      >
-        <SessionImages images={images()} paddingLeft={2} />
+      <SessionContentLane width="readable">
         <box
-          onMouseOver={() => {
-            setHover(true)
-          }}
-          onMouseOut={() => {
-            setHover(false)
-          }}
-          onMouseUp={() => {
-            if (renderer.getSelection()?.getSelectedText()) return
-            if (delivery() === "steer") {
+          border={["left"]}
+          borderColor={delivery() ? theme.border.default : color()}
+          customBorderChars={SplitBorder.customBorderChars}
+        >
+          <SessionImages images={images()} paddingLeft={2} />
+          <box
+            onMouseOver={() => {
+              setHover(true)
+            }}
+            onMouseOut={() => {
+              setHover(false)
+            }}
+            onMouseUp={() => {
+              if (renderer.getSelection()?.getSelectedText()) return
+              if (delivery() === "steer") {
+                dialog.replace(() => (
+                  <DialogSelect
+                    title="Pending steer"
+                    options={[
+                      { title: "Move to queue", value: "queue" as const },
+                      { title: "Delete", value: "cancel" as const },
+                    ]}
+                    onSelect={(option) => {
+                      void updatePendingSteer(option.value)
+                    }}
+                  />
+                ))
+                return
+              }
               dialog.replace(() => (
-                <DialogSelect
-                  title="Pending steer"
-                  options={[
-                    { title: "Move to queue", value: "queue" as const },
-                    { title: "Delete", value: "cancel" as const },
-                  ]}
-                  onSelect={(option) => {
-                    void updatePendingSteer(option.value)
-                  }}
+                <DialogMessage
+                  messageID={props.message.id}
+                  sessionID={ctx.sessionID}
+                  setPrompt={(value) => promptRef.current?.set(value)}
                 />
               ))
-              return
-            }
-            dialog.replace(() => (
-              <DialogMessage
-                messageID={props.message.id}
-                sessionID={ctx.sessionID}
-                setPrompt={(value) => promptRef.current?.set(value)}
-              />
-            ))
-          }}
-          paddingTop={1}
-          paddingBottom={1}
-          paddingLeft={2}
-          backgroundColor={hover() ? theme.raise(theme.background.default) : theme.background.default}
-          flexShrink={0}
-        >
-          <text fg={theme.text.default}>{props.message.text}</text>
-          <Show when={skills().length}>
-            <box flexDirection="row" paddingTop={1} gap={1} flexWrap="wrap">
-              <For each={skills()}>
-                {(skill) => (
-                  <text fg={theme.text.default}>
-                    <span
-                      style={{
-                        bg: theme.hue.accent[mode() === "light" ? 700 : 200],
-                        fg: theme.background.default,
-                        bold: true,
-                      }}
-                    >
-                      {" skill "}
-                    </span>
-                    <span style={{ bg: theme.raise(theme.background.default), fg: theme.text.subdued }}>
-                      {` ${skill.name} `}
-                    </span>
-                  </text>
-                )}
-              </For>
-            </box>
-          </Show>
-          <Show when={files().length}>
-            <box flexDirection="row" paddingTop={1} gap={1} flexWrap="wrap">
-              <For each={files()}>
-                {(file) => {
-                  const label = file.mime === "application/x-directory" ? "dir" : "file"
-                  return (
+            }}
+            paddingTop={1}
+            paddingBottom={1}
+            paddingLeft={2}
+            backgroundColor={hover() ? theme.raise(theme.background.default) : theme.background.default}
+            flexShrink={0}
+          >
+            <text fg={theme.text.default}>{props.message.text}</text>
+            <Show when={skills().length}>
+              <box flexDirection="row" paddingTop={1} gap={1} flexWrap="wrap">
+                <For each={skills()}>
+                  {(skill) => (
                     <text fg={theme.text.default}>
                       <span
                         style={{
@@ -2019,20 +2067,45 @@ function UserMessage(props: { message: SessionMessageUser }) {
                           bold: true,
                         }}
                       >
-                        {` ${label} `}
+                        {" skill "}
                       </span>
                       <span style={{ bg: theme.raise(theme.background.default), fg: theme.text.subdued }}>
-                        {" "}
-                        {file.name ?? (file.source.type === "uri" ? file.source.uri : "attachment")}{" "}
+                        {` ${skill.name} `}
                       </span>
                     </text>
-                  )
-                }}
-              </For>
-            </box>
-          </Show>
+                  )}
+                </For>
+              </box>
+            </Show>
+            <Show when={files().length}>
+              <box flexDirection="row" paddingTop={1} gap={1} flexWrap="wrap">
+                <For each={files()}>
+                  {(file) => {
+                    const label = file.mime === "application/x-directory" ? "dir" : "file"
+                    return (
+                      <text fg={theme.text.default}>
+                        <span
+                          style={{
+                            bg: theme.hue.accent[mode() === "light" ? 700 : 200],
+                            fg: theme.background.default,
+                            bold: true,
+                          }}
+                        >
+                          {` ${label} `}
+                        </span>
+                        <span style={{ bg: theme.raise(theme.background.default), fg: theme.text.subdued }}>
+                          {" "}
+                          {file.name ?? (file.source.type === "uri" ? file.source.uri : "attachment")}{" "}
+                        </span>
+                      </text>
+                    )
+                  }}
+                </For>
+              </box>
+            </Show>
+          </box>
         </box>
-      </box>
+      </SessionContentLane>
     </Show>
   )
 }
@@ -2215,14 +2288,16 @@ function TextPart(props: { last: boolean; part: SessionMessageAssistantText }) {
   const theme = useTheme()
   const { currentSyntax: syntax } = useThemes()
   const plugins = usePlugin()
-  return (
-    <Show when={props.part.text.trim()}>
+  const constrained = () => (ctx.config.session?.max_width ?? "auto") !== "auto"
+
+  function Content(input: { content: string }) {
+    return (
       <box paddingLeft={3} flexShrink={0}>
         <markdown
           syntaxStyle={syntax()}
           streaming={true}
           internalBlockMode="top-level"
-          content={props.part.text.trim()}
+          content={input.content.trim()}
           tableOptions={{ style: "grid" }}
           conceal={ctx.markdownMode() === "rendered"}
           fg={theme.markdown.text}
@@ -2230,6 +2305,38 @@ function TextPart(props: { last: boolean; part: SessionMessageAssistantText }) {
           renderNode={plugins.markdown()}
         />
       </box>
+    )
+  }
+
+  return (
+    <Show when={props.part.text.trim()}>
+      <Switch>
+        <Match when={!constrained()}>
+          <Content content={props.part.text} />
+        </Match>
+        <Match when={constrained()}>
+          <Index each={markdownLanes(props.part.text.trim())}>
+            {(segment, index) => {
+              const content = <Content content={segment().content} />
+              return (
+                <box width="100%" marginTop={markdownLaneMarginTop(index, segment().width)} flexShrink={0}>
+                  <Switch>
+                    <Match when={segment().width === "full"}>
+                      <SessionBreakoutLane>{content}</SessionBreakoutLane>
+                    </Match>
+                    <Match when={segment().width === "technical"}>
+                      <SessionContentLane width="technical">{content}</SessionContentLane>
+                    </Match>
+                    <Match when={segment().width === "readable"}>
+                      <SessionContentLane width="readable">{content}</SessionContentLane>
+                    </Match>
+                  </Switch>
+                </box>
+              )
+            }}
+          </Index>
+        </Match>
+      </Switch>
     </Show>
   )
 }
@@ -2238,6 +2345,7 @@ function TextPart(props: { last: boolean; part: SessionMessageAssistantText }) {
 
 function ToolPart(props: { part: SessionMessageAssistantTool; images?: boolean }) {
   const display = createMemo(() => toolDisplay(props.part.name))
+  const width = createMemo(() => toolLane(props.part.name))
 
   const toolprops = {
     get metadata() {
@@ -2307,10 +2415,12 @@ function ToolPart(props: { part: SessionMessageAssistantTool; images?: boolean }
     </Switch>
   )
   return [
-    content,
-    <Show when={props.images !== false}>
-      <ToolImages parts={[props.part]} />
-    </Show>,
+    <SessionContentLane width={width()}>{content}</SessionContentLane>,
+    <SessionContentLane width="readable">
+      <Show when={props.images !== false}>
+        <ToolImages parts={[props.part]} />
+      </Show>
+    </SessionContentLane>,
   ]
 }
 
@@ -3144,7 +3254,7 @@ function Edit(props: ToolProps) {
     const diffView = ctx.config.diffs?.view
     if (diffView === "unified") return "unified"
     if (diffView === "split") return "split"
-    // Default to "auto" behavior
+    if ((ctx.config.session?.max_width ?? "auto") !== "auto") return "unified"
     return ctx.width > 120 ? "split" : "unified"
   })
 
@@ -3222,6 +3332,7 @@ function ApplyPatch(props: ToolProps) {
   const view = createMemo(() => {
     if (ctx.config.diffs?.view === "unified") return "unified"
     if (ctx.config.diffs?.view === "split") return "split"
+    if ((ctx.config.session?.max_width ?? "auto") !== "auto") return "unified"
     return ctx.width > 120 ? "split" : "unified"
   })
 
@@ -3407,11 +3518,17 @@ const toolDisplays = new Set([
   "skill",
 ])
 
+const technicalToolDisplays = new Set(["shell", "write", "edit", "execute", "patch", "generic"])
+
 export function toolDisplay(tool: string) {
   const normalized = canonicalToolName(tool)
   return toolDisplays.has(normalized) ? normalized : "generic"
 }
 
+export function toolLane(tool: string): "readable" | "technical" {
+  return technicalToolDisplays.has(toolDisplay(tool)) ? "technical" : "readable"
+}
+
 function recordValue(value: unknown): Record<string, unknown> | undefined {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return
   return value as Record<string, unknown>

packages/tui/src/routes/session/markdown-lanes.ts

@@ -0,0 +1,65 @@
+export type MarkdownLane = {
+  content: string
+  width: "readable" | "technical" | "full"
+}
+
+export function markdownLanes(content: string): MarkdownLane[] {
+  const result: MarkdownLane[] = []
+  let fence: { marker: "`" | "~"; length: number } | undefined
+  let table = false
+  const lines = content.match(/[^\n]*(?:\n|$)/g)?.filter(Boolean) ?? []
+
+  for (const [index, line] of lines.entries()) {
+    const opening = fence ? undefined : line.match(/^ {0,3}(`{3,}|~{3,})([^\n]*)/)
+    const marker = opening?.[1]
+    const tableOpening = !opening && !fence && isTableRow(line) && isTableDelimiter(lines[index + 1])
+    if (marker) fence = { marker: marker.startsWith("`") ? "`" : "~", length: marker.length }
+    if (tableOpening) table = true
+
+    const width = opening
+      ? opening[2]?.trim().split(/\s/, 1)[0]?.toLowerCase() === "mermaid"
+        ? "full"
+        : "technical"
+      : fence
+        ? (result.at(-1)?.width ?? "technical")
+        : table
+          ? "technical"
+          : "readable"
+    const previous = result.at(-1)
+    if (previous?.width === width) previous.content += line
+    else result.push({ content: line, width })
+
+    if (!fence) {
+      if (table && !isTableRow(lines[index + 1])) table = false
+      continue
+    }
+    const currentFence = fence
+    const trimmed = line.trim()
+    if (
+      !opening &&
+      (line.match(/^ */)?.[0].length ?? 0) <= 3 &&
+      trimmed.length >= currentFence.length &&
+      [...trimmed].every((character) => character === currentFence.marker)
+    ) {
+      fence = undefined
+    }
+  }
+
+  return result
+}
+
+function isTableRow(line: string | undefined) {
+  return Boolean(line?.trim() && line.includes("|"))
+}
+
+function isTableDelimiter(line: string | undefined) {
+  if (!line) return false
+  const value = line.trim().replace(/^\||\|$/g, "")
+  const cells = value.split("|")
+  return cells.length > 1 && cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim()))
+}
+
+export function markdownLaneMarginTop(index: number, width: MarkdownLane["width"]) {
+  if (index === 0 || width === "full") return 0
+  return 1
+}

packages/tui/src/ui/layout.ts

@@ -1,6 +1,19 @@
 export const SESSION_SIDEBAR_WIDTH = 42
+export const SESSION_TECHNICAL_LANE_WIDTH = 88
 const SESSION_CONTENT_MIN_WIDTH = 44
 
 export function sessionTabsFitVertically(total: number) {
   return total >= SESSION_SIDEBAR_WIDTH + SESSION_CONTENT_MIN_WIDTH
 }
+
+// The shared spine centers the prose measure; the technical rail shares its
+// leading edge and extends rightward, clamped so it still fits the canvas.
+export function sessionLaneLayout(available: number, readable: number) {
+  const technical = Math.min(available, Math.max(readable, SESSION_TECHNICAL_LANE_WIDTH))
+  const centered = Math.floor((available - Math.min(readable, technical)) / 2)
+  return {
+    inset: Math.max(0, Math.min(centered, available - technical)),
+    readable: Math.min(readable, technical),
+    technical,
+  }
+}

packages/tui/test/cli/tui/inline-tool-wrap-snapshot.test.tsx

@@ -10,6 +10,7 @@ import {
   parseQuestionAnswers,
   parseQuestions,
   toolDisplay,
+  toolLane,
 } from "../../../src/routes/session"
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined
@@ -131,6 +132,11 @@ describe("TUI inline tool wrapping", () => {
     expect(toolDisplay("apply_patch")).toBe("patch")
     expect(toolDisplay("patch")).toBe("patch")
     expect(toolDisplay("plugin_tool")).toBe("generic")
+    expect(toolLane("glob")).toBe("readable")
+    expect(toolLane("webfetch")).toBe("readable")
+    expect(toolLane("shell")).toBe("technical")
+    expect(toolLane("apply_patch")).toBe("technical")
+    expect(toolLane("plugin_tool")).toBe("technical")
   })
 
   test("replaces pending copy when a tool fails before completion", async () => {

packages/tui/test/cli/tui/markdown-lanes.test.ts

@@ -0,0 +1,68 @@
+import { expect, test } from "bun:test"
+import { markdownLaneMarginTop, markdownLanes } from "../../../src/routes/session/markdown-lanes"
+
+test("keeps prose in the readable lane", () => {
+  expect(markdownLanes("Before\n\nAfter")).toEqual([{ content: "Before\n\nAfter", width: "readable" }])
+})
+
+test("moves Mermaid fences into the full lane", () => {
+  expect(
+    markdownLanes(`Before
+
+\`\`\`mermaid
+flowchart LR
+  A --> B
+\`\`\`
+
+After`),
+  ).toEqual([
+    { content: "Before\n\n", width: "readable" },
+    { content: "```mermaid\nflowchart LR\n  A --> B\n```\n", width: "full" },
+    { content: "\nAfter", width: "readable" },
+  ])
+})
+
+test("keeps an incomplete streaming Mermaid fence full width", () => {
+  expect(markdownLanes("Before\n```mermaid\nflowchart LR\n  A -->")).toEqual([
+    { content: "Before\n", width: "readable" },
+    { content: "```mermaid\nflowchart LR\n  A -->", width: "full" },
+  ])
+})
+
+test("supports tilde fences and longer closing fences", () => {
+  expect(markdownLanes("~~~ts\nconst value = 1\n~~~~\nAfter")).toEqual([
+    { content: "~~~ts\nconst value = 1\n~~~~\n", width: "technical" },
+    { content: "After", width: "readable" },
+  ])
+})
+
+test("does not close a fence indented as code", () => {
+  expect(markdownLanes("```ts\n    ```\nstill code")).toEqual([
+    { content: "```ts\n    ```\nstill code", width: "technical" },
+  ])
+})
+
+test("gives ordinary fenced code an intermediate lane", () => {
+  expect(markdownLanes("```ts\nexport const value = true\n```")).toEqual([
+    { content: "```ts\nexport const value = true\n```", width: "technical" },
+  ])
+})
+
+test("gives Markdown tables the technical lane", () => {
+  expect(markdownLanes("Before\n\n| Name | Value |\n| --- | ---: |\n| Width | 88 |\n\nAfter")).toEqual([
+    { content: "Before\n\n", width: "readable" },
+    { content: "| Name | Value |\n| --- | ---: |\n| Width | 88 |\n", width: "technical" },
+    { content: "\nAfter", width: "readable" },
+  ])
+})
+
+test("does not treat ordinary pipe characters as a table", () => {
+  expect(markdownLanes("Use foo | bar in prose.")).toEqual([{ content: "Use foo | bar in prose.", width: "readable" }])
+})
+
+test("restores spacing between separately rendered blocks", () => {
+  expect(markdownLaneMarginTop(0, "readable")).toBe(0)
+  expect(markdownLaneMarginTop(1, "technical")).toBe(1)
+  expect(markdownLaneMarginTop(2, "readable")).toBe(1)
+  expect(markdownLaneMarginTop(1, "full")).toBe(0)
+})

packages/tui/test/config-v2.test.tsx

@@ -27,6 +27,15 @@ test("validates the session tabs setting", () => {
   expect(decode({ session: { image_preview: true } })).toEqual({ session: { image_preview: true } })
 })
 
+test("validates the session max width setting", () => {
+  const decode = Schema.decodeUnknownSync(Info)
+
+  expect(decode({ session: { max_width: "auto" } })).toEqual({ session: { max_width: "auto" } })
+  expect(decode({ session: { max_width: 100 } })).toEqual({ session: { max_width: 100 } })
+  expect(() => decode({ session: { max_width: 4 } })).toThrow()
+  expect(() => decode({ session: { max_width: 100.5 } })).toThrow()
+})
+
 test("resolves nested config and keybind defaults", () => {
   const config = resolve(
     {
@@ -53,6 +62,13 @@ test("shows resolved tab defaults in settings", () => {
   expect(settings.find((setting) => setting.path.join(".") === "tabs.layout")?.default).toBe("horizontal")
 })
 
+test("shows session reading width presets in settings", () => {
+  const setting = settings.find((setting) => setting.path.join(".") === "session.max_width")
+
+  expect(setting?.default).toBe("auto")
+  expect(setting?.values).toEqual(["auto", 66, 72, 80])
+})
+
 test("provides config and its host interface", async () => {
   const config = resolve({}, { terminalSuspend: true })
   let current = {}

packages/tui/test/ui/layout.test.ts

@@ -1,8 +1,23 @@
 import { expect, test } from "bun:test"
-import { sessionTabsFitVertically, SESSION_SIDEBAR_WIDTH } from "../../src/ui/layout"
+import {
+  sessionLaneLayout,
+  sessionTabsFitVertically,
+  SESSION_SIDEBAR_WIDTH,
+  SESSION_TECHNICAL_LANE_WIDTH,
+} from "../../src/ui/layout"
 
 test("vertical tabs match the session sidebar and preserve compact content width", () => {
   expect(SESSION_SIDEBAR_WIDTH).toBe(42)
   expect(sessionTabsFitVertically(86)).toBe(true)
   expect(sessionTabsFitVertically(85)).toBe(false)
 })
+
+test("session lanes center the prose measure on one leading edge", () => {
+  expect(SESSION_TECHNICAL_LANE_WIDTH).toBe(88)
+  // Wide canvas: prose is truly centered, technical extends rightward.
+  expect(sessionLaneLayout(156, 66)).toEqual({ inset: 45, readable: 66, technical: 88 })
+  // Centering the prose would push the technical rail past the canvas; clamp.
+  expect(sessionLaneLayout(100, 66)).toEqual({ inset: 12, readable: 66, technical: 88 })
+  expect(sessionLaneLayout(80, 66)).toEqual({ inset: 0, readable: 66, technical: 80 })
+  expect(sessionLaneLayout(60, 66)).toEqual({ inset: 0, readable: 60, technical: 60 })
+})

packages/www/openapi.json

@@ -14373,9 +14373,6 @@
               },
               "agent": {
                 "type": "string"
-              },
-              "previous": {
-                "type": "string"
               }
             },
             "required": ["sessionID", "agent"],
@@ -14444,9 +14441,6 @@
               },
               "model": {
                 "$ref": "#/components/schemas/Model.Ref"
-              },
-              "previous": {
-                "$ref": "#/components/schemas/Model.Ref"
               }
             },
             "required": ["sessionID", "model"],

packages/www/public/openapi.json

@@ -14373,9 +14373,6 @@
               },
               "agent": {
                 "type": "string"
-              },
-              "previous": {
-                "type": "string"
               }
             },
             "required": ["sessionID", "agent"],
@@ -14444,9 +14441,6 @@
               },
               "model": {
                 "$ref": "#/components/schemas/Model.Ref"
-              },
-              "previous": {
-                "$ref": "#/components/schemas/Model.Ref"
               }
             },
             "required": ["sessionID", "model"],