docs: add v2 configuration reference

packages/core/src/plugin/skill.ts

@@ -13,14 +13,14 @@ import { FSUtil } from "../fs-util"
 import os from "os"
 import path from "path"
 import { fileURLToPath } from "url"
-import customizeOpencodeContent from "./skill/customize-opencode.md" with { type: "text" }
+import opencodeContent from "./skill/opencode.md" with { type: "text" }
 import reportContent from "./skill/report.md" with { type: "text" }
 
-export const CustomizeOpencodeContent = customizeOpencodeContent
+export const OpencodeContent = opencodeContent
 export const ReportContent = reportContent
 
-const CUSTOMIZE_OPENCODE_DESCRIPTION =
-  "Use ONLY when the user is editing or creating opencode's own configuration: opencode.json, opencode.jsonc, files under .opencode/, or files under ~/.config/opencode/. Also use when creating or fixing opencode agents, subagents, commands, skills, plugins, MCP servers, or permission rules. Do not use for the user's own application code, or for any project that is not configuring opencode itself."
+export const OpencodeDescription =
+  "Use this skill for any question about OpenCode itself, including how OpenCode works, using or configuring it, troubleshooting it, developing plugins or integrations, using the OpenCode SDK, clients, server, or API, and contributing to the OpenCode codebase. Also use it for OpenCode agents, commands, skills, tools, permissions, MCP servers, providers, models, themes, keybinds, formatters, the CLI, TUI, desktop app, and web app."
 const REPORT_DESCRIPTION =
   "Use when the user wants to report an opencode issue or bug. Collect standard diagnostics, add user-specific reproduction context, and publish the issue with GitHub CLI."
 
