refactor(tui): compact settings values

.changeset/calm-services-start.md

@@ -1,5 +0,0 @@
----
-"@opencode-ai/client": patch
----
-
-Reuse a same-version background service when a repeated health probe succeeds instead of replacing an endpoint another client may already be using.

packages/app/src/i18n/en.ts

@@ -65,8 +65,8 @@ export const dict = {
   "command.message.next.description": "Go to the next user message",
   "command.model.choose": "Choose model",
   "command.model.choose.description": "Select a different model",
-  "command.mcp.toggle": "Manage MCP servers",
-  "command.mcp.toggle.description": "Enable or disable MCP servers",
+  "command.mcp.toggle": "Toggle MCPs",
+  "command.mcp.toggle.description": "Toggle MCPs",
   "command.agent.cycle": "Cycle agent",
   "command.agent.cycle.description": "Switch to the next agent",
   "command.agent.cycle.reverse": "Cycle agent backwards",
@@ -307,9 +307,9 @@ export const dict = {
   "prompt.toast.promptSendFailed.title": "Failed to send prompt",
   "prompt.toast.promptSendFailed.description": "Unable to retrieve session",
 
-  "dialog.mcp.title": "MCP servers",
+  "dialog.mcp.title": "MCPs",
   "dialog.mcp.description": "{{enabled}} of {{total}} enabled",
-  "dialog.mcp.empty": "No MCP servers configured",
+  "dialog.mcp.empty": "No MCPs configured",
 
   "dialog.lsp.empty": "LSPs auto-detected from file types",
   "dialog.plugins.empty": "Plugins configured in opencode.json",

packages/client/src/effect/service.ts

@@ -59,11 +59,11 @@ const discoverLocal = Effect.fnUntraced(function* (options: Options) {
 export const start = Effect.fn("service.start")(function* (options: StartOptions = {}) {
   const compatible = yield* discover(options)
   if (compatible !== undefined) return compatible
-  const existing = yield* find(options)
-  if (existing?.version !== undefined && (options.version === undefined || existing.version === options.version))
-    return existing.endpoint
-  yield* Effect.sync(() => options.onStart?.(existing === undefined ? "missing" : "version-mismatch", existing?.info))
-  if (existing !== undefined) yield* kill(existing.info, options).pipe(Effect.ignore)
+  const mismatched = yield* find(options)
+  yield* Effect.sync(() =>
+    options.onStart?.(mismatched === undefined ? "missing" : "version-mismatch", mismatched?.info),
+  )
+  if (mismatched !== undefined) yield* kill(mismatched.info, options).pipe(Effect.ignore)
 
   const [command, ...args] = options.command ?? ["opencode", "serve", "--service"]
   if (command === undefined) return yield* Effect.fail(new Error("Missing service command"))
@@ -138,7 +138,6 @@ const read = Effect.fnUntraced(function* (file?: string) {
 type LocalService = {
   readonly info: Info
   readonly endpoint: Endpoint
-  readonly version?: string
 }
 
 const probe = Effect.fnUntraced(function* (info: Info, version?: string, allowLegacy = false) {
@@ -162,7 +161,7 @@ const probe = Effect.fnUntraced(function* (info: Info, version?: string, allowLe
     if (health.value.pid !== info.pid) return undefined
     if (info.version !== undefined && health.value.version !== info.version) return undefined
     if (version !== undefined && health.value.version !== version) return undefined
-    return { info, endpoint, version: health.value.version } satisfies LocalService
+    return { info, endpoint } satisfies LocalService
   }
   if (
     !allowLegacy ||

packages/client/test/fixture/service.ts

@@ -1,39 +0,0 @@
-import { rename, writeFile } from "node:fs/promises"
-
-const [registration, mode] = process.argv.slice(2)
-if (registration === undefined || mode === undefined) throw new Error("Missing service fixture arguments")
-
-let requests = 0
-const server = Bun.serve({
-  port: 0,
-  async fetch(request) {
-    if (new URL(request.url).pathname !== "/api/health") return new Response(null, { status: 404 })
-    requests += 1
-    if (mode === "modern" && requests === 1) {
-      await writeFile(registration + ".first-request", "")
-      while (!(await Bun.file(registration + ".release").exists())) await Bun.sleep(5)
-      return new Response(null, { status: 503 })
-    }
-    if (mode === "legacy") return Response.json({ healthy: true })
-    return Response.json({ healthy: true, version: "test", pid: process.pid })
-  },
-})
-
-await writeFile(
-  registration + ".tmp",
-  JSON.stringify({
-    id: crypto.randomUUID(),
-    version: mode === "legacy" ? undefined : "test",
-    url: server.url.toString(),
-    pid: process.pid,
-  }),
-  { mode: 0o600 },
-)
-await rename(registration + ".tmp", registration)
-
-const shutdown = () => {
-  server.stop(true)
-  process.exit()
-}
-process.on("SIGTERM", shutdown)
-process.on("SIGINT", shutdown)

packages/client/test/service.test.ts

@@ -1,91 +0,0 @@
-import { NodeFileSystem } from "@effect/platform-node"
-import { afterEach, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { mkdtemp, rm, writeFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { Service } from "../src/effect/index"
-
-const fixture = join(import.meta.dir, "fixture/service.ts")
-const processes: Bun.Subprocess[] = []
-const directories: string[] = []
-
-afterEach(async () => {
-  processes.forEach((process) => process.kill("SIGTERM"))
-  await Promise.all(processes.splice(0).map((process) => process.exited))
-  await Promise.all(directories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })))
-})
-
-test("a concurrent same-version start cannot invalidate a resolved endpoint", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  spawn(registration, "modern")
-  await waitForFile(registration)
-  const original = await Bun.file(registration).json()
-
-  const starts: Service.StartReason[] = []
-  const first = run(
-    Service.start({
-      file: registration,
-      version: "test",
-      command: [],
-      onStart: (reason) => starts.push(reason),
-    }),
-  )
-  await waitForFile(registration + ".first-request")
-
-  const resolved = await run(Service.start({ file: registration, version: "test" }))
-  expect(resolved.url).toBe(original.url)
-
-  await writeFile(registration + ".release", "")
-  await first
-
-  expect(starts).toEqual([])
-  expect(await Bun.file(registration).json()).toEqual(original)
-  expect(await health(resolved.url)).toEqual({ healthy: true, version: "test", pid: original.pid })
-})
-
-test("a legacy health response is still replaced", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  const existing = spawn(registration, "legacy")
-  await waitForFile(registration)
-
-  const starts: Service.StartReason[] = []
-  const result = run(Service.start({ file: registration, command: [], onStart: (reason) => starts.push(reason) }))
-
-  await expect(result).rejects.toThrow("Missing service command")
-  expect(starts).toEqual(["version-mismatch"])
-  await existing.exited
-})
-
-function run<A, E>(effect: Effect.Effect<A, E, never>) {
-  return Effect.runPromise(effect.pipe(Effect.provide(NodeFileSystem.layer)))
-}
-
-function spawn(registration: string, mode: string, ...args: string[]) {
-  const subprocess = Bun.spawn([process.execPath, fixture, registration, mode, ...args], {
-    stdout: "ignore",
-    stderr: "inherit",
-  })
-  processes.push(subprocess)
-  return subprocess
-}
-
-async function temp() {
-  const directory = await mkdtemp(join(tmpdir(), "opencode-client-service-"))
-  directories.push(directory)
-  return directory
-}
-
-async function waitForFile(file: string) {
-  for (let attempt = 0; attempt < 600; attempt++) {
-    if (await Bun.file(file).exists()) return
-    await Bun.sleep(5)
-  }
-  throw new Error(`Timed out waiting for ${file}`)
-}
-
-async function health(url: string) {
-  return fetch(new URL("/api/health", url), { signal: AbortSignal.timeout(1_000) }).then((response) => response.json())
-}

packages/codemode/AGENTS.md

@@ -4,7 +4,7 @@
 - Do not add a speculative generic permission or approval policy. A host omits tools it does not expose and enforces domain authorization inside each provided tool.
 - Keep Code Mode unaware of host session, channel, and conversation models. The hosting application supplies trusted execution scope around it.
 - Tool schemas are the model-facing Interface. Keep arguments minimal and natural to the operation; never add unrelated IDs as ambient capability tokens.
-- When interpreter behavior or support changes, update `interpreter-support.md` and direct tests in the same PR.
+- When interpreter behavior or support changes, update `interpreter-support.md` and direct tests in the same PR. Update `codemode.md` when the package design, integration status, or rationale changes.
 
 ## OpenAPI
 

packages/codemode/codemode.md

@@ -0,0 +1,164 @@
+# CodeMode Design and Status
+
+This is the living design and status document for `@opencode-ai/codemode` and its existing V2 OpenCode adapter.
+It records current behavior, intentional boundaries, durable rationale, and material remaining work.
+
+Completed implementation history, branch names, test counts, and closed findings belong in git, not here. Remove
+completed work instead of preserving checked-off chronology.
+
+Detailed package API documentation lives in [README.md](./README.md), and the checkable language/runtime matrix lives
+in [interpreter-support.md](./interpreter-support.md). OpenAPI-specific follow-ups live in
+[src/openapi/TODO.md](./src/openapi/TODO.md).
+
+## How CodeMode Works
+
+### Purpose
+
+CodeMode gives a model one `execute` tool backed by a confined JavaScript interpreter. Inside the program, the model
+can call an explicit tree of schema-described tools, sequence dependent work, run independent calls concurrently,
+and filter or aggregate results before returning them to the agent loop.
+
+The goals are:
+
+- Reduce model context consumed by large tool catalogs.
+- Avoid an agent round-trip between every dependent tool call.
+- Keep large intermediate results inside the program instead of sending them through model context.
+- Give generated code only the authority explicitly supplied by the host.
+
+CodeMode is an orchestration language, not a general JavaScript runtime or an application authorization system.
+
+### Runtime
+
+The generic runtime lives in `packages/codemode` and is host-neutral:
+
+1. The host builds a tree of `Tool.make(...)` definitions and calls `CodeMode.make(...)` or `CodeMode.execute(...)`.
+2. CodeMode generates model instructions, a budgeted inline catalog, and the global `search(...)` built-in.
+3. TypeScript syntax is transpiled away, Acorn parses the resulting JavaScript, and an owned tree-walking interpreter
+   executes it without `eval`.
+4. Tool inputs and outputs cross schema and plain-data boundaries before they become visible on either side.
+5. Execution returns `CodeMode.Result`. Expected program and tool failures are diagnostic data; host interruption
+   remains Effect interruption.
+
+Effect Schemas validate and transform tool inputs and outputs. JSON Schemas render model-facing signatures but do not
+validate values; adapter-provided values still cross the plain-data boundary. A tool without an output schema is
+advertised as `Promise<unknown>`.
+
+### Discovery and model workflow
+
+The model sees a token-budgeted catalog. Every namespace remains visible, and complete signatures are selected
+round-robin across namespaces so one large namespace cannot starve the others. The global `search(...)` built-in is
+always callable - synchronously, counted as an admitted tool call - and is advertised when the inline catalog is
+partial.
+
+The intended workflow is:
+
+1. Pick an exact signature from the inline catalog, or return `search(...)` results and use a selected path in the
+   next execution.
+2. Call the exact returned path without guessing or normalizing segments.
+3. Narrow `Promise<unknown>` results before reading fields.
+4. Start independent calls together and await them with `Promise.all`.
+5. Filter and aggregate inside the program, then return only the data needed by the model.
+
+Search returns directly usable JavaScript paths, descriptions, and complete TypeScript signatures. It supports exact
+path lookup, namespace browsing, deterministic ranking, and pagination.
+
+### Tool execution
+
+Every sandbox promise starts eagerly on a run-once fiber owned by the whole CodeMode execution, including tool calls,
+async functions, chained `.then`/`.catch`/`.finally` reactions, `new Promise(executor)` constructions, and the
+`Promise.all`/`allSettled`/`race`/`any`/`resolve`/`reject` statics. Nested functions therefore cannot end the lifetime
+of work they started.
+Independent aggregate batches overlap, and rejection is observed at the eventual `await` or chained rejection handler.
+`Promise.race` and `Promise.any` use native non-cancelling settlement semantics: the deciding member wins while losers
+continue running, and an all-rejected `Promise.any` rejects with an `AggregateError`. `new Promise(...)` hands the
+executor first-class resolve/reject callables that may escape and settle the promise later, exactly once.
+Reaction ordering matches what V8 makes observable - handlers and await continuations are deferred and run in attach
+order, and a combinator settles one reaction turn after its deciding member - without promising exact microtask-count
+parity beyond that. At normal completion CodeMode interrupts everything still running - race losers,
+fail-fast `Promise.all` stragglers, and fire-and-forget calls alike: the program has returned, so no future await can
+exist, and work whose completion matters must be awaited by the program. Waiting for any class of leftover instead
+would let it hold the execution open indefinitely.
+Rejections that settled un-awaited before the return become `Success.warnings` diagnostics. A fatal program failure or
+host interruption closes the execution promise scope and interrupts its active fibers instead. A timeout does the
+same, except that a value the program already returned is preserved alongside a `TimeoutExceeded` warning rather than
+discarded. CodeMode does not limit tool-call concurrency.
+
+The public execution-policy knobs are `timeoutMs`, `maxToolCalls`, and `maxOutputBytes`. The package supplies no
+defaults because budgets are host policy. The interpreter also enforces a fixed internal data nesting depth.
+`maxOutputBytes` bounds retained payload bytes, not the complete rendered message;
+warning diagnostics have an equal separate budget so a large value cannot starve them, and fixed truncation notices and
+host-added framing are intentionally outside the budgets.
+
+### Data, files, and failures
+
+Program results and tool arguments are JSON-like data. Dates become ISO strings at host boundaries; RegExp, Map, and
+Set values become `{}` as they do under JSON serialization. Promise and runtime reference values cannot cross the
+boundary.
+
+Unknown host failures and invalid outputs are sanitized. `ToolError` is the explicit channel for a safe message that a
+tool wants the model to see. Diagnostic categories distinguish parsing, unsupported syntax, unknown tools, invalid
+data, tool failures, limits, timeouts, execution failures, and warning truncation.
+
+Files and other attachment content stay outside the interpreter. A host may collect them while child tools execute and
+attach them to the outer result, but the program receives only the structured tool output.
+
+### V2 OpenCode adapter
+
+CodeMode is integrated into V2 through `packages/core/src/tool/registry.ts` and
+`packages/core/src/tool/execute.ts`:
+
+- Core has one canonical `Tool` representation. Location-scoped producers register direct or deferred tools through
+  `Tools.Service`.
+- Each model step snapshots effective registrations, applies catalog visibility filtering, and exposes direct tools
+  normally.
+- When visible deferred tools exist, Core reserves and materializes one `execute` tool. Grouped deferred tools become
+  CodeMode namespaces instead of flattened model-facing names.
+- Nested calls execute the registered `Tool` values captured for the model request; later registrations affect later
+  requests.
+- Authorization and side-effect ordering remain responsibilities of the leaf tool. Catalog visibility is not execution
+  authorization.
+- Structured child output enters the interpreter. File parts are collected host-side and attached to the outer result.
+- Nested call statuses are returned as final `execute` metadata for the TUI.
+- `execute` is the one model-facing tool invocation. Nested calls reuse its invocation context and do not independently
+  run registry hooks or model-output bounding; this keeps complete intermediate structured values available for
+  in-program filtering. The outer `execute` settlement is the single model-output bounding boundary.
+- Core supplies no CodeMode timeout or tool-call limit. User cancellation interrupts the outer invocation and its
+  supervised children; the outer settlement applies Core's normal output-retention policy.
+
+MCP tools use this canonical path: they register as grouped tools and are deferred while CodeMode is enabled. Existing
+output schemas are preserved in generated signatures. Direct Core tools remain direct and are not ambient globals
+inside CodeMode.
+
+## Intentionally Unsupported
+
+These are product boundaries rather than DSL backlog:
+
+- Ambient filesystem, process, environment, network, credential, or application access. External work must go through
+  supplied tools.
+- Modules, imports, dynamic imports, `eval`, arbitrary host globals, npm packages, and prototype mutation.
+- Generic permission prompts, authorization policy, durable pause/resume, replay, storage, or exactly-once external
+  side effects. Hosts and tools own those concerns.
+- Heuristic parsing of text tool results as JSON. A result should not silently change type based on its contents.
+
+The OpenAPI adapter may gain more transports and encodings, but it must continue skipping operations it cannot
+represent accurately rather than guessing semantics.
+
+## Decisions and Rationale
+
+| Decision                                                     | Rationale                                                                                                                                                                                                                |
+| ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Keep an owned tree-walking interpreter.                      | The product need is bounded tool orchestration, not arbitrary JavaScript. Owning the language surface keeps authority and behavior explicit.                                                                             |
+| Treat schemas as the model-facing interface.                 | Signatures drive correct calls; Effect Schema also provides the runtime validation boundary, while JSON Schema supports adapter interoperability.                                                                        |
+| Keep authority host-owned.                                   | CodeMode can only confine programs to supplied tools. The host chooses those tools, and each tool enforces its own authorization and side-effect policy.                                                                 |
+| Use progressive catalog disclosure plus search.              | Large tool sets should not consume the prompt, but every namespace must remain discoverable and speculative search calls should remain valid.                                                                            |
+| Start promises eagerly and supervise them for the execution. | This preserves normal call-time parallelism and run-once settlement while allowing pending work to be interrupted when the program returns.                                                                              |
+| Keep files outside the sandbox value space.                  | Models should compose structured data without routing binary payloads through generated code or context.                                                                                                                 |
+| Treat `execute` as the model-facing invocation boundary.     | Nested calls are implementation details of one orchestration program. Reusing the outer context and bounding only the final result preserves complete intermediate data without inventing durable child-call identities. |
+| Return expected failures as data.                            | Models need actionable diagnostics without exposing private host causes; host interruption and defects must still propagate correctly.                                                                                   |
+| Leave execution-limit defaults to hosts.                     | Appropriate budgets depend on the surrounding product and its own cancellation, retention, and output-bounding policies.                                                                                                 |
+| Skip unsupported OpenAPI operations.                         | Incorrect parameter encoding, authentication, or transport behavior is worse than a precise `skipped` reason.                                                                                                            |
+
+## Remaining Work
+
+The [interpreter support checklist](./interpreter-support.md) owns concrete DSL, standard-library, semantic-correctness,
+diagnostic, and data-boundary work. OpenAPI adapter work remains in [src/openapi/TODO.md](./src/openapi/TODO.md).

packages/core/src/config.ts

@@ -200,6 +200,7 @@ const layer = Layer.effect(
             .up({
               targets: [".opencode", ".claude", ".agents", ...names.toReversed()],
               start: location.directory,
+              stop: location.project.directory,
             })
           .pipe(Effect.orDie)
 

packages/core/src/flag/flag.ts

@@ -52,6 +52,9 @@ export const Flag = {
   get OPENCODE_EXPERIMENTAL_REFERENCES() {
     return enabledByExperimental("OPENCODE_EXPERIMENTAL_REFERENCES")
   },
+  get CODEMODE_ENABLED() {
+    return process.env["CODEMODE_ENABLED"] === undefined || truthy("CODEMODE_ENABLED")
+  },
   get OPENCODE_TUI_CONFIG() {
     return process.env["OPENCODE_TUI_CONFIG"]
   },

packages/core/src/mcp/guidance.ts

@@ -1,6 +1,7 @@
 export * as McpGuidance from "./guidance"
 
 import { makeLocationNode } from "../effect/app-node"
+import { Flag } from "../flag/flag"
 import { Context, Effect, Layer, Schema } from "effect"
 import { AgentV2 } from "../agent"
 import { PermissionV2 } from "../permission"
@@ -17,7 +18,11 @@ type Summary = typeof Summary.Type
 const entries = (servers: ReadonlyArray<Summary>) =>
   servers.flatMap((server) => [
     `  <server name="${server.server}">`,
-    `    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(McpTool.group(server.server))}]\`.`,
+    ...(Flag.CODEMODE_ENABLED
+      ? [
+          `    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(McpTool.group(server.server))}]\`.`,
+        ]
+      : []),
     ...server.instructions.split("\n").map((line) => `    ${line}`),
     "  </server>",
   ])
@@ -76,7 +81,7 @@ export const layer = Layer.effect(
               removed: () => "MCP server instructions are no longer available.",
             },
           })
-        if (PermissionV2.evaluate("execute", "*", agent.permissions).effect === "deny")
+        if (Flag.CODEMODE_ENABLED && PermissionV2.evaluate("execute", "*", agent.permissions).effect === "deny")
           return source(Instructions.removed)
         const [instructions, tools] = yield* Effect.all([mcp.instructions(), mcp.tools()], {
           concurrency: "unbounded",
@@ -85,9 +90,12 @@ export const layer = Layer.effect(
         const visible = instructions
           .filter((item) => {
             const owned = tools.filter((tool) => tool.server === item.server)
-            return owned.some(
-              (tool) =>
-                PermissionV2.evaluate(McpTool.name(tool.server, tool.name), "*", agent.permissions).effect !== "deny",
+            return (
+              (!Flag.CODEMODE_ENABLED && owned.length === 0) ||
+              owned.some(
+                (tool) =>
+                  PermissionV2.evaluate(McpTool.name(tool.server, tool.name), "*", agent.permissions).effect !== "deny",
+              )
             )
           })
           .map((item) => ({ server: item.server, instructions: item.instructions }))

packages/core/src/tool/AGENTS.md

@@ -29,8 +29,7 @@ Leaves own resolution, permission, and side-effect ordering. Translate only expe
 ## Registration
 
 Built-ins and plugin tools register through `Tools.Service.register({ [name]: tool })`. Registrations may provide a
-group, which flattens direct model names to `<group>_<tool>`, and default into CodeMode (`codemode` defaults true;
-`codemode: false` keeps the tool on the provider's native tool list).
+group, which flattens direct model names to `<group>_<tool>`, and may be deferred from direct model exposure.
 
 Registrations are scoped:
 

packages/core/src/tool/edit.ts

@@ -212,7 +212,6 @@ export const Plugin = {
             }),
             "edit",
           ),
-          { codemode: false },
         ),
       )
       .pipe(Effect.orDie)

packages/core/src/tool/execute.ts

@@ -58,16 +58,16 @@ export const create = (registrations: ReadonlyMap<string, Registration>) => {
       })
       if (registration.group === undefined) {
         const path = registration.name
-        if (Object.hasOwn(tools, path)) throw new TypeError(`CodeMode tool namespace conflict: ${path}`)
+        if (Object.hasOwn(tools, path)) throw new TypeError(`Deferred tool namespace conflict: ${path}`)
         tools[path] = value
         continue
       }
       const path = registration.name
       const namespace = registration.group
       const group = tools[namespace]
-      if (group && Tool.isDefinition(group)) throw new TypeError(`CodeMode tool namespace conflict: ${namespace}`)
+      if (group && Tool.isDefinition(group)) throw new TypeError(`Deferred tool namespace conflict: ${namespace}`)
       if (group) {
-        if (Object.hasOwn(group, path)) throw new TypeError(`CodeMode tool namespace conflict: ${namespace}.${path}`)
+        if (Object.hasOwn(group, path)) throw new TypeError(`Deferred tool namespace conflict: ${namespace}.${path}`)
         group[path] = value
         continue
       }

packages/core/src/tool/glob.ts

@@ -106,7 +106,6 @@ export const Plugin = {
                 ),
               ),
           }),
-          { codemode: false },
         ),
       )
       .pipe(Effect.orDie)

packages/core/src/tool/grep.ts

@@ -137,7 +137,6 @@ export const Plugin = {
                 ),
               ),
           }),
-          { codemode: false },
         ),
       )
       .pipe(Effect.orDie)

