Merge branch 'dev' into migrate-project

refactor: migrate src/project/project.ts from Bun.file() to Filesystem/stat modules
Replace Bun-specific file operations with Filesystem module and fs/promises: - Add stat import from fs/promises - Replace Bun.file().text() with Filesystem.readText() - Replace Bun.file().write() with Filesystem.write() - Replace Bun.file().arrayBuffer() and .type with Filesystem.readBytes() and mimeType() - Replace Bun.file().stat() with stat() from fs/promises All 18 project tests pass.
2026-02-18 23:04:19 +00:00 · 2026-02-18 17:53:44 -05:00 · 2026-02-18 10:48:28 -05:00
25 changed files with 289 additions and 1182 deletions
--- a/packages/console/app/package.json
+++ b/packages/console/app/package.json
@@ -7,7 +7,7 @@
    "typecheck": "tsgo --noEmit",
    "dev": "vite dev --host 0.0.0.0",
    "dev:remote": "VITE_AUTH_URL=https://auth.dev.opencode.ai VITE_STRIPE_PUBLISHABLE_KEY=pk_test_51RtuLNE7fOCwHSD4mewwzFejyytjdGoSDK7CAvhbffwaZnPbNb2rwJICw6LTOXCmWO320fSNXvb5NzI08RZVkAxd00syfqrW7t bun sst shell --stage=dev bun dev",