@@ -33,10 +33,10 @@ export const Plugin = define({
         SkillV2.EmbeddedSource.make({
           type: "embedded",
           skill: SkillV2.Info.make({
-            name: "customize-opencode",
-            description: CUSTOMIZE_OPENCODE_DESCRIPTION,
-            location: AbsolutePath.make("/builtin/customize-opencode.md"),
-            content: CustomizeOpencodeContent,
+            name: "opencode",
+            description: OpencodeDescription,
+            location: AbsolutePath.make("/builtin/opencode.md"),
+            content: OpencodeContent,
           }),
         }),
       )

packages/core/src/plugin/skill/customize-opencode.md

@@ -1,452 +0,0 @@
-<!--
-  Built-in skill. Name and description are registered in code at
-  packages/core/src/plugin/skill.ts
-  and CUSTOMIZE_OPENCODE_SKILL_DESCRIPTION). The body below becomes the
-  skill's content.
--->
-
-# Customizing opencode
-
-opencode validates its own config strictly and refuses to start when a field
-is wrong. The shapes below cover the common surface area, but they are a
-**summary, not the source of truth**.
-
-## Full schema reference
-
-The authoritative list of every config option — with field types, enums,
-defaults, and descriptions — lives in the published JSON Schema:
-
-**<https://opencode.ai/config.json>**
-
-If a field is not documented in this skill, or you need to confirm an exact
-shape before writing config, **fetch that URL and read the schema directly**
-rather than guessing. opencode hard-fails on invalid config, so the cost of a
-wrong shape is a broken startup.
-
-Independently, every `opencode.json` should declare
-`"$schema": "https://opencode.ai/config.json"` so the user's editor catches
-mistakes as they type.
-
-## Applying changes
-
-Config is loaded once when opencode starts and is not hot-reloaded. After
-saving changes to `opencode.json`, an agent file, a skill, a plugin, or any
-other config-time file, **tell the user to quit and restart opencode** for
-the changes to take effect. The running session will keep using the
-already-loaded config until then.
-
-## Where files live
-
-| Scope                         | Path                                                                                                                      |
-| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| Project config                | `./opencode.json`, `./opencode.jsonc`, or `.opencode/opencode.json` (opencode walks up from the cwd to the worktree root) |
-| Global config                 | `~/.config/opencode/opencode.json` (NOT `~/.opencode/`)                                                                   |
-| Project agents                | `.opencode/agent/<name>.md` or `.opencode/agents/<name>.md`                                                               |
-| Global agents                 | `~/.config/opencode/agent(s)/<name>.md`                                                                                   |
-| Project commands              | `.opencode/command/<name>.md` or `.opencode/commands/<name>.md`                                                           |
-| Global commands               | `~/.config/opencode/command(s)/<name>.md`                                                                                 |
-| Project skills                | `.opencode/skill(s)/<name>/SKILL.md`                                                                                      |
-| Global skills                 | `~/.config/opencode/skill(s)/<name>/SKILL.md`                                                                             |
-| External skills (auto-loaded) | `~/.claude/skills/<name>/SKILL.md`, `~/.agents/skills/<name>/SKILL.md`                                                    |
-
-Configs from each scope are deep-merged. Project overrides global. Unknown
-top-level keys in `opencode.json` are rejected with `ConfigInvalidError`.
-
-## opencode.json
-
-Every field is optional.
-
-```json
-{
-  "$schema": "https://opencode.ai/config.json",
-  "username": "string",
-  "model": "provider/model-id",
-  "small_model": "provider/model-id",
-  "default_agent": "agent-name",
-  "shell": "/bin/zsh",
-  "logLevel": "DEBUG" | "INFO" | "WARN" | "ERROR",
-  "share": "manual" | "auto" | "disabled",
-  "autoupdate": true | false | "notify",
-  "snapshot": true,
-  "instructions": ["AGENTS.md", "docs/style.md"],
-
-  "skills": {
-    "paths": [".opencode/skills", "/abs/path/to/skills"],
-    "urls": ["https://example.com/.well-known/skills/"]
-  },
-
-  "references": {
-    "docs": {
-      "path": "../docs",
-      "description": "Use for product behavior and documentation conventions"
-    },
-    "sdk": {
-      "repository": "owner/sdk",
-      "branch": "main",
-      "description": "Use for SDK implementation details",
-      "hidden": true
-    }
-  },
-
-  "agent": {
-    "my-agent": {
-      "model": "anthropic/claude-sonnet-4-6",
-      "mode": "subagent",
-      "description": "...",
-      "permission": { "edit": "deny" }
-    }
-  },
-
-  "command": {
-    "deploy": { "description": "...", "template": "..." }
-  },
-
-  "provider": {
-    "anthropic": { "options": { "apiKey": "..." } }
-  },
-  "disabled_providers": ["openai"],
-  "enabled_providers": ["anthropic"],
-
-  "mcp": {
-    "playwright": {
-      "type": "local",
-      "command": ["npx", "-y", "@playwright/mcp"],
-      "enabled": true,
-      "env": {}
-    },
-    "remote-thing": {
-      "type": "remote",
-      "url": "https://...",
-      "headers": { "Authorization": "Bearer ..." }
-    }
-  },
-
-  "plugin": [
-    "opencode-gemini-auth",
-    "opencode-foo@1.2.3",
-    "./local-plugin.ts",
-    ["opencode-bar", { "option": "value" }]
-  ],
-
-  "permission": {
-    "edit": "deny",
-    "bash": { "git *": "allow", "*": "ask" }
-  },
-
-  "formatter": false,
-  "lsp": false,
-
-  "experimental": {
-    "primary_tools": ["edit"],
-    "mcp_timeout": 30000
-  },
-
-  "tool_output": { "max_lines": 200, "max_bytes": 8192 },
-
-  "compaction": { "auto": true, "tail_turns": 15 }
-}
-```
-
-Shape notes worth being explicit about:
-
-- `model` always carries a provider prefix: `"anthropic/claude-sonnet-4-6"`.
-- `skills` is an object with `paths` and/or `urls`, not an array.
-- `references` is an object keyed by alias. Each value is a local path, Git repository, or string shorthand.
-- `agent` is an object keyed by agent name, not an array.
-- `command` is an object keyed by command name, not an array.
-- `plugin` is an array of strings or `[name, options]` tuples, not an object.
-- `mcp[name].command` is an array of strings, never a single string. `type` is required.
-- `permission` is either a string action or an object keyed by tool name.
-
-## Skills
-
-opencode's skill loader scans for `**/SKILL.md` inside skill directories. The
-file is named `SKILL.md` exactly, and lives in its own folder named after the
-skill:
-
-```
-.opencode/skills/my-skill/SKILL.md
-```
-
-Frontmatter:
-
-```markdown
----
-name: my-skill
-description: One sentence covering what this skill does AND when to trigger it. Front-load the literal keywords or filenames the user is likely to say.
----
-
-# My Skill
-
-(skill body in markdown: instructions, examples, references)
-```
-
-- `name` is required, lowercase hyphen-separated, up to 64 chars, and matches the folder name.
-- `description` is effectively required: skills without one are filtered out and never surfaced to the model. Cover both _what_ the skill does and _when_ to use it. Write in third person ("Use when...", not "I help with..."). Front-load concrete trigger keywords and filenames; gate with "Use ONLY when..." if the skill should stay quiet on adjacent topics.
-- Optional: `license`, `compatibility`, `metadata` (string-string map).
-
-Register skills from non-default locations via `skills.paths` (scanned
-recursively for `**/SKILL.md`) and `skills.urls` (each URL serves a list of
-skills).
-
-## References
-
-References make local directories and Git repositories outside the active
-project available as supporting context. Configure them under `references`,
-keyed by the alias used in `@` autocomplete:
-
-```json
-{
-  "references": {
-    "docs": {
-      "path": "../product-docs",
-      "description": "Use for product behavior and terminology"
-    },
-    "effect": {
-      "repository": "Effect-TS/effect",
-      "branch": "main",
-      "description": "Use for Effect implementation details"
-    }
-  }
-}
-```
-
-Local `path` values may be relative to the declaring config, absolute, or use
-`~/`. Git `repository` values accept Git URLs, host/path references, and GitHub
-`owner/repo` shorthand; `branch` is optional. Both forms support optional
-`description` and `hidden` fields.
-
-- Only references with a `description` are advertised to agents in system context.
-- `hidden: true` removes a reference from TUI `@` autocomplete only. It remains available to agents and by direct path.
-- Reference directories are automatically allowed through the external-directory boundary; normal read/edit/tool permissions still apply.
-- String shorthand is supported: use `"docs": "../docs"` for local paths or `"effect": "Effect-TS/effect"` for Git repositories.
-
-## Agents
-
-Two ways to define an agent. Use the file form for anything non-trivial.
-
-### Inline (in `opencode.json`)
-
-```json
-{
-  "agent": {
-    "my-reviewer": {
-      "description": "Reviews PRs for style violations.",
-      "mode": "subagent",
-      "model": "anthropic/claude-sonnet-4-6",
-      "permission": { "edit": "deny", "bash": "ask" },
-      "prompt": "You are a strict PR reviewer..."
-    }
-  }
-}
-```
-
-### File
-
-```
-.opencode/agent/my-reviewer.md      OR     .opencode/agents/my-reviewer.md
-```
-
-```markdown
----
-description: Reviews PRs for style violations.
-mode: subagent
-model: anthropic/claude-sonnet-4-6
-permission:
-  edit: deny
-  bash: ask
----
-
-You are a strict PR reviewer. Focus on...
-```
-
-The file body becomes the agent's `prompt`. Do not also put `prompt:` in the
-frontmatter.
-
-`mode` is one of `"primary"`, `"subagent"`, `"all"`.
-
-Allowed top-level frontmatter fields: `name, model, variant, description, mode,
-hidden, color, steps, options, permission, disable, temperature, top_p`. Any
-unknown field is silently routed into `options`.
-
-To disable a built-in agent: `agent: { build: { disable: true } }`, or in a
-file, `disable: true` in frontmatter.
-
-`default_agent` must point to a non-hidden, primary-mode agent.
-
-### Built-in agents
-
-opencode ships with `build`, `plan`, `general`, `explore`. Hidden internal agents:
-`compaction`, `title`, `summary`. To override a built-in's fields, define the
-same key in `agent: { <name>: { ... } }`.
-
-## Commands
-
-opencode's command loader scans for `**/*.md` inside command directories. The
-file is named after the command, and lives directly inside the `command` folder:
-
-```
-.opencode/command/deploy.md
-```
-
-Frontmatter:
-
-```markdown
----
-description: One sentence describing what the command does.
-agent: build
-model: anthropic/claude-sonnet-4-6
----
-
-(command body in markdown: the prompt opencode runs, with $ARGUMENTS for the user's input)
-```
-
-- `template` is the command body — everything below the frontmatter — and is required: it is the prompt opencode runs when the command is invoked. Do not also put a `template:` key in the frontmatter.
-- `$ARGUMENTS` is replaced with everything the user typed after the command; `$1`, `$2`, … pull individual positional arguments.
-- Optional: `description`, `agent`, `model`, `variant`, `subtask`.
-
-## Plugins
-
-`plugin:` is an array. Each entry is one of:
-
-```json
-"plugin": [
-  "opencode-gemini-auth",            // npm spec, latest
-  "opencode-foo@1.2.3",              // npm spec, pinned
-  "./local-plugin.ts",               // file path, relative to the declaring config
-  "file:///abs/path/plugin.js",      // file URL
-  ["opencode-bar", { "key": "val" }] // tuple form with options
-]
-```
-
-Auto-discovered plugins (no config entry needed): any `*.ts` or `*.js` file in
-`.opencode/plugin/` or `.opencode/plugins/`.
-
-A plugin module exports `default` (or any named export) of type
-`Plugin = (input: PluginInput, options?) => Promise<Hooks>`. The export is a
-function, not a plain object literal, and the function returns an object
-(return `{}` if there is nothing to register).
-
-```ts
-import type { Plugin } from "@opencode-ai/plugin"
-
-export default (async ({ client, project, directory, $ }) => {
-  return {
-    config: (cfg) => {
-      // cfg is the live merged config; mutate fields here.
-    },
-    "tool.execute.before": async (input, output) => {
-      // mutate output.args before the tool runs
-    },
-  }
-}) satisfies Plugin
-```
-
-Hook surface (mutate `output` in place; return `void`):
-
-- `event(input)`: every bus event
-- `config(cfg)`: once on init with the merged config
-- `chat.message`, `chat.params`, `chat.headers`
-- `tool.execute.before`, `tool.execute.after`
-- `tool.definition`
-- `command.execute.before`
-- `shell.env`
-- `permission.ask`
-- `experimental.chat.messages.transform`, `experimental.chat.system.transform`,
-  `experimental.session.compacting`, `experimental.compaction.autocontinue`,
-  `experimental.text.complete`
-
-Special object-shaped (not callbacks): `tool: { my_tool: { ... } }`,
-`auth: { ... }`, `provider: { ... }`.
-
-## MCP servers
-
-`mcp:` is an object keyed by server name. Each server is discriminated by
-`type`:
-
-```json
-{
-  "mcp": {
-    "playwright": {
-      "type": "local",
-      "command": ["npx", "-y", "@playwright/mcp"],
-      "enabled": true,
-      "env": { "BROWSER": "chromium" }
-    },
-    "github": {
-      "type": "remote",
-      "url": "https://...",
-      "enabled": true,
-      "headers": { "Authorization": "Bearer {env:GITHUB_TOKEN}" }
-    },
-    "old-server": { "enabled": false }
-  }
-}
-```
-
-`command` is an array of strings. `type` is required. Use `enabled: false` to
-disable a server inherited from a parent config. String values such as header
-tokens support `{env:VAR}` interpolation (and `{file:path}`); the shell-style
-`${VAR}` is not substituted.
-
-## Permissions
-
-```json
-"permission": {
-  "edit": "deny",
-  "bash": { "git *": "allow", "rm *": "deny", "*": "ask" },
-  "external_directory": { "~/secrets/**": "deny", "*": "allow" }
-}
-```
-
-Actions: `"allow"`, `"ask"`, `"deny"`.
-
-Per-tool value forms: `"allow"` shorthand (treated as `{"*": "allow"}`), or an
-object `{ pattern: action }`. Within an object, **insertion order matters**.
-opencode evaluates the LAST matching rule, so put broad rules first and narrow
-rules last.
-
-`permission: "allow"` (a string at the top level) is shorthand for "allow
-everything" and is rarely what the user wants.
-
-Known permission keys: `read, edit, glob, grep, list, bash, task,
-external_directory, todowrite, question, webfetch, websearch, lsp, doom_loop,
-skill`. Some of these (`todowrite,
-question, webfetch, websearch, doom_loop`) only accept a flat
-action, not a per-pattern object.
-
-`external_directory` patterns are filesystem paths (use `~/`, absolute paths,
-or globs like `~/projects/**`).
-
-Per-agent `permission:` overrides top-level `permission:`. Plan Mode lives on
-the `plan` agent's permission ruleset (`edit: deny *`).
-
-## Escape hatches
-
-When a user's config is broken and opencode won't start, these env vars help:
-
-- `OPENCODE_DISABLE_PROJECT_CONFIG=1`: skip the project's local `opencode.json`
-  and start from globals only. Run from the project directory, opencode loads,
-  the user edits the broken file, then they restart without the flag.
-- `OPENCODE_CONFIG=/path/to/file.json`: load an additional explicit config.
-- `OPENCODE_CONFIG_CONTENT='{"$schema":"https://opencode.ai/config.json"}'`:
-  inject inline JSON as a final local-scope merge.
-- `OPENCODE_DISABLE_DEFAULT_PLUGINS=1`: skip default plugins.
-- `OPENCODE_PURE=1`: skip external plugins entirely.
-- `OPENCODE_DISABLE_EXTERNAL_SKILLS=1`,
-  `OPENCODE_DISABLE_CLAUDE_CODE_SKILLS=1`: skip the external skill scans under
-  `~/.claude/` and `~/.agents/`.
-
-## When proposing edits
-
-- Validate against the schema before writing. If you are unsure of a field's
-  exact shape, or the field is not covered in this skill, fetch
-  `https://opencode.ai/config.json` and read the schema rather than guessing.
-- Preserve `$schema` and any existing fields the user did not ask to change.
-- For agent, command, skill, and plugin definitions, prefer creating new files
-  in the correct location over inlining everything in `opencode.json`.
-- If the user's existing config is malformed, point them at the env-var escape
-  hatches above so they can edit from inside opencode without breaking their
-  session.
-- After saving any config change, remind the user to quit and restart opencode
-  — running sessions keep using the already-loaded config.