packages/core/src/tool/mcp.ts

@@ -5,7 +5,7 @@ import { McpEvent } from "@opencode-ai/schema/mcp-event"
 import { Effect, Exit, type JsonSchema, Layer, Scope, Semaphore, Stream } from "effect"
 import { makeLocationNode } from "../effect/app-node"
 import { EventV2 } from "../event"
-
+import { Flag } from "../flag/flag"
 import { MCP } from "../mcp"
 import { PermissionV2 } from "../permission"
 import { Tool } from "./tool"
@@ -107,7 +107,7 @@ export const layer = Layer.effectDiscard(
         const next = yield* Scope.fork(scope)
         yield* Effect.forEach(
           groups,
-          ([group, record]) => tools.register(record, { group }),
+          ([group, record]) => tools.register(record, { group, deferred: Flag.CODEMODE_ENABLED }),
           {
             discard: true,
           },

packages/core/src/tool/patch.ts

@@ -191,7 +191,6 @@ export const Plugin = {
             }),
             "edit",
           ),
-          { codemode: false },
         ),
       )
       .pipe(Effect.orDie)

packages/core/src/tool/question.ts

@@ -106,7 +106,6 @@ export const Plugin = {
                   }),
                 ),
           }),
-          { codemode: false },
         ),
       )
       .pipe(Effect.orDie)