-    "build": "./script/generate-sitemap.ts && vite build && ../../opencode/script/schema.ts ./.output/public/config.json ./.output/public/tui.json",
+    "build": "./script/generate-sitemap.ts && vite build && ../../opencode/script/schema.ts ./.output/public/config.json",
    "start": "vite start"
  },
  "dependencies": {
--- a/packages/opencode/script/schema.ts
+++ b/packages/opencode/script/schema.ts
@@ -2,62 +2,46 @@

 import { z } from "zod"
 import { Config } from "../src/config/config"
-import { TuiConfig } from "../src/config/tui"

-function generate(schema: z.ZodType) {
-  const result = z.toJSONSchema(schema, {
-    io: "input", // Generate input shape (treats optional().default() as not required)
-    /**
-     * We'll use the `default` values of the field as the only value in `examples`.
-     * This will ensure no docs are needed to be read, as the configuration is
-     * self-documenting.
-     *
-     * See https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-00#rfc.section.9.5
-     */
-    override(ctx) {
-      const schema = ctx.jsonSchema
+const file = process.argv[2]
+console.log(file)

-      // Preserve strictness: set additionalProperties: false for objects
-      if (
-        schema &&
-        typeof schema === "object" &&
-        schema.type === "object" &&
-        schema.additionalProperties === undefined
-      ) {
-        schema.additionalProperties = false
+const result = z.toJSONSchema(Config.Info, {
+  io: "input", // Generate input shape (treats optional().default() as not required)
+  /**
+   * We'll use the `default` values of the field as the only value in `examples`.
+   * This will ensure no docs are needed to be read, as the configuration is
+   * self-documenting.
+   *
+   * See https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-00#rfc.section.9.5
+   */
+  override(ctx) {
+    const schema = ctx.jsonSchema
+
+    // Preserve strictness: set additionalProperties: false for objects
+    if (schema && typeof schema === "object" && schema.type === "object" && schema.additionalProperties === undefined) {
+      schema.additionalProperties = false
+    }
+
+    // Add examples and default descriptions for string fields with defaults
+    if (schema && typeof schema === "object" && "type" in schema && schema.type === "string" && schema?.default) {
+      if (!schema.examples) {
+        schema.examples = [schema.default]
      }

-      // Add examples and default descriptions for string fields with defaults
-      if (schema && typeof schema === "object" && "type" in schema && schema.type === "string" && schema?.default) {
-        if (!schema.examples) {
-          schema.examples = [schema.default]
-        }
-
-        schema.description = [schema.description || "", `default: \`${schema.default}\``]
-          .filter(Boolean)
-          .join("\n\n")
-          .trim()
-      }
-    },
-  }) as Record<string, unknown> & {
-    allowComments?: boolean
-    allowTrailingCommas?: boolean
-  }
-
-  // used for json lsps since config supports jsonc
-  result.allowComments = true
-  result.allowTrailingCommas = true
-
-  return result
+      schema.description = [schema.description || "", `default: \`${schema.default}\``]
+        .filter(Boolean)
+        .join("\n\n")
+        .trim()
+    }
+  },
+}) as Record<string, unknown> & {
+  allowComments?: boolean
+  allowTrailingCommas?: boolean
 }

-const configFile = process.argv[2]
-const tuiFile = process.argv[3]
+// used for json lsps since config supports jsonc
+result.allowComments = true
+result.allowTrailingCommas = true

-console.log(configFile)
-await Bun.write(configFile, JSON.stringify(generate(Config.Info), null, 2))
-
-if (tuiFile) {
-  console.log(tuiFile)
-  await Bun.write(tuiFile, JSON.stringify(generate(TuiConfig.Info), null, 2))
-}
+await Bun.write(file, JSON.stringify(result, null, 2))
--- a/packages/opencode/src/cli/cmd/tui/app.tsx
+++ b/packages/opencode/src/cli/cmd/tui/app.tsx
@@ -38,8 +38,6 @@ import { ArgsProvider, useArgs, type Args } from "./context/args"
 import open from "open"
 import { writeHeapSnapshot } from "v8"
 import { PromptRefProvider, usePromptRef } from "./context/prompt"
-import { TuiConfigProvider } from "./context/tui-config"
-import { TuiConfig } from "@/config/tui"

 async function getTerminalBackgroundColor(): Promise<"dark" | "light"> {
  // can't set raw mode if not a TTY
@@ -106,7 +104,6 @@ import type { EventSource } from "./context/sdk"
 export function tui(input: {
  url: string
  args: Args
-  config: TuiConfig.Info
  directory?: string
  fetch?: typeof fetch
  headers?: RequestInit["headers"]
@@ -141,37 +138,35 @@ export function tui(input: {
                <KVProvider>
                  <ToastProvider>
                    <RouteProvider>
-                      <TuiConfigProvider config={input.config}>
-                        <SDKProvider
-                          url={input.url}
-                          directory={input.directory}
-                          fetch={input.fetch}
-                          headers={input.headers}
-                          events={input.events}
-                        >
-                          <SyncProvider>
-                            <ThemeProvider mode={mode}>
-                              <LocalProvider>
-                                <KeybindProvider>
-                                  <PromptStashProvider>
-                                    <DialogProvider>
-                                      <CommandProvider>
-                                        <FrecencyProvider>
-                                          <PromptHistoryProvider>
-                                            <PromptRefProvider>
-                                              <App />
-                                            </PromptRefProvider>
-                                          </PromptHistoryProvider>
-                                        </FrecencyProvider>
-                                      </CommandProvider>
-                                    </DialogProvider>
-                                  </PromptStashProvider>
-                                </KeybindProvider>
-                              </LocalProvider>
-                            </ThemeProvider>
-                          </SyncProvider>
-                        </SDKProvider>
-                      </TuiConfigProvider>
+                      <SDKProvider
+                        url={input.url}
+                        directory={input.directory}
+                        fetch={input.fetch}
+                        headers={input.headers}
+                        events={input.events}
+                      >
+                        <SyncProvider>
+                          <ThemeProvider mode={mode}>
+                            <LocalProvider>
+                              <KeybindProvider>
+                                <PromptStashProvider>
+                                  <DialogProvider>
+                                    <CommandProvider>
+                                      <FrecencyProvider>
+                                        <PromptHistoryProvider>
+                                          <PromptRefProvider>
+                                            <App />
+                                          </PromptRefProvider>
+                                        </PromptHistoryProvider>
+                                      </FrecencyProvider>
+                                    </CommandProvider>
+                                  </DialogProvider>
+                                </PromptStashProvider>
+                              </KeybindProvider>
+                            </LocalProvider>
+                          </ThemeProvider>
+                        </SyncProvider>
+                      </SDKProvider>
                    </RouteProvider>
                  </ToastProvider>
                </KVProvider>
--- a/packages/opencode/src/cli/cmd/tui/attach.ts
+++ b/packages/opencode/src/cli/cmd/tui/attach.ts
@@ -2,9 +2,6 @@ import { cmd } from "../cmd"
 import { UI } from "@/cli/ui"
 import { tui } from "./app"
 import { win32DisableProcessedInput, win32InstallCtrlCGuard } from "./win32"
-import { TuiConfig } from "@/config/tui"
-import { Instance } from "@/project/instance"
-import { existsSync } from "fs"

 export const AttachCommand = cmd({
  command: "attach <url>",
@@ -66,13 +63,8 @@ export const AttachCommand = cmd({
        const auth = `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`
        return { Authorization: auth }
      })()
-      const config = await Instance.provide({
-        directory: directory && existsSync(directory) ? directory : process.cwd(),
-        fn: () => TuiConfig.get(),
-      })
      await tui({
        url: args.url,
-        config,
        args: {
          continue: args.continue,
          sessionID: args.session,
--- a/packages/opencode/src/cli/cmd/tui/component/tips.tsx
+++ b/packages/opencode/src/cli/cmd/tui/component/tips.tsx
@@ -80,11 +80,11 @@ const TIPS = [
  "Switch to {highlight}Plan{/highlight} agent to get suggestions without making actual changes",
  "Use {highlight}@agent-name{/highlight} in prompts to invoke specialized subagents",
  "Press {highlight}Ctrl+X Right/Left{/highlight} to cycle through parent and child sessions",
-  "Create {highlight}opencode.json{/highlight} for server settings and {highlight}tui.json{/highlight} for TUI settings",
-  "Place TUI settings in {highlight}~/.config/opencode/tui.json{/highlight} for global config",
+  "Create {highlight}opencode.json{/highlight} in project root for project-specific settings",
+  "Place settings in {highlight}~/.config/opencode/opencode.json{/highlight} for global config",
  "Add {highlight}$schema{/highlight} to your config for autocomplete in your editor",
  "Configure {highlight}model{/highlight} in config to set your default model",
-  "Override any keybind in {highlight}tui.json{/highlight} via the {highlight}keybinds{/highlight} section",
+  "Override any keybind in config via the {highlight}keybinds{/highlight} section",
  "Set any keybind to {highlight}none{/highlight} to disable it completely",
  "Configure local or remote MCP servers in the {highlight}mcp{/highlight} config section",
  "OpenCode auto-handles OAuth for remote MCP servers requiring auth",
@@ -140,7 +140,7 @@ const TIPS = [
  "Press {highlight}Ctrl+X G{/highlight} or {highlight}/timeline{/highlight} to jump to specific messages",
  "Press {highlight}Ctrl+X H{/highlight} to toggle code block visibility in messages",
  "Press {highlight}Ctrl+X S{/highlight} or {highlight}/status{/highlight} to see system status info",
-  "Enable {highlight}scroll_acceleration{/highlight} in {highlight}tui.json{/highlight} for smooth macOS-style scrolling",
+  "Enable {highlight}tui.scroll_acceleration{/highlight} for smooth macOS-style scrolling",
  "Toggle username display in chat via command palette ({highlight}Ctrl+P{/highlight})",
  "Run {highlight}docker run -it --rm ghcr.io/anomalyco/opencode{/highlight} for containerized use",
  "Use {highlight}/connect{/highlight} with OpenCode Zen for curated, tested models",
--- a/packages/opencode/src/cli/cmd/tui/context/keybind.tsx
+++ b/packages/opencode/src/cli/cmd/tui/context/keybind.tsx
@@ -1,4 +1,5 @@
 import { createMemo } from "solid-js"
+import { useSync } from "@tui/context/sync"
 import { Keybind } from "@/util/keybind"
 import { pipe, mapValues } from "remeda"
 import type { KeybindsConfig } from "@opencode-ai/sdk/v2"
@@ -6,15 +7,14 @@ import type { ParsedKey, Renderable } from "@opentui/core"
 import { createStore } from "solid-js/store"
 import { useKeyboard, useRenderer } from "@opentui/solid"
 import { createSimpleContext } from "./helper"
-import { useTuiConfig } from "./tui-config"

 export const { use: useKeybind, provider: KeybindProvider } = createSimpleContext({
  name: "Keybind",
  init: () => {
-    const config = useTuiConfig()
-    const keybinds = createMemo<Record<string, Keybind.Info[]>>(() => {
+    const sync = useSync()
+    const keybinds = createMemo(() => {
      return pipe(
-        (config.keybinds ?? {}) as Record<string, string>,
+        sync.data.config.keybinds ?? {},
        mapValues((value) => Keybind.parse(value)),
      )
    })
--- a/packages/opencode/src/cli/cmd/tui/context/theme.tsx
+++ b/packages/opencode/src/cli/cmd/tui/context/theme.tsx
@@ -1,6 +1,7 @@
 import { SyntaxStyle, RGBA, type TerminalColors } from "@opentui/core"
 import path from "path"
 import { createEffect, createMemo, onMount } from "solid-js"
+import { useSync } from "@tui/context/sync"
 import { createSimpleContext } from "./helper"
 import aura from "./theme/aura.json" with { type: "json" }
 import ayu from "./theme/ayu.json" with { type: "json" }
@@ -40,7 +41,6 @@ import { useRenderer } from "@opentui/solid"
 import { createStore, produce } from "solid-js/store"
 import { Global } from "@/global"
 import { Filesystem } from "@/util/filesystem"
-import { useTuiConfig } from "./tui-config"

 type ThemeColors = {
  primary: RGBA
@@ -279,17 +279,17 @@ function ansiToRgba(code: number): RGBA {
 export const { use: useTheme, provider: ThemeProvider } = createSimpleContext({
  name: "Theme",
  init: (props: { mode: "dark" | "light" }) => {
-    const config = useTuiConfig()
+    const sync = useSync()
    const kv = useKV()
    const [store, setStore] = createStore({
      themes: DEFAULT_THEMES,
      mode: kv.get("theme_mode", props.mode),
-      active: (config.theme ?? kv.get("theme", "opencode")) as string,
+      active: (sync.data.config.theme ?? kv.get("theme", "opencode")) as string,
      ready: false,
    })

    createEffect(() => {
-      const theme = config.theme
+      const theme = sync.data.config.theme
      if (theme) setStore("active", theme)
    })

--- a/packages/opencode/src/cli/cmd/tui/context/tui-config.tsx
+++ b/packages/opencode/src/cli/cmd/tui/context/tui-config.tsx
@@ -1,9 +0,0 @@
-import { TuiConfig } from "@/config/tui"
-import { createSimpleContext } from "./helper"
-
-export const { use: useTuiConfig, provider: TuiConfigProvider } = createSimpleContext({
-  name: "TuiConfig",
-  init: (props: { config: TuiConfig.Info }) => {
-    return props.config
-  },
-})
--- a/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
+++ b/packages/opencode/src/cli/cmd/tui/routes/session/index.tsx
@@ -78,7 +78,6 @@ import { QuestionPrompt } from "./question"
 import { DialogExportOptions } from "../../ui/dialog-export-options"
 import { formatTranscript } from "../../util/transcript"
 import { UI } from "@/cli/ui.ts"
-import { useTuiConfig } from "../../context/tui-config"

 addDefaultParsers(parsers.parsers)

@@ -101,7 +100,6 @@ const context = createContext<{
  showDetails: () => boolean
  diffWrapMode: () => "word" | "none"
  sync: ReturnType<typeof useSync>
-  tui: ReturnType<typeof useTuiConfig>
 }>()

 function use() {
@@ -114,7 +112,6 @@ export function Session() {
  const route = useRouteData("session")
  const { navigate } = useRoute()
  const sync = useSync()
-  const tuiConfig = useTuiConfig()
  const kv = useKV()
  const { theme } = useTheme()
  const promptRef = usePromptRef()
@@ -167,7 +164,7 @@ export function Session() {
  const contentWidth = createMemo(() => dimensions().width - (sidebarVisible() ? 42 : 0) - 4)

  const scrollAcceleration = createMemo(() => {
-    const tui = tuiConfig
+    const tui = sync.data.config.tui
    if (tui?.scroll_acceleration?.enabled) {
      return new MacOSScrollAccel()
    }
@@ -979,7 +976,6 @@ export function Session() {
        showDetails,
        diffWrapMode,
        sync,
-        tui: tuiConfig,
      }}
    >
      <box flexDirection="row">
@@ -1924,7 +1920,7 @@ function Edit(props: ToolProps<typeof EditTool>) {
  const { theme, syntax } = useTheme()

  const view = createMemo(() => {
-    const diffStyle = ctx.tui.diff_style
+    const diffStyle = ctx.sync.data.config.tui?.diff_style
    if (diffStyle === "stacked") return "unified"
    // Default to "auto" behavior
    return ctx.width > 120 ? "split" : "unified"
@@ -1995,7 +1991,7 @@ function ApplyPatch(props: ToolProps<typeof ApplyPatchTool>) {
  const files = createMemo(() => props.metadata.files ?? [])

  const view = createMemo(() => {
-    const diffStyle = ctx.tui.diff_style
+    const diffStyle = ctx.sync.data.config.tui?.diff_style
    if (diffStyle === "stacked") return "unified"
    return ctx.width > 120 ? "split" : "unified"
  })
--- a/packages/opencode/src/cli/cmd/tui/routes/session/permission.tsx
+++ b/packages/opencode/src/cli/cmd/tui/routes/session/permission.tsx
@@ -15,7 +15,6 @@ import { Keybind } from "@/util/keybind"
 import { Locale } from "@/util/locale"
 import { Global } from "@/global"
 import { useDialog } from "../../ui/dialog"
-import { useTuiConfig } from "../../context/tui-config"

 type PermissionStage = "permission" | "always" | "reject"

@@ -49,14 +48,14 @@ function EditBody(props: { request: PermissionRequest }) {
  const themeState = useTheme()
  const theme = themeState.theme
  const syntax = themeState.syntax
-  const config = useTuiConfig()
+  const sync = useSync()
  const dimensions = useTerminalDimensions()

  const filepath = createMemo(() => (props.request.metadata?.filepath as string) ?? "")
  const diff = createMemo(() => (props.request.metadata?.diff as string) ?? "")

  const view = createMemo(() => {
-    const diffStyle = config.diff_style
+    const diffStyle = sync.data.config.tui?.diff_style
    if (diffStyle === "stacked") return "unified"
    return dimensions().width > 120 ? "split" : "unified"
  })
--- a/packages/opencode/src/cli/cmd/tui/thread.ts
+++ b/packages/opencode/src/cli/cmd/tui/thread.ts
@@ -12,8 +12,6 @@ import { Filesystem } from "@/util/filesystem"
 import type { Event } from "@opencode-ai/sdk/v2"
 import type { EventSource } from "./context/sdk"
 import { win32DisableProcessedInput, win32InstallCtrlCGuard } from "./win32"
-import { TuiConfig } from "@/config/tui"
-import { Instance } from "@/project/instance"

 declare global {
  const OPENCODE_WORKER_PATH: string
@@ -137,10 +135,6 @@ export const TuiThreadCommand = cmd({
        if (!args.prompt) return piped
        return piped ? piped + "\n" + args.prompt : args.prompt
      })
-      const config = await Instance.provide({
-        directory: cwd,
-        fn: () => TuiConfig.get(),
-      })

      // Check if server should be started (port or hostname explicitly set in CLI or config)
      const networkOpts = await resolveNetworkOptions(args)
@@ -169,8 +163,6 @@ export const TuiThreadCommand = cmd({

      const tuiPromise = tui({
        url,
-        config,
-        directory: cwd,
        fetch: customFetch,
        events,
        args: {
--- a/packages/opencode/src/config/config.ts
+++ b/packages/opencode/src/config/config.ts
@@ -3,6 +3,7 @@ import path from "path"
 import { pathToFileURL } from "url"
 import os from "os"
 import z from "zod"
+import { Filesystem } from "../util/filesystem"
 import { ModelsDev } from "../provider/models"
 import { mergeDeep, pipe, unique } from "remeda"
 import { Global } from "../global"
@@ -31,8 +32,6 @@ import { PackageRegistry } from "@/bun/registry"
 import { proxied } from "@/util/proxied"
 import { iife } from "@/util/iife"
 import { Control } from "@/control"
-import { ConfigPaths } from "./paths"
-import { Filesystem } from "@/util/filesystem"

 export namespace Config {
  const ModelId = z.string().meta({ $ref: "https://models.dev/model-schema.json#/$defs/Model" })
@@ -41,7 +40,7 @@ export namespace Config {

  // Managed settings directory for enterprise deployments (highest priority, admin-controlled)
  // These settings override all user and project settings
-  function systemManagedConfigDir(): string {
+  function getManagedConfigDir(): string {
    switch (process.platform) {
      case "darwin":
        return "/Library/Application Support/opencode"
@@ -52,14 +51,10 @@ export namespace Config {
    }
  }

-  export function managedConfigDir() {
-    return process.env.OPENCODE_TEST_MANAGED_CONFIG_DIR || systemManagedConfigDir()
-  }
-
-  const managedDir = managedConfigDir()
+  const managedConfigDir = process.env.OPENCODE_TEST_MANAGED_CONFIG_DIR || getManagedConfigDir()

  // Custom merge function that concatenates array fields instead of replacing them
-  function mergeConfigConcatArrays(target: Info, source: Info): Info {
+  function merge(target: Info, source: Info): Info {
    const merged = mergeDeep(target, source)
    if (target.plugin && source.plugin) {
      merged.plugin = Array.from(new Set([...target.plugin, ...source.plugin]))
@@ -94,10 +89,7 @@ export namespace Config {
        const remoteConfig = wellknown.config ?? {}
        // Add $schema to prevent load() from trying to write back to a non-existent file
        if (!remoteConfig.$schema) remoteConfig.$schema = "https://opencode.ai/config.json"
-        result = mergeConfigConcatArrays(
-          result,
-          await load(JSON.stringify(remoteConfig), `${key}/.well-known/opencode`),
-        )
+        result = merge(result, await load(JSON.stringify(remoteConfig), `${key}/.well-known/opencode`))
        log.debug("loaded remote config from well-known", { url: key })
      }
    }
@@ -107,18 +99,21 @@ export namespace Config {
    }

    // Global user config overrides remote config.
-    result = mergeConfigConcatArrays(result, await global())
+    result = merge(result, await global())

    // Custom config path overrides global config.
    if (Flag.OPENCODE_CONFIG) {
-      result = mergeConfigConcatArrays(result, await loadFile(Flag.OPENCODE_CONFIG))
+      result = merge(result, await loadFile(Flag.OPENCODE_CONFIG))
      log.debug("loaded custom config", { path: Flag.OPENCODE_CONFIG })
    }

    // Project config overrides global and remote config.
    if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG) {
-      for (const file of await ConfigPaths.projectFiles("opencode", Instance.directory, Instance.worktree)) {
-        result = mergeConfigConcatArrays(result, await loadFile(file))
+      for (const file of ["opencode.jsonc", "opencode.json"]) {
+        const found = await Filesystem.findUp(file, Instance.directory, Instance.worktree)
+        for (const resolved of found.toReversed()) {
+          result = merge(result, await loadFile(resolved))
+        }
      }
    }

@@ -126,10 +121,31 @@ export namespace Config {
    result.mode = result.mode || {}
    result.plugin = result.plugin || []

-    const directories = await ConfigPaths.directories(Instance.directory, Instance.worktree)
+    const directories = [
+      Global.Path.config,
+      // Only scan project .opencode/ directories when project discovery is enabled
+      ...(!Flag.OPENCODE_DISABLE_PROJECT_CONFIG
+        ? await Array.fromAsync(
+            Filesystem.up({
+              targets: [".opencode"],
+              start: Instance.directory,
+              stop: Instance.worktree,
+            }),
+          )
+        : []),
+      // Always scan ~/.opencode/ (user home directory)
+      ...(await Array.fromAsync(
+        Filesystem.up({
+          targets: [".opencode"],
+          start: Global.Path.home,
+          stop: Global.Path.home,
+        }),
+      )),
+    ]

    // .opencode directory config overrides (project and global) config sources.
    if (Flag.OPENCODE_CONFIG_DIR) {
+      directories.push(Flag.OPENCODE_CONFIG_DIR)
      log.debug("loading config from OPENCODE_CONFIG_DIR", { path: Flag.OPENCODE_CONFIG_DIR })
    }

@@ -139,7 +155,7 @@ export namespace Config {
      if (dir.endsWith(".opencode") || dir === Flag.OPENCODE_CONFIG_DIR) {
        for (const file of ["opencode.jsonc", "opencode.json"]) {
          log.debug(`loading config from ${path.join(dir, file)}`)
-          result = mergeConfigConcatArrays(result, await loadFile(path.join(dir, file)))
+          result = merge(result, await loadFile(path.join(dir, file)))
          // to satisfy the type checker
          result.agent ??= {}
          result.mode ??= {}
@@ -162,7 +178,7 @@ export namespace Config {

    // Inline config content overrides all non-managed config sources.
    if (Flag.OPENCODE_CONFIG_CONTENT) {
-      result = mergeConfigConcatArrays(result, JSON.parse(Flag.OPENCODE_CONFIG_CONTENT))
+      result = merge(result, JSON.parse(Flag.OPENCODE_CONFIG_CONTENT))
      log.debug("loaded custom config from OPENCODE_CONFIG_CONTENT")
    }

@@ -170,9 +186,9 @@ export namespace Config {
    // Kept separate from directories array to avoid write operations when installing plugins
    // which would fail on system directories requiring elevated permissions
    // This way it only loads config file and not skills/plugins/commands
-    if (existsSync(managedDir)) {
+    if (existsSync(managedConfigDir)) {
      for (const file of ["opencode.jsonc", "opencode.json"]) {
-        result = mergeConfigConcatArrays(result, await loadFile(path.join(managedDir, file)))
+        result = merge(result, await loadFile(path.join(managedConfigDir, file)))
      }
    }

@@ -211,6 +227,8 @@ export namespace Config {
      result.share = "auto"
    }

+    if (!result.keybinds) result.keybinds = Info.shape.keybinds.parse({})
+
    // Apply flag overrides for compaction settings
    if (Flag.OPENCODE_DISABLE_AUTOCOMPACT) {
      result.compaction = { ...result.compaction, auto: false }
@@ -273,7 +291,7 @@ export namespace Config {
    }
  }

-  export async function needsInstall(dir: string) {
+  async function needsInstall(dir: string) {
    // Some config dirs may be read-only.
    // Installing deps there will fail; skip installation in that case.
    const writable = await isWritable(dir)
@@ -900,6 +918,20 @@ export namespace Config {
      ref: "KeybindsConfig",
    })

+  export const TUI = z.object({
+    scroll_speed: z.number().min(0.001).optional().describe("TUI scroll speed"),
+    scroll_acceleration: z
+      .object({
+        enabled: z.boolean().describe("Enable scroll acceleration"),
+      })
+      .optional()
+      .describe("Scroll acceleration settings"),
+    diff_style: z
+      .enum(["auto", "stacked"])
+      .optional()
+      .describe("Control diff rendering style: 'auto' adapts to terminal width, 'stacked' always shows single column"),
+  })
+
  export const Server = z
    .object({
      port: z.number().int().positive().optional().describe("Port to listen on"),
@@ -974,7 +1006,10 @@ export namespace Config {
  export const Info = z
    .object({
      $schema: z.string().optional().describe("JSON schema reference for configuration validation"),
+      theme: z.string().optional().describe("Theme name to use for the interface"),
+      keybinds: Keybinds.optional().describe("Custom keybind configurations"),
      logLevel: Log.Level.optional().describe("Log level"),
+      tui: TUI.optional().describe("TUI specific settings"),
      server: Server.optional().describe("Server configuration for opencode serve and web commands"),
      command: z
        .record(z.string(), Command)
@@ -1194,32 +1229,82 @@ export namespace Config {
    return result
  })

-  export const { readFile } = ConfigPaths
-
  async function loadFile(filepath: string): Promise<Info> {
    log.info("loading", { path: filepath })
-    const text = await readFile(filepath)
+    let text = await Filesystem.readText(filepath).catch((err: any) => {
+      if (err.code === "ENOENT") return
+      throw new JsonError({ path: filepath }, { cause: err })
+    })
    if (!text) return {}
    return load(text, filepath)
  }

  async function load(text: string, configFilepath: string) {
    const original = text
-    const data = await ConfigPaths.parseText(text, configFilepath)
+    text = text.replace(/\{env:([^}]+)\}/g, (_, varName) => {
+      return process.env[varName] || ""
+    })

-    const normalized = (() => {
-      if (!data || typeof data !== "object" || Array.isArray(data)) return data
-      const copy = { ...(data as Record<string, unknown>) }
-      const hadLegacy = "theme" in copy || "keybinds" in copy || "tui" in copy
-      if (!hadLegacy) return copy
-      delete copy.theme
-      delete copy.keybinds
-      delete copy.tui
-      log.warn("tui keys in opencode config are deprecated; move them to tui.json", { path: configFilepath })
-      return copy
-    })()
+    const fileMatches = text.match(/\{file:[^}]+\}/g)
+    if (fileMatches) {
+      const configDir = path.dirname(configFilepath)
+      const lines = text.split("\n")

-    const parsed = Info.safeParse(normalized)
+      for (const match of fileMatches) {
+        const lineIndex = lines.findIndex((line) => line.includes(match))
+        if (lineIndex !== -1 && lines[lineIndex].trim().startsWith("//")) {
+          continue // Skip if line is commented
+        }
+        let filePath = match.replace(/^\{file:/, "").replace(/\}$/, "")
+        if (filePath.startsWith("~/")) {
+          filePath = path.join(os.homedir(), filePath.slice(2))
+        }
+        const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(configDir, filePath)
+        const fileContent = (
+          await Filesystem.readText(resolvedPath).catch((error: any) => {
+            const errMsg = `bad file reference: "${match}"`
+            if (error.code === "ENOENT") {
+              throw new InvalidError(
+                {
+                  path: configFilepath,
+                  message: errMsg + ` ${resolvedPath} does not exist`,
+                },
+                { cause: error },
+              )
+            }
+            throw new InvalidError({ path: configFilepath, message: errMsg }, { cause: error })
+          })
+        ).trim()
+        // escape newlines/quotes, strip outer quotes
+        text = text.replace(match, () => JSON.stringify(fileContent).slice(1, -1))
+      }
+    }
+
+    const errors: JsoncParseError[] = []
+    const data = parseJsonc(text, errors, { allowTrailingComma: true })
+    if (errors.length) {
+      const lines = text.split("\n")
+      const errorDetails = errors
+        .map((e) => {
+          const beforeOffset = text.substring(0, e.offset).split("\n")
+          const line = beforeOffset.length
+          const column = beforeOffset[beforeOffset.length - 1].length + 1
+          const problemLine = lines[line - 1]
+
+          const error = `${printParseErrorCode(e.error)} at line ${line}, column ${column}`
+          if (!problemLine) return error
+
+          return `${error}\n   Line ${line}: ${problemLine}\n${"".padStart(column + 9)}^`
+        })
+        .join("\n")
+
+      throw new JsonError({
+        path: configFilepath,
+        message: `\n--- JSONC Input ---\n${text}\n--- Errors ---\n${errorDetails}\n--- End ---`,
+      })
+    }
+
+    const parsed = Info.safeParse(data)
    if (parsed.success) {
      if (!parsed.data.$schema) {
        parsed.data.$schema = "https://opencode.ai/config.json"
@@ -1244,7 +1329,13 @@ export namespace Config {
      issues: parsed.error.issues,
    })
  }
-  export const { JsonError, InvalidError } = ConfigPaths
+  export const JsonError = NamedError.create(
+    "ConfigJsonError",
+    z.object({
+      path: z.string(),
+      message: z.string().optional(),
+    }),
+  )

  export const ConfigDirectoryTypoError = NamedError.create(
    "ConfigDirectoryTypoError",
@@ -1255,6 +1346,15 @@ export namespace Config {
    }),
  )

+  export const InvalidError = NamedError.create(
+    "ConfigInvalidError",
+    z.object({
+      path: z.string(),
+      issues: z.custom<z.core.$ZodIssue[]>().optional(),
+      message: z.string().optional(),
+    }),
+  )
+
  export async function get() {
    return state().then((x) => x.config)
  }
--- a/packages/opencode/src/config/migrate-tui-config.ts
+++ b/packages/opencode/src/config/migrate-tui-config.ts
@@ -1,155 +0,0 @@
-import path from "path"
-import { applyEdits, modify, parse as parseJsonc } from "jsonc-parser"
-import { unique } from "remeda"
-import z from "zod"
-import { ConfigPaths } from "./paths"
-import { TuiInfo, TuiOptions } from "./tui-schema"
-import { Instance } from "@/project/instance"
-import { Flag } from "@/flag/flag"
-import { Log } from "@/util/log"
-import { Global } from "@/global"
-
-const log = Log.create({ service: "tui.migrate" })
-
-const TUI_SCHEMA_URL = "https://opencode.ai/tui.json"
-
-const LegacyTheme = TuiInfo.shape.theme.optional()
-const LegacyRecord = z.record(z.string(), z.unknown()).optional()
-
-const TuiLegacy = z
-  .object({
-    scroll_speed: TuiOptions.shape.scroll_speed.catch(undefined),
-    scroll_acceleration: TuiOptions.shape.scroll_acceleration.catch(undefined),
-    diff_style: TuiOptions.shape.diff_style.catch(undefined),
-  })
-  .strip()
-
-interface MigrateInput {
-  directories: string[]
-  custom?: string
-  managed: string
-}
-
-/**
- * Migrates tui-specific keys (theme, keybinds, tui) from opencode.json files
- * into dedicated tui.json files. Migration is performed per-directory and
- * skips only locations where a tui.json already exists.
- */
-export async function migrateTuiConfig(input: MigrateInput) {
-  const opencode = await opencodeFiles(input)
-  for (const file of opencode) {
-    const source = await Bun.file(file)
-      .text()
-      .catch((error) => {
-        log.warn("failed to read config for tui migration", { path: file, error })
-        return undefined
-      })
-    if (!source) continue
-    const data = parseJsonc(source)
-    if (!data || typeof data !== "object" || Array.isArray(data)) continue
-
-    const theme = LegacyTheme.safeParse("theme" in data ? data.theme : undefined)
-    const keybinds = LegacyRecord.safeParse("keybinds" in data ? data.keybinds : undefined)
-    const legacyTui = LegacyRecord.safeParse("tui" in data ? data.tui : undefined)
-    const extracted = {
-      theme: theme.success ? theme.data : undefined,
-      keybinds: keybinds.success ? keybinds.data : undefined,
-      tui: legacyTui.success ? legacyTui.data : undefined,
-    }
-    const tui = extracted.tui ? normalizeTui(extracted.tui) : undefined
-    if (extracted.theme === undefined && extracted.keybinds === undefined && !tui) continue
-
-    const target = path.join(path.dirname(file), "tui.json")
-    const targetExists = await Bun.file(target).exists()
-    if (targetExists) continue
-
-    const payload: Record<string, unknown> = {
-      $schema: TUI_SCHEMA_URL,
-    }
-    if (extracted.theme !== undefined) payload.theme = extracted.theme
-    if (extracted.keybinds !== undefined) payload.keybinds = extracted.keybinds
-    if (tui) Object.assign(payload, tui)
-
-    const wrote = await Bun.write(target, JSON.stringify(payload, null, 2))
-      .then(() => true)
-      .catch((error) => {
-        log.warn("failed to write tui migration target", { from: file, to: target, error })
-        return false
-      })
-    if (!wrote) continue
-
-    const stripped = await backupAndStripLegacy(file, source)
-    if (!stripped) {
-      log.warn("tui config migrated but source file was not stripped", { from: file, to: target })
-      continue
-    }
-    log.info("migrated tui config", { from: file, to: target })
-  }
-}
-
-function normalizeTui(data: Record<string, unknown>) {
-  const parsed = TuiLegacy.parse(data)
-  if (
-    parsed.scroll_speed === undefined &&
-    parsed.diff_style === undefined &&
-    parsed.scroll_acceleration === undefined
-  ) {
-    return
-  }
-  return parsed
-}
-
-async function backupAndStripLegacy(file: string, source: string) {
-  const backup = file + ".tui-migration.bak"
-  const hasBackup = await Bun.file(backup).exists()
-  const backed = hasBackup
-    ? true
-    : await Bun.write(backup, source)
-        .then(() => true)
-        .catch((error) => {
-          log.warn("failed to backup source config during tui migration", { path: file, backup, error })
-          return false
-        })
-  if (!backed) return false
-
-  const text = ["theme", "keybinds", "tui"].reduce((acc, key) => {
-    const edits = modify(acc, [key], undefined, {
-      formattingOptions: {
-        insertSpaces: true,
-        tabSize: 2,
-      },
-    })
-    if (!edits.length) return acc
-    return applyEdits(acc, edits)
-  }, source)
-
-  return Bun.write(file, text)
-    .then(() => {
-      log.info("stripped tui keys from server config", { path: file, backup })
-      return true
-    })
-    .catch((error) => {
-      log.warn("failed to strip legacy tui keys from server config", { path: file, backup, error })
-      return false
-    })
-}
-
-async function opencodeFiles(input: { directories: string[]; managed: string }) {
-  const project = Flag.OPENCODE_DISABLE_PROJECT_CONFIG
-    ? []
-    : await ConfigPaths.projectFiles("opencode", Instance.directory, Instance.worktree)
-  const files = [...project, ...ConfigPaths.fileInDirectory(Global.Path.config, "opencode")]
-  for (const dir of unique(input.directories)) {
-    files.push(...ConfigPaths.fileInDirectory(dir, "opencode"))
-  }
-  if (Flag.OPENCODE_CONFIG) files.push(Flag.OPENCODE_CONFIG)
-  files.push(...ConfigPaths.fileInDirectory(input.managed, "opencode"))
-
-  const existing = await Promise.all(
-    unique(files).map(async (file) => {
-      const ok = await Bun.file(file).exists()
-      return ok ? file : undefined
-    }),
-  )
-  return existing.filter((file): file is string => !!file)
-}
--- a/packages/opencode/src/config/paths.ts
+++ b/packages/opencode/src/config/paths.ts
@@ -1,154 +0,0 @@
-import path from "path"
-import os from "os"
-import z from "zod"
-import { type ParseError as JsoncParseError, parse as parseJsonc, printParseErrorCode } from "jsonc-parser"
-import { NamedError } from "@opencode-ai/util/error"
-import { Filesystem } from "@/util/filesystem"
-import { Flag } from "@/flag/flag"
-import { Global } from "@/global"
-
-export namespace ConfigPaths {
-  export async function projectFiles(name: string, directory: string, worktree: string) {
-    const files: string[] = []
-    for (const file of [`${name}.jsonc`, `${name}.json`]) {
-      const found = await Filesystem.findUp(file, directory, worktree)
-      for (const resolved of found.toReversed()) {
-        files.push(resolved)
-      }
-    }
-    return files
-  }
-
-  export async function directories(directory: string, worktree: string) {
-    return [
-      Global.Path.config,
-      ...(!Flag.OPENCODE_DISABLE_PROJECT_CONFIG
-        ? await Array.fromAsync(
-            Filesystem.up({
-              targets: [".opencode"],
-              start: directory,
-              stop: worktree,
-            }),
-          )
-        : []),
-      ...(await Array.fromAsync(
-        Filesystem.up({
-          targets: [".opencode"],
-          start: Global.Path.home,
-          stop: Global.Path.home,
-        }),
-      )),
-      ...(Flag.OPENCODE_CONFIG_DIR ? [Flag.OPENCODE_CONFIG_DIR] : []),
-    ]
-  }
-
-  export function fileInDirectory(dir: string, name: string) {
-    return [path.join(dir, `${name}.jsonc`), path.join(dir, `${name}.json`)]
-  }
-
-  export const JsonError = NamedError.create(
-    "ConfigJsonError",
-    z.object({
-      path: z.string(),
-      message: z.string().optional(),
-    }),
-  )
-
-  export const InvalidError = NamedError.create(
-    "ConfigInvalidError",
-    z.object({
-      path: z.string(),
-      issues: z.custom<z.core.$ZodIssue[]>().optional(),
-      message: z.string().optional(),
-    }),
-  )
-
-  /** Read a config file, returning undefined for missing files and throwing JsonError for other failures. */
-  export async function readFile(filepath: string) {
-    return Bun.file(filepath)
-      .text()
-      .catch((err) => {
-        if (err.code === "ENOENT") return
-        throw new JsonError({ path: filepath }, { cause: err })
-      })
-  }
-
-  /** Apply {env:VAR} and {file:path} substitutions to config text. */
-  async function substitute(text: string, configFilepath: string, missing: "error" | "empty" = "error") {
-    text = text.replace(/\{env:([^}]+)\}/g, (_, varName) => {
-      return process.env[varName] || ""
-    })
-
-    const fileMatches = text.match(/\{file:[^}]+\}/g)
-    if (!fileMatches) return text
-
-    const configDir = path.dirname(configFilepath)
-    const lines = text.split("\n")
-
-    for (const match of fileMatches) {
-      const lineIndex = lines.findIndex((line) => line.includes(match))
-      if (lineIndex !== -1 && lines[lineIndex].trim().startsWith("//")) continue
-
-      let filePath = match.replace(/^\{file:/, "").replace(/\}$/, "")
-      if (filePath.startsWith("~/")) {
-        filePath = path.join(os.homedir(), filePath.slice(2))
-      }
-
-      const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(configDir, filePath)
-      const fileContent = (
-        await Bun.file(resolvedPath)
-          .text()
-          .catch((error) => {
-            if (missing === "empty") return ""
-
-            const errMsg = `bad file reference: "${match}"`
-            if (error.code === "ENOENT") {
-              throw new InvalidError(
-                {
-                  path: configFilepath,
-                  message: errMsg + ` ${resolvedPath} does not exist`,
-                },
-                { cause: error },
-              )
-            }
-            throw new InvalidError({ path: configFilepath, message: errMsg }, { cause: error })
-          })
-      ).trim()
-
-      text = text.replace(match, () => JSON.stringify(fileContent).slice(1, -1))
-    }
-
-    return text
-  }
-
-  /** Substitute and parse JSONC text, throwing JsonError on syntax errors. */
-  export async function parseText(text: string, configFilepath: string, missing: "error" | "empty" = "error") {
-    text = await substitute(text, configFilepath, missing)
-
-    const errors: JsoncParseError[] = []
-    const data = parseJsonc(text, errors, { allowTrailingComma: true })
-    if (errors.length) {
-      const lines = text.split("\n")
-      const errorDetails = errors
-        .map((e) => {
-          const beforeOffset = text.substring(0, e.offset).split("\n")
-          const line = beforeOffset.length
-          const column = beforeOffset[beforeOffset.length - 1].length + 1
-          const problemLine = lines[line - 1]
-
-          const error = `${printParseErrorCode(e.error)} at line ${line}, column ${column}`
-          if (!problemLine) return error
-
-          return `${error}\n   Line ${line}: ${problemLine}\n${"".padStart(column + 9)}^`
-        })
-        .join("\n")
-
-      throw new JsonError({
-        path: configFilepath,
-        message: `\n--- JSONC Input ---\n${text}\n--- Errors ---\n${errorDetails}\n--- End ---`,
-      })
-    }
-
-    return data
-  }
-}
--- a/packages/opencode/src/config/tui-schema.ts
+++ b/packages/opencode/src/config/tui-schema.ts
@@ -1,25 +0,0 @@
-import z from "zod"
-import { Config } from "./config"
-
-export const TuiOptions = z.object({
-  scroll_speed: z.number().min(0.001).optional().describe("TUI scroll speed"),
-  scroll_acceleration: z
-    .object({
-      enabled: z.boolean().describe("Enable scroll acceleration"),
-    })
-    .optional()
-    .describe("Scroll acceleration settings"),
-  diff_style: z
-    .enum(["auto", "stacked"])
-    .optional()
-    .describe("Control diff rendering style: 'auto' adapts to terminal width, 'stacked' always shows single column"),
-})
-
-export const TuiInfo = z
-  .object({
-    $schema: z.string().optional(),
-    theme: z.string().optional(),
-    keybinds: Config.Keybinds.optional(),
-  })
-  .extend(TuiOptions.shape)
-  .strict()
--- a/packages/opencode/src/config/tui.ts
+++ b/packages/opencode/src/config/tui.ts
@@ -1,118 +0,0 @@
-import { existsSync } from "fs"
-import z from "zod"
-import { mergeDeep, unique } from "remeda"
-import { Config } from "./config"
-import { ConfigPaths } from "./paths"
-import { migrateTuiConfig } from "./migrate-tui-config"
-import { TuiInfo } from "./tui-schema"
-import { Instance } from "@/project/instance"
-import { Flag } from "@/flag/flag"
-import { Log } from "@/util/log"
-import { Global } from "@/global"
-
-export namespace TuiConfig {
-  const log = Log.create({ service: "tui.config" })
-
-  export const Info = TuiInfo
-
-  export type Info = z.output<typeof Info>
-
-  function mergeInfo(target: Info, source: Info): Info {
-    return mergeDeep(target, source)
-  }
-
-  function customPath() {
-    return Flag.OPENCODE_TUI_CONFIG
-  }
-
-  const state = Instance.state(async () => {
-    let projectFiles = Flag.OPENCODE_DISABLE_PROJECT_CONFIG
-      ? []
-      : await ConfigPaths.projectFiles("tui", Instance.directory, Instance.worktree)
-    const directories = await ConfigPaths.directories(Instance.directory, Instance.worktree)
-    const custom = customPath()
-    const managed = Config.managedConfigDir()
-    await migrateTuiConfig({ directories, custom, managed })
-    // Re-compute after migration since migrateTuiConfig may have created new tui.json files
-    projectFiles = Flag.OPENCODE_DISABLE_PROJECT_CONFIG
-      ? []
-      : await ConfigPaths.projectFiles("tui", Instance.directory, Instance.worktree)
-
-    let result: Info = {}
-
-    for (const file of ConfigPaths.fileInDirectory(Global.Path.config, "tui")) {
-      result = mergeInfo(result, await loadFile(file))
-    }
-
-    if (custom) {
-      result = mergeInfo(result, await loadFile(custom))
-      log.debug("loaded custom tui config", { path: custom })
-    }
-
-    for (const file of projectFiles) {
-      result = mergeInfo(result, await loadFile(file))
-    }
-
-    for (const dir of unique(directories)) {
-      if (!dir.endsWith(".opencode") && dir !== Flag.OPENCODE_CONFIG_DIR) continue
-      for (const file of ConfigPaths.fileInDirectory(dir, "tui")) {
-        result = mergeInfo(result, await loadFile(file))
-      }
-    }
-
-    if (existsSync(managed)) {
-      for (const file of ConfigPaths.fileInDirectory(managed, "tui")) {
-        result = mergeInfo(result, await loadFile(file))
-      }
-    }
-
-    result.keybinds ??= Config.Keybinds.parse({})
-
-    return {
-      config: result,
-    }
-  })
-
-  export async function get() {
-    return state().then((x) => x.config)
-  }
-
-  async function loadFile(filepath: string): Promise<Info> {
-    const text = await ConfigPaths.readFile(filepath)
-    if (!text) return {}
-    return load(text, filepath).catch((error) => {
-      log.warn("failed to load tui config", { path: filepath, error })
-      return {}
-    })
-  }
-
-  async function load(text: string, configFilepath: string): Promise<Info> {
-    const data = await ConfigPaths.parseText(text, configFilepath, "empty")
-    if (!data || typeof data !== "object" || Array.isArray(data)) return {}
-
-    // Flatten a nested "tui" key so users who wrote `{ "tui": { ... } }` inside tui.json
-    // (mirroring the old opencode.json shape) still get their settings applied.
-    const normalized = (() => {
-      const copy = { ...(data as Record<string, unknown>) }
-      if (!("tui" in copy)) return copy
-      if (!copy.tui || typeof copy.tui !== "object" || Array.isArray(copy.tui)) {
-        delete copy.tui
-        return copy
-      }
-      const tui = copy.tui as Record<string, unknown>
-      delete copy.tui
-      return {
-        ...tui,
-        ...copy,
-      }
-    })()
-
-    const parsed = Info.safeParse(normalized)
-    if (!parsed.success) {
-      log.warn("invalid tui config", { path: configFilepath, issues: parsed.error.issues })
-      return {}
-    }
-
-    return parsed.data
-  }
-}
--- a/packages/opencode/src/flag/flag.ts
+++ b/packages/opencode/src/flag/flag.ts
@@ -7,7 +7,6 @@ export namespace Flag {
  export const OPENCODE_AUTO_SHARE = truthy("OPENCODE_AUTO_SHARE")
  export const OPENCODE_GIT_BASH_PATH = process.env["OPENCODE_GIT_BASH_PATH"]
  export const OPENCODE_CONFIG = process.env["OPENCODE_CONFIG"]
-  export declare const OPENCODE_TUI_CONFIG: string | undefined
  export declare const OPENCODE_CONFIG_DIR: string | undefined
  export const OPENCODE_CONFIG_CONTENT = process.env["OPENCODE_CONFIG_CONTENT"]
  export const OPENCODE_DISABLE_AUTOUPDATE = truthy("OPENCODE_DISABLE_AUTOUPDATE")
@@ -75,17 +74,6 @@ Object.defineProperty(Flag, "OPENCODE_DISABLE_PROJECT_CONFIG", {
  configurable: false,
 })

-// Dynamic getter for OPENCODE_TUI_CONFIG
-// This must be evaluated at access time, not module load time,
-// because tests and external tooling may set this env var at runtime
-Object.defineProperty(Flag, "OPENCODE_TUI_CONFIG", {
-  get() {
-    return process.env["OPENCODE_TUI_CONFIG"]
-  },
-  enumerable: true,
-  configurable: false,
-})
-
 // Dynamic getter for OPENCODE_CONFIG_DIR
 // This must be evaluated at access time, not module load time,
 // because external tooling may set this env var at runtime
--- a/packages/opencode/src/project/project.ts
+++ b/packages/opencode/src/project/project.ts
@@ -1,6 +1,7 @@
 import z from "zod"
 import { Filesystem } from "../util/filesystem"
 import path from "path"
+import { stat } from "fs/promises"
 import { Database, eq } from "../storage/db"
 import { ProjectTable } from "./project.sql"
 import { SessionTable } from "../session/session.sql"
@@ -86,8 +87,7 @@ export namespace Project {
        const gitBinary = Bun.which("git")

        // cached id calculation
-        let id = await Bun.file(path.join(dotgit, "opencode"))
-          .text()
+        let id = await Filesystem.readText(path.join(dotgit, "opencode"))
          .then((x) => x.trim())
          .catch(() => undefined)

@@ -125,9 +125,7 @@ export namespace Project {

          id = roots[0]
          if (id) {
-            void Bun.file(path.join(dotgit, "opencode"))
-              .write(id)
-              .catch(() => undefined)
+            void Filesystem.write(path.join(dotgit, "opencode"), id).catch(() => undefined)
          }
        }

@@ -277,10 +275,9 @@ export namespace Project {
    )
    const shortest = matches.sort((a, b) => a.length - b.length)[0]
    if (!shortest) return
-    const file = Bun.file(shortest)
-    const buffer = await file.arrayBuffer()
-    const base64 = Buffer.from(buffer).toString("base64")
-    const mime = file.type || "image/png"
+    const buffer = await Filesystem.readBytes(shortest)
+    const base64 = buffer.toString("base64")
+    const mime = Filesystem.mimeType(shortest) || "image/png"
    const url = `data:${mime};base64,${base64}`
    await update({
      projectID: input.id,
@@ -381,10 +378,8 @@ export namespace Project {
    const data = fromRow(row)
    const valid: string[] = []
    for (const dir of data.sandboxes) {
-      const stat = await Bun.file(dir)
-        .stat()
-        .catch(() => undefined)
-      if (stat?.isDirectory()) valid.push(dir)
+      const s = await stat(dir).catch(() => undefined)
+      if (s?.isDirectory()) valid.push(dir)
    }
    return valid
  }
--- a/packages/opencode/test/config/config.test.ts
+++ b/packages/opencode/test/config/config.test.ts
@@ -55,28 +55,6 @@ test("loads JSON config file", async () => {
  })
 })

-test("ignores legacy tui keys in opencode config", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await writeConfig(dir, {
-        $schema: "https://opencode.ai/config.json",
-        model: "test/model",
-        theme: "legacy",
-        tui: { scroll_speed: 4 },
-      })
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await Config.get()
-      expect(config.model).toBe("test/model")
-      expect((config as Record<string, unknown>).theme).toBeUndefined()
-      expect((config as Record<string, unknown>).tui).toBeUndefined()
-    },
-  })
-})
-
 test("loads JSONC config file", async () => {
  await using tmp = await tmpdir({
    init: async (dir) => {
@@ -131,14 +109,14 @@ test("merges multiple config files with correct precedence", async () => {

 test("handles environment variable substitution", async () => {
  const originalEnv = process.env["TEST_VAR"]
-  process.env["TEST_VAR"] = "test-user"
+  process.env["TEST_VAR"] = "test_theme"

  try {
    await using tmp = await tmpdir({
      init: async (dir) => {
        await writeConfig(dir, {
          $schema: "https://opencode.ai/config.json",
-          username: "{env:TEST_VAR}",
+          theme: "{env:TEST_VAR}",
        })
      },
    })
@@ -146,7 +124,7 @@ test("handles environment variable substitution", async () => {
      directory: tmp.path,
      fn: async () => {
        const config = await Config.get()
-        expect(config.username).toBe("test-user")
+        expect(config.theme).toBe("test_theme")
      },
    })
  } finally {
@@ -169,7 +147,7 @@ test("preserves env variables when adding $schema to config", async () => {
        await Bun.write(
          path.join(dir, "opencode.json"),
          JSON.stringify({
-            username: "{env:PRESERVE_VAR}",
+            theme: "{env:PRESERVE_VAR}",
          }),
        )
      },
@@ -178,7 +156,7 @@ test("preserves env variables when adding $schema to config", async () => {
      directory: tmp.path,
      fn: async () => {
        const config = await Config.get()
-        expect(config.username).toBe("secret_value")
+        expect(config.theme).toBe("secret_value")

        // Read the file to verify the env variable was preserved
        const content = await Bun.file(path.join(tmp.path, "opencode.json")).text()
@@ -199,10 +177,10 @@ test("preserves env variables when adding $schema to config", async () => {
 test("handles file inclusion substitution", async () => {
  await using tmp = await tmpdir({
    init: async (dir) => {
-      await Bun.write(path.join(dir, "included.txt"), "test-user")
+      await Bun.write(path.join(dir, "included.txt"), "test_theme")
      await writeConfig(dir, {
        $schema: "https://opencode.ai/config.json",
-        username: "{file:included.txt}",
+        theme: "{file:included.txt}",
      })
    },
  })
@@ -210,7 +188,7 @@ test("handles file inclusion substitution", async () => {
    directory: tmp.path,
    fn: async () => {
      const config = await Config.get()
-      expect(config.username).toBe("test-user")
+      expect(config.theme).toBe("test_theme")
    },
  })
 })
@@ -221,7 +199,7 @@ test("handles file inclusion with replacement tokens", async () => {
      await Bun.write(path.join(dir, "included.md"), "const out = await Bun.$`echo hi`")
      await writeConfig(dir, {
        $schema: "https://opencode.ai/config.json",
-        username: "{file:included.md}",
+        theme: "{file:included.md}",
      })
    },
  })
@@ -229,7 +207,7 @@ test("handles file inclusion with replacement tokens", async () => {
    directory: tmp.path,
    fn: async () => {
      const config = await Config.get()
-      expect(config.username).toBe("const out = await Bun.$`echo hi`")
+      expect(config.theme).toBe("const out = await Bun.$`echo hi`")
    },
  })
 })
@@ -1064,6 +1042,7 @@ test("managed settings override project settings", async () => {
        $schema: "https://opencode.ai/config.json",
        autoupdate: true,
        disabled_providers: [],
+        theme: "dark",
      })
    },
  })
@@ -1080,6 +1059,7 @@ test("managed settings override project settings", async () => {
      const config = await Config.get()
      expect(config.autoupdate).toBe(false)
      expect(config.disabled_providers).toEqual(["openai"])
+      expect(config.theme).toBe("dark")
    },
  })
 })
--- a/packages/opencode/test/config/tui.test.ts
+++ b/packages/opencode/test/config/tui.test.ts
@@ -1,439 +0,0 @@
-import { afterEach, expect, test } from "bun:test"
-import path from "path"
-import fs from "fs/promises"
-import { tmpdir } from "../fixture/fixture"
-import { Instance } from "../../src/project/instance"
-import { TuiConfig } from "../../src/config/tui"
-import { Global } from "../../src/global"
-
-const managedConfigDir = process.env.OPENCODE_TEST_MANAGED_CONFIG_DIR!
-
-afterEach(async () => {
-  delete process.env.OPENCODE_CONFIG
-  delete process.env.OPENCODE_TUI_CONFIG
-  await fs.rm(path.join(Global.Path.config, "tui.json"), { force: true }).catch(() => {})
-  await fs.rm(path.join(Global.Path.config, "tui.jsonc"), { force: true }).catch(() => {})
-  await fs.rm(managedConfigDir, { force: true, recursive: true }).catch(() => {})
-})
-
-test("loads tui config with the same precedence order as server config paths", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(path.join(Global.Path.config, "tui.json"), JSON.stringify({ theme: "global" }, null, 2))
-      await Bun.write(path.join(dir, "tui.json"), JSON.stringify({ theme: "project" }, null, 2))
-      await fs.mkdir(path.join(dir, ".opencode"), { recursive: true })
-      await Bun.write(
-        path.join(dir, ".opencode", "tui.json"),
-        JSON.stringify({ theme: "local", diff_style: "stacked" }, null, 2),
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.theme).toBe("local")
-      expect(config.diff_style).toBe("stacked")
-    },
-  })
-})
-
-test("migrates tui-specific keys from opencode.json when tui.json does not exist", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(
-        path.join(dir, "opencode.json"),
-        JSON.stringify(
-          {
-            theme: "migrated-theme",
-            tui: { scroll_speed: 5 },
-            keybinds: { app_exit: "ctrl+q" },
-          },
-          null,
-          2,
-        ),
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.theme).toBe("migrated-theme")
-      expect(config.scroll_speed).toBe(5)
-      expect(config.keybinds?.app_exit).toBe("ctrl+q")
-      const text = await Bun.file(path.join(tmp.path, "tui.json")).text()
-      expect(JSON.parse(text)).toMatchObject({
-        theme: "migrated-theme",
-        scroll_speed: 5,
-      })
-      const server = JSON.parse(await Bun.file(path.join(tmp.path, "opencode.json")).text())
-      expect(server.theme).toBeUndefined()
-      expect(server.keybinds).toBeUndefined()
-      expect(server.tui).toBeUndefined()
-      expect(await Bun.file(path.join(tmp.path, "opencode.json.tui-migration.bak")).exists()).toBe(true)
-      expect(await Bun.file(path.join(tmp.path, "tui.json")).exists()).toBe(true)
-    },
-  })
-})
-
-test("migrates project legacy tui keys even when global tui.json already exists", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(path.join(Global.Path.config, "tui.json"), JSON.stringify({ theme: "global" }, null, 2))
-      await Bun.write(
-        path.join(dir, "opencode.json"),
-        JSON.stringify(
-          {
-            theme: "project-migrated",
-            tui: { scroll_speed: 2 },
-          },
-          null,
-          2,
-        ),
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.theme).toBe("project-migrated")
-      expect(config.scroll_speed).toBe(2)
-      expect(await Bun.file(path.join(tmp.path, "tui.json")).exists()).toBe(true)
-
-      const server = JSON.parse(await Bun.file(path.join(tmp.path, "opencode.json")).text())
-      expect(server.theme).toBeUndefined()
-      expect(server.tui).toBeUndefined()
-    },
-  })
-})
-
-test("drops unknown legacy tui keys during migration", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(
-        path.join(dir, "opencode.json"),
-        JSON.stringify(
-          {
-            theme: "migrated-theme",
-            tui: { scroll_speed: 2, foo: 1 },
-          },
-          null,
-          2,
-        ),
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.theme).toBe("migrated-theme")
-      expect(config.scroll_speed).toBe(2)
-
-      const text = await Bun.file(path.join(tmp.path, "tui.json")).text()
-      const migrated = JSON.parse(text)
-      expect(migrated.scroll_speed).toBe(2)
-      expect(migrated.foo).toBeUndefined()
-    },
-  })
-})
-
-test("skips migration when tui.json already exists", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(path.join(dir, "opencode.json"), JSON.stringify({ theme: "legacy" }, null, 2))
-      await Bun.write(path.join(dir, "tui.json"), JSON.stringify({ diff_style: "stacked" }, null, 2))
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.diff_style).toBe("stacked")
-      expect(config.theme).toBeUndefined()
-
-      const server = JSON.parse(await Bun.file(path.join(tmp.path, "opencode.json")).text())
-      expect(server.theme).toBe("legacy")
-      expect(await Bun.file(path.join(tmp.path, "opencode.json.tui-migration.bak")).exists()).toBe(false)
-    },
-  })
-})
-
-test("continues loading tui config when legacy source cannot be stripped", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(path.join(dir, "opencode.json"), JSON.stringify({ theme: "readonly-theme" }, null, 2))
-    },
-  })
-
-  const source = path.join(tmp.path, "opencode.json")
-  await fs.chmod(source, 0o444)
-
-  try {
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const config = await TuiConfig.get()
-        expect(config.theme).toBe("readonly-theme")
-        expect(await Bun.file(path.join(tmp.path, "tui.json")).exists()).toBe(true)
-
-        const server = JSON.parse(await Bun.file(source).text())
-        expect(server.theme).toBe("readonly-theme")
-      },
-    })
-  } finally {
-    await fs.chmod(source, 0o644)
-  }
-})
-
-test("migration backup preserves JSONC comments", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(
-        path.join(dir, "opencode.jsonc"),
-        `{
-  // top-level comment
-  "theme": "jsonc-theme",
-  "tui": {
-    // nested comment
-    "scroll_speed": 1.5
-  }
-}`,
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      await TuiConfig.get()
-      const backup = await Bun.file(path.join(tmp.path, "opencode.jsonc.tui-migration.bak")).text()
-      expect(backup).toContain("// top-level comment")
-      expect(backup).toContain("// nested comment")
-      expect(backup).toContain('"theme": "jsonc-theme"')
-      expect(backup).toContain('"scroll_speed": 1.5')
-    },
-  })
-})
-
-test("migrates legacy tui keys across multiple opencode.json levels", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      const nested = path.join(dir, "apps", "client")
-      await fs.mkdir(nested, { recursive: true })
-      await Bun.write(path.join(dir, "opencode.json"), JSON.stringify({ theme: "root-theme" }, null, 2))
-      await Bun.write(path.join(nested, "opencode.json"), JSON.stringify({ theme: "nested-theme" }, null, 2))
-    },
-  })
-
-  await Instance.provide({
-    directory: path.join(tmp.path, "apps", "client"),
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.theme).toBe("nested-theme")
-      expect(await Bun.file(path.join(tmp.path, "tui.json")).exists()).toBe(true)
-      expect(await Bun.file(path.join(tmp.path, "apps", "client", "tui.json")).exists()).toBe(true)
-    },
-  })
-})
-
-test("flattens nested tui key inside tui.json", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(
-        path.join(dir, "tui.json"),
-        JSON.stringify({
-          theme: "outer",
-          tui: { scroll_speed: 3, diff_style: "stacked" },
-        }),
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.scroll_speed).toBe(3)
-      expect(config.diff_style).toBe("stacked")
-      // top-level keys take precedence over nested tui keys
-      expect(config.theme).toBe("outer")
-    },
-  })
-})
-
-test("top-level keys in tui.json take precedence over nested tui key", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(
-        path.join(dir, "tui.json"),
-        JSON.stringify({
-          diff_style: "auto",
-          tui: { diff_style: "stacked", scroll_speed: 2 },
-        }),
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.diff_style).toBe("auto")
-      expect(config.scroll_speed).toBe(2)
-    },
-  })
-})
-
-test("OPENCODE_TUI_CONFIG takes precedence over project config", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(path.join(dir, "tui.json"), JSON.stringify({ theme: "project", diff_style: "auto" }))
-      const custom = path.join(dir, "custom-tui.json")
-      await Bun.write(custom, JSON.stringify({ theme: "custom", diff_style: "stacked" }))
-      process.env.OPENCODE_TUI_CONFIG = custom
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      // project tui.json overrides the custom path (higher precedence)
-      expect(config.theme).toBe("project")
-      // but project also set diff_style, so that wins
-      expect(config.diff_style).toBe("auto")
-    },
-  })
-})
-
-test("OPENCODE_TUI_CONFIG provides settings when no project config exists", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      const custom = path.join(dir, "custom-tui.json")
-      await Bun.write(custom, JSON.stringify({ theme: "from-env", diff_style: "stacked" }))
-      process.env.OPENCODE_TUI_CONFIG = custom
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.theme).toBe("from-env")
-      expect(config.diff_style).toBe("stacked")
-    },
-  })
-})
-
-test("does not derive tui path from OPENCODE_CONFIG", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      const customDir = path.join(dir, "custom")
-      await fs.mkdir(customDir, { recursive: true })
-      await Bun.write(path.join(customDir, "opencode.json"), JSON.stringify({ model: "test/model" }))
-      await Bun.write(path.join(customDir, "tui.json"), JSON.stringify({ theme: "should-not-load" }))
-      process.env.OPENCODE_CONFIG = path.join(customDir, "opencode.json")
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.theme).toBeUndefined()
-    },
-  })
-})
-
-test("applies env and file substitutions in tui.json", async () => {
-  const original = process.env.TUI_THEME_TEST
-  process.env.TUI_THEME_TEST = "env-theme"
-  try {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "keybind.txt"), "ctrl+q")
-        await Bun.write(
-          path.join(dir, "tui.json"),
-          JSON.stringify({
-            theme: "{env:TUI_THEME_TEST}",
-            keybinds: { app_exit: "{file:keybind.txt}" },
-          }),
-        )
-      },
-    })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const config = await TuiConfig.get()
-        expect(config.theme).toBe("env-theme")
-        expect(config.keybinds?.app_exit).toBe("ctrl+q")
-      },
-    })
-  } finally {
-    if (original === undefined) delete process.env.TUI_THEME_TEST
-    else process.env.TUI_THEME_TEST = original
-  }
-})
-
-test("loads managed tui config and gives it highest precedence", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(path.join(dir, "tui.json"), JSON.stringify({ theme: "project-theme" }, null, 2))
-      await fs.mkdir(managedConfigDir, { recursive: true })
-      await Bun.write(path.join(managedConfigDir, "tui.json"), JSON.stringify({ theme: "managed-theme" }, null, 2))
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.theme).toBe("managed-theme")
-    },
-  })
-})
-
-test("loads .opencode/tui.json", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await fs.mkdir(path.join(dir, ".opencode"), { recursive: true })
-      await Bun.write(path.join(dir, ".opencode", "tui.json"), JSON.stringify({ diff_style: "stacked" }, null, 2))
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.diff_style).toBe("stacked")
-    },
-  })
-})
-
-test("gracefully falls back when tui.json has invalid JSON", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(path.join(dir, "tui.json"), "{ invalid json }")
-      await fs.mkdir(managedConfigDir, { recursive: true })
-      await Bun.write(path.join(managedConfigDir, "tui.json"), JSON.stringify({ theme: "managed-fallback" }, null, 2))
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const config = await TuiConfig.get()
-      expect(config.theme).toBe("managed-fallback")
-      expect(config.keybinds).toBeDefined()
-    },
-  })
-})
--- a/packages/web/src/content/docs/cli.mdx
+++ b/packages/web/src/content/docs/cli.mdx
@@ -558,7 +558,6 @@ OpenCode can be configured using environment variables.
 | `OPENCODE_AUTO_SHARE`                 | boolean | Automatically share sessions                      |
 | `OPENCODE_GIT_BASH_PATH`              | string  | Path to Git Bash executable on Windows            |
 | `OPENCODE_CONFIG`                     | string  | Path to config file                               |