packages/core/src/plugin/skill/opencode.md

@@ -0,0 +1,112 @@
+# OpenCode
+
+Use this guide as the starting point for work involving OpenCode itself. It
+covers the core concepts needed to configure and customize OpenCode, extend it
+with plugins, and build integrations with the OpenCode SDK, clients, and API.
+
+Full documentation is available at <https://opencode.mintlify.site/>. Consult
+it when this overview does not contain enough detail for the task.
+
+## Configuration
+
+OpenCode configuration uses JSON or JSONC. Include the published schema so the
+user's editor can validate fields and provide autocomplete:
+
+```jsonc
+{
+  "$schema": "https://opencode.ai/config.json"
+}
+```
+
+Global configuration lives at `~/.config/opencode/opencode.json(c)` and applies
+to every project for that user. Project configuration can live in any directory
+as `opencode.json(c)` or `.opencode/opencode.json(c)`, including nested packages
+in a monorepo.
+
+When OpenCode starts, it searches upward from the current directory for project
+configuration and merges the files it finds with the global configuration.
+
+Common configuration fields include `model`, `default_agent`, `permissions`,
+`agents`, `commands`, `plugins`, `providers`, `mcp`, `skills`, `instructions`,
+`references`, `formatter`, and `lsp`.
+
+Do not guess field names or shapes. Use
+<https://opencode.ai/config.json> as the source of truth and preserve unrelated
+settings when editing an existing file.
+
+See the [full configuration guide](https://opencode.mintlify.site/config) for
+every field, examples, config locations, and links to dedicated feature guides.
+
+## Service
+
+OpenCode uses a client-server architecture. Interfaces such as the TUI connect
+to a background OpenCode service, which owns sessions, configuration, plugins,
+permissions, and tool execution.
+
+Configuration and related files are typically watched and reloaded while the
+service is running. If a change does not appear, restart the service:
+
+```sh
+opencode2 service restart
+```
+
+Check its status after restarting:
+
+```sh
+opencode2 service status
+```
+
+## API
+
+OpenCode exposes an HTTP API from its server. The API is described by an
+OpenAPI document available from the running server at `/openapi.json`.
+
+Use OpenCode's built-in `api` command for local requests. It discovers the same
+background server used by the TUI, starts it when necessary, and applies the
+server's authentication headers automatically.
+
+Call an endpoint with an HTTP method and path:
+
+```sh
+opencode2 api get /api/health
+```
+
+Pass a request body with `--data` or `-d`, and additional headers with
+`--header` or `-H`:
+
+```sh
+opencode2 api post /api/example --data '{"key":"value"}'
+opencode2 api get /api/example --header 'X-Example:value'
+```
+
+Request bodies default to `Content-Type: application/json`. When OpenCode is
+connected to an explicit server instead of its managed background service, use
+the same configured server and authentication context rather than constructing
+an unauthenticated request separately.
+
+See the [full API reference](https://opencode.mintlify.site/api) for available
+endpoints, parameters, request bodies, and response schemas. The
+raw [OpenAPI specification](https://opencode.mintlify.site/openapi.json) is also
+available for code generation and other tooling.
+
+## Troubleshooting
+
+OpenCode runs a client and a background server. Start by determining whether a
+problem belongs to the client, the shared server, or one project.
+
+- Check the service with `opencode2 service status` and verify the API with
+  `opencode2 api get /api/health`.
+- Inspect `~/.local/share/opencode/log/opencode.log`. Filter `role=cli` for
+  client startup and `role=server` for sessions, providers, plugins,
+  permissions, and tools.
+- Run one reproduction with `OPENCODE_LOG_LEVEL=DEBUG` when normal logs are not
+  sufficient.
+- Do not delete or edit the database, service registration, or service config
+  while diagnosing a problem. Back up persistent data before inspecting it
+  with external tools.
+- Redact API keys, authorization headers, prompts, file contents, and other
+  sensitive data before sharing diagnostics.
+
+See the [full troubleshooting guide](https://opencode.mintlify.site/troubleshooting)
+for service lifecycle commands, API inspection, log locations, explicit server
+connections, issue-reporting details, and local development paths.

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

@@ -41,8 +41,8 @@ describe("SkillPlugin.Plugin", () => {
 
       expect(skills).toContainEqual(
         expect.objectContaining({
-          name: "customize-opencode",
-          description: expect.stringContaining("opencode's own configuration"),
+          name: "opencode",
+          description: expect.stringContaining("any question about OpenCode itself"),
         }),
       )
       expect(skills).toContainEqual(

packages/docs/AGENTS.md

@@ -0,0 +1,22 @@
+# V2 documentation guide
+
+## Structure
+
+- This directory is a standalone Mintlify site deployed from `packages/docs` on the `dev` branch.
+- Write documentation in MDX. Every page should have `title` and `description` frontmatter.
+- `docs.json` owns site configuration and navigation. Add, move, or remove its page entries whenever the corresponding MDX pages change.
+- Put static files in `assets/` and reference them with root-relative paths such as `/assets/example.svg`.
+- The API endpoint reference is generated by Mintlify from `openapi.json`; do not duplicate endpoint documentation as hand-written MDX.
+- Keep documentation aligned with the V2 packages. Do not use `packages/opencode` as the source of truth unless the task explicitly concerns V1.
+
+## Local development
+
+- At the start of documentation work, launch `bun dev` from `packages/docs` using the shell tool with `background: true`. Never run the dev server in a foreground shell call and do not poll the process; wait for the background completion notification.
+- Preview the site at `http://localhost:3333`. Mintlify does not expose a host option and binds the preview to all network interfaces. The server reloads changes to MDX and `docs.json` automatically.
+- Use the running preview to verify navigation, links, Mintlify components, code blocks, and desktop and mobile layout.
+
+## Validation
+
+- Run `bun validate` from `packages/docs` after making documentation or configuration changes.
+- Run `bun broken-links` from `packages/docs` when pages, navigation, headings, or links change.
+- Treat validation errors and broken internal links as blockers. Also verify external links relevant to the change when practical.

packages/docs/README.md

@@ -4,21 +4,19 @@ The V2 documentation is a Mintlify site deployed from `packages/docs` on the `de
 
 ## Local preview
 
-The Mintlify CLI requires Node.js 20 through 24.
-
 From this directory, run:
 
 ```bash
-npx mint dev
+bun dev
 ```
 
-The preview opens at `http://localhost:3000` and reloads when MDX or `docs.json` changes.
+The preview opens at `http://localhost:3333` and reloads when MDX or `docs.json` changes.
 
 Validate changes before opening a pull request:
 
 ```bash
-npx mint validate
-npx mint broken-links
+bun validate
+bun broken-links
 ```
 
 The hosted preview is available at [opencode.mintlify.site](https://opencode.mintlify.site).

packages/docs/config.mdx

@@ -6,3 +6,439 @@ description: "Configure OpenCode."
 <Tip>
   You shouldn't have to configure OpenCode manually. Ask OpenCode to update its configuration for you.
 </Tip>
+
+## Format
+
+OpenCode supports both **JSON** and **JSONC** (JSON with Comments) configuration files.
+
+```jsonc title="opencode.jsonc"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "model": "openai/gpt-5.2-custom",
+  "providers": {
+    "openai": {
+      "models": {
+        "gpt-5.2-custom": {
+          "modelID": "gpt-5.2",
+          "name": "GPT-5.2 Custom"
+        }
+      }
+    }
+  }
+}
+```
+
+## Locations
+
+OpenCode loads global configuration from:
+
+```text
+~/.config/opencode/opencode.json(c)
+```
+
+Project-specific configuration can use either form:
+
+```text
+/home/user/projects/my-app/opencode.json(c)
+/home/user/projects/my-app/.opencode/opencode.json(c)
+```
+
+When OpenCode starts, it searches for configuration files from the current
+directory upward to the project root. The files are merged, and configuration
+closer to the current directory takes precedence.
+
+For example, consider a monorepo with OpenCode started from
+`/home/user/projects/acme/packages/web`:
+
+```text
+~/.config/opencode/opencode.json
+
+/home/user/projects/acme/
+├── opencode.json
+└── packages/
+    └── web/
+        ├── opencode.json
+        └── src/
+```
+
+OpenCode applies these files from lowest to highest precedence:
+
+1. `~/.config/opencode/opencode.json`
+2. `/home/user/projects/acme/opencode.json`
+3. `/home/user/projects/acme/packages/web/opencode.json`
+
+Settings in the package config override matching settings from the repository
+config, which override matching settings from the global config. Settings that
+do not conflict are preserved from every file.
+
+## Schema
+
+The complete OpenCode configuration schema is available at
+[opencode.ai/config.json](https://opencode.ai/config.json).
+
+Add the `$schema` field to your configuration file to enable validation and
+autocomplete in editors that support JSON Schema:
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json"
+}
+```
+
+Use the schema as the source of truth for available fields, accepted values,
+and nested configuration shapes.
+
+### Shell
+
+Set the shell used by the terminal and shell tools.
+
+```jsonc
+{
+  "shell": "/bin/zsh"
+}
+```
+
+### Model
+
+Set the default model in `provider/model` format. Add `#variant` to select a
+specific model variant.
+
+```jsonc
+{
+  "model": "anthropic/claude-sonnet-4-5#high"
+}
+```
+
+See the [models guide](https://opencode.ai/docs/models/) for model selection
+and local models.
+
+### Default agent
+
+Choose the primary agent used when a session does not select one explicitly.
+
+```jsonc
+{
+  "default_agent": "build"
+}
+```
+
+See the [agents guide](https://opencode.ai/docs/agents/) for built-in and custom
+agents.
+
+### Autoupdate
+
+Control automatic updates. Set this to `false` to disable updates or `"notify"`
+to receive update notifications.
+
+```jsonc
+{
+  "autoupdate": false
+}
+```
+
+### Sharing
+
+Control whether sessions can be shared manually, shared automatically, or not
+shared at all.
+
+```jsonc
+{
+  "share": "manual"
+}
+```
+
+See the [sharing guide](https://opencode.ai/docs/share/) for more details.
+
+### Username
+
+Set the username displayed in conversations.
+
+```jsonc
+{
+  "username": "alice"
+}
+```
+
+### Permissions
+
+Define ordered rules that allow, deny, or ask before an agent uses a tool on a
+matching resource.
+
+```jsonc
+{
+  "permissions": [
+    {
+      "action": "bash",
+      "resource": "git push *",
+      "effect": "ask"
+    }
+  ]
+}
+```
+
+See the [permissions guide](https://opencode.ai/docs/permissions/) for rule
+matching and available actions.
+
+### Agents
+
+Override built-in agents or define specialized agents with their own model,
+instructions, mode, and permissions.
+
+```jsonc
+{
+  "agents": {
+    "reviewer": {
+      "description": "Review changes without editing files",
+      "mode": "subagent",
+      "system": "Focus on correctness, security, and missing tests.",
+      "permissions": [
+        { "action": "edit", "resource": "*", "effect": "deny" }
+      ]
+    }
+  }
+}
+```
+
+See the [agents guide](https://opencode.ai/docs/agents/) for all agent options
+and file-based agents.
+
+### Snapshots
+
+Enable or disable the snapshots used by undo and revert behavior.
+
+```jsonc
+{
+  "snapshots": false
+}
+```
+
+### Watcher
+
+Ignore files and directories that should not trigger filesystem updates.
+
+```jsonc
+{
+  "watcher": {
+    "ignore": ["dist/**", "coverage/**"]
+  }
+}
+```
+
+### Formatter
+
+Enable built-in formatters, disable formatting entirely, or configure formatter
+commands by name.
+
+```jsonc
+{
+  "formatter": {
+    "prettier": {
+      "command": ["bunx", "prettier", "--write", "$FILE"],
+      "extensions": [".js", ".ts", ".tsx"]
+    }
+  }
+}
+```
+
+See the [formatters guide](https://opencode.ai/docs/formatters/) for built-in
+formatters and custom commands.
+
+### LSP
+
+Enable built-in language servers, disable them, or configure servers by name.
+
+```jsonc
+{
+  "lsp": {
+    "typescript": {
+      "command": ["typescript-language-server", "--stdio"],
+      "extensions": [".ts", ".tsx"]
+    }
+  }
+}
+```
+
+See the [LSP guide](https://opencode.ai/docs/lsp/) for language server setup.
+
+### Attachments
+
+Control how oversized image attachments are resized or rejected before they are
+sent to a model.
+
+```jsonc
+{
+  "attachments": {
+    "image": {
+      "auto_resize": true,
+      "max_width": 2000,
+      "max_height": 2000,
+      "max_base64_bytes": 5242880
+    }
+  }
+}
+```
+
+### Tool output
+
+Set the maximum number of lines and bytes retained from a tool result.
+
+```jsonc
+{
+  "tool_output": {
+    "max_lines": 2000,
+    "max_bytes": 51200
+  }
+}
+```
+
+### MCP
+
+Configure local and remote Model Context Protocol servers. Global timeouts can
+be overridden by an individual server.
+
+```jsonc
+{
+  "mcp": {
+    "servers": {
+      "playwright": {
+        "type": "local",
+        "command": ["bunx", "@playwright/mcp"]
+      }
+    }
+  }
+}
+```
+
+See the [MCP guide](https://opencode.ai/docs/mcp-servers/) for remote servers,
+OAuth, environment variables, and timeouts.
+
+### Compaction
+
+Control automatic context compaction and how much recent context it preserves.
+
+```jsonc
+{
+  "compaction": {
+    "auto": true,
+    "keep": {
+      "tokens": 8000
+    },
+    "buffer": 20000
+  }
+}
+```
+
+### Skills
+
+Add directories or URLs that OpenCode should search for agent skills.
+
+```jsonc
+{
+  "skills": ["./team-skills", "https://example.com/.well-known/skills/"]
+}
+```
+
+See the [skills guide](https://opencode.ai/docs/skills/) for skill structure and
+automatic discovery under `.opencode/skills/`.
+
+### Commands
+
+Define reusable slash commands as named prompt templates.
+
+```jsonc
+{
+  "commands": {
+    "review": {
+      "description": "Review the current changes",
+      "template": "Review the current diff for correctness and missing tests."
+    }
+  }
+}
+```
+
+See the [commands guide](https://opencode.ai/docs/commands/) for arguments,
+models, agents, and file-based commands.
+
+### Instructions
+
+Load additional instruction files, globs, or URLs into the agent's context.
+
+```jsonc
+{
+  "instructions": ["CONTRIBUTING.md", "docs/guidelines/*.md"]
+}
+```
+
+See the [rules guide](https://opencode.ai/docs/rules/) for project instructions
+and `AGENTS.md`.
+
+### References
+
+Make local directories or Git repositories available as named supporting
+context.
+
+```jsonc
+{
+  "references": {
+    "docs": {
+      "path": "../product-docs",
+      "description": "Product behavior and terminology"
+    },
+    "effect": {
+      "repository": "Effect-TS/effect",
+      "branch": "main"
+    }
+  }
+}
+```
+
+See the [references guide](https://opencode.ai/docs/references/) for shorthand,
+visibility, and path resolution.
+
+### Plugins
+
+Load plugins from packages or local files. Use the object form when a plugin
+accepts options.
+
+```jsonc
+{
+  "plugins": [
+    "opencode-example-plugin",
+    {
+      "package": "./plugins/local.ts",
+      "options": {
+        "enabled": true
+      }
+    }
+  ]
+}
+```
+
+See the [plugins guide](/plugins) for plugin development and configuration.
+
+### Providers
+
+Configure providers and add or override their models, request settings,
+headers, and model variants.
+
+```jsonc
+{
+  "providers": {
+    "openai": {
+      "models": {
+        "gpt-5.2-custom": {
+          "modelID": "gpt-5.2",
+          "name": "GPT-5.2 Custom",
+          "limit": {
+            "context": 200000,
+            "output": 32000
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+See the [providers guide](https://opencode.ai/docs/providers/) for credentials,
+custom endpoints, provider packages, and model configuration.

packages/docs/package.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@opencode-ai/docs",
+  "private": true,
+  "scripts": {
+    "dev": "bun --bun mint dev --no-open --port 3333",
+    "validate": "bun --bun mint validate",
+    "broken-links": "bun --bun mint broken-links"
+  },
+  "devDependencies": {
+    "mint": "4.2.666"
+  }
+}

packages/opencode/src/skill/index.ts

@@ -24,15 +24,8 @@ const EXTERNAL_SKILL_PATTERN = "skills/**/SKILL.md"
 const OPENCODE_SKILL_PATTERN = "{skill,skills}/**/SKILL.md"
 const SKILL_PATTERN = "**/SKILL.md"
 
-// Built-in skill that ships with opencode. The model's intuition for what an
-// opencode.json should look like is often wrong, and opencode hard-fails on
-// invalid config, so users hit cryptic startup errors. Loading this skill
-// when the model is asked to touch opencode's own config files gives it the
-// actual schemas instead of guesses.
-const CUSTOMIZE_OPENCODE_SKILL_NAME = "customize-opencode"
-const CUSTOMIZE_OPENCODE_SKILL_DESCRIPTION =
-  "Use ONLY when the user is editing or creating opencode's own configuration: opencode.json, opencode.jsonc, files under .opencode/, or files under ~/.config/opencode/. Also use when creating or fixing opencode agents, subagents, skills, plugins, MCP servers, or permission rules. Do not use for the user's own application code, or for any project that is not configuring opencode itself."
-const CUSTOMIZE_OPENCODE_SKILL_BODY = SkillPlugin.CustomizeOpencodeContent
+const OPENCODE_SKILL_NAME = "opencode"
+const OPENCODE_SKILL_BODY = SkillPlugin.OpencodeContent
 
 export const Info = Schema.Struct({
   name: Schema.String,
@@ -275,11 +268,11 @@ const layer = Layer.effect(
         const s: State = { skills: {}, dirs: new Set() }
         // Register the built-in skill BEFORE disk discovery so a user-disk
         // skill with the same name can override it.
-        s.skills[CUSTOMIZE_OPENCODE_SKILL_NAME] = {
-          name: CUSTOMIZE_OPENCODE_SKILL_NAME,
-          description: CUSTOMIZE_OPENCODE_SKILL_DESCRIPTION,
+        s.skills[OPENCODE_SKILL_NAME] = {
+          name: OPENCODE_SKILL_NAME,
+          description: SkillPlugin.OpencodeDescription,
           location: "<built-in>",
-          content: CUSTOMIZE_OPENCODE_SKILL_BODY,
+          content: OPENCODE_SKILL_BODY,
         }
         yield* loadSkills(s, yield* InstanceState.get(discovered), events)
         return s