packages/core/src/tool/read.ts

@@ -139,7 +139,6 @@ export const Plugin = {
               )
             },
           }),
-          { codemode: false },
         ),
       )
       .pipe(Effect.orDie)

packages/core/src/tool/registry.ts

@@ -3,6 +3,7 @@ export * as ToolRegistry from "./registry"
 import { ToolOutput, type ToolCall, type ToolDefinition, type ToolResultValue } from "@opencode-ai/llm"
 import { Context, Effect, Layer, Scope } from "effect"
 import type { AgentV2 } from "../agent"
+import { Flag } from "../flag/flag"
 import { PermissionV2 } from "../permission"
 import { SessionMessage } from "../session/message"
 import { SessionSchema } from "../session/schema"
@@ -55,7 +56,7 @@ const registryLayer = Layer.effect(
       readonly tool: AnyTool
       readonly name: string
       readonly group?: string
-      readonly codemode: boolean
+      readonly deferred: boolean
     }
     const local = new Map<string, Array<{ readonly token: object; readonly registration: Registration }>>()
 
@@ -131,8 +132,7 @@ const registryLayer = Layer.effect(
       register: Effect.fn("ToolRegistry.register")(function* (tools, options) {
         const entries = registrationEntries(tools, options?.group)
         if (entries.length === 0) return
-        const codemode = options?.codemode ?? true
-        const reserved = codemode ? undefined : entries.find((entry) => entry.key === "execute")
+        const reserved = options?.deferred ? undefined : entries.find((entry) => entry.key === "execute")
         if (reserved)
           return yield* Effect.fail(
             new RegistrationError({ name: reserved.key, message: 'Tool name "execute" is reserved for CodeMode' }),
@@ -149,7 +149,7 @@ const registryLayer = Layer.effect(
                     tool: entry.tool,
                     name: entry.name,
                     group: entry.group,
-                    codemode,
+                    deferred: options?.deferred ?? false,
                   },
                 },
               ])
@@ -168,17 +168,18 @@ const registryLayer = Layer.effect(
       }),
       materialize: Effect.fn("ToolRegistry.materialize")(function* (permissions) {
         const direct = new Map<string, Registration>()
-        const codemode = new Map<string, Registration>()
+        const deferred = new Map<string, Registration>()
         const rules = permissions ?? []
         for (const [name, entries] of local) {
           const registration = entries.at(-1)?.registration
           if (!registration) continue
+          if (registration.deferred && !Flag.CODEMODE_ENABLED) continue
           if (whollyDisabled(permission(registration.tool, name), rules)) continue
-          if (registration.codemode) codemode.set(name, registration)
+          if (registration.deferred) deferred.set(name, registration)
           else direct.set(name, registration)
         }
         const execute =
-          codemode.size > 0 && !whollyDisabled("execute", rules) ? ExecuteTool.create(codemode) : undefined
+          deferred.size > 0 && !whollyDisabled("execute", rules) ? ExecuteTool.create(deferred) : undefined
         return {
           definitions: [
             ...Array.from(direct, ([name, registration]) => definition(name, registration.tool)),

packages/core/src/tool/shell.ts

@@ -132,8 +132,6 @@ export const Plugin = {
           return runtime.session.synthetic({
             sessionID,
             text: `<shell id="${callID}" state="${state}" command="${command}">\n${text}\n</shell>`,
-            description: command,
-            metadata: { source: "shell", state },
           })
         }),
         Effect.forkIn(scope, { startImmediately: true }),
@@ -278,7 +276,6 @@ export const Plugin = {
                 ),
               ),
           }),
