From 8dfee7cd50546673c9316e7c87c7c9f935bed854 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Fri, 23 Oct 2026 23:04:06 -0700
Subject: [PATCH 1/4] chore(quest): claim quest/m0/kix/opencode.md

Quest-Claim: 91eed9ed7411e89d

From 539c90786e7ce443d107232c5c74504c219f0b34 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Fri, 23 Oct 2026 23:46:51 -0700
Subject: [PATCH 2/4] feat(runner): drive opencode accounts through opencode
 serve

A runner now offers opencode accounts alongside Claude Code ones, covering
OpenCode Go, ChatGPT plans, and API-key providers. Each account signs in with
`opencode auth login` in its own XDG home; each turn runs `opencode serve` on
localhost behind a fresh password inside the job's devShell and drives one
session through the SDK, with the kix tools as a remote MCP server and
opencode's question tool denied. Limits abort the turn and pause the account.

The flake pins opencode for the runner and checks the SDK matches it.

Completes quest/m0/kix/opencode.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                 |  30 +--
 bun.lock                  |  15 ++
 flake.nix                 |  16 +-
 package.json              |   1 +
 quest/m0/kix/README.md    |   8 +-
 quest/m0/kix/opencode.md  |  26 ---
 quest/m1/cloud/funding.md |   1 -
 src/cli/main.ts           |  22 ++-
 src/runner/adapter.ts     |  43 ++++-
 src/runner/claude.ts      |  36 ++--
 src/runner/cli.ts         |  62 ++++--
 src/runner/home.ts        |   5 +-
 src/runner/opencode.ts    | 385 ++++++++++++++++++++++++++++++++++++++
 src/runner/runner.ts      |   2 +-
 test/runner.test.ts       | 294 ++++++++++++++++++++++++++++-
 15 files changed, 845 insertions(+), 101 deletions(-)
 delete mode 100644 quest/m0/kix/opencode.md
 create mode 100644 src/runner/opencode.ts

diff --git a/README.md b/README.md
index 65f9531c..f00dd7f8 100644
--- a/README.md
+++ b/README.md
@@ -495,22 +495,28 @@ signals the agent and waits until its `start` or `resume` has reported.
 ## Run kix jobs on your machines
 
 `quest runner` turns a Linux or macOS machine with Nix into a