-| `OPENCODE_TUI_CONFIG`                 | string  | Path to TUI config file                           |
 | `OPENCODE_CONFIG_DIR`                 | string  | Path to config directory                          |
 | `OPENCODE_CONFIG_CONTENT`             | string  | Inline json config content                        |
 | `OPENCODE_DISABLE_AUTOUPDATE`         | boolean | Disable automatic update checks                   |
--- a/packages/web/src/content/docs/config.mdx
+++ b/packages/web/src/content/docs/config.mdx
@@ -14,11 +14,10 @@ OpenCode supports both **JSON** and **JSONC** (JSON with Comments) formats.
 ```jsonc title="opencode.jsonc"
 {
  "$schema": "https://opencode.ai/config.json",
+  // Theme configuration
+  "theme": "opencode",
  "model": "anthropic/claude-sonnet-4-5",
  "autoupdate": true,
-  "server": {
-    "port": 4096,
-  },
 }
 ```

@@ -35,7 +34,7 @@ Configuration files are **merged together**, not replaced.

 Configuration files are merged together, not replaced. Settings from the following config locations are combined. Later configs override earlier ones only for conflicting keys. Non-conflicting settings from all configs are preserved.

-For example, if your global config sets `autoupdate: true` and your project config sets `model: "anthropic/claude-sonnet-4-5"`, the final configuration will include both settings.
+For example, if your global config sets `theme: "opencode"` and `autoupdate: true`, and your project config sets `model: "anthropic/claude-sonnet-4-5"`, the final configuration will include all three settings.

 ---