-          { codemode: false },
         ),
       )
       .pipe(Effect.orDie)

packages/core/src/tool/skill.ts

@@ -97,7 +97,6 @@ export const Plugin = {
                 }).pipe(Effect.mapError((error) => unableToLoad(input.id, error)))
               }),
           }),
-          { codemode: false },
         ),
       )
       .pipe(Effect.orDie)

packages/core/src/tool/subagent.ts

@@ -208,7 +208,6 @@ export const Plugin = {
                 return { sessionID: child.id, status: "completed" as const, output: result?.info.output ?? NO_TEXT }
               }),
           }),
-          { codemode: false },
         ),
       )
       .pipe(Effect.orDie)

packages/core/src/tool/webfetch.ts

@@ -174,7 +174,6 @@ export const Plugin = {
                 }
               }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Unable to fetch ${input.url}`, error }))),
           }),
-          { codemode: false },
         ),
       )
       .pipe(Effect.orDie)

packages/core/src/tool/websearch.ts

@@ -252,7 +252,6 @@ export const Plugin = {
               )
             },
           }),
-          { codemode: false },
         ),
       )
       .pipe(Effect.orDie)

packages/core/src/tool/write.ts

@@ -91,7 +91,6 @@ export const Plugin = {
             }),
             "edit",
           ),
-          { codemode: false },
         ),
       )
       .pipe(Effect.orDie)

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

@@ -876,7 +876,7 @@ describe("Config", () => {
     ),
   )
 
-  it.live("loads global and ancestor configuration across the project boundary", () =>
+  it.live("loads global, ancestor, and .opencode configuration up to the project boundary", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),
       (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
@@ -936,7 +936,6 @@ describe("Config", () => {
             ])
             expect(documents.map((document) => document.info.$schema)).toEqual([
               "global",
-              "outside",
               "root",
               "parent",
               "directory",
@@ -952,8 +951,6 @@ describe("Config", () => {
               AbsolutePath.make(path.join(root, ".agents")),
               "global",
               AbsolutePath.make(global),
-              "outside",
-              AbsolutePath.make(path.join(tmp.path, "opencode.json")),
               "root",
               AbsolutePath.make(path.join(root, "opencode.json")),
               "parent",

packages/core/test/plugin.test.ts

@@ -260,7 +260,6 @@ describe("PluginV2", () => {
                   output: Schema.Struct({ ok: Schema.Boolean }),
                   execute: () => Effect.succeed({ ok: true }),
                 }),
-                { codemode: false },
               ),
             )
             .pipe(Effect.orDie),
@@ -274,7 +273,7 @@ describe("PluginV2", () => {
     }),
   )
 
-  it.effect("groups tool names and routes codemode registrations through execute", () =>
+  it.effect("groups tool names and defers registrations from direct exposure", () =>
     Effect.gen(function* () {
       const plugins = yield* PluginV2.Service
       const registry = yield* ToolRegistry.Service
@@ -290,9 +289,9 @@ describe("PluginV2", () => {
         effect: (ctx) =>
           ctx.tool
             .transform((draft) => {
-              draft.add("plain", tool("Plain"), { codemode: false })
-              draft.add("look/up", tool("Lookup"), { group: "context 7", codemode: false })
-              draft.add("search", tool("Search"), { group: "context 7" })
+              draft.add("plain", tool("Plain"))
+              draft.add("look/up", tool("Lookup"), { group: "context 7" })
+              draft.add("search", tool("Search"), { group: "context 7", deferred: true })
             })
             .pipe(Effect.orDie),
       })
@@ -331,7 +330,6 @@ describe("PluginV2", () => {
                     output: Schema.Struct({ text: Schema.String }),
                     execute: ({ text }) => Effect.sync(() => executed.push({ text })).pipe(Effect.as({ text })),
                   }),
-                  { codemode: false },
                 ),
               )
               .pipe(Effect.orDie)

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

@@ -135,7 +135,6 @@ describe("fromPromise", () => {
           await ctx.tool.transform((tools) => {
             tools.add({
               name: "hello",
-              options: { codemode: false },
               description: "Hello",
               input: Schema.Struct({ name: Schema.String }),
               output: Schema.String,

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

@@ -70,7 +70,7 @@ describe("ToolRegistry", () => {
         bash: make(),
         edit: make("edit"),
         write: make("edit"),
-      }, { codemode: false })
+      })
       const names = (permissions: PermissionV2.Ruleset) =>
         toolDefinitions(service, permissions).pipe(Effect.map((definitions) => definitions.map((tool) => tool.name)))
 
@@ -95,8 +95,8 @@ describe("ToolRegistry", () => {
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service
       const shared = make()
-      yield* service.register({ first: shared }, { codemode: false })
-      yield* service.register({ second: Tool.withPermission(shared, "edit") }, { codemode: false })
+      yield* service.register({ first: shared })
+      yield* service.register({ second: Tool.withPermission(shared, "edit") })
       Tool.withPermission(shared, "question")
 
       expect(
@@ -110,7 +110,7 @@ describe("ToolRegistry", () => {
   it.effect("reuses model definitions across requests", () =>
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service
-      yield* service.register({ echo: make() }, { codemode: false })
+      yield* service.register({ echo: make() })
       const first = yield* toolDefinitions(service)
       const second = yield* toolDefinitions(service)
 
@@ -122,7 +122,7 @@ describe("ToolRegistry", () => {
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service
       const scope = yield* Scope.make()
-      yield* service.register({ echo: make() }, { codemode: false }).pipe(Scope.provide(scope))
+      yield* service.register({ echo: make() }).pipe(Scope.provide(scope))
       expect((yield* toolDefinitions(service)).map((tool) => tool.name)).toEqual(["echo"])
       yield* Scope.close(scope, Exit.void)
       expect(yield* toolDefinitions(service)).toEqual([])
@@ -135,7 +135,7 @@ describe("ToolRegistry", () => {
       const scope = yield* Scope.make()
       const registered = yield* Deferred.make<void>()
       const fiber = yield* service
-        .register({ echo: make() }, { codemode: false })
+        .register({ echo: make() })
         .pipe(
           Effect.andThen(Deferred.succeed(registered, undefined)),
           Effect.andThen(Effect.never),
@@ -161,7 +161,7 @@ describe("ToolRegistry", () => {
           output: Schema.Struct({ ok: Schema.Boolean }),
           execute: () => Effect.fail(new Tool.Failure({ message: "Denied" })),
         }),
-      }, { codemode: false })
+      })
       expect(
         yield* executeTool(service, {
           sessionID,
@@ -184,7 +184,7 @@ describe("ToolRegistry", () => {
           output: Schema.Struct({}),
           execute: () => Effect.die("unexpected executor defect"),
         }),
-      }, { codemode: false })
+      })
       expect(
         yield* service.materialize().pipe(
           Effect.flatMap((materialized) =>
@@ -203,7 +203,7 @@ describe("ToolRegistry", () => {
   it.effect("propagates retention failures through settlement", () =>
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service
-      yield* service.register({ echo: make() }, { codemode: false })
+      yield* service.register({ echo: make() })
       const materialized = yield* service.materialize()
       const exit = yield* materialized.settle(call("echo", "call-retention-failure")).pipe(Effect.exit)
 
@@ -234,7 +234,7 @@ describe("ToolRegistry", () => {
           output: Schema.Struct({ ok: Schema.Boolean }),
           execute: (_, context) => Effect.sync(() => contexts.push(context)).pipe(Effect.as({ ok: true })),
         }),
-      }, { codemode: false })
+      })
       yield* executeTool(service, {
         sessionID,
         ...identity,
@@ -248,7 +248,7 @@ describe("ToolRegistry", () => {
     Effect.gen(function* () {
       bounds.length = 0
       const service = yield* ToolRegistry.Service
-      yield* service.register({ bounded: make() }, { codemode: false })
+      yield* service.register({ bounded: make() })
       expect(
         yield* settleTool(service, {
           sessionID,
@@ -282,7 +282,7 @@ describe("ToolRegistry", () => {
           execute: ({ value }) => Effect.sync(() => executed.push(value)).pipe(Effect.as({ value })),
           toModelOutput: ({ output }) => [{ type: "text", text: String(output.value) }],
         }),
-      }, { codemode: false })
+      })
 
       expect(
         yield* executeTool(service, {
@@ -319,7 +319,7 @@ describe("ToolRegistry", () => {
           }),
           execute: () => Effect.succeed({ value: "invalid" }),
         }),
-      }, { codemode: false })
+      })
       expect(
         yield* executeTool(service, {
           sessionID,
@@ -334,10 +334,10 @@ describe("ToolRegistry", () => {
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service
       const scope = yield* Scope.make()
-      yield* service.register({ echo: constant("advertised") }, { codemode: false }).pipe(Scope.provide(scope))
+      yield* service.register({ echo: constant("advertised") }).pipe(Scope.provide(scope))
       const request = yield* service.materialize()
       yield* Scope.close(scope, Exit.void)
-      yield* service.register({ echo: constant("replacement") }, { codemode: false })
+      yield* service.register({ echo: constant("replacement") })
 
       expect((yield* request.settle(call("echo"))).result).toEqual({ type: "text", value: "advertised" })
       expect(yield* executeTool(service, call("echo"))).toEqual({ type: "text", value: "replacement" })
@@ -347,9 +347,9 @@ describe("ToolRegistry", () => {
   it.effect("reveals the previous registration after an overlay closes", () =>
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service
-      yield* service.register({ echo: constant("base") }, { codemode: false })
+      yield* service.register({ echo: constant("base") })
       const overlay = yield* Scope.make()
-      yield* service.register({ echo: constant("overlay") }, { codemode: false }).pipe(Scope.provide(overlay))
+      yield* service.register({ echo: constant("overlay") }).pipe(Scope.provide(overlay))
 
       expect(yield* executeTool(service, call("echo"))).toEqual({ type: "text", value: "overlay" })
       yield* Scope.close(overlay, Exit.void)
@@ -357,31 +357,37 @@ describe("ToolRegistry", () => {
     }),
   )
 
-  it.effect("executes codemode tools advertised in a model request", () =>
+  it.effect("executes deferred tools advertised in a model request", () =>
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service
       const executed: string[] = []
       const scope = yield* Scope.make()
       yield* service
-        .register({
+        .register(
+          {
+            echo: Tool.make({
+              description: "Echo text",
+              input: Schema.Struct({ text: Schema.String }),
+              output: Schema.Struct({ text: Schema.String }),
+              execute: ({ text }) => Effect.sync(() => executed.push(`old:${text}`)).pipe(Effect.as({ text })),
+            }),
+          },
+          { deferred: true },
+        )
+        .pipe(Scope.provide(scope))
+      const materialized = yield* service.materialize()
+      yield* Scope.close(scope, Exit.void)
+      yield* service.register(
+        {
           echo: Tool.make({
             description: "Echo text",
             input: Schema.Struct({ text: Schema.String }),
             output: Schema.Struct({ text: Schema.String }),
-            execute: ({ text }) => Effect.sync(() => executed.push(`old:${text}`)).pipe(Effect.as({ text })),
+            execute: ({ text }) => Effect.sync(() => executed.push(`new:${text}`)).pipe(Effect.as({ text })),
           }),
-        })
-        .pipe(Scope.provide(scope))
-      const materialized = yield* service.materialize()
-      yield* Scope.close(scope, Exit.void)
-      yield* service.register({
-        echo: Tool.make({
-          description: "Echo text",
-          input: Schema.Struct({ text: Schema.String }),
-          output: Schema.Struct({ text: Schema.String }),
-          execute: ({ text }) => Effect.sync(() => executed.push(`new:${text}`)).pipe(Effect.as({ text })),
-        }),
-      })
+        },
+        { deferred: true },
+      )
 
       const settlement = yield* materialized.settle({
         ...call("execute"),

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

@@ -261,7 +261,7 @@ const echo = Layer.effectDiscard(
         output: Schema.Any,
         execute: () => Effect.succeed({ big: 1n }),
       }),
-    }, { codemode: false }),
+    }),
   ),
 )
 const echoNode = makeLocationNode({ name: "test/session-runner-tools", layer: echo, deps: [ToolRegistry.node] })
@@ -782,7 +782,7 @@ describe("SessionRunnerLLM", () => {
               return { answer: query.toUpperCase() }
             }),
         }),
-      }, { codemode: false })
+      })
       yield* admit(session, "Use application context")
       responses = [reply.tool("call-location", "location_context", { query: "hello" }), []]
 
@@ -827,7 +827,7 @@ describe("SessionRunnerLLM", () => {
             output: Schema.Struct({ value: Schema.String }),
             execute: () => Effect.sync(() => executions.push("advertised")).pipe(Effect.as({ value: "advertised" })),
           }),
-        }, { codemode: false })
+        })
         .pipe(Scope.provide(scope))
       yield* admit(session, "Use the reloaded tool")
       responses = [
@@ -852,7 +852,7 @@ describe("SessionRunnerLLM", () => {
           output: Schema.Struct({ value: Schema.String }),
           execute: () => Effect.sync(() => executions.push("replacement")).pipe(Effect.as({ value: "replacement" })),
         }),
-      }, { codemode: false })
+      })
       yield* Deferred.succeed(streamGate, undefined)
       yield* Fiber.join(run)
 
@@ -3189,7 +3189,7 @@ describe("SessionRunnerLLM", () => {
               Effect.mapError(() => new Tool.Failure({ message: "Permission blocked" })),
             ),
         }),
-      }, { codemode: false })
+      })
       yield* admit(session, "Call blocked")
 
       responses = [reply.tool("call-blocked", "blocked", {}), reply.stop()]
@@ -3221,7 +3221,7 @@ describe("SessionRunnerLLM", () => {
           output: Schema.Struct({}),
           execute: () => Effect.die(new PermissionV2.DeclinedError()),
         }),
-      }, { codemode: false })
+      })
       yield* admit(session, "Call declined")
 
       response = reply.tool("call-declined", "declined", {})
@@ -3261,7 +3261,7 @@ describe("SessionRunnerLLM", () => {
               Effect.mapError(() => new Tool.Failure({ message: "Use another tool" })),
             ),
         }),
-      }, { codemode: false })
+      })
       yield* admit(session, "Call corrected")
 
       responses = [reply.tool("call-corrected", "corrected", {}), reply.stop()]
@@ -3321,7 +3321,7 @@ describe("SessionRunnerLLM", () => {
     Effect.gen(function* () {
       const session = yield* setup
       const registry = yield* ToolRegistry.Service
-      yield* registry.register({ permissionfail: permissionFail }, { codemode: false })
+      yield* registry.register({ permissionfail: permissionFail })
       yield* admit(session, "Reject permission")
       responses = [
         reply.tool("call-permission", "permissionfail", {}),
@@ -3366,7 +3366,7 @@ describe("SessionRunnerLLM", () => {
           output: Schema.Struct({}),
           execute: () => Effect.die(new QuestionTool.CancelledError()),
         }),
-      }, { codemode: false })
+      })
       yield* admit(session, "Ask then stop")
 
       responses = [reply.tool("call-question", "question", {}), []]

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

@@ -2,7 +2,7 @@ import fs from "fs/promises"
 import { realpathSync } from "node:fs"
 import path from "path"
 import { describe, expect, test } from "bun:test"
-import { DateTime, Duration, Effect, Fiber, Layer, Scope, Stream } from "effect"
+import { DateTime, Duration, Effect, Fiber, Layer, Scope } from "effect"
 import { Money } from "@opencode-ai/schema/money"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
@@ -443,12 +443,6 @@ describe("ShellTool", () => {
         reset()
         return withSession(tmp.path, (registry) =>
           Effect.gen(function* () {
-            const events = yield* EventV2.Service
-            const admitted = yield* events.subscribe(SessionEvent.InputAdmitted).pipe(
-              Stream.filter((event) => event.data.sessionID === sessionID && event.data.input.type === "synthetic"),
-              Stream.runHead,
-              Effect.forkScoped({ startImmediately: true }),
-            )
             const settled = yield* settleTool(registry, call({ command: idleCommand, timeout: 50, background: true }))
             const structured = settled.output?.structured as Record<string, unknown> | undefined
             const shellID = typeof structured?.shellID === "string" ? structured.shellID : undefined
@@ -460,13 +454,6 @@ describe("ShellTool", () => {
             const id = ShellSchema.ID.make(shellID)
             expect((yield* shell.list()).map((info) => info.id)).toContain(id)
             expect((yield* shell.wait(id)).status).toBe("timeout")
-            expect((yield* Fiber.join(admitted)).valueOrUndefined?.data.input.data).toMatchObject({
-              description: idleCommand,
-              metadata: {
-                source: "shell",
-                state: "completed",
-              },
-            })
           }),
         )
       },

packages/docs/build/plugins.mdx

@@ -315,12 +315,11 @@ export default Plugin.define({
 Unsupported characters in tool and group names are normalized to underscores.
 The resulting exposed key must begin with a letter and contain at most 64
 letters, digits, underscores, or hyphens. Set `options` on the declaration to
-configure registration with `{ group, codemode }`:
+configure registration with `{ group, deferred }`:
 
 - `group` prefixes and groups the exposed tool name.
-- `codemode` defaults to `true` and makes the tool available through the
-  `execute` CodeMode tool. Set `codemode: false` to expose it directly to the
-  provider.
+- `deferred: true` makes the tool available through the deferred `execute`
+  tool instead of exposing it directly.
 
 The executor receives a second context argument containing `sessionID`,
 `agent`, `assistantMessageID`, and `toolCallID`.

packages/docs/migrate-v1.mdx

@@ -3,19 +3,14 @@ title: "Migrate from V1"
 description: "Move from OpenCode V1 to the OpenCode 2.0 beta."
 ---
 
-## Breaking changes
+<Note>
+  The only intentional breaking changes in V2 are the server API and the plugin API. All other functionality is intended
+  to remain compatible with V1.
+</Note>
 
-V2 has three intentional breaking changes:
-
-- [Plugins](#plugins) use a new plugin API.
-- 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).
-
-All other functionality is intended to remain compatible with V1.
-
-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.
+Existing 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.
 
 <Tip>
   Run `/report` if existing V1 functionality does not work in V2. The report skill collects diagnostics and helps you file
@@ -471,58 +466,6 @@ If a V1 setup relied on a `CLAUDE.md` fallback, move that guidance into the appl
 discovers `AGENTS.md`; because non-API V1 behavior is intended to remain compatible, also run `/report` with the affected
 project details. See [Instructions](/instructions).
 
-## TUI configuration
-
-V1 loaded `tui.json(c)` from the global config directory and from project directories discovered while walking up from
-the current directory. V2 instead stores CLI and TUI settings in one global file:
-
-```text
-~/.config/opencode/cli.json
-```
-
-The CLI owns this file. The background service does not load it, and V2 does not discover or merge project-local
-`tui.json(c)` or `cli.json` files.
-
-The native V2 format groups related settings. For example:
-
-```jsonc
-// V1: ~/.config/opencode/tui.json
-{
-  "theme": "tokyonight",
-  "scroll_speed": 2,
-  "scroll_acceleration": {
-    "enabled": true
-  }
-}
-
-// V2: ~/.config/opencode/cli.json
-{
-  "theme": {
-    "name": "tokyonight"
-  },
-  "scroll": {
-    "speed": 2,
-    "acceleration": true
-  }
-}
-```
-
-V2 migrates the global TUI configuration automatically. On the first CLI or TUI startup, when `cli.json` does not already
-exist, it:
-
-- Reads `~/.config/opencode/tui.json`.
-- Reads persisted TUI preferences from the legacy `kv.json` state file.
-- Converts supported settings to the native grouped format and writes `~/.config/opencode/cli.json`.
-- Leaves the V1 files unchanged so V1 can continue using them.
-
-Migration runs only while `cli.json` is absent. Once that file exists, V2 treats it as the source of truth and does not
-continually synchronize later changes from `tui.json` or `kv.json`. If you created `cli.json` before starting V2, merge any
-V1 settings you still need into it manually.
-
-Project-local V1 TUI configuration is not migrated because V2 has no project-local CLI configuration. Move settings you
-still want into the global `cli.json`; when multiple projects used different values for the same setting, choose the
-global behavior you want V2 to use.
-
 ## Plugins
 
 Rename `plugin` to `plugins`. Replace a package-and-options tuple with an object:

packages/plugin/src/v2/effect/tool.ts

@@ -272,8 +272,7 @@ export interface ToolExecuteAfterEvent {
 
 export interface RegisterOptions {
   readonly group?: string
-  /** Defaults to true. False exposes the tool directly to the provider. */
-  readonly codemode?: boolean
+  readonly deferred?: boolean
 }
 
 export interface ToolDraft {

packages/plugin/src/v2/promise/tool.ts

@@ -69,8 +69,7 @@ export interface ToolExecuteAfterEvent {
 
 export interface RegisterOptions {
   readonly group?: string
-  /** Defaults to true. False exposes the tool directly to the provider. */
-  readonly codemode?: boolean
+  readonly deferred?: boolean
 }
 
 export interface ToolDraft {

packages/tui/src/app.tsx

@@ -526,7 +526,7 @@ function App(props: {
         toast.show({
           variant: "error",
           title: `MCP server failed: ${server.name}`,
-          message: "Open MCP servers to view details.",
+          message: "Open MCPs to view details.",
         })
     }
   })
@@ -791,7 +791,7 @@ function App(props: {
       },
       {
         name: "mcp.list",
-        title: "MCP servers",
+        title: "MCP Servers",
         category: "Agent",
         slashName: "mcps",
         run: () => {

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

@@ -1,10 +1,10 @@
-import { TextAttributes } from "@opentui/core"
+import { TextAttributes, type ScrollBoxRenderable } from "@opentui/core"
 import { useTerminalDimensions } from "@opentui/solid"
-import { createMemo, createSignal, onMount, Show } from "solid-js"
+import { createMemo, createSignal, For, onMount, Show } from "solid-js"
 import { useConfig } from "../config"
 import { useTheme } from "../context/theme"
+import { useBindings } from "../keymap"
 import { useDialog } from "../ui/dialog"
-import { DialogSelect } from "../ui/dialog-select"
 import { useToast } from "../ui/toast"
 
 type Setting = {
@@ -249,8 +249,9 @@ export function DialogConfig() {
   const themeState = useTheme()
   const { theme } = themeState
   const dimensions = useTerminalDimensions()
-  const [selected, setSelected] = createSignal(settings[0])
+  const [selected, setSelected] = createSignal(0)
   const [saving, setSaving] = createSignal(false)
+  let scroll: ScrollBoxRenderable | undefined
   onMount(() => {
     dialog.setSize("xlarge")
     dialog.setCentered(true)
@@ -274,19 +275,34 @@ export function DialogConfig() {
     const index = setting.values?.indexOf(current)
     return index === undefined || index < 0 ? String(current) : (setting.labels?.[index] ?? String(current))
   }
-  const options = createMemo(() =>
-    settings.map((setting) => ({
-      title: setting.title,
-      category: setting.category,
-      value: setting,
-      footer: selected() === setting ? `‹ ${display(setting)} ›` : `  ${display(setting)}  `,
+  const rows = createMemo(() =>
+    settings.map((setting, index) => ({
+      setting,
+      index,
+      heading: index === 0 || settings[index - 1].category !== setting.category,
     })),
   )
   const split = createMemo(() => dimensions().width >= 110)
   const height = createMemo(() => Math.max(8, Math.min(36, dimensions().height - 12)))
 
-  async function change(setting: Setting, direction: number) {
+  function move(direction: number) {
+    const next = (selected() + direction + settings.length) % settings.length
+    setSelected(next)
+    queueMicrotask(() => {
+      if (!scroll) return
+      const row =
+        next +
+        settings.slice(0, next + 1).filter((setting, index) => {
+          return index === 0 || settings[index - 1].category !== setting.category
+        }).length
+      if (row < scroll.scrollTop) scroll.scrollTo(row)
+      if (row >= scroll.scrollTop + scroll.viewport.height) scroll.scrollTo(row - scroll.viewport.height + 1)
+    })
+  }
+
+  async function change(direction: number) {
     if (saving()) return
+    const setting = settings[selected()]
     const current = value(setting)
     const choices = values(setting)
     const next = choices
@@ -306,22 +322,72 @@ export function DialogConfig() {
       .finally(() => setSaving(false))
   }
 
+  useBindings(() => ({
+    bindings: [
+      {
+        key: "up",
+        desc: "Previous setting",
+        group: "Settings",
+        cmd: () => move(-1),
+      },
+      {
+        key: "down",
+        desc: "Next setting",
+        group: "Settings",
+        cmd: () => move(1),
+      },
+      { key: "left", desc: "Previous value", group: "Settings", cmd: () => void change(-1) },
+      { key: "right", desc: "Next value", group: "Settings", cmd: () => void change(1) },
+      { key: "return", desc: "Next value", group: "Settings", cmd: () => void change(1) },
+    ],
+  }))
+
   return (
     <box flexDirection="row" height={height() + 1}>
-      <box width={split() ? "54%" : "100%"}>
-        <DialogSelect
-          title="Settings"
-          options={options()}
-          renderFilter={false}
-          hideClose={split()}
-          maxHeight={height() - 2}
-          onMove={(option) => setSelected(option.value)}
-          onSelect={(option) => void change(option.value, 1)}
-          bindings={[
-            { key: "left", desc: "Previous value", group: "Settings", cmd: () => void change(selected(), -1) },
-            { key: "right", desc: "Next value", group: "Settings", cmd: () => void change(selected(), 1) },
-          ]}
-        />
+      <box width={split() ? "54%" : "100%"} paddingLeft={4} paddingRight={split() ? 3 : 4} paddingBottom={1}>
+        <text fg={theme.text} attributes={TextAttributes.BOLD} paddingBottom={1}>
+          Settings
+        </text>
+        <scrollbox
+          ref={(element: ScrollBoxRenderable) => (scroll = element)}
+          flexGrow={1}
+          scrollbarOptions={{ visible: false }}
+        >
+          <For each={rows()}>
+            {(row) => (
+              <>
+                <Show when={row.heading}>
+                  <box paddingTop={row.index === 0 ? 0 : 1}>
+                    <text fg={theme.primary} attributes={TextAttributes.BOLD}>
+                      {row.setting.category}
+                    </text>
+                  </box>
+                </Show>
+                <box flexDirection="row" height={1}>
+                  <text
+                    width={25}
+                    fg={row.index === selected() ? theme.text : theme.textMuted}
+                    attributes={row.index === selected() ? TextAttributes.BOLD : undefined}
+                  >
+                    {row.setting.title}
+                  </text>
+                  <box flexGrow={1} flexDirection="row" justifyContent="flex-end">
+                    <box flexDirection="row">
+                      <text fg={theme.textMuted}>{row.index === selected() ? "‹ " : "  "}</text>
+                      <text
+                        fg={row.index === selected() ? theme.primary : theme.textMuted}
+                        attributes={row.index === selected() ? TextAttributes.BOLD : undefined}
+                      >
+                        {display(row.setting)}
+                      </text>
+                      <text fg={theme.textMuted}>{row.index === selected() ? " ›" : "  "}</text>
+                    </box>
+                  </box>
+                </box>
+              </>
+            )}
+          </For>
+        </scrollbox>
       </box>
       <Show when={split()}>
         <box
@@ -336,7 +402,7 @@ export function DialogConfig() {
         >
           <box flexDirection="row" justifyContent="space-between">
             <text fg={theme.primary} attributes={TextAttributes.BOLD}>
-              {selected().title}
+              {settings[selected()].title}
             </text>
             <text fg={theme.textMuted} onMouseUp={() => dialog.clear()}>
               esc
@@ -344,7 +410,7 @@ export function DialogConfig() {
           </box>
           <box paddingTop={1}>
             <text fg={theme.text} wrapMode="word">
-              {selected().detail ?? selected().description}
+              {settings[selected()].detail ?? settings[selected()].description}
             </text>
           </box>
         </box>

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

@@ -92,7 +92,7 @@ export function DialogMcp() {
         when={detail()}
         fallback={
           <DialogSelect
-            title="MCP servers"
+            title="MCPs"
             options={options()}
             current={focused()}
             preserveSelection
@@ -152,7 +152,7 @@ function DialogMcpError(props: { server: McpServer; onBack: () => void }) {
     <box paddingLeft={4} paddingRight={4} paddingBottom={1} gap={1}>
       <box flexDirection="row" justifyContent="space-between">
         <text attributes={TextAttributes.BOLD} fg={theme.text}>
-          MCP server: {props.server.name}
+          MCP / {props.server.name}
         </text>
         <text fg={theme.textMuted} onMouseUp={props.onBack}>
           esc back

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

@@ -46,6 +46,7 @@ export function DialogSkill(props: DialogSkillProps) {
       title: skill.name.padEnd(maxWidth),
       description: skill.description?.replace(/\s+/g, " ").trim(),
       value: skill.id,
+      category: "Skills",
       onSelect: () => {
         props.onSelect(skill.id)
         dialog.clear()
@@ -56,6 +57,7 @@ export function DialogSkill(props: DialogSkillProps) {
   return (
     <DialogSelect
       title="Skills"
+      placeholder="Search skills..."
       options={options()}
       renderFilter={!showError()}
       locked={showError()}

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

@@ -22,11 +22,9 @@ export function DialogStatus() {
           esc
         </text>
       </box>
-      <Show when={mcp().length > 0} fallback={<text fg={theme.text}>No MCP servers</text>}>
+      <Show when={mcp().length > 0} fallback={<text fg={theme.text}>No MCP Servers</text>}>
         <box>
-          <text fg={theme.text}>
-            {mcp().length} MCP server{mcp().length === 1 ? "" : "s"}
-          </text>
+          <text fg={theme.text}>{mcp().length} MCP Servers</text>
           <For each={mcp()}>
             {(item) => (
               <box flexDirection="row" gap={1}>

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

@@ -142,6 +142,7 @@ export const Definitions = {
   messages_copy: keybind("<leader>y", "Copy message"),
   messages_undo: keybind("<leader>u", "Undo message"),
   messages_redo: keybind("<leader>r", "Redo message"),
+  messages_toggle_conceal: keybind("<leader>h", "Toggle code block concealment in messages"),
   display_thinking: keybind("none", "Toggle thinking blocks visibility"),
 
   prompt_submit: keybind("none", "Submit prompt"),
@@ -340,6 +341,7 @@ export const CommandMap = {
   messages_copy: "messages.copy",
   messages_undo: "session.undo",
   messages_redo: "session.redo",
+  messages_toggle_conceal: "session.toggle.conceal",
   display_thinking: "session.toggle.thinking",
   prompt_submit: "prompt.submit",
   prompt_editor_context_clear: "prompt.editor_context.clear",

packages/tui/src/feature-plugins/home/tips-view.tsx

@@ -25,6 +25,7 @@ type Shortcuts = {
   messagesLast: TipShortcut
   messagesPageDown: TipShortcut
   messagesPageUp: TipShortcut
+  messagesToggleConceal: TipShortcut
   modelCycleRecent: TipShortcut
   modelList: TipShortcut
   sessionExport: TipShortcut
@@ -114,6 +115,7 @@ export function Tips(props: { api: TuiPluginApi; connected?: boolean }) {
     messagesLast: configShortcut(props.api, "session.last"),
     messagesPageDown: configShortcut(props.api, "session.page.down"),
     messagesPageUp: configShortcut(props.api, "session.page.up"),
+    messagesToggleConceal: configShortcut(props.api, "session.toggle.conceal"),
     modelCycleRecent: useCommandShortcut("model.cycle_recent"),
     modelList: useCommandShortcut("model.list"),
     sessionExport: configShortcut(props.api, "session.export"),
@@ -265,6 +267,7 @@ const TIPS: Tip[] = [
   "Run {highlight}opencode debug config{/highlight} to troubleshoot configuration",
   "Use {highlight}--print-logs{/highlight} flag to see detailed logs in stderr",
   (shortcuts) => `Use ${commandText("/timeline", shortcuts.sessionTimeline())} to jump to specific messages`,
+  (shortcuts) => press(shortcuts.messagesToggleConceal(), "to toggle code block visibility in messages"),
   (shortcuts) => `Use ${commandText("/status", shortcuts.statusView())} to see system status info`,
   "Enable {highlight}scroll.acceleration{/highlight} in {highlight}cli.json{/highlight} for smooth scrolling",
   (shortcuts) =>

packages/tui/src/routes/session/dialog-message.tsx

@@ -6,13 +6,8 @@ import { useToast } from "../../ui/toast"
 import { useSDK } from "../../context/sdk"
 import { errorMessage } from "../../util/error"
 import { DialogFork } from "./dialog-fork"
-import type { PromptInfo } from "../../prompt/history"
 
-export function DialogMessage(props: {
-  messageID: string
-  sessionID: string
-  setPrompt?: (prompt: PromptInfo) => void
-}) {
+export function DialogMessage(props: { messageID: string; sessionID: string }) {
   const data = useData()
   const clipboard = useClipboard()
   const toast = useToast()
@@ -27,26 +22,9 @@ export function DialogMessage(props: {
           title: "Revert",
           value: "session.revert",
           description: "undo messages and file changes",
-          onSelect: (dialog) => {
-            const value = message()
-            if (value?.type === "user") {
-              props.setPrompt?.({
-                text: value.text,
-                files: value.files?.map((file) => ({
-                  uri: file.source.type === "uri" ? file.source.uri : `data:${file.mime};base64,${file.data}`,
-                  name: file.name,
-                  description: file.description,
-                  mention: file.mention ? { ...file.mention } : undefined,
-                })),
-                agents: value.agents?.map((agent) => ({
-                  name: agent.name,
-                  mention: agent.mention ? { ...agent.mention } : undefined,
-                })),
-                pasted: [],
-              })
-            }
-            void sdk.api.session.revert
-              .stage({ sessionID: props.sessionID, messageID: props.messageID })
+          onSelect: async (dialog) => {
+            await sdk.api.session
+              .revert.stage({ sessionID: props.sessionID, messageID: props.messageID })
               .catch((error) => toast.show({ message: errorMessage(error), variant: "error", duration: 5000 }))
             dialog.clear()
           },

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

@@ -88,6 +88,7 @@ const sessionBindingCommands = [
   "session.undo",
   "session.redo",
   "session.sidebar.toggle",
+  "session.toggle.conceal",
   "session.toggle.thinking",
   "session.toggle.scrollbar",
   "session.toggle.exploration_grouping",
@@ -120,6 +121,7 @@ const sessionGlobalUnfocusedBindingCommands = ["session.first", "session.last"]
 const context = createContext<{
   width: number
   sessionID: string
+  conceal: () => boolean
   thinkingMode: () => ThinkingMode
   showThinking: () => boolean
   groupExploration: () => boolean
@@ -196,6 +198,7 @@ export function Session() {
   const dimensions = useTerminalDimensions()
   const [sidebar, setSidebar] = kv.signal<"auto" | "hide">("sidebar", "auto")
   const [sidebarOpen, setSidebarOpen] = createSignal(false)
+  const [conceal, setConceal] = createSignal(true)
   const thinking = useThinkingMode()
   const thinkingMode = thinking.mode
   const showThinking = createMemo(() => true)
@@ -468,6 +471,15 @@ export function Session() {
         dialog.clear()
       },
     },
+    {
+      title: conceal() ? "Disable code concealment" : "Enable code concealment",
+      value: "session.toggle.conceal",
+      category: "Session",
+      run: () => {
+        setConceal((prev) => !prev)
+        dialog.clear()
+      },
+    },
     {
       title: (() => {
         const next = nextThinkingMode(thinkingMode())
@@ -495,7 +507,7 @@ export function Session() {
       },
     },
     {
-      title: groupExploration() ? "Show tool calls individually" : "Group related tool calls",
+      title: groupExploration() ? "Show exploration tools individually" : "Group exploration tools",
       value: "session.toggle.exploration_grouping",
       category: "Session",
       run: () => {
@@ -853,6 +865,7 @@ export function Session() {
             return contentWidth()
           },
           sessionID: route.sessionID,
+          conceal,
           thinkingMode,
           showThinking,
           groupExploration,
@@ -1231,27 +1244,21 @@ function SessionSwitchMessageV2(props: { message: SessionMessageInfo }) {
 }
 
 function SessionNoticeMessageV2(props: { message: SessionMessageInfo }) {
-  const ctx = use()
   const { theme } = useTheme()
   const metadata = () => (props.message.type === "synthetic" ? props.message.metadata : undefined)
-  const source = () => stringValue(metadata()?.source)
-  const completion = () => source() === "subagent" || source() === "shell"
+  const completion = () => metadata()?.source === "subagent"
   const state = () => stringValue(metadata()?.state)
-  const actor = () => (source() === "shell" ? "Shell" : Locale.titlecase(stringValue(metadata()?.agent) ?? "Subagent"))
+  const agent = () => Locale.titlecase(stringValue(metadata()?.agent) ?? "Subagent")
   const text = () => {
     if (props.message.type === "system") return props.message.text
     if (props.message.type === "synthetic") return props.message.description ?? ""
     return ""
   }
-  const description = () => (source() === "shell" ? text().replace(/\s+/g, " ").trim() : text())
   const status = () => {
     if (state() === "completed") return "finished"
     if (state() === "error") return "failed"
     return state() ?? "finished"
   }
-  const heading = () => `${state() === "completed" ? "↳" : "!"} ${actor()} ${status()}`
-  const suffix = () =>
-    Locale.truncateWidth(` · ${description()}`, Math.max(0, ctx.width - 3 - Bun.stringWidth(heading())))
   const color = () => {
     if (state() === "error") return theme.error
     if (state() === "cancelled") return theme.warning
@@ -1267,9 +1274,11 @@ function SessionNoticeMessageV2(props: { message: SessionMessageInfo }) {
       }
     >
       <box marginLeft={3}>
-        <text wrapMode="none">
-          <span style={{ fg: color() }}>{heading()}</span>
-          <span style={{ fg: theme.textMuted }}>{suffix()}</span>
+        <text>
+          <span style={{ fg: color() }}>
+            {state() === "completed" ? "↳" : "!"} {agent()} {status()}
+          </span>
+          <span style={{ fg: theme.textMuted }}> · {text()}</span>
         </text>
       </box>
     </Show>
@@ -1320,7 +1329,7 @@ function CompactionMessage(props: { message: Extract<SessionMessageInfo, { type:
             internalBlockMode="top-level"
             content={content()}
             tableOptions={{ style: "grid" }}
-            conceal={false}
+            conceal={ctx.conceal()}
             fg={theme.markdownText}
             bg={theme.background}
           />
@@ -1468,7 +1477,6 @@ function UserMessage(props: { message: SessionMessageUser }) {
   )
   const dialog = useDialog()
   const renderer = useRenderer()
-  const promptRef = usePromptRef()
 
   return (
     <Show when={props.message.text.trim() || files().length}>
@@ -1487,13 +1495,7 @@ function UserMessage(props: { message: SessionMessageUser }) {
           }}
           onMouseUp={() => {
             if (renderer.getSelection()?.getSelectedText()) return
-            dialog.replace(() => (
-              <DialogMessage
-                messageID={props.message.id}
-                sessionID={ctx.sessionID}
-                setPrompt={(value) => promptRef.current?.set(value)}
-              />
-            ))
+            dialog.replace(() => <DialogMessage messageID={props.message.id} sessionID={ctx.sessionID} />)
           }}
           paddingTop={1}
           paddingBottom={1}
@@ -1745,7 +1747,7 @@ function ReasoningPart(props: {
               streaming={true}
               syntaxStyle={syntax()}
               content={summary().body}
-              conceal={false}
+              conceal={ctx.conceal()}
               fg={theme.textMuted}
             />
           </box>
@@ -1811,7 +1813,7 @@ function TextPart(props: { last: boolean; part: SessionMessageAssistantText }) {
           internalBlockMode="top-level"
           content={props.part.text.trim()}
           tableOptions={{ style: "grid" }}
-          conceal={false}
+          conceal={ctx.conceal()}
           fg={theme.markdownText}
           bg={theme.background}
         />

packages/tui/src/theme/index.ts

@@ -914,6 +914,12 @@ function getSyntaxRules(theme: Theme) {
         foreground: theme.text,
       },
     },
+    {
+      scope: ["conceal"],
+      style: {
+        foreground: theme.textMuted,
+      },
+    },
     // Additional common highlight groups
     {
       scope: ["string.special", "string.special.url"],

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

@@ -51,8 +51,6 @@ export interface DialogSelectProps<T> {
   }[]
   bindings?: readonly Binding<Renderable, KeyEvent>[]
   current?: T
-  hideClose?: boolean
-  maxHeight?: number
 }
 
 export interface DialogSelectOption<T = any> {
@@ -214,7 +212,7 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
   })
 
   const dimensions = useTerminalDimensions()
-  const height = createMemo(() => Math.min(rows(), props.maxHeight ?? Math.floor(dimensions().height / 2) - 6))
+  const height = createMemo(() => Math.min(rows(), Math.floor(dimensions().height / 2) - 6))
 
   const selected = createMemo(() => flat()[store.selected])
 
@@ -567,11 +565,9 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
               {props.title}
             </text>
           )}
-          <Show when={!props.hideClose}>
-            <text fg={theme.textMuted} onMouseUp={() => dialog.clear()}>
-              esc
-            </text>
-          </Show>
+          <text fg={theme.textMuted} onMouseUp={() => dialog.clear()}>
+            esc
+          </text>
         </box>
         <Show when={props.renderFilter !== false}>
           <box paddingTop={1}>
@@ -793,11 +789,7 @@ function Option(props: {
       </text>
       <Show when={props.footer}>
         <box flexShrink={0}>
-          {typeof props.footer === "string" ? (
-            <text fg={props.active && !props.muted ? fg : theme.textMuted}>{props.footer}</text>
-          ) : (
-            props.footer
-          )}
+          <text fg={props.active && !props.muted ? fg : theme.textMuted}>{props.footer}</text>
         </box>
       </Show>
     </>

packages/tui/src/util/locale.ts

@@ -63,24 +63,6 @@ export function truncate(str: string, len: number): string {
   return str.slice(0, len - 1) + "…"
 }
 
-const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" })
-
-export function truncateWidth(str: string, width: number): string {
-  if (width <= 0) return ""
-  if (Bun.stringWidth(str) <= width) return str
-  if (width === 1) return "…"
-
-  const result: string[] = []
-  let used = 0
-  for (const item of graphemeSegmenter.segment(str)) {
-    const next = Bun.stringWidth(item.segment)
-    if (used + next > width - 1) break
-    result.push(item.segment)
-    used += next
-  }
-  return result.join("") + "…"
-}
-
 export function truncateLeft(str: string, len: number): string {
   if (str.length <= len) return str
   return "…" + str.slice(-(len - 1))

packages/tui/test/util/locale.test.ts

@@ -1,9 +0,0 @@
-import { expect, test } from "bun:test"
-import { Locale } from "../../src/util/locale"
-
-test("truncates text from the right by terminal width", () => {
-  expect(Locale.truncateWidth("abcdefgh", 5)).toBe("abcd…")
-  expect(Locale.truncateWidth("ab界cd", 5)).toBe("ab界…")
-  expect(Locale.truncateWidth("abcdefgh", 1)).toBe("…")
-  expect(Locale.truncateWidth("abcdefgh", 0)).toBe("")
-})

packages/web/src/content/docs/mcp-servers.mdx

@@ -292,7 +292,7 @@ The `mcp debug` command shows the current auth status, tests HTTP connectivity,
 
 ## Manage
 
-Tools from your MCP servers are available in OpenCode alongside built-in tools. You can manage them through the OpenCode config like any other tool.
+Your MCPs are available as tools in OpenCode, alongside built-in tools. So you can manage them through the OpenCode config like any other tool.
 
 ---
 
@@ -319,7 +319,7 @@ This means that you can enable or disable them globally.
 }
 ```
 
-We can also use a glob pattern to disable all matching MCP tools.
+We can also use a glob pattern to disable all matching MCPs.
 
 ```json title="opencode.json" {14}
 {
@@ -340,7 +340,7 @@ We can also use a glob pattern to disable all matching MCP tools.
 }
 ```
 
-Here we are using the glob pattern `my-mcp*` to disable all matching MCP tools.
+Here we are using the glob pattern `my-mcp*` to disable all MCPs.
 
 ---