feat(tui): manage pending steers

packages/ai/src/schema/options.ts

@@ -178,7 +178,6 @@ export class LanguageModelCompatibility extends Schema.Class<LanguageModelCompat
   toolSchema: Schema.optional(LanguageModelToolSchemaCompatibility),
   reasoningField: Schema.optional(Schema.String),
   maxTokensField: Schema.optional(LanguageModelMaxTokensFieldCompatibility),
-  requireFinishReason: Schema.optional(Schema.Boolean),
 }) {}
 
 export namespace LanguageModelCompatibility {

packages/ai/test/llm.test.ts

@@ -102,7 +102,7 @@ describe("llm constructors", () => {
     const updated = LanguageModel.update(base, {
       route: responsesRoute,
       defaults: { generation: { maxTokens: 20 } },
-      compatibility: { toolSchema: "gemini", requireFinishReason: false },
+      compatibility: { toolSchema: "gemini" },
     })
     const updatedInput = LanguageModel.input(updated)
 
@@ -110,7 +110,7 @@ describe("llm constructors", () => {
     expect(String(updated.id)).toBe("fake-model")
     expect(updated.route).toBe(responsesRoute)
     expect(updated.defaults?.generation).toEqual({ maxTokens: 20 })
-    expect(updated.compatibility).toEqual({ toolSchema: "gemini", requireFinishReason: false })
+    expect(updated.compatibility).toEqual({ toolSchema: "gemini" })
     expect(updatedInput.defaults).toBe(updated.defaults)
     expect(updatedInput.compatibility).toBe(updated.compatibility)
     expect(String(updatedInput.provider)).toBe("fake")

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

@@ -153,4 +153,88 @@ describe("v2 session reducer", () => {
 
     expect(result).toMatchObject({ sessionID: "ses_1", missing: "msg_user", touched: [] })
   })
+
+  test("removes cancelled input from the pending promotion fold", () => {
+    const reducer = createV2SessionReducer()
+    reducer.reduce(
+      [],
+      event({
+        ...base,
+        id: "evt_admitted",
+        type: "session.input.admitted",
+        data: {
+          sessionID: "ses_1",
+          inputID: "msg_user",
+          input: { type: "user", delivery: "queue", data: { text: "cancel me" } },
+        },
+      }),
+    )
+    reducer.reduce(
+      [],
+      event({
+        ...base,
+        id: "evt_cancelled",
+        type: "session.input.cancelled",
+        data: { sessionID: "ses_1", inputID: "msg_user" },
+      }),
+    )
+    const result = reducer.reduce(
+      [],
+      event({
+        ...base,
+        id: "evt_promoted",
+        type: "session.input.promoted",
+        data: { sessionID: "ses_1", inputID: "msg_user" },
+      }),
+    )
+
+    expect(result).toMatchObject({ missing: "msg_user" })
+  })
+
+  test("keeps steered input available to the promotion fold", () => {
+    const reducer = createV2SessionReducer()
+    reducer.reduce(
+      [],
+      event({
+        ...base,
+        id: "evt_admitted",
+        type: "session.input.admitted",
+        data: {
+          sessionID: "ses_1",
+          inputID: "msg_user",
+          input: { type: "user", delivery: "queue", data: { text: "steer me" } },
+        },
+      }),
+    )
+    reducer.reduce(
+      [],
+      event({
+        ...base,
+        id: "evt_steered",
+        type: "session.input.steered",
+        data: { sessionID: "ses_1", inputID: "msg_user" },
+      }),
+    )
+    reducer.reduce(
+      [],
+      event({
+        ...base,
+        id: "evt_queued",
+        type: "session.input.queued",
+        data: { sessionID: "ses_1", inputID: "msg_user" },
+      }),
+    )
+
+    const result = reducer.reduce(
+      [],
+      event({
+        ...base,
+        id: "evt_promoted",
+        type: "session.input.promoted",
+        data: { sessionID: "ses_1", inputID: "msg_user" },
+      }),
+    )
+
+    expect(result?.messages).toMatchObject([{ id: "msg_user", type: "user", text: "steer me" }])
+  })
 })

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

@@ -29,6 +29,9 @@ export function createV2SessionReducer() {
       case "session.input.admitted":
         pending.set(key(sessionID, event.data.inputID), event.data.input)
         return result([...source])
+      case "session.input.cancelled":
+        pending.delete(key(sessionID, event.data.inputID))
+        return
       case "session.input.promoted": {
         const input = pending.get(key(sessionID, event.data.inputID))
         pending.delete(key(sessionID, event.data.inputID))

packages/cli/src/commands/commands.ts

@@ -140,32 +140,6 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
       description: "List all available models",
       params: ServerParams,
     }),
-    Spec.make("export", {
-      description: "Export session data as JSON",
-      params: {
-        ...ServerParams,
-        session: Flag.string("session").pipe(
-          Flag.withAlias("s"),
-          Flag.withDescription("Session ID to export to stdout"),
-          Flag.optional,
-        ),
-        sanitize: Flag.boolean("sanitize").pipe(
-          Flag.withDescription("Redact sensitive transcript and file data"),
-          Flag.withDefault(false),
-        ),
-      },
-    }),
-    Spec.make("import", {
-      description: "Import session data from a JSON file or URL",
-      params: {
-        ...ServerParams,
-        file: Argument.string("file").pipe(Argument.withDescription("JSON file or URL to import")),
-        directory: Flag.string("directory").pipe(
-          Flag.withDescription("Directory in which to import the session"),
-          Flag.optional,
-        ),
-      },
-    }),
     Spec.make("mini", {
       description: "Start the minimal interactive interface",
       params: {

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

@@ -1,140 +0,0 @@
-import { OpenCode, type SessionInfo } from "@opencode-ai/client"
-import { Service } from "@opencode-ai/client/effect/service"
-import { Effect, Option } from "effect"
-import { EOL, tmpdir } from "node:os"
-import path from "node:path"
-import { emitKeypressEvents, type Key } from "node:readline"
-import { Commands } from "../commands"
-import { Runtime } from "../../framework/runtime"
-import { ServerConnection } from "../../services/server-connection"
-
-export default Runtime.handler(
-  Commands.commands.export,
-  Effect.fn("cli.export")(function* (input) {
-    const server = yield* ServerConnection.resolve({
-      server: Option.getOrUndefined(input.server),
-      standalone: input.standalone,
-    })
-    const client = OpenCode.make({
-      baseUrl: server.endpoint.url,
-      headers: Service.headers(server.endpoint),
-    })
-    const requested = Option.getOrUndefined(input.session)
-    const selected = requested
-      ? undefined
-      : yield* Effect.promise(async () => {
-          const location = await client.location.get({ location: { directory: process.cwd() } })
-          const page = await client.session.list({
-            directory: location.directory,
-            workspace: location.workspaceID,
-            parentID: null,
-            order: "desc",
-            limit: 50,
-          })
-          if (page.data.length === 0) {
-            process.stderr.write(`No sessions found${EOL}`)
-            return undefined
-          }
-          return selectSession(page.data, input.sanitize)
-        })
-    const sessionID = requested ?? selected?.session.id
-    if (!sessionID) return
-    const data = yield* Effect.promise(() =>
-      client.session.export({ sessionID, sanitize: selected?.sanitize ?? input.sanitize }),
-    )
-    process.stdout.write(yield* Effect.promise(() => writeExport(data, sessionID, requested !== undefined)))
-  }),
-)
-
-type Selection = { session: SessionInfo; sanitize: boolean }
-
-function selectSession(sessions: SessionInfo[], initialSanitize: boolean) {
-  if (!process.stdin.isTTY) return Promise.reject(new Error("Session ID is required when stdin is not interactive"))
-  const input = process.stdin
-  const output = process.stderr
-  const wasRaw = input.isRaw
-  const wasPaused = input.isPaused()
-  const date = new Intl.DateTimeFormat(undefined, {
-    month: "short",
-    day: "numeric",
-    hour: "numeric",
-    minute: "2-digit",
-  })
-  const columns = output.columns ?? 100
-  const titleWidth = Math.max(8, Math.min(48, columns - 34))
-  let selected = 0
-  let offset = 0
-  let sanitize = initialSanitize
-  let height = 0
-
-  const render = () => {
-    const visible = sessions.slice(offset, offset + 10)
-    const lines = ["  \x1b[36mExport session\x1b[0m", ""]
-    lines.push(
-      ...visible.map((session) => {
-        const index = sessions.indexOf(session)
-        const title = (session.title ?? "Untitled session").slice(0, titleWidth).padEnd(titleWidth)
-        const updated = date.format(session.time.updated).slice(0, 18).padEnd(18)
-        const row = `${index === selected ? ">" : " "} ${title}  ${updated}  ${session.id.slice(-8)}`
-        return index === selected ? `\x1b[1m${row}\x1b[0m` : row
-      }),
-      "",
-      `  [${sanitize ? "x" : " "}] sanitize sensitive data`,
-      "",
-      "  navigate \x1b[2mup/down\x1b[0m   sanitize \x1b[2mspace\x1b[0m   export \x1b[2menter\x1b[0m   cancel \x1b[2mesc\x1b[0m",
-    )
-    if (height > 0) output.write(`\x1b[${height}F\x1b[J`)
-    output.write(lines.join(EOL) + EOL)
-    height = lines.length
-  }
-  const clear = () => {
-    if (height > 0) output.write(`\x1b[${height}F\x1b[J`)
-    output.write("\x1b[?25h")
-    input.removeListener("keypress", onKeypress)
-    input.setRawMode(wasRaw ?? false)
-    if (wasPaused) input.pause()
-  }
-  const onKeypress = (value: string | undefined, key: Key) => {
-    if (key.name === "up") {
-      selected = (selected - 1 + sessions.length) % sessions.length
-      if (selected === sessions.length - 1) offset = Math.max(0, sessions.length - 10)
-      if (selected < offset) offset = selected
-    }
-    if (key.name === "down") {
-      selected = (selected + 1) % sessions.length
-      if (selected === 0) offset = 0
-      if (selected >= offset + 10) offset = selected - 9
-    }
-    if (key.name === "space" || value === " ") sanitize = !sanitize
-    if (key.name === "return") return finish(sessions[selected])
-    if (key.name === "escape" || (key.ctrl && key.name === "c")) return cancel()
-    render()
-  }
-  const finish = (session: SessionInfo) => {
-    clear()
-    resolveSelection?.({ session, sanitize })
-  }
-  const cancel = () => {
-    clear()
-    resolveSelection?.()
-  }
-  let resolveSelection: ((selection?: Selection) => void) | undefined
-
-  emitKeypressEvents(input)
-  input.setRawMode(true)
-  input.resume()
-  input.on("keypress", onKeypress)
-  output.write("\x1b[?25l")
-  render()
-  return new Promise<Selection | undefined>((resolve) => {
-    resolveSelection = resolve
-  })
-}
-
-export async function writeExport(data: unknown, sessionID: string, stdout: boolean) {
-  const json = JSON.stringify(data, null, 2) + EOL
-  if (stdout) return json
-  const file = path.join(tmpdir(), `opencode-session-${sessionID}-${crypto.randomUUID().slice(0, 8)}.json`)
-  await Bun.write(file, json)
-  return file + EOL
-}

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

@@ -1,60 +0,0 @@
-import { OpenCode } from "@opencode-ai/client"
-import { Service } from "@opencode-ai/client/effect/service"
-import { Session } from "@opencode-ai/schema/session"
-import { SessionTransfer } from "@opencode-ai/schema/session-transfer"
-import { Effect, Option, Schema } from "effect"
-import { EOL } from "node:os"
-import path from "node:path"
-import { Commands } from "../commands"
-import { Runtime } from "../../framework/runtime"
-import { ServerConnection } from "../../services/server-connection"
-
-export default Runtime.handler(
-  Commands.commands.import,
-  Effect.fn("cli.import")(function* (input) {
-    const text = yield* Effect.tryPromise({
-      try: () =>
-        input.file.startsWith("http://") || input.file.startsWith("https://")
-          ? fetch(input.file).then((response) => {
-              if (!response.ok) throw new Error(`Failed to fetch session data: ${response.statusText}`)
-              return response.text()
-            })
-          : Bun.file(input.file).text(),
-      catch: (cause) => new Error(`Failed to read session data: ${cause instanceof Error ? cause.message : String(cause)}`),
-    })
-    const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(SessionTransfer.Data))(text)
-    const encoded = Schema.encodeSync(SessionTransfer.Data)(data)
-    const server = yield* ServerConnection.resolve({
-      server: Option.getOrUndefined(input.server),
-      standalone: input.standalone,
-    })
-    const client = OpenCode.make({
-      baseUrl: server.endpoint.url,
-      headers: Service.headers(server.endpoint),
-    })
-    const location = yield* Effect.promise(() =>
-      client.location.get({
-        location: { directory: path.resolve(Option.getOrElse(input.directory, () => process.cwd())) },
-      }),
-    )
-    const response = yield* Effect.promise(() =>
-      fetch(new URL("/api/session/import", server.endpoint.url), {
-        method: "POST",
-        headers: { ...Service.headers(server.endpoint), "content-type": "application/json" },
-        body: JSON.stringify({
-          ...encoded,
-          location: { directory: location.directory, workspaceID: location.workspaceID },
-        }),
-      }),
-    )
-    if (response.status === 409) {
-      process.stderr.write(`Session already exists${EOL}`)
-      return
-    }
-    if (!response.ok) yield* Effect.fail(new Error(`Failed to import session: ${response.statusText}`))
-    const imported = yield* Schema.decodeUnknownEffect(
-      Schema.fromJsonString(Schema.Struct({ data: Session.Info })),
-    )(yield* Effect.promise(() => response.text()))
-    process.stdout.write(`Imported session: ${imported.data.id}${EOL}`)
-  }),
-)

packages/cli/src/index.ts

@@ -37,8 +37,6 @@ const Handlers = Runtime.handlers(Commands, {
     list: () => import("./commands/handlers/plugin/list"),
   },
   models: () => import("./commands/handlers/models"),
-  export: () => import("./commands/handlers/export"),
-  import: () => import("./commands/handlers/import"),
   mini: () => import("./commands/handlers/mini"),
   run: () => import("./commands/handlers/run"),
   pair: () => import("./commands/handlers/pair"),

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

@@ -1,210 +0,0 @@
-import { expect, test } from "bun:test"
-import fs from "node:fs/promises"
-import os from "node:os"
-import path from "node:path"
-import { OPENCODE_VERSION } from "../src/version"
-import { writeExport } from "../src/commands/handlers/export"
-
-const info = {
-  id: "ses_export_test",
-  projectID: "global",
-  cost: 0,
-  tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-  time: { created: 1, updated: 2 },
-  title: "Exported session",
-  location: { directory: "/project" },
-}
-const transfer = {
-  info,
-  messages: [
-    { id: "msg_first", type: "user", text: "First", time: { created: 1 } },
-    { id: "msg_second", type: "user", text: "Second", time: { created: 2 } },
-  ],
-}
-const sanitizedTransfer = {
-  info: {
-    ...info,
-    title: "[redacted:session-title:ses_export_test]",
-    location: { directory: "/[redacted:session-directory:ses_export_test]" },
-  },
-  messages: [
-    {
-      id: "msg_first",
-      type: "user",
-      text: "[redacted:text:msg_first]",
-      time: { created: 1 },
-    },
-    {
-      id: "msg_second",
-      type: "user",
-      text: "[redacted:text:msg_second]",
-      time: { created: 2 },
-    },
-  ],
-}
-
-const health = () => Response.json({ healthy: true, version: OPENCODE_VERSION, pid: process.pid })
-
-function run(args: string[], stdin?: string) {
-  const child = Bun.spawn([process.execPath, "run", "src/index.ts", ...args], {
-    cwd: path.join(import.meta.dir, ".."),
-    stdin: stdin === undefined ? undefined : new Blob([stdin]),
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-  return Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited])
-}
-
-test("export is raw by default and supports explicit sanitization", async () => {
-  const sanitization: string[] = []
-  const server = Bun.serve({
-    port: 0,
-    fetch(request) {
-      const url = new URL(request.url)
-      if (url.pathname === "/api/health") return health()
-      if (url.pathname === `/api/session/${info.id}`) return Response.json({ data: info })
-      if (url.pathname === `/api/session/${info.id}/export`) {
-        sanitization.push(url.searchParams.get("sanitize") ?? "")
-        return Response.json({ data: url.searchParams.get("sanitize") === "true" ? sanitizedTransfer : transfer })
-      }
-      return new Response("Not found", { status: 404 })
-    },
-  })
-
-  try {
-    const [stdout, , exitCode] = await run(["export", "-s", info.id, "--server", server.url.toString()])
-    const exported = JSON.parse(stdout)
-
-    expect(exitCode).toBe(0)
-    expect(exported).toEqual(transfer)
-
-    const [sanitized, , sanitizedExitCode] = await run([
-      "export",
-      "-s",
-      info.id,
-      "--sanitize",
-      "--server",
-      server.url.toString(),
-    ])
-    expect(sanitizedExitCode).toBe(0)
-    expect(JSON.parse(sanitized)).toEqual(sanitizedTransfer)
-    expect(sanitization).toEqual(["false", "true"])
-  } finally {
-    await server.stop(true)
-  }
-}, 15_000)
-
-test("export reports an empty session list without a stack trace", async () => {
-  const server = Bun.serve({
-    port: 0,
-    fetch(request) {
-      const url = new URL(request.url)
-      if (url.pathname === "/api/health") return health()
-      if (url.pathname === "/api/location") {
-        return Response.json({
-          directory: "/project",
-          project: { id: "global", directory: "/project", canonical: "/project" },
-        })
-      }
-      if (url.pathname === "/api/session") return Response.json({ data: [], cursor: {} })
-      return new Response("Not found", { status: 404 })
-    },
-  })
-
-  try {
-    const [stdout, stderr, exitCode] = await run(["export", "--server", server.url.toString()])
-
-    expect(exitCode).toBe(0)
-    expect(stdout).toBe("")
-    expect(stderr).toBe(`No sessions found${os.EOL}`)
-  } finally {
-    await server.stop(true)
-  }
-})
-
-test("interactive export writes a temporary JSON file", async () => {
-  const output = await writeExport(transfer, info.id, false)
-  const file = output.trim()
-
-  try {
-    expect(path.dirname(file)).toBe(os.tmpdir())
-    expect(await Bun.file(file).json()).toEqual(transfer)
-  } finally {
-    await fs.rm(file, { force: true })
-  }
-})
-
-test("import validates a file and sends it to the resolved location", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-import-"))
-  const file = path.join(root, "session.json")
-  await fs.writeFile(file, JSON.stringify(transfer))
-  let imported: unknown
-  const server = Bun.serve({
-    port: 0,
-    async fetch(request) {
-      const url = new URL(request.url)
-      if (url.pathname === "/api/health") return health()
-      if (url.pathname === "/api/location") {
-        return Response.json({
-          directory: root,
-          project: { id: "global", directory: root, canonical: root },
-        })
-      }
-      if (url.pathname === "/api/session/import") {
-        imported = await request.json()
-        return Response.json({ data: { ...info, location: { directory: root } } })
-      }
-      return new Response("Not found", { status: 404 })
-    },
-  })
-
-  try {
-    const [stdout, , exitCode] = await run([
-      "import",
-      file,
-      "--directory",
-      root,
-      "--server",
-      server.url.toString(),
-    ])
-
-    expect(exitCode).toBe(0)
-    expect(stdout).toBe(`Imported session: ${info.id}${os.EOL}`)
-    expect(imported).toEqual({ ...transfer, location: { directory: root } })
-  } finally {
-    await server.stop(true)
-    await fs.rm(root, { recursive: true, force: true })
-  }
-})
-
-test("import reports an existing session without a stack trace", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-import-conflict-"))
-  const file = path.join(root, "session.json")
-  await fs.writeFile(file, JSON.stringify(transfer))
-  const server = Bun.serve({
-    port: 0,
-    fetch(request) {
-      const url = new URL(request.url)
-      if (url.pathname === "/api/health") return health()
-      if (url.pathname === "/api/location") {
-        return Response.json({
-          directory: root,
-          project: { id: "global", directory: root, canonical: root },
-        })
-      }
-      if (url.pathname === "/api/session/import") return new Response("Conflict", { status: 409 })
-      return new Response("Not found", { status: 404 })
-    },
-  })
-
-  try {
-    const [stdout, stderr, exitCode] = await run(["import", file, "--server", server.url.toString()])
-
-    expect(exitCode).toBe(0)
-    expect(stdout).toBe("")
-    expect(stderr).toBe(`Session already exists${os.EOL}`)
-  } finally {
-    await server.stop(true)
-    await fs.rm(root, { recursive: true, force: true })
-  }
-})

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

@@ -127,54 +127,42 @@ export type Endpoint5_1Input = {
 export type Endpoint5_1Output = Session.Info
 export type SessionCreateOperation<E = never> = (input?: Endpoint5_1Input) => Effect.Effect<Endpoint5_1Output, E>
 
-export type Endpoint5_2Input = {
-  readonly info: Session.Info
-  readonly messages: ReadonlyArray<SessionMessage.Info>
-  readonly location?: Location.Ref | undefined
-}
-export type Endpoint5_2Output = Session.Info
-export type SessionImportOperation<E = never> = (input: Endpoint5_2Input) => Effect.Effect<Endpoint5_2Output, E>
+export type Endpoint5_2Output = { readonly [x: Session.ID]: { readonly type: "running" } }
+export type SessionActiveOperation<E = never> = () => Effect.Effect<Endpoint5_2Output, E>
 
-export type Endpoint5_3Input = { readonly sessionID: Session.ID; readonly sanitize?: boolean | undefined }
-export type Endpoint5_3Output = { readonly info: Session.Info; readonly messages: ReadonlyArray<SessionMessage.Info> }
-export type SessionExportOperation<E = never> = (input: Endpoint5_3Input) => Effect.Effect<Endpoint5_3Output, E>
+export type Endpoint5_3Input = { readonly sessionID: Session.ID }
+export type Endpoint5_3Output = Session.Info
+export type SessionGetOperation<E = never> = (input: Endpoint5_3Input) => Effect.Effect<Endpoint5_3Output, E>
 
-export type Endpoint5_4Output = { readonly [x: Session.ID]: { readonly type: "running" } }
-export type SessionActiveOperation<E = never> = () => Effect.Effect<Endpoint5_4Output, E>
+export type Endpoint5_4Input = { readonly sessionID: Session.ID }
+export type Endpoint5_4Output = void
+export type SessionRemoveOperation<E = never> = (input: Endpoint5_4Input) => Effect.Effect<Endpoint5_4Output, E>
 
-export type Endpoint5_5Input = { readonly sessionID: Session.ID }
+export type Endpoint5_5Input = { readonly sessionID: Session.ID; readonly boundary: Session.ForkRequestBoundary }
 export type Endpoint5_5Output = Session.Info
-export type SessionGetOperation<E = never> = (input: Endpoint5_5Input) => Effect.Effect<Endpoint5_5Output, E>
+export type SessionForkOperation<E = never> = (input: Endpoint5_5Input) => Effect.Effect<Endpoint5_5Output, E>
 
-export type Endpoint5_6Input = { readonly sessionID: Session.ID }
+export type Endpoint5_6Input = { readonly sessionID: Session.ID; readonly agent: Agent.ID }
 export type Endpoint5_6Output = void
-export type SessionRemoveOperation<E = never> = (input: Endpoint5_6Input) => Effect.Effect<Endpoint5_6Output, E>
+export type SessionSwitchAgentOperation<E = never> = (input: Endpoint5_6Input) => Effect.Effect<Endpoint5_6Output, E>
 
-export type Endpoint5_7Input = { readonly sessionID: Session.ID; readonly boundary: Session.ForkRequestBoundary }
-export type Endpoint5_7Output = Session.Info
-export type SessionForkOperation<E = never> = (input: Endpoint5_7Input) => Effect.Effect<Endpoint5_7Output, E>
+export type Endpoint5_7Input = { readonly sessionID: Session.ID; readonly model: Model.Ref }
+export type Endpoint5_7Output = void
+export type SessionSwitchModelOperation<E = never> = (input: Endpoint5_7Input) => Effect.Effect<Endpoint5_7Output, E>
 
-export type Endpoint5_8Input = { readonly sessionID: Session.ID; readonly agent: Agent.ID }
+export type Endpoint5_8Input = { readonly sessionID: Session.ID; readonly title: string }
 export type Endpoint5_8Output = void
-export type SessionSwitchAgentOperation<E = never> = (input: Endpoint5_8Input) => Effect.Effect<Endpoint5_8Output, E>
+export type SessionRenameOperation<E = never> = (input: Endpoint5_8Input) => Effect.Effect<Endpoint5_8Output, E>
 
-export type Endpoint5_9Input = { readonly sessionID: Session.ID; readonly model: Model.Ref }
-export type Endpoint5_9Output = void
-export type SessionSwitchModelOperation<E = never> = (input: Endpoint5_9Input) => Effect.Effect<Endpoint5_9Output, E>
-
-export type Endpoint5_10Input = { readonly sessionID: Session.ID; readonly title: string }
-export type Endpoint5_10Output = void
-export type SessionRenameOperation<E = never> = (input: Endpoint5_10Input) => Effect.Effect<Endpoint5_10Output, E>
-
-export type Endpoint5_11Input = {
+export type Endpoint5_9Input = {
   readonly sessionID: Session.ID
   readonly directory: AbsolutePath
   readonly workspaceID?: Workspace.ID | undefined
 }
-export type Endpoint5_11Output = void
-export type SessionMoveOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>
+export type Endpoint5_9Output = void
+export type SessionMoveOperation<E = never> = (input: Endpoint5_9Input) => Effect.Effect<Endpoint5_9Output, E>
 
-export type Endpoint5_12Input = {
+export type Endpoint5_10Input = {
   readonly sessionID: Session.ID
   readonly id?: SessionMessage.ID | undefined
   readonly text: string
@@ -184,10 +172,10 @@ export type Endpoint5_12Input = {
   readonly delivery?: "steer" | "queue" | undefined
   readonly resume?: boolean | undefined
 }
-export type Endpoint5_12Output = SessionPending.User
-export type SessionPromptOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>
+export type Endpoint5_10Output = SessionPending.User
+export type SessionPromptOperation<E = never> = (input: Endpoint5_10Input) => Effect.Effect<Endpoint5_10Output, E>
 
-export type Endpoint5_13Input = {
+export type Endpoint5_11Input = {
   readonly sessionID: Session.ID
   readonly id?: SessionMessage.ID | undefined
   readonly command: string
@@ -199,19 +187,19 @@ export type Endpoint5_13Input = {
   readonly delivery?: "steer" | "queue" | undefined
   readonly resume?: boolean | undefined
 }
-export type Endpoint5_13Output = SessionPending.User
-export type SessionCommandOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>
+export type Endpoint5_11Output = SessionPending.User
+export type SessionCommandOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>
 
-export type Endpoint5_14Input = {
+export type Endpoint5_12Input = {
   readonly sessionID: Session.ID
   readonly id?: SessionMessage.ID | undefined
   readonly skill: Skill.ID
   readonly resume?: boolean | undefined
 }
-export type Endpoint5_14Output = void
-export type SessionSkillOperation<E = never> = (input: Endpoint5_14Input) => Effect.Effect<Endpoint5_14Output, E>
+export type Endpoint5_12Output = void
+export type SessionSkillOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>
 
-export type Endpoint5_15Input = {
+export type Endpoint5_13Input = {
   readonly sessionID: Session.ID
   readonly id?: SessionMessage.ID | undefined
   readonly text: string
@@ -220,81 +208,95 @@ export type Endpoint5_15Input = {
   readonly delivery?: "steer" | "queue" | undefined
   readonly resume?: boolean | undefined
 }
-export type Endpoint5_15Output = SessionPending.Synthetic
-export type SessionSyntheticOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>
+export type Endpoint5_13Output = SessionPending.Synthetic
+export type SessionSyntheticOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>
 
-export type Endpoint5_16Input = {
+export type Endpoint5_14Input = {
   readonly sessionID: Session.ID
   readonly id?: Event.ID | undefined
   readonly command: string
 }
+export type Endpoint5_14Output = void
+export type SessionShellOperation<E = never> = (input: Endpoint5_14Input) => Effect.Effect<Endpoint5_14Output, E>
+
+export type Endpoint5_15Input = { readonly sessionID: Session.ID; readonly id?: SessionMessage.ID | undefined }
+export type Endpoint5_15Output = SessionPending.Compaction
+export type SessionCompactOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>
+
+export type Endpoint5_16Input = { readonly sessionID: Session.ID }
 export type Endpoint5_16Output = void
-export type SessionShellOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>
+export type SessionWaitOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>
 
-export type Endpoint5_17Input = { readonly sessionID: Session.ID; readonly id?: SessionMessage.ID | undefined }
-export type Endpoint5_17Output = SessionPending.Compaction
-export type SessionCompactOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>
-
-export type Endpoint5_18Input = { readonly sessionID: Session.ID }
-export type Endpoint5_18Output = void
-export type SessionWaitOperation<E = never> = (input: Endpoint5_18Input) => Effect.Effect<Endpoint5_18Output, E>
-
-export type Endpoint5_19Input = {
+export type Endpoint5_17Input = {
   readonly sessionID: Session.ID
   readonly messageID: SessionMessage.ID
   readonly files?: boolean | undefined
 }
-export type Endpoint5_19Output = Session.Revert
-export type SessionRevertStageOperation<E = never> = (input: Endpoint5_19Input) => Effect.Effect<Endpoint5_19Output, E>
+export type Endpoint5_17Output = Session.Revert
+export type SessionRevertStageOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>
+
+export type Endpoint5_18Input = { readonly sessionID: Session.ID }
+export type Endpoint5_18Output = void
+export type SessionRevertClearOperation<E = never> = (input: Endpoint5_18Input) => Effect.Effect<Endpoint5_18Output, E>
+
+export type Endpoint5_19Input = { readonly sessionID: Session.ID }
+export type Endpoint5_19Output = void
+export type SessionRevertCommitOperation<E = never> = (input: Endpoint5_19Input) => Effect.Effect<Endpoint5_19Output, E>
 
 export type Endpoint5_20Input = { readonly sessionID: Session.ID }
-export type Endpoint5_20Output = void
-export type SessionRevertClearOperation<E = never> = (input: Endpoint5_20Input) => Effect.Effect<Endpoint5_20Output, E>
+export type Endpoint5_20Output = ReadonlyArray<SessionMessage.Info>
+export type SessionContextOperation<E = never> = (input: Endpoint5_20Input) => Effect.Effect<Endpoint5_20Output, E>
 
 export type Endpoint5_21Input = { readonly sessionID: Session.ID }
-export type Endpoint5_21Output = void
-export type SessionRevertCommitOperation<E = never> = (input: Endpoint5_21Input) => Effect.Effect<Endpoint5_21Output, E>
+export type Endpoint5_21Output = ReadonlyArray<SessionPending.Info>
+export type SessionPendingListOperation<E = never> = (input: Endpoint5_21Input) => Effect.Effect<Endpoint5_21Output, E>
 
-export type Endpoint5_22Input = { readonly sessionID: Session.ID }
-export type Endpoint5_22Output = ReadonlyArray<SessionMessage.Info>
-export type SessionContextOperation<E = never> = (input: Endpoint5_22Input) => Effect.Effect<Endpoint5_22Output, E>
+export type Endpoint5_22Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+export type Endpoint5_22Output = void
+export type SessionPendingCancelOperation<E = never> = (
+  input: Endpoint5_22Input,
+) => Effect.Effect<Endpoint5_22Output, E>
 
-export type Endpoint5_23Input = { readonly sessionID: Session.ID }
-export type Endpoint5_23Output = ReadonlyArray<SessionPending.Info>
-export type SessionPendingListOperation<E = never> = (input: Endpoint5_23Input) => Effect.Effect<Endpoint5_23Output, E>
+export type Endpoint5_23Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+export type Endpoint5_23Output = void
+export type SessionPendingSteerOperation<E = never> = (input: Endpoint5_23Input) => Effect.Effect<Endpoint5_23Output, E>
 
-export type Endpoint5_24Input = { readonly sessionID: Session.ID }
-export type Endpoint5_24Output = ReadonlyArray<InstructionEntry.Info>
+export type Endpoint5_24Input = { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
+export type Endpoint5_24Output = void
+export type SessionPendingQueueOperation<E = never> = (input: Endpoint5_24Input) => Effect.Effect<Endpoint5_24Output, E>
+
+export type Endpoint5_25Input = { readonly sessionID: Session.ID }
+export type Endpoint5_25Output = ReadonlyArray<InstructionEntry.Info>
 export type SessionInstructionsEntryListOperation<E = never> = (
-  input: Endpoint5_24Input,
-) => Effect.Effect<Endpoint5_24Output, E>
+  input: Endpoint5_25Input,
+) => Effect.Effect<Endpoint5_25Output, E>
 
-export type Endpoint5_25Input = {
+export type Endpoint5_26Input = {
   readonly sessionID: Session.ID
   readonly key: InstructionEntry.Key
   readonly value: Schema.Json
 }
-export type Endpoint5_25Output = void
-export type SessionInstructionsEntryPutOperation<E = never> = (
-  input: Endpoint5_25Input,
-) => Effect.Effect<Endpoint5_25Output, E>
-
-export type Endpoint5_26Input = { readonly sessionID: Session.ID; readonly key: InstructionEntry.Key }
 export type Endpoint5_26Output = void
-export type SessionInstructionsEntryRemoveOperation<E = never> = (
+export type SessionInstructionsEntryPutOperation<E = never> = (
   input: Endpoint5_26Input,
 ) => Effect.Effect<Endpoint5_26Output, E>
 
-export type Endpoint5_27Input = { readonly sessionID: Session.ID; readonly prompt: string }
-export type Endpoint5_27Output = { readonly text: string }
-export type SessionGenerateOperation<E = never> = (input: Endpoint5_27Input) => Effect.Effect<Endpoint5_27Output, E>
+export type Endpoint5_27Input = { readonly sessionID: Session.ID; readonly key: InstructionEntry.Key }
+export type Endpoint5_27Output = void
+export type SessionInstructionsEntryRemoveOperation<E = never> = (
+  input: Endpoint5_27Input,
+) => Effect.Effect<Endpoint5_27Output, E>
 
-export type Endpoint5_28Input = {
+export type Endpoint5_28Input = { readonly sessionID: Session.ID; readonly prompt: string }
+export type Endpoint5_28Output = { readonly text: string }
+export type SessionGenerateOperation<E = never> = (input: Endpoint5_28Input) => Effect.Effect<Endpoint5_28Output, E>
+
+export type Endpoint5_29Input = {
   readonly sessionID: Session.ID
   readonly after?: Event.Seq | undefined
   readonly follow?: boolean | undefined
 }
-export type Endpoint5_28Output =
+export type Endpoint5_29Output =
   | (
       | {
           readonly id: Event.ID
@@ -404,6 +406,33 @@ export type Endpoint5_28Output =
             readonly input: SessionPending.Message
           }
         }
+      | {
+          readonly id: Event.ID
+          readonly created: DateTime.Utc
+          readonly metadata?: { readonly [x: string]: unknown } | undefined
+          readonly type: "session.input.cancelled"
+          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 inputID: SessionMessage.ID }
+        }
+      | {
+          readonly id: Event.ID
+          readonly created: DateTime.Utc
+          readonly metadata?: { readonly [x: string]: unknown } | undefined
+          readonly type: "session.input.steered"
+          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 inputID: SessionMessage.ID }
+        }
+      | {
+          readonly id: Event.ID
+          readonly created: DateTime.Utc
+          readonly metadata?: { readonly [x: string]: unknown } | undefined
+          readonly type: "session.input.queued"
+          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 inputID: SessionMessage.ID }
+        }
       | {
           readonly id: Event.ID
           readonly created: DateTime.Utc
@@ -862,25 +891,23 @@ export type Endpoint5_28Output =
         }
     )
   | EventLog.Synced
-export type SessionLogOperation<E = never> = (input: Endpoint5_28Input) => Stream.Stream<Endpoint5_28Output, E>
-
-export type Endpoint5_29Input = { readonly sessionID: Session.ID }
-export type Endpoint5_29Output = void
-export type SessionInterruptOperation<E = never> = (input: Endpoint5_29Input) => Effect.Effect<Endpoint5_29Output, E>
+export type SessionLogOperation<E = never> = (input: Endpoint5_29Input) => Stream.Stream<Endpoint5_29Output, E>
 
 export type Endpoint5_30Input = { readonly sessionID: Session.ID }
 export type Endpoint5_30Output = void
-export type SessionBackgroundOperation<E = never> = (input: Endpoint5_30Input) => Effect.Effect<Endpoint5_30Output, E>
+export type SessionInterruptOperation<E = never> = (input: Endpoint5_30Input) => Effect.Effect<Endpoint5_30Output, E>
 
-export type Endpoint5_31Input = { readonly sessionID: Session.ID; readonly messageID: SessionMessage.ID }
-export type Endpoint5_31Output = SessionMessage.Info
-export type SessionMessageOperation<E = never> = (input: Endpoint5_31Input) => Effect.Effect<Endpoint5_31Output, E>
+export type Endpoint5_31Input = { readonly sessionID: Session.ID }
+export type Endpoint5_31Output = void
+export type SessionBackgroundOperation<E = never> = (input: Endpoint5_31Input) => Effect.Effect<Endpoint5_31Output, E>
+
+export type Endpoint5_32Input = { readonly sessionID: Session.ID; readonly messageID: SessionMessage.ID }
+export type Endpoint5_32Output = SessionMessage.Info
+export type SessionMessageOperation<E = never> = (input: Endpoint5_32Input) => Effect.Effect<Endpoint5_32Output, E>
 
 export interface SessionApi<E = never> {
   readonly list: SessionListOperation<E>
   readonly create: SessionCreateOperation<E>
-  readonly import: SessionImportOperation<E>
-  readonly export: SessionExportOperation<E>
   readonly active: SessionActiveOperation<E>
   readonly get: SessionGetOperation<E>
   readonly remove: SessionRemoveOperation<E>
@@ -902,7 +929,12 @@ export interface SessionApi<E = never> {
     readonly commit: SessionRevertCommitOperation<E>
   }
   readonly context: SessionContextOperation<E>
-  readonly pending: { readonly list: SessionPendingListOperation<E> }
+  readonly pending: {
+    readonly list: SessionPendingListOperation<E>
+    readonly cancel: SessionPendingCancelOperation<E>
+    readonly steer: SessionPendingSteerOperation<E>
+    readonly queue: SessionPendingQueueOperation<E>
+  }
   readonly instructions: {
     readonly entry: {
       readonly list: SessionInstructionsEntryListOperation<E>

packages/client/src/effect/generated/client.ts

@@ -21,10 +21,10 @@ import type {
   Endpoint5_0Output,
   Endpoint5_1Input,
   Endpoint5_1Output,
-  Endpoint5_2Input,
   Endpoint5_2Output,
   Endpoint5_3Input,
   Endpoint5_3Output,
+  Endpoint5_4Input,
   Endpoint5_4Output,
   Endpoint5_5Input,
   Endpoint5_5Output,
@@ -80,6 +80,8 @@ import type {
   Endpoint5_30Output,
   Endpoint5_31Input,
   Endpoint5_31Output,
+  Endpoint5_32Input,
+  Endpoint5_32Output,
   Endpoint6_0Input,
   Endpoint6_0Output,
   Endpoint7_0Input,
@@ -321,11 +323,9 @@ const Endpoint5_1 = (raw: RawClient["server.session"]) => (input?: Endpoint5_1In
     ),
   )
 
-const Endpoint5_2 = (raw: RawClient["server.session"]) => (input: Endpoint5_2Input) =>
+const Endpoint5_2 = (raw: RawClient["server.session"]) => () =>
   preserveEffect<Endpoint5_2Output>()(
-    raw["session.import"]({
-      payload: { info: input["info"], messages: input["messages"], location: input["location"] },
-    }).pipe(
+    raw["session.active"]({}).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
@@ -333,23 +333,20 @@ const Endpoint5_2 = (raw: RawClient["server.session"]) => (input: Endpoint5_2Inp
 
 const Endpoint5_3 = (raw: RawClient["server.session"]) => (input: Endpoint5_3Input) =>
   preserveEffect<Endpoint5_3Output>()(
-    raw["session.export"]({ params: { sessionID: input["sessionID"] }, query: { sanitize: input["sanitize"] } }).pipe(
+    raw["session.get"]({ params: { sessionID: input["sessionID"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
   )
 
-const Endpoint5_4 = (raw: RawClient["server.session"]) => () =>
+const Endpoint5_4 = (raw: RawClient["server.session"]) => (input: Endpoint5_4Input) =>
   preserveEffect<Endpoint5_4Output>()(
-    raw["session.active"]({}).pipe(
-      Effect.mapError(mapClientError),
-      Effect.map((value) => value.data),
-    ),
+    raw["session.remove"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
 const Endpoint5_5 = (raw: RawClient["server.session"]) => (input: Endpoint5_5Input) =>
   preserveEffect<Endpoint5_5Output>()(
-    raw["session.get"]({ params: { sessionID: input["sessionID"] } }).pipe(
+    raw["session.fork"]({ params: { sessionID: input["sessionID"] }, payload: { boundary: input["boundary"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
@@ -357,48 +354,35 @@ const Endpoint5_5 = (raw: RawClient["server.session"]) => (input: Endpoint5_5Inp
 
 const Endpoint5_6 = (raw: RawClient["server.session"]) => (input: Endpoint5_6Input) =>
   preserveEffect<Endpoint5_6Output>()(
-    raw["session.remove"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
+    raw["session.switchAgent"]({ params: { sessionID: input["sessionID"] }, payload: { agent: input["agent"] } }).pipe(
+      Effect.mapError(mapClientError),
+    ),
   )
 
 const Endpoint5_7 = (raw: RawClient["server.session"]) => (input: Endpoint5_7Input) =>
   preserveEffect<Endpoint5_7Output>()(
-    raw["session.fork"]({ params: { sessionID: input["sessionID"] }, payload: { boundary: input["boundary"] } }).pipe(
+    raw["session.switchModel"]({ params: { sessionID: input["sessionID"] }, payload: { model: input["model"] } }).pipe(
       Effect.mapError(mapClientError),
-      Effect.map((value) => value.data),
     ),
   )
 
 const Endpoint5_8 = (raw: RawClient["server.session"]) => (input: Endpoint5_8Input) =>
   preserveEffect<Endpoint5_8Output>()(
-    raw["session.switchAgent"]({ params: { sessionID: input["sessionID"] }, payload: { agent: input["agent"] } }).pipe(
+    raw["session.rename"]({ params: { sessionID: input["sessionID"] }, payload: { title: input["title"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
 
 const Endpoint5_9 = (raw: RawClient["server.session"]) => (input: Endpoint5_9Input) =>
   preserveEffect<Endpoint5_9Output>()(
-    raw["session.switchModel"]({ params: { sessionID: input["sessionID"] }, payload: { model: input["model"] } }).pipe(
-      Effect.mapError(mapClientError),
-    ),
-  )
-
-const Endpoint5_10 = (raw: RawClient["server.session"]) => (input: Endpoint5_10Input) =>
-  preserveEffect<Endpoint5_10Output>()(
-    raw["session.rename"]({ params: { sessionID: input["sessionID"] }, payload: { title: input["title"] } }).pipe(
-      Effect.mapError(mapClientError),
-    ),
-  )
-
-const Endpoint5_11 = (raw: RawClient["server.session"]) => (input: Endpoint5_11Input) =>
-  preserveEffect<Endpoint5_11Output>()(
     raw["session.move"]({
       params: { sessionID: input["sessionID"] },
       payload: { directory: input["directory"], workspaceID: input["workspaceID"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_12 = (raw: RawClient["server.session"]) => (input: Endpoint5_12Input) =>
-  preserveEffect<Endpoint5_12Output>()(
+const Endpoint5_10 = (raw: RawClient["server.session"]) => (input: Endpoint5_10Input) =>
+  preserveEffect<Endpoint5_10Output>()(
     raw["session.prompt"]({
       params: { sessionID: input["sessionID"] },
       payload: {
@@ -416,8 +400,8 @@ const Endpoint5_12 = (raw: RawClient["server.session"]) => (input: Endpoint5_12I
     ),
   )
 
-const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13Input) =>
-  preserveEffect<Endpoint5_13Output>()(
+const Endpoint5_11 = (raw: RawClient["server.session"]) => (input: Endpoint5_11Input) =>
+  preserveEffect<Endpoint5_11Output>()(
     raw["session.command"]({
       params: { sessionID: input["sessionID"] },
       payload: {
@@ -437,16 +421,16 @@ const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13I
     ),
   )
 
-const Endpoint5_14 = (raw: RawClient["server.session"]) => (input: Endpoint5_14Input) =>
-  preserveEffect<Endpoint5_14Output>()(
+const Endpoint5_12 = (raw: RawClient["server.session"]) => (input: Endpoint5_12Input) =>
+  preserveEffect<Endpoint5_12Output>()(
     raw["session.skill"]({
       params: { sessionID: input["sessionID"] },
       payload: { id: input["id"], skill: input["skill"], resume: input["resume"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_15 = (raw: RawClient["server.session"]) => (input: Endpoint5_15Input) =>
-  preserveEffect<Endpoint5_15Output>()(
+const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13Input) =>
+  preserveEffect<Endpoint5_13Output>()(
     raw["session.synthetic"]({
       params: { sessionID: input["sessionID"] },
       payload: {
@@ -463,29 +447,29 @@ const Endpoint5_15 = (raw: RawClient["server.session"]) => (input: Endpoint5_15I
     ),
   )
 
-const Endpoint5_16 = (raw: RawClient["server.session"]) => (input: Endpoint5_16Input) =>
-  preserveEffect<Endpoint5_16Output>()(
+const Endpoint5_14 = (raw: RawClient["server.session"]) => (input: Endpoint5_14Input) =>
+  preserveEffect<Endpoint5_14Output>()(
     raw["session.shell"]({
       params: { sessionID: input["sessionID"] },
       payload: { id: input["id"], command: input["command"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_17 = (raw: RawClient["server.session"]) => (input: Endpoint5_17Input) =>
-  preserveEffect<Endpoint5_17Output>()(
+const Endpoint5_15 = (raw: RawClient["server.session"]) => (input: Endpoint5_15Input) =>
+  preserveEffect<Endpoint5_15Output>()(
     raw["session.compact"]({ params: { sessionID: input["sessionID"] }, payload: { id: input["id"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
   )
 
-const Endpoint5_18 = (raw: RawClient["server.session"]) => (input: Endpoint5_18Input) =>
-  preserveEffect<Endpoint5_18Output>()(
+const Endpoint5_16 = (raw: RawClient["server.session"]) => (input: Endpoint5_16Input) =>
+  preserveEffect<Endpoint5_16Output>()(
     raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_19 = (raw: RawClient["server.session"]) => (input: Endpoint5_19Input) =>
-  preserveEffect<Endpoint5_19Output>()(
+const Endpoint5_17 = (raw: RawClient["server.session"]) => (input: Endpoint5_17Input) =>
+  preserveEffect<Endpoint5_17Output>()(
     raw["session.revert.stage"]({
       params: { sessionID: input["sessionID"] },
       payload: { messageID: input["messageID"], files: input["files"] },
@@ -495,65 +479,86 @@ const Endpoint5_19 = (raw: RawClient["server.session"]) => (input: Endpoint5_19I
     ),
   )
 
-const Endpoint5_20 = (raw: RawClient["server.session"]) => (input: Endpoint5_20Input) =>
-  preserveEffect<Endpoint5_20Output>()(
+const Endpoint5_18 = (raw: RawClient["server.session"]) => (input: Endpoint5_18Input) =>
+  preserveEffect<Endpoint5_18Output>()(
     raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_21 = (raw: RawClient["server.session"]) => (input: Endpoint5_21Input) =>
-  preserveEffect<Endpoint5_21Output>()(
+const Endpoint5_19 = (raw: RawClient["server.session"]) => (input: Endpoint5_19Input) =>
+  preserveEffect<Endpoint5_19Output>()(
     raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_22 = (raw: RawClient["server.session"]) => (input: Endpoint5_22Input) =>
-  preserveEffect<Endpoint5_22Output>()(
+const Endpoint5_20 = (raw: RawClient["server.session"]) => (input: Endpoint5_20Input) =>
+  preserveEffect<Endpoint5_20Output>()(
     raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
   )
 
-const Endpoint5_23 = (raw: RawClient["server.session"]) => (input: Endpoint5_23Input) =>
-  preserveEffect<Endpoint5_23Output>()(
+const Endpoint5_21 = (raw: RawClient["server.session"]) => (input: Endpoint5_21Input) =>
+  preserveEffect<Endpoint5_21Output>()(
     raw["session.pending.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
   )
 
+const Endpoint5_22 = (raw: RawClient["server.session"]) => (input: Endpoint5_22Input) =>
+  preserveEffect<Endpoint5_22Output>()(
+    raw["session.pending.cancel"]({ params: { sessionID: input["sessionID"], inputID: input["inputID"] } }).pipe(
+      Effect.mapError(mapClientError),
+    ),
+  )
+
+const Endpoint5_23 = (raw: RawClient["server.session"]) => (input: Endpoint5_23Input) =>
+  preserveEffect<Endpoint5_23Output>()(
+    raw["session.pending.steer"]({ params: { sessionID: input["sessionID"], inputID: input["inputID"] } }).pipe(
+      Effect.mapError(mapClientError),
+    ),
+  )
+
 const Endpoint5_24 = (raw: RawClient["server.session"]) => (input: Endpoint5_24Input) =>
   preserveEffect<Endpoint5_24Output>()(
+    raw["session.pending.queue"]({ params: { sessionID: input["sessionID"], inputID: input["inputID"] } }).pipe(
+      Effect.mapError(mapClientError),
+    ),
+  )
+
+const Endpoint5_25 = (raw: RawClient["server.session"]) => (input: Endpoint5_25Input) =>
+  preserveEffect<Endpoint5_25Output>()(
     raw["session.instructions.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
   )
 
-const Endpoint5_25 = (raw: RawClient["server.session"]) => (input: Endpoint5_25Input) =>
-  preserveEffect<Endpoint5_25Output>()(
+const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26Input) =>
+  preserveEffect<Endpoint5_26Output>()(
     raw["session.instructions.entry.put"]({
       params: { sessionID: input["sessionID"], key: input["key"] },
       payload: { value: input["value"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26Input) =>
-  preserveEffect<Endpoint5_26Output>()(
+const Endpoint5_27 = (raw: RawClient["server.session"]) => (input: Endpoint5_27Input) =>
+  preserveEffect<Endpoint5_27Output>()(
     raw["session.instructions.entry.remove"]({ params: { sessionID: input["sessionID"], key: input["key"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
 
-const Endpoint5_27 = (raw: RawClient["server.session"]) => (input: Endpoint5_27Input) =>
-  preserveEffect<Endpoint5_27Output>()(
+const Endpoint5_28 = (raw: RawClient["server.session"]) => (input: Endpoint5_28Input) =>
+  preserveEffect<Endpoint5_28Output>()(
     raw["session.generate"]({ params: { sessionID: input["sessionID"] }, payload: { prompt: input["prompt"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
     ),
   )
 
-const Endpoint5_28 = (raw: RawClient["server.session"]) => (input: Endpoint5_28Input) =>
-  preserveStream<Endpoint5_28Output>()(
+const Endpoint5_29 = (raw: RawClient["server.session"]) => (input: Endpoint5_29Input) =>
+  preserveStream<Endpoint5_29Output>()(
     Stream.unwrap(
       raw["session.log"]({
         params: { sessionID: input["sessionID"] },
@@ -565,18 +570,18 @@ const Endpoint5_28 = (raw: RawClient["server.session"]) => (input: Endpoint5_28I
     ),
   )
 
-const Endpoint5_29 = (raw: RawClient["server.session"]) => (input: Endpoint5_29Input) =>
-  preserveEffect<Endpoint5_29Output>()(
-    raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
-  )
-
 const Endpoint5_30 = (raw: RawClient["server.session"]) => (input: Endpoint5_30Input) =>
   preserveEffect<Endpoint5_30Output>()(
-    raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
+    raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
 const Endpoint5_31 = (raw: RawClient["server.session"]) => (input: Endpoint5_31Input) =>
   preserveEffect<Endpoint5_31Output>()(
+    raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
+  )
+
+const Endpoint5_32 = (raw: RawClient["server.session"]) => (input: Endpoint5_32Input) =>
+  preserveEffect<Endpoint5_32Output>()(
     raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(
       Effect.mapError(mapClientError),
       Effect.map((value) => value.data),
@@ -586,32 +591,30 @@ const Endpoint5_31 = (raw: RawClient["server.session"]) => (input: Endpoint5_31I
 const adaptGroup5 = (raw: RawClient["server.session"]) => ({
   list: Endpoint5_0(raw),
   create: Endpoint5_1(raw),
-  import: Endpoint5_2(raw),
-  export: Endpoint5_3(raw),
-  active: Endpoint5_4(raw),
-  get: Endpoint5_5(raw),
-  remove: Endpoint5_6(raw),
-  fork: Endpoint5_7(raw),
-  switchAgent: Endpoint5_8(raw),
-  switchModel: Endpoint5_9(raw),
-  rename: Endpoint5_10(raw),
-  move: Endpoint5_11(raw),
-  prompt: Endpoint5_12(raw),
-  command: Endpoint5_13(raw),
-  skill: Endpoint5_14(raw),
-  synthetic: Endpoint5_15(raw),
-  shell: Endpoint5_16(raw),
-  compact: Endpoint5_17(raw),
-  wait: Endpoint5_18(raw),
-  revert: { stage: Endpoint5_19(raw), clear: Endpoint5_20(raw), commit: Endpoint5_21(raw) },
-  context: Endpoint5_22(raw),
-  pending: { list: Endpoint5_23(raw) },
-  instructions: { entry: { list: Endpoint5_24(raw), put: Endpoint5_25(raw), remove: Endpoint5_26(raw) } },
-  generate: Endpoint5_27(raw),
-  log: Endpoint5_28(raw),
-  interrupt: Endpoint5_29(raw),
-  background: Endpoint5_30(raw),
-  message: Endpoint5_31(raw),
+  active: Endpoint5_2(raw),
+  get: Endpoint5_3(raw),
+  remove: Endpoint5_4(raw),
+  fork: Endpoint5_5(raw),
+  switchAgent: Endpoint5_6(raw),
+  switchModel: Endpoint5_7(raw),
+  rename: Endpoint5_8(raw),
+  move: Endpoint5_9(raw),
+  prompt: Endpoint5_10(raw),
+  command: Endpoint5_11(raw),
+  skill: Endpoint5_12(raw),
+  synthetic: Endpoint5_13(raw),
+  shell: Endpoint5_14(raw),
+  compact: Endpoint5_15(raw),
+  wait: Endpoint5_16(raw),
+  revert: { stage: Endpoint5_17(raw), clear: Endpoint5_18(raw), commit: Endpoint5_19(raw) },
+  context: Endpoint5_20(raw),
+  pending: { list: Endpoint5_21(raw), cancel: Endpoint5_22(raw), steer: Endpoint5_23(raw), queue: Endpoint5_24(raw) },
+  instructions: { entry: { list: Endpoint5_25(raw), put: Endpoint5_26(raw), remove: Endpoint5_27(raw) } },
+  generate: Endpoint5_28(raw),
+  log: Endpoint5_29(raw),
+  interrupt: Endpoint5_30(raw),
+  background: Endpoint5_31(raw),
+  message: Endpoint5_32(raw),
 })
 
 const Endpoint6_0 = (raw: RawClient["server.message"]) => (input: Endpoint6_0Input) =>

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

@@ -15,10 +15,6 @@ import type {
   SessionListOutput,
   SessionCreateInput,
   SessionCreateOutput,
-  SessionImportInput,
-  SessionImportOutput,
-  SessionExportInput,
-  SessionExportOutput,
   SessionActiveOutput,
   SessionGetInput,
   SessionGetOutput,
@@ -58,6 +54,12 @@ import type {
   SessionContextOutput,
   SessionPendingListInput,
   SessionPendingListOutput,
+  SessionPendingCancelInput,
+  SessionPendingCancelOutput,
+  SessionPendingSteerInput,
+  SessionPendingSteerOutput,
+  SessionPendingQueueInput,
+  SessionPendingQueueOutput,
   SessionInstructionsEntryListInput,
   SessionInstructionsEntryListOutput,
   SessionInstructionsEntryPutInput,
@@ -482,30 +484,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
-      import: (input: SessionImportInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionImportOutput }>(
-          {
-            method: "POST",
-            path: `/api/session/import`,
-            body: { info: input["info"], messages: input["messages"], location: input["location"] },
-            successStatus: 200,
-            declaredStatuses: [409, 401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      export: (input: SessionExportInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionExportOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/export`,
-            query: { sanitize: input["sanitize"] },
-            successStatus: 200,
-            declaredStatuses: [404, 500, 401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
       active: (requestOptions?: RequestOptions) =>
         request<{ readonly data: SessionActiveOutput }>(
           {
@@ -766,6 +744,39 @@ export function make(options: ClientOptions) {
             },
             requestOptions,
           ).then((value) => value.data),
+        cancel: (input: SessionPendingCancelInput, requestOptions?: RequestOptions) =>
+          request<SessionPendingCancelOutput>(
+            {
+              method: "DELETE",
+              path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}`,
+              successStatus: 204,
+              declaredStatuses: [409, 404, 401, 400],
+              empty: true,
+            },
+            requestOptions,
+          ),
+        steer: (input: SessionPendingSteerInput, requestOptions?: RequestOptions) =>
+          request<SessionPendingSteerOutput>(
+            {
+              method: "POST",
+              path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}/steer`,
+              successStatus: 204,
+              declaredStatuses: [409, 404, 401, 400],
+              empty: true,
+            },
+            requestOptions,
+          ),
+        queue: (input: SessionPendingQueueInput, requestOptions?: RequestOptions) =>
+          request<SessionPendingQueueOutput>(
+            {
+              method: "POST",
+              path: `/api/session/${encodeURIComponent(input.sessionID)}/pending/${encodeURIComponent(input.inputID)}/queue`,
+              successStatus: 204,
+              declaredStatuses: [409, 404, 401, 400],
+              empty: true,
+            },
+            requestOptions,
+          ),
       },
       instructions: {
         entry: {

packages/client/test/promise.test.ts

@@ -32,6 +32,7 @@ test("exposes every standard HTTP API group", () => {
     "projectCopy",
     "vcs",
     "debug",
+    "migration",
     "websearch",
     "config",
   ])
@@ -356,6 +357,28 @@ test("session.pending.list uses the public HTTP contract", async () => {
   expect(requests).toEqual([{ method: "GET", url: "http://localhost:3000/api/session/ses_test/pending" }])
 })
 
+test("session.pending mutations use the public HTTP contract", async () => {
+  const requests: Array<{ method: string; url: string }> = []
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async (input, init) => {
+      const request = input instanceof Request ? input : new Request(input, init)
+      requests.push({ method: request.method, url: request.url })
+      return new Response(null, { status: 204 })
+    },
+  })
+
+  await client.session.pending.cancel({ sessionID: "ses_test", inputID: "msg_cancel" })
+  await client.session.pending.steer({ sessionID: "ses_test", inputID: "msg_steer" })
+  await client.session.pending.queue({ sessionID: "ses_test", inputID: "msg_queue" })
+
+  expect(requests).toEqual([
+    { method: "DELETE", url: "http://localhost:3000/api/session/ses_test/pending/msg_cancel" },
+    { method: "POST", url: "http://localhost:3000/api/session/ses_test/pending/msg_steer/steer" },
+    { method: "POST", url: "http://localhost:3000/api/session/ses_test/pending/msg_queue/queue" },
+  ])
+})
+
 test("event.subscribe exposes the Promise event stream wire projection", async () => {
   const client = OpenCode.make({
     baseUrl: "http://localhost:3000",

packages/core/package.json

@@ -17,7 +17,6 @@
     "opencode": "./bin/opencode"
   },
   "exports": {
-    "./environment": "./src/environment/index.ts",
     "./session/runner": "./src/session/runner/index.ts",
     "./instructions": "./src/instructions/index.ts",
     "./*": "./src/*.ts"

packages/core/src/config.ts

@@ -24,7 +24,8 @@ import { Global } from "@opencode-ai/util/global"
 import { Location } from "./location"
 import { AbsolutePath } from "./schema"
 import { ConfigVariable } from "./config/variable"
-import { ConfigNormalize } from "./config/normalize"
+import { ConfigV1 } from "./v1/config/config"
+import { ConfigMigrateV1 } from "./v1/config/migrate"
 import { WellKnown } from "./wellknown"
 
 export function latest<K extends keyof Info>(entries: readonly Entry[], key: K): Info[K] | undefined {
@@ -92,43 +93,24 @@ export const layer = (options?: Options) => Layer.effect(
     const reloadLock = Semaphore.makeUnsafe(1)
     const decodeOptions = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" } as const
     const decodeInfo = Schema.decodeUnknownOption(Info, decodeOptions)
-    const parseInfo = Effect.fn("Config.parseInfo")(function* (text: string, source: string) {
+    const decodeV1Info = Schema.decodeUnknownOption(ConfigV1.Info, decodeOptions)
+
+    const parseInfo = (text: string) => {
       const errors: ParseError[] = []
       const input: unknown = parse(text, errors, { allowTrailingComma: true })
-      if (errors.length) {
-        yield* Effect.logWarning("configuration normalization diagnostic", {
-          source,
-          path: "$",
-          kind: "invalid",
-          action: "rejected malformed JSON or JSONC document",
-        })
-        return
-      }
-      const result = ConfigNormalize.normalize(input)
-      yield* Effect.forEach(result.diagnostics, (diagnostic) =>
-        Effect.logWarning("configuration normalization diagnostic", {
-          source,
-          path: diagnostic.path[0] === "$" ? "$" : `$.${diagnostic.path.join(".")}`,
-          kind: diagnostic.kind,
-          action: diagnostic.message,
-        }),
+      if (errors.length) return
+      return Option.getOrUndefined(
+        ConfigMigrateV1.isV1(input)
+          ? decodeV1Info(input).pipe(Option.map(ConfigMigrateV1.migrate), Option.flatMap(decodeInfo))
+          : decodeInfo(input),
       )
-      if (result.type === "rejected") return
-      const info = Option.getOrUndefined(decodeInfo(result.encoded))
-      if (info) return info
-      yield* Effect.logWarning("configuration normalization diagnostic", {
-        source,
-        path: "$",
-        kind: "invalid",
-        action: "rejected canonical configuration after final validation",
-      })
-    })
+    }
 
     const loadFile = Effect.fnUntraced(function* (filepath: string) {
       const text = yield* fs.readFileStringSafe(filepath)
-      if (text === undefined) return
+      if (!text) return
       const substituted = yield* ConfigVariable.substitute({ type: "path", path: filepath, text })
-      const info = yield* parseInfo(substituted, filepath)
+      const info = parseInfo(substituted)
       if (!info) return
       return new Document({ type: "document", path: filepath, info })
     })
@@ -159,7 +141,7 @@ export const layer = (options?: Options) => Layer.effect(
               text: JSON.stringify(config),
               env: variables,
             }).pipe(
-              Effect.flatMap((text) => parseInfo(text, entry.origin)),
+              Effect.map(parseInfo),
               Effect.map((info) => (info ? new Document({ type: "document", info }) : undefined)),
             ),
           ).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)))
@@ -236,14 +218,14 @@ export const layer = (options?: Options) => Layer.effect(
             Effect.orDie,
           )
         : []
-      const content = options?.content !== undefined
+      const content = options?.content
         ? yield* ConfigVariable.substitute({
             type: "virtual",
             source: "OPENCODE_CONFIG_CONTENT",
             dir: location.directory,
             text: options.content,
           }).pipe(
-            Effect.flatMap((text) => parseInfo(text, "OPENCODE_CONFIG_CONTENT")),
+            Effect.map(parseInfo),
             Effect.map((info) => (info ? [new Document({ type: "document", info })] : [])),
             Effect.orDie,
           )

packages/core/src/config/normalize.ts

@@ -1,796 +0,0 @@
-export * as ConfigNormalize from "./normalize"
-
-import { isDeepStrictEqual } from "node:util"
-import { Option, Schema } from "effect"
-import { Info } from "@opencode-ai/schema/config"
-import { ConfigAgent } from "@opencode-ai/schema/config/agent"
-import { ConfigCommand } from "@opencode-ai/schema/config/command"
-import { ConfigCompaction } from "@opencode-ai/schema/config/compaction"
-import { ConfigFormatter } from "@opencode-ai/schema/config/formatter"
-import { ConfigLSP } from "@opencode-ai/schema/config/lsp"
-import { ConfigMedia } from "@opencode-ai/schema/config/media"
-import { ConfigMCP } from "@opencode-ai/schema/config/mcp"
-import { ConfigPlugin } from "@opencode-ai/schema/config/plugin"
-import { ConfigPolicy } from "@opencode-ai/schema/config/policy"
-import { ConfigProvider } from "@opencode-ai/schema/config/provider"
-import { ConfigReference } from "@opencode-ai/schema/config/reference"
-import { ConfigExperimental } from "@opencode-ai/schema/config/experimental"
-import { Permission } from "@opencode-ai/schema/permission"
-import { ConfigAgentV1 } from "../v1/config/agent"
-import { ConfigAttachmentV1 } from "../v1/config/attachment"
-import { ConfigCommandV1 } from "../v1/config/command"
-import { ConfigMCPV1 } from "../v1/config/mcp"
-import { ConfigPermissionV1 } from "../v1/config/permission"
-import { ConfigPluginV1 } from "../v1/config/plugin"
-import { ConfigProviderV1 } from "../v1/config/provider"
-import { ConfigMigrateV1 } from "../v1/config/migrate"
-import { PositiveInt } from "../schema"
-
-export interface Diagnostic {
-  readonly kind: "conflict" | "invalid" | "unsupported"
-  readonly path: readonly string[]
-  readonly message: string
-}
-
-export type Result =
-  | {
-      readonly type: "normalized"
-      readonly encoded: Readonly<Record<string, unknown>>
-      readonly diagnostics: readonly Diagnostic[]
-    }
-  | { readonly type: "rejected"; readonly diagnostics: readonly Diagnostic[] }
-
-const options = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" } as const
-const unsupportedTopLevel = ["logLevel", "server", "small_model", "subagent_depth", "layout"] as const
-const unsupportedExperimental = [
-  "disable_paste_summary",
-  "batch_tool",
-  "openTelemetry",
-  "primary_tools",
-  "continue_loop_on_deny",
-] as const
-const unsupportedProvider = ["id", "whitelist", "blacklist"] as const
-const unsupportedModel = ["release_date", "attachment", "reasoning", "temperature", "experimental"] as const
-
-export function normalize(input: unknown): Result {
-  if (!isRecord(input))
-    return {
-      type: "rejected",
-      diagnostics: [
-        { kind: "invalid", path: ["$"], message: "rejected configuration because its root is not an object" },
-      ],
-    }
-
-  const diagnostics: Diagnostic[] = []
-  const encoded: Record<string, unknown> = {}
-  unsupportedTopLevel.forEach((key) => unsupportedIfPresent(input, key, [key], diagnostics))
-
-  const legacySnapshots = own(input, "snapshot")
-    ? decodeEncoded(Schema.Boolean, input.snapshot, ["snapshot"], diagnostics)
-    : undefined
-  const legacyShare = own(input, "autoshare")
-    ? decodeValue(Schema.Boolean, input.autoshare, ["autoshare"], diagnostics) === true
-      ? "auto"
-      : undefined
-    : undefined
-  const legacyMedia = own(input, "attachment")
-    ? decodeValue(ConfigAttachmentV1.Info, input.attachment, ["attachment"], diagnostics)
-    : undefined
-  if (legacyMedia !== undefined) {
-    const migrated = ConfigMigrateV1.migrate({ attachment: legacyMedia }).media
-    if (migrated !== undefined) encoded.media = canonical(ConfigMedia.Info, migrated)
-  }
-  if (legacySnapshots !== undefined) encoded.snapshots = legacySnapshots
-  if (legacyShare !== undefined) encoded.share = legacyShare
-
-  const legacyReferences = decodeEncodedMap(input.reference, ConfigReference.Entry, ["reference"], diagnostics)
-  const nativeReferences = decodeEncodedMap(input.references, ConfigReference.Entry, ["references"], diagnostics)
-  mergeMap(
-    encoded,
-    "references",
-    legacyReferences,
-    nativeReferences,
-    isRecord(input.reference) || isRecord(input.references),
-    diagnostics,
-  )
-
-  const legacyCommands = decodeMap(input.command, ConfigCommandV1.Info, ["command"], diagnostics)
-  diagnoseSelectionMap(input.command, ["command"], diagnostics)
-  const migratedCommands = mapValues(legacyCommands, (value) => {
-    const migrated = ConfigMigrateV1.commands({ value })?.value
-    return migrated === undefined ? undefined : canonical(ConfigCommand.Info, migrated)
-  })
-  const nativeCommands = decodeEncodedMap(input.commands, ConfigCommand.Info, ["commands"], diagnostics)
-  mergeMap(
-    encoded,
-    "commands",
-    migratedCommands,
-    nativeCommands,
-    isRecord(input.command) || isRecord(input.commands),
-    diagnostics,
-  )
-
-  const legacyAgents = mapValues(decodeMap(input.agent, ConfigAgentV1.Info, ["agent"], diagnostics), (value) =>
-    canonical(ConfigAgent.Info, ConfigMigrateV1.migrateAgent(value)),
-  )
-  const modeAgents = mapValues(decodeMap(input.mode, ConfigAgentV1.Info, ["mode"], diagnostics), (value) =>
-    canonical(ConfigAgent.Info, ConfigMigrateV1.migrateAgent({ ...value, mode: "primary" })),
-  )
-  const migratedAgents = mergeMaps(legacyAgents, modeAgents, ["agents"], diagnostics)
-  const nativeAgents = decodeEncodedMap(input.agents, ConfigAgent.Info, ["agents"], diagnostics)
-  diagnoseAgentUnsupported(input.agent, ["agent"], diagnostics)
-  diagnoseAgentUnsupported(input.mode, ["mode"], diagnostics)
-  mergeMap(
-    encoded,
-    "agents",
-    migratedAgents,
-    nativeAgents,
-    isRecord(input.agent) || isRecord(input.mode) || isRecord(input.agents),
-    diagnostics,
-  )
-
-  const legacyProviders = migrateProviders(input.provider, diagnostics)
-  const nativeProviders = decodeEncodedMap(input.providers, ConfigProvider.Info, ["providers"], diagnostics)
-  mergeMap(
-    encoded,
-    "providers",
-    legacyProviders,
-    nativeProviders,
-    isRecord(input.provider) || isRecord(input.providers),
-    diagnostics,
-  )
-
-  const toolRules = migrateTools(input.tools, diagnostics)
-  const permissionRules = migratePermissions(input.permission, diagnostics)
-  const nativePermissions = decodeEncodedList(input.permissions, Permission.Rule, ["permissions"], diagnostics)
-  const permissions = [...toolRules, ...permissionRules, ...nativePermissions]
-  if (permissions.length || Array.isArray(input.permissions)) encoded.permissions = permissions
-
-  const legacyPlugins = decodeList(input.plugin, ConfigPluginV1.Spec, ["plugin"], diagnostics).map((plugin) =>
-    typeof plugin === "string" ? plugin : { package: plugin[0], options: plugin[1] },
-  )
-  const nativePlugins = decodeEncodedList(input.plugins, ConfigPlugin.Plugin, ["plugins"], diagnostics)
-  if (legacyPlugins.length || nativePlugins.length || Array.isArray(input.plugin) || Array.isArray(input.plugins))
-    encoded.plugins = [...legacyPlugins, ...nativePlugins]
-
-  normalizeSkills(input, encoded, diagnostics)
-  normalizeMcp(input, encoded, diagnostics)
-  normalizeCompaction(input, encoded, diagnostics)
-  normalizeExperimental(input, encoded, diagnostics)
-  normalizeWatcher(input, encoded, diagnostics)
-  normalizeFormatter(input, encoded, diagnostics)
-  normalizeLsp(input, encoded, diagnostics)
-
-  const nativeAtomic = {
-    $schema: Info.fields.$schema,
-    shell: Info.fields.shell,
-    model: Info.fields.model,
-    default_agent: Info.fields.default_agent,
-    autoupdate: Info.fields.autoupdate,
-    share: Info.fields.share,
-    enterprise: Info.fields.enterprise,
-    username: Info.fields.username,
-    snapshots: Info.fields.snapshots,
-    media: Info.fields.media,
-    tool_output: Info.fields.tool_output,
-    websearch: Info.fields.websearch,
-    warming: Info.fields.warming,
-  }
-  Object.entries(nativeAtomic).forEach(([key, schema]) => {
-    if (!own(input, key)) return
-    const value = decodeEncoded(schema, input[key], [key], diagnostics)
-    if (value === undefined) return
-    overlay(encoded, key, value, [key], diagnostics)
-  })
-
-  const instructions = decodeEncodedList(input.instructions, Schema.String, ["instructions"], diagnostics)
-  if (instructions.length || Array.isArray(input.instructions)) encoded.instructions = instructions
-
-  return { type: "normalized", encoded, diagnostics }
-}
-
-function normalizeSkills(input: Record<string, unknown>, encoded: Record<string, unknown>, diagnostics: Diagnostic[]) {
-  if (!own(input, "skills")) return
-  if (Array.isArray(input.skills)) {
-    encoded.skills = decodeEncodedList(input.skills, Schema.String, ["skills"], diagnostics)
-    return
-  }
-  if (!isRecord(input.skills)) {
-    invalid(["skills"], diagnostics)
-    return
-  }
-  encoded.skills = [
-    ...decodeEncodedList(input.skills.paths, Schema.String, ["skills", "paths"], diagnostics),
-    ...decodeEncodedList(input.skills.urls, Schema.String, ["skills", "urls"], diagnostics),
-  ]
-}
-
-function normalizeMcp(input: Record<string, unknown>, encoded: Record<string, unknown>, diagnostics: Diagnostic[]) {
-  const legacyServers: Record<string, unknown> = {}
-  const nativeServers: Record<string, unknown> = {}
-  const timeout: Record<string, unknown> = {}
-  if (isRecord(input.experimental) && own(input.experimental, "mcp_timeout")) {
-    const value = decodeEncoded(
-      PositiveInt,
-      input.experimental.mcp_timeout,
-      ["experimental", "mcp_timeout"],
-      diagnostics,
-    )
-    if (value !== undefined) {
-      timeout.catalog = value
-      timeout.execution = value
-    }
-  }
-  if (own(input, "mcp")) {
-    if (!isRecord(input.mcp)) invalid(["mcp"], diagnostics)
-    if (isRecord(input.mcp)) {
-      Object.entries(input.mcp).forEach(([name, value]) => {
-        const path = ["mcp", name]
-        if (isEnabledOnlyMcp(value)) {
-          diagnostics.push({ kind: "unsupported", path, message: "omitted enabled-only legacy MCP entry" })
-          return
-        }
-        if (name === "servers" && !isDirectLegacyMcp(value)) {
-          Object.entries(decodeEncodedMap(value, ConfigMCP.Server, path, diagnostics)).forEach(([key, server]) =>
-            setOwn(nativeServers, key, server),
-          )
-          return
-        }
-        if (name === "timeout" && !isDirectLegacyMcp(value)) {
-          normalizeMcpTimeout(value, timeout, path, diagnostics)
-          return
-        }
-        const server = decodeValue(ConfigMCPV1.Info, value, path, diagnostics)
-        if (server !== undefined)
-          setOwn(legacyServers, name, canonical(ConfigMCP.Server, ConfigMigrateV1.migrateMcp(server)))
-      })
-    }
-  }
-  const servers = mergeMaps(legacyServers, nativeServers, ["mcp", "servers"], diagnostics)
-  if (!Object.keys(servers).length && !Object.keys(timeout).length) {
-    if (isRecord(input.mcp) && !Object.keys(input.mcp).length) encoded.mcp = {}
-    return
-  }
-  encoded.mcp = {
-    ...(Object.keys(timeout).length ? { timeout } : {}),
-    ...(Object.keys(servers).length ? { servers } : {}),
-  }
-}
-
-function normalizeMcpTimeout(
-  value: unknown,
-  timeout: Record<string, unknown>,
-  path: string[],
-  diagnostics: Diagnostic[],
-) {
-  if (!isRecord(value)) {
-    invalid(path, diagnostics)
-    return
-  }
-  const recognized = ["startup", "catalog", "execution"].filter((key) => own(value, key))
-  if (Object.keys(value).length && !recognized.length) {
-    invalid(path, diagnostics)
-    return
-  }
-  recognized.forEach((key) => {
-    const leaf = decodeEncoded(
-      ConfigMCP.Timeout.fields[key as keyof typeof ConfigMCP.Timeout.fields],
-      value[key],
-      [...path, key],
-      diagnostics,
-    )
-    if (leaf === undefined) return
-    overlay(timeout, key, leaf, [...path, key], diagnostics)
-  })
-}
-
-function normalizeCompaction(
-  input: Record<string, unknown>,
-  encoded: Record<string, unknown>,
-  diagnostics: Diagnostic[],
-) {
-  if (!own(input, "compaction")) return
-  if (!isRecord(input.compaction)) {
-    invalid(["compaction"], diagnostics)
-    return
-  }
-  unsupportedIfPresent(input.compaction, "tail_turns", ["compaction", "tail_turns"], diagnostics)
-  unsupportedIfPresent(input.compaction, "prune", ["compaction", "prune"], diagnostics)
-  const result: Record<string, unknown> = {}
-  if (own(input.compaction, "auto")) {
-    const value = decodeEncoded(
-      ConfigCompaction.Info.fields.auto,
-      input.compaction.auto,
-      ["compaction", "auto"],
-      diagnostics,
-    )
-    if (value !== undefined) result.auto = value
-  }
-  const legacyTokens = own(input.compaction, "preserve_recent_tokens")
-    ? decodeEncoded(
-        ConfigCompaction.Keep.fields.tokens,
-        input.compaction.preserve_recent_tokens,
-        ["compaction", "preserve_recent_tokens"],
-        diagnostics,
-      )
-    : undefined
-  const nativeKeep = isRecord(input.compaction.keep) ? input.compaction.keep : undefined
-  if (own(input.compaction, "keep") && !nativeKeep) invalid(["compaction", "keep"], diagnostics)
-  const nativeTokens =
-    nativeKeep && own(nativeKeep, "tokens")
-      ? decodeEncoded(
-          ConfigCompaction.Keep.fields.tokens,
-          nativeKeep.tokens,
-          ["compaction", "keep", "tokens"],
-          diagnostics,
-        )
-      : undefined
-  const tokens = prefer(legacyTokens, nativeTokens, ["compaction", "keep", "tokens"], diagnostics)
-  if (tokens !== undefined) result.keep = { tokens }
-  const legacyBuffer = own(input.compaction, "reserved")
-    ? decodeEncoded(
-        ConfigCompaction.Info.fields.buffer,
-        input.compaction.reserved,
-        ["compaction", "reserved"],
-        diagnostics,
-      )
-    : undefined
-  const nativeBuffer = own(input.compaction, "buffer")
-    ? decodeEncoded(ConfigCompaction.Info.fields.buffer, input.compaction.buffer, ["compaction", "buffer"], diagnostics)
-    : undefined
-  const buffer = prefer(legacyBuffer, nativeBuffer, ["compaction", "buffer"], diagnostics)
-  if (buffer !== undefined) result.buffer = buffer
-  if (Object.keys(result).length || !Object.keys(input.compaction).length) encoded.compaction = result
-}
-
-function normalizeExperimental(
-  input: Record<string, unknown>,
-  encoded: Record<string, unknown>,
-  diagnostics: Diagnostic[],
-) {
-  const result: Record<string, unknown> = {}
-  const generated: unknown[] = []
-  const enabled = decodeProviderList(input, "enabled_providers", diagnostics)
-  if (enabled.present && (!enabled.nonEmpty || enabled.values.length)) {
-    generated.push({ action: "provider.use", resource: "*", effect: "deny" })
-    generated.push(
-      ...enabled.values.map((resource) => ({
-        action: "provider.use",
-        resource: ConfigMigrateV1.providerID(resource),
-        effect: "allow",
-      })),
-    )
-  }
-  const disabled = decodeProviderList(input, "disabled_providers", diagnostics)
-  generated.push(
-    ...disabled.values.map((resource) => ({
-      action: "provider.use",
-      resource: ConfigMigrateV1.providerID(resource),
-      effect: "deny",
-    })),
-  )
-  const native: unknown[] = []
-  if (own(input, "experimental")) {
-    if (!isRecord(input.experimental)) invalid(["experimental"], diagnostics)
-    if (isRecord(input.experimental)) {
-      const experimental = input.experimental
-      unsupportedExperimental.forEach((key) =>
-        unsupportedIfPresent(experimental, key, ["experimental", key], diagnostics),
-      )
-      if (own(experimental, "subagent_depth")) {
-        const value = decodeEncoded(
-          ConfigExperimental.Info.fields.subagent_depth,
-          experimental.subagent_depth,
-          ["experimental", "subagent_depth"],
-          diagnostics,
-        )
-        if (value !== undefined) result.subagent_depth = value
-      }
-      native.push(
-        ...decodeEncodedList(experimental.policies, ConfigPolicy.Info, ["experimental", "policies"], diagnostics),
-      )
-    }
-  }
-  if (generated.length || native.length || (isRecord(input.experimental) && Array.isArray(input.experimental.policies)))
-    result.policies = [...generated, ...native]
-  if (Object.keys(result).length || (isRecord(input.experimental) && !Object.keys(input.experimental).length))
-    encoded.experimental = result
-}
-
-function normalizeWatcher(input: Record<string, unknown>, encoded: Record<string, unknown>, diagnostics: Diagnostic[]) {
-  if (!own(input, "watcher")) return
-  if (!isRecord(input.watcher)) {
-    invalid(["watcher"], diagnostics)
-    return
-  }
-  const ignore = decodeEncodedList(input.watcher.ignore, Schema.String, ["watcher", "ignore"], diagnostics)
-  encoded.watcher = ignore.length || Array.isArray(input.watcher.ignore) ? { ignore } : {}
-}
-
-function normalizeFormatter(
-  input: Record<string, unknown>,
-  encoded: Record<string, unknown>,
-  diagnostics: Diagnostic[],
-) {
-  if (!own(input, "formatter")) return
-  if (typeof input.formatter === "boolean") {
-    const value = decodeEncoded(ConfigFormatter.Info, input.formatter, ["formatter"], diagnostics)
-    if (value !== undefined) encoded.formatter = value
-    return
-  }
-  const entries = decodeEncodedMap(input.formatter, ConfigFormatter.Entry, ["formatter"], diagnostics)
-  if (isRecord(input.formatter) && (!Object.keys(input.formatter).length || Object.keys(entries).length))
-    encoded.formatter = entries
-}
-
-function normalizeLsp(input: Record<string, unknown>, encoded: Record<string, unknown>, diagnostics: Diagnostic[]) {
-  if (!own(input, "lsp")) return
-  if (typeof input.lsp === "boolean") {
-    const value = decodeEncoded(ConfigLSP.Info, input.lsp, ["lsp"], diagnostics)
-    if (value !== undefined) encoded.lsp = value
-    return
-  }
-  const entries = decodeEncodedMap(input.lsp, ConfigLSP.Entry, ["lsp"], diagnostics)
-  if (isRecord(input.lsp) && (!Object.keys(input.lsp).length || Object.keys(entries).length)) encoded.lsp = entries
-}
-
-function migrateTools(value: unknown, diagnostics: Diagnostic[]) {
-  if (value === undefined) return []
-  if (!isRecord(value)) {
-    invalid(["tools"], diagnostics)
-    return []
-  }
-  return Object.entries(value).flatMap(([action, raw]) => {
-    const enabled = decodeValue(Schema.Boolean, raw, ["tools", action], diagnostics)
-    if (enabled === undefined) return []
-    return [{ action: ConfigMigrateV1.normalizeAction(action), resource: "*", effect: enabled ? "allow" : "deny" }]
-  })
-}
-
-function migratePermissions(value: unknown, diagnostics: Diagnostic[]) {
-  if (value === undefined) return []
-  if (typeof value === "string") {
-    const effect = decodeValue(ConfigPermissionV1.Action, value, ["permission"], diagnostics)
-    return effect === undefined ? [] : [{ action: "*", resource: "*", effect }]
-  }
-  if (!isRecord(value)) {
-    invalid(["permission"], diagnostics)
-    return []
-  }
-  return Object.entries(value).flatMap(([action, raw]) => {
-    if (typeof raw === "string") {
-      const effect = decodeValue(ConfigPermissionV1.Action, raw, ["permission", action], diagnostics)
-      return effect === undefined ? [] : [{ action: ConfigMigrateV1.normalizeAction(action), resource: "*", effect }]
-    }
-    if (!isRecord(raw)) {
-      invalid(["permission", action], diagnostics)
-      return []
-    }
-    return Object.entries(raw).flatMap(([resource, effect], index) => {
-      const decoded = decodeValue(ConfigPermissionV1.Action, effect, ["permission", action, String(index)], diagnostics)
-      return decoded === undefined
-        ? []
-        : [{ action: ConfigMigrateV1.normalizeAction(action), resource, effect: decoded }]
-    })
-  })
-}
-
-function migrateProviders(value: unknown, diagnostics: Diagnostic[]) {
-  if (value === undefined) return {}
-  if (!isRecord(value)) {
-    invalid(["provider"], diagnostics)
-    return {}
-  }
-  const candidates = Object.entries(value).flatMap(([name, raw]) => {
-    const path = ["provider", name]
-    diagnoseProviderUnsupported(raw, path, diagnostics)
-    if (invalidProviderOverlays(raw, path, diagnostics)) return []
-    const provider = decodeValue(ConfigProviderV1.Info, raw, path, diagnostics)
-    if (provider === undefined) return []
-    const destination = ConfigMigrateV1.providerID(name)
-    return [
-      {
-        name,
-        destination,
-        provider: canonical(ConfigProvider.Info, ConfigMigrateV1.migrateProvider(name, provider)),
-      },
-    ]
-  })
-  const current = new Set(candidates.filter((item) => item.name === item.destination).map((item) => item.destination))
-  const result: Record<string, unknown> = {}
-  candidates.forEach((item) => {
-    if (item.name !== item.destination && current.has(item.destination)) return
-    setOwn(result, item.destination, item.provider)
-  })
-  return result
-}
-
-function invalidProviderOverlays(value: unknown, path: string[], diagnostics: Diagnostic[]) {
-  if (!isRecord(value) || !isRecord(value.options)) return false
-  const headersInvalid =
-    own(value.options, "headers") &&
-    (!isPlainRecord(value.options.headers) ||
-      Object.values(value.options.headers).some((item) => typeof item !== "string"))
-  const bodyInvalid = own(value.options, "body") && !isPlainRecord(value.options.body)
-  if (headersInvalid) invalid([...path, "options", "headers"], diagnostics)
-  if (bodyInvalid) invalid([...path, "options", "body"], diagnostics)
-  return headersInvalid || bodyInvalid
-}
-
-function diagnoseProviderUnsupported(value: unknown, path: string[], diagnostics: Diagnostic[]) {
-  if (!isRecord(value)) return
-  unsupportedProvider.forEach((key) => unsupportedIfPresent(value, key, [...path, key], diagnostics))
-  if (!isRecord(value.models)) return
-  Object.entries(value.models).forEach(([name, model]) => {
-    if (!isRecord(model)) return
-    unsupportedModel.forEach((key) => unsupportedIfPresent(model, key, [...path, "models", name, key], diagnostics))
-    if (own(model, "status") && model.status !== "deprecated")
-      unsupportedIfPresent(model, "status", [...path, "models", name, "status"], diagnostics)
-    if (own(model, "interleaved") && typeof model.interleaved === "boolean")
-      unsupportedIfPresent(model, "interleaved", [...path, "models", name, "interleaved"], diagnostics)
-  })
-}
-
-function diagnoseAgentUnsupported(value: unknown, path: string[], diagnostics: Diagnostic[]) {
-  if (!isRecord(value)) return
-  Object.entries(value).forEach(([name, agent]) => {
-    if (!isRecord(agent)) return
-    unsupportedIfPresent(agent, "name", [...path, name, "name"], diagnostics)
-    diagnoseSelection(agent, [...path, name], diagnostics)
-  })
-}
-
-function diagnoseSelectionMap(value: unknown, path: string[], diagnostics: Diagnostic[]) {
-  if (!isRecord(value)) return
-  Object.entries(value).forEach(([name, entry]) => {
-    if (isRecord(entry)) diagnoseSelection(entry, [...path, name], diagnostics)
-  })
-}
-
-function diagnoseSelection(value: Record<string, unknown>, path: string[], diagnostics: Diagnostic[]) {
-  const modelValid = typeof value.model === "string" && /^[^/#]+\/[^#]+$/.test(value.model)
-  if (own(value, "model") && typeof value.model === "string" && !modelValid)
-    diagnostics.push({
-      kind: "unsupported",
-      path: [...path, "model"],
-      message: "omitted unsupported legacy model reference",
-    })
-  if (
-    own(value, "variant") &&
-    typeof value.variant === "string" &&
-    (!modelValid || value.variant.length === 0 || value.variant.includes("#"))
-  )
-    diagnostics.push({
-      kind: "unsupported",
-      path: [...path, "variant"],
-      message: "omitted unsupported legacy model variant",
-    })
-}
-
-function decodeProviderList(
-  input: Record<string, unknown>,
-  key: "enabled_providers" | "disabled_providers",
-  diagnostics: Diagnostic[],
-) {
-  if (!own(input, key)) return { present: false, nonEmpty: false, values: [] as string[] }
-  if (!Array.isArray(input[key])) {
-    invalid([key], diagnostics)
-    return { present: true, nonEmpty: true, values: [] as string[] }
-  }
-  return {
-    present: true,
-    nonEmpty: input[key].length > 0,
-    values: decodeList(input[key], Schema.String, [key], diagnostics),
-  }
-}
-
-function decodeEncodedMap<S extends Schema.Codec<unknown, unknown, never, never>>(
-  value: unknown,
-  schema: S,
-  path: string[],
-  diagnostics: Diagnostic[],
-) {
-  if (value === undefined) return {}
-  if (!isRecord(value)) {
-    invalid(path, diagnostics)
-    return {}
-  }
-  return Object.fromEntries(
-    Object.entries(value).flatMap(([name, raw]) => {
-      const decoded = decodeEncoded(schema, raw, [...path, name], diagnostics)
-      return decoded === undefined ? [] : [[name, decoded]]
-    }),
-  )
-}
-
-function decodeMap<S extends Schema.Codec<unknown, unknown, never, never>>(
-  value: unknown,
-  schema: S,
-  path: string[],
-  diagnostics: Diagnostic[],
-) {
-  if (value === undefined) return {} as Record<string, S["Type"]>
-  if (!isRecord(value)) {
-    invalid(path, diagnostics)
-    return {} as Record<string, S["Type"]>
-  }
-  return Object.fromEntries(
-    Object.entries(value).flatMap(([name, raw]) => {
-      const decoded = decodeValue(schema, raw, [...path, name], diagnostics)
-      return decoded === undefined ? [] : [[name, decoded]]
-    }),
-  ) as Record<string, S["Type"]>
-}
-
-function decodeEncodedList<S extends Schema.Codec<unknown, unknown, never, never>>(
-  value: unknown,
-  schema: S,
-  path: string[],
-  diagnostics: Diagnostic[],
-) {
-  if (value === undefined) return [] as S["Encoded"][]
-  if (!Array.isArray(value)) {
-    invalid(path, diagnostics)
-    return [] as S["Encoded"][]
-  }
-  return value.flatMap((item, index) => {
-    const decoded = decodeEncoded(schema, item, [...path, String(index)], diagnostics)
-    return decoded === undefined ? [] : [decoded]
-  })
-}
-
-function decodeList<S extends Schema.Codec<unknown, unknown, never, never>>(
-  value: unknown,
-  schema: S,
-  path: string[],
-  diagnostics: Diagnostic[],
-) {
-  if (value === undefined) return [] as S["Type"][]
-  if (!Array.isArray(value)) {
-    invalid(path, diagnostics)
-    return [] as S["Type"][]
-  }
-  return value.flatMap((item, index) => {
-    const decoded = decodeValue(schema, item, [...path, String(index)], diagnostics)
-    return decoded === undefined ? [] : [decoded]
-  })
-}
-
-function decodeValue<S extends Schema.Codec<unknown, unknown, never, never>>(
-  schema: S,
-  value: unknown,
-  path: string[],
-  diagnostics: Diagnostic[],
-) {
-  const decoded = Schema.decodeUnknownOption(schema, options)(value)
-  if (Option.isSome(decoded)) return decoded.value
-  invalid(path, diagnostics)
-  return undefined
-}
-
-function decodeEncoded<S extends Schema.Codec<unknown, unknown, never, never>>(
-  schema: S,
-  value: unknown,
-  path: string[],
-  diagnostics: Diagnostic[],
-) {
-  const decoded = Schema.decodeUnknownOption(schema, options)(value)
-  if (Option.isNone(decoded)) {
-    invalid(path, diagnostics)
-    return undefined
-  }
-  const encoded = Schema.encodeUnknownOption(schema, options)(decoded.value)
-  if (Option.isSome(encoded)) return plain(encoded.value)
-  invalid(path, diagnostics)
-  return undefined
-}
-
-function canonical<S extends Schema.Codec<unknown, unknown, never, never>>(schema: S, value: unknown) {
-  return plain(
-    Option.getOrThrow(
-      Schema.decodeUnknownOption(
-        schema,
-        options,
-      )(plain(value)).pipe(Option.flatMap((decoded) => Schema.encodeUnknownOption(schema, options)(decoded))),
-    ),
-  )
-}
-
-function plain(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map(plain)
-  if (!isRecord(value)) return value
-  return Object.fromEntries(
-    Object.entries(value).flatMap(([key, item]) => (item === undefined ? [] : [[key, plain(item)]])),
-  )
-}
-
-function mergeMap(
-  target: Record<string, unknown>,
-  key: string,
-  legacy: Readonly<Record<string, unknown>>,
-  native: Readonly<Record<string, unknown>>,
-  present: boolean,
-  diagnostics: Diagnostic[],
-) {
-  const merged = mergeMaps(legacy, native, [key], diagnostics)
-  if (present) target[key] = merged
-}
-
-function mergeMaps(
-  legacy: Readonly<Record<string, unknown>>,
-  native: Readonly<Record<string, unknown>>,
-  path: string[],
-  diagnostics: Diagnostic[],
-) {
-  const result = Object.fromEntries(Object.entries(legacy))
-  Object.entries(native).forEach(([name, value]) => {
-    if (own(result, name) && !isDeepStrictEqual(result[name], value)) conflict([...path, name], diagnostics)
-    setOwn(result, name, value)
-  })
-  return result
-}
-
-function mapValues<A>(input: Readonly<Record<string, A>>, map: (value: A) => unknown) {
-  return Object.fromEntries(
-    Object.entries(input).flatMap(([key, value]) => {
-      const mapped = map(value)
-      return mapped === undefined ? [] : [[key, mapped]]
-    }),
-  )
-}
-
-function overlay(
-  target: Record<string, unknown>,
-  key: string,
-  value: unknown,
-  path: string[],
-  diagnostics: Diagnostic[],
-) {
-  if (own(target, key) && !isDeepStrictEqual(target[key], value)) conflict(path, diagnostics)
-  target[key] = value
-}
-
-function prefer(legacy: unknown, native: unknown, path: string[], diagnostics: Diagnostic[]) {
-  if (native === undefined) return legacy
-  if (legacy !== undefined && !isDeepStrictEqual(legacy, native)) conflict(path, diagnostics)
-  return native
-}
-
-function unsupportedIfPresent(value: Record<string, unknown>, key: string, path: string[], diagnostics: Diagnostic[]) {
-  if (!own(value, key)) return
-  diagnostics.push({ kind: "unsupported", path, message: "omitted unsupported legacy setting" })
-}
-
-function invalid(path: string[], diagnostics: Diagnostic[]) {
-  diagnostics.push({ kind: "invalid", path, message: "skipped malformed recognized value" })
-}
-
-function conflict(path: string[], diagnostics: Diagnostic[]) {
-  diagnostics.push({ kind: "conflict", path, message: "retained native value over legacy value" })
-}
-
-function isDirectLegacyMcp(value: unknown) {
-  return isRecord(value) && (value.type === "local" || value.type === "remote")
-}
-
-function isEnabledOnlyMcp(value: unknown) {
-  return isRecord(value) && !own(value, "type") && typeof value.enabled === "boolean"
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-function isPlainRecord(value: unknown): value is Record<string, unknown> {
-  if (!isRecord(value)) return false
-  const prototype = Object.getPrototypeOf(value)
-  return prototype === Object.prototype || prototype === null
-}
-
-function own(value: Record<string, unknown>, key: string) {
-  return Object.prototype.hasOwnProperty.call(value, key)
-}
-
-function setOwn(value: Record<string, unknown>, key: string, item: unknown) {
-  Object.defineProperty(value, key, { value: item, enumerable: true, configurable: true, writable: true })
-}

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

@@ -161,14 +161,11 @@ function isPathAction(action: string): action is PathAction {
 }
 
 function expandHome(resource: string, home: string) {
+  if (resource.startsWith("~/")) return home + resource.slice(1)
   if (resource === "~") return home
   if (resource === "$HOME") return home
-  const relative = resource.startsWith("~/")
-    ? resource.slice(2)
-    : resource.startsWith("$HOME/") || resource.startsWith("$HOME\\")
-      ? resource.slice(6)
-      : undefined
-  if (relative !== undefined) return (path.posix.isAbsolute(home) ? path.posix : path.win32).join(home, relative)
+  if (resource.startsWith("$HOME/")) return home + resource.slice(5)
+  if (resource.startsWith("$HOME\\")) return home + resource.slice(5)
   return resource
 }
 

packages/core/src/environment/driver.ts

@@ -1,9 +0,0 @@
-import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-import type { FilesImpl } from "./files"
-
-export interface Driver {
-  readonly spawner: ChildProcessSpawner["Service"]
-  readonly overrides?: Partial<FilesImpl>
-}
-
-export * as EnvironmentDriver from "./driver"

packages/core/src/environment/exec-defaults.ts

@@ -1,185 +0,0 @@
-import { Effect, Stream } from "effect"
-import { ChildProcess } from "effect/unstable/process"
-import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-import { collectStream } from "@opencode-ai/util/process"
-import { Failed, NotFound, WrongKind, type FileInfo, type FileType, type FilesImpl } from "./files"
-
-const MAX_DATA_BYTES = 64 * 1024 * 1024
-const MAX_ERROR_BYTES = 64 * 1024
-const NOT_FOUND = 44
-const WRONG_KIND = 45
-const FAILED = 46
-
-const loadMetadata = (flags = "") => `
-metadata=$(stat ${flags} -c '%F\t%s\t%Y' -- "$1" 2>&1) || {
-  case "$metadata" in
-    *'No such file or directory'*|*'Not a directory'*) exit ${NOT_FOUND} ;;
-    *) printf '%s' "$metadata" >&2; exit ${FAILED} ;;
-  esac
-}
-`
-
-const statScript = `
-${loadMetadata()}
-printf '%s\n' "$metadata"
-`
-
-const readScript = `
-${loadMetadata("-L")}
-kind=\${metadata%%	*}
-if [ "$kind" != 'regular file' ] && [ "$kind" != 'regular empty file' ]; then
-  printf '%s' "$kind" >&2
-  exit ${WRONG_KIND}
-fi
-printf '%s\n' "$metadata"
-if [ "$2" = range ]; then
-  dd if="$1" iflag=skip_bytes,count_bytes skip="$3" count="$4" status=none
-else
-  cat -- "$1"
-fi
-`
-
-const listScript = `
-${loadMetadata()}
-kind=\${metadata%%	*}
-if [ "$kind" != directory ]; then
-  printf '%s' "$kind" >&2
-  exit ${WRONG_KIND}
-fi
-find "$1" -mindepth 1 -maxdepth 1 -printf '%y\0%f\0'
-`
-
-interface Result {
-  readonly exitCode: number
-  readonly stdout: Uint8Array
-  readonly stderr: Uint8Array
-}
-
-export const execDefaults = (spawner: ChildProcessSpawner["Service"]): FilesImpl => {
-  const run = (
-    path: string,
-    script: string,
-    args: ReadonlyArray<string> = [],
-    stdin?: Uint8Array,
-  ): Effect.Effect<Result, Failed> =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const command = ChildProcess.make("sh", ["-c", script, "sh", path, ...args], {
-          env: { LC_ALL: "C" },
-          extendEnv: true,
-          stdin: stdin === undefined ? undefined : Stream.make(stdin),
-        })
-        const handle = yield* spawner.spawn(command).pipe(Effect.mapError((cause) => new Failed({ path, cause })))
-        const [stdout, stderr, exitCode] = yield* Effect.all(
-          [
-            collectStream(handle.stdout, MAX_DATA_BYTES),
-            collectStream(handle.stderr, MAX_ERROR_BYTES),
-            handle.exitCode,
-          ],
-          { concurrency: "unbounded" },
-        ).pipe(Effect.mapError((cause) => new Failed({ path, cause })))
-        if (stdout.truncated || stderr.truncated) {
-          return yield* new Failed({ path, cause: new Error("Process output exceeded its collection limit") })
-        }
-        return { exitCode, stdout: stdout.buffer, stderr: stderr.buffer }
-      }),
-    )
-
-  const classify = <A>(
-    path: string,
-    result: Result,
-    success: (stdout: Uint8Array) => A,
-  ): Effect.Effect<A, NotFound | WrongKind | Failed> => {
-    if (result.exitCode === 0) return Effect.sync(() => success(result.stdout))
-    if (result.exitCode === NOT_FOUND) return Effect.fail(new NotFound({ path }))
-    if (result.exitCode === WRONG_KIND) {
-      return Effect.fail(new WrongKind({ path, actual: parseType(new TextDecoder().decode(result.stderr)) }))
-    }
-    return Effect.fail(processFailure(path, result))
-  }
-
-  const stat: FilesImpl["stat"] = (path) =>
-    run(path, statScript).pipe(Effect.flatMap((result) => classifyStat(path, result)))
-
-  const complete = (path: string, result: Result) =>
-    result.exitCode === 0 ? Effect.void : Effect.fail(processFailure(path, result))
-
-  return {
-    stat,
-    read: (path, range) =>
-      run(
-        path,
-        readScript,
-        range === undefined ? ["whole"] : ["range", String(range.offset), String(range.length)],
-      ).pipe(
-        Effect.flatMap((result) =>
-          classify(path, result, (stdout) => {
-            const newline = stdout.indexOf(10)
-            if (newline < 0) throw new Error("Missing read metadata header")
-            return {
-              info: parseInfo(stdout.slice(0, newline)),
-              bytes: stdout.slice(newline + 1),
-            }
-          }),
-        ),
-      ),
-    write: (path, bytes) =>
-      run(path, `mkdir -p "$(dirname "$1")" && cat > "$1"`, [], bytes).pipe(
-        Effect.flatMap((result) => complete(path, result)),
-      ),
-    list: (path) => run(path, listScript).pipe(Effect.flatMap((result) => classify(path, result, parseList))),
-    remove: (path) => run(path, `rm -rf -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result))),
-    move: (from, to) =>
-      run(
-        from,
-        `${loadMetadata()}
-mv -- "$1" "$2"`,
-        [to],
-      ).pipe(Effect.flatMap((result) => classifyMove(from, result))),
-    mkdir: (path) => run(path, `mkdir -p -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result))),
-  }
-}
-
-const classifyStat = (path: string, result: Result): Effect.Effect<FileInfo, NotFound | Failed> => {
-  if (result.exitCode === 0) return Effect.sync(() => parseInfo(result.stdout))
-  if (result.exitCode === NOT_FOUND) return Effect.fail(new NotFound({ path }))
-  return Effect.fail(processFailure(path, result))
-}
-
-const classifyMove = (path: string, result: Result): Effect.Effect<void, NotFound | Failed> => {
-  if (result.exitCode === 0) return Effect.void
-  if (result.exitCode === NOT_FOUND) return Effect.fail(new NotFound({ path }))
-  return Effect.fail(processFailure(path, result))
-}
-
-const processFailure = (path: string, result: Result) =>
-  new Failed({
-    path,
-    cause: new Error(new TextDecoder().decode(result.stderr).trim() || `Process exited with code ${result.exitCode}`),
-  })
-
-const parseInfo = (bytes: Uint8Array): FileInfo => {
-  const [rawType, rawSize, rawMtime] = new TextDecoder().decode(bytes).trim().split("\t")
-  const size = Number(rawSize)
-  const mtimeMs = Number(rawMtime) * 1_000
-  if (!rawType || !Number.isFinite(size) || !Number.isFinite(mtimeMs)) throw new Error("Invalid stat output")
-  return { type: parseType(rawType), size, mtimeMs }
-}
-
-const parseType = (value: string): FileType => {
-  if (value === "regular file" || value === "regular empty file" || value === "f") return "file"
-  if (value === "directory" || value === "d") return "directory"
-  if (value === "symbolic link" || value === "l") return "symlink"
-  return "other"
-}
-
-const parseList = (bytes: Uint8Array) => {
-  const fields = new TextDecoder().decode(bytes).split("\0")
-  fields.pop()
-  if (fields.length % 2 !== 0) throw new Error("Invalid find output")
-  return fields
-    .filter((_, index) => index % 2 === 0)
-    .map((type, index) => ({ name: fields[index * 2 + 1], type: parseType(type) }))
-}
-
-export * as EnvironmentExecDefaults from "./exec-defaults"

packages/core/src/environment/files.ts

@@ -1,53 +0,0 @@
-import { Effect, Schema } from "effect"
-
-export const FileType = Schema.Literals(["file", "directory", "symlink", "other"])
-export type FileType = typeof FileType.Type
-
-export interface FileInfo {
-  readonly type: FileType
-  readonly size: number
-  readonly mtimeMs: number
-}
-
-export interface DirEntry {
-  readonly name: string
-  readonly type: FileType
-}
-
-export class NotFound extends Schema.TaggedErrorClass<NotFound>()("Environment.NotFound", {
-  path: Schema.String,
-}) {}
-
-export class WrongKind extends Schema.TaggedErrorClass<WrongKind>()("Environment.WrongKind", {
-  path: Schema.String,
-  actual: FileType,
-}) {}
-
-export class Failed extends Schema.TaggedErrorClass<Failed>()("Environment.Failed", {
-  path: Schema.String,
-  cause: Schema.Defect(),
-}) {}
-
-export interface FilesImpl {
-  /**
-   * Reads a file, following a final symlink so `info` describes the target whose bytes are returned.
-   * The process-backed default caps collected output at 64 MiB; larger whole-file reads fail with
-   * `Failed`, so callers must use ranges for larger files.
-   */
-  readonly read: (
-    path: string,
-    range?: { readonly offset: number; readonly length: number },
-  ) => Effect.Effect<{ readonly info: FileInfo; readonly bytes: Uint8Array }, NotFound | WrongKind | Failed>
-  readonly write: (path: string, bytes: Uint8Array) => Effect.Effect<void, Failed>
-  /** Describes the path entry itself, so a final symlink is reported as `symlink` rather than followed. */
-  readonly stat: (path: string) => Effect.Effect<FileInfo, NotFound | Failed>
-  /** Lists a directory entry without following a final symlink; intermediate symlinks are traversed. */
-  readonly list: (path: string) => Effect.Effect<ReadonlyArray<DirEntry>, NotFound | WrongKind | Failed>
-  readonly remove: (path: string) => Effect.Effect<void, Failed>
-  readonly move: (from: string, to: string) => Effect.Effect<void, NotFound | Failed>
-  readonly mkdir: (path: string) => Effect.Effect<void, Failed>
-}
-
-export interface Files extends FilesImpl {}
-
-export * as EnvironmentFiles from "./files"

packages/core/src/environment/index.ts

@@ -1,24 +0,0 @@
-export * as Environment from "./index"
-
-export { type Driver } from "./driver"
-export {
-  type DirEntry,
-  Failed,
-  type FileInfo,
-  type Files,
-  type FilesImpl,
-  type FileType,
-  NotFound,
-  WrongKind,
-} from "./files"
-export { execDefaults } from "./exec-defaults"
-export { makeMemoryDriver, type MemoryDriver } from "./memory"
-
-import type { Driver } from "./driver"
-import { execDefaults } from "./exec-defaults"
-import type { Files } from "./files"
-
-export const makeFiles = (driver: Driver): Files => ({
-  ...execDefaults(driver.spawner),
-  ...driver.overrides,
-})

packages/core/src/environment/memory.ts

@@ -1,168 +0,0 @@
-import path from "node:path"
-import { Effect, PlatformError } from "effect"
-import { make } from "effect/unstable/process/ChildProcessSpawner"
-import type { Driver } from "./driver"
-import { Failed, NotFound, WrongKind, type FileInfo, type FilesImpl, type FileType } from "./files"
-
-type Node =
-  | { readonly type: "file"; readonly bytes: Uint8Array; readonly mtimeMs: number }
-  | { readonly type: "directory"; readonly mtimeMs: number }
-  | { readonly type: "symlink"; readonly target: string; readonly mtimeMs: number }
-
-export interface MemoryDriver extends Driver {
-  readonly symlink: (target: string, path: string) => Effect.Effect<void, Failed>
-}
-
-export const makeMemoryDriver = (): MemoryDriver => {
-  const nodes = new Map<string, Node>([["/", { type: "directory", mtimeMs: Date.now() }]])
-  const key = (value: string) => path.posix.resolve("/", value)
-  const info = (node: Node): FileInfo => ({
-    type: node.type,
-    size:
-      node.type === "file"
-        ? node.bytes.length
-        : node.type === "symlink"
-          ? new TextEncoder().encode(node.target).length
-          : 0,
-    mtimeMs: node.mtimeMs,
-  })
-  const resolveKey = (value: string, followFinal: boolean, seen = new Set<string>()): string | undefined => {
-    const normalized = key(value)
-    const parts = normalized.split("/").filter(Boolean)
-    const base = "/"
-    const walk = (current: string, index: number): string | undefined => {
-      if (index === parts.length) return current
-      const part = parts[index]
-      const candidate = path.posix.join(current, part)
-      const node = nodes.get(candidate)
-      if (node?.type !== "symlink" || (!followFinal && index === parts.length - 1)) return walk(candidate, index + 1)
-      if (seen.has(candidate)) return undefined
-      seen.add(candidate)
-      const target = path.posix.resolve(path.posix.dirname(candidate), node.target)
-      return resolveKey(path.posix.join(target, ...parts.slice(index + 1)), followFinal, seen)
-    }
-    return walk(base, 0)
-  }
-  const lookup = (value: string) => nodes.get(resolveKey(value, false) ?? key(value))
-  const requireParent = (value: string) => {
-    const parentPath = path.posix.dirname(key(value))
-    const parent = nodes.get(resolveKey(parentPath, true) ?? parentPath)
-    if (!parent) throw new Error(`Parent directory does not exist: ${path.posix.dirname(value)}`)
-    if (parent.type !== "directory") throw new Error(`Parent is not a directory: ${path.posix.dirname(value)}`)
-  }
-  const mkdirSync = (value: string) => {
-    const target = resolveKey(value, false) ?? key(value)
-    const existing = nodes.get(target)
-    if (existing?.type === "directory") return
-    if (existing) throw new Error(`Path is not a directory: ${value}`)
-    const parent = path.posix.dirname(target)
-    if (parent !== target) mkdirSync(parent)
-    nodes.set(target, { type: "directory", mtimeMs: Date.now() })
-  }
-  const failed = (value: string, cause: unknown) => new Failed({ path: value, cause })
-  const overrides: FilesImpl = {
-    stat: (value) => {
-      const node = lookup(value)
-      return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound({ path: value }))
-    },
-    read: (value, range) => {
-      const original = lookup(value)
-      if (!original) return Effect.fail(new NotFound({ path: value }))
-      if (original.type === "directory") return Effect.fail(new WrongKind({ path: value, actual: "directory" }))
-      const resolved = resolveKey(value, true)
-      const node = resolved === undefined ? undefined : nodes.get(resolved)
-      if (!node) return Effect.fail(new NotFound({ path: value }))
-      if (node.type !== "file") return Effect.fail(new WrongKind({ path: value, actual: node.type }))
-      const bytes = range === undefined ? node.bytes : node.bytes.subarray(range.offset, range.offset + range.length)
-      return Effect.succeed({ info: info(node), bytes: bytes.slice() })
-    },
-    write: (value, bytes) =>
-      Effect.try({
-        try: () => {
-          mkdirSync(path.posix.dirname(key(value)))
-          const existing = lookup(value)
-          if (existing?.type === "directory") throw new Error(`Path is a directory: ${value}`)
-          const target = existing?.type === "symlink" ? resolveKey(value, true) : resolveKey(value, false)
-          if (!target) throw new Error(`Cannot resolve symlink: ${value}`)
-          requireParent(target)
-          nodes.set(target, { type: "file", bytes: bytes.slice(), mtimeMs: Date.now() })
-        },
-        catch: (cause) => failed(value, cause),
-      }),
-    list: (value) => {
-      const target = resolveKey(value, false) ?? key(value)
-      const node = nodes.get(target)
-      if (!node) return Effect.fail(new NotFound({ path: value }))
-      if (node.type !== "directory") return Effect.fail(new WrongKind({ path: value, actual: node.type }))
-      const entries = [...nodes.entries()]
-        .filter(([entry]) => entry !== target && path.posix.dirname(entry) === target)
-        .map(([entry, child]) => ({ name: path.posix.basename(entry), type: child.type satisfies FileType }))
-        .sort((a, b) => a.name.localeCompare(b.name))
-      return Effect.succeed(entries)
-    },
-    remove: (value) =>
-      Effect.sync(() => {
-        const target = resolveKey(value, false) ?? key(value)
-        for (const entry of nodes.keys()) {
-          if (entry === target || entry.startsWith(`${target}/`)) nodes.delete(entry)
-        }
-      }),
-    move: (from, to) => {
-      const source = resolveKey(from, false) ?? key(from)
-      const node = nodes.get(source)
-      if (!node) return Effect.fail(new NotFound({ path: from }))
-      return Effect.try({
-        try: () => {
-          const requested = resolveKey(to, false) ?? key(to)
-          const destination =
-            nodes.get(requested)?.type === "directory"
-              ? path.posix.join(requested, path.posix.basename(source))
-              : requested
-          if (node.type === "directory" && destination.startsWith(`${source}/`)) {
-            throw new Error(`Cannot move a directory into itself: ${from}`)
-          }
-          const existing = nodes.get(destination)
-          if (node.type === "directory" && existing && existing.type !== "directory") {
-            throw new Error(`Cannot overwrite a non-directory with a directory: ${to}`)
-          }
-          requireParent(destination)
-          const moved = [...nodes.entries()].filter(([entry]) => entry === source || entry.startsWith(`${source}/`))
-          for (const [entry] of moved) nodes.delete(entry)
-          for (const [entry, child] of moved) nodes.set(`${destination}${entry.slice(source.length)}`, child)
-        },
-        catch: (cause) => failed(from, cause),
-      })
-    },
-    mkdir: (value) => Effect.try({ try: () => mkdirSync(value), catch: (cause) => failed(value, cause) }),
-  }
-
-  const spawner = make((command) =>
-    Effect.suspend(() => {
-      const description = command._tag === "StandardCommand" ? command.command : "pipeline"
-      return Effect.fail(
-        PlatformError.systemError({
-          _tag: "Unknown",
-          module: "EnvironmentMemory",
-          method: "spawn",
-          pathOrDescriptor: description,
-          cause: failed(description, new Error("The memory driver cannot spawn processes")),
-        }),
-      )
-    }),
-  )
-
-  return {
-    spawner,
-    overrides,
-    symlink: (target, value) =>
-      Effect.try({
-        try: () => {
-          requireParent(value)
-          nodes.set(resolveKey(value, false) ?? key(value), { type: "symlink", target, mtimeMs: Date.now() })
-        },
-        catch: (cause) => failed(value, cause),
-      }),
-  }
-}
-
-export * as EnvironmentMemory from "./memory"

packages/core/src/session.ts

@@ -133,6 +133,14 @@ export class CompactionConflictError extends Schema.TaggedErrorClass<CompactionC
 export class BusyError extends Schema.TaggedErrorClass<BusyError>()("Session.BusyError", {
   sessionID: SessionSchema.ID,
 }) {}
+export class PendingInputConflictError extends Schema.TaggedErrorClass<PendingInputConflictError>()(
+  "Session.PendingInputConflictError",
+  {
+    sessionID: SessionSchema.ID,
+    inputID: SessionMessage.ID,
+  },
+) {}
+type PendingInputRef = { readonly sessionID: SessionSchema.ID; readonly inputID: SessionMessage.ID }
 export class SkillNotFoundError extends Schema.TaggedErrorClass<SkillNotFoundError>()("Session.SkillNotFoundError", {
   skill: Skill.ID,
 }) {}
@@ -181,6 +189,9 @@ export interface Interface {
    * unhandled compaction barriers.
    */
   readonly pending: (sessionID: SessionSchema.ID) => Effect.Effect<SessionPending.Info[], NotFoundError>
+  readonly cancelPending: (input: PendingInputRef) => Effect.Effect<void, NotFoundError | PendingInputConflictError>
+  readonly steerPending: (input: PendingInputRef) => Effect.Effect<void, NotFoundError | PendingInputConflictError>
+  readonly queuePending: (input: PendingInputRef) => Effect.Effect<void, NotFoundError | PendingInputConflictError>
   /**
    * Durable, ordered session log read. Replays durable session bus after
    * the exclusive `after` cursor, emits a `Synced` marker at the captured
@@ -318,6 +329,28 @@ const layer = Layer.effect(
         ),
       )
 
+    const mutatePending = (
+      input: PendingInputRef,
+      mutation: (
+        bus: Bus.Interface,
+        input: { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID },
+      ) => Effect.Effect<unknown>,
+      wake = false,
+    ) =>
+      Effect.uninterruptible(
+        Effect.gen(function* () {
+          yield* result.get(input.sessionID)
+          yield* mutation(bus, { sessionID: input.sessionID, id: input.inputID }).pipe(
+            Effect.catchDefect((defect) =>
+              defect instanceof SessionPending.LifecycleConflict
+                ? new PendingInputConflictError(input)
+                : Effect.die(defect),
+            ),
+          )
+          if (wake) yield* execution.wake(input.sessionID)
+        }),
+      )
+
     const result = Service.of({
       create: Effect.fn("Session.create")(function* (input) {
         const sessionID = input.id ?? SessionSchema.ID.create()
@@ -507,6 +540,9 @@ const layer = Layer.effect(
         yield* result.get(sessionID)
         return yield* SessionPending.list(db, sessionID)
       }),
+      cancelPending: Effect.fn("Session.cancelPending")((input) => mutatePending(input, SessionPending.cancel)),
+      steerPending: Effect.fn("Session.steerPending")((input) => mutatePending(input, SessionPending.steer, true)),
+      queuePending: Effect.fn("Session.queuePending")((input) => mutatePending(input, SessionPending.queue)),
       log: (input) =>
         Stream.unwrap(
           result

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

@@ -90,6 +90,9 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       "session.forked": () => Effect.void,
       "session.input.promoted": () => Effect.void,
       "session.input.admitted": () => Effect.void,
+      "session.input.cancelled": () => Effect.void,
+      "session.input.steered": () => Effect.void,
+      "session.input.queued": () => Effect.void,
       "session.execution.started": () => Effect.void,
       "session.execution.succeeded": () => clearCurrentRetry,
       "session.execution.failed": () => clearCurrentRetry,

packages/core/src/session/pending.ts

@@ -312,6 +312,63 @@ export const projectPromoted = Effect.fn("SessionPending.projectPromoted")(funct
   return stored
 })
 
+export const projectCancelled = Effect.fn("SessionPending.projectCancelled")(function* (
+  db: DatabaseService,
+  input: {
+    readonly id: SessionMessage.ID
+    readonly sessionID: SessionSchema.ID
+  },
+) {
+  const deleted = yield* db
+    .delete(SessionPendingTable)
+    .where(
+      and(
+        eq(SessionPendingTable.id, input.id),
+        eq(SessionPendingTable.session_id, input.sessionID),
+        or(eq(SessionPendingTable.delivery, "queue"), eq(SessionPendingTable.delivery, "steer")),
+      ),
+    )
+    .returning({ id: SessionPendingTable.id })
+    .get()
+    .pipe(Effect.orDie)
+  if (!deleted) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+})
+
+const projectDelivery = Effect.fn("SessionPending.projectDelivery")(function* (
+  db: DatabaseService,
+  input: {
+    readonly id: SessionMessage.ID
+    readonly sessionID: SessionSchema.ID
+    readonly from: Delivery
+    readonly to: Delivery
+  },
+) {
+  const updated = yield* db
+    .update(SessionPendingTable)
+    .set({ delivery: input.to })
+    .where(
+      and(
+        eq(SessionPendingTable.id, input.id),
+        eq(SessionPendingTable.session_id, input.sessionID),
+        eq(SessionPendingTable.delivery, input.from),
+      ),
+    )
+    .returning({ id: SessionPendingTable.id })
+    .get()
+    .pipe(Effect.orDie)
+  if (!updated) return yield* Effect.die(new LifecycleConflict({ id: input.id }))
+})
+
+export const projectSteered = Effect.fn("SessionPending.projectSteered")(
+  (db: DatabaseService, input: { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID }) =>
+    projectDelivery(db, { ...input, from: "queue", to: "steer" }),
+)
+
+export const projectQueued = Effect.fn("SessionPending.projectQueued")(
+  (db: DatabaseService, input: { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID }) =>
+    projectDelivery(db, { ...input, from: "steer", to: "queue" }),
+)
+
 export const settleCompaction = Effect.fn("SessionPending.settleCompaction")(function* (
   db: DatabaseService,
   input: { readonly sessionID: SessionSchema.ID },
@@ -389,6 +446,42 @@ export const equivalent = (
   return false
 }
 
+export const cancel = Effect.fn("SessionPending.cancel")(function* (
+  bus: Bus.Interface,
+  input: { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID },
+) {
+  yield* inboxLocks.withLock(input.sessionID)(
+    bus.publish(SessionEvent.InputCancelled, {
+      sessionID: input.sessionID,
+      inputID: input.id,
+    }),
+  )
+})
+
+export const steer = Effect.fn("SessionPending.steer")(function* (
+  bus: Bus.Interface,
+  input: { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID },
+) {
+  yield* inboxLocks.withLock(input.sessionID)(
+    bus.publish(SessionEvent.InputSteered, {
+      sessionID: input.sessionID,
+      inputID: input.id,
+    }),
+  )
+})
+
+export const queue = Effect.fn("SessionPending.queue")(function* (
+  bus: Bus.Interface,
+  input: { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID },
+) {
+  yield* inboxLocks.withLock(input.sessionID)(
+    bus.publish(SessionEvent.InputQueued, {
+      sessionID: input.sessionID,
+      inputID: input.id,
+    }),
+  )
+})
+
 const publish = Effect.fn("SessionPending.publish")(function* (
   db: DatabaseService,
   bus: Bus.Interface,

packages/core/src/session/projector.ts

@@ -485,6 +485,24 @@ const layer = Layer.effectDiscard(
           .pipe(Effect.orDie)
       }),
     )
+    yield* bus.project(SessionEvent.InputCancelled, (event) =>
+      SessionPending.projectCancelled(db, {
+        id: event.data.inputID,
+        sessionID: event.data.sessionID,
+      }),
+    )
+    yield* bus.project(SessionEvent.InputSteered, (event) =>
+      SessionPending.projectSteered(db, {
+        id: event.data.inputID,
+        sessionID: event.data.sessionID,
+      }),
+    )
+    yield* bus.project(SessionEvent.InputQueued, (event) =>
+      SessionPending.projectQueued(db, {
+        id: event.data.inputID,
+        sessionID: event.data.sessionID,
+      }),
+    )
     yield* bus.project(SessionEvent.Compaction.Admitted, (event) =>
       Effect.gen(function* () {
         if (event.durable === undefined)

packages/core/src/session/transfer.ts

@@ -1,323 +0,0 @@
-export * as SessionTransfer from "./transfer"
-
-import { SessionTransfer } from "@opencode-ai/schema/session-transfer"
-import { Tool } from "@opencode-ai/schema/tool"
-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"
-import { App } from "../app"
-import { Bus } from "../bus"
-import { Database } from "../database/database"
-import { Location } from "../location"
-import { Project } from "../project"
-import { ProjectTable } from "../project/sql"
-import { AbsolutePath, RelativePath } from "../schema"
-import { Session } from "../session"
-import { Slug } from "../util/slug"
-import { SessionEvent } from "./event"
-import { SessionMessage } from "./message"
-import { SessionProjector } from "./projector"
-import { SessionMessageTable, SessionTable } from "./sql"
-
-export const Data = SessionTransfer.Data
-export type Data = SessionTransfer.Data
-
-export class ImportConflictError extends Schema.TaggedErrorClass<ImportConflictError>()(
-  "SessionTransfer.ImportConflictError",
-  { sessionID: Session.ID },
-) {}
-
-export interface Interface {
-  readonly export: (input: {
-    sessionID: Session.ID
-    sanitize?: boolean
-  }) => Effect.Effect<Data, Session.NotFoundError | Session.MessageDecodeError>
-  readonly import: (input: {
-    data: Data
-    location: Location.Ref
-  }) => Effect.Effect<Session.Info, ImportConflictError>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SessionTransfer") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const app = yield* App.Metadata
-    const bus = yield* Bus.Service
-    const { db } = yield* Database.Service
-    const projects = yield* Project.Service
-    const sessions = yield* Session.Service
-    const encodeMessage = Schema.encodeSync(SessionMessage.Info)
-
-    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) {
-        const data = {
-          info: yield* sessions.get(input.sessionID),
-          messages: yield* sessions.messages({ sessionID: input.sessionID, order: "asc" }),
-        }
-        return input.sanitize ? sanitize(data) : data
-      }),
-      import: Effect.fn("SessionTransfer.import")(function* (input) {
-        const sessionID = input.data.info.id
-        const recorded = yield* db
-          .select({ id: SessionTable.id })
-          .from(SessionTable)
-          .where(eq(SessionTable.id, sessionID))
-          .get()
-          .pipe(Effect.orDie)
-        if (recorded) return yield* new ImportConflictError({ sessionID })
-        const project = yield* projects.resolve(input.location.directory)
-        yield* persistProject(project)
-        const messages = input.data.messages.map((message, index) => {
-          const encoded = encodeMessage(message)
-          const { id: _, type, ...data } = encoded
-          return {
-            id: message.id,
-            session_id: sessionID,
-            type,
-            seq: index + 1,
-            time_created: DateTime.toEpochMillis(message.time.created),
-            data,
-          }
-        })
-        yield* bus
-          .publish(
-            SessionEvent.Created,
-            {
-              sessionID,
-              slug: Slug.create(),
-              version: app.version,
-              projectID: project.id,
-              location: input.location,
-              subpath: RelativePath.make(path.relative(project.directory, input.location.directory).replaceAll("\\", "/")),
-              title: input.data.info.title,
-              agent: input.data.info.agent,
-              model: input.data.info.model,
-            },
-            {
-              location: input.location,
-              commit: (seq) =>
-                Effect.gen(function* () {
-                  if (messages.length > 0) {
-                    yield* db.insert(SessionMessageTable).values(messages).run().pipe(Effect.orDie)
-                    yield* Bus.reserveSequence(db, sessionID, seq + messages.length)
-                  }
-                  yield* db
-                    .update(SessionTable)
-                    .set({
-                      cost: input.data.info.cost,
-                      tokens_input: input.data.info.tokens.input,
-                      tokens_output: input.data.info.tokens.output,
-                      tokens_reasoning: input.data.info.tokens.reasoning,
-                      tokens_cache_read: input.data.info.tokens.cache.read,
-                      tokens_cache_write: input.data.info.tokens.cache.write,
-                      time_created: DateTime.toEpochMillis(input.data.info.time.created),
-                      time_updated: DateTime.toEpochMillis(input.data.info.time.updated),
-                      time_archived: input.data.info.time.archived
-                        ? DateTime.toEpochMillis(input.data.info.time.archived)
-                        : null,
-                    })
-                    .where(eq(SessionTable.id, sessionID))
-                    .run()
-                    .pipe(Effect.orDie)
-                }),
-            },
-          )
-          .pipe(
-            Effect.catchDefect((defect) =>
-              defect instanceof SessionProjector.SessionAlreadyProjected
-                ? Effect.fail(new ImportConflictError({ sessionID }))
-                : Effect.die(defect),
-            ),
-          )
-        return yield* sessions.get(sessionID).pipe(Effect.orDie)
-      }),
-    })
-  }),
-)
-
-export const node = makeGlobalNode({
-  service: Service,
-  layer,
-  deps: [App.node, Bus.node, Database.node, Project.node, Session.node],
-})
-
-function redact(kind: string, id: string, value: string) {
-  return value.trim() ? `[redacted:${kind}:${id}]` : value
-}
-
-function metadata(kind: string, id: string, value: Readonly<Record<string, unknown>> | undefined) {
-  if (!value) return value
-  return Object.keys(value).length > 0 ? { redacted: `${kind}:${id}` } : value
-}
-
-function sanitize(data: Data): Data {
-  return {
-    info: {
-      ...data.info,
-      title: data.info.title === undefined ? undefined : redact("session-title", data.info.id, data.info.title),
-      location: {
-        ...data.info.location,
-        directory: AbsolutePath.make(`/${redact("session-directory", data.info.id, data.info.location.directory)}`),
-      },
-      revert: data.info.revert
-        ? {
-            ...data.info.revert,
-            files: data.info.revert.files?.map((file, index) => ({
-              ...file,
-              file: redact("revert-file", String(index), file.file),
-              patch: redact("revert-patch", String(index), file.patch),
-            })),
-          }
-        : undefined,
-    },
-    messages: data.messages.map(sanitizeMessage),
-  }
-}
-
-function sanitizeMessage(message: SessionMessage.Info): SessionMessage.Info {
-  const meta = metadata("message-metadata", message.id, message.metadata)
-  if (message.type === "user")
-    return {
-      ...message,
-      metadata: meta,
-      text: redact("text", message.id, message.text),
-      files: message.files?.map((file, index) => ({
-        ...file,
-        data: "",
-        source: { type: "inline" },
-        name: file.name === undefined ? undefined : redact("file-name", String(index), file.name),
-        description:
-          file.description === undefined ? undefined : redact("file-description", String(index), file.description),
-        mention: file.mention
-          ? { ...file.mention, text: redact("file-mention", String(index), file.mention.text) }
-          : undefined,
-      })),
-      agents: message.agents?.map((agent, index) => ({
-        ...agent,
-        name: redact("agent-name", String(index), agent.name),
-        mention: agent.mention
-          ? { ...agent.mention, text: redact("agent-mention", String(index), agent.mention.text) }
-          : undefined,
-      })),
-    }
-  if (message.type === "synthetic")
-    return {
-      ...message,
-      metadata: meta,
-      text: redact("synthetic", message.id, message.text),
-      description:
-        message.description === undefined
-          ? undefined
-          : redact("synthetic-description", message.id, message.description),
-    }
-  if (message.type === "system")
-    return { ...message, metadata: meta, text: redact("system", message.id, message.text) }
-  if (message.type === "skill") return { ...message, metadata: meta, text: redact("skill", message.id, message.text) }
-  if (message.type === "shell")
-    return {
-      ...message,
-      metadata: meta,
-      command: redact("shell-command", message.id, message.command),
-      output: message.output
-        ? { ...message.output, output: redact("shell-output", message.id, message.output.output) }
-        : undefined,
-    }
-  if (message.type === "assistant")
-    return {
-      ...message,
-      metadata: meta,
-      content: message.content.map((content) => {
-        if (content.type === "text")
-          return {
-            ...content,
-            text: redact("text", message.id, content.text),
-            state: content.state ? { redacted: `text-state:${message.id}` } : undefined,
-          }
-        if (content.type === "reasoning")
-          return {
-            ...content,
-            text: redact("reasoning", message.id, content.text),
-            state: content.state ? { redacted: `reasoning-state:${message.id}` } : undefined,
-          }
-        return {
-          ...content,
-          providerState: content.providerState ? { redacted: `tool-provider-state:${message.id}` } : undefined,
-          providerResultState: content.providerResultState
-            ? { redacted: `tool-provider-result-state:${message.id}` }
-            : undefined,
-          state: sanitizeToolState(message.id, content.state),
-        }
-      }),
-    }
-  if (message.type === "compaction") {
-    if (message.status === "failed")
-      return {
-        ...message,
-        metadata: meta,
-      }
-    return {
-      ...message,
-      metadata: meta,
-      summary: redact("compaction-summary", message.id, message.summary),
-      recent: redact("compaction-recent", message.id, message.recent),
-    }
-  }
-  return { ...message, metadata: meta }
-}
-
-function sanitizeToolState(id: string, state: SessionMessage.ToolState): SessionMessage.ToolState {
-  if (state.status === "streaming") return { ...state, input: redact("tool-input", id, state.input) }
-  if (state.status === "running")
-    return { ...state, input: { redacted: `tool-input:${id}` }, metadata: { redacted: `tool-metadata:${id}` } }
-  const meta = state.metadata === undefined ? undefined : { redacted: `tool-metadata:${id}` }
-  if (state.status === "completed")
-    return {
-      ...state,
-      input: { redacted: `tool-input:${id}` },
-      content: [
-        sanitizeToolContent(id, state.content[0]),
-        ...state.content.slice(1).map((item) => sanitizeToolContent(id, item)),
-      ],
-      metadata: meta,
-    }
-  return {
-    ...state,
-    input: { redacted: `tool-input:${id}` },
-    content: state.content
-      ? [
-          sanitizeToolContent(id, state.content[0]),
-          ...state.content.slice(1).map((item) => sanitizeToolContent(id, item)),
-        ]
-      : undefined,
-    metadata: meta,
-  }
-}
-
-function sanitizeToolContent(id: string, content: Tool.Content): Tool.Content {
-  if (content.type === "text") return { ...content, text: redact("tool-output", id, content.text) }
-  return {
-    ...content,
-    uri: redact("tool-file-uri", id, content.uri),
-    name: content.name === undefined ? undefined : redact("tool-file-name", id, content.name),
-  }
-}

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

@@ -2,7 +2,7 @@ export * as WebSearchTool from "./websearch"
 
 import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
-import { Effect, Schema, Semaphore } from "effect"
+import { Effect, Schema } from "effect"
 import { Form } from "../../form"
 import { KV } from "../../kv"
 import { Permission } from "../../permission"
@@ -10,7 +10,6 @@ import { WebSearch } from "../../websearch"
 
 export const name = "websearch"
 export const NO_RESULTS = "No search results found. Please try a different query."
-const providerSelectionLock = Semaphore.makeUnsafe(1)
 
 export const description = `Search the web using the user's selected search integration. Use this for current information beyond knowledge cutoff.
 
@@ -30,7 +29,6 @@ export const Plugin = {
     const permission = yield* Permission.Service
     const forms = yield* Form.Service
     const kv = yield* KV.Service
-    const websearch = yield* WebSearch.Service
 
     yield* ctx.tool
       .transform((draft) =>
@@ -51,90 +49,70 @@ export const Plugin = {
                 agent: context.agent,
                 source: { type: "tool", messageID: context.messageID, id: context.id },
               })
-              const search = (): Effect.Effect<Effect.Success<ReturnType<typeof ctx.websearch.query>>, unknown> =>
-                ctx.websearch.query(input).pipe(
-                  Effect.catch((error) => {
-                    if (!Schema.is(WebSearch.ProviderRequiredError)(error)) return Effect.fail(error)
-                    return providerSelectionLock
-                      .withPermit(
-                        Effect.gen(function* () {
-                          if (yield* websearch.default()) return yield* Effect.void
-                          const providers = (yield* ctx.websearch.providers()).data
-                          const defaultProvider = providers[0]
-                          if (!defaultProvider) return yield* new WebSearch.ProviderRequiredError()
-                          const response = yield* forms.ask({
+              const result = yield* ctx.websearch.query(input).pipe(
+                Effect.catch((error) => {
+                  if (!Schema.is(WebSearch.ProviderRequiredError)(error)) return Effect.fail(error)
+                  return Effect.gen(function* () {
+                    const providers = (yield* ctx.websearch.providers()).data
+                    const defaultProvider = providers[0]
+                    if (!defaultProvider) return yield* new WebSearch.ProviderRequiredError()
+                    const response = yield* forms.ask({
+                      sessionID: context.sessionID,
+                      title: "Web Search",
+                      metadata: { kind: "websearch.provider" },
+                      fields: [
+                        {
+                          key: "choice",
+                          description: "Allow OpenCode to search the web for up-to-date information?",
+                          type: "string",
+                          required: true,
+                          custom: false,
+                          options: [
+                            {
+                              value: "allow",
+                              label: `Allow web search via ${defaultProvider.name}`,
+                            },
+                            {
+                              value: "choose",
+                              label: "Choose another provider",
+                            },
+                            { value: "disable", label: "Disable web search" },
+                          ],
+                        },
+                      ],
+                    })
+                    if (response.status === "cancelled") return yield* Effect.fail(new Error("Web search cancelled"))
+                    if (response.answer.choice === "disable") {
+                      yield* kv.set("websearch:provider", false)
+                      return yield* new WebSearch.DisabledError()
+                    }
+                    const selection =
+                      response.answer.choice === "choose"
+                        ? yield* forms.ask({
                             sessionID: context.sessionID,
-                            title: "Web Search",
+                            title: "Choose a web search provider",
                             metadata: { kind: "websearch.provider" },
                             fields: [
                               {
-                                key: "choice",
-                                description: "Allow OpenCode to search the web for up-to-date information?",
+                                key: "provider",
+                                description: "Choose a provider for web search.",
                                 type: "string",
                                 required: true,
                                 custom: false,
-                                options: [
-                                  {
-                                    value: "allow",
-                                    label: `Allow web search via ${defaultProvider.name}`,
-                                  },
-                                  {
-                                    value: "choose",
-                                    label: "Choose another provider",
-                                  },
-                                  { value: "disable", label: "Disable web search" },
-                                ],
+                                options: providers.map((provider) => ({ value: provider.id, label: provider.name })),
                               },
                             ],
                           })
-                          if (response.status === "cancelled")
-                            return yield* Effect.fail(new Error("Web search cancelled"))
-                          if (response.answer.choice === "disable") {
-                            yield* kv.set("websearch:provider", false)
-                            return yield* new WebSearch.DisabledError()
-                          }
-                          const selection =
-                            response.answer.choice === "choose"
-                              ? yield* forms.ask({
-                                  sessionID: context.sessionID,
-                                  title: "Choose a web search provider",
-                                  metadata: { kind: "websearch.provider" },
-                                  fields: [
-                                    {
-                                      key: "provider",
-                                      description: "Choose a provider for web search.",
-                                      type: "string",
-                                      required: true,
-                                      custom: false,
-                                      options: providers.map((provider) => ({
-                                        value: provider.id,
-                                        label: provider.name,
-                                      })),
-                                    },
-                                  ],
-                                })
-                              : undefined
-                          if (selection?.status === "cancelled")
-                            return yield* Effect.fail(new Error("Web search cancelled"))
-                          const providerID = selection?.answer.provider ?? defaultProvider.id
-                          if (
-                            typeof providerID !== "string" ||
-                            !providers.some((provider) => provider.id === providerID)
-                          )
-                            return yield* new WebSearch.ProviderRequiredError()
-                          return yield* kv.set("websearch:provider", providerID)
-                        }),
-                      )
-                      .pipe(
-                        Effect.timeoutOrElse({
-                          duration: "1 minute",
-                          orElse: () => Effect.fail(new Error("Web search cancelled")),
-                        }),
-                        Effect.andThen(Effect.suspend(search)),
-                      )
-                  }),
-                )
-              const result = yield* search()
+                        : undefined
+                    if (selection?.status === "cancelled") return yield* Effect.fail(new Error("Web search cancelled"))
+                    const providerID = selection?.answer.provider ?? defaultProvider.id
+                    if (typeof providerID !== "string" || !providers.some((provider) => provider.id === providerID))
+                      return yield* new WebSearch.ProviderRequiredError()
+                    yield* kv.set("websearch:provider", providerID)
+                    return yield* ctx.websearch.query(input)
+                  })
+                }),
+              )
               const output = {
                 provider: result.data.providerID,
                 results: result.data.results,

packages/core/src/v1/config/migrate.ts

@@ -18,6 +18,44 @@ const decodeInfo = Schema.decodeUnknownSync(Schema.fromJsonString(Info), decodeO
 const encodeInfo = Schema.encodeSync(Info)
 const decodeAgent = Schema.decodeUnknownSync(Schema.fromJsonString(ConfigAgent.Info), decodeOptions)
 const encodeAgent = Schema.encodeSync(ConfigAgent.Info)
+
+const keys = new Set([
+  "logLevel",
+  "server",
+  "command",
+  "reference",
+  "snapshot",
+  "plugin",
+  "autoshare",
+  "disabled_providers",
+  "enabled_providers",
+  "small_model",
+  "mode",
+  "agent",
+  "provider",
+  "permission",
+  "tools",
+  "attachment",
+  "layout",
+])
+
+export function isV1(input: unknown) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return false
+  const record = input as Record<string, unknown>
+  if (Object.keys(record).some((key) => keys.has(key))) return true
+  // `mcp` exists in both versions, so presence alone is ambiguous: v1 lists servers directly under
+  // `mcp`, while v2 nests them under `mcp.servers`. Only the v1 shape (a server entry with `type`)
+  // counts, so a bare `mcp`-only file still migrates instead of silently parsing to zero servers.
+  const mcp = record.mcp
+  return (
+    typeof mcp === "object" &&
+    mcp !== null &&
+    !Array.isArray(mcp) &&
+    !("servers" in mcp) &&
+    Object.values(mcp).some((server) => typeof server === "object" && server !== null && "type" in server)
+  )
+}
+
 export function migrate(info: typeof ConfigV1.Info.Type) {
   return encodeInfo(
     decodeInfo(
@@ -107,7 +145,7 @@ function permissions(info?: ConfigPermissionV1.Info, tools?: Readonly<Record<str
 }
 
 // Map v1 permission/tool keys onto their renamed v2 tool actions so migrated rules keep matching.
-export function normalizeAction(action: string) {
+function normalizeAction(action: string) {
   if (action === "write" || action === "patch") return "edit"
   if (action === "task") return "subagent"
   if (action === "bash") return "shell"
@@ -147,7 +185,7 @@ export function migrateAgent(info: ConfigAgentV1.Info) {
   )
 }
 
-export function commands(info?: Readonly<Record<string, ConfigCommandV1.Info>>) {
+function commands(info?: Readonly<Record<string, ConfigCommandV1.Info>>) {
   if (!info) return undefined
   return Object.fromEntries(
     Object.entries(info).map(([id, command]) => [
@@ -184,7 +222,7 @@ function mcp(info: typeof ConfigV1.Info.Type) {
   return { timeout: timeout === undefined ? undefined : { catalog: timeout, execution: timeout }, servers }
 }
 
-export function migrateMcp(info: ConfigMCPV1.Info) {
+function migrateMcp(info: ConfigMCPV1.Info) {
   const disabled = info.enabled === undefined ? undefined : !info.enabled
   if (info.type === "local")
     return {
@@ -223,7 +261,7 @@ function providers(info?: Readonly<Record<string, ConfigProviderV1.Info>>) {
   )
 }
 
-export function migrateProvider(sourceID: string, info: ConfigProviderV1.Info) {
+function migrateProvider(sourceID: string, info: ConfigProviderV1.Info) {
   if (sourceID === "azure-cognitive-services") return migrateAzureCognitiveServicesProvider(info)
   if (sourceID === "google-vertex-anthropic") return migrateGoogleVertexAnthropicProvider(info)
   return migrateStandardProvider(info)
@@ -235,7 +273,7 @@ function migrateStandardProvider(info: ConfigProviderV1.Info) {
     name: info.name,
     env: info.env,
     package: info.npm ? Provider.aisdk(info.npm) : undefined,
-    settings: info.api ? { ...options.settings, baseURL: info.api } : info.options ? options.settings : undefined,
+    settings: info.api ? { ...options.settings, baseURL: info.api } : options.settings,
     headers: info.options && options.headers,
     body: info.options && options.body,
     models:
@@ -279,8 +317,8 @@ function migrateGoogleVertexAnthropicProvider(info: ConfigProviderV1.Info) {
   }
 }
 
-// Rename these only while migrating unambiguous V1 fields.
-export function providerID(input: string) {
+// Rename these only in files detected as V1 by a field that exists only in the old config format.
+function providerID(input: string) {
   if (input === "azure-cognitive-services") return "azure"
   if (input === "google-vertex-anthropic") return "google-vertex"
   return input

packages/core/test/config/agent.test.ts

@@ -12,7 +12,6 @@ import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
 import { Permission } from "@opencode-ai/core/permission"
-import { AgentPlugin } from "@opencode-ai/core/plugin/agent"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { ConfigMigrateV1 } from "@opencode-ai/core/v1/config/migrate"
 import { advance, drain } from "../lib/clock"
@@ -51,11 +50,6 @@ describe("ConfigAgentPlugin.Plugin", () => {
   it.effect("matches Windows paths against home-relative permissions", () =>
     Effect.gen(function* () {
       const permissions = yield* loadHomePermissions("C:\\Users\\test")
-      expect(permissions).toContainEqual({
-        action: "external_directory",
-        resource: "C:\\Users\\test\\p\\**",
-        effect: "allow",
-      })
       expect(
         Permission.evaluate("external_directory", "C:\\Users\\test\\p\\opencode\\src\\*", permissions).effect,
       ).toBe("allow")
@@ -65,96 +59,6 @@ describe("ConfigAgentPlugin.Plugin", () => {
     }),
   )
 
-  it.effect("applies remote permission defaults before explicit global and build rules", () =>
-    Effect.gen(function* () {
-      const agents = yield* Agent.Service
-      const global = yield* Global.Service
-      yield* AgentPlugin.Plugin.effect(host({ agent: agentHost(agents) }))
-
-      const entries = [
-        new Document({
-          type: "document",
-          info: decode(
-            ConfigMigrateV1.migrate({
-              permission: {
-                bash: "ask",
-                edit: "ask",
-                webfetch: "ask",
-                read: {
-                  "*": "allow",
-                  "*.env": "deny",
-                  "*.env.*": "deny",
-                  "*.env.example": "allow",
-                  "*.dev.vars": "deny",
-                  "~/.local/share/opencode/mcp-auth.json": "deny",
-                  "$HOME/.local/share/opencode/mcp-auth.json": "deny",
-                },
-                external_directory: {
-                  "*": "ask",
-                  "~/.local/share/opencode/*": "deny",
-                },
-              },
-            }),
-          ),
-        }),
-        new Document({
-          type: "document",
-          info: decode({
-            permissions: [{ action: "*", resource: "*", effect: "allow" }],
-            agents: {
-              build: {
-                permissions: [
-                  { action: "external_directory", resource: "*", effect: "allow" },
-                  {
-                    action: "external_directory",
-                    resource: "~/.local/share/opencode/*",
-                    effect: "deny",
-                  },
-                  { action: "read", resource: "*.env", effect: "deny" },
-                ],
-              },
-            },
-          }),
-        }),
-      ]
-
-      yield* ConfigAgentPlugin.Plugin.effect(host({ agent: agentHost(agents) })).pipe(
-        Effect.provide(Config.testLayer(entries)),
-      )
-
-      const build = yield* agents.get(Agent.defaultID)
-      if (!build) throw new Error("expected configured build agent")
-      const opencodeData = path.join(global.home, ".local", "share", "opencode", "*")
-      const mcpAuth = path.join(global.home, ".local", "share", "opencode", "mcp-auth.json")
-      expect(build.permissions).toEqual([
-        ...defaultPermissions(global),
-        { action: "question", resource: "*", effect: "allow" },
-        { action: "shell", resource: "*", effect: "ask" },
-        { action: "edit", resource: "*", effect: "ask" },
-        { action: "webfetch", resource: "*", effect: "ask" },
-        { action: "read", resource: "*", effect: "allow" },
-        { action: "read", resource: "*.env", effect: "deny" },
-        { action: "read", resource: "*.env.*", effect: "deny" },
-        { action: "read", resource: "*.env.example", effect: "allow" },
-        { action: "read", resource: "*.dev.vars", effect: "deny" },
-        { action: "read", resource: mcpAuth, effect: "deny" },
-        { action: "read", resource: mcpAuth, effect: "deny" },
-        { action: "external_directory", resource: "*", effect: "ask" },
-        { action: "external_directory", resource: opencodeData, effect: "deny" },
-        { action: "*", resource: "*", effect: "allow" },
-        { action: "external_directory", resource: "*", effect: "allow" },
-        { action: "external_directory", resource: opencodeData, effect: "deny" },
-        { action: "read", resource: "*.env", effect: "deny" },
-      ])
-      expect(Permission.evaluate("shell", "bun test", build.permissions).effect).toBe("allow")
-      expect(Permission.evaluate("edit", "src/index.ts", build.permissions).effect).toBe("allow")
-      expect(Permission.evaluate("webfetch", "https://example.com", build.permissions).effect).toBe("allow")
-      expect(Permission.evaluate("read", ".env", build.permissions).effect).toBe("deny")
-      expect(Permission.evaluate("external_directory", opencodeData, build.permissions).effect).toBe("deny")
-      expect(Permission.evaluate("external_directory", "/outside/*", build.permissions).effect).toBe("allow")
-    }),
-  )
-
   it.effect("applies all global permissions before agent-specific permissions", () =>
     Effect.gen(function* () {
       const agents = yield* Agent.Service

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

@@ -1,7 +1,7 @@
 import path from "path"
 import fs from "fs/promises"
 import { describe, expect } from "bun:test"
-import { Effect, Fiber, Layer, Logger, PubSub, Schema, Stream } from "effect"
+import { Effect, Fiber, Layer, PubSub, Schema, Stream } from "effect"
 import { FastCheck } from "effect/testing"
 import { Config } from "@opencode-ai/core/config"
 import { AgentsDirectory, Directory, Document, Event, Info } from "@opencode-ai/schema/config"
@@ -307,7 +307,7 @@ describe("Config", () => {
     }),
   )
 
-  it.live("loads authenticated wellknown config before user configuration", () =>
+  it.live("loads authenticated wellknown config at highest priority", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),
       (tmp) =>
@@ -370,13 +370,7 @@ describe("Config", () => {
           return yield* Effect.gen(function* () {
             const config = yield* Config.Service
             const bus = yield* Bus.Service
-            const initial = yield* config.entries()
-            expect(Config.latest(initial, "shell")).toBe("project")
-            expect(
-              initial.flatMap((entry) =>
-                entry.type === "document" && entry.info.shell ? [entry.info.shell] : [],
-              ),
-            ).toEqual(["secret", "global", "project"])
+            expect(Config.latest(yield* config.entries(), "shell")).toBe("secret")
             const updated = yield* bus
               .subscribe(Event.Updated)
               .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
@@ -384,13 +378,7 @@ describe("Config", () => {
             key = "next"
             yield* bus.publish(Integration.Event.ConnectionUpdated, { integrationID })
             expect(yield* Fiber.join(updated)).toHaveLength(1)
-            const refreshed = yield* config.entries()
-            expect(Config.latest(refreshed, "shell")).toBe("project")
-            expect(
-              refreshed.flatMap((entry) =>
-                entry.type === "document" && entry.info.shell ? [entry.info.shell] : [],
-              ),
-            ).toEqual(["next", "global", "project"])
+            expect(Config.latest(yield* config.entries(), "shell")).toBe("next")
           }).pipe(
             Effect.provide(testLayer(project, global, project, undefined, undefined, credentialNode, wellknownNode)),
           )
@@ -399,96 +387,27 @@ describe("Config", () => {
     ),
   )
 
-  it.live("logs redacted source-aware diagnostics for every config source", () => {
-    const output: Array<Record<string, unknown>> = []
-    const logger = Logger.map(Logger.formatStructured, (entry) => {
-      if (!Array.isArray(entry.message) || entry.message[0] !== "configuration normalization diagnostic") return
-      const details = entry.message[1]
-      if (typeof details === "object" && details !== null) output.push(details as Record<string, unknown>)
-    })
-    return Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) =>
-        Effect.gen(function* () {
-          const global = path.join(tmp.path, "global")
-          const project = path.join(tmp.path, "project")
-          const malformed = path.join(tmp.path, "malformed.json")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(global, { recursive: true })
-            await fs.mkdir(project, { recursive: true })
-            await fs.writeFile(path.join(global, "opencode.json"), "null")
-            await fs.writeFile(path.join(project, "opencode.json"), "")
-            await fs.writeFile(malformed, '{ "credential": "file-secret"')
-          })
-          const integrationID = Integration.ID.make("https://invalid.example.com")
-          const entry: WellKnown.Entry = {
-            origin: "https://invalid.example.com",
-            integrationID,
-            manifest: { auth: { command: ["login"], env: "TOKEN" } },
-          }
-          const credentialNode = makeGlobalNode({
-            service: Credential.Service,
-            layer: Layer.succeed(
-              Credential.Service,
-              Credential.Service.of({
-                all: () => Effect.die("unused Credential.all"),
-                list: () =>
-                  Effect.succeed([
-                    new Credential.Info({
-                      id: Credential.ID.create(),
-                      integrationID,
-                      label: "default",
-                      value: Credential.Key.make({ type: "key", key: "wellknown-secret" }),
-                    }),
-                  ]),
-                get: () => Effect.die("unused Credential.get"),
-                create: () => Effect.die("unused Credential.create"),
-                update: () => Effect.die("unused Credential.update"),
-                remove: () => Effect.die("unused Credential.remove"),
-              }),
-            ),
-            deps: [],
-          })
-          const wellknownNode = makeGlobalNode({
-            service: WellKnown.Service,
-            layer: Layer.succeed(
-              WellKnown.Service,
-              WellKnown.Service.of({
-                entries: () => Effect.succeed([entry]),
-                snapshot: () => [entry],
-                refresh: () => Effect.succeed(false),
-                add: () => Effect.die("unused Wellknown.add"),
-                remove: () => Effect.die("unused Wellknown.remove"),
-                // Exercise the loader boundary against a malformed implementation response.
-                resolve: () => Effect.succeed([null as unknown as WellKnown.Config]),
-              }),
-            ),
-            deps: [],
-          })
+  it.effect("detects v1 configuration from any v1-only top-level key", () =>
+    Effect.sync(() => {
+      expect(ConfigMigrateV1.isV1({ snapshot: false })).toBe(true)
+      expect(ConfigMigrateV1.isV1({ snapshot: false, agents: {} })).toBe(true)
+      expect(ConfigMigrateV1.isV1({ reference: {} })).toBe(true)
+      expect(ConfigMigrateV1.isV1({ shell: "/bin/zsh", model: "anthropic/claude" })).toBe(false)
+      expect(ConfigMigrateV1.isV1({ references: {} })).toBe(false)
+    }),
+  )
 
-          yield* Config.Service.use((config) => config.entries()).pipe(
-            Effect.provide(
-              testLayer(project, global, project, undefined, undefined, credentialNode, wellknownNode, {
-                file: malformed,
-                content: "",
-              }),
-            ),
-          )
-
-          expect(output.map((item) => `${item.source}:${item.path}:${item.kind}`).toSorted()).toEqual(
-            [
-              `${path.join(global, "opencode.json")}:$:invalid`,
-              `${path.join(project, "opencode.json")}:$:invalid`,
-              `${malformed}:$:invalid`,
-              "https://invalid.example.com:$:invalid",
-              "OPENCODE_CONFIG_CONTENT:$:invalid",
-            ].toSorted(),
-          )
-          expect(JSON.stringify(output)).not.toContain("secret")
-        }),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(Effect.provide(Logger.layer([logger])))
-  })
+  it.effect("detects a bare v1-shaped mcp block while leaving v2 mcp config alone", () =>
+    Effect.sync(() => {
+      // V1 lists servers directly under `mcp`, so a file with only `$schema` + `mcp` still migrates.
+      expect(ConfigMigrateV1.isV1({ mcp: { context7: { type: "local", command: ["npx"] } } })).toBe(true)
+      expect(ConfigMigrateV1.isV1({ $schema: "x", mcp: { executor: { type: "remote", url: "https://x" } } })).toBe(true)
+      // Current config nests under `mcp.servers`, so it must not be misdetected and re-migrated.
+      expect(ConfigMigrateV1.isV1({ mcp: { servers: { context7: { type: "local", command: ["npx"] } } } })).toBe(false)
+      expect(ConfigMigrateV1.isV1({ mcp: {} })).toBe(false)
+      expect(ConfigMigrateV1.isV1({ mcp: { timeout: { execution: 1000 } } })).toBe(false)
+    }),
+  )
 
   it.effect("migrates arbitrary v1 configuration into valid v2 configuration", () =>
     Effect.sync(() => {

packages/core/test/config/normalization.test.ts

@@ -1,489 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Duration, Schema } from "effect"
-import { FastCheck } from "effect/testing"
-import { ConfigNormalize } from "@opencode-ai/core/config/normalize"
-import { Info } from "@opencode-ai/schema/config"
-
-const options = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" } as const
-
-function normalized(input: unknown) {
-  const result = ConfigNormalize.normalize(input)
-  expect(result.type).toBe("normalized")
-  if (result.type !== "normalized") throw new Error("expected normalized config")
-  return result
-}
-
-function decoded(input: unknown) {
-  return Schema.decodeUnknownSync(Info, options)(normalized(input).encoded)
-}
-
-function withoutEmptyCompatibilityContainers(input: Record<string, unknown>) {
-  const result = structuredClone(input)
-  if (typeof result.mcp === "object" && result.mcp !== null && !Array.isArray(result.mcp)) {
-    const mcp = result.mcp as Record<string, unknown>
-    const originallyEmpty = !Object.keys(mcp).length
-    for (const key of ["servers", "timeout"]) {
-      if (
-        typeof mcp[key] === "object" &&
-        mcp[key] !== null &&
-        !Array.isArray(mcp[key]) &&
-        !Object.keys(mcp[key]).length
-      )
-        delete mcp[key]
-    }
-    if (!originallyEmpty && !Object.keys(mcp).length) delete result.mcp
-  }
-  if (typeof result.compaction === "object" && result.compaction !== null && !Array.isArray(result.compaction)) {
-    const compaction = result.compaction as Record<string, unknown>
-    const originallyEmpty = !Object.keys(compaction).length
-    if (
-      typeof compaction.keep === "object" &&
-      compaction.keep !== null &&
-      !Array.isArray(compaction.keep) &&
-      !Object.keys(compaction.keep).length
-    )
-      delete compaction.keep
-    if (!originallyEmpty && !Object.keys(compaction).length) delete result.compaction
-  }
-  return result
-}
-
-describe("ConfigNormalize", () => {
-  test("rejects every non-object root with one root diagnostic", () => {
-    for (const input of [null, [], "config", true, 1]) {
-      expect(ConfigNormalize.normalize(input)).toEqual({
-        type: "rejected",
-        diagnostics: [
-          {
-            kind: "invalid",
-            path: ["$"],
-            message: "rejected configuration because its root is not an object",
-          },
-        ],
-      })
-    }
-  })
-
-  test("keeps unrelated native fields when a legacy field is present", () => {
-    const result = decoded({ snapshot: false, agents: { reviewer: { system: "Use V2" } } })
-    expect(result.snapshots).toBe(false)
-    expect(result.agents?.reviewer?.system).toBe("Use V2")
-  })
-
-  test("canonicalizes transformed native values through decode then encode", () => {
-    const result = normalized({ warming: { interval: "4 minutes", duration: "30 minutes" } })
-    expect(result.encoded.warming).toEqual({ interval: "240000 millis", duration: "1800000 millis" })
-    const info = Schema.decodeUnknownSync(Info)(result.encoded)
-    if (typeof info.warming === "boolean" || info.warming === undefined) throw new Error("expected warming info")
-    expect(Duration.toMillis(info.warming.interval ?? Duration.zero)).toBe(240_000)
-    expect(Duration.toMillis(info.warming.duration ?? Duration.zero)).toBe(1_800_000)
-  })
-
-  test("preserves arbitrary JSON-round-tripped native configuration", () => {
-    FastCheck.assert(
-      FastCheck.property(Schema.toArbitrary(Info), (info) => {
-        const source = JSON.parse(JSON.stringify(Schema.encodeSync(Info)(info)))
-        const result = normalized(source)
-        expect(Schema.decodeUnknownSync(Info)(result.encoded)).toEqual(
-          Schema.decodeUnknownSync(Info)(withoutEmptyCompatibilityContainers(source)),
-        )
-      }),
-      { numRuns: 100 },
-    )
-  })
-
-  test("merges named maps by entry and gives valid native entries precedence", () => {
-    const result = normalized({
-      reference: { legacy: { path: "../legacy" }, duplicate: { path: "../old" } },
-      references: { native: { path: "../native" }, duplicate: { path: "../new" } },
-      command: { legacy: { template: "legacy" }, duplicate: { template: "old" } },
-      commands: { native: { template: "native" }, duplicate: { template: "new" } },
-    })
-    expect(result.encoded.references).toEqual({
-      legacy: { path: "../legacy" },
-      native: { path: "../native" },
-      duplicate: { path: "../new" },
-    })
-    expect(result.encoded.commands).toEqual({
-      legacy: { template: "legacy" },
-      native: { template: "native" },
-      duplicate: { template: "new" },
-    })
-    expect(result.diagnostics.filter((item) => item.kind === "conflict").map((item) => item.path)).toEqual([
-      ["references", "duplicate"],
-      ["commands", "duplicate"],
-    ])
-  })
-
-  test("does not report canonical-equal duplicates as conflicts", () => {
-    const result = normalized({
-      snapshot: false,
-      snapshots: false,
-      reference: { docs: { path: "../docs" } },
-      references: { docs: { path: "../docs" } },
-      agent: { reviewer: { prompt: "same" } },
-      agents: { reviewer: { system: "same" } },
-      provider: { custom: { name: "same" } },
-      providers: { custom: { name: "same" } },
-      compaction: { preserve_recent_tokens: 1000, keep: { tokens: 1000 } },
-    })
-    expect(result.diagnostics.filter((item) => item.kind === "conflict")).toEqual([])
-  })
-
-  test("uses agent then mode then native agent precedence", () => {
-    const result = normalized({
-      agent: { reviewer: { prompt: "agent" }, agentOnly: { prompt: "agent-only" } },
-      mode: { reviewer: { prompt: "mode" }, modeOnly: { prompt: "mode-only" } },
-      agents: { reviewer: { system: "native" }, nativeOnly: { system: "native-only" } },
-    })
-    expect(result.encoded.agents).toEqual({
-      reviewer: { system: "native" },
-      agentOnly: { system: "agent-only" },
-      modeOnly: { system: "mode-only", mode: "primary" },
-      nativeOnly: { system: "native-only" },
-    })
-    expect(result.diagnostics.filter((item) => item.kind === "conflict").map((item) => item.path)).toEqual([
-      ["agents", "reviewer"],
-      ["agents", "reviewer"],
-    ])
-    expect(() => Schema.decodeUnknownSync(Info)(result.encoded)).not.toThrow()
-  })
-
-  test("recovers malformed named entries and retains a valid legacy collision", () => {
-    const result = normalized({
-      command: { fallback: { template: "legacy" } },
-      commands: {
-        fallback: { template: 1 },
-        valid: { template: "native" },
-        invalid: { template: false },
-      },
-      providers: {
-        valid: { name: "Valid" },
-        invalid: { env: [1] },
-      },
-    })
-    expect(result.encoded.commands).toEqual({ fallback: { template: "legacy" }, valid: { template: "native" } })
-    expect(result.encoded.providers).toEqual({ valid: { name: "Valid" } })
-    expect(result.diagnostics.filter((item) => item.kind === "invalid").map((item) => item.path)).toEqual([
-      ["commands", "fallback"],
-      ["commands", "invalid"],
-      ["providers", "invalid"],
-    ])
-  })
-
-  test("uses a valid retired provider alias when the canonical legacy entry is malformed", () => {
-    const result = normalized({
-      provider: {
-        "azure-cognitive-services": { models: { deployment: {} } },
-        azure: { env: [1] },
-      },
-    })
-    expect(result.encoded.providers).toHaveProperty("azure.models.deployment")
-    expect(result.diagnostics.filter((item) => item.kind === "invalid").map((item) => item.path)).toContainEqual([
-      "provider",
-      "azure",
-    ])
-  })
-
-  test("preserves permission source order and appends native rules", () => {
-    expect(
-      normalized({
-        tools: { bash: true, write: false },
-        permission: { read: "allow", custom: { first: "deny", second: "ask" }, task: "allow" },
-        permissions: [{ action: "native", resource: "*", effect: "deny" }],
-      }).encoded.permissions,
-    ).toEqual([
-      { action: "shell", resource: "*", effect: "allow" },
-      { action: "edit", resource: "*", effect: "deny" },
-      { action: "read", resource: "*", effect: "allow" },
-      { action: "custom", resource: "first", effect: "deny" },
-      { action: "custom", resource: "second", effect: "ask" },
-      { action: "subagent", resource: "*", effect: "allow" },
-      { action: "native", resource: "*", effect: "deny" },
-    ])
-  })
-
-  test("redacts permission resource keys from invalid diagnostics", () => {
-    const result = normalized({
-      permission: { bash: { "curl -H Authorization:Bearer TOPSECRET *": "bogus" } },
-    })
-    expect(result.diagnostics).toEqual([
-      {
-        kind: "invalid",
-        path: ["permission", "bash", "0"],
-        message: "skipped malformed recognized value",
-      },
-    ])
-    expect(JSON.stringify(result.diagnostics)).not.toContain("TOPSECRET")
-  })
-
-  test("recovers list items for skills, plugins, instructions, and permissions", () => {
-    const result = normalized({
-      skills: { paths: ["./skills", 1], urls: [false, "https://example.com/skills"] },
-      plugin: ["legacy", ["tuple", {}], [1, {}]],
-      plugins: ["native", { package: "object" }, { package: 1 }],
-      instructions: ["one", 2, "three"],
-      permissions: [
-        { action: "read", resource: "*", effect: "allow" },
-        { action: "read", resource: "*", effect: "invalid" },
-      ],
-    })
-    expect(result.encoded.skills).toEqual(["./skills", "https://example.com/skills"])
-    expect(result.encoded.plugins).toEqual([
-      "legacy",
-      { package: "tuple", options: {} },
-      "native",
-      { package: "object" },
-    ])
-    expect(result.encoded.instructions).toEqual(["one", "three"])
-    expect(result.encoded.permissions).toEqual([{ action: "read", resource: "*", effect: "allow" }])
-    expect(result.diagnostics.filter((item) => item.kind === "invalid")).toHaveLength(6)
-  })
-
-  test("omits malformed collection roots instead of synthesizing empty values", () => {
-    const result = normalized({
-      commands: [],
-      providers: "invalid",
-      references: false,
-      agents: 1,
-      plugins: {},
-      permissions: {},
-      instructions: {},
-    })
-    expect(result.encoded).toEqual({})
-    expect(result.diagnostics.filter((item) => item.kind === "invalid").map((item) => item.path)).toEqual([
-      ["references"],
-      ["commands"],
-      ["agents"],
-      ["providers"],
-      ["permissions"],
-      ["plugins"],
-      ["instructions"],
-    ])
-  })
-
-  test("omits all-invalid formatter and LSP maps while preserving explicit empty maps", () => {
-    const invalid = normalized({
-      formatter: { prettier: { command: [1] } },
-      lsp: { typescript: { command: [1] } },
-    })
-    expect(invalid.encoded).not.toHaveProperty("formatter")
-    expect(invalid.encoded).not.toHaveProperty("lsp")
-    expect(invalid.diagnostics.filter((item) => item.kind === "invalid").map((item) => item.path)).toEqual([
-      ["formatter", "prettier"],
-      ["lsp", "typescript"],
-    ])
-
-    expect(normalized({ formatter: {}, lsp: {} }).encoded).toMatchObject({ formatter: {}, lsp: {} })
-  })
-
-  test("combines legacy and native MCP servers and merges timeout leaves", () => {
-    const result = normalized({
-      experimental: { mcp_timeout: 5000 },
-      mcp: {
-        legacy: { type: "local", command: ["legacy"] },
-        duplicate: { type: "remote", url: "https://legacy.example.com" },
-        servers: {
-          native: { type: "local", command: ["native"] },
-          duplicate: { type: "remote", url: "https://native.example.com" },
-          invalid: { type: "local", command: [1] },
-        },
-        timeout: { startup: 1000, catalog: 6000 },
-      },
-    })
-    expect(result.encoded.mcp).toEqual({
-      timeout: { catalog: 6000, execution: 5000, startup: 1000 },
-      servers: {
-        legacy: { type: "local", command: ["legacy"], disabled: undefined, timeout: undefined },
-        duplicate: { type: "remote", url: "https://native.example.com" },
-        native: { type: "local", command: ["native"] },
-      },
-    })
-    expect(
-      result.diagnostics.some((item) => item.kind === "conflict" && item.path.join(".") === "mcp.servers.duplicate"),
-    ).toBe(true)
-    expect(
-      result.diagnostics.some((item) => item.kind === "conflict" && item.path.join(".") === "mcp.timeout.catalog"),
-    ).toBe(true)
-    expect(
-      result.diagnostics.some((item) => item.kind === "invalid" && item.path.join(".") === "mcp.servers.invalid"),
-    ).toBe(true)
-  })
-
-  test("uses raw MCP discriminators for reserved server names", () => {
-    const result = normalized({
-      mcp: {
-        servers: { type: "local", command: ["reserved-servers"] },
-        timeout: { type: "remote", url: "https://reserved.example.com" },
-      },
-    })
-    expect((result.encoded.mcp as { servers: Record<string, unknown> }).servers).toEqual({
-      servers: { type: "local", command: ["reserved-servers"], disabled: undefined, timeout: undefined },
-      timeout: { type: "remote", url: "https://reserved.example.com", disabled: undefined, timeout: undefined },
-    })
-
-    const enabledOnly = normalized({ mcp: { servers: { enabled: true }, timeout: { enabled: false } } })
-    expect(enabledOnly.encoded.mcp).toBeUndefined()
-    expect(enabledOnly.diagnostics.map((item) => [item.kind, item.path])).toEqual([
-      ["unsupported", ["mcp", "servers"]],
-      ["unsupported", ["mcp", "timeout"]],
-    ])
-  })
-
-  test("merges bounded compaction leaves and omits unsupported leaves", () => {
-    const result = normalized({
-      compaction: {
-        auto: false,
-        preserve_recent_tokens: 1000,
-        keep: { tokens: 2000 },
-        reserved: 3000,
-        buffer: 4000,
-        tail_turns: 2,
-        prune: true,
-      },
-    })
-    expect(result.encoded.compaction).toEqual({ auto: false, keep: { tokens: 2000 }, buffer: 4000 })
-    expect(result.diagnostics.map((item) => [item.kind, item.path])).toEqual([
-      ["unsupported", ["compaction", "tail_turns"]],
-      ["unsupported", ["compaction", "prune"]],
-      ["conflict", ["compaction", "keep", "tokens"]],
-      ["conflict", ["compaction", "buffer"]],
-    ])
-  })
-
-  test("distinguishes empty, mixed, and wholly malformed enabled provider lists", () => {
-    expect(normalized({ enabled_providers: [] }).encoded.experimental).toEqual({
-      policies: [{ action: "provider.use", resource: "*", effect: "deny" }],
-    })
-    expect(normalized({ enabled_providers: [1, "anthropic", false] }).encoded.experimental).toEqual({
-      policies: [
-        { action: "provider.use", resource: "*", effect: "deny" },
-        { action: "provider.use", resource: "anthropic", effect: "allow" },
-      ],
-    })
-    expect(normalized({ enabled_providers: [1, false] }).encoded.experimental).toBeUndefined()
-    expect(normalized({ enabled_providers: "anthropic" }).encoded.experimental).toBeUndefined()
-  })
-
-  test("appends native policies after migrated provider policies", () => {
-    expect(
-      normalized({
-        enabled_providers: ["anthropic"],
-        disabled_providers: ["openai"],
-        experimental: {
-          subagent_depth: 0,
-          policies: [{ action: "provider.use", resource: "custom", effect: "allow" }],
-        },
-      }).encoded.experimental,
-    ).toEqual({
-      subagent_depth: 0,
-      policies: [
-        { action: "provider.use", resource: "*", effect: "deny" },
-        { action: "provider.use", resource: "anthropic", effect: "allow" },
-        { action: "provider.use", resource: "openai", effect: "deny" },
-        { action: "provider.use", resource: "custom", effect: "allow" },
-      ],
-    })
-  })
-
-  test("reports unsupported legacy settings without including their values", () => {
-    const secret = "do-not-log-this-value"
-    const result = normalized({
-      logLevel: "DEBUG",
-      small_model: secret,
-      agent: { reviewer: { name: secret, prompt: "review" } },
-      provider: {
-        custom: {
-          id: secret,
-          whitelist: ["model"],
-          models: {
-            model: {
-              release_date: secret,
-              status: "active",
-              interleaved: true,
-            },
-          },
-        },
-      },
-      experimental: { openTelemetry: true },
-    })
-    expect(result.diagnostics.filter((item) => item.kind === "unsupported").map((item) => item.path)).toEqual([
-      ["logLevel"],
-      ["small_model"],
-      ["agent", "reviewer", "name"],
-      ["provider", "custom", "id"],
-      ["provider", "custom", "whitelist"],
-      ["provider", "custom", "models", "model", "release_date"],
-      ["provider", "custom", "models", "model", "status"],
-      ["provider", "custom", "models", "model", "interleaved"],
-      ["experimental", "openTelemetry"],
-    ])
-    expect(JSON.stringify(result.diagnostics)).not.toContain(secret)
-  })
-
-  test("diagnoses unsupported legacy model selections without dropping their entries", () => {
-    const result = normalized({
-      command: {
-        invalidModel: { template: "one", model: "invalid" },
-        invalidVariant: { template: "two", model: "anthropic/model", variant: "bad#variant" },
-        missingModel: { template: "three", variant: "high" },
-      },
-      agent: { invalid: { prompt: "agent", model: "invalid", variant: "" } },
-    })
-    expect(Object.keys(result.encoded.commands as Record<string, unknown>)).toEqual([
-      "invalidModel",
-      "invalidVariant",
-      "missingModel",
-    ])
-    expect(Object.keys(result.encoded.agents as Record<string, unknown>)).toEqual(["invalid"])
-    expect(result.diagnostics.filter((item) => item.kind === "unsupported").map((item) => item.path)).toEqual([
-      ["command", "invalidModel", "model"],
-      ["command", "invalidVariant", "variant"],
-      ["command", "missingModel", "variant"],
-      ["agent", "invalid", "model"],
-      ["agent", "invalid", "variant"],
-    ])
-  })
-
-  test("invalid legacy provider overlays skip only that provider", () => {
-    const result = normalized({
-      provider: {
-        headers: { options: { headers: { valid: "yes", invalid: 1 } } },
-        body: { options: { body: "not-an-object" } },
-        valid: { options: { headers: { valid: "yes" }, body: { trace: true } } },
-      },
-    })
-    expect(result.encoded.providers).toEqual({
-      valid: { settings: {}, headers: { valid: "yes" }, body: { trace: true } },
-    })
-    expect(result.diagnostics.filter((item) => item.kind === "invalid").map((item) => item.path)).toEqual([
-      ["provider", "headers", "options", "headers"],
-      ["provider", "body", "options", "body"],
-    ])
-  })
-
-  test("preserves explicit false, zero, empty list, and empty map presence", () => {
-    const result = normalized({
-      snapshot: false,
-      autoshare: false,
-      references: {},
-      commands: {},
-      agents: {},
-      providers: {},
-      plugins: [],
-      instructions: [],
-      experimental: { subagent_depth: 0 },
-    })
-    expect(result.encoded).toMatchObject({
-      snapshots: false,
-      references: {},
-      commands: {},
-      agents: {},
-      providers: {},
-      plugins: [],
-      instructions: [],
-      experimental: { subagent_depth: 0 },
-    })
-    expect(result.encoded.share).toBeUndefined()
-  })
-})

packages/core/test/config/provider.test.ts

@@ -237,11 +237,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
                   models: {
                     chat: {
                       name: "First",
-                      compatibility: {
-                        reasoningField: "vendor_reasoning",
-                        maxTokensField: "max_completion_tokens",
-                        requireFinishReason: false,
-                      },
+                      compatibility: { reasoningField: "vendor_reasoning" },
                       capabilities: { tools: true, input: ["text"], output: ["text"] },
                       disabled: true,
                       limit: { context: 100, output: 50 },
@@ -322,11 +318,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
         expect(model.id).toBe(modelID)
         expect(model.modelID).toBe(Model.ID.make("api-chat"))
         expect(model.name).toBe("Last")
-        expect(model.compatibility).toEqual({
-          reasoningField: "vendor_reasoning",
-          maxTokensField: "max_completion_tokens",
-          requireFinishReason: false,
-        })
+        expect(model.compatibility).toEqual({ reasoningField: "vendor_reasoning" })
         expect(model.capabilities).toEqual({ tools: true, input: ["text"], output: ["text"] })
         expect(model.enabled).toBe(false)
         expect(model.limit).toEqual({ context: 100, output: 75 })

packages/core/test/environment.test.ts

@@ -1,40 +0,0 @@
-import fs from "node:fs/promises"
-import { Effect } from "effect"
-import { ChildProcessSpawner } from "effect/unstable/process"
-import { CrossSpawnSpawner } from "@opencode-ai/util/cross-spawn-spawner"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { execDefaults, Failed, makeFiles, makeMemoryDriver } from "../src/environment/index"
-import { tmpdir } from "./fixture/tmpdir"
-import { environmentConformance } from "./lib/environment-conformance"
-
-environmentConformance("memory environment", () => {
-  const driver = makeMemoryDriver()
-  return {
-    files: makeFiles(driver),
-    root: `/workspace-${crypto.randomUUID()}`,
-    symlink: driver.symlink,
-  }
-})
-
-environmentConformance(
-  "GNU exec environment",
-  async () => {
-    const spawner = await Effect.runPromise(
-      Effect.gen(function* () {
-        return yield* ChildProcessSpawner.ChildProcessSpawner
-      }).pipe(Effect.provide(LayerNode.compile(CrossSpawnSpawner.node))),
-    )
-    const tmp = await tmpdir("opencode-environment-")
-    return {
-      files: execDefaults(spawner),
-      root: tmp.path,
-      symlink: (target: string, link: string) =>
-        Effect.tryPromise({
-          try: () => fs.symlink(target, link),
-          catch: (cause) => new Failed({ path: link, cause }),
-        }),
-      dispose: () => tmp[Symbol.asyncDispose](),
-    }
-  },
-  process.platform !== "linux",
-)

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

@@ -1,148 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { Failed, NotFound, WrongKind, type Files } from "../../src/environment/index"
-
-export interface EnvironmentHarness {
-  readonly files: Files
-  readonly root: string
-  readonly symlink?: (target: string, path: string) => Effect.Effect<void, Failed>
-  readonly dispose?: () => Promise<void>
-}
-
-export const environmentConformance = (
-  name: string,
-  makeHarness: () => EnvironmentHarness | Promise<EnvironmentHarness>,
-  skip = false,
-) => {
-  const check = (title: string, body: (harness: EnvironmentHarness) => Promise<void>) =>
-    test(title, async () => {
-      const harness = await makeHarness()
-      try {
-        await Effect.runPromise(harness.files.mkdir(harness.root))
-        await body(harness)
-      } finally {
-        try {
-          await Effect.runPromise(harness.files.remove(harness.root))
-        } finally {
-          await harness.dispose?.()
-        }
-      }
-    })
-
-  const bytes = (value: string) => new TextEncoder().encode(value)
-  const text = (value: Uint8Array) => new TextDecoder().decode(value)
-  const failure = <E>(effect: Effect.Effect<unknown, E>) => Effect.runPromise(Effect.flip(effect))
-
-  const suite = skip ? describe.skip : describe
-
-  suite(name, () => {
-    check("writes, stats, and reads a file with its info", async ({ files, root }) => {
-      const target = `${root}/hello.txt`
-      await Effect.runPromise(files.write(target, bytes("hello")))
-      const result = await Effect.runPromise(files.read(target))
-      expect(text(result.bytes)).toBe("hello")
-      expect(result.info.type).toBe("file")
-      expect(result.info.size).toBe(5)
-      expect(await Effect.runPromise(files.stat(target))).toEqual(result.info)
-    })
-
-    check("reports missing paths", async ({ files, root }) => {
-      const target = `${root}/missing`
-      expect(await failure(files.read(target))).toBeInstanceOf(NotFound)
-      expect(await failure(files.stat(target))).toBeInstanceOf(NotFound)
-      expect(await failure(files.list(target))).toBeInstanceOf(NotFound)
-      expect(await failure(files.move(target, `${root}/other`))).toBeInstanceOf(NotFound)
-    })
-
-    check("reports the actual kind", async ({ files, root }) => {
-      const directory = `${root}/directory`
-      const file = `${root}/file`
-      await Effect.runPromise(files.mkdir(directory))
-      await Effect.runPromise(files.write(file, bytes("data")))
-      const readError = await failure(files.read(directory))
-      const listError = await failure(files.list(file))
-      expect(readError).toBeInstanceOf(WrongKind)
-      expect((readError as WrongKind).actual).toBe("directory")
-      expect(listError).toBeInstanceOf(WrongKind)
-      expect((listError as WrongKind).actual).toBe("file")
-    })
-
-    check("write creates parent directories", async ({ files, root }) => {
-      const target = `${root}/one/two/file`
-      await Effect.runPromise(files.write(target, bytes("nested")))
-      await Effect.runPromise(files.write(`${root}/empty`, new Uint8Array()))
-      expect((await Effect.runPromise(files.stat(`${root}/one/two`))).type).toBe("directory")
-      expect(await Effect.runPromise(files.stat(`${root}/empty`))).toMatchObject({ type: "file", size: 0 })
-      expect(text((await Effect.runPromise(files.read(target))).bytes)).toBe("nested")
-    })
-
-    check("reads byte ranges", async ({ files, root }) => {
-      const target = `${root}/range`
-      await Effect.runPromise(files.write(target, bytes("0123456789")))
-      expect(text((await Effect.runPromise(files.read(target, { offset: 2, length: 4 }))).bytes)).toBe("2345")
-      expect(text((await Effect.runPromise(files.read(target, { offset: 8, length: 8 }))).bytes)).toBe("89")
-      expect(text((await Effect.runPromise(files.read(target, { offset: 20, length: 4 }))).bytes)).toBe("")
-    })
-
-    check("lists immediate entries with their kinds", async ({ files, root }) => {
-      await Effect.runPromise(files.write(`${root}/file name`, bytes("data")))
-      await Effect.runPromise(files.mkdir(`${root}/directory`))
-      await Effect.runPromise(files.write(`${root}/directory/nested`, bytes("nested")))
-      const entries = await Effect.runPromise(files.list(root))
-      expect(entries.toSorted((a, b) => a.name.localeCompare(b.name))).toEqual([
-        { name: "directory", type: "directory" },
-        { name: "file name", type: "file" },
-      ])
-    })
-
-    check("reports symlinks without resolving them", async (harness) => {
-      if (!harness.symlink) return
-      await Effect.runPromise(harness.files.write(`${harness.root}/target`, bytes("target")))
-      await Effect.runPromise(harness.files.write(`${harness.root}/target-dir/file`, bytes("through link")))
-      await Effect.runPromise(harness.symlink("target", `${harness.root}/link`))
-      await Effect.runPromise(harness.symlink("target-dir", `${harness.root}/link-dir`))
-      expect((await Effect.runPromise(harness.files.stat(`${harness.root}/link`))).type).toBe("symlink")
-      expect(await Effect.runPromise(harness.files.list(harness.root))).toContainEqual({
-        name: "link",
-        type: "symlink",
-      })
-      expect(text((await Effect.runPromise(harness.files.read(`${harness.root}/link-dir/file`))).bytes)).toBe(
-        "through link",
-      )
-      const listError = await failure(harness.files.list(`${harness.root}/link-dir`))
-      expect(listError).toBeInstanceOf(WrongKind)
-      expect((listError as WrongKind).actual).toBe("symlink")
-    })
-
-    check("follows symlinks when reading", async (harness) => {
-      if (!harness.symlink) return
-      await Effect.runPromise(harness.files.write(`${harness.root}/target`, bytes("target content")))
-      await Effect.runPromise(harness.files.mkdir(`${harness.root}/directory`))
-      await Effect.runPromise(harness.symlink("target", `${harness.root}/file-link`))
-      await Effect.runPromise(harness.symlink("directory", `${harness.root}/directory-link`))
-      await Effect.runPromise(harness.symlink("missing", `${harness.root}/dangling-link`))
-
-      const result = await Effect.runPromise(harness.files.read(`${harness.root}/file-link`))
-      expect(text(result.bytes)).toBe("target content")
-      expect(result.info.type).toBe("file")
-      expect(result.info.size).toBe(bytes("target content").length)
-
-      const directoryError = await failure(harness.files.read(`${harness.root}/directory-link`))
-      expect(directoryError).toBeInstanceOf(WrongKind)
-      expect((directoryError as WrongKind).actual).toBe("directory")
-      expect(await failure(harness.files.read(`${harness.root}/dangling-link`))).toBeInstanceOf(NotFound)
-    })
-
-    check("moves files and removes trees idempotently", async ({ files, root }) => {
-      const source = `${root}/source/file`
-      const destination = `${root}/destination`
-      await Effect.runPromise(files.write(source, bytes("moved")))
-      await Effect.runPromise(files.move(source, destination))
-      expect(text((await Effect.runPromise(files.read(destination))).bytes)).toBe("moved")
-      expect(await failure(files.stat(source))).toBeInstanceOf(NotFound)
-      await Effect.runPromise(files.remove(`${root}/source`))
-      await Effect.runPromise(files.remove(`${root}/source`))
-      expect(await failure(files.stat(`${root}/source`))).toBeInstanceOf(NotFound)
-    })
-  })
-}

packages/core/test/model-resolver.test.ts

@@ -194,11 +194,7 @@ describe("ModelResolver", () => {
     Effect.gen(function* () {
       const resolved = yield* ModelResolver.fromCatalogModel(
         model(Provider.aisdk("@ai-sdk/openai-compatible"), {
-          compatibility: {
-            reasoningField: "vendor_reasoning",
-            maxTokensField: "max_completion_tokens",
-            requireFinishReason: false,
-          },
+          compatibility: { reasoningField: "vendor_reasoning" },
           settings: {
             apiKey: "settings-secret",
             baseURL: "https://compatible.example/v1",
@@ -208,8 +204,7 @@ describe("ModelResolver", () => {
           body: {},
         }),
       )
-      const request = LLM.request({ model: resolved, prompt: "Hello", generation: { maxTokens: 10 } })
-      const prepared = yield* compileRequest(request)
+      const request = LLM.request({ model: resolved, prompt: "Hello" })
       const headers = yield* resolved.route.auth.apply({
         request,
         method: "POST",
@@ -221,10 +216,6 @@ describe("ModelResolver", () => {
       expect(headers.authorization).toBe("Bearer settings-secret")
       expect(resolved.route.id).toBe("openai-compatible-chat")
       expect(resolved.compatibility?.reasoningField).toBe("vendor_reasoning")
-      expect(resolved.compatibility?.maxTokensField).toBe("max_completion_tokens")
-      expect(resolved.compatibility?.requireFinishReason).toBe(false)
-      expect(prepared.body).toMatchObject({ max_completion_tokens: 10 })
-      expect(prepared.body).not.toHaveProperty("max_tokens")
       expect(resolved.route.endpoint.baseURL).toBe("https://compatible.example/v1")
       expect(resolved.route.defaults.http?.body).toEqual({})
     }),

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

@@ -23,7 +23,6 @@ import { SessionPending } from "@opencode-ai/core/session/pending"
 import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
-import { SessionTransfer } from "@opencode-ai/core/session/transfer"
 import { Workspace } from "@opencode-ai/core/workspace"
 import { testEffect } from "./lib/effect"
 import { tmpdir } from "./fixture/tmpdir"
@@ -38,14 +37,7 @@ const projects = Layer.succeed(
 )
 const it = testEffect(
   AppNodeBuilder.build(
-    LayerNode.group([
-      Database.node,
-      Bus.node,
-      SessionProjector.node,
-      SessionStore.node,
-      Session.node,
-      SessionTransfer.node,
-    ]),
+    LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node, Session.node]),
     [
       [Bus.node, Bus.configured({ persist: true })],
       [Project.node, projects],
@@ -748,77 +740,3 @@ describe("Session.create", () => {
     }),
   )
 })
-
-describe("SessionTransfer", () => {
-  it.effect("imports projected messages and reserves their aggregate sequence", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const transfer = yield* SessionTransfer.Service
-      const bus = yield* Bus.Service
-      const { db } = yield* Database.Service
-      const template = yield* session.create({ location, title: "Exported" })
-      const sessionID = Session.ID.create()
-      const sourceMessageID = SessionMessage.ID.create()
-      const errorMessageID = SessionMessage.ID.create()
-
-      const imported = yield* transfer.import({
-        data: {
-          info: { ...template, id: sessionID },
-          messages: [
-            {
-              id: sourceMessageID,
-              type: "user",
-              text: "Imported message",
-              time: { created: DateTime.makeUnsafe(100) },
-            },
-            {
-              id: errorMessageID,
-              type: "compaction",
-              status: "failed",
-              reason: "manual",
-              error: { type: "test_error", message: "Original error" },
-              time: { created: DateTime.makeUnsafe(101) },
-            },
-          ],
-        },
-        location,
-      })
-      const messages = yield* session.messages({ sessionID, order: "asc" })
-
-      expect(imported).toMatchObject({ id: sessionID, title: "Exported", location })
-      expect(messages).toMatchObject([
-        { id: sourceMessageID, type: "user", text: "Imported message" },
-        { id: errorMessageID, type: "compaction", error: { type: "test_error", message: "Original error" } },
-      ])
-      expect(yield* Bus.latestSequence(db, sessionID)).toBe(2)
-      expect((yield* transfer.export({ sessionID })).messages).toEqual(messages)
-      expect((yield* transfer.export({ sessionID, sanitize: true })).messages).toMatchObject([
-        { id: sourceMessageID, text: `[redacted:text:${sourceMessageID}]` },
-        { id: errorMessageID, error: { type: "test_error", message: "Original error" } },
-      ])
-
-      yield* session.prompt({ sessionID, text: "Continue", resume: false })
-      yield* SessionPending.promote(db, bus, sessionID, "steer")
-
-      expect((yield* session.messages({ sessionID, order: "asc" })).map((message) => message.type)).toEqual([
-        "user",
-        "compaction",
-        "user",
-      ])
-      expect(yield* Bus.latestSequence(db, sessionID)).toBe(4)
-    }),
-  )
-
-  it.effect("rejects an existing session ID without changing its transcript", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const transfer = yield* SessionTransfer.Service
-      const existing = yield* session.create({ location, title: "Existing" })
-      const exit = yield* Effect.exit(transfer.import({ data: { info: existing, messages: [] }, location }))
-
-      expect(exit._tag).toBe("Failure")
-      expect((yield* session.get(existing.id)).title).toBe("Existing")
-      expect(yield* session.messages({ sessionID: existing.id })).toEqual([])
-    }),
-  )
-})

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

@@ -1086,4 +1086,78 @@ describe("Session.pending", () => {
       expect(yield* session.pending(sessionID)).toEqual([])
     }),
   )
+
+  it.effect("cancels only queued input and allows its ID to be admitted again", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const session = yield* Session.Service
+      const inputID = SessionMessage.ID.make("msg_cancelled_queue")
+      yield* session.prompt({
+        id: inputID,
+        sessionID,
+        text: "Queue this",
+        delivery: "queue",
+        resume: false,
+      })
+
+      yield* session.cancelPending({ sessionID, inputID })
+
+      expect(yield* session.pending(sessionID)).toEqual([])
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputCancelled.type, 1))).toBe(1)
+      expect(
+        yield* session.cancelPending({ sessionID, inputID }).pipe(Effect.flip),
+      ).toMatchObject({ _tag: "Session.PendingInputConflictError", sessionID, inputID })
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputCancelled.type, 1))).toBe(1)
+
+      const retried = yield* session.prompt({
+        id: inputID,
+        sessionID,
+        text: "Queue this",
+        delivery: "queue",
+        resume: false,
+      })
+      expect(retried).toMatchObject({ id: inputID, delivery: "queue" })
+    }),
+  )
+
+  it.effect("moves pending input between steer and queue delivery", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const session = yield* Session.Service
+      const queued = yield* session.synthetic({
+        sessionID,
+        text: "Steer this",
+        delivery: "queue",
+        resume: false,
+      })
+      const alreadySteered = yield* session.prompt({ sessionID, text: "Already steer", resume: false })
+      wakeCalls.length = 0
+
+      yield* session.steerPending({ sessionID, inputID: queued.id })
+
+      expect(yield* session.pending(sessionID)).toMatchObject([
+        { id: queued.id, delivery: "steer" },
+        { id: alreadySteered.id, delivery: "steer" },
+      ])
+      expect(wakeCalls).toEqual([sessionID])
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputSteered.type, 1))).toBe(1)
+
+      wakeCalls.length = 0
+      yield* session.queuePending({ sessionID, inputID: queued.id })
+      expect(yield* session.pending(sessionID)).toMatchObject([
+        { id: queued.id, delivery: "queue" },
+        { id: alreadySteered.id, delivery: "steer" },
+      ])
+      expect(wakeCalls).toEqual([])
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputQueued.type, 1))).toBe(1)
+
+      expect(
+        yield* session.steerPending({ sessionID, inputID: alreadySteered.id }).pipe(Effect.flip),
+      ).toMatchObject({ _tag: "Session.PendingInputConflictError", sessionID, inputID: alreadySteered.id })
+      yield* session.cancelPending({ sessionID, inputID: alreadySteered.id })
+      expect(wakeCalls).toEqual([])
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputSteered.type, 1))).toBe(1)
+      expect(yield* eventCount(Bus.versionedType(SessionEvent.InputCancelled.type, 1))).toBe(1)
+    }),
+  )
 })

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

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect } from "bun:test"
-import { Deferred, Effect, Layer } from "effect"
+import { Effect, Layer } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Permission } from "@opencode-ai/core/permission"
@@ -39,8 +39,6 @@ const providers = [
 let providerRequired = false
 let formResponse: Form.TerminalState = { status: "cancelled" }
 const formResponses: Form.TerminalState[] = []
-let queryBarrier: Deferred.Deferred<void> | undefined
-let synchronizedQueries = 0
 let result = new WebSearch.Response({
   providerID: WebSearch.ID.make("exa"),
   results: [{ url: "https://example.com", title: "Search results", content: "search results", time: {} }],
@@ -54,8 +52,6 @@ beforeEach(() => {
   providerRequired = false
   formResponse = { status: "cancelled" }
   formResponses.length = 0
-  queryBarrier = undefined
-  synchronizedQueries = 0
   result = new WebSearch.Response({
     providerID: WebSearch.ID.make("exa"),
     results: [{ url: "https://example.com", title: "Search results", content: "search results", time: {} }],
@@ -79,21 +75,11 @@ const websearch = Layer.succeed(
     transform: () => Effect.die("unused"),
     reload: () => Effect.die("unused"),
     providers: () => Effect.succeed(providers),
-    default: () =>
-      Effect.gen(function* () {
-        const stored = values.get("websearch:provider")
-        if (stored === false) return yield* new WebSearch.DisabledError()
-        return typeof stored === "string" ? providers.find((provider) => provider.id === stored) : undefined
-      }),
+    default: () => Effect.succeed(undefined),
     query: (input) =>
       Effect.gen(function* () {
         queries.push(input)
         const stored = values.get("websearch:provider")
-        if (queryBarrier && synchronizedQueries < 5) {
-          synchronizedQueries++
-          if (synchronizedQueries === 5) yield* Deferred.succeed(queryBarrier, undefined)
-          yield* Deferred.await(queryBarrier)
-        }
         if (providerRequired && typeof stored !== "string") return yield* new WebSearch.ProviderRequiredError()
         if (typeof stored === "string")
           return new WebSearch.Response({ providerID: WebSearch.ID.make(stored), results: result.results })
@@ -330,35 +316,6 @@ describe("WebSearchTool registration", () => {
     }),
   )
 
-  it.effect("shares provider consent across concurrent searches", () =>
-    Effect.gen(function* () {
-      providerRequired = true
-      formResponse = { status: "answered", answer: { choice: "allow" } }
-      queryBarrier = yield* Deferred.make<void>()
-      const registry = yield* Tool.Service
-
-      const results = yield* Effect.all(
-        Array.from({ length: 5 }, (_, index) =>
-          executeTool(registry, {
-            sessionID,
-            ...toolIdentity,
-            call: {
-              type: "tool-call",
-              id: `call-concurrent-${index}`,
-              name: "websearch",
-              input: { query: `effect ${index}` },
-            },
-          }),
-        ),
-        { concurrency: "unbounded" },
-      )
-
-      expect(results.every((item) => item.status === "completed")).toBe(true)
-      expect(formRequests).toHaveLength(1)
-      expect(values.get("websearch:provider")).toBe("exa")
-    }),
-  )
-
   it.effect("persists the choice to disable web search", () =>
     Effect.gen(function* () {
       providerRequired = true

packages/protocol/src/groups/session.ts

@@ -1,5 +1,4 @@
 import { SessionMessage } from "@opencode-ai/schema/session-message"
-import { SessionTransfer } from "@opencode-ai/schema/session-transfer"
 import { SessionPending } from "@opencode-ai/schema/session-pending"
 import { PromptInput } from "@opencode-ai/schema/prompt-input"
 import { Session } from "@opencode-ai/schema/session"
@@ -164,36 +163,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
         }),
       ),
     )
-    .add(
-      HttpApiEndpoint.post("session.import", "/api/session/import", {
-        payload: Schema.Struct({
-          ...SessionTransfer.Data.fields,
-          location: Location.Ref.pipe(Schema.optional),
-        }),
-        success: Schema.Struct({ data: Session.Info }),
-        error: ConflictError,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.session.import",
-          summary: "Import session",
-          description: "Import a projected session transcript at the requested location.",
-        }),
-      ),
-    )
-    .add(
-      HttpApiEndpoint.get("session.export", "/api/session/:sessionID/export", {
-        params: { sessionID: Session.ID },
-        query: Schema.Struct({ sanitize: BooleanFromString.pipe(Schema.optional) }),
-        success: Schema.Struct({ data: SessionTransfer.Data }),
-        error: [SessionNotFoundError, UnknownError],
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.session.export",
-          summary: "Export session",
-          description: "Export a complete projected session transcript.",
-        }),
-      ),
-    )
     .add(
       HttpApiEndpoint.get("session.active", "/api/session/active", {
         success: Schema.Struct({ data: Schema.Record(Session.ID, SessionActive) }),
@@ -522,6 +491,45 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
           }),
         ),
     )
+    .add(
+      HttpApiEndpoint.delete("session.pending.cancel", "/api/session/:sessionID/pending/:inputID", {
+        params: { sessionID: Session.ID, inputID: SessionMessage.ID },
+        success: HttpApiSchema.NoContent,
+        error: [ConflictError, SessionNotFoundError],
+      }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "v2.session.pending.cancel",
+            summary: "Cancel pending input",
+            description: "Cancel an input that has not yet been promoted into session history.",
+          }),
+        ),
+    )
+    .add(
+      HttpApiEndpoint.post("session.pending.steer", "/api/session/:sessionID/pending/:inputID/steer", {
+        params: { sessionID: Session.ID, inputID: SessionMessage.ID },
+        success: HttpApiSchema.NoContent,
+        error: [ConflictError, SessionNotFoundError],
+      }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "v2.session.pending.steer",
+            summary: "Steer queued input",
+            description: "Change a queued input to steer delivery and wake session execution.",
+          }),
+        ),
+    )
+    .add(
+      HttpApiEndpoint.post("session.pending.queue", "/api/session/:sessionID/pending/:inputID/queue", {
+        params: { sessionID: Session.ID, inputID: SessionMessage.ID },
+        success: HttpApiSchema.NoContent,
+        error: [ConflictError, SessionNotFoundError],
+      }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "v2.session.pending.queue",
+            summary: "Queue pending steer",
+            description: "Change a pending steer to queued delivery.",
+          }),
+        ),
+    )
     .add(
       HttpApiEndpoint.get("session.instructions.entry.list", "/api/session/:sessionID/instructions/entries", {
         params: { sessionID: Session.ID },

packages/schema/src/index.ts

@@ -25,7 +25,6 @@ export { Vcs } from "./vcs.js"
 export { SessionPending } from "./session-pending.js"
 export { SessionError } from "./session-error.js"
 export { SessionMessage } from "./session-message.js"
-export { SessionTransfer } from "./session-transfer.js"
 export { Snapshot } from "./snapshot.js"
 export { Shell } from "./shell.js"
 export { Skill } from "./skill.js"

packages/schema/src/model.ts

@@ -47,16 +47,9 @@ export const ReasoningField: Schema.Codec<ReasoningField> = Schema.Union([
   Schema.String,
 ]).annotate({ identifier: "Model.ReasoningField" })
 
-export const MaxTokensField = Schema.Literals(["max_completion_tokens", "max_tokens"]).annotate({
-  identifier: "Model.MaxTokensField",
-})
-export type MaxTokensField = typeof MaxTokensField.Type
-
 export interface Compatibility extends Schema.Schema.Type<typeof Compatibility> {}
 export const Compatibility = Schema.Struct({
   reasoningField: ReasoningField.pipe(optional),
-  maxTokensField: MaxTokensField.pipe(optional),
-  requireFinishReason: Schema.Boolean.pipe(optional),
 }).annotate({ identifier: "Model.Compatibility" })
 
 export interface Capabilities extends Schema.Schema.Type<typeof Capabilities> {}

packages/schema/src/session-event.ts

@@ -173,6 +173,36 @@ export const InputAdmitted = Event.durable({
 })
 export type InputAdmitted = typeof InputAdmitted.Type
 
+export const InputCancelled = Event.durable({
+  type: "session.input.cancelled",
+  ...options,
+  schema: {
+    sessionID: SessionID,
+    inputID: SessionMessage.ID,
+  },
+})
+export type InputCancelled = typeof InputCancelled.Type
+
+export const InputSteered = Event.durable({
+  type: "session.input.steered",
+  ...options,
+  schema: {
+    sessionID: SessionID,
+    inputID: SessionMessage.ID,
+  },
+})
+export type InputSteered = typeof InputSteered.Type
+
+export const InputQueued = Event.durable({
+  type: "session.input.queued",
+  ...options,
+  schema: {
+    sessionID: SessionID,
+    inputID: SessionMessage.ID,
+  },
+})
+export type InputQueued = typeof InputQueued.Type
+
 export namespace Execution {
   export const Started = Event.durable({ type: "session.execution.started", ...options, schema: Base })
   export type Started = typeof Started.Type
@@ -580,6 +610,9 @@ export const Definitions = Event.inventory(
   Forked,
   InputPromoted,
   InputAdmitted,
+  InputCancelled,
+  InputSteered,
+  InputQueued,
   Execution.Started,
   Execution.Succeeded,
   Execution.Failed,
@@ -621,13 +654,16 @@ export const DurableDefinitions = Event.inventory(
   ...Definitions.filter((definition) => definition.durability === "durable"),
   UsageRecorded,
 )
+export const EphemeralDefinitions = Event.inventory(
+  ...Definitions.filter((definition) => definition.durability === "ephemeral"),
+)
 
 export const Durable = Schema.Union(DurableDefinitions, { mode: "oneOf" })
   .pipe(Schema.toTaggedUnion("type"))
   .annotate({ identifier: "Session.Event.Durable" })
 export type DurableEvent = typeof Durable.Type
 
-export const All = Schema.Union(Event.inventory(...Definitions, UsageRecorded), { mode: "oneOf" }).pipe(
+export const All = Schema.Union([Durable, ...EphemeralDefinitions], { mode: "oneOf" }).pipe(
   Schema.toTaggedUnion("type"),
 )
 export type Event = typeof All.Type

packages/schema/src/session-transfer.ts

@@ -1,11 +0,0 @@
-export * as SessionTransfer from "./session-transfer.js"
-
-import { Schema } from "effect"
-import { Session } from "./session.js"
-import { SessionMessage } from "./session-message.js"
-
-export interface Data extends Schema.Schema.Type<typeof Data> {}
-export const Data = Schema.Struct({
-  info: Session.Info,
-  messages: Schema.Array(SessionMessage.Info),
-}).annotate({ identifier: "SessionTransfer.Data" })

packages/schema/test/event-manifest.test.ts

@@ -84,6 +84,9 @@ describe("public event manifest", () => {
         "session.forked.2",
         "session.input.promoted.1",
         "session.input.admitted.1",
+        "session.input.cancelled.1",
+        "session.input.steered.1",
+        "session.input.queued.1",
         "session.execution.started.1",
         "session.execution.succeeded.1",
         "session.execution.failed.1",

packages/schema/test/model.test.ts

@@ -30,22 +30,3 @@ describe("Model.ReasoningField", () => {
       expect(decode(field)).toBe(field)
   })
 })
-
-describe("Model.Compatibility", () => {
-  test("decodes model compatibility overrides", () => {
-    const decode = Schema.decodeUnknownSync(Model.Compatibility)
-
-    expect(decode({})).toEqual({})
-    expect(
-      decode({
-        reasoningField: "vendor_reasoning",
-        maxTokensField: "max_completion_tokens",
-        requireFinishReason: false,
-      }),
-    ).toEqual({
-      reasoningField: "vendor_reasoning",
-      maxTokensField: "max_completion_tokens",
-      requireFinishReason: false,
-    })
-  })
-})

packages/server/src/handlers/session.ts

@@ -1,5 +1,4 @@
 import { Session } from "@opencode-ai/core/session"
-import { SessionTransfer } from "@opencode-ai/core/session/transfer"
 import { InstructionEntry } from "@opencode-ai/core/session/instruction-entry"
 import { DateTime, Effect, Stream } from "effect"
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
@@ -25,7 +24,22 @@ const DefaultSessionsLimit = 50
 export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handlers) =>
   Effect.gen(function* () {
     const session = yield* Session.Service
-    const transfer = yield* SessionTransfer.Service
+    const pendingMutation = (effect: ReturnType<typeof session.cancelPending>, conflict: string) =>
+      effect.pipe(
+        Effect.catchTag(
+          "Session.NotFoundError",
+          (error) =>
+            new SessionNotFoundError({
+              sessionID: error.sessionID,
+              message: `Session not found: ${error.sessionID}`,
+            }),
+        ),
+        Effect.catchTag(
+          "Session.PendingInputConflictError",
+          (error) => new ConflictError({ resource: error.inputID, message: `${conflict}: ${error.inputID}` }),
+        ),
+        Effect.as(HttpApiSchema.NoContent.make()),
+      )
 
     return handlers
       .handle(
@@ -88,56 +102,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
           }
         }),
       )
-      .handle(
-        "session.import",
-        Effect.fn(function* (ctx) {
-          return {
-            data: yield* transfer
-              .import({
-                data: { info: ctx.payload.info, messages: ctx.payload.messages },
-                location: ctx.payload.location ?? { directory: AbsolutePath.make(process.cwd()) },
-              })
-              .pipe(
-                Effect.catchTag(
-                  "SessionTransfer.ImportConflictError",
-                  (error) =>
-                    new ConflictError({
-                      message: `Session already exists: ${error.sessionID}`,
-                      resource: error.sessionID,
-                    }),
-                ),
-              ),
-          }
-        }),
-      )
-      .handle(
-        "session.export",
-        Effect.fn(function* (ctx) {
-          return {
-            data: yield* transfer.export({ sessionID: ctx.params.sessionID, sanitize: ctx.query.sanitize }).pipe(
-              Effect.catchTag(
-                "Session.NotFoundError",
-                (error) =>
-                  new SessionNotFoundError({
-                    sessionID: error.sessionID,
-                    message: `Session not found: ${error.sessionID}`,
-                  }),
-              ),
-              Effect.catchTag("Session.MessageDecodeError", (error) => {
-                const ref = `err_${crypto.randomUUID().slice(0, 8)}`
-                return Effect.logError("failed to decode session message").pipe(
-                  Effect.annotateLogs({ ref, sessionID: error.sessionID, messageID: error.messageID }),
-                  Effect.andThen(
-                    Effect.fail(
-                      new UnknownError({ message: "Unexpected server error. Check server logs for details.", ref }),
-                    ),
-                  ),
-                )
-              }),
-            ),
-          }
-        }),
-      )
       .handle(
         "session.active",
         Effect.fn(function* () {
@@ -661,6 +625,33 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
           }
         }),
       )
+      .handle(
+        "session.pending.cancel",
+        Effect.fn(function* (ctx) {
+          return yield* pendingMutation(
+            session.cancelPending({ sessionID: ctx.params.sessionID, inputID: ctx.params.inputID }),
+            "Pending input can no longer be cancelled",
+          )
+        }),
+      )
+      .handle(
+        "session.pending.steer",
+        Effect.fn(function* (ctx) {
+          return yield* pendingMutation(
+            session.steerPending({ sessionID: ctx.params.sessionID, inputID: ctx.params.inputID }),
+            "Pending input is no longer queued",
+          )
+        }),
+      )
+      .handle(
+        "session.pending.queue",
+        Effect.fn(function* (ctx) {
+          return yield* pendingMutation(
+            session.queuePending({ sessionID: ctx.params.sessionID, inputID: ctx.params.inputID }),
+            "Pending input is no longer a steer",
+          )
+        }),
+      )
       .handle(
         "session.instructions.entry.list",
         Effect.fn(function* (ctx) {

packages/server/src/routes.ts

@@ -16,7 +16,6 @@ import { PtyTicket } from "@opencode-ai/core/pty/ticket"
 import { Pty } from "@opencode-ai/core/pty"
 import { Project } from "@opencode-ai/core/project"
 import { Session } from "@opencode-ai/core/session"
-import { SessionTransfer } from "@opencode-ai/core/session/transfer"
 import { Shell } from "@opencode-ai/core/shell"
 import { Job } from "@opencode-ai/core/job"
 import { MCP } from "@opencode-ai/core/mcp/index"
@@ -52,7 +51,6 @@ const applicationServices = LayerNode.group([
   Job.node,
   Project.node,
   Session.node,
-  SessionTransfer.node,
   PluginRuntime.providerNode,
   SdkPlugins.node,
   PermissionSaved.node,

packages/tui/src/app.tsx

@@ -512,7 +512,7 @@ function App(props: { pair?: DialogPairCredentials }) {
   const terminalTitleEnabled = () => config.data.terminal?.title ?? true
   const copyOnSelectEnabled = () => config.data.terminal?.copy_on_select ?? process.platform !== "win32"
   const pasteSummaryEnabled = () => config.data.prompt?.paste !== "full"
-  const tabsVertical = () => config.data.tabs.layout === "vertical" && sessionTabsFitVertically(dimensions().width)
+  const tabsVertical = () => (config.data.tabs?.vertical ?? false) && sessionTabsFitVertically(dimensions().width)
   const tabsVisible = () =>
     sessionTabs.enabled() && (sessionTabs.tabs().length > 0 || sessionTabs.newTab()) && route.data.type !== "plugin"
 

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

@@ -88,7 +88,7 @@ export const settings: Setting[] = [
     title: "Enabled",
     category: "Tabs",
     path: ["tabs", "enabled"],
-    default: true,
+    default: false,
     values: [false, true],
     labels: ["off", "on"],
   },
@@ -96,16 +96,17 @@ export const settings: Setting[] = [
     title: "Scope",
     category: "Tabs",
     path: ["tabs", "scope"],
-    default: "cwd",
+    default: "global",
     values: ["cwd", "global"],
     labels: ["current directory", "global"],
   },
   {
-    title: "Layout",
+    title: "Vertical",
     category: "Tabs",
-    path: ["tabs", "layout"],
-    default: "horizontal",
-    values: ["horizontal", "vertical"],
+    path: ["tabs", "vertical"],
+    default: false,
+    values: [false, true],
+    labels: ["off", "on"],
     keywords: ["sidebar", "orientation", "left"],
   },
   {

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

@@ -19,20 +19,13 @@ function statusError(status: McpServer["status"]) {
   return undefined
 }
 
-function Status(props: { status: McpServer["status"]; loading: boolean }) {
-  if (props.loading || props.status.status === "pending") {
-    return <>Connecting …</>
+function Status(props: { enabled: boolean; loading: boolean }) {
+  const theme = useTheme("elevated")
+  if (props.loading) return <span style={{ fg: theme.text.subdued }}>⋯ Loading</span>
+  if (props.enabled) {
+    return <span style={{ fg: theme.text.feedback.success.default, attributes: TextAttributes.BOLD }}>✓ Enabled</span>
   }
-  if (props.status.status === "connected") {
-    return <span style={{ attributes: TextAttributes.BOLD }}>Connected ✓</span>
-  }
-  if (props.status.status === "failed") {
-    return <>Failed !</>
-  }
-  if (props.status.status === "needs_auth") {
-    return <>Sign in required →</>
-  }
-  return <>Disabled ○</>
+  return <span style={{ fg: theme.text.subdued }}>○ Disabled</span>
 }
 
 export function DialogMcp() {
@@ -45,13 +38,6 @@ export function DialogMcp() {
   const [detail, setDetail] = createSignal<McpServer>()
   const [loading, setLoading] = createSignal<string | null>(null)
 
-  const statusColor = (status: McpServer["status"]) => {
-    if (status.status === "connected") return theme.text.feedback.success.default
-    if (status.status === "failed") return theme.text.feedback.error.default
-    if (status.status === "needs_auth") return theme.text.feedback.warning.default
-    return theme.text.subdued
-  }
-
   const servers = createMemo(() =>
     pipe(
       data.location.mcp.server.list() ?? [],
@@ -67,29 +53,17 @@ export function DialogMcp() {
 
   const options = createMemo(() => {
     const loadingMcp = loading()
-    return servers().map((server) => {
-      const pending = loadingMcp === server.name || server.status.status === "pending"
-      return {
-        value: server.name,
-        title: server.name,
-        footer: <Status status={server.status} loading={pending} />,
-        footerColor: pending ? theme.text.subdued : statusColor(server.status),
-      }
-    })
-  })
-
-  const focusedServer = createMemo(() => servers().find((server) => server.name === focused()))
-
-  const toggleTitle = createMemo(() => {
-    const status = focusedServer()?.status.status
-    if (status === "connected") return "disconnect"
-    if (status === "failed") return "retry"
-    if (status === "needs_auth") return "sign in"
-    return "connect"
+    return servers().map((server) => ({
+      value: server.name,
+      title: server.name,
+      description: server.status.status,
+      footer: <Status enabled={server.status.status === "connected"} loading={loadingMcp === server.name} />,
+    }))
   })
 
   const focusedError = createMemo(() => {
-    const server = focusedServer()
+    const name = focused()
+    const server = servers().find((entry) => entry.name === name)
     return server ? statusError(server.status) : undefined
   })
 
@@ -126,7 +100,7 @@ export function DialogMcp() {
             onSelect={(option) => open(option.value as string)}
             actions={[
               {
-                title: toggleTitle(),
+                title: "toggle",
                 command: "dialog.mcp.toggle",
                 onTrigger: (option) => {
                   setFocused(option.value as string)

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

@@ -8,21 +8,17 @@ import * as fuzzysort from "fuzzysort"
 import { useConnected } from "./use-connected"
 import { useData } from "../context/data"
 import { modelPreferenceKey } from "../model-preference"
-import { useLocation } from "../context/location"
 
 export function DialogModel(props: { providerID?: string }) {
   const local = useLocal()
   const data = useData()
   const dialog = useDialog()
-  const location = useLocation()
   const [query, setQuery] = createSignal("")
   const favoritePriority = new Set(local.model.favorite().map(modelPreferenceKey))
 
   const connected = useConnected()
-  const providers = createMemo(
-    () => new Map((data.location.provider.list(location.ref) ?? []).map((item) => [item.id, item])),
-  )
-  const models = createMemo(() => data.location.model.list(location.ref) ?? [])
+  const providers = createMemo(() => new Map((data.location.provider.list() ?? []).map((item) => [item.id, item])))
+  const models = createMemo(() => data.location.model.list() ?? [])
 
   const showExtra = createMemo(() => connected() && !props.providerID)
 

packages/tui/src/component/prompt/index.tsx

@@ -59,6 +59,7 @@ export type PromptProps = {
   visible?: boolean
   disabled?: boolean
   onSubmit?: () => void
+  onEmptySubmit?: () => boolean | Promise<boolean>
   ref?: (ref: PromptRef | undefined) => void
   hint?: JSX.Element
   right?: JSX.Element
@@ -327,6 +328,10 @@ export function Prompt(props: PromptProps) {
     if (!session) return
     const agent = session.agent && local.agent.list().find((agent) => agent.id === session.agent)
     if (agent && !args.agent) local.agent.set(agent.id)
+    if (session.model) {
+      local.model.set({ providerID: session.model.providerID, modelID: session.model.id })
+      local.model.variant.set(session.model.variant)
+    }
     syncedSessionID = sessionID
   })
 
@@ -357,6 +362,20 @@ export function Prompt(props: PromptProps) {
           dialog.clear()
         },
       },
+      {
+        title: "Queue prompt",
+        name: "prompt.queue",
+        category: "Prompt",
+        palette: undefined,
+        run: async (_input: string | undefined, event?: KeyEvent) => {
+          event?.preventDefault()
+          event?.stopPropagation()
+          if (!input.focused) return
+          const handled = await submit("queue")
+          if (!handled) return
+          dialog.clear()
+        },
+      },
       {
         title: "Remove editor context",
         name: "prompt.editor_context.clear",
@@ -515,6 +534,11 @@ export function Prompt(props: PromptProps) {
     commands: promptCommands(),
   }))
 
+  Keymap.createLayer(() => ({
+    priority: 1,
+    bindings: ["prompt.queue"],
+  }))
+
   Keymap.createLayer(() => ({
     bindings: [
       "prompt.submit",
@@ -900,7 +924,7 @@ export function Prompt(props: PromptProps) {
   })
 
   let submitting = false
-  async function submit() {
+  async function submit(delivery: "steer" | "queue" = "steer") {
     // Prevent overlapping invocations (e.g. a double-pressed Enter, or the
     // input's native onSubmit racing another dispatch). Without this guard,
     // a second call slips past the empty-input check before the first call
@@ -910,13 +934,13 @@ export function Prompt(props: PromptProps) {
     if (submitting) return false
     submitting = true
     try {
-      return await submitInner()
+      return await submitInner(delivery)
     } finally {
       submitting = false
     }
   }
 
-  async function submitInner() {
+  async function submitInner(delivery: "steer" | "queue") {
     // IME: double-defer may fire before onContentChange flushes the last
     // composed character (e.g. Korean hangul) to the store, so read
     // plainText directly and sync before any downstream reads.
@@ -927,55 +951,48 @@ export function Prompt(props: PromptProps) {
     if (props.disabled) return false
     if (move.creating()) return false
     if (auto()?.visible) return false
-    if (!store.prompt.text) return false
     const trimmed = store.prompt.text.trim()
+    if (!trimmed) return delivery === "steer" ? (await props.onEmptySubmit?.()) === true : false
+    if (
+      delivery === "queue" &&
+      (store.mode === "shell" || trimmed === "exit" || trimmed === "quit" || trimmed === ":q")
+    ) {
+      toast.show({ message: "This prompt cannot be queued", variant: "warning" })
+      return false
+    }
     if (trimmed === "exit" || trimmed === "quit" || trimmed === ":q") {
       void exit()
       return true
     }
     const slash = argumentSlash(store.prompt.text, keymapCommands())
     if (slash) {
+      if (delivery === "queue") {
+        toast.show({ message: "This prompt cannot be queued", variant: "warning" })
+        return false
+      }
       clearPrompt()
       await slash.command.run(slash.input)
       return true
     }
-    const inputText = expandTrackedPastedText(
-      store.prompt.text,
-      input.extmarks.getAllForTypeId(promptPartTypeId).flatMap((extmark) => {
-        const ref = store.extmarkToPart.get(extmark.id)
-        if (ref?.type !== "pasted") return []
-        const part = store.prompt.pasted[ref.index]
-        if (!part) return []
-        return [{ start: extmark.start, end: extmark.end, text: part.text }]
-      }),
-    )
-    const slashHead = parseSlashHead(inputText, /\s/)
-    const isSkill =
-      slashHead !== undefined &&
-      (data.location.skill.list(currentLocation.ref) ?? []).some(
-        (skill) => skill.slash === true && skill.id === slashHead.name,
+    if (
+      delivery === "queue" &&
+      store.prompt.text.startsWith("/") &&
+      (data.location.skill.list(currentLocation.current) ?? []).some(
+        (skill) => skill.slash === true && skill.id === store.prompt.text.split("\n")[0].split(" ")[0].slice(1),
       )
-    const isCommand =
-      slashHead !== undefined &&
-      (data.location.command.list(currentLocation.ref) ?? []).some((command) => command.name === slashHead.name)
+    ) {
+      toast.show({ message: "Skills cannot be queued", variant: "warning" })
+      return false
+    }
     const agent = local.agent.current()
     if (!agent) return false
-    const selection = local.model.selection()
-    if (!selection) {
+    const selectedModel = local.model.current()
+    if (!selectedModel) {
       void promptModelWarning()
       return false
     }
-    const usesModel = !props.sessionID || (store.mode !== "shell" && !isSkill)
-    if (usesModel && !local.model.available(selection)) {
-      toast.show({
-        title: "Model unavailable",
-        message: `${selection.providerID}/${selection.modelID} is not available in this session's location`,
-        variant: "warning",
-      })
-      return false
-    }
 
-    const variant = selection.variant
+    const variant = local.model.variant.current()
     let sessionID = props.sessionID
     let session = sessionID ? data.session.get(sessionID) : undefined
     let finishMoveProgress = false
@@ -993,8 +1010,8 @@ export function Prompt(props: PromptProps) {
           location: directory ? { directory } : location,
           agent: agent.id,
           model: {
-            providerID: selection.providerID,
-            id: selection.modelID,
+            providerID: selectedModel.providerID,
+            id: selectedModel.modelID,
             variant,
           },
         })
@@ -1014,6 +1031,17 @@ export function Prompt(props: PromptProps) {
       session = created
     }
 
+    const inputText = expandTrackedPastedText(
+      store.prompt.text,
+      input.extmarks.getAllForTypeId(promptPartTypeId).flatMap((extmark) => {
+        const ref = store.extmarkToPart.get(extmark.id)
+        if (ref?.type !== "pasted") return []
+        const part = store.prompt.pasted[ref.index]
+        if (!part) return []
+        return [{ start: extmark.start, end: extmark.end, text: part.text }]
+      }),
+    )
+
     // Capture mode before it gets reset
     const currentMode = store.mode
     const editorSelection = editorContext()
@@ -1026,30 +1054,44 @@ export function Prompt(props: PromptProps) {
         command: inputText,
       })
       setStore("mode", "normal")
-    } else if (slashHead && isCommand) {
+    } else if (
+      inputText.startsWith("/") &&
+      (data.location.command.list(currentLocation.current) ?? []).some(
+        (command) => command.name === inputText.split("\n")[0].split(" ")[0].slice(1),
+      )
+    ) {
       move.startSubmit()
-      const model = { providerID: selection.providerID, id: selection.modelID, variant }
-      const cancelCommit = local.model.trackSessionCommit(sessionID, model)
+      // Parse command from first line, preserve multi-line content in arguments
+      const firstLineEnd = inputText.indexOf("\n")
+      const firstLine = firstLineEnd === -1 ? inputText : inputText.slice(0, firstLineEnd)
+      const [command, ...firstLineArgs] = firstLine.split(" ")
+      const restOfInput = firstLineEnd === -1 ? "" : inputText.slice(firstLineEnd + 1)
+      const args = firstLineArgs.join(" ") + (restOfInput ? "\n" + restOfInput : "")
 
       void client.api.session
         .command({
           sessionID,
-          command: slashHead.name,
-          arguments: slashHead.arguments,
+          command: command.slice(1),
+          arguments: args,
           agent: agent.id,
-          model,
+          model: { providerID: selectedModel.providerID, id: selectedModel.modelID, variant },
           files: store.prompt.files,
           agents: store.prompt.agents,
+          delivery,
         })
         .catch((error) => {
-          cancelCommit()
           toast.show({ title: "Failed to run command", message: errorMessage(error), variant: "error" })
         })
-    } else if (isSkill) {
+    } else if (
+      inputText.startsWith("/") &&
+      (data.location.skill.list(currentLocation.current) ?? []).some(
+        (skill) => skill.slash === true && skill.id === inputText.split("\n")[0].split(" ")[0].slice(1),
+      )
+    ) {
       move.startSubmit()
       void client.api.session.skill({
         sessionID,
-        skill: slashHead!.name,
+        skill: inputText.split("\n")[0].split(" ")[0].slice(1),
       })
     } else {
       move.startSubmit()
@@ -1061,15 +1103,13 @@ export function Prompt(props: PromptProps) {
         await client.api.session.switchAgent({ sessionID, agent: agent.id })
       }
       if (
-        session?.model?.providerID !== selection.providerID ||
-        session.model.id !== selection.modelID ||
+        session?.model?.providerID !== selectedModel.providerID ||
+        session.model.id !== selectedModel.modelID ||
         (session.model.variant ?? "default") !== (variant ?? "default")
       ) {
-        const model = { providerID: selection.providerID, id: selection.modelID, variant }
-        const cancelCommit = local.model.trackSessionCommit(sessionID, model)
-        await client.api.session.switchModel({ sessionID, model }).catch((error) => {
-          cancelCommit()
-          throw error
+        await client.api.session.switchModel({
+          sessionID,
+          model: { providerID: selectedModel.providerID, id: selectedModel.modelID, variant },
         })
       }
       if (session?.revert) {
@@ -1105,6 +1145,7 @@ export function Prompt(props: PromptProps) {
           text: inputText,
           files: store.prompt.files,
           agents: store.prompt.agents,
+          delivery,
         })
         .then(
           () => undefined,
@@ -1322,7 +1363,10 @@ export function Prompt(props: PromptProps) {
       return `Ask anything... "${list()[store.placeholder % list().length]}"`
     })()
     if (!value) return undefined
-    const width = dimensions().width < 44 ? dimensions().width - 5 : Math.min(75, dimensions().width - 4) - 5
+    const width =
+      dimensions().width < 44
+        ? dimensions().width - 5
+        : Math.min(75, dimensions().width - 4) - 5
     return Locale.takeWidth(value, Math.max(1, width)).trimEnd()
   })
   const locationLabel = createMemo(() => {

packages/tui/src/config/index.tsx

@@ -132,8 +132,8 @@ export const Info = Schema.Struct({
       scope: Schema.optional(Schema.Literals(["global", "cwd"])).annotate({
         description: "Share tabs globally or keep a separate set for each working directory",
       }),
-      layout: Schema.optional(Schema.Literals(["horizontal", "vertical"])).annotate({
-        description: "Show tabs in a horizontal strip or vertical sidebar",
+      vertical: Schema.optional(Schema.Boolean).annotate({
+        description: "Show tabs in a left sidebar instead of a horizontal strip",
       }),
     }),
   ).annotate({ description: "Tab strip settings" }),
@@ -179,7 +179,7 @@ export const Info = Schema.Struct({
 })
 export type Info = Schema.Schema.Type<typeof Info>
 
-export type Resolved = Omit<Info, "attention" | "keybinds" | "leader" | "mouse" | "tabs"> & {
+export type Resolved = Omit<Info, "attention" | "keybinds" | "leader" | "mouse"> & {
   attention: {
     enabled: boolean
     notifications: boolean
@@ -191,11 +191,6 @@ export type Resolved = Omit<Info, "attention" | "keybinds" | "leader" | "mouse"
   keybinds: TuiKeybind.BindingLookupView
   leader: { timeout: number }
   mouse: boolean
-  tabs: {
-    enabled: boolean
-    scope: "global" | "cwd"
-    layout: "horizontal" | "vertical"
-  }
 }
 
 export function resolve(input: Info, options: { terminalSuspend: boolean }): Resolved {
@@ -226,12 +221,6 @@ export function resolve(input: Info, options: { terminalSuspend: boolean }): Res
     }),
     leader: { timeout: input.leader?.timeout ?? 2000 },
     mouse: input.mouse ?? true,
-    tabs: {
-      ...input.tabs,
-      enabled: input.tabs?.enabled ?? true,
-      scope: input.tabs?.scope ?? "cwd",
-      layout: input.tabs?.layout ?? "horizontal",
-    },
   }
 }
 

packages/tui/src/config/v1/keybind.ts

@@ -104,6 +104,7 @@ export const Definitions = {
   session_background: keybind("ctrl+b", "Background blocking session tools"),
   session_compact: keybind("<leader>c", "Compact the session"),
   session_queued_prompts: keybind("<leader>q", "View pending work"),
+  queued_prompt_delete: keybind("ctrl+d", "Delete queued prompt"),
   session_child_first: keybind("down", "Toggle subagent picker"),
   session_parent: keybind("up", "Go to parent session"),
   session_pin_toggle: keybind("ctrl+f", "Pin or unpin session in the session list"),
@@ -161,6 +162,7 @@ export const Definitions = {
   display_thinking: keybind("none", "Toggle thinking blocks visibility"),
 
   prompt_submit: keybind("none", "Submit prompt"),
+  prompt_queue: keybind("alt+return", "Queue prompt"),
   prompt_editor_context_clear: keybind("none", "Clear editor context"),
   prompt_skills: keybind("none", "Open skill selector"),
   prompt_stash: keybind("none", "Stash prompt"),
@@ -170,7 +172,7 @@ export const Definitions = {
   input_clear: keybind("ctrl+c", "Clear input field"),
   input_paste: keybind({ key: "ctrl+v", preventDefault: false }, "Paste from clipboard"),
   input_submit: keybind("return", "Submit input"),
-  input_newline: keybind("shift+return,ctrl+return,alt+return,ctrl+j", "Insert newline in input"),
+  input_newline: keybind("shift+return,ctrl+return,ctrl+j", "Insert newline in input"),
   input_move_left: keybind("left,ctrl+b", "Move cursor left in input"),
   input_move_right: keybind("right,ctrl+f", "Move cursor right in input"),
   input_move_up: keybind("up", "Move cursor up in input"),
@@ -305,6 +307,7 @@ export const CommandMap = {
   session_background: "session.background",
   session_compact: "session.compact",
   session_queued_prompts: "session.queued_prompts",
+  queued_prompt_delete: "queued_prompt.delete",
   session_child_first: "session.child.first",
   session_parent: "session.parent",
   session_pin_toggle: "session.pin.toggle",
@@ -359,6 +362,7 @@ export const CommandMap = {
   messages_redo: "session.redo",
   display_thinking: "session.toggle.thinking",
   prompt_submit: "prompt.submit",
+  prompt_queue: "prompt.queue",
   prompt_editor_context_clear: "prompt.editor_context.clear",
   prompt_skills: "prompt.skills",
   prompt_stash: "prompt.stash",

packages/tui/src/context/data.tsx

@@ -168,12 +168,27 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
 
     function removePending(sessionID: string, inputID?: string) {
       if (!inputID) return
-      setStore(
-        "session",
-        "pending",
-        sessionID,
-        (store.session.pending[sessionID] ?? []).filter((item) => item.id !== inputID),
-      )
+      if (store.session.pending[sessionID]?.some((item) => item.id === inputID))
+        setStore(
+          "session",
+          "pending",
+          sessionID,
+          (store.session.pending[sessionID] ?? []).filter((item) => item.id !== inputID),
+        )
+      if (store.session.input[sessionID]?.includes(inputID))
+        setStore(
+          "session",
+          "input",
+          sessionID,
+          (store.session.input[sessionID] ?? []).filter((id) => id !== inputID),
+        )
+    }
+
+    function updatePending(sessionID: string, inputID: string, delivery: "steer" | "queue") {
+      const index = store.session.pending[sessionID]?.findIndex((item) => item.id === inputID) ?? -1
+      const item = store.session.pending[sessionID]?.[index]
+      if (index < 0 || !item || item.type === "compaction" || item.delivery === delivery) return
+      setStore("session", "pending", sessionID, index, { ...item, delivery })
     }
 
     const message = {
@@ -222,6 +237,12 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           (item): item is SessionMessageAssistantReasoning => item.type === "reasoning" && !item.time?.completed,
         )
       },
+      reindex(messages: SessionMessageInfo[], index: Map<string, number>, start: number) {
+        for (let position = start; position < messages.length; position++) {
+          const item = messages[position]
+          if (item) index.set(item.id, position)
+        }
+      },
     }
 
     function index(sessionID: string) {
@@ -403,24 +424,36 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           }
           break
         case "session.input.promoted": {
+          const admitted = store.session.input[event.data.sessionID]?.includes(event.data.inputID) ?? false
           removePending(event.data.sessionID, event.data.inputID)
           message.update(event.data.sessionID, (draft, index) => {
             const position = index.get(event.data.inputID)
             if (position === undefined) return
             const existing = draft[position]
-            if (!existing || !store.session.input[event.data.sessionID]?.includes(event.data.inputID)) return
+            if (!existing || !admitted) return
             existing.time.created = event.created
             draft.splice(position, 1)
             draft.push(existing)
-            index.clear()
-            draft.forEach((message, indexValue) => index.set(message.id, indexValue))
+            message.reindex(draft, index, position)
           })
-          setStore(
-            "session",
-            "input",
-            event.data.sessionID,
-            (store.session.input[event.data.sessionID] ?? []).filter((id) => id !== event.data.inputID),
-          )
+          break
+        }
+        case "session.input.steered":
+          updatePending(event.data.sessionID, event.data.inputID, "steer")
+          break
+        case "session.input.queued":
+          updatePending(event.data.sessionID, event.data.inputID, "queue")
+          break
+        case "session.input.cancelled": {
+          removePending(event.data.sessionID, event.data.inputID)
+          if (messageIndex.get(event.data.sessionID)?.has(event.data.inputID))
+            message.update(event.data.sessionID, (draft, index) => {
+              const position = index.get(event.data.inputID)
+              if (position === undefined) return
+              draft.splice(position, 1)
+              index.delete(event.data.inputID)
+              message.reindex(draft, index, position)
+            })
           break
         }
         case "session.input.admitted":

packages/tui/src/context/local.tsx

@@ -1,7 +1,7 @@
 import { createStore } from "solid-js/store"
 import { dedupeWith } from "effect/Array"
 import { createSimpleContext } from "./helper"
-import { batch, createMemo, onCleanup } from "solid-js"
+import { batch, createMemo } from "solid-js"
 import { useEvent } from "./event"
 import path from "path"
 import { useTuiPaths } from "./runtime"
@@ -22,7 +22,6 @@ import { useToast } from "../ui/toast"
 import { useRoute } from "./route"
 import { useData } from "./data"
 import { usePermission } from "./permission"
-import { useLocation } from "./location"
 
 export function parseModel(model: string) {
   const [providerID, ...rest] = model.split("/")
@@ -58,29 +57,26 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
     const args = useArgs()
     const event = useEvent()
     const permission = usePermission()
-    const location = useLocation()
-
-    const models = () => data.location.model.list(location.ref)
-    const providers = () => data.location.provider.list(location.ref)
 
     function isModelValid(model: ModelPreferenceModel) {
-      return !!models()?.some((item) => item.providerID === model.providerID && item.id === model.modelID)
+      return !!data.location.model
+        .list()
+        ?.some((item) => item.providerID === model.providerID && item.id === model.modelID)
     }
 
     function getFirstValidModel(...modelFns: (() => ModelPreferenceModel | undefined)[]) {
       for (const modelFn of modelFns) {
         const model = modelFn()
-        if (model && isModelValid(model)) return model
+        if (!model) continue
+        if (isModelValid(model)) return model
       }
     }
 
     function createAgent() {
       const agents = createMemo(() =>
-        (data.location.agent.list(location.ref) ?? []).filter((agent) => agent.mode !== "subagent" && !agent.hidden),
-      )
-      const visibleAgents = createMemo(() =>
-        (data.location.agent.list(location.ref) ?? []).filter((agent) => !agent.hidden),
+        (data.location.agent.list() ?? []).filter((agent) => agent.mode !== "subagent" && !agent.hidden),
       )
+      const visibleAgents = createMemo(() => (data.location.agent.list() ?? []).filter((agent) => !agent.hidden))
       const [agentStore, setAgentStore] = createStore({
         current: undefined as string | undefined,
       })
@@ -132,40 +128,35 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
     const agent = createAgent()
 
     function createModel() {
-      type ModelSelection = ModelPreferenceModel & { variant?: string }
-      const [preferences, setPreferences] = createStore<ModelPreference & { ready: boolean }>({
+      const [modelStore, setModelStore] = createStore<
+        ModelPreference & {
+          ready: boolean
+          model: Record<string, ModelPreferenceModel>
+        }
+      >({
         ready: false,
+        model: {},
         recent: [],
         favorite: [],
         variant: {},
       })
-      const [selectionState, setSelectionState] = createStore<{
-        newSessionModelByLocationAgent: Record<string, ModelPreferenceModel | undefined>
-        draftBySession: Record<string, ModelSelection | undefined>
-      }>({
-        newSessionModelByLocationAgent: {},
-        draftBySession: {},
-      })
 
       const repository = createModelPreferenceRepository(path.join(paths.state, "model.json"))
-      const pendingSelectionCommits = new Map<string, string>()
-      const selectionKey = (value: ModelSelection) =>
-        `${modelPreferenceKey(value)}:${normalizeModelVariant(value.variant) ?? "default"}`
-      const saveState = {
+      const state = {
         pending: false,
       }
 
-      function savePreferences() {
-        if (!preferences.ready) {
-          saveState.pending = true
+      function save() {
+        if (!modelStore.ready) {
+          state.pending = true
           return
         }
-        saveState.pending = false
+        state.pending = false
         void repository
           .patch({
-            recent: preferences.recent,
-            favorite: preferences.favorite,
-            variant: preferences.variant,
+            recent: modelStore.recent,
+            favorite: modelStore.favorite,
+            variant: modelStore.variant,
           })
           .catch(() => undefined)
       }
@@ -173,14 +164,14 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       repository
         .load()
         .then((value) => {
-          setPreferences("recent", value.recent)
-          setPreferences("favorite", value.favorite)
-          setPreferences("variant", value.variant)
+          setModelStore("recent", value.recent)
+          setModelStore("favorite", value.favorite)
+          setModelStore("variant", value.variant)
         })
         .catch(() => {})
         .finally(() => {
-          setPreferences("ready", true)
-          if (saveState.pending) savePreferences()
+          setModelStore("ready", true)
+          if (state.pending) save()
         })
 
       const fallbackModel = createMemo(() => {
@@ -194,13 +185,13 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
           }
         }
 
-        for (const item of preferences.recent) {
+        for (const item of modelStore.recent) {
           if (isModelValid(item)) {
             return item
           }
         }
 
-        const model = models()?.[0]
+        const model = data.location.model.list()?.[0]
         if (!model) return undefined
         return {
           providerID: model.providerID,
@@ -208,134 +199,30 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
         }
       })
 
-      const newSessionModel = createMemo(() => {
-        const a = agent.current()
-        return getFirstValidModel(
-          () => a && selectionState.newSessionModelByLocationAgent[locationAgentKey(a.id)],
-          () => a?.model && { providerID: a.model.providerID, modelID: a.model.id },
-          fallbackModel,
-        )
-      })
-
-      const currentSelection = createMemo<ModelSelection | undefined>(() => {
-        if (route.data.type === "session") return sessionSelection(route.data.sessionID)
-        const model = newSessionModel()
-        if (!model) return
-        return { ...model, variant: normalizeModelVariant(preferences.variant[modelPreferenceKey(model)]) }
-      })
-
       const currentModel = createMemo(() => {
-        const selection = currentSelection()
-        if (!selection) return
-        return { providerID: selection.providerID, modelID: selection.modelID }
-      })
-
-      function locationAgentKey(agentID: string) {
-        const ref = location.ref ?? data.location.default()
-        return `${JSON.stringify([ref.directory, ref.workspaceID])}:${agentID}`
-      }
-
-      function durableSelection(sessionID: string): ModelSelection | undefined {
-        const model = data.session.get(sessionID)?.model
-        if (!model) return
-        return {
-          providerID: model.providerID,
-          modelID: model.id,
-          variant: normalizeModelVariant(model.variant),
-        }
-      }
-
-      function sessionSelection(sessionID: string) {
-        return selectionState.draftBySession[sessionID] ?? durableSelection(sessionID)
-      }
-
-      function setSessionDraft(sessionID: string, selection: ModelSelection) {
-        const durable = durableSelection(sessionID)
-        setSelectionState(
-          "draftBySession",
-          sessionID,
-          durable && selectionKey(durable) === selectionKey(selection) ? undefined : selection,
+        const a = agent.current()
+        return (
+          getFirstValidModel(
+            () => a && modelStore.model[a.id],
+            () => a?.model && { providerID: a.model.providerID, modelID: a.model.id },
+            fallbackModel,
+          ) ?? undefined
         )
-      }
-
-      function selectModel(model: ModelPreferenceModel) {
-        if (route.data.type === "session") {
-          const sessionID = route.data.sessionID
-          const current = sessionSelection(sessionID)
-          const preferred = normalizeModelVariant(
-            current?.providerID === model.providerID && current.modelID === model.modelID
-              ? current.variant
-              : preferences.variant[modelPreferenceKey(model)],
-          )
-          const info = models()?.find((item) => item.providerID === model.providerID && item.id === model.modelID)
-          const variant = preferred && info?.variants?.some((item) => item.id === preferred) ? preferred : undefined
-          setSessionDraft(sessionID, { ...model, variant })
-          return true
-        }
-        const current = agent.current()
-        if (!current) return false
-        setSelectionState("newSessionModelByLocationAgent", locationAgentKey(current.id), model)
-        return true
-      }
-
-      onCleanup(
-        event.on("session.model.selected", (evt) => {
-          const expected = pendingSelectionCommits.get(evt.data.sessionID)
-          if (!expected) return
-          const committed = selectionKey({
-            providerID: evt.data.model.providerID,
-            modelID: evt.data.model.id,
-            variant: evt.data.model.variant,
-          })
-          if (committed !== expected) return
-          pendingSelectionCommits.delete(evt.data.sessionID)
-          const draft = selectionState.draftBySession[evt.data.sessionID]
-          if (draft && selectionKey(draft) === committed)
-            setSelectionState("draftBySession", evt.data.sessionID, undefined)
-        }),
-      )
-
-      onCleanup(
-        event.on("session.deleted", (evt) => {
-          pendingSelectionCommits.delete(evt.data.sessionID)
-          setSelectionState("draftBySession", evt.data.sessionID, undefined)
-        }),
-      )
+      })
 
       return {
         current: currentModel,
-        selection: currentSelection,
-        available(model = currentModel()) {
-          return model ? isModelValid(model) : false
-        },
-        trackSessionCommit(
-          sessionID: string,
-          value: {
-            providerID: string
-            id: string
-            variant?: string
-          },
-        ) {
-          const committed = selectionKey({ providerID: value.providerID, modelID: value.id, variant: value.variant })
-          pendingSelectionCommits.set(sessionID, committed)
-          return () => {
-            if (pendingSelectionCommits.get(sessionID) === committed) pendingSelectionCommits.delete(sessionID)
-          }
-        },
         get ready() {
-          return preferences.ready
-        },
-        get catalogReady() {
-          return models() !== undefined
+          return modelStore.ready
         },
         recent() {
-          return preferences.recent
+          return modelStore.recent
         },
         favorite() {
-          return preferences.favorite
+          return modelStore.favorite
         },
         parsed: createMemo(() => {
-          const value = currentSelection()
+          const value = currentModel()
           if (!value) {
             return {
               provider: "Connect a provider",
@@ -343,28 +230,33 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
               reasoning: false,
             }
           }
-          const provider = providers()?.find((item) => item.id === value.providerID)
-          const info = models()?.find((item) => item.providerID === value.providerID && item.id === value.modelID)
+          const provider = data.location.provider.list()?.find((item) => item.id === value.providerID)
+          const info = data.location.model
+            .list()
+            ?.find((item) => item.providerID === value.providerID && item.id === value.modelID)
           return {
             provider: provider?.name ?? value.providerID,
-            model: info?.name ?? `${value.modelID} (unavailable)`,
+            model: info?.name ?? value.modelID,
             reasoning: (info?.variants?.length ?? 0) !== 0,
           }
         }),
         cycle(direction: 1 | -1) {
-          const current = currentSelection()
+          const current = currentModel()
           if (!current) return
-          const recent = recentModels(current, preferences.recent).filter(isModelValid)
+          const recent = modelStore.recent
           const index = recent.findIndex((x) => x.providerID === current.providerID && x.modelID === current.modelID)
-          let next = index === -1 ? (direction === 1 ? 0 : recent.length - 1) : index + direction
+          if (index === -1) return
+          let next = index + direction
           if (next < 0) next = recent.length - 1
           if (next >= recent.length) next = 0
           const val = recent[next]
           if (!val) return
-          selectModel({ ...val })
+          const a = agent.current()
+          if (!a) return
+          setModelStore("model", a.id, { ...val })
         },
         cycleFavorite(direction: 1 | -1) {
-          const favorites = preferences.favorite.filter((item) => isModelValid(item))
+          const favorites = modelStore.favorite.filter((item) => isModelValid(item))
           if (!favorites.length) {
             toast.show({
               variant: "info",
@@ -373,7 +265,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
             })
             return
           }
-          const current = currentSelection()
+          const current = currentModel()
           let index = -1
           if (current) {
             index = favorites.findIndex((x) => x.providerID === current.providerID && x.modelID === current.modelID)
@@ -387,39 +279,45 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
           }
           const next = favorites[index]
           if (!next) return
-          if (!selectModel({ ...next })) return
-          setPreferences("recent", recentModels(next, preferences.recent))
-          savePreferences()
+          const a = agent.current()
+          if (!a) return
+          setModelStore("model", a.id, { ...next })
+          setModelStore("recent", recentModels(next, modelStore.recent))
+          save()
         },
         set(model: { providerID: string; modelID: string }, options?: { recent?: boolean }) {
           batch(() => {
             if (!isModelValid(model)) return
-            if (!selectModel(model)) return
+            const a = agent.current()
+            if (!a) return
+            setModelStore("model", a.id, model)
             if (options?.recent) {
-              setPreferences("recent", recentModels(model, preferences.recent))
-              savePreferences()
+              setModelStore("recent", recentModels(model, modelStore.recent))
+              save()
             }
           })
         },
         toggleFavorite(model: { providerID: string; modelID: string }) {
           batch(() => {
             if (!isModelValid(model)) return
-            const exists = preferences.favorite.some(
+            const exists = modelStore.favorite.some(
               (x) => x.providerID === model.providerID && x.modelID === model.modelID,
             )
             const next = exists
-              ? preferences.favorite.filter((x) => x.providerID !== model.providerID || x.modelID !== model.modelID)
-              : [model, ...preferences.favorite]
-            setPreferences(
+              ? modelStore.favorite.filter((x) => x.providerID !== model.providerID || x.modelID !== model.modelID)
+              : [model, ...modelStore.favorite]
+            setModelStore(
               "favorite",
               next.map((x) => ({ providerID: x.providerID, modelID: x.modelID })),
             )
-            savePreferences()
+            save()
           })
         },
         variant: {
           selected() {
-            return currentSelection()?.variant
+            const m = currentModel()
+            if (!m) return undefined
+            return normalizeModelVariant(modelStore.variant[modelPreferenceKey(m)])
           },
           current() {
             const v = this.selected()
@@ -427,20 +325,18 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
             return undefined
           },
           list() {
-            const m = currentSelection()
+            const m = currentModel()
             if (!m) return []
-            const info = models()?.find((item) => item.providerID === m.providerID && item.id === m.modelID)
+            const info = data.location.model
+              .list()
+              ?.find((item) => item.providerID === m.providerID && item.id === m.modelID)
             return info?.variants?.map((variant) => variant.id) ?? []
           },
           set(value: string | undefined) {
-            const m = currentSelection()
+            const m = currentModel()
             if (!m) return
-            if (route.data.type === "session") {
-              setSessionDraft(route.data.sessionID, { ...m, variant: normalizeModelVariant(value) })
-              return
-            }
-            setPreferences("variant", modelPreferenceKey(m), normalizeModelVariant(value))
-            savePreferences()
+            setModelStore("variant", modelPreferenceKey(m), normalizeModelVariant(value))
+            save()
           },
           cycle() {
             const variants = this.list()

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

@@ -49,7 +49,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     const event = useEvent()
     const config = useConfig().data
     const paths = useTuiPaths()
-    const enabled = () => config.tabs.enabled
+    const enabled = () => config.tabs?.enabled ?? false
     // Keyed reconcile keeps tab object identity across reorders, so strip rows move instead of
     // mutating in place, which per-row animations and drag state depend on.
     const [store, updateStore] = useStorage().store<PersistedState>("tabs", {
@@ -66,12 +66,12 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     let closedTabs: ClosedSessionTab[] = []
 
     function state() {
-      if (config.tabs.scope === "cwd") return store.cwd[paths.cwd] ?? fallback
+      if (config.tabs?.scope === "cwd") return store.cwd[paths.cwd] ?? fallback
       return store.global
     }
 
     function update(mutation: (draft: TabsState) => void) {
-      const scope = config.tabs.scope
+      const scope = config.tabs?.scope ?? "global"
       void updateStore((draft) => mutation(scope === "cwd" ? (draft.cwd[paths.cwd] ??= empty()) : draft.global)).catch(
         // Failed writes lose only tab layout, but silence would hide tabs resetting every launch.
         (error) => console.error("Failed to persist session tabs", error),

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

@@ -3,7 +3,9 @@ import { TextAttributes, type InputRenderable, type KeyEvent } from "@opentui/co
 import { useKeyboard, type JSX } from "@opentui/solid"
 import fuzzysort from "fuzzysort"
 import { createEffect, createMemo, createSignal, type Accessor } from "solid-js"
+import { Keymap } from "../context/keymap"
 import { RunFooterMenu, createFooterMenuState, type RunFooterMenuItem } from "./footer.menu"
+import { monoShortcut } from "./mono"
 import type { RunFooterTheme } from "./theme"
 import type {
   FooterQueuedPrompt,
@@ -56,6 +58,10 @@ type SkillEntry = PanelEntry & {
   name: string
 }
 
+type QueuedPromptEntry = PanelEntry & {
+  prompt: FooterQueuedPrompt
+}
+
 type SubagentEntry = PanelEntry & {
   sessionID: string
   current: boolean
@@ -837,28 +843,48 @@ export function RunQueuedPromptSelectBody(props: {
   theme: Accessor<RunFooterTheme>
   prompts: Accessor<FooterQueuedPrompt[]>
   onClose: () => void
+  onSteer: (prompt: FooterQueuedPrompt) => void
+  onDelete: (prompt: FooterQueuedPrompt) => void
   onRows?: (rows: number) => void
   mono?: boolean
 }) {
-  const entries = createMemo(() =>
+  const entries = createMemo<QueuedPromptEntry[]>(() =>
     props.prompts().map((prompt) => ({
       category: "",
       display: prompt.prompt.text.replaceAll("\n", " "),
-      footer: prompt.delivery,
+      footer: "queued",
       keywords: prompt.prompt.text,
+      prompt,
     })),
   )
   const controller = createSearchablePanelController({
     entries,
     limit: SUBAGENT_LIST_ROWS,
     onClose: props.onClose,
-    onSelect: props.onClose,
+    onSelect: (item) => props.onSteer(item.prompt),
     onRows: props.onRows,
   })
+  const shortcuts = Keymap.useShortcuts()
+  const deleteShortcut = () => monoShortcut(shortcuts.get("queued_prompt.delete") ?? "", props.mono ?? false)
+  Keymap.createLayer(() => ({
+    priority: 1,
+    commands: [
+      {
+        id: "queued_prompt.delete",
+        title: "Delete queued prompt",
+        group: "Prompt",
+        run() {
+          const item = controller.items()[controller.menu.selected()]
+          if (!item) return false
+          props.onDelete(item.prompt)
+        },
+      },
+    ],
+  }))
 
   return (
     <PanelShell
-      title="Pending work"
+      title="Queued prompts"
       query={controller.query()}
       count={controller.items().length}
       total={entries().length}
@@ -866,6 +892,7 @@ export function RunQueuedPromptSelectBody(props: {
       theme={props.theme}
       inputRef={controller.inputRef}
       onQuery={controller.setQuery}
+      hint={["enter steer", deleteShortcut() ? `${deleteShortcut()} delete` : undefined].filter(Boolean).join(" · ")}
       mono={props.mono}
     >
       <RunFooterMenu
@@ -875,7 +902,7 @@ export function RunQueuedPromptSelectBody(props: {
         offset={controller.menu.offset}
         rows={controller.menu.rows}
         limit={SUBAGENT_LIST_ROWS}
-        empty="No pending work"
+        empty="No queued prompts"
         border={false}
         paddingLeft={panelPad(props.mono)}
         paddingRight={panelPad(props.mono)}

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

@@ -19,6 +19,7 @@ import {
   displayCharAt,
   displaySlice,
   isExitCommand,
+  isCompactCommand,
   mentionTriggerIndex,
   isNewCommand,
   movePromptHistory,
@@ -31,7 +32,15 @@ import { realignEditorPromptParts, resolveEditorSlashValue } from "./prompt.edit
 import { monoTruncateMiddle } from "./mono"
 import { FOOTER_MENU_ROWS, createFooterMenuState, type RunFooterMenuItem } from "./footer.menu"
 import type { RunFooterTheme } from "./theme"
-import type { FooterState, RunAgent, RunCommand, RunPrompt, RunPromptPart, RunReference } from "./types"
+import type {
+  FooterQueuedPrompt,
+  FooterState,
+  RunAgent,
+  RunCommand,
+  RunPrompt,
+  RunPromptPart,
+  RunReference,
+} from "./types"
 
 const AUTOCOMPLETE_ROWS = FOOTER_MENU_ROWS
 const AUTOCOMPLETE_BOTTOM_ROWS = 1
@@ -72,6 +81,8 @@ type PromptInput = {
   theme: Accessor<RunFooterTheme>
   mono: Accessor<boolean>
   history?: Accessor<RunPrompt[]>
+  queuedPrompts: Accessor<FooterQueuedPrompt[]>
+  onQueuedPromptSteer: (inputID: string) => Promise<boolean>
   onSubmit: (input: RunPrompt) => boolean | Promise<boolean>
   onCycle: () => void
   onInterrupt: () => boolean
@@ -980,8 +991,18 @@ export function createPromptState(input: PromptInput): PromptState {
   }))
 
   Keymap.createLayer(() => ({
+    priority: 1,
     enabled: input.prompt() && !visible(),
     commands: [
+      {
+        id: "prompt.queue",
+        title: "Queue prompt",
+        group: "Prompt",
+        run() {
+          syncDraft()
+          submitPrompt(promptCopy(draft), "queue")
+        },
+      },
       {
         id: "prompt.editor",
         title: "Open editor",
@@ -1116,7 +1137,8 @@ export function createPromptState(input: PromptInput): PromptState {
     }
   }
 
-  const submitPrompt = (next: RunPrompt) => {
+  let submitting = false
+  const submitPrompt = (next: RunPrompt, delivery: "steer" | "queue" = "steer") => {
     if (!area || area.isDestroyed) {
       draft = promptCopy(next)
     }
@@ -1130,12 +1152,29 @@ export function createPromptState(input: PromptInput): PromptState {
       hide()
     }
 
+    if (submitting) return
+
     if (!next.text.trim()) {
+      const queued = delivery === "steer" ? input.queuedPrompts()[0] : undefined
+      if (queued) {
+        submitting = true
+        void input.onQueuedPromptSteer(queued.messageID).finally(() => {
+          submitting = false
+        })
+        return
+      }
       input.onStatus(input.state().phase === "running" ? "waiting for current response" : "empty prompt ignored")
       return
     }
 
     const command = next.mode === "shell" ? undefined : selectedCommand(next.text, next.command)
+    if (
+      delivery === "queue" &&
+      (next.mode === "shell" || command?.source === "skill" || isNewCommand(next.text) || isCompactCommand(next.text))
+    ) {
+      input.onStatus("this prompt cannot be queued")
+      return
+    }
     if (!command && next.mode !== "shell" && isExitCommand(next.text)) {
       input.onExit()
       return
@@ -1157,24 +1196,28 @@ export function createPromptState(input: PromptInput): PromptState {
     }
 
     const submit = command
-      ? { ...next, command }
+      ? { ...next, command, delivery }
       : parsed?.type === "command"
-        ? { ...next, command: parsed.command }
-        : next
+        ? { ...next, command: parsed.command, delivery }
+        : { ...next, delivery }
     const shellMode = next.mode === "shell"
 
+    submitting = true
     resetDraft()
     queueMicrotask(async () => {
-      if (await input.onSubmit(submit)) {
-        push(next)
-        if (shellMode) {
-          setShellMode(false)
-          draft = emptyPrompt(false)
+      try {
+        if (await input.onSubmit(submit)) {
+          push(next)
+          if (shellMode) {
+            setShellMode(false)
+            draft = emptyPrompt(false)
+          }
+          return
         }
-        return
+        restore(next)
+      } finally {
+        submitting = false
       }
-
-      restore(next)
     })
   }
 

packages/tui/src/mini/footer.ts

@@ -51,6 +51,7 @@ import type {
   MiniSettingChange,
   MiniSettings,
   PermissionReply,
+  QueuedPromptAction,
   RunAgent,
   RunCommand,
   RunInput,
@@ -96,6 +97,7 @@ type RunFooterOptions = {
   onVariantSelect?: (variant: string | undefined) => CycleResult | void | Promise<CycleResult | void>
   onInterrupt?: () => void
   onBackground?: () => void
+  onQueuedPromptAction?: (action: QueuedPromptAction, inputID: string) => Promise<void>
   onEditorOpen: (input: { value: string }) => Promise<string | undefined>
   onSubagentSelect?: (sessionID: string | undefined) => void
   onSubagentInterrupt?: (sessionID: string) => void
@@ -343,6 +345,7 @@ export class RunFooter implements FooterApi {
               onCycle: footer.handleCycle,
               onInterrupt: footer.handleInterrupt,
               onBackground: options.onBackground,
+              onQueuedPromptAction: options.onQueuedPromptAction,
               onEditorOpen: options.onEditorOpen,
               onInputClear: footer.handleInputClear,
               onExitRequest: footer.handleExit,

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

@@ -34,6 +34,7 @@ import { Keymap } from "../context/keymap"
 import { modelInfo } from "./variant.shared"
 import { monoShortcut } from "./mono"
 import { stringWidth } from "../util/string-width"
+import { errorMessage } from "../util/error"
 
 import type {
   FooterPromptRoute,
@@ -46,6 +47,7 @@ import type {
   MiniSettingChange,
   MiniSettings,
   PermissionReply,
+  QueuedPromptAction,
   RunAgent,
   RunCommand,
   RunInput,
@@ -92,13 +94,14 @@ type RunFooterViewProps = {
   mono: boolean
   miniSettings: () => MiniSettings
   history?: () => RunPrompt[]
-  onSubmit: (input: RunPrompt) => boolean
+  onSubmit: (input: RunPrompt) => boolean | Promise<boolean>
   onPermissionReply: (input: PermissionReply) => void | Promise<void>
   onFormReply: (input: FormReply) => void | Promise<void>
   onFormCancel: (input: FormCancel) => void | Promise<void>
   onCycle: () => void
   onInterrupt: () => boolean
   onBackground?: () => void
+  onQueuedPromptAction?: (action: QueuedPromptAction, inputID: string) => Promise<void>
   onEditorOpen: (input: { value: string }) => Promise<string | undefined>
   onInputClear: () => void
   onExitRequest?: () => boolean
@@ -132,6 +135,7 @@ export function RunFooterView(props: RunFooterViewProps) {
   const [route, setRoute] = createSignal<FooterPromptRoute>({ type: "composer" })
   const [subagentMenuRows, setSubagentMenuRows] = createSignal(RUN_SUBAGENT_PANEL_ROWS)
   const queuedPrompts = createMemo(() => props.queuedPrompts?.() ?? [])
+  const queue = createMemo(() => queuedPrompts().filter((item) => item.delivery === "queue"))
   const skills = createMemo(() => (props.commands() ?? []).filter((item) => item.source === "skill"))
   const prompt = createMemo(() => active().type === "prompt" && route().type === "composer")
   const selectingSubagent = createMemo(() => active().type === "prompt" && route().type === "subagent-menu")
@@ -229,7 +233,7 @@ export function RunFooterView(props: RunFooterViewProps) {
     const details = [busy() ? "running" : "idle", `agent ${props.currentAgent()}`]
     if (current) details.push(variant ? `${current} ${variant}` : current)
     if (usage()) details.push(props.mono ? usage().replaceAll(" · ", " - ") : usage())
-    if (queuedPrompts().length > 0) details.push(`${queuedPrompts().length} pending`)
+    if (queue().length > 0) details.push(`${queue().length} queued`)
     if (activeTabs().length > 0) details.push(`${activeTabs().length} subagent${activeTabs().length === 1 ? "" : "s"}`)
     return details.join(props.mono ? " - " : " · ")
   })
@@ -309,7 +313,7 @@ export function RunFooterView(props: RunFooterViewProps) {
   }
 
   const openQueuedMenu = () => {
-    if (queuedPrompts().length === 0) return
+    if (queue().length === 0) return
     setRoute({ type: "queued-menu" })
     props.onSubagentSelect?.(undefined)
   }
@@ -318,6 +322,23 @@ export function RunFooterView(props: RunFooterViewProps) {
     setRoute({ type: "composer" })
   }
 
+  const pendingQueueActions = new Set<string>()
+  const queuedPromptAction = async (action: QueuedPromptAction, inputID: string) => {
+    if (pendingQueueActions.has(inputID)) return false
+    const run = props.onQueuedPromptAction
+    if (!run) return false
+    pendingQueueActions.add(inputID)
+    const error = await run(action, inputID)
+      .then(
+        () => undefined,
+        (error) => error,
+      )
+      .finally(() => pendingQueueActions.delete(inputID))
+    if (!error) return true
+    props.onStatus(`failed to ${action === "cancel" ? "delete" : action} queued prompt: ${errorMessage(error)}`)
+    return false
+  }
+
   const openTab = (sessionID: string) => {
     setRoute({ type: "subagent", sessionID })
     props.onSubagentSelect?.(sessionID)
@@ -357,6 +378,8 @@ export function RunFooterView(props: RunFooterViewProps) {
     theme,
     mono: () => props.mono,
     history: props.history,
+    queuedPrompts: queue,
+    onQueuedPromptSteer: (inputID) => queuedPromptAction("steer", inputID),
     onSubmit: props.onSubmit,
     onCycle: props.onCycle,
     onInterrupt: props.onInterrupt,
@@ -451,13 +474,12 @@ export function RunFooterView(props: RunFooterViewProps) {
     if (foregroundSubagents() && backgroundShortcut()) {
       items.push({ key: backgroundShortcut(), label: "background" })
     }
-    if (queuedPrompts().length > 0 && queuedShortcut()) {
-      items.push({ key: queuedShortcut(), label: `${queuedPrompts().length} pending` })
+    if (queue().length > 0 && queuedShortcut()) {
+      items.push({ key: queuedShortcut(), label: `${queue().length} queued` })
     }
     if (activeTabs().length > 0 && subagentShortcut()) {
       items.push({ key: subagentShortcut(), label: "subagents" })
     }
-
     return items
   })
   const commandHint = createMemo(() => {
@@ -568,7 +590,7 @@ export function RunFooterView(props: RunFooterViewProps) {
   }))
 
   Keymap.createLayer(() => ({
-    enabled: active().type === "prompt" && route().type === "composer" && queuedPrompts().length > 0,
+    enabled: active().type === "prompt" && route().type === "composer" && queue().length > 0,
     commands: [
       {
         id: "session.queued_prompts",
@@ -630,7 +652,7 @@ export function RunFooterView(props: RunFooterViewProps) {
   })
 
   createEffect(() => {
-    if (route().type !== "queued-menu" || queuedPrompts().length > 0) return
+    if (route().type !== "queued-menu" || queue().length > 0) return
     closePanel()
   })
 
@@ -734,8 +756,16 @@ export function RunFooterView(props: RunFooterViewProps) {
                         <Match when={selectingQueued()}>
                           <RunQueuedPromptSelectBody
                             theme={theme}
-                            prompts={queuedPrompts}
+                            prompts={queue}
                             onClose={closePanel}
+                            onSteer={(item) => {
+                              void queuedPromptAction("steer", item.messageID).then((steered) => {
+                                if (steered) closePanel()
+                              })
+                            }}
+                            onDelete={(item) => {
+                              void queuedPromptAction("cancel", item.messageID)
+                            }}
                             onRows={setSubagentMenuRows}
                             mono={props.mono}
                           />
@@ -745,7 +775,7 @@ export function RunFooterView(props: RunFooterViewProps) {
                             theme={theme}
                             commands={props.commands}
                             subagents={tabs}
-                            queued={queuedPrompts}
+                            queued={queue}
                             variants={props.variants}
                             variantCycle={variantCycle()}
                             onClose={closePanel}

packages/tui/src/mini/runtime.lifecycle.ts

@@ -22,6 +22,7 @@ import type {
   MiniSettings,
   MiniHost,
   PermissionReply,
+  QueuedPromptAction,
   RunAgent,
   RunInput,
   RunPrompt,
@@ -70,6 +71,7 @@ export type LifecycleInput = {
   onVariantSelect?: (variant: string | undefined) => CycleResult | void | Promise<CycleResult | void>
   onInterrupt?: () => void
   onBackground?: () => void
+  onQueuedPromptAction?: (action: QueuedPromptAction, inputID: string) => Promise<void>
   onSubagentSelect?: (sessionID: string | undefined) => void
   onSubagentInterrupt?: (sessionID: string) => void
 }
@@ -243,6 +245,7 @@ export async function createRuntimeLifecycle(input: LifecycleInput): Promise<Lif
     onVariantSelect: input.onVariantSelect,
     onInterrupt: input.onInterrupt,
     onBackground: input.onBackground,
+    onQueuedPromptAction: input.onQueuedPromptAction,
     onEditorOpen: async ({ value }) => {
       if (closed || renderer.isDestroyed) {
         return

packages/tui/src/mini/runtime.queue.ts

@@ -25,7 +25,7 @@ export type QueueInput = {
   onAdmissionError?: (prompt: RunPrompt, error: unknown) => void | Promise<void>
   onNewSession?: () => void | Promise<void>
   onCompact?: () => void | Promise<void>
-  admit: (prompt: RunPrompt, signal: AbortSignal) => Promise<void>
+  admit: (prompt: RunPrompt, delivery: "steer" | "queue", signal: AbortSignal) => Promise<void>
   settle: () => Promise<void>
   run: (prompt: RunPrompt, signal: AbortSignal, admitted: () => void) => Promise<void>
 }
@@ -183,7 +183,7 @@ export async function runPromptQueue(input: QueueInput): Promise<void> {
               input.trace?.write("ui.commit", commit)
               input.footer.append(commit)
             }
-            input.onSend?.(sent, "steer")
+            input.onSend?.(sent, sent.delivery ?? "steer")
 
             if (state.closed) {
               break
@@ -276,10 +276,11 @@ export async function runPromptQueue(input: QueueInput): Promise<void> {
       const sent = { ...prompt, messageID: SessionMessage.ID.create() }
       const admission = state.admission
       admissionVersion += 1
-      input.onSend?.(sent, "queue")
+      const delivery = prompt.delivery ?? "queue"
+      input.onSend?.(sent, delivery)
       admissions = admissions
         .then(() => admission)
-        .then(() => input.admit(sent, admissionController.signal))
+        .then(() => input.admit(sent, delivery, admissionController.signal))
         .catch((error) => (state.closed ? undefined : input.onAdmissionError?.(sent, error)))
       return
     }

packages/tui/src/mini/runtime.ts

@@ -390,6 +390,15 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
       log?.write("send.background", { sessionID: state.sessionID })
       void state.sdk.session.background({ sessionID: state.sessionID }).catch(() => {})
     },
+    onQueuedPromptAction: async (action, inputID) => {
+      if (!state.sessionID) return
+      log?.write(`send.pending.${action}`, { sessionID: state.sessionID, inputID })
+      if (action === "steer") {
+        await state.sdk.session.pending.steer({ sessionID: state.sessionID, inputID })
+        return
+      }
+      await state.sdk.session.pending.cancel({ sessionID: state.sessionID, inputID })
+    },
     onSubagentInterrupt: (sessionID) => {
       log?.write("send.subagent.interrupt", { sessionID })
       void state.sdk.session.interrupt({ sessionID }).catch(() => {})
@@ -892,7 +901,7 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
       trace: log,
       onSend: (prompt, delivery) => {
         state.shown = true
-        state.history.push(prompt)
+        state.history.push({ ...prompt, delivery: undefined })
         if (prompt.mode !== "shell" && delivery === "steer") {
           rememberLocal({
             kind: "user",
@@ -903,18 +912,21 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
           })
         }
       },
-      admit: async (prompt, signal) => {
+      admit: async (prompt, delivery, signal) => {
         await state.switching?.catch(() => {})
         const next = await ensureStream()
-        await next.handle.queuePromptTurn({
-          agent: state.agent,
-          model: state.model,
-          variant: state.activeVariant,
-          prompt,
-          files: input.files,
-          includeFiles: false,
-          signal,
-        })
+        await next.handle.admitPromptTurn(
+          {
+            agent: state.agent,
+            model: state.model,
+            variant: state.activeVariant,
+            prompt,
+            files: input.files,
+            includeFiles: false,
+            signal,
+          },
+          delivery,
+        )
       },
       onAdmissionError: renderPromptError,
       onCompact: async () => {

packages/tui/src/mini/stream-v2.subagent.ts

@@ -653,6 +653,10 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
       }
       return
     }
+    if (event.type === "session.input.cancelled") {
+      child.prompts.delete(event.data.inputID)
+      return
+    }
     if (event.type === "session.step.started") {
       touch(child, event.created)
       if (child.label === FALLBACK_LABEL && event.data.agent) child.label = Locale.titlecase(event.data.agent)

packages/tui/src/mini/stream-v2.transport.ts

@@ -71,7 +71,7 @@ export type SessionResizeReplayInput = {
 
 export type SessionTransport = {
   runPromptTurn(input: SessionTurnInput, admitted?: () => void): Promise<void>
-  queuePromptTurn(input: SessionTurnInput): Promise<void>
+  admitPromptTurn(input: SessionTurnInput, delivery: "steer" | "queue"): Promise<void>
   waitForIdle(): Promise<void>
   interruptActiveTurn(): Promise<void>
   selectSubagent(sessionID: string | undefined): void
@@ -515,8 +515,12 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
     )
   }
 
+  let syncedPending: string[] | undefined
   const syncPending = () => {
-    const prompts = [...state.pending.values()]
+    const prompts = [...state.pending.values()].filter((item) => item.delivery === "queue")
+    const ids = prompts.map((item) => item.messageID)
+    if (syncedPending?.length === ids.length && syncedPending.every((id, index) => id === ids[index])) return
+    syncedPending = ids
     input.trace?.write("ui.patch", { pending: prompts.length })
     input.footer.event({ type: "queued.prompts", prompts })
   }
@@ -934,6 +938,36 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       write([], { phase: "running", status: "waiting for assistant" })
       return
     }
+    if (event.type === "session.input.steered") {
+      const pending = state.pending.get(event.data.inputID)
+      if (!pending) return
+      state.pending.set(event.data.inputID, { ...pending, delivery: "steer" })
+      syncPending()
+      if (state.messageIDs.has(event.data.inputID)) return
+      state.messageIDs.add(event.data.inputID)
+      write([
+        {
+          kind: "user",
+          source: "system",
+          text: pending.prompt.text,
+          phase: "start",
+          messageID: event.data.inputID,
+        },
+      ])
+      return
+    }
+    if (event.type === "session.input.queued") {
+      const pending = state.pending.get(event.data.inputID)
+      if (!pending) return
+      state.pending.set(event.data.inputID, { ...pending, delivery: "queue" })
+      syncPending()
+      return
+    }
+    if (event.type === "session.input.cancelled") {
+      state.admitted.delete(event.data.inputID)
+      if (state.pending.delete(event.data.inputID)) syncPending()
+      return
+    }
     if (event.type === "session.step.started") {
       state.stepModel = { providerID: event.data.model.providerID, modelID: event.data.model.id }
       write([], { phase: "running", status: "assistant responding" })
@@ -1643,14 +1677,14 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
   }
 
   return {
-    async queuePromptTurn(next) {
+    async admitPromptTurn(next, delivery) {
       if (next.prompt.mode === "shell" || next.prompt.command?.source === "skill")
         throw new Error("This prompt cannot be queued")
       if (!state.connected) throw new Error("Event stream is reconnecting")
       const client = sdk
       if (next.agent)
         await client.session.switchAgent({ sessionID: input.sessionID, agent: next.agent }, { signal: next.signal })
-      mergePending(await admitPrompt(next, client, "queue"))
+      mergePending(await admitPrompt(next, client, delivery))
       settlementClient = client
     },
     async waitForIdle() {
@@ -1688,7 +1722,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
         return
       }
       if (command) {
-        await runTurnWait(next, messageID, client, () => admitPrompt(next, client, "steer"), admitted)
+        await runTurnWait(next, messageID, client, () => admitPrompt(next, client, next.prompt.delivery ?? "steer"), admitted)
         return
       }
 
@@ -1700,7 +1734,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       if (selected)
         await client.session.switchModel({ sessionID: input.sessionID, model: selected }, { signal: next.signal })
 
-      await runTurnWait(next, messageID, client, () => admitPrompt(next, client, "steer"), admitted)
+      await runTurnWait(next, messageID, client, () => admitPrompt(next, client, next.prompt.delivery ?? "steer"), admitted)
     },
     async interruptActiveTurn() {
       // A running shell holds no drain, so session.interrupt cannot reach it;

packages/tui/src/mini/types.ts

@@ -75,6 +75,7 @@ export type RunPrompt = {
   messageID?: string
   text: string
   parts: RunPromptPart[]
+  delivery?: "steer" | "queue"
   mode?: "shell"
   command?: {
     name: string
@@ -90,6 +91,8 @@ export type FooterQueuedPrompt = {
   delivery: "steer" | "queue"
 }
 
+export type QueuedPromptAction = "steer" | "cancel"
+
 export type RunAgent = {
   id: string
   name: string

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

@@ -52,6 +52,7 @@ import { useClient } from "../../context/client"
 import { useEditorContext } from "../../context/editor"
 import { openEditor } from "../../editor"
 import { useDialog } from "../../ui/dialog"
+import { DialogSelect } from "../../ui/dialog-select"
 import { DialogSessionRename } from "../../component/dialog-session-rename"
 import { DialogMessage } from "./dialog-message"
 import { DialogFork } from "./dialog-fork"
@@ -109,6 +110,7 @@ const NAVIGATION_SLACK_ID = "session-navigation-slack"
 const TRANSCRIPT_TAIL_ROWS = 40
 const TRANSCRIPT_BACKFILL_CHUNK = 60
 const TRANSCRIPT_BACKFILL_DELAY = 120
+type PendingAction = "steer" | "queue" | "cancel"
 
 const context = createContext<{
   width: number
@@ -120,6 +122,7 @@ const context = createContext<{
   diffWrapMode: () => "word" | "none"
   models: () => ModelInfo[]
   config: ReturnType<typeof useConfig>["data"]
+  mutatePending: (action: PendingAction, inputID: string) => Promise<boolean>
 }>()
 
 function use() {
@@ -175,6 +178,11 @@ export function Session() {
       .flatMap((sessionID) => data.session.form.list(sessionID) ?? [])
       .concat(global)
   })
+  const queuedPrompts = createMemo(() =>
+    data.session.pending.list(route.sessionID).flatMap((item) =>
+      item.type === "user" && item.delivery === "queue" ? [{ id: item.id, text: item.data.text }] : [],
+    ),
+  )
   const [composer, setComposer] = createStore({
     open: false,
     tab: undefined as string | undefined,
@@ -204,7 +212,7 @@ export function Session() {
   const availableWidth = createMemo(
     () =>
       dimensions().width -
-      (config.tabs?.enabled && config.tabs.layout === "vertical" && sessionTabsFitVertically(dimensions().width)
+      (config.tabs?.enabled && config.tabs.vertical && sessionTabsFitVertically(dimensions().width)
         ? SESSION_SIDEBAR_WIDTH
         : 0),
   )
@@ -361,7 +369,7 @@ export function Session() {
 
   createEffect(() => {
     const current = prompt()
-    if (sent || !current || !synced() || !local.model.ready || !local.model.catalogReady) return
+    if (sent || !current || !synced() || !local.model.ready) return
     if (!local.agent.current() || !local.model.current()) return
     if (!args.prompt || route.prompt?.text !== args.prompt || current.current.text !== args.prompt) return
     sent = true
@@ -369,6 +377,55 @@ export function Session() {
   })
   const dialog = useDialog()
   const renderer = useRenderer()
+  const pendingQueueActions = new Set<string>()
+  const mutatePending = async (action: PendingAction, inputID: string) => {
+    if (pendingQueueActions.has(inputID)) return false
+    pendingQueueActions.add(inputID)
+    const request =
+      action === "steer"
+        ? client.api.session.pending.steer({ sessionID: route.sessionID, inputID })
+        : action === "queue"
+          ? client.api.session.pending.queue({ sessionID: route.sessionID, inputID })
+          : client.api.session.pending.cancel({ sessionID: route.sessionID, inputID })
+    const error = await request
+      .then(
+        () => undefined,
+        (error) => error,
+      )
+      .finally(() => pendingQueueActions.delete(inputID))
+    if (!error) return true
+    const label = action === "cancel" ? "delete" : action
+    toast.show({ title: `Failed to ${label} pending prompt`, message: errorMessage(error), variant: "error" })
+    return false
+  }
+  const openQueuedPrompts = () =>
+    dialog.replace(() => (
+      <DialogSelect
+        title="Queued prompts"
+        options={queuedPrompts().map((prompt, index) => ({
+          title: prompt.text,
+          value: prompt.id,
+          footer: `${index + 1} of ${queuedPrompts().length}`,
+        }))}
+        onSelect={(option) => {
+          void mutatePending("steer", option.value).then((steered) => {
+            if (steered) dialog.clear()
+          })
+        }}
+        actions={[
+          {
+            command: "queued_prompt.delete",
+            title: "delete",
+            onTrigger: (option) => {
+              void mutatePending("cancel", option.value).then((cancelled) => {
+                if (cancelled && queuedPrompts().length <= 1) dialog.clear()
+              })
+            },
+          },
+        ]}
+        footerHints={[{ title: "steer", label: "enter" }]}
+      />
+    ))
   const unavailable = (feature: string) => {
     toast.show({ message: `${feature} is not implemented for V2 sessions yet`, variant: "error", duration: 5000 })
     dialog.clear()
@@ -824,13 +881,22 @@ export function Session() {
           if (options === null) return
 
           const content =
-              options.format === "markdown"
-                ? formatSessionTranscript(sessionData, messages(), options.thinking)
-                : JSON.stringify(
-                    await client.api.session.export({ sessionID: sessionData.id, sanitize: options.sanitize }),
-                    null,
-                    2,
-                  ) + EOL
+            options.format === "markdown"
+              ? formatSessionTranscript(sessionData, messages(), options.thinking)
+              : await (async () => {
+                  const messages: unknown[] = []
+                  let cursor: string | undefined
+                  do {
+                    const page = await client.api.message.list(
+                      cursor
+                        ? { sessionID: sessionData.id, limit: 200, cursor }
+                        : { sessionID: sessionData.id, limit: 200, order: "asc" },
+                    )
+                    messages.push(...page.data)
+                    cursor = page.data.length ? (page.cursor.next ?? undefined) : undefined
+                  } while (cursor)
+                  return JSON.stringify({ info: sessionData, messages }, null, 2) + EOL
+                })()
 
           if (options.action === "copy") {
             await clipboard.write?.(content)
@@ -871,6 +937,13 @@ export function Session() {
         dialog.clear()
       },
     },
+    {
+      title: "View queued prompts",
+      id: "session.queued_prompts",
+      group: "Session",
+      enabled: queuedPrompts().length > 0,
+      run: openQueuedPrompts,
+    },
     {
       title: "Go to parent session",
       id: "session.parent",
@@ -942,6 +1015,7 @@ export function Session() {
         diffWrapMode,
         models,
         config,
+        mutatePending,
       }}
     >
       <box flexDirection="row" flexGrow={1} minHeight={0}>
@@ -997,6 +1071,9 @@ export function Session() {
               </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}
@@ -1032,6 +1109,11 @@ export function Session() {
                     onSubmit={() => {
                       toBottom()
                     }}
+                    onEmptySubmit={async () => {
+                      const next = queuedPrompts()[0]
+                      if (!next) return false
+                      return mutatePending("steer", next.id)
+                    }}
                     sessionID={route.sessionID}
                   />
                 </Match>
@@ -1813,6 +1895,7 @@ function ShellMessage(props: { message: Extract<SessionMessageInfo, { type: "she
 
   return (
     <box
+      width="100%"
       border={["left"]}
       paddingTop={1}
       paddingBottom={1}
@@ -1840,18 +1923,23 @@ function UserMessage(props: { message: SessionMessageUser }) {
   const mode = themes.mode
   const [hover, setHover] = createSignal(false)
   const color = createMemo(() => local.agent.color(data.session.get(ctx.sessionID)?.agent ?? "build"))
-  const queued = createMemo(
-    () => data.session.status(ctx.sessionID) === "running" && data.session.input.has(ctx.sessionID, props.message.id),
-  )
+  const delivery = createMemo(() => {
+    const pending = data.session.pending.list(ctx.sessionID).find((item) => item.id === props.message.id)
+    return pending?.type === "user" ? pending.delivery : undefined
+  })
   const dialog = useDialog()
   const renderer = useRenderer()
   const promptRef = usePromptRef()
 
+  const updatePendingSteer = async (action: "queue" | "cancel") => {
+    if (await ctx.mutatePending(action, props.message.id)) dialog.clear()
+  }
+
   return (
     <Show when={props.message.text.trim() || files().length}>
       <box
         border={["left"]}
-        borderColor={queued() ? theme.border.default : color()}
+        borderColor={delivery() ? theme.border.default : color()}
         customBorderChars={SplitBorder.customBorderChars}
       >
         <box
@@ -1863,6 +1951,21 @@ function UserMessage(props: { message: SessionMessageUser }) {
           }}
           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(() => (
               <DialogMessage
                 messageID={props.message.id}
@@ -1910,6 +2013,35 @@ function UserMessage(props: { message: SessionMessageUser }) {
   )
 }
 
+function QueuedPromptDock(props: { prompts: { id: string; text: string }[]; onOpen: () => void }) {
+  const theme = useTheme("elevated")
+  const next = createMemo(() => props.prompts[0]?.text)
+
+  return (
+    <box
+      border={["left"]}
+      borderColor={theme.border.default}
+      customBorderChars={SplitBorder.customBorderChars}
+      onMouseUp={props.onOpen}
+    >
+      <box
+        width="100%"
+        paddingTop={1}
+        paddingBottom={1}
+        paddingLeft={2}
+        paddingRight={1}
+        backgroundColor={theme.background.default}
+        flexDirection="row"
+      >
+        <text fg={theme.text.subdued} wrapMode="none" truncate flexGrow={1} flexShrink={1} minWidth={0}>
+          <span style={{ fg: theme.text.default }}>{props.prompts.length} queued</span>
+          <Show when={next()}>{(text) => <> · {text()}</>}</Show>
+        </text>
+      </box>
+    </box>
+  )
+}
+
 function AssistantRetry(props: { retry: SessionMessageAssistant["retry"] }) {
   const theme = useTheme()
   return (

packages/tui/src/routes/session/rows.ts

@@ -46,9 +46,14 @@ export function createSessionRows(sessionID: Accessor<string>) {
   function reduce() {
     const messages = data.session.message.list(sessionID())
     const inputs = new Set(data.session.input.list(sessionID()))
+    const pending = data.session.pending.list(sessionID())
+    const queued = new Set(
+      pending.flatMap((item) => (item.type === "user" && item.delivery === "queue" ? [item.id] : [])),
+    )
+    const visible = queued.size === 0 ? messages : messages.filter((message) => !queued.has(message.id))
     const boundary = revertBoundary()
     const rows = reduceSessionRows(
-      boundary ? messages.filter((message) => message.id < boundary) : messages,
+      boundary ? visible.filter((message) => message.id < boundary) : visible,
       inputs,
       turnTokens(),
     )
@@ -57,8 +62,7 @@ export function createSessionRows(sessionID: Accessor<string>) {
     rows.splice(
       position === -1 ? rows.length : position,
       0,
-      ...data.session.pending
-        .list(sessionID())
+      ...pending
         .filter((item) => item.type === "compaction")
         .map((item): SessionRow => ({ type: "compaction-queued", inputID: item.id })),
     )
@@ -112,10 +116,11 @@ export function createSessionRows(sessionID: Accessor<string>) {
   createEffect(
     on(
       () =>
-        data.session.pending
-          .list(sessionID())
-          .filter((item) => item.type === "compaction")
-          .map((item) => item.id),
+        data.session.pending.list(sessionID()).flatMap((item) => {
+          if (item.type === "compaction") return [`${item.id}:compaction`]
+          if (item.type === "user" && item.delivery === "queue") return [`${item.id}:queue`]
+          return []
+        }),
       () => setRows(reconcile(reduce())),
       { defer: true },
     ),
@@ -196,7 +201,9 @@ export function createSessionRows(sessionID: Accessor<string>) {
 
   const queuedStart = (rows: SessionRow[]) => {
     const index = rows.findIndex(
-      (row) => row.type === "compaction-queued" || (row.type === "message" && isPending(row.messageID)),
+      (row) =>
+        row.type === "compaction-queued" ||
+        (row.type === "message" && isPending(row.messageID)),
     )
     return index === -1 ? rows.length : index
   }

packages/tui/src/ui/dialog-export-options.tsx

@@ -9,11 +9,11 @@ export type ExportFormat = "markdown" | "json"
 
 export type DialogExportOptionsProps = {
   defaultThinking: boolean
-  onConfirm?: (options: { action: "copy" | "export"; format: ExportFormat; thinking: boolean; sanitize: boolean }) => void
+  onConfirm?: (options: { action: "copy" | "export"; format: ExportFormat; thinking: boolean }) => void
   onCancel?: () => void
 }
 
-type Active = ExportFormat | "thinking" | "sanitize" | "copy" | "export"
+type Active = ExportFormat | "thinking" | "copy" | "export"
 
 export function DialogExportOptions(props: DialogExportOptionsProps) {
   const dialog = useDialog()
@@ -22,7 +22,6 @@ export function DialogExportOptions(props: DialogExportOptionsProps) {
   const [store, setStore] = createStore({
     format: "markdown" as ExportFormat,
     thinking: props.defaultThinking,
-    sanitize: false,
     active: "markdown" as Active,
   })
 
@@ -31,7 +30,6 @@ export function DialogExportOptions(props: DialogExportOptionsProps) {
       action,
       format: store.format,
       thinking: store.thinking,
-      sanitize: store.sanitize,
     })
 
   const activate = () => {
@@ -40,7 +38,6 @@ export function DialogExportOptions(props: DialogExportOptionsProps) {
       return
     }
     if (store.active === "thinking") setStore("thinking", !store.thinking)
-    if (store.active === "sanitize") setStore("sanitize", !store.sanitize)
     if (store.active === "copy" || store.active === "export") confirm(store.active)
   }
 
@@ -55,7 +52,7 @@ export function DialogExportOptions(props: DialogExportOptionsProps) {
           const order: Active[] =
             store.format === "markdown"
               ? ["markdown", "json", "thinking", "copy", "export"]
-              : ["markdown", "json", "sanitize", "copy", "export"]
+              : ["markdown", "json", "copy", "export"]
           setStore("active", order[(order.indexOf(store.active) + 1) % order.length])
         },
       },
@@ -156,46 +153,6 @@ export function DialogExportOptions(props: DialogExportOptionsProps) {
           </text>
         </box>
       </Show>
-      <Show when={store.format === "json"}>
-        <box
-          flexDirection="row"
-          gap={1}
-          backgroundColor={
-            store.active === "sanitize"
-              ? theme.background.formfield.focused
-              : store.sanitize
-                ? theme.background.formfield.selected
-                : theme.background.formfield.default
-          }
-          onMouseUp={() => {
-            setStore("active", "sanitize")
-            setStore("sanitize", !store.sanitize)
-          }}
-        >
-          <text
-            fg={
-              store.active === "sanitize"
-                ? theme.text.formfield.focused
-                : store.sanitize
-                  ? theme.text.formfield.selected
-                  : theme.text.formfield.default
-            }
-          >
-            {store.sanitize ? "[x]" : "[ ]"}
-          </text>
-          <text
-            fg={
-              store.active === "sanitize"
-                ? theme.text.formfield.focused
-                : store.sanitize
-                  ? theme.text.formfield.selected
-                  : theme.text.formfield.default
-            }
-          >
-            Sanitize sensitive data
-          </text>
-        </box>
-      </Show>
       <box flexDirection="row" justifyContent="flex-end" gap={1} paddingBottom={1}>
         <box
           paddingLeft={4}
@@ -229,7 +186,6 @@ DialogExportOptions.show = (dialog: DialogContext, defaultThinking: boolean) =>
     action: "copy" | "export"
     format: ExportFormat
     thinking: boolean
-    sanitize: boolean
   } | null>((resolve) => {
     dialog.replace(
       () => (

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

@@ -84,8 +84,7 @@ export function DialogPrompt(props: DialogPromptProps) {
       <box gap={1}>
         {props.description?.()}
         <textarea
-          height={1}
-          wrapMode="none"
+          height={3}
           ref={(val: TextareaRenderable) => {
             textarea = val
             setTextareaTarget(val)

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

@@ -71,7 +71,6 @@ export interface DialogSelectOption<T = any> {
   detailsColor?: RGBA
   detailsWrap?: boolean
   footer?: JSX.Element | string
-  footerColor?: RGBA
   titleWidth?: number
   truncateTitle?: boolean | "left"
   category?: string
@@ -728,7 +727,6 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
                               footer={
                                 flatten() ? (option.searchFooter ?? option.category ?? option.footer) : option.footer
                               }
-                              footerColor={option.footerColor}
                               titleWidth={option.titleWidth}
                               truncateTitle={option.truncateTitle}
                               description={option.description !== category ? option.description : undefined}
@@ -786,7 +784,6 @@ function Option(props: {
   current?: boolean
   muted?: boolean
   footer?: JSX.Element | string
-  footerColor?: RGBA
   titleWidth?: number
   truncateTitle?: boolean | "left"
   gutter?: () => JSX.Element
@@ -835,17 +832,7 @@ function Option(props: {
       </text>
       <Show when={props.footer}>
         <box flexShrink={0}>
-          <text
-            fg={
-              props.active && !props.muted
-                ? text()
-                : props.muted && (props.active || props.current)
-                  ? theme.text.subdued
-                  : (props.footerColor ?? theme.text.subdued)
-            }
-          >
-            {props.footer}
-          </text>
+          <text fg={props.active && !props.muted ? text() : theme.text.subdued}>{props.footer}</text>
         </box>
       </Show>
     </>

packages/tui/test/cli/tui/data.test.tsx

@@ -914,6 +914,106 @@ test("completes exploration when a queued prompt is promoted", async () => {
   }
 })
 
+test("updates and removes queued inputs from durable lifecycle events", async () => {
+  const events = createEventStream()
+  const sessionID = "session-queue-management"
+  const calls = createFetch((url) => {
+    if (url.pathname === `/api/session/${sessionID}/message`) return json({ data: [], cursor: {} })
+  }, events)
+  let data!: ReturnType<typeof useData>
+  let rows!: ReturnType<typeof createSessionRows>
+  let client!: ReturnType<typeof useClient>
+
+  function Probe() {
+    client = useClient()
+    data = useData()
+    rows = createSessionRows(() => sessionID)
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <ClientProvider api={createApi(calls.fetch)}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </ClientProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    await wait(() => client.connection.status() === "connected")
+    emitEvent(events, {
+      id: "evt_queue_admitted",
+      created: 1,
+      type: "session.input.admitted",
+      durable: durable(sessionID),
+      data: {
+        sessionID,
+        inputID: "message-queued",
+        input: { type: "user", data: { text: "Steer me" }, delivery: "queue" },
+      },
+    })
+    await wait(() => data.session.pending.list(sessionID).length === 1)
+    expect(rows).not.toContainEqual({ type: "message", messageID: "message-queued" })
+
+    emitEvent(events, {
+      id: "evt_queue_steered",
+      created: 2,
+      type: "session.input.steered",
+      durable: durable(sessionID, 1),
+      data: { sessionID, inputID: "message-queued" },
+    })
+    await wait(() =>
+      data.session.pending
+        .list(sessionID)
+        .some((item) => item.id === "message-queued" && item.type !== "compaction" && item.delivery === "steer"),
+    )
+    expect(rows).toContainEqual({ type: "message", messageID: "message-queued" })
+
+    emitEvent(events, {
+      id: "evt_queue_restored",
+      created: 3,
+      type: "session.input.queued",
+      durable: durable(sessionID, 2),
+      data: { sessionID, inputID: "message-queued" },
+    })
+    await wait(() =>
+      data.session.pending
+        .list(sessionID)
+        .some((item) => item.id === "message-queued" && item.type !== "compaction" && item.delivery === "queue"),
+    )
+    expect(rows).not.toContainEqual({ type: "message", messageID: "message-queued" })
+
+    emitEvent(events, {
+      id: "evt_cancel_admitted",
+      created: 4,
+      type: "session.input.admitted",
+      durable: durable(sessionID, 3),
+      data: {
+        sessionID,
+        inputID: "message-cancelled",
+        input: { type: "user", data: { text: "Delete me" }, delivery: "queue" },
+      },
+    })
+    await wait(() => data.session.pending.list(sessionID).length === 2)
+    emitEvent(events, {
+      id: "evt_queue_cancelled",
+      created: 5,
+      type: "session.input.cancelled",
+      durable: durable(sessionID, 4),
+      data: { sessionID, inputID: "message-cancelled" },
+    })
+    await wait(() => !data.session.input.has(sessionID, "message-cancelled"))
+    expect(data.session.pending.list(sessionID).map((item) => item.id)).toEqual(["message-queued"])
+    expect(data.session.message.get(sessionID, "message-cancelled")).toBeUndefined()
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
 test("classifies live tool rows independently of their call ID", async () => {
   const events = createEventStream()
   const sessionID = "session-tool-call-id"

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

@@ -3,7 +3,6 @@ import { testRender } from "@opentui/solid"
 import { expect, test } from "bun:test"
 import { Schema } from "effect"
 import { resolve, ConfigProvider, Info, useConfig, type Interface } from "../src/config"
-import { settings } from "../src/component/dialog-config"
 
 test("validates mini replay settings", () => {
   const decode = Schema.decodeUnknownSync(Info)
@@ -18,10 +17,7 @@ test("validates mini replay settings", () => {
 test("validates the session tabs setting", () => {
   const decode = Schema.decodeUnknownSync(Info)
 
-  expect(decode({ tabs: { enabled: true, layout: "vertical" } })).toEqual({
-    tabs: { enabled: true, layout: "vertical" },
-  })
-  expect(() => decode({ tabs: { layout: true } })).toThrow()
+  expect(decode({ tabs: { enabled: true, vertical: true } })).toEqual({ tabs: { enabled: true, vertical: true } })
   expect(() => decode({ tabs: { enabled: "on" } })).toThrow()
 })
 
@@ -42,13 +38,6 @@ test("resolves nested config and keybind defaults", () => {
   expect(config.scroll).toEqual({ speed: 2, acceleration: true })
   expect(config.diffs).toEqual({ view: "split" })
   expect(config.debug).toEqual({ devtools: true })
-  expect(config.tabs).toEqual({ enabled: true, scope: "cwd", layout: "horizontal" })
-})
-
-test("shows resolved tab defaults in settings", () => {
-  expect(settings.find((setting) => setting.path.join(".") === "tabs.enabled")?.default).toBe(true)
-  expect(settings.find((setting) => setting.path.join(".") === "tabs.scope")?.default).toBe("cwd")
-  expect(settings.find((setting) => setting.path.join(".") === "tabs.layout")?.default).toBe("horizontal")
 })
 
 test("provides config and its host interface", async () => {

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

@@ -60,8 +60,8 @@ async function renderSessionTabs(
     await Bun.write(
       file,
       JSON.stringify({
-        global: { tabs: [], unread: {} },
-        cwd: { [directory]: { tabs: options.persisted.map((sessionID) => ({ sessionID })), unread: {} } },
+        global: { tabs: options.persisted.map((sessionID) => ({ sessionID })), unread: {} },
+        cwd: {},
       }),
     )
   }
@@ -153,15 +153,15 @@ test("loads persisted tab metadata concurrently on connect", async () => {
   }
 })
 
-test("stores session tabs for the current working directory by default", async () => {
+test("stores session tabs globally by default", async () => {
   const setup = await renderSessionTabs("first")
 
   try {
     const file = path.join(setup.state, "test", "tui", "tabs.json")
     await wait(() => Bun.file(file).size > 0)
     expect(await Bun.file(file).json()).toEqual({
-      global: { tabs: [], unread: {} },
-      cwd: { [directory]: { tabs: [{ sessionID: "first" }], unread: {} } },
+      global: { tabs: [{ sessionID: "first" }], unread: {} },
+      cwd: {},
     })
   } finally {
     setup.destroy()
@@ -180,7 +180,7 @@ test("concurrent TUIs do not alternate shared tab titles from divergent session
     await titled.data.session.sync("shared")
     await wait(async () => {
       if (!(await Bun.file(file).exists())) return false
-      return (await Bun.file(file).json()).cwd[directory]?.tabs[0]?.title === "Generated title"
+      return (await Bun.file(file).json()).global.tabs[0]?.title === "Generated title"
     })
     const observed = ["Generated title"]
     const pending = new Set<Promise<void>>()
@@ -189,7 +189,7 @@ test("concurrent TUIs do not alternate shared tab titles from divergent session
       const read = Bun.file(file)
         .json()
         .then((value) => {
-          const title = value.cwd[directory]?.tabs[0]?.title
+          const title = value.global.tabs[0]?.title
           if (title && observed.at(-1) !== title) observed.push(title)
         })
         .catch(() => undefined)

packages/tui/test/mini/fixture/footer-api.ts

@@ -56,9 +56,9 @@ export function createFooterApiFixture(input: { events?: FooterEvent[]; commits?
     commits,
     calls,
     promptReady,
-    submit(text: string, mode?: RunPrompt["mode"]) {
+    submit(text: string, mode?: RunPrompt["mode"], delivery?: RunPrompt["delivery"]) {
       if (prompts.size === 0) return false
-      const prompt: RunPrompt = mode ? { text, parts: [], mode } : { text, parts: [] }
+      const prompt: RunPrompt = { text, parts: [], ...(mode ? { mode } : {}), ...(delivery ? { delivery } : {}) }
       for (const fn of [...prompts]) fn(prompt)
       return true
     },

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

@@ -21,6 +21,7 @@ import { RunFooterView } from "../../src/mini/footer.view"
 import { RunEntryContent } from "../../src/mini/scrollback.writer"
 import { RUN_THEME_FALLBACK, type RunTheme } from "../../src/mini/theme"
 import type {
+  FooterQueuedPrompt,
   FooterState,
   FooterSubagentState,
   FooterSubagentTab,
@@ -120,13 +121,15 @@ async function renderFooter(
     height?: number
     state?: Partial<FooterState>
     onCycle?: () => void
-    onSubmit?: (prompt: RunPrompt) => boolean
+    onSubmit?: (prompt: RunPrompt) => boolean | Promise<boolean>
     view?: FooterView
     onFormReply?: (input: unknown) => void
     miniSettings?: MiniSettings
     mono?: boolean
     onStatus?: (status: string) => void
     onMiniSettingChange?: (change: MiniSettingChange) => void
+    queuedPrompts?: FooterQueuedPrompt[]
+    onQueuedPromptAction?: (action: "steer" | "cancel", inputID: string) => Promise<void>
   } = {},
 ) {
   const [view, setView] = createSignal<FooterView>(input.view ?? { type: "prompt" })
@@ -164,6 +167,7 @@ async function renderFooter(
           state={state}
           view={view}
           subagent={subagents}
+          queuedPrompts={() => input.queuedPrompts ?? []}
           theme={input.theme ?? (() => RUN_THEME_FALLBACK)}
           mono={input.mono ?? false}
           miniSettings={miniSettings}
@@ -173,6 +177,7 @@ async function renderFooter(
           onFormCancel={() => {}}
           onCycle={input.onCycle ?? (() => {})}
           onInterrupt={() => false}
+          onQueuedPromptAction={input.onQueuedPromptAction}
           onEditorOpen={async () => undefined}
           onInputClear={() => {}}
           onExit={() => {}}
@@ -913,7 +918,7 @@ test("direct subagent panel closes when moving up from the first item", async ()
   }
 })
 
-test("direct pending panel shows durable delivery without edit actions", async () => {
+test("direct queued panel steers and deletes selected prompts", async () => {
   const [prompts] = createSignal([
     {
       messageID: "m-1",
@@ -921,16 +926,22 @@ test("direct pending panel shows durable delivery without edit actions", async (
       delivery: "queue" as const,
     },
   ])
+  const steered: string[] = []
+  const deleted: string[] = []
 
   const app = await testRender(
     () => (
-      <box width={100} height={RUN_SUBAGENT_PANEL_ROWS}>
-        <RunQueuedPromptSelectBody
-          theme={() => RUN_THEME_FALLBACK.footer}
-          prompts={prompts}
-          onClose={() => {}}
-        />
-      </box>
+      <Keymap.Provider config={tuiConfig}>
+        <box width={100} height={RUN_SUBAGENT_PANEL_ROWS}>
+          <RunQueuedPromptSelectBody
+            theme={() => RUN_THEME_FALLBACK.footer}
+            prompts={prompts}
+            onClose={() => {}}
+            onSteer={(prompt) => steered.push(prompt.messageID)}
+            onDelete={(prompt) => deleted.push(prompt.messageID)}
+          />
+        </box>
+      </Keymap.Provider>
     ),
     { width: 100, height: RUN_SUBAGENT_PANEL_ROWS },
   )
@@ -940,19 +951,75 @@ test("direct pending panel shows durable delivery without edit actions", async (
     const frame = app.captureCharFrame()
     const list = panelMenu(app.renderer.root)
 
-    expect(frame).toContain("Pending work")
+    expect(frame).toContain("Queued prompts")
     expect(frame).toContain("fix the auth test")
-    expect(frame).toContain("queue")
+    expect(frame).toContain("queued")
+    expect(frame).toContain("enter steer · ctrl+d delete")
     expect(frame).not.toContain("┌")
     expect(frame).not.toContain("┃")
     expectPaletteList(list, 0)
-    expect(frame).not.toContain("edit")
-    expect(frame).not.toContain("remove")
+    app.mockInput.pressEnter()
+    app.mockInput.pressKey("d", { ctrl: true })
+    expect(steered).toEqual(["m-1"])
+    expect(deleted).toEqual(["m-1"])
   } finally {
     app.renderer.destroy()
   }
 })
 
+test("direct footer steers the oldest queued prompt from an empty composer", async () => {
+  const steered: string[] = []
+  const app = await renderFooter({
+    queuedPrompts: [
+      { messageID: "m-1", prompt: { text: "first", parts: [] }, delivery: "queue" },
+      { messageID: "m-2", prompt: { text: "second", parts: [] }, delivery: "queue" },
+    ],
+    onQueuedPromptAction: async (action, inputID) => {
+      if (action === "steer") steered.push(inputID)
+    },
+  })
+
+  try {
+    await app.renderOnce()
+    app.mockInput.pressEnter({ meta: true })
+    await Bun.sleep(0)
+    expect(steered).toEqual([])
+    app.mockInput.pressEnter()
+    await Bun.sleep(0)
+    expect(steered).toEqual(["m-1"])
+  } finally {
+    app.cleanup()
+  }
+})
+
+test("direct footer does not steer queued work on a double submit", async () => {
+  const submitted: RunPrompt[] = []
+  const steered: string[] = []
+  const app = await renderFooter({
+    queuedPrompts: [{ messageID: "m-1", prompt: { text: "queued", parts: [] }, delivery: "queue" }],
+    onSubmit: async (prompt) => {
+      submitted.push(prompt)
+      await Bun.sleep(10)
+      return true
+    },
+    onQueuedPromptAction: async (action, inputID) => {
+      if (action === "steer") steered.push(inputID)
+    },
+  })
+
+  try {
+    await app.renderOnce()
+    await app.mockInput.typeText("send once")
+    app.mockInput.pressEnter()
+    app.mockInput.pressEnter()
+    await Bun.sleep(20)
+    expect(submitted).toHaveLength(1)
+    expect(steered).toEqual([])
+  } finally {
+    app.cleanup()
+  }
+})
+
 // OpenTUI currently crashes Bun in the full `test/cli/run` directory run here.
 // Re-enable after the upstream OpenTUI fix lands in this repo.
 test.skip("direct footer recreates the frame across command panel transitions", async () => {
@@ -1068,11 +1135,11 @@ test("direct footer submits slash autocomplete selections without dispatching sh
     await app.renderOnce()
 
     expect(submits).toEqual([
-      { text: "/review ", parts: [], command: { name: "review", arguments: "" } },
-      { text: "/review ", parts: [], command: { name: "review", arguments: "" } },
-      { text: "/review branch", parts: [], command: { name: "review", arguments: "branch" } },
-      { text: "/new ", parts: [] },
-      { text: "/new ", parts: [] },
+      { text: "/review ", parts: [], command: { name: "review", arguments: "" }, delivery: "steer" },
+      { text: "/review ", parts: [], command: { name: "review", arguments: "" }, delivery: "steer" },
+      { text: "/review branch", parts: [], command: { name: "review", arguments: "branch" }, delivery: "steer" },
+      { text: "/new ", parts: [], delivery: "steer" },
+      { text: "/new ", parts: [], delivery: "steer" },
     ])
     expect(app.renderer.currentFocusedEditor?.plainText).toBe("/settings ")
   } finally {
@@ -1100,7 +1167,9 @@ test("direct footer slash autocomplete keeps a real skills command", async () =>
     app.mockInput.pressEnter()
     await app.renderOnce()
 
-    expect(submits).toEqual([{ text: "/skills ", parts: [], command: { name: "skills", arguments: "" } }])
+    expect(submits).toEqual([
+      { text: "/skills ", parts: [], command: { name: "skills", arguments: "" }, delivery: "steer" },
+    ])
     expect(app.captureCharFrame()).not.toContain("Apply formatter fixes")
   } finally {
     app.cleanup()
@@ -1158,7 +1227,12 @@ test("direct footer tags skill slash submissions with their catalog source", asy
     await app.renderOnce()
 
     expect(submits).toEqual([
-      { text: "/formatter src", parts: [], command: { name: "formatter", arguments: "src", source: "skill" } },
+      {
+        text: "/formatter src",
+        parts: [],
+        command: { name: "formatter", arguments: "src", source: "skill" },
+        delivery: "steer",
+      },
     ])
   } finally {
     app.cleanup()
@@ -1238,7 +1312,7 @@ test.skip("direct footer clears the synthetic skills draft when the panel closes
   }
 })
 
-test("direct footer shows authoritative pending work while running", async () => {
+test("direct footer shows authoritative queued work while running", async () => {
   const [state] = createSignal<FooterState>({
     phase: "running",
     status: "",
@@ -1342,9 +1416,9 @@ test("direct footer shows authoritative pending work while running", async () =>
     const hint = statusItems.at(-1)!
 
     expect(spinner).toBeDefined()
-    expect(frame).toContain("1 pending")
+    expect(frame).toContain("1 queued")
     expect(frame).toContain("ctrl+b background")
-    expect(frame).toContain("ctrl+x q 1 pending")
+    expect(frame).toContain("ctrl+x q 1 queued")
     expect(frame).toContain("↓ subagents")
     expect(frame).toContain("ctrl+p cmd")
     expect(frame).toContain("subagents · ctrl+p cmd")

packages/tui/test/mini/runtime.boot.test.ts

@@ -82,7 +82,8 @@ describe("run runtime boot", () => {
     expect(result.keybinds.get("prompt.history.next")?.[0]?.key).toBe("down")
     expect(result.keybinds.get("prompt.clear")?.[0]?.key).toBe("ctrl+c")
     expect(result.keybinds.get("input.submit")?.[0]?.key).toBe("return")
-    expect(result.keybinds.get("input.newline")?.[0]?.key).toBe("shift+return,ctrl+return,alt+return,ctrl+j")
+    expect(result.keybinds.get("input.newline")?.[0]?.key).toBe("shift+return,ctrl+return,ctrl+j")
+    expect(result.keybinds.get("prompt.queue")?.[0]?.key).toBe("alt+return")
   })
 
   test("preserves disabled leader from resolved tui config", async () => {

packages/tui/test/mini/runtime.queue.test.ts

@@ -265,6 +265,33 @@ describe("run runtime queue", () => {
     await task
   })
 
+  test("preserves explicit steer and queue delivery for in-flight prompts", async () => {
+    const ui = createFooterApiFixture()
+    const admitted: string[] = []
+    const gate = Promise.withResolvers<void>()
+
+    const task = runPromptQueue({
+      footer: ui.api,
+      run: async (_input, _signal, onAdmitted) => {
+        onAdmitted()
+        await gate.promise
+      },
+      admit: async (input, delivery) => {
+        admitted.push(`${input.text}:${delivery}`)
+      },
+      settle: async () => ui.api.close(),
+    })
+
+    ui.submit("one")
+    ui.submit("two", undefined, "steer")
+    ui.submit("three", undefined, "queue")
+    while (admitted.length < 2) await Bun.sleep(0)
+    expect(admitted).toEqual(["two:steer", "three:queue"])
+
+    gate.resolve()
+    await task
+  })
+
   test("continues durable admission after one fails", async () => {
     const ui = createFooterApiFixture()
     const admitted: string[] = []
@@ -308,7 +335,7 @@ describe("run runtime queue", () => {
         admitted()
         await new Promise<void>((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }))
       },
-      admit: async (_prompt, signal) => {
+      admit: async (_prompt, _delivery, signal) => {
         admissionStarted.resolve()
         await new Promise<void>((resolve) => {
           if (signal.aborted) {

packages/tui/test/mini/runtime.test.ts

@@ -126,7 +126,7 @@ describe("run interactive runtime", () => {
                 turnStarted.resolve()
                 api.close()
               },
-              queuePromptTurn: async () => {},
+              admitPromptTurn: async () => {},
               waitForIdle: async () => {},
               interruptActiveTurn: async () => {},
               selectSubagent: () => {},
@@ -209,7 +209,7 @@ describe("run interactive runtime", () => {
             streamStarted.resolve()
             return {
               runPromptTurn: async () => {},
-              queuePromptTurn: async () => {},
+              admitPromptTurn: async () => {},
               waitForIdle: async () => {},
               interruptActiveTurn: async () => {},
               selectSubagent: () => {},
@@ -556,7 +556,7 @@ describe("run interactive runtime", () => {
             setTimeout(() => input.footer.close(), 0)
             return {
               runPromptTurn: async () => {},
-              queuePromptTurn: async () => {},
+              admitPromptTurn: async () => {},
               waitForIdle: async () => {},
               interruptActiveTurn: async () => {},
               selectSubagent: () => {},

packages/tui/test/mini/stream-v2.transport.test.ts

@@ -669,6 +669,14 @@ describe("V2 mini transport", () => {
             data: { text: "follow up" },
             delivery: "queue",
           },
+          {
+            id: "msg_cancelled",
+            sessionID: "ses_1",
+            timeCreated: 2,
+            type: "user",
+            data: { text: "remove me" },
+            delivery: "queue",
+          },
         ],
       },
     })
@@ -684,11 +692,14 @@ describe("V2 mini transport", () => {
         .findLast((item) => item.type === "queued.prompts")
         ?.prompts.map((item) => [item.messageID, item.delivery])
 
-    expect(pending()).toEqual([["msg_queued", "queue"]])
+    expect(pending()).toEqual([
+      ["msg_queued", "queue"],
+      ["msg_cancelled", "queue"],
+    ])
     events.push({
-      id: "evt_promoted",
-      created: 2,
-      type: "session.input.promoted",
+      id: "evt_steered",
+      created: 3,
+      type: "session.input.steered",
       durable: durable("ses_1", 2),
       data: { sessionID: "ses_1", inputID: "msg_queued" },
     })
@@ -697,18 +708,48 @@ describe("V2 mini transport", () => {
     expect(ui.commits).toContainEqual(
       expect.objectContaining({ kind: "user", messageID: "msg_queued", text: "follow up" }),
     )
-    expect(pending()).toEqual([])
+    expect(pending()).toEqual([["msg_cancelled", "queue"]])
+    events.push({
+      id: "evt_queued",
+      created: 4,
+      type: "session.input.queued",
+      durable: durable("ses_1", 3),
+      data: { sessionID: "ses_1", inputID: "msg_queued" },
+    })
+    while (pending()?.length !== 2) await Bun.sleep(0)
+    expect(pending()).toEqual([
+      ["msg_queued", "queue"],
+      ["msg_cancelled", "queue"],
+    ])
+    events.push({
+      id: "evt_cancelled",
+      created: 5,
+      type: "session.input.cancelled",
+      durable: durable("ses_1", 4),
+      data: { sessionID: "ses_1", inputID: "msg_cancelled" },
+    })
+    while (pending()?.length !== 1) await Bun.sleep(0)
+    expect(pending()).toEqual([["msg_queued", "queue"]])
+    events.push({
+      id: "evt_promoted",
+      created: 6,
+      type: "session.input.promoted",
+      durable: durable("ses_1", 5),
+      data: { sessionID: "ses_1", inputID: "msg_queued" },
+    })
+    while (pending()?.length !== 0) await Bun.sleep(0)
+    expect(ui.commits.filter((item) => item.messageID === "msg_queued")).toHaveLength(1)
     const prompt = spyOn(client.session, "prompt").mockImplementation(
       (request) => ok(promptAdmission(request)) as never,
     )
-    await transport.queuePromptTurn({
+    await transport.admitPromptTurn({
       agent: "review",
       model: undefined,
       variant: undefined,
       prompt: { messageID: "msg_next", text: "another", parts: [] },
       files: [],
       includeFiles: false,
-    })
+    }, "queue")
     expect(client.session.switchAgent).toHaveBeenCalledWith({ sessionID: "ses_1", agent: "review" }, expect.anything())
     expect(prompt).toHaveBeenCalledWith(expect.objectContaining({ delivery: "queue" }), expect.anything())
     events.push({
@@ -722,15 +763,8 @@ describe("V2 mini transport", () => {
         input: { type: "user", data: { text: "earlier" }, delivery: "steer" },
       },
     })
-    while (true) {
-      const pending = ui.events.findLast((item) => item.type === "queued.prompts")
-      if (pending?.type === "queued.prompts" && pending.prompts.length >= 2) break
-      await Bun.sleep(0)
-    }
-    expect(pending()).toEqual([
-      ["msg_next", "queue"],
-      ["msg_earlier", "steer"],
-    ])
+    await Bun.sleep(10)
+    expect(pending()).toEqual([["msg_next", "queue"]])
     await transport.close()
   })
 
@@ -813,14 +847,14 @@ describe("V2 mini transport", () => {
       durable: durable("ses_1", 2),
       data: { sessionID: "ses_1", inputID: "msg_prompt" },
     })
-    await transport.queuePromptTurn({
+    await transport.admitPromptTurn({
       agent: undefined,
       model: undefined,
       variant: undefined,
       prompt: { messageID: "msg_queued", text: "follow up", parts: [] },
       files: [],
       includeFiles: false,
-    })
+    }, "queue")
     events.push({
       id: "evt_queued_promoted",
       created: 3,

packages/www/content/docs/(Configure)/compaction.mdx

@@ -81,6 +81,7 @@ Add `compaction` to any [OpenCode configuration file](/config):
   "$schema": "https://opencode.ai/config.json",
   "compaction": {
     "auto": true,
+    "prune": false,
     "keep": {
       "tokens": 15000
     },
@@ -92,6 +93,7 @@ Add `compaction` to any [OpenCode configuration file](/config):
 | Field | Default | V2 behavior |
 | --- | ---: | --- |
 | `auto` | `true` | Runs the preflight context-size check. It does not disable manual compaction or one-shot provider-overflow recovery. |
+| `prune` | None | Accepted by the V2 schema, but currently has no runtime effect. V2 does not prune old tool outputs in place. |
 | `keep.tokens` | `15000` | Approximate number of tokens from the newest serialized conversation context to retain beside the summary. |
 | `buffer` | `20000` | Safety reserve below an explicit input limit. Without one, it is the minimum context reserve and the model output allowance wins when larger. |
 
@@ -133,6 +135,8 @@ behavior.
 
 ## Current limitations
 
+- `prune` is reserved configuration; V1-style in-place tool-output pruning is
+  not implemented in V2.
 - Compaction requires a resolvable model with a positive catalog context limit.
   There is no separate compaction-model setting or fallback model.
 - Summary generation can fail if the summary prompt itself cannot fit beside

packages/www/content/docs/migrate-v1.mdx

@@ -16,17 +16,15 @@ V2 has three intentional breaking changes:
 - The [server API and clients](#server-api-and-clients) have new contracts.
 - [TUI configuration](#tui-configuration) moves from layered `tui.json(c)` files to one global `cli.json` file (auto migrated).
 
-Supported V1 functionality outside those areas is intended to remain compatible with V1. Some fields accepted by the V1
-schema never had a V2 equivalent and are intentionally ignored; these are listed under
-[Accepted but unsupported fields](#accepted-but-unsupported-fields).
+All other functionality is intended to remain compatible with V1.
 
-Existing supported server config fields, agent definitions, command definitions, skills, and other files in `.opencode/`
-should continue to work without changes. If supported behavior described in this guide stops working in V2, treat it as a
-beta compatibility bug rather than an expected migration requirement.
+Existing server config files, agent definitions, command definitions, skills, and other files in `.opencode/` should
+continue to work without changes. If one of these stops working in V2, treat it as a beta compatibility bug rather than
+an expected migration requirement.
 
 <Callout type="tip">
-  Run `/report` if supported V1 functionality does not work in V2. The report skill collects diagnostics and helps you
-  file a compatibility issue.
+  Run `/report` if existing V1 functionality does not work in V2. The report skill collects diagnostics and helps you file
+  a compatibility issue.
 </Callout>
 
 <Callout type="warning">
@@ -62,9 +60,8 @@ V2 reads existing global and project configuration from the same locations as V1
 <project>/.opencode/opencode.json(c)
 ```
 
-V2 reads these same locations. It normalizes supported V1 and native V2 fields in memory without rewriting the source
-file. Existing supported V1 configuration is intended to keep working, so you do not need to convert it to try or adopt
-V2.
+V2 reads these same locations. It detects V1-shaped configuration and translates it in memory without rewriting the
+source file. Existing V1 configuration is intended to keep working, so you do not need to convert it to try or adopt V2.
 
 ### Ask OpenCode to migrate
 
@@ -79,13 +76,7 @@ Preserve its behavior and all unrelated settings.
 ```
 
 OpenCode can inspect the complete file, apply the relevant changes below, and avoid rewriting settings that do not need to
-change. Conversion does not need to happen all at once: supported V1 and native V2 fields may coexist at the top level.
-When both forms set the same canonical value, a valid native V2 value takes precedence regardless of JSON key order.
-
-Nested mixing is intentionally bounded. OpenCode recognizes mixed V1 and V2 members within `mcp`, `compaction`, and
-`experimental`, but it does not recursively infer formats inside individual agents, providers, commands, or models. Keep
-each of those nested entries entirely in one format. Supported V1 syntax remains quiet by itself; malformed values,
-unsupported legacy fields, and conflicting V1/V2 values produce warnings while unrelated valid settings continue to load.
+change. Do not mix V1 and V2 field names manually in one file.
 
 ### Sharing
 
@@ -259,8 +250,8 @@ V2 groups the retained-context token budget under `keep` and gives the reserve a
 }
 ```
 
-`auto` keeps its name. V2 has no native `tail_turns` or `prune` field; both legacy fields are ignored with a warning. Recent
-context is retained by token budget instead. See [Compaction](/compaction).
+`auto` and `prune` keep their names. V2 has no native `tail_turns` field; recent context is retained by token budget instead.
+See [Compaction](/compaction).
 
 ### Skills
 
@@ -363,17 +354,6 @@ Rename the singular `provider` map to `providers`. V2 separates the runtime pack
 V1 `npm` becomes `package`, and AI SDK packages receive the `aisdk:` prefix. `api` becomes `settings.baseURL`. Provider
 `options` are separated into `settings`, `headers`, and `body` according to their request role. See [Providers](/providers).
 
-V2 consolidated two legacy provider namespaces:
-
-| V1 provider ID | Canonical V2 provider ID |
-| --- | --- |
-| `azure-cognitive-services` | `azure` |
-| `google-vertex-anthropic` | `google-vertex` |
-
-Migration of unambiguous V1 provider, agent, command, and provider-filter fields uses these canonical IDs. The shared
-top-level `model` field keeps its exact provider ID because the same syntax is valid in native V2 config; update that field
-to the canonical ID when migrating a legacy built-in provider.
-
 ### Models and variants
 
 Models remain nested under their provider, but several model fields become more explicit:
@@ -410,39 +390,22 @@ Models remain nested under their provider, but several model fields become more
 
 See [Models](/models) for the complete native model shape.
 
-### Supported fields without direct native equivalents
+### Fields without native equivalents
 
 Most fields that keep the same shape, including `shell`, `model`, `default_agent`, `autoupdate`, `watcher`, `formatter`,
 `lsp`, `instructions`, `enterprise`, and `tool_output`, require no migration.
 
-The V1 provider filters do not have one-to-one native V2 config fields, but their behavior remains supported:
-
-- `enabled_providers` becomes an internal deny-by-default provider policy followed by allows for the listed providers.
-- `disabled_providers` becomes internal deny policies for the listed providers.
-
-You may keep these fields in V1 syntax. OpenCode normalizes them without warning.
-
-### Accepted but unsupported fields
-
-The V1 schema also accepted fields that have no supported V2 behavior. V2 ignores these values and emits a warning so
-they are not mistaken for active configuration:
+These V1 fields do not have one-to-one native V2 config fields:
 
 - `logLevel`: use `OPENCODE_LOG_LEVEL` when starting OpenCode.
 - `server`: use the V2 service and explicit server options; the server API is an intentional breaking change.
 - `layout`: remove it; V1 already treated it as deprecated and always used stretch layout.
+- `enabled_providers` and `disabled_providers`: there is no native provider allowlist or denylist field yet.
 - `small_model`: V2 selects models for internal maintenance agents without a separate top-level field.
-- Top-level `subagent_depth`: use `experimental.subagent_depth` instead.
-- `compaction.tail_turns` and `compaction.prune`: V2 uses `compaction.keep.tokens` and checkpoint-based compaction instead.
-- Agent `name` inside V1 JSON configuration.
-- An enabled-only V1 MCP entry without a `type`.
-- V1 experimental fields `disable_paste_summary`, `batch_tool`, `openTelemetry`, `primary_tools`, and
-  `continue_loop_on_deny`.
-- V1 provider fields `id`, `whitelist`, and `blacklist`.
-- V1 provider-model fields `release_date`, `attachment`, `reasoning`, `temperature`, `experimental`, a non-`deprecated`
-  `status`, and boolean `interleaved`.
+- `compaction.tail_turns`: V2 uses `compaction.keep.tokens` instead.
 
-Ignoring these fields is intentional and is not a compatibility regression. If V2 does not preserve behavior identified
-as supported elsewhere in this guide, run `/report`.
+If your V1 configuration relies on a field without a native equivalent, keep using the supported V1 format rather than
+forcing a manual conversion. Run `/report` if V2 does not preserve the behavior you rely on.
 
 ### Agent files
 

plans/config-normalization.md

@@ -1,163 +0,0 @@
-# Mixed V1/V2 Config Normalization Plan
-
-Status: **Implemented and verified**
-
-## Goal
-
-Replace whole-document V1/V2 detection with one config-domain compatibility pipeline. Supported V1 fields, native V2 fields, and practical mixtures of both should load without an unrelated legacy key changing how the rest of the document is decoded.
-
-## Decision
-
-Normalize recognized fields independently into the encoded side of the V2 `Config.Info` schema, then perform one final complete-document V2 decode:
-
-```text
-JSON/JSONC encoded input
-    -> parse and retain source-property presence
-    -> validate each recognized field or collection entry
-    -> migrate supported V1 candidates to V2 encoded values
-    -> decode and re-encode native V2 candidates
-    -> merge with native V2 precedence
-    -> decode Config.Info once
-    -> log redacted diagnostics
-```
-
-There is no whole-document version classification and no independent whole-document V1 and V2 decode.
-
-The encoded boundary matters because schemas such as warming durations transform strings into runtime values. Decoded values must not be fed back into the encoded side of `Config.Info`.
-
-## Behavior
-
-| Situation | Result |
-| --- | --- |
-| Supported V1-only field | Migrate it to its canonical V2 destination. |
-| Native V2 field | Preserve it after schema decode and encode. |
-| Disjoint V1 and V2 map entries | Preserve both. |
-| Same canonical scalar, map entry, or nested leaf | Valid native V2 wins regardless of JSON key order. |
-| Malformed native value with valid legacy fallback | Skip native value, log it, and retain legacy value. |
-| Malformed collection entry | Skip only the explicitly supported recovery unit. |
-| Unsupported accepted V1 setting | Omit it and log a redacted warning. |
-| Unknown field | Continue ignoring it for forward compatibility. |
-
-Valid supported V1 syntax does not warn merely because it is legacy.
-
-## Field Precedence
-
-| Destination | Lowest to highest precedence |
-| --- | --- |
-| `snapshots` | `snapshot` < `snapshots` |
-| `share` | `autoshare` < `share` |
-| `references[name]` | `reference[name]` < `references[name]` |
-| `agents[name]` | `agent[name]` < `mode[name]` < `agents[name]` |
-| `commands[name]` | `command[name]` < `commands[name]` |
-| `providers[name]` | `provider[name]` < `providers[name]` |
-| `permissions` | `tools` rules < `permission` rules < native `permissions` |
-| `plugins` | migrated `plugin` items < native `plugins` items |
-| `media` | `attachment` < `media` |
-| `experimental.policies` | enabled-provider policies < disabled-provider policies < native policies |
-| `mcp.servers[name]` | direct legacy server < native `servers[name]` |
-| `mcp.timeout.*` | `experimental.mcp_timeout` < native timeout leaf |
-| `compaction.keep.tokens` | `preserve_recent_tokens` < `keep.tokens` |
-| `compaction.buffer` | `reserved` < `buffer` |
-
-Ordered rules and plugin directives retain both forms, with migrated V1 entries first and native V2 entries last.
-
-## Shared Shapes
-
-### Skills
-
-- A V2 array retains each valid string item.
-- A V1 object combines valid `paths` followed by valid `urls`.
-- Empty and unknown-only V1 objects normalize to an empty array under permissive excess-property handling.
-
-### MCP
-
-- Direct entries under `mcp` are V1 servers.
-- Entries under `mcp.servers` are native V2 servers.
-- Both sets are merged by server name, with a complete native server replacing a duplicate legacy server.
-- A malformed native duplicate is skipped so a valid legacy server remains.
-- Native global timeout leaves override only matching values migrated from `experimental.mcp_timeout`.
-- Raw `type` and `enabled` discriminators preserve legacy servers that happen to be named `servers` or `timeout`.
-
-### Compaction
-
-- `preserve_recent_tokens` becomes `keep.tokens`.
-- `reserved` becomes `buffer`.
-- Native leaves win conflicts.
-- `tail_turns` and `prune` remain unsupported and produce warnings.
-
-### Experimental
-
-- `subagent_depth` is shared.
-- Legacy provider lists generate ordered canonical policies.
-- Native policies follow generated policies.
-- An explicit empty `enabled_providers` keeps deny-all behavior.
-- A non-empty list with no valid items contributes no policy, avoiding accidental deny-all from malformed input.
-
-## Recovery Units
-
-Named commands, agents, providers, MCP servers, formatters, language servers, and references recover independently. Plugin, permission, skill, instruction, provider-ID, and policy arrays recover by item. Top-level legacy permissions recover by action/resource rule. Complex interiors of one agent, provider, command, or MCP server remain atomic rather than being recursively salvaged.
-
-Every decoder preserves `propertyOrder: "original"` because V1 permission precedence depends on user order. Excess properties remain ignored except for the explicit unsupported inventory.
-
-## Provider IDs
-
-Provider ID compatibility remains a config migration concern only. Existing V1 agent, command, provider, and provider-policy adapters continue using the migration helper's retired-ID mapping.
-
-The shared top-level `model` field remains exact because its string and object forms are valid native V2 syntax and provider declarations may come from a different config layer. It is never reinterpreted based on unrelated legacy fields.
-
-This change does not add runtime provider aliases or modify provider policy evaluation, catalog state, model resolution, Sessions, plugins, Server behavior, or generation.
-
-## Diagnostics
-
-Diagnostics contain only source, JSON path, category, and action. They never include raw values because config may contain credentials after substitution.
-
-Malformed JSON, empty content, and valid non-object roots reject one document with a source-aware warning. Malformed recognized fields and entries are skipped at their recovery boundary while unrelated valid configuration continues loading.
-
-## Implementation
-
-- Add a pure `ConfigNormalize.normalize` module under `packages/core/src/config/`.
-- Reuse field migration primitives from `packages/core/src/v1/config/migrate.ts`.
-- Replace `ConfigMigrateV1.isV1` in `packages/core/src/config.ts` with normalization and one final V2 decode.
-- Log diagnostics uniformly for files, `OPENCODE_CONFIG_CONTENT`, and well-known virtual config.
-- Add property and table-driven config normalization tests.
-- Update migration and compaction documentation.
-
-## Verification
-
-The implementation must establish:
-
-1. Valid native V2 config preserves decoded meaning after encoded normalization.
-2. Supported V1 fields preserve existing behavior.
-3. Adding a legacy field cannot change unrelated native field interpretation.
-4. Native V2 wins canonical conflicts independent of key order.
-5. One malformed entry does not remove valid siblings.
-6. Mixed MCP, compaction, and experimental values normalize deterministically.
-7. Diagnostics are precise and value-redacted.
-8. False, zero, empty, and absent values retain distinct presence semantics.
-
-Run from `packages/core`:
-
-```sh
-bun test test/config
-bun typecheck
-```
-
-Run from `packages/www` after documentation changes:
-
-```sh
-bun typecheck
-bun validate
-bun run build
-```
-
-## Non-Goals
-
-- Runtime provider alias resolution.
-- Provider policy or catalog changes.
-- Model resolver or Session changes.
-- Plugin API changes.
-- Server or Protocol changes.
-- Generation lifecycle changes.
-- Recursive V1/V2 inference inside one agent, provider, command, or model.
-- Restoring removed V1 functionality.
-- Rewriting user files on disk.