-[kix.quest](https://kix.quest) runner, driving Claude Code with that machine's
-own logins:
+[kix.quest](https://kix.quest) runner, driving Claude Code or opencode with
+that machine's own logins:
 
 ```sh
 quest runner login --name laptop  # prints a link to approve while signed in to kix
 quest runner account add          # Claude Code's own sign-in, in an isolated home
 quest runner account add --console --label work
+quest runner account add opencode # opencode's sign-in: OpenCode Go, ChatGPT, or an API key
+quest runner account add opencode --model openai/gpt-5.5
 quest runner account list
 quest runner --slots 2            # runs jobs in the foreground until interrupted
 ```
 
 `login` makes a token that never leaves the machine; the link carries only its
 hash, and kix connects the runner once you approve it. Each account signs in
-through `claude auth login` in its own `CLAUDE_CONFIG_DIR`, so kix stores only
-an opaque account id, its kind, and a label. kix.quest/runners shows each
-runner's presence and sets the order jobs use your accounts in.
+through its CLI's own flow in its own home: `claude auth login` in a
+`CLAUDE_CONFIG_DIR`, or `opencode auth login` in a set of XDG directories, so
+kix stores only an opaque account id, its kind, and a label. An opencode
+account uses only the providers it signed in to, with `--model` or opencode's
+default. Use Claude Code for Claude subscriptions, since opencode cannot sign
+in to them. kix.quest/runners shows each runner's presence and sets the order
+jobs use your accounts in.
 
 Every job runs in its own checkout inside the project's `nix develop` shell,
 with the flake's `nixConfig` honored; a project without a flake gets a bootstrap
@@ -522,12 +528,14 @@ token. kix publishes as its GitHub App, so the runner never pushes. A job that h
 pauses for you to pick another account; the runner never switches on its own.
 On SIGINT or SIGTERM, running work is published and its jobs move to another
 runner. Until the job sandbox ships, runners take only trusted revisions,
-agents run with `--permission-mode bypassPermissions`, and a job resumes with
-another maintainer's answer only once you approve it in the inbox.
-
-The flake's `runner` package is a `quest` whose Claude Code is pinned by this
-repository's lock (`nix run github:kixelated/quest#runner -- runner`);
-otherwise `claude` comes from `QUEST_RUNNER_CLAUDE` or `PATH`. State lives in `$QUEST_RUNNER_HOME`, by default
+agents run with every tool allowed (Claude Code's `bypassPermissions`), and a
+job resumes with another maintainer's answer only once you approve it in the
+inbox. opencode runs as `opencode serve` on localhost behind a password made for each turn.
+
+The flake's `runner` package is a `quest` whose Claude Code and opencode are
+pinned by this repository's lock (`nix run github:kixelated/quest#runner -- runner`);
+otherwise `claude` and `opencode` come from `QUEST_RUNNER_CLAUDE` and
+`QUEST_RUNNER_OPENCODE`, or `PATH`. State lives in `$QUEST_RUNNER_HOME`, by default
 `$XDG_DATA_HOME/quest/runner`. To keep a runner up, run `quest runner` as a user
 service, such as a systemd user unit with `Restart=on-failure`.
 
diff --git a/bun.lock b/bun.lock
index ba2088a6..e822aaf7 100644
--- a/bun.lock
+++ b/bun.lock
@@ -5,6 +5,7 @@
     "": {
       "name": "quest",
       "dependencies": {
+        "@opencode-ai/sdk": "1.18.34",
         "commander": "15.0.0",
         "mdast-util-from-markdown": "2.1.0",
         "mdast-util-gfm-strikethrough": "2.0.1",
@@ -201,6 +202,8 @@
 
     "@noble/hashes": ["@noble/hashes@2.4.0", "", {}, "sha512-X5XaVWZIBCT7HHZGm5I7ZQXDwLG+bGXuSrMQAW+7Zvl87h1kmc1ZB1VSRJcpUfoUrGQp4Fkoxm5kZ+Ms+aW+eA=="],
 
+    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.18.34", "", { "dependencies": { "cross-spawn": "7.0.6" } }, "sha512-R9QWUpcngtdQ6FCixz7NC6n1WsSho6CEuRUzYHz/CzZcp3miSklDzXkm0oDwXVCnuEu+ANoeM0f6RDp51kOMzQ=="],
+
     "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.43.0", "", {}, "sha512-eSYWTm620tTk45EKSedaUL8MFYI8hW164hIXsgIHyxu3VobUB3fFCu5t0hQby6OoWRPsG1KkKUG2M5UadiLiVg=="],
 
     "@oxc-project/types": ["@oxc-project/types@0.152.0", "", {}, "sha512-oM/5rLBm2tPkg0iBgkH/FOeR3PCDpY19GTgAZjMFM8h9WI9VW7cLgzp6nwtarYKmovavIQZ+Fe/RKX/8C8O/Rw=="],
@@ -359,6 +362,8 @@
 
     "cookie": ["cookie@1.1.1", "", {}, "sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ=="],
 
+    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
+
     "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
 
     "decode-named-character-reference": ["decode-named-character-reference@1.3.0", "", { "dependencies": { "character-entities": "^2.0.0" } }, "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q=="],
@@ -387,6 +392,8 @@
 
     "hono": ["hono@4.13.13", "", {}, "sha512-CQ46U0ZkAGmbT/4UxdzzGJpacP2IeKgY4a5/tOI9AABbpOMfK739wfDXmv1usCk+3RkKj1hQy4/fjhiwa2xlrA=="],
 
+    "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
+
     "jose": ["jose@6.2.12", "", {}, "sha512-9NiFmJEex0sy2Dk58j2UGBSHgUs2ypF9eZSu4L6vjOX3Dp96Sw1F3uL+H+D1sx02jZZdzUT0HgvCy59CuvXcWw=="],
 
     "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="],
@@ -495,6 +502,8 @@
 
     "obug": ["obug@2.2.1", "", {}, "sha512-XrsrhT5sybtKI6wakr2SPOlGZWWYbUXZ7a0jT8/QOeAPau+1X/bSegNe5YR75oJmEZQbKningirmGOEJCIk61Q=="],
 
+    "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
+
     "path-to-regexp": ["path-to-regexp@6.3.0", "", {}, "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ=="],
 
     "pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
@@ -527,6 +536,10 @@
 
     "sharp": ["sharp@0.35.5", "", { "dependencies": { "@img/colour": "^1.1.0", "detect-libc": "^2.1.2", "semver": "^7.8.5" }, "optionalDependencies": { "@img/sharp-darwin-arm64": "0.35.5", "@img/sharp-darwin-x64": "0.35.5", "@img/sharp-freebsd-wasm32": "0.35.5", "@img/sharp-libvips-darwin-arm64": "1.3.4", "@img/sharp-libvips-darwin-x64": "1.3.4", "@img/sharp-libvips-linux-arm": "1.3.4", "@img/sharp-libvips-linux-arm64": "1.3.4", "@img/sharp-libvips-linux-ppc64": "1.3.4", "@img/sharp-libvips-linux-riscv64": "1.3.4", "@img/sharp-libvips-linux-s390x": "1.3.4", "@img/sharp-libvips-linux-x64": "1.3.4", "@img/sharp-libvips-linuxmusl-arm64": "1.3.4", "@img/sharp-libvips-linuxmusl-x64": "1.3.4", "@img/sharp-linux-arm": "0.35.5", "@img/sharp-linux-arm64": "0.35.5", "@img/sharp-linux-ppc64": "0.35.5", "@img/sharp-linux-riscv64": "0.35.5", "@img/sharp-linux-s390x": "0.35.5", "@img/sharp-linux-x64": "0.35.5", "@img/sharp-linuxmusl-arm64": "0.35.5", "@img/sharp-linuxmusl-x64": "0.35.5", "@img/sharp-webcontainers-wasm32": "0.35.5", "@img/sharp-win32-arm64": "0.35.5", "@img/sharp-win32-ia32": "0.35.5", "@img/sharp-win32-x64": "0.35.5" } }, "sha512-Ywn4OnzGukp7CDMrp08RQ50YKmuwG47brZgIVPTvBaaAfQlRlygrRqSrxdCiL9M+LlzLBiJ68IR1QqvzHyjC7g=="],
 
+    "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="],
+
+    "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
+
     "source-map-js": ["source-map-js@1.2.2", "", {}, "sha512-KGj/8Y43x35aZVDtt+J4mK1hoLGHULMYfSkODJNQjNDC3oW1PqPoxMwo0pLUsWM/UEGzON/NxeHywEfNXNP3Vw=="],
 
     "std-env": ["std-env@4.3.0", "", {}, "sha512-OtU/EgQ1kIm5KwqQpBC6ZEMXrZRui11w8zgfTWp8cdO9B8OaPsbA8bTHO2P+HNo1VlUTGMVBwPhydu6poeXiag=="],
@@ -563,6 +576,8 @@
 
     "vitest": ["vitest@5.0.3", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/mocker": "5.0.3", "chai": "^6.2.2", "es-module-lexer": "^2.3.2", "expect-type": "^1.4.0", "magic-string": "^1.2.3", "obug": "^2.1.4", "picomatch": "^4.0.7", "std-env": "^4.2.0", "tinybench": "^6.1.4", "tinyexec": "^1.3.0", "tinyglobby": "^0.2.17", "why-is-node-running": "3.2.1" }, "peerDependencies": { "@edge-runtime/vm": "*", "@opentelemetry/api": "^1.9.0", "@types/node": "^22.0.0 || >=24.0.0", "@vitest/browser-playwright": "5.0.3", "@vitest/browser-preview": "5.0.3", "@vitest/browser-webdriverio": "^5.0.0-beta.5 || >=5.0.0", "@vitest/coverage-istanbul": "5.0.3", "@vitest/coverage-v8": "5.0.3", "@vitest/ui": "5.0.3", "happy-dom": "*", "jsdom": "*", "vite": "^6.4.0 || ^7.0.0 || ^8.0.0" }, "optionalPeers": ["@edge-runtime/vm", "@opentelemetry/api", "@types/node", "@vitest/browser-playwright", "@vitest/browser-preview", "@vitest/browser-webdriverio", "@vitest/coverage-istanbul", "@vitest/coverage-v8", "@vitest/ui", "happy-dom", "jsdom"], "bin": "vitest.mjs" }, "sha512-xMw97S3rjdtj5dkVat7jCsqWBpvchs3RlpQctUqwJD0KkERk40vz2fJ77lDwW/Vzh/pk18eItYAzkodhSes3jQ=="],
 
+    "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
+
     "why-is-node-running": ["why-is-node-running@3.2.1", "", { "bin": "cli.js" }, "sha512-Tb2FUhB4vUsGQlfSquQLYkApkuPAFQXGFzxWKHHumVz2dK+X1RUm/HnID4+TfIGYJ1kTcwOaCk/buYCEJr6YjQ=="],
 
     "workerd": ["workerd@1.20261012.1", "", { "optionalDependencies": { "@cloudflare/workerd-darwin-64": "1.20261012.1", "@cloudflare/workerd-darwin-arm64": "1.20261012.1", "@cloudflare/workerd-linux-64": "1.20261012.1", "@cloudflare/workerd-linux-arm64": "1.20261012.1", "@cloudflare/workerd-windows-64": "1.20261012.1" }, "bin": "bin/workerd" }, "sha512-tEHoMPsMga0seVjxfsR8Pd3f8IRqYwkq++dTUKI5Gdgj6zuSDluYwisydq+dn90SsIACwBquJUQ1nBpcOqaWTA=="],
diff --git a/flake.nix b/flake.nix
index ba92332a..f9353698 100644
--- a/flake.nix
+++ b/flake.nix
@@ -35,12 +35,17 @@
             paths = [ quest ];
             nativeBuildInputs = [ pkgs.makeWrapper ];
             postBuild = ''
-              wrapProgram $out/bin/quest --set-default QUEST_RUNNER_CLAUDE ${pkgs.lib.getExe pkgs.claude-code}
+              wrapProgram $out/bin/quest \
+                --set-default QUEST_RUNNER_CLAUDE ${pkgs.lib.getExe pkgs.claude-code} \
+                --set-default QUEST_RUNNER_OPENCODE ${pkgs.lib.getExe pkgs.opencode}
             '';
             meta = quest.meta;
           };
+          manifest = pkgs.lib.importJSON ./package.json;
           # package.json's packageManager pins Bun for CI runners without Nix.
-          bunVersion = pkgs.lib.removePrefix "bun@" (pkgs.lib.importJSON ./package.json).packageManager;
+          bunVersion = pkgs.lib.removePrefix "bun@" manifest.packageManager;
+          # The runner drives the pinned opencode through the SDK of the same release.
+          opencodeSdk = manifest.dependencies."@opencode-ai/sdk";
         in
         {
           packages = {
@@ -73,6 +78,13 @@
               fi
               touch "$out"
             '';
+            opencode-sdk = pkgs.runCommand "opencode-sdk" { } ''
+              if [ "${pkgs.opencode.version}" != "${opencodeSdk}" ]; then
+                echo "package.json pins @opencode-ai/sdk ${opencodeSdk}, but the runner pins opencode ${pkgs.opencode.version}" >&2
+                exit 1
+              fi
+              touch "$out"
+            '';
             quest-tree = pkgs.runCommand "quest-tree" { nativeBuildInputs = [ quest ]; } ''
               quest --root ${self} check
               touch "$out"
diff --git a/package.json b/package.json
index 2d882f1c..fd0febc9 100644
--- a/package.json
+++ b/package.json
@@ -26,6 +26,7 @@
 		"fix": "prettier --write ."
 	},
 	"dependencies": {
+		"@opencode-ai/sdk": "1.18.34",
 		"commander": "15.0.0",
 		"mdast-util-from-markdown": "2.1.0",
 		"mdast-util-gfm-strikethrough": "2.0.1",
diff --git a/quest/m0/kix/README.md b/quest/m0/kix/README.md
index 8da0e5e8..f8128571 100644
--- a/quest/m0/kix/README.md
+++ b/quest/m0/kix/README.md
@@ -107,6 +107,13 @@ fixes what it finds:
 - A rejected `rate_limit_event` and its `resetsAt` arrive when a plan runs
   out, so the account sits out until its reset instead of the one-hour
   fallback.
+- opencode accounts (shipped with stubbed servers and a free model) sign in
+  to an OpenCode Go plan and a ChatGPT plan, the latter through its headless
+  method on a remote runner, and run a job on opencode's default model or
+  `--model`. Their limits pause the account until the reset: OpenCode Go's
+  `account_rate_limit` retry, and ChatGPT's `usage_limit_reached` error with
+  `resets_at`. If ChatGPT plans fall short through opencode, plan the Codex
+  adapter the 2026-10-15 decision allows.
 
 ## Required
 
@@ -115,7 +122,6 @@ fixes what it finds:
 - [Operator setup](/quest/m0/kix/operator-setup.md) - fork namespace, pilot installations, and a verified test PR
 - [Per-project forks](/quest/m0/kix/forks.md) - each project publishes through its own fork, recorded by repository ID
 - [Job sandbox](/quest/m0/kix/sandbox.md) - OS-sandboxed commands, with untrusted PR devShells built in a VM on Linux runners
-- [opencode adapter](/quest/m0/kix/opencode.md) - OpenCode Go, ChatGPT plans, and API-key providers through opencode
 - [Merge jobs](/quest/m0/kix/merge-job.md) - a merge pick fixes conflicts, CI, and reviews on a runner, then lands the PR
 - [Agent activity](/quest/m0/kix/activity.md) - agent cards and map highlights built from checkpoint summaries
 - [Web planning](/quest/m0/kix/planning.md) - issue-to-quest interviews produce draft planning PRs
diff --git a/quest/m0/kix/opencode.md b/quest/m0/kix/opencode.md
deleted file mode 100644
index 6880b2a8..00000000
--- a/quest/m0/kix/opencode.md
+++ /dev/null
@@ -1,26 +0,0 @@
-# [M] Drive opencode from the runner
-
-## Goal
-
-A runner offers opencode accounts alongside Claude Code ones, so a
-maintainer can run jobs with an OpenCode Go plan, a ChatGPT plan, or an API
-key for any provider opencode supports. Jobs behave the same as Claude Code
-jobs in the UI: questions, checkpoint summaries, and results.
-
-## Plan
-
-- Decided 2026-10-15: Claude Code and opencode are the two m0 adapters.
-  opencode covers OpenCode Go, ChatGPT/Codex plans, and API-key providers. Add
-  a separate Codex adapter only if opencode's ChatGPT support falls short.
-- Drive the headless `opencode serve` HTTP/OpenAPI server through its
-  TypeScript SDK and Server-Sent Events, bound to localhost with server
-  authentication. Pin opencode through the runner's Nix closure.
-- Give each account its own isolated opencode config/data home. opencode
-  dropped Claude subscription login in March 2026, so Claude subscriptions
-  stay on the Claude Code adapter.
-- Verify that structured questions, the checkpoint status tool, resume, and
-  cancellation map onto the shared adapter interface without
-  provider-specific behavior leaking into the service.
-- Sources: [OpenCode Go](https://opencode.ai/docs/go/),
-  [server](https://opencode.ai/docs/server/), and
-  [Sign in with ChatGPT](https://help.openai.com/articles/20001542).
diff --git a/quest/m1/cloud/funding.md b/quest/m1/cloud/funding.md
index 19941b42..08c029e0 100644
--- a/quest/m1/cloud/funding.md
+++ b/quest/m1/cloud/funding.md
@@ -54,7 +54,6 @@ cloud runners; donor allocations follow working cloud runners separately.
 ## Required
 
 - [Job sandbox](/quest/m0/kix/sandbox.md) - the boundary keeping provider credentials outside job commands
-- [opencode adapter](/quest/m0/kix/opencode.md) - the supported API-provider adapter
 
 ## Related
 
diff --git a/src/cli/main.ts b/src/cli/main.ts
index 913501db..d5a97bbb 100644
--- a/src/cli/main.ts
+++ b/src/cli/main.ts
@@ -3,7 +3,7 @@
 import { realpathSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
 
-import { Command, CommanderError, InvalidArgumentError, Option } from "commander";
+import { Argument, Command, CommanderError, InvalidArgumentError, Option } from "commander";
 
 import { description, version } from "../../package.json";
 import {
@@ -28,6 +28,7 @@ import {
 	removeAccount,
 	runRunner,
 } from "../runner/cli";
+import type { AdapterName } from "../runner/adapter";
 import { held, reach, target, upstream, upstreamHead } from "./claims";
 import { gate } from "./gate";
 import { gitHubDependencies, GitHubInputError, mergedHead, pullRequest, remoteUrl } from "./github";
@@ -705,7 +706,7 @@ export function main(argv: string[], out: Output): number | Promise<number> {
 			"Turn this Linux or macOS machine into a kix runner. `quest runner login` connects it to your kix " +
 				"account, `quest runner account add` signs agent accounts in with their own CLIs, and `quest runner` " +
 				"runs routed jobs in the foreground until interrupted.\n\n" +
-				"Each account signs in through Claude Code's own flow in an isolated home (CLAUDE_CONFIG_DIR); kix " +
+				"Each account signs in through its CLI's own flow, Claude Code or opencode, in an isolated home; kix " +
 				"stores only an opaque account id, its kind, and its label, and never sees its tokens. Every job runs " +
 				"inside its project's `nix develop` shell. State lives in $QUEST_RUNNER_HOME, by default " +
 				"$XDG_DATA_HOME/quest/runner.",
@@ -730,11 +731,18 @@ export function main(argv: string[], out: Output): number | Promise<number> {
 	const account = runner.command("account").description("Add, list, and remove this runner's agent accounts");
 	account
 		.command("add")
-		.description("Sign a Claude Code account in with `claude auth login` in a new isolated home")
-		.option("--console", "Sign in with an Anthropic Console account (API billing) instead of a subscription")
-		.option("--label <label>", "The name kix shows for the account (default: its email and plan)")
-		.action((options: { console?: boolean; label?: string }) =>
-			runnerAction(() => addAccount(runnerIO(), { console: !!options.console, label: options.label })),
+		.description(
+			"Sign an account in with its CLI's own flow in a new isolated home: `claude auth login` for Claude " +
+				"Code, or `opencode auth login` for an OpenCode Go plan, a ChatGPT plan, or any provider's API key",
+		)
+		.addArgument(new Argument("[cli]", "The agent CLI").choices(["claude", "opencode"]).default("claude"))
+		.option("--console", "Claude Code: sign in with an Anthropic Console account (API billing)")
+		.option("--model <provider/model>", "opencode: the model this account's jobs use (default: opencode's)")
+		.option("--label <label>", "The name kix shows for the account (default: its email or providers)")
+		.action((cli: AdapterName, options: { console?: boolean; model?: string; label?: string }) =>
+			runnerAction(() =>
+				addAccount(runnerIO(), { cli, console: !!options.console, model: options.model, label: options.label }),
+			),
 		);
 	account
 		.command("list")
diff --git a/src/runner/adapter.ts b/src/runner/adapter.ts
index 1b1fb279..00be2559 100644
--- a/src/runner/adapter.ts
+++ b/src/runner/adapter.ts
@@ -1,10 +1,39 @@
-// How a runner drives one agent CLI. The interface stays small so another
-// CLI (opencode) fits it: sign an account in, start or resume a session with
-// the kix tools attached, stream its raw output, stop it, and read how it ended.
+// How a runner drives one agent CLI, Claude Code or opencode. The interface
+// stays small: sign an account in, start or resume a session with the kix
+// tools attached, stream its raw output, stop it, and read how it ended.
 // Questions, checkpoints, and delivery reach kix through those tools, not
 // through anything CLI-specific.
+import { strippedEnvironment } from "../cli/agent";
 import type { AccountKind } from "./home";
 
+/** The agent CLIs a runner drives. */
+export type AdapterName = "claude" | "opencode";
+
+/** How long a stopped agent has to exit before it is killed. */
+export const STOP_GRACE_MS = 10_000;
+
+/**
+ * Signal the process group a detached CLI leads, so stopping it also stops
+ * the devShell and every tool it started.
+ */
+export function signalGroup(pid: number | undefined, name: NodeJS.Signals): void {
+	if (pid === undefined) return;
+	try {
+		process.kill(-pid, name);
+	} catch {}
+}
+
+/**
+ * The user's environment for an account's CLI, without other harnesses'
+ * state, keys, or GitHub tokens: kix publishes, and the agent never pushes.
+ */
+export function baseEnvironment(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+	const kept = strippedEnvironment(env);
+	delete kept.GH_TOKEN;
+	delete kept.GITHUB_TOKEN;
+	return kept;
+}
+
 export interface Launch {
 	/** The job's checkout, where the agent works. */
 	cwd: string;
@@ -42,16 +71,16 @@ export interface Running {
 }
 
 export interface SignedIn {
+	/** The provider kix shows for the account, such as anthropic or openai. */
+	provider: string;
 	kind: AccountKind;
 	/** A label for the account, such as its email. */
 	label: string;
 }
 
 export interface Adapter {
-	readonly name: "claude";
-	/** The provider kix shows for this adapter's accounts. */
-	readonly provider: string;
-	/** Run the CLI's own interactive sign-in in `home`. */
+	readonly name: AdapterName;
+	/** Run the CLI's own interactive sign-in in `home`. `console` picks Claude Code's Console billing. */
 	login(home: string, options: { console: boolean }): Promise<void>;
 	/** Whether `home` holds a signed-in account, and what kind. */
 	status(home: string): Promise<SignedIn | null>;
diff --git a/src/runner/claude.ts b/src/runner/claude.ts
index d7792d80..36c8a6e6 100644
--- a/src/runner/claude.ts
+++ b/src/runner/claude.ts
@@ -9,24 +9,23 @@ import { constants } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
 
-import { boundedLines, LINE_LIMIT, strippedEnvironment } from "../cli/agent";
-import type { Adapter, Exit, Launch, Running, SignedIn } from "./adapter";
+import { boundedLines, LINE_LIMIT } from "../cli/agent";
+import {
+	type Adapter,
+	baseEnvironment,
+	type Exit,
+	type Launch,
+	type Running,
+	type SignedIn,
+	signalGroup,
+	STOP_GRACE_MS,
+} from "./adapter";
 
 const run = promisify(execFile);
 
-/** How long a stopped agent has to exit before it is killed. */
-export const STOP_GRACE_MS = 10_000;
-
-/**
- * The environment for an account's CLI: the user's, without other harnesses'
- * state, keys, or GitHub tokens (kix publishes; the agent never pushes), and
- * with the account's own home.
- */
+/** The environment for an account's Claude Code, with the account's own home. */
 export function accountEnvironment(env: NodeJS.ProcessEnv, home: string): NodeJS.ProcessEnv {
-	const kept = strippedEnvironment(env);
-	delete kept.GH_TOKEN;
-	delete kept.GITHUB_TOKEN;
-	return { ...kept, CLAUDE_CONFIG_DIR: home };
+	return { ...baseEnvironment(env), CLAUDE_CONFIG_DIR: home };
 }
 
 function json(line: string): Record<string, unknown> | undefined {
@@ -80,7 +79,6 @@ export function streamReader() {
 
 export class Claude implements Adapter {
 	readonly name = "claude";
-	readonly provider = "anthropic";
 
 	/** `binary` is an absolute path, resolved before entering a devShell that could shadow it. */
 	constructor(
@@ -117,7 +115,7 @@ export class Claude implements Adapter {
 		const email = typeof status.email === "string" ? status.email : undefined;
 		const plan = typeof status.subscriptionType === "string" ? status.subscriptionType : undefined;
 		const label = [email ?? "Claude Code", plan && `(${plan})`].filter(Boolean).join(" ");
-		return { kind, label };
+		return { provider: "anthropic", kind, label };
 	}
 
 	launch(launch: Launch): Running {
@@ -172,11 +170,7 @@ export class Claude implements Adapter {
 		});
 		child.stdin.on("error", () => {});
 		child.stdin.end(launch.prompt);
-		const signal = (name: NodeJS.Signals) => {
-			try {
-				process.kill(-child.pid!, name);
-			} catch {}
-		};
+		const signal = (name: NodeJS.Signals) => signalGroup(child.pid, name);
 		let killer: ReturnType<typeof setTimeout> | undefined;
 		const done = new Promise<Exit>((resolve) => {
 			child.once("error", (error: NodeJS.ErrnoException) => {
diff --git a/src/runner/cli.ts b/src/runner/cli.ts
index f983245d..4b3fa01f 100644
--- a/src/runner/cli.ts
+++ b/src/runner/cli.ts
@@ -7,8 +7,9 @@ import { hostname } from "node:os";
 import { delimiter, isAbsolute, join } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 
-import type { Adapter } from "./adapter";
+import type { Adapter, AdapterName } from "./adapter";
 import { Claude } from "./claude";
+import { Opencode } from "./opencode";
 import { type Account, type Login, RunnerHome, defaultHome } from "./home";
 import type { Job } from "./protocol";
 import { Runner } from "./runner";
@@ -44,24 +45,31 @@ export function which(name: string, env: NodeJS.ProcessEnv): string | undefined
 	return undefined;
 }
 
+const CLIS: Record<AdapterName, { binary: string; variable: string; product: string }> = {
+	claude: { binary: "claude", variable: "QUEST_RUNNER_CLAUDE", product: "Claude Code" },
+	opencode: { binary: "opencode", variable: "QUEST_RUNNER_OPENCODE", product: "opencode" },
+};
+
 /**
- * The Claude Code binary: `QUEST_RUNNER_CLAUDE`, or `claude` on PATH. It is
- * resolved before any devShell is entered, so a project cannot substitute
- * its own `claude` for the one the account signed in with.
+ * An agent CLI's binary: its `QUEST_RUNNER_*` variable, or the CLI on PATH.
+ * It is resolved before any devShell is entered, so a project cannot
+ * substitute its own CLI for the one the account signed in with.
  */
-export function claudeBinary(env: NodeJS.ProcessEnv): string {
-	const configured = env.QUEST_RUNNER_CLAUDE;
+export function cliBinary(name: AdapterName, env: NodeJS.ProcessEnv): string {
+	const { binary, variable, product } = CLIS[name];
+	const configured = env[variable];
 	if (configured) {
-		if (!isAbsolute(configured)) throw new RunnerInputError("QUEST_RUNNER_CLAUDE must be an absolute path");
+		if (!isAbsolute(configured)) throw new RunnerInputError(`${variable} must be an absolute path`);
 		return configured;
 	}
-	const found = which("claude", env);
-	if (!found) throw new RunnerInputError("claude is not installed; install Claude Code or set QUEST_RUNNER_CLAUDE");
+	const found = which(binary, env);
+	if (!found) throw new RunnerInputError(`${binary} is not installed; install ${product} or set ${variable}`);
 	return found;
 }
 
-function adapterFor(io: RunnerIO): Adapter {
-	return new Claude(claudeBinary(io.env), "bypassPermissions", io.env);
+export function adapterFor(name: AdapterName, env: NodeJS.ProcessEnv): Adapter {
+	const binary = cliBinary(name, env);
+	return name === "opencode" ? new Opencode(binary, env) : new Claude(binary, "bypassPermissions", env);
 }
 
 function home(io: RunnerIO): RunnerHome {
@@ -111,22 +119,33 @@ export async function login(
 }
 
 /** Sign a new account in with its CLI's own flow, in its own home. */
-export async function addAccount(io: RunnerIO, options: { console: boolean; label?: string }): Promise<number> {
+export async function addAccount(
+	io: RunnerIO,
+	options: { cli: AdapterName; console: boolean; label?: string; model?: string },
+): Promise<number> {
 	platform();
 	const label = options.label?.trim();
 	if (label !== undefined && (!label || label.length > 100))
 		throw new RunnerInputError("--label must be 1 to 100 characters");
+	if (options.console && options.cli !== "claude")
+		throw new RunnerInputError("--console is for Claude Code; opencode asks how to sign in");
+	const model = options.model?.trim();
+	if (model !== undefined && options.cli !== "opencode")
+		throw new RunnerInputError("--model is for opencode; Claude Code picks its own");
+	if (model !== undefined && !/^[^/\s]+\/\S+$/.test(model))
+		throw new RunnerInputError("--model must be provider/model, such as openai/gpt-5.5");
 	const state = home(io);
-	const adapter = adapterFor(io);
+	const adapter = adapterFor(options.cli, io.env);
 	const { id, home: dir } = state.newAccount();
 	try {
 		await adapter.login(dir, { console: options.console });
 		const signedIn = await adapter.status(dir);
 		if (!signedIn) throw new Error("the account did not finish signing in");
+		if (model) Opencode.setModel(dir, model);
 		const account: Account = {
 			id,
 			adapter: adapter.name,
-			provider: adapter.provider,
+			provider: signedIn.provider,
 			kind: signedIn.kind,
 			label: label ?? signedIn.label.slice(0, 100),
 		};
@@ -171,8 +190,12 @@ export async function runRunner(io: RunnerIO, options: { slots: number }): Promi
 	const state = home(io);
 	const current = state.login();
 	if (!current) throw new RunnerInputError("this machine is not signed in; run `quest runner login` first");
-	if (!state.accounts().length) throw new RunnerInputError("no accounts; add one with `quest runner account add`");
-	const adapter = adapterFor(io);
+	const accounts = state.accounts();
+	if (!accounts.length) throw new RunnerInputError("no accounts; add one with `quest runner account add`");
+	// Only the CLIs some account uses, each resolved once, before any job enters a devShell.
+	const adapters = new Map<AdapterName, Adapter>();
+	for (const account of accounts)
+		if (!adapters.has(account.adapter)) adapters.set(account.adapter, adapterFor(account.adapter, io.env));
 	if (!which("nix", io.env))
 		throw new RunnerInputError("nix is not installed; every job runs in its project's devShell");
 	try {
@@ -188,7 +211,12 @@ export async function runRunner(io: RunnerIO, options: { slots: number }): Promi
 		home: state,
 		login: current,
 		slots: options.slots,
-		adapter: () => adapter,
+		// An account added while the runner runs uses a CLI resolved then.
+		adapter: (account) => {
+			let adapter = adapters.get(account.adapter);
+			if (!adapter) adapters.set(account.adapter, (adapter = adapterFor(account.adapter, io.env)));
+			return adapter;
+		},
 		shell: devShell,
 		remote: (job) => `https://github.com/${job.owner}/${job.name}.git`,
 		env: io.env,
diff --git a/src/runner/home.ts b/src/runner/home.ts
index 08eb39b8..905996f8 100644
--- a/src/runner/home.ts
+++ b/src/runner/home.ts
@@ -8,6 +8,7 @@ import { join } from "node:path";
 
 import { privateDirectory } from "../cli/agent";
 import { save } from "../cli/worktree";
+import type { AdapterName } from "./adapter";
 
 /** The runner's kix sign-in, from `quest runner login`. */
 export interface Login {
@@ -25,8 +26,8 @@ export type AccountKind = "subscription" | "api-key";
 export interface Account {
 	/** Opaque and stable across restarts, so kix keeps its preference rank and paused sessions. */
 	id: string;
-	/** The CLI that drives it. Only Claude Code ships so far. */
-	adapter: "claude";
+	/** The CLI that drives it. */
+	adapter: AdapterName;
 	provider: string;
 	kind: AccountKind;
 	label: string;
diff --git a/src/runner/opencode.ts b/src/runner/opencode.ts
new file mode 100644
index 00000000..ee150d34
--- /dev/null
+++ b/src/runner/opencode.ts
@@ -0,0 +1,385 @@
+// The opencode adapter. It runs the unmodified `opencode` binary as a headless
+// `opencode serve` on localhost behind a per-launch password and drives one
+// session through its SDK: each turn is one prompt, and the session's events
+// stream as raw output. Each account signs in with opencode's own
+// `auth login` in its own XDG home; the runner reads only which providers that
+// home signed in to, never the credentials. The kix tools attach as a remote
+// MCP server, and opencode's question tool is denied so every question goes
+// through kix's `ask` instead.
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import {
+	type AssistantMessage,
+	createOpencodeClient,
+	type Event,
+	type Part,
+	type SessionStatus,
+} from "@opencode-ai/sdk/v2/client";
+
+import { boundedLines, LINE_LIMIT } from "../cli/agent";
+import {
+	type Adapter,
+	baseEnvironment,
+	type Exit,
+	type Launch,
+	type Running,
+	type SignedIn,
+	signalGroup,
+	STOP_GRACE_MS,
+} from "./adapter";
+
+/** The XDG base directories opencode keeps its config, credentials, sessions, and caches in, with their defaults. */
+const XDG = {
+	XDG_CONFIG_HOME: ".config",
+	XDG_DATA_HOME: join(".local", "share"),
+	XDG_CACHE_HOME: ".cache",
+	XDG_STATE_HOME: join(".local", "state"),
+} as const;
+
+/** An account's own XDG directories, under its home. */
+export function accountDirectories(home: string): Record<keyof typeof XDG, string> {
+	return {
+		XDG_CONFIG_HOME: join(home, "config"),
+		XDG_DATA_HOME: join(home, "data"),
+		XDG_CACHE_HOME: join(home, "cache"),
+		XDG_STATE_HOME: join(home, "state"),
+	};
+}
+
+/** The user's environment for opencode, without the user's own opencode settings. */
+function environment(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+	return Object.fromEntries(Object.entries(baseEnvironment(env)).filter(([name]) => !name.startsWith("OPENCODE_")));
+}
+
+/**
+ * The XDG directories the agent's commands get back: the user's, so tools
+ * such as nix and git read their usual config rather than the account's.
+ */
+function userDirectories(env: NodeJS.ProcessEnv): Record<string, string> {
+	const home = env.HOME || homedir();
+	return Object.fromEntries(Object.entries(XDG).map(([name, fallback]) => [name, env[name] || join(home, fallback)]));
+}
+
+/**
+ * An opencode plugin that gives the agent's commands the user's XDG
+ * directories back, since opencode passes its own environment to them.
+ */
+const PLUGIN = `export default {
+	id: "quest-runner",
+	server: async (_input, options) => ({
+		"shell.env": async (_context, output) => {
+			Object.assign(output.env, options.env);
+		},
+	}),
+};
+`;
+
+export interface Credential {
+	/** opencode's provider ID, such as openai or opencode-go. */
+	provider: string;
+	/** How it signed in: oauth for a plan login, api for a key. */
+	type: string;
+}
+
+/** Which providers an account's home signed in to, from opencode's credential file, without the credentials. */
+export function credentials(home: string): Credential[] {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(
+			readFileSync(join(accountDirectories(home).XDG_DATA_HOME, "opencode", "auth.json"), "utf8"),
+		);
+	} catch {
+		return [];
+	}
+	if (!parsed || typeof parsed !== "object") return [];
+	return Object.entries(parsed).flatMap(([provider, value]) => {
+		const type = (value as { type?: unknown } | null)?.type;
+		return typeof type === "string" ? [{ provider: provider.replace(/\/+$/, ""), type }] : [];
+	});
+}
+
+/** What kix shows for a credential, and whether it is a plan rather than a metered key. */
+function describe({ provider, type }: Credential): { name: string; plan: boolean } {
+	if (provider === "openai" && type === "oauth") return { name: "ChatGPT", plan: true };
+	if (provider === "opencode-go") return { name: "OpenCode Go", plan: true };
+	if (type === "oauth") return { name: provider, plan: true };
+	return { name: `${provider} API key`, plan: false };
+}
+
+/** An account that signed in to any provider, labelled by them all. */
+export function signedIn(found: Credential[]): SignedIn | null {
+	if (!found.length) return null;
+	const described = found.map(describe);
+	return {
+		// kix accepts letters, digits, `-`, and `_`; custom provider IDs may hold more.
+		provider: found[0]!.provider.replace(/[^\w-]/g, "-").slice(0, 64),
+		kind: described.some((d) => d.plan) ? "subscription" : "api-key",
+		label: `${described.map((d) => d.name).join(", ")} (opencode)`,
+	};
+}
+
+/** Messages a provider sends when the plan or key cannot pay for more, as opposed to a brief rate limit. */
+const LIMIT =
+	/usage limit|usage_limit_reached|insufficient_quota|quota exceeded|exceeded your current quota|free usage exceeded/i;
+
+/**
+ * Whether a retry opencode is waiting on is an account limit: an OpenCode Go
+ * limit retries when it resets, and other limits only say so in the message.
+ * opencode would otherwise wait until the reset, however far off.
+ */
+export function retryLimit(status: SessionStatus): Exit["limited"] {
+	if (status.type !== "retry") return null;
+	if (status.action?.reason === "account_rate_limit") return { until: status.next };
+	if (status.action?.reason === "free_tier_limit" || LIMIT.test(status.message)) return { until: null };
+	return null;
+}
+
+function object(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
+}
+
+/** When a limit resets, from a ChatGPT-style error body or a `retry-after` header. */
+function resets(body: string | undefined, headers: Record<string, string> | undefined, now: number): number | null {
+	let error: Record<string, unknown> | undefined;
+	try {
+		error = object(object(JSON.parse(body ?? ""))?.error);
+	} catch {}
+	if (typeof error?.resets_at === "number") return error.resets_at * 1000;
+	if (typeof error?.resets_in_seconds === "number") return now + error.resets_in_seconds * 1000;
+	const after = Number(headers?.["retry-after"]);
+	return after > 0 ? now + after * 1000 : null;
+}
+
+/** How a turn ended, from its last assistant message and any limit seen while it ran. */
+export function turnExit(
+	info: AssistantMessage | undefined,
+	parts: Part[],
+	limited: Exit["limited"],
+	now = Date.now(),
+): Exit {
+	const error = info?.error;
+	if (!limited && error?.name === "APIError") {
+		const { message, responseBody, responseHeaders } = error.data;
+		if (LIMIT.test(`${message}\n${responseBody ?? ""}`))
+			limited = { until: resets(responseBody, responseHeaders, now) };
+	}
+	const text = parts
+		.flatMap((part) => (part.type === "text" && !part.synthetic ? [part.text] : []))
+		.join("\n")
+		.trim();
+	const message = (error?.data as { message?: unknown } | undefined)?.message;
+	return {
+		limited,
+		failed: !info || error !== undefined,
+		reply: text || (typeof message === "string" ? message : error?.name),
+	};
+}
+
+export class Opencode implements Adapter {
+	readonly name = "opencode";
+
+	/** `binary` is an absolute path, resolved before entering a devShell that could shadow it. */
+	constructor(
+		readonly binary: string,
+		readonly env: NodeJS.ProcessEnv = process.env,
+	) {}
+
+	/** opencode's own sign-in, which asks for the provider and how to sign in to it. */
+	async login(home: string): Promise<void> {
+		await new Promise<void>((resolve, reject) => {
+			const child = spawn(this.binary, ["auth", "login"], {
+				env: { ...environment(this.env), ...accountDirectories(home) },
+				stdio: "inherit",
+			});
+			child.once("error", reject);
+			child.once("close", (code) =>
+				code === 0 ? resolve() : reject(new Error(`opencode auth login exited ${code}`)),
+			);
+		});
+	}
+
+	async status(home: string): Promise<SignedIn | null> {
+		return signedIn(credentials(home));
+	}
+
+	/** Pick the account's model in its own opencode config, which applies to every job it runs. */
+	static setModel(home: string, model: string): void {
+		const dir = join(accountDirectories(home).XDG_CONFIG_HOME, "opencode");
+		mkdirSync(dir, { recursive: true, mode: 0o700 });
+		writeFileSync(join(dir, "opencode.json"), `${JSON.stringify({ model }, null, "\t")}\n`, { mode: 0o600 });
+	}
+
+	launch(launch: Launch): Running {
+		const password = randomBytes(32).toString("base64url");
+		// Kept in the account's private home: a session ID per kix session, and the per-launch plugin.
+		const sessions = join(launch.home, "kix-sessions");
+		const plugin = join(launch.home, `kix-${launch.session}.js`);
+		writeFileSync(plugin, PLUGIN, { mode: 0o600 });
+		const config = {
+			autoupdate: false,
+			share: "disabled",
+			// Only what the account signed in to, not keys the user's environment happens to hold.
+			enabled_providers: credentials(launch.home).map((c) => c.provider),
+			permission: { "*": "allow", question: "deny" },
+			mcp: {
+				kix: {
+					type: "remote",
+					url: launch.tools.url,
+					headers: { Authorization: `Bearer ${launch.tools.token}` },
+					oauth: false,
+				},
+			},
+			plugin: [[pathToFileURL(plugin).href, { env: userDirectories(launch.env) }]],
+		};
+		// The account's XDG directories apply to opencode alone: the devShell's nix reads the user's.
+		const xdg = Object.entries(accountDirectories(launch.home)).map(([name, dir]) => `${name}=${dir}`);
+		const argv = [
+			...launch.shell,
+			"/usr/bin/env",
+			...xdg,
+			this.binary,
+			"serve",
+			"--hostname=127.0.0.1",
+			"--port=0",
+		];
+		// The password and the tools' bearer token stay out of the command line, which other users can read.
+		const child = spawn(argv[0]!, argv.slice(1), {
+			cwd: launch.cwd,
+			env: {
+				...environment(launch.env),
+				OPENCODE_SERVER_PASSWORD: password,
+				OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
+			},
+			stdio: ["ignore", "pipe", "pipe"],
+			// Its own process group, so stopping it also stops the devShell and every tool it started.
+			detached: true,
+		});
+
+		let stderr = "";
+		let listening: (url: string | null) => void = () => {};
+		const url = new Promise<string | null>((resolve) => (listening = resolve));
+		const lines = boundedLines(LINE_LIMIT, (line) => {
+			const found = /^opencode server listening on (http:\/\/\S+)/.exec(line);
+			if (found) listening(found[1]!);
+		});
+		child.stdout.setEncoding("utf8").on("data", (chunk: string) => {
+			lines.data(chunk);
+			launch.output(chunk);
+		});
+		child.stderr.setEncoding("utf8").on("data", (chunk: string) => {
+			stderr = (stderr + chunk).slice(-64 * 1024);
+			launch.output(chunk);
+		});
+		const closed = new Promise<void>((resolve) => {
+			child.once("error", (error) => {
+				stderr += `could not start ${argv[0]}: ${error.message}\n`;
+				resolve();
+			});
+			child.once("close", () => resolve());
+		});
+		void closed.then(() => listening(null));
+
+		let stopping = false;
+		let killer: ReturnType<typeof setTimeout> | undefined;
+		let abort: () => Promise<unknown> = async () => {};
+		let watched: Promise<void> = Promise.resolve();
+		const tail = () => stderr.trim().split("\n").slice(-20).join("\n");
+		const failure = (reply: string): Exit => ({ limited: null, failed: true, reply: reply || undefined });
+
+		const turn = async (): Promise<Exit> => {
+			const base = await url;
+			if (!base) return failure(tail());
+			const client = createOpencodeClient({
+				baseUrl: base,
+				directory: launch.cwd,
+				headers: { Authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}` },
+			});
+			let session: string | undefined;
+			if (launch.resume) {
+				try {
+					session = readFileSync(join(sessions, launch.session), "utf8").trim();
+				} catch {
+					return failure(`opencode has no session for ${launch.session} in this account`);
+				}
+			} else {
+				const created = await client.session.create({});
+				if (!created.data)
+					return failure(`opencode could not create a session: ${JSON.stringify(created.error)}`);
+				session = created.data.id;
+				mkdirSync(sessions, { recursive: true, mode: 0o700 });
+				writeFileSync(join(sessions, launch.session), session, { mode: 0o600 });
+			}
+			abort = () => client.session.abort({ sessionID: session });
+			if (stopping) return failure("stopped");
+
+			let limited: Exit["limited"] = null;
+			let connected: () => void = () => {};
+			const ready = new Promise<void>((resolve) => (connected = resolve));
+			const ignore = () => {};
+			// The stream ends when the server stops; aborting it instead leaves the SDK an unhandled rejection.
+			watched = (async () => {
+				const { stream } = await client.event.subscribe({}, { sseMaxRetryAttempts: 1 });
+				for await (const event of stream as AsyncIterable<Event>) {
+					connected();
+					const { properties } = event as { properties: { sessionID?: string } };
+					// Token deltas repeat what the finished parts carry; other sessions' events are not this job's.
+					if (properties.sessionID !== session || event.type.endsWith(".delta")) continue;
+					launch.output(`${JSON.stringify(event)}\n`);
+					if (event.type === "session.status") {
+						const hit = retryLimit(event.properties.status);
+						if (hit && !limited) {
+							limited = hit;
+							abort().catch(ignore);
+						}
+					} else if (event.type === "permission.asked") {
+						// Every tool is allowed, as Claude Code's bypassPermissions; a project's own rules may still ask.
+						client.permission.reply({ requestID: event.properties.id, reply: "once" }).catch(ignore);
+					} else if (event.type === "question.asked") {
+						client.question.reject({ requestID: event.properties.id }).catch(ignore);
+					}
+				}
+			})()
+				.catch(ignore)
+				.finally(connected);
+			await ready;
+			const reply = await client.session.prompt({
+				sessionID: session,
+				system: launch.system,
+				parts: [{ type: "text", text: launch.prompt }],
+			});
+			if (!reply.data)
+				return { ...failure(`opencode refused the prompt: ${JSON.stringify(reply.error)}`), limited };
+			return turnExit(reply.data.info, reply.data.parts, limited);
+		};
+
+		const done = turn()
+			// The server's own last words explain a lost connection better than the client's error.
+			.catch((error: unknown) => failure(tail() || (error instanceof Error ? error.message : String(error))))
+			.then(async (exit) => {
+				signalGroup(child.pid, "SIGTERM");
+				killer ??= setTimeout(() => signalGroup(child.pid, "SIGKILL"), STOP_GRACE_MS);
+				await closed;
+				await watched;
+				clearTimeout(killer);
+				lines.end();
+				rmSync(plugin, { force: true });
+				return exit;
+			});
+		return {
+			done,
+			stop() {
+				stopping = true;
+				// Abort the turn so opencode records it, then stop the server whether or not it answered.
+				abort()
+					.catch(() => {})
+					.finally(() => signalGroup(child.pid, "SIGTERM"));
+				killer ??= setTimeout(() => signalGroup(child.pid, "SIGKILL"), STOP_GRACE_MS);
+			},
+		};
+	}
+}
diff --git a/src/runner/runner.ts b/src/runner/runner.ts
index eba10e71..b1c2d259 100644
--- a/src/runner/runner.ts
+++ b/src/runner/runner.ts
@@ -104,7 +104,7 @@ export class Runner {
 		const now = this.#now();
 		return this.options.home.accounts().map((account) => ({
 			id: account.id,
-			provider: this.options.adapter(account).provider,
+			provider: account.provider,
 			kind: account.kind,
 			label: account.label,
 			limited: (account.limitedUntil ?? 0) > now,
diff --git a/test/runner.test.ts b/test/runner.test.ts
index 7f7f544f..99c7f98f 100644
--- a/test/runner.test.ts
+++ b/test/runner.test.ts
@@ -3,11 +3,13 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, symlinkSync, writeFileS
 import { join } from "node:path";
 import { describe, expect, test, vi } from "vitest";
 
+import type { AdapterName } from "../src/runner/adapter";
 import { Claude, streamReader } from "../src/runner/claude";
-import { devShell, login } from "../src/runner/cli";
+import { addAccount, devShell, login, RunnerInputError } from "../src/runner/cli";
 import { Connection, type Socket, backoff } from "../src/runner/connection";
 import { type Account, RunnerHome } from "../src/runner/home";
 import { serveTools } from "../src/runner/mcp";
+import { accountDirectories, credentials, Opencode, retryLimit, signedIn, turnExit } from "../src/runner/opencode";
 import { FLUSH_BYTES, OutputUploader, split } from "../src/runner/output";
 import { formatAnswer, resumePrompt, startPrompt } from "../src/runner/prompt";
 import type { Job } from "../src/runner/protocol";
@@ -327,6 +329,70 @@ describe("Claude Code output", () => {
 	});
 });
 
+describe("opencode", () => {
+	test("labels an account by the providers its home signed in to", () => {
+		const home = tempDir();
+		expect(credentials(home)).toEqual([]);
+		const data = join(accountDirectories(home).XDG_DATA_HOME, "opencode");
+		mkdirSync(data, { recursive: true });
+		writeFileSync(
+			join(data, "auth.json"),
+			JSON.stringify({ openai: { type: "oauth", access: "a" }, "opencode-go": { type: "api", key: "k" } }),
+		);
+		expect(signedIn(credentials(home))).toEqual({
+			provider: "openai",
+			kind: "subscription",
+			label: "ChatGPT, OpenCode Go (opencode)",
+		});
+		expect(signedIn([{ provider: "wafer.ai", type: "api" }])).toEqual({
+			provider: "wafer-ai",
+			kind: "api-key",
+			label: "wafer.ai API key (opencode)",
+		});
+		expect(signedIn([])).toBeNull();
+	});
+
+	test("reads account limits from retries and errors, not brief rate limits", () => {
+		const retry = { type: "retry" as const, attempt: 1, next: 1_900_000_000_000 };
+		expect(
+			retryLimit({
+				...retry,
+				message: "Go limit reached",
+				action: { reason: "account_rate_limit", provider: "opencode-go", title: "", message: "", label: "" },
+			}),
+		).toEqual({ until: 1_900_000_000_000 });
+		expect(retryLimit({ ...retry, message: "The usage limit has been reached" })).toEqual({ until: null });
+		expect(retryLimit({ ...retry, message: "Rate limit reached for requests" })).toBeNull();
+		expect(retryLimit({ type: "busy" })).toBeNull();
+
+		const now = 1_000_000;
+		const api = (message: string, responseBody?: string, responseHeaders?: Record<string, string>) =>
+			({
+				role: "assistant",
+				error: { name: "APIError", data: { message, isRetryable: false, responseBody, responseHeaders } },
+			}) as never;
+		expect(
+			turnExit(
+				api("Too many", JSON.stringify({ error: { type: "usage_limit_reached", resets_at: 1_900_000 } })),
+				[],
+				null,
+				now,
+			).limited,
+		).toEqual({ until: 1_900_000_000 });
+		expect(turnExit(api("Quota exceeded.", "", { "retry-after": "60" }), [], null, now).limited).toEqual({
+			until: now + 60_000,
+		});
+		expect(turnExit(api("Bad request"), [], null, now)).toEqual({
+			limited: null,
+			failed: true,
+			reply: "Bad request",
+		});
+		expect(
+			turnExit({ role: "assistant" } as never, [{ type: "text", text: "All done" } as never], null, now),
+		).toEqual({ limited: null, failed: false, reply: "All done" });
+	});
+});
+
 describe("kix tools", () => {
 	test("speak MCP over HTTP to the attempt's agent only", async () => {
 		const server = await serveTools([
@@ -444,6 +510,45 @@ describe("prompts", () => {
 	});
 });
 
+describe("account add", () => {
+	posix("signs an opencode account in with its own flow in its own home", async () => {
+		const dir = tempDir();
+		const bin = join(dir, "bin");
+		mkdirSync(bin);
+		// opencode's sign-in stores the credential under its XDG data home.
+		writeFileSync(
+			join(bin, "opencode"),
+			`#!/bin/sh\nmkdir -p "$XDG_DATA_HOME/opencode"\necho '{"opencode-go":{"type":"api","key":"k"}}' > "$XDG_DATA_HOME/opencode/auth.json"\n`,
+		);
+		chmodSync(join(bin, "opencode"), 0o755);
+		const out: string[] = [];
+		const io = {
+			stdout: (text: string) => out.push(text),
+			stderr: () => {},
+			env: { ...process.env, PATH: `${bin}:${process.env.PATH}`, QUEST_RUNNER_HOME: join(dir, "home") },
+		};
+		await expect(addAccount(io, { cli: "opencode", console: true })).rejects.toThrow(RunnerInputError);
+		await expect(addAccount(io, { cli: "opencode", console: false, model: "gpt" })).rejects.toThrow(
+			RunnerInputError,
+		);
+		expect(await addAccount(io, { cli: "opencode", console: false, model: "opencode-go/kimi-k3" })).toBe(0);
+		const home = new RunnerHome(join(dir, "home"));
+		const [account] = home.accounts();
+		expect(account).toMatchObject({
+			adapter: "opencode",
+			provider: "opencode-go",
+			kind: "subscription",
+			label: "OpenCode Go (opencode)",
+		});
+		const config = join(
+			accountDirectories(home.accountHome(account!.id)).XDG_CONFIG_HOME,
+			"opencode",
+			"opencode.json",
+		);
+		expect(JSON.parse(readFileSync(config, "utf8"))).toEqual({ model: "opencode-go/kimi-k3" });
+	});
+});
+
 describe("login", () => {
 	posix("connects once the owner approves the link, keeping the token local", async () => {
 		const home = tempDir();
@@ -517,6 +622,80 @@ async function rpc(method, params) {
 })();
 `;
 
+/**
+ * A fake `opencode serve` that runs the same steps as the fake `claude` on
+ * each prompt: it checks the password, streams events, and ends a waiting
+ * turn when the session is aborted.
+ */
+const FAKE_OPENCODE = `
+const fs = require("node:fs");
+const http = require("node:http");
+const argv = process.argv.slice(2);
+const log = (value) => fs.appendFileSync(process.env.FAKE_LOG, JSON.stringify(value) + "\\n");
+const config = JSON.parse(process.env.OPENCODE_CONFIG_CONTENT);
+const auth = "Basic " + Buffer.from("opencode:" + process.env.OPENCODE_SERVER_PASSWORD).toString("base64");
+const kix = config.mcp.kix;
+const streams = [];
+const send = (event) => { for (const s of streams) s.write("data: " + JSON.stringify(event) + "\\n\\n"); };
+let aborted = () => {};
+let sessions = 0;
+let id = 0;
+async function rpc(method, params) {
+	const response = await fetch(kix.url, {
+		method: "POST",
+		headers: { ...kix.headers, "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
+		body: JSON.stringify({ jsonrpc: "2.0", id: ++id, method, params }),
+	});
+	return (await response.json()).result;
+}
+const body = (request) => new Promise((resolve) => {
+	let text = "";
+	request.on("data", (chunk) => (text += chunk));
+	request.on("end", () => resolve(text ? JSON.parse(text) : {}));
+});
+const json = (response, value) => response.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(value));
+async function prompt(session, input) {
+	const steps = JSON.parse(fs.readFileSync(process.env.FAKE_STEPS, "utf8"));
+	const resume = fs.existsSync(process.env.FAKE_LOG) && fs.readFileSync(process.env.FAKE_LOG, "utf8").includes('"prompted":"' + session + '"');
+	log({
+		argv, cwd: process.cwd(), stdin: input.parts[0].text, system: input.system, session, prompted: session,
+		xdg: process.env.XDG_DATA_HOME, gh: process.env.GH_TOKEN ?? null, config,
+	});
+	await rpc("initialize", { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "fake", version: "0" } });
+	for (const step of steps[resume ? "resume" : "start"] ?? []) {
+		if (step.write) fs.writeFileSync(step.write, step.content);
+		if (step.remove) fs.rmSync(step.remove);
+		if (step.emit) send({ ...step.emit, properties: { ...step.emit.properties, sessionID: session } });
+		if (step.tool) log({ tool: step.tool, reply: await rpc("tools/call", { name: step.tool, arguments: step.args }) });
+		if (step.wait) {
+			await new Promise((resolve) => (aborted = resolve));
+			log({ aborted: session });
+			return { info: { role: "assistant", error: { name: "MessageAbortedError", data: { message: "Aborted" } } }, parts: [] };
+		}
+	}
+	return { info: { role: "assistant", finish: "stop" }, parts: [{ type: "text", text: "done" }] };
+}
+const server = http.createServer(async (request, response) => {
+	if (request.headers.authorization !== auth) return response.writeHead(401).end();
+	const path = new URL(request.url, "http://x").pathname;
+	if (path === "/event") {
+		response.writeHead(200, { "Content-Type": "text/event-stream" });
+		streams.push(response);
+		return response.write("data: " + JSON.stringify({ type: "server.connected", properties: {} }) + "\\n\\n");
+	}
+	if (path === "/session") return json(response, { id: "ses_" + ++sessions + "_" + process.pid });
+	const message = /^\\/session\\/([^/]+)\\/message$/.exec(path);
+	if (message) return json(response, await prompt(message[1], await body(request)));
+	if (/\\/abort$/.test(path)) {
+		aborted();
+		return json(response, true);
+	}
+	response.writeHead(404).end();
+});
+process.on("SIGTERM", () => process.exit(143));
+server.listen(0, "127.0.0.1", () => console.log("opencode server listening on http://127.0.0.1:" + server.address().port));
+`;
+
 /** A fake `nix` that runs `develop ... --command <argv>` in place. */
 const FAKE_NIX = `
 const fs = require("node:fs");
@@ -548,11 +727,12 @@ function rig(
 		body: Sent,
 		upstream: { dir: string; commit: string },
 	) => { status: number; body: unknown } | undefined,
+	cli: AdapterName = "claude",
 ): Rig {
 	const dir = tempDir();
 	const bin = join(dir, "bin");
 	mkdirSync(bin);
-	for (const [name, body] of Object.entries({ claude: FAKE_CLAUDE, nix: FAKE_NIX })) {
+	for (const [name, body] of Object.entries({ claude: FAKE_CLAUDE, opencode: FAKE_OPENCODE, nix: FAKE_NIX })) {
 		writeFileSync(join(bin, name), `#!${process.execPath}\n${body}`);
 		chmodSync(join(bin, name), 0o755);
 	}
@@ -561,12 +741,17 @@ function rig(
 	const home = new RunnerHome(join(dir, "home"));
 	const account: Account = {
 		id: "acct1",
-		adapter: "claude",
-		provider: "anthropic",
+		adapter: cli,
+		provider: cli === "claude" ? "anthropic" : "openai",
 		kind: "subscription",
 		label: "me@example.test",
 	};
 	home.saveAccounts([account]);
+	if (cli === "opencode") {
+		const data = join(accountDirectories(home.accountHome("acct1")).XDG_DATA_HOME, "opencode");
+		mkdirSync(data, { recursive: true });
+		writeFileSync(join(data, "auth.json"), JSON.stringify({ openai: { type: "oauth", access: "secret" } }));
+	}
 	const hub = new FakeHub();
 	const publishes: Sent[] = [];
 	const contexts: string[] = [];
@@ -584,7 +769,10 @@ function rig(
 		home,
 		login: { url: "http://kix.test", token: "token", id: "r1", name: "laptop" },
 		slots: 2,
-		adapter: () => new Claude(join(bin, "claude"), "bypassPermissions", env),
+		adapter: () =>
+			cli === "claude"
+				? new Claude(join(bin, "claude"), "bypassPermissions", env)
+				: new Opencode(join(bin, "opencode"), env),
 		shell: devShell,
 		remote: () => source.dir,
 		env,
@@ -769,6 +957,102 @@ describe("quest runner", () => {
 		await r.runner.shutdown();
 	});
 
+	posix("drives opencode serve through a question and a resume in the same session", async () => {
+		const r = rig(undefined, "opencode");
+		r.steps({
+			start: [
+				{ write: "a.txt", content: "draft\n" },
+				{ tool: "checkpoint", args: { summary: "Drafted" } },
+				{
+					tool: "ask",
+					args: { summary: "Need a choice", questions: [{ question: "Which?", options: [{ label: "A" }] }] },
+				},
+			],
+			resume: [{ tool: "deliver", args: { summary: "Went with A", title: "feat: a", body: "Body" } }],
+		});
+		r.assign(job(r.upstream.commit), "Extra rule.");
+		const question = await r.hub.next((m) => m.type === "question");
+		await idle(r.runner);
+		expect(r.hub.of("checkpoint")).toMatchObject([{ summary: "Drafted", session: question.session }]);
+		const [nix, first] = r.calls();
+		expect(nix).toEqual({ nix: ["develop", "--accept-flake-config", "--no-write-lock-file"] });
+		const home = r.home.accountHome("acct1");
+		// The account's XDG home applies to opencode alone, set inside the devShell.
+		expect(first.argv).toEqual(["serve", "--hostname=127.0.0.1", "--port=0"]);
+		expect(first.xdg).toBe(join(home, "data"));
+		expect(first.gh).toBeNull();
+		expect(first.stdin).toContain("kix adds for this job: Extra rule.");
+		expect(first.system).toContain("checkpoint");
+		expect(first.config).toMatchObject({
+			enabled_providers: ["openai"],
+			permission: { "*": "allow", question: "deny" },
+			mcp: { kix: { type: "remote", headers: { Authorization: expect.stringMatching(/^Bearer /) } } },
+		});
+		expect(first.config.plugin[0][1].env.XDG_DATA_HOME).not.toContain(home);
+		// Events stream as raw output.
+		expect(
+			r.hub
+				.of("output")
+				.map((o) => o.text)
+				.join(""),
+		).toContain("opencode server listening");
+
+		r.assign(
+			job(r.upstream.commit, {
+				attempt: 2,
+				session: question.session,
+				head: "0".repeat(39) + "1",
+				questions: [
+					{
+						id: "q1",
+						attempt: 1,
+						kind: "agent",
+						prompt: question.prompt,
+						answer: { answers: [{ choices: ["A"] }] },
+						approvedAt: 1,
+					},
+				],
+			}),
+		);
+		const result = await r.result();
+		await idle(r.runner);
+		expect(result).toMatchObject({ attempt: 2, outcome: "completed", summary: "Went with A" });
+		const resumed = r.calls().filter((c) => c.prompted);
+		expect(resumed).toHaveLength(2);
+		// The kix session maps to the opencode session that asked.
+		expect(resumed[1].session).toBe(first.session);
+		expect(resumed[1].stdin).toContain("Q: Which?\nA: A");
+		await r.runner.shutdown();
+	});
+
+	posix("aborts opencode on a cancel or an account limit", async () => {
+		const r = rig(undefined, "opencode");
+		r.steps({ start: [{ write: "a.txt", content: "partial\n" }, ready, { wait: true }] });
+		r.assign(job(r.upstream.commit));
+		await waiting(r);
+		r.hub.socket.deliver({ type: "cancel", job: "job1", attempt: 1 });
+		const cancelled = await r.result();
+		await idle(r.runner);
+		expect(cancelled).toMatchObject({ outcome: "cancelled" });
+		expect(r.calls().some((c) => c.aborted)).toBe(true);
+
+		const resets = Date.now() + 3_600_000;
+		const status = {
+			type: "retry",
+			attempt: 1,
+			message: "Go limit",
+			next: resets,
+			action: { reason: "account_rate_limit" },
+		};
+		r.steps({ start: [{ emit: { type: "session.status", properties: { status } } }, { wait: true }] });
+		r.assign(job(r.upstream.commit, { id: "job2" }));
+		const limited = await r.hub.next((m) => m.type === "result" && m.job === "job2");
+		await idle(r.runner);
+		expect(limited).toMatchObject({ outcome: "limited" });
+		expect(r.home.accounts()[0]!.limitedUntil).toBe(resets);
+		await r.runner.shutdown();
+	});
+
 	posix("cancels on request, publishing the partial work", async () => {
 		const r = rig();
 		r.steps({

From b2dfa2340ee46aa37261be07d5b10241b490cc0f Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Sat, 24 Oct 2026 00:20:29 -0700
Subject: [PATCH 3/4] chore(deps): bump @opencode-ai/sdk to the pinned opencode
 1.19.0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 bun.lock     | 4 ++--
 package.json | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/bun.lock b/bun.lock
index 04287065..2f4195fa 100644
--- a/bun.lock
+++ b/bun.lock
@@ -5,7 +5,7 @@
     "": {
       "name": "quest",
       "dependencies": {
-        "@opencode-ai/sdk": "1.18.34",
+        "@opencode-ai/sdk": "1.19.0",
         "commander": "15.0.0",
         "mdast-util-from-markdown": "2.1.0",
         "mdast-util-gfm-strikethrough": "2.0.1",
@@ -202,7 +202,7 @@
 
     "@noble/hashes": ["@noble/hashes@2.4.0", "", {}, "sha512-X5XaVWZIBCT7HHZGm5I7ZQXDwLG+bGXuSrMQAW+7Zvl87h1kmc1ZB1VSRJcpUfoUrGQp4Fkoxm5kZ+Ms+aW+eA=="],
 
-    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.18.34", "", { "dependencies": { "cross-spawn": "7.0.6" } }, "sha512-R9QWUpcngtdQ6FCixz7NC6n1WsSho6CEuRUzYHz/CzZcp3miSklDzXkm0oDwXVCnuEu+ANoeM0f6RDp51kOMzQ=="],
+    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.19.0", "", { "dependencies": { "cross-spawn": "7.0.6" } }, "sha512-lDFYTD6qxzq1mfwxF6Kq1DAs6rEwF4xoZ2I3G1sB7hAZ8Yb28JurtSmmcK7ZzZ8Z4qBUYbZimHJ6DM4JFq5amw=="],
 
     "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.43.0", "", {}, "sha512-eSYWTm620tTk45EKSedaUL8MFYI8hW164hIXsgIHyxu3VobUB3fFCu5t0hQby6OoWRPsG1KkKUG2M5UadiLiVg=="],
 
diff --git a/package.json b/package.json
index 5ec35f41..5e773c37 100644
--- a/package.json
+++ b/package.json
@@ -26,7 +26,7 @@
 		"fix": "prettier --write ."
 	},
 	"dependencies": {
-		"@opencode-ai/sdk": "1.18.34",
+		"@opencode-ai/sdk": "1.19.0",
 		"commander": "15.0.0",
 		"mdast-util-from-markdown": "2.1.0",
 		"mdast-util-gfm-strikethrough": "2.0.1",

From faddef8fb0143a76220e0c0750186088951d06ee Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Sat, 24 Oct 2026 00:30:09 -0700
Subject: [PATCH 4/4] fix(runner): keep user provider keys from opencode and
 enforce the account model

Provider credentials in the runner's environment could outrank the account's own sign-in, and a project's opencode.json could override the account's --model. Strip credential-named variables from opencode's environment, and pass the account's model in the launch config, which loads after project config.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/runner/opencode.ts | 44 +++++++++++++++++++++++++++++++++++-------
 test/runner.test.ts    | 22 ++++++++++++++++++++-
 2 files changed, 58 insertions(+), 8 deletions(-)

diff --git a/src/runner/opencode.ts b/src/runner/opencode.ts
index ee150d34..1017c3a2 100644
--- a/src/runner/opencode.ts
+++ b/src/runner/opencode.ts
@@ -10,7 +10,7 @@ import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 
 import {
@@ -51,9 +51,36 @@ export function accountDirectories(home: string): Record<keyof typeof XDG, strin
 	};
 }
 
-/** The user's environment for opencode, without the user's own opencode settings. */
-function environment(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
-	return Object.fromEntries(Object.entries(baseEnvironment(env)).filter(([name]) => !name.startsWith("OPENCODE_")));
+/**
+ * Variables opencode would read in place of the account's own sign-in: the
+ * user's opencode settings, and provider credentials, which some providers
+ * prefer over a stored key. Matched by name, since every provider names its own.
+ */
+const UNSET = [
+	/^OPENCODE_/,
+	/_(API_KEY|API_TOKEN|AUTH_TOKEN|ACCESS_KEY(_ID)?|SECRET_ACCESS_KEY|SESSION_TOKEN)$/,
+	/BEARER_TOKEN/,
+];
+
+/** The user's environment for opencode, so only the account's sign-in pays for its jobs. */
+export function environment(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+	return Object.fromEntries(
+		Object.entries(baseEnvironment(env)).filter(([name]) => !UNSET.some((pattern) => pattern.test(name))),
+	);
+}
+
+/** The model the account picked with `--model`, from its own opencode config. */
+function accountModel(home: string): string | undefined {
+	try {
+		const { model } = JSON.parse(readFileSync(modelConfig(home), "utf8")) as { model?: unknown };
+		return typeof model === "string" ? model : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function modelConfig(home: string): string {
+	return join(accountDirectories(home).XDG_CONFIG_HOME, "opencode", "opencode.json");
 }
 
 /**
@@ -209,9 +236,9 @@ export class Opencode implements Adapter {
 
 	/** Pick the account's model in its own opencode config, which applies to every job it runs. */
 	static setModel(home: string, model: string): void {
-		const dir = join(accountDirectories(home).XDG_CONFIG_HOME, "opencode");
-		mkdirSync(dir, { recursive: true, mode: 0o700 });
-		writeFileSync(join(dir, "opencode.json"), `${JSON.stringify({ model }, null, "\t")}\n`, { mode: 0o600 });
+		const file = modelConfig(home);
+		mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+		writeFileSync(file, `${JSON.stringify({ model }, null, "\t")}\n`, { mode: 0o600 });
 	}
 
 	launch(launch: Launch): Running {
@@ -220,7 +247,10 @@ export class Opencode implements Adapter {
 		const sessions = join(launch.home, "kix-sessions");
 		const plugin = join(launch.home, `kix-${launch.session}.js`);
 		writeFileSync(plugin, PLUGIN, { mode: 0o600 });
+		const model = accountModel(launch.home);
 		const config = {
+			// The account's pick outranks a project's own opencode.json, which loads after the account's config.
+			...(model && { model }),
 			autoupdate: false,
 			share: "disabled",
 			// Only what the account signed in to, not keys the user's environment happens to hold.
diff --git a/test/runner.test.ts b/test/runner.test.ts
index 99c7f98f..e71b4670 100644
--- a/test/runner.test.ts
+++ b/test/runner.test.ts
@@ -9,7 +9,15 @@ import { addAccount, devShell, login, RunnerInputError } from "../src/runner/cli
 import { Connection, type Socket, backoff } from "../src/runner/connection";
 import { type Account, RunnerHome } from "../src/runner/home";
 import { serveTools } from "../src/runner/mcp";
-import { accountDirectories, credentials, Opencode, retryLimit, signedIn, turnExit } from "../src/runner/opencode";
+import {
+	accountDirectories,
+	credentials,
+	environment,
+	Opencode,
+	retryLimit,
+	signedIn,
+	turnExit,
+} from "../src/runner/opencode";
 import { FLUSH_BYTES, OutputUploader, split } from "../src/runner/output";
 import { formatAnswer, resumePrompt, startPrompt } from "../src/runner/prompt";
 import type { Job } from "../src/runner/protocol";
@@ -352,6 +360,16 @@ describe("opencode", () => {
 		expect(signedIn([])).toBeNull();
 	});
 
+	test("keeps the user's provider credentials and opencode settings from the account", () => {
+		const kept = environment({
+			PATH: "/bin",
+			CLOUDFLARE_API_KEY: "k",
+			AWS_SECRET_ACCESS_KEY: "s",
+			OPENCODE_CONFIG: "c",
+		});
+		expect(kept).toEqual({ PATH: "/bin" });
+	});
+
 	test("reads account limits from retries and errors, not brief rate limits", () => {
 		const retry = { type: "retry" as const, attempt: 1, next: 1_900_000_000_000 };
 		expect(
@@ -751,6 +769,7 @@ function rig(
 		const data = join(accountDirectories(home.accountHome("acct1")).XDG_DATA_HOME, "opencode");
 		mkdirSync(data, { recursive: true });
 		writeFileSync(join(data, "auth.json"), JSON.stringify({ openai: { type: "oauth", access: "secret" } }));
+		Opencode.setModel(home.accountHome("acct1"), "openai/gpt-5.5");
 	}
 	const hub = new FakeHub();
 	const publishes: Sent[] = [];
@@ -984,6 +1003,7 @@ describe("quest runner", () => {
 		expect(first.stdin).toContain("kix adds for this job: Extra rule.");
 		expect(first.system).toContain("checkpoint");
 		expect(first.config).toMatchObject({
+			model: "openai/gpt-5.5",
 			enabled_providers: ["openai"],
 			permission: { "*": "allow", question: "deny" },
 			mcp: { kix: { type: "remote", headers: { Authorization: expect.stringMatching(/^Bearer /) } } },