@@ -96,9 +95,7 @@ You can enable specific servers in your local config:

 ### Global

-Place your global OpenCode config in `~/.config/opencode/opencode.json`. Use global config for user-wide server/runtime preferences like providers, models, and permissions.
-
-For TUI-specific settings, use `~/.config/opencode/tui.json`.
+Place your global OpenCode config in `~/.config/opencode/opencode.json`. Use global config for user-wide preferences like themes, providers, or keybinds.

 Global config overrides remote organizational defaults.

@@ -108,8 +105,6 @@ Global config overrides remote organizational defaults.

 Add `opencode.json` in your project root. Project config has the highest precedence among standard config files - it overrides both global and remote configs.

-For project-specific TUI settings, add `tui.json` alongside it.
-
 :::tip
 Place project specific config in the root of your project.
 :::
@@ -151,9 +146,7 @@ The custom directory is loaded after the global config and `.opencode` directori

 ## Schema

-The server/runtime config schema is defined in [**`opencode.ai/config.json`**](https://opencode.ai/config.json).
-
-TUI config uses [**`opencode.ai/tui.json`**](https://opencode.ai/tui.json).
+The config file has a schema that's defined in [**`opencode.ai/config.json`**](https://opencode.ai/config.json).

 Your editor should be able to validate and autocomplete based on the schema.

@@ -161,24 +154,28 @@ Your editor should be able to validate and autocomplete based on the schema.

 ### TUI

-Use a dedicated `tui.json` (or `tui.jsonc`) file for TUI-specific settings.
+You can configure TUI-specific settings through the `tui` option.

-```json title="tui.json"
+```json title="opencode.json"
 {
-  "$schema": "https://opencode.ai/tui.json",
-  "scroll_speed": 3,
-  "scroll_acceleration": {
-    "enabled": true
-  },
-  "diff_style": "auto"
+  "$schema": "https://opencode.ai/config.json",
+  "tui": {
+    "scroll_speed": 3,
+    "scroll_acceleration": {
+      "enabled": true
+    },
+    "diff_style": "auto"
+  }
 }
 ```

-Use `OPENCODE_TUI_CONFIG` to point to a custom TUI config file.
+Available options:

-Legacy `theme`, `keybinds`, and `tui` keys in `opencode.json` are deprecated and automatically migrated when possible.
+- `scroll_acceleration.enabled` - Enable macOS-style scroll acceleration. **Takes precedence over `scroll_speed`.**
+- `scroll_speed` - Custom scroll speed multiplier (default: `3`, minimum: `1`). Ignored if `scroll_acceleration.enabled` is `true`.
+- `diff_style` - Control diff rendering. `"auto"` adapts to terminal width, `"stacked"` always shows single column.

-[Learn more about TUI configuration here](/docs/tui#configure).
+[Learn more about using the TUI here](/docs/tui).

 ---

@@ -304,12 +301,12 @@ Bearer tokens (`AWS_BEARER_TOKEN_BEDROCK` or `/connect`) take precedence over pr

 ### Themes

-Set your UI theme in `tui.json`.
+You can configure the theme you want to use in your OpenCode config through the `theme` option.

-```json title="tui.json"
+```json title="opencode.json"
 {
-  "$schema": "https://opencode.ai/tui.json",
-  "theme": "tokyonight"
+  "$schema": "https://opencode.ai/config.json",
+  "theme": ""
 }
 ```

@@ -409,11 +406,11 @@ You can also define commands using markdown files in `~/.config/opencode/command

 ### Keybinds

-Customize keybinds in `tui.json`.
+You can customize your keybinds through the `keybinds` option.

-```json title="tui.json"
+```json title="opencode.json"
 {
-  "$schema": "https://opencode.ai/tui.json",
+  "$schema": "https://opencode.ai/config.json",
  "keybinds": {}
 }
 ```
--- a/packages/web/src/content/docs/keybinds.mdx
+++ b/packages/web/src/content/docs/keybinds.mdx
@@ -3,11 +3,11 @@ title: Keybinds
 description: Customize your keybinds.
 ---

-OpenCode has a list of keybinds that you can customize through `tui.json`.
+OpenCode has a list of keybinds that you can customize through the OpenCode config.

-```json title="tui.json"
+```json title="opencode.json"
 {
-  "$schema": "https://opencode.ai/tui.json",
+  "$schema": "https://opencode.ai/config.json",
  "keybinds": {
    "leader": "ctrl+x",
    "app_exit": "ctrl+c,ctrl+d,<leader>q",
@@ -117,11 +117,11 @@ You don't need to use a leader key for your keybinds but we recommend doing so.

 ## Disable keybind

-You can disable a keybind by adding the key to `tui.json` with a value of "none".
+You can disable a keybind by adding the key to your config with a value of "none".

-```json title="tui.json"
+```json title="opencode.json"
 {
-  "$schema": "https://opencode.ai/tui.json",
+  "$schema": "https://opencode.ai/config.json",
  "keybinds": {
    "session_compact": "none"
  }
--- a/packages/web/src/content/docs/themes.mdx
+++ b/packages/web/src/content/docs/themes.mdx
@@ -61,11 +61,11 @@ The system theme is for users who:

 ## Using a theme

-You can select a theme by bringing up the theme select with the `/theme` command. Or you can specify it in `tui.json`.
+You can select a theme by bringing up the theme select with the `/theme` command. Or you can specify it in your [config](/docs/config).

-```json title="tui.json" {3}
+```json title="opencode.json" {3}
 {
-  "$schema": "https://opencode.ai/tui.json",
+  "$schema": "https://opencode.ai/config.json",
  "theme": "tokyonight"
 }
 ```
--- a/packages/web/src/content/docs/tui.mdx
+++ b/packages/web/src/content/docs/tui.mdx
@@ -355,34 +355,24 @@ Some editors need command-line arguments to run in blocking mode. The `--wait` f

 ## Configure

-You can customize TUI behavior through `tui.json` (or `tui.jsonc`).
+You can customize TUI behavior through your OpenCode config file.

-```json title="tui.json"
+```json title="opencode.json"
 {
-  "$schema": "https://opencode.ai/tui.json",
-  "theme": "opencode",
-  "keybinds": {
-    "leader": "ctrl+x"
-  },
-  "scroll_speed": 3,
-  "scroll_acceleration": {
-    "enabled": true
-  },
-  "diff_style": "auto"
+  "$schema": "https://opencode.ai/config.json",
+  "tui": {
+    "scroll_speed": 3,
+    "scroll_acceleration": {
+      "enabled": true
+    }
+  }
 }
 ```

-This is separate from `opencode.json`, which configures server/runtime behavior.
-
 ### Options

- `theme` - Sets your UI theme. [Learn more](/docs/themes).
- `keybinds` - Customizes keyboard shortcuts. [Learn more](/docs/keybinds).
- `scroll_acceleration.enabled` - Enable macOS-style scroll acceleration for smooth, natural scrolling. When enabled, scroll speed increases with rapid scrolling gestures and stays precise for slower movements. **This setting takes precedence over `scroll_speed` and overrides it when enabled.**
+- `scroll_acceleration` - Enable macOS-style scroll acceleration for smooth, natural scrolling. When enabled, scroll speed increases with rapid scrolling gestures and stays precise for slower movements. **This setting takes precedence over `scroll_speed` and overrides it when enabled.**
 - `scroll_speed` - Controls how fast the TUI scrolls when using scroll commands (minimum: `1`). Defaults to `3`. **Note: This is ignored if `scroll_acceleration.enabled` is set to `true`.**
- `diff_style` - Controls diff rendering. `"auto"` adapts to terminal width, `"stacked"` always shows a single-column layout.
-
-Use `OPENCODE_TUI_CONFIG` to load a custom TUI config path.

 ---