Delegate bounded coding tasks to OpenCode and review the results

Hands a bounded coding task to a separate implementer - the OpenCode CLI - then lets you review what it produced and land it yourself. You write the brief and own the judgment; OpenCode does the typing in its own session; you verify and commit. The loop needs only the ability to run a shell command and read a file, so any agent with those two capabilities can drive it - designed for and run on Claude Code, with other orchestrators treated as designed-for but not yet proven.

The loop is five steps. Steps 1, 4, and 5 are judgment calls; 2 and 3 are mechanical:

1. Write the brief. OpenCode sees only the text sent to it plus what it can read from the working tree - no chat history, no shared context. The brief needs the goal, the current state, what to change, what to leave untouched, the project's actual gate commands (discovered from the repo's AGENTS.md/CLAUDE.md/Makefile, never assumed), and a report contract. Tell OpenCode it will not commit, and keep one task per brief.
2. Dispatch the brief to OpenCode with the bundled relay helper, which wraps opencode run, captures the run, and writes a structured result.json. The helper defaults to the write-capable build agent, writes its artifacts to a temp dir so the repo under review stays clean, and never commits itself.
3. Wait for completion. The helper blocks until OpenCode finishes. A pre-run usage error (bad args or an empty brief) exits with code 2 and writes no result file. A missing opencode binary exits 127 but does write a result.json with status opencode_unavailable. A run is done when result.json exists with a status - trust that over any progress tracker. The implementer's full report is the finalMessage field in result.json, also printed on stdout between the report markers.
4. Review - do not trust the self-report. Re-run the project's gates yourself rather than taking "gates passed" on faith. Read the diff against the brief - did OpenCode do what was asked, nothing more and nothing less - starting from touchedFiles. Run relevant guard skills on the diff if installed. For schema/migration changes, round-trip them; for removals, grep for dangling references.
5. Land it. The implementer edits the working tree; the orchestrator commits, since committing should be the act of the party that verified the work. Only after gates pass and the diff holds: commit with a clear message, or send a delta brief with --resume-last for rework and review again.

Use it to hand off a bounded coding task to OpenCode and review the diff afterward, or when explicitly asked to delegate to this implementer.

Do NOT use it when the task is small enough to do inline, when the opencode CLI is not installed or not authenticated (opencode auth login), or when only a review is needed rather than an implementation - use the plan agent via --read-only instead of the write-capable default.

Prerequisites: opencode --version succeeds (install via npm i -g opencode-ai or the native installer from opencode.ai, then opencode auth login); confirm which opencode is on PATH with command -v opencode since the relay records the version it ran into result.json, making a stale binary visible after the fact; a model provider is authenticated, checked with opencode auth list; and you are in, or point --cd at, the target git repository.

OpenCode has no safe default - a bare opencode run errors - so a fresh run needs a model via --model or a fleet --lane that sets one (a resumed run inherits its session's model). The human owns which models are allowed to run, since opencode models lists hundreds of entries, most billed per token, and only the human knows which are flat-rate subscriptions - ideally stated once in the repo's AGENTS.md or CLAUDE.md. The orchestrator then picks per task from that allowed set, matching the model to the brief: cheap and fast for a mechanical sweep, strong for a subtle bug or a money/security path. If no usable set is stated, ask rather than guess from the catalog, since a wrong guess risks a metered model and a surprise bill.

node "<skill-dir>/scripts/relay.mjs" --brief brief.txt --model <provider/model> --cd /path/to/repo

--model (or a --lane that sets one) is required on a fresh run. --read-only runs the plan agent for review/diagnosis without edits. --resume-last continues the previous OpenCode session with a delta brief, keeping the model. --timeout 2h sets a hard watchdog limit (default off; implementation runs routinely need 1-2 hours).

OpenCode's autonomy is governed by the agent, not a sandbox enum: build (the relay default) is write-capable and edits files in the working dir headlessly; plan (via --read-only) is read-only and reviews or diagnoses without touching the tree. Permissions auto-approve by default - the relay passes --auto so a headless run never blocks on a prompt no one can answer, with the orchestrator's diff review as the safety net instead of a per-action prompt. --no-auto honors the agent's own permission config instead, and should be paired with an agent whose in-workspace permissions are set to allow, or a headless run can hang waiting on an ask. Read-only (plan) runs never get --auto, so a review can't be tricked into touching the tree.

Orchestrating agents or developers who want to delegate a bounded coding task to a separate OpenCode implementer session while keeping review and commit authority themselves.