duet-cli 0.2.5__tar.gz → 0.2.6__tar.gz

{duet_cli-0.2.5/duet_cli.egg-info → duet_cli-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duet-cli
-Version: 0.2.5
+Version: 0.2.6
 Summary: Two CLI agents in conversation. One Python file. Stdlib only.
 Author: Volkan Altan
 License-Expression: MIT
@@ -24,12 +24,12 @@ Dynamic: license-file
 **Two CLI agents in conversation. One Python file. Stdlib only.**
 
 `duet` runs two command-line coding agents in alternating turns until they
-agree. By default that is Claude and Codex; Gemini and Copilot are also
-supported, and you can pair two agents from the same backend. One agent plans
-or reviews while the other implements; each keeps its own session memory across
-turns, and every run leaves a transcript you can inspect.
+agree. By default that is Claude and Codex; Gemini, Copilot, and OpenCode are
+also supported, and you can pair two agents from the same backend. One agent
+plans or reviews while the other implements; each keeps its own session memory
+across turns, and every run leaves a transcript you can inspect.
 
-## Use it three ways
+## Use it four ways
 
 ### 1. Inside Claude Code — `/duet`
 
@@ -93,7 +93,26 @@ CLI, so install that first (see below) and make sure `command -v duet` passes in
 Codex's shell. Full guide:
 [docs/CODEX_PLUGIN.md](https://github.com/volkan/duet/blob/main/docs/CODEX_PLUGIN.md).
 
-### 3. From the terminal — `duet`
+### 3. Inside OpenCode — `/duet`
+
+OpenCode custom commands are drop-in files — no marketplace step:
+
+```bash
+mkdir -p ~/.config/opencode/command
+cp plugins/duet-opencode/command/duet.md ~/.config/opencode/command/duet.md
+```
+
+Then invoke `/duet` in the OpenCode TUI (or `opencode run --command duet "..."`
+non-interactively). Like the other plugins it shells out to the `duet` CLI, so
+install that first and make sure `command -v duet` passes in OpenCode's shell.
+The command runs on OpenCode's `build` agent; plain `/duet` runs the same
+`claude -p /review` kickoff, and `/duet 'npm test 2>&1' --turns 4` seeds from
+any command. Full guide:
+[docs/OPENCODE_PLUGIN.md](https://github.com/volkan/duet/blob/main/docs/OPENCODE_PLUGIN.md).
+(duet can also drive OpenCode as a backend — `--partner opencode:coder` — so
+OpenCode can be one of the two looped agents too.)
+
+### 4. From the terminal — `duet`
 
 ```bash
 pipx install duet-cli        # recommended; the command it installs is `duet`
@@ -172,8 +191,9 @@ coder fixes them). Run one with `duet --config examples/pr-review.yaml`.
 ## How it works
 
 Each agent keeps its own conversation memory across turns (Claude via
-`--resume`, Codex via `codex exec resume`, Gemini and Copilot via their JSON
-session ids). On each turn duet sends one agent's latest reply to the other.
+`--resume`, Codex via `codex exec resume`, Gemini, Copilot, and OpenCode via
+their JSON session ids). On each turn duet sends one agent's latest reply to the
+other.
 
 To converge, an agent must include an `LGTM rationale:` explaining why the work
 is done, followed by the sentinel `<<<LGTM>>>` on its own line — a bare
@@ -186,7 +206,7 @@ stderr logs, and the `wt/` worktree when `--worktree` is on. Inspect a run with
 `duet --status <run-id>`, list runs with `duet --list`, and start a fresh run
 from saved state with `duet --continue <run> --task "next thing"`.
 
-- **Backends:** `claude`, `codex`, `gemini`, `copilot`
+- **Backends:** `claude`, `codex`, `gemini`, `copilot`, `opencode`
 - **Roles:** `planner`, `coder`, `reviewer`, `triage-reviewer`, or a custom one
 - **Reasoning:** `--reasoning minimal|low|medium|high|xhigh|max`
 

{duet_cli-0.2.5 → duet_cli-0.2.6}/README.md

@@ -3,12 +3,12 @@
 **Two CLI agents in conversation. One Python file. Stdlib only.**
 
 `duet` runs two command-line coding agents in alternating turns until they
-agree. By default that is Claude and Codex; Gemini and Copilot are also
-supported, and you can pair two agents from the same backend. One agent plans
-or reviews while the other implements; each keeps its own session memory across
-turns, and every run leaves a transcript you can inspect.
+agree. By default that is Claude and Codex; Gemini, Copilot, and OpenCode are
+also supported, and you can pair two agents from the same backend. One agent
+plans or reviews while the other implements; each keeps its own session memory
+across turns, and every run leaves a transcript you can inspect.
 
-## Use it three ways
+## Use it four ways
 
 ### 1. Inside Claude Code — `/duet`
 
@@ -72,7 +72,26 @@ CLI, so install that first (see below) and make sure `command -v duet` passes in
 Codex's shell. Full guide:
 [docs/CODEX_PLUGIN.md](https://github.com/volkan/duet/blob/main/docs/CODEX_PLUGIN.md).
 
-### 3. From the terminal — `duet`
+### 3. Inside OpenCode — `/duet`
+
+OpenCode custom commands are drop-in files — no marketplace step:
+
+```bash
+mkdir -p ~/.config/opencode/command
+cp plugins/duet-opencode/command/duet.md ~/.config/opencode/command/duet.md
+```
+
+Then invoke `/duet` in the OpenCode TUI (or `opencode run --command duet "..."`
+non-interactively). Like the other plugins it shells out to the `duet` CLI, so
+install that first and make sure `command -v duet` passes in OpenCode's shell.
+The command runs on OpenCode's `build` agent; plain `/duet` runs the same
+`claude -p /review` kickoff, and `/duet 'npm test 2>&1' --turns 4` seeds from
+any command. Full guide:
+[docs/OPENCODE_PLUGIN.md](https://github.com/volkan/duet/blob/main/docs/OPENCODE_PLUGIN.md).
+(duet can also drive OpenCode as a backend — `--partner opencode:coder` — so
+OpenCode can be one of the two looped agents too.)
+
+### 4. From the terminal — `duet`
 
 ```bash
 pipx install duet-cli        # recommended; the command it installs is `duet`
@@ -151,8 +170,9 @@ coder fixes them). Run one with `duet --config examples/pr-review.yaml`.
 ## How it works
 
 Each agent keeps its own conversation memory across turns (Claude via
-`--resume`, Codex via `codex exec resume`, Gemini and Copilot via their JSON
-session ids). On each turn duet sends one agent's latest reply to the other.
+`--resume`, Codex via `codex exec resume`, Gemini, Copilot, and OpenCode via
+their JSON session ids). On each turn duet sends one agent's latest reply to the
+other.
 
 To converge, an agent must include an `LGTM rationale:` explaining why the work
 is done, followed by the sentinel `<<<LGTM>>>` on its own line — a bare
@@ -165,7 +185,7 @@ stderr logs, and the `wt/` worktree when `--worktree` is on. Inspect a run with
 `duet --status <run-id>`, list runs with `duet --list`, and start a fresh run
 from saved state with `duet --continue <run> --task "next thing"`.
 
-- **Backends:** `claude`, `codex`, `gemini`, `copilot`
+- **Backends:** `claude`, `codex`, `gemini`, `copilot`, `opencode`
 - **Roles:** `planner`, `coder`, `reviewer`, `triage-reviewer`, or a custom one
 - **Reasoning:** `--reasoning minimal|low|medium|high|xhigh|max`
 

{duet_cli-0.2.5 → duet_cli-0.2.6}/duet.py

@@ -28,8 +28,12 @@ Each agent keeps its own session across turns:
     UUID makes resume robust to parallel Codex sessions sharing the cwd, but
     `--last` is still keyed on cwd — use `--worktree` to isolate duet's Codex
     cwd from the host repo when no UUID is available.
+  - Gemini: `gemini -p ... --output-format json`; subsequent turns use
+    `gemini --resume <session_id>` from the JSON response.
   - Copilot: `copilot -p ... --output-format json`; subsequent turns use
     `copilot --resume=<sessionId>` from the JSONL result event.
+  - OpenCode: `opencode run --format json`; subsequent turns use
+    `opencode run -s <sessionID>` from the JSONL event stream.
 
 Transcript is always logged to runs/<ts>/transcript.md for humans, but each
 prompt sent to an agent is just the latest counterpart message — keeping
@@ -223,6 +227,18 @@ COPILOT_REASONING_MAP = {
 }
 COPILOT_REASONING_PROMPT_PREFIX = CLAUDE_REASONING_PROMPT_PREFIX
 
+# OpenCode exposes reasoning effort through `run --variant <value>`, documented
+# as "provider-specific reasoning effort (e.g. high, max, minimal)". The valid
+# set is model/provider-dependent, but OpenCode silently ignores a variant a
+# model doesn't define rather than erroring, so we pass duet's level through
+# unchanged (identity map): a model that knows the variant honors it, one that
+# doesn't is unaffected. This keeps the mapping forward-compatible without duet
+# tracking each provider's variant vocabulary.
+OPENCODE_REASONING_MAP = {level: level for level in REASONING_LEVELS}
+# `--variant` is the authoritative effort control; the high/xhigh/max prompt
+# nudges are belt-and-braces, same as Claude/Gemini/Copilot.
+OPENCODE_REASONING_PROMPT_PREFIX = CLAUDE_REASONING_PROMPT_PREFIX
+
 # Map duet's existing Claude-flavored permission mode knob to Gemini CLI's
 # approval vocabulary. Unknown values pass through so advanced users can try
 # newer Gemini modes without waiting for a duet release.
@@ -1498,6 +1514,145 @@ def call_copilot(agent: Agent, system_prompt: str, message: str,
     return text, new_sid
 
 
+def _parse_opencode_jsonl(stdout: str) -> tuple[str, Optional[str], Optional[str]]:
+    """Return (assistant_text, sessionID, error_message) from `opencode run --format json`.
+
+    OpenCode emits a JSONL event stream on stdout. Every event carries a
+    top-level `sessionID`; assistant reply text arrives as one or more
+    ``{"type":"text","part":{"type":"text","text":...}}`` events; failures
+    arrive as ``{"type":"error","error":{...}}`` events. Crucially, `opencode
+    run` exits 0 even on model/tool errors — the failure lives in the event
+    stream, not the exit code — so the caller must treat a returned
+    error_message as fatal.
+
+    Text parts that carry an id are keyed by it (last write wins) so a streamed
+    part re-emitted as it grows doesn't duplicate; the rare id-less part gets a
+    unique synthetic key (``__noid_<n>``) so distinct parts (e.g. text split
+    around a tool call) are still concatenated in arrival order without ever
+    aliasing a real id. Non-JSON lines are skipped rather than fatal: OpenCode
+    can print a one-time DB-migration banner on a fresh machine, and a genuine
+    failure still surfaces via a missing sessionID or an error event.
+    """
+    parts: dict[str, str] = {}
+    session_id: Optional[str] = None
+    error_message: Optional[str] = None
+    for raw_line in stdout.splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(event, dict):
+            continue
+        sid = event.get("sessionID")
+        if sid:
+            session_id = str(sid)
+        etype = event.get("type")
+        if etype == "text":
+            part = event.get("part")
+            if isinstance(part, dict) and part.get("type") == "text":
+                text = part.get("text")
+                if isinstance(text, str):
+                    # Real OpenCode parts always carry a stable id (prt_…). The
+                    # synthetic key keeps a rare id-less part distinct without
+                    # ever aliasing a real id like "0".
+                    raw_id = part.get("id")
+                    pid = str(raw_id) if raw_id else f"__noid_{len(parts)}"
+                    parts[pid] = text
+        elif etype == "error":
+            err = event.get("error")
+            if isinstance(err, str):
+                # OpenCode documents a dict error payload, but tolerate a
+                # plain-string one so the real cause is surfaced verbatim
+                # instead of degrading to "unknown error".
+                msg = err
+            else:
+                data = err.get("data") if isinstance(err, dict) else None
+                msg = data.get("message") if isinstance(data, dict) else None
+                if not msg and isinstance(err, dict):
+                    msg = err.get("name")
+            error_message = str(msg or "unknown error")
+    return "\n".join(parts.values()).rstrip(), session_id, error_message
+
+
+def call_opencode(agent: Agent, system_prompt: str, message: str,
+                  cwd: pathlib.Path, timeout: int, dry: bool,
+                  first_turn: bool, reasoning: Optional[str] = None,
+                  stderr_log_path: Optional[pathlib.Path] = None,
+                  pid_file_path: Optional[pathlib.Path] = None) -> tuple[str, Optional[str]]:
+    """Returns (assistant_text, new_session_id) from the OpenCode CLI JSONL stream."""
+    # OpenCode resume is id-keyed (`-s <sessionID>`) and the id is stable across
+    # turns, so there's no first-turn command bifurcation; the argument keeps the
+    # adapter dispatch signature aligned with Codex/Gemini/Copilot.
+    _ = first_turn
+    eff_cwd = agent.cwd_override or cwd
+    if reasoning:
+        prefix = backend_adapter("opencode").reasoning_prompt_prefix.get(reasoning, "")
+        system_prompt = prefix + system_prompt
+    if dry:
+        new_sid = agent.session_id or f"dry-opencode-{agent.name}-{int(time.time())}"
+        wt_note = f" wt={eff_cwd}" if agent.cwd_override else ""
+        rn = f" reasoning={reasoning}" if reasoning else ""
+        return (
+            f"[dry-run opencode/{agent.name}{wt_note}{rn}] received {len(message)} chars\n"
+            "LGTM rationale: dry-run accepted the harness path and has no real "
+            "agent output to review.\n"
+            f"{DEFAULT_SENTINEL}"
+        ), new_sid
+
+    full_prompt = f"=== ROLE ===\n{system_prompt}\n\n=== MESSAGE FROM PARTNER ===\n{message}"
+    # OpenCode permissions are native; like Copilot we run non-interactively and
+    # auto-approve so tool-using turns don't hang waiting for an approval that
+    # can never arrive. `--sandbox` / `permission_mode` do not apply. All options
+    # precede the positional message (the `run [message..]` positional is last).
+    cmd = [
+        "opencode", "run",
+        "--format", "json",
+        "--dir", str(eff_cwd),
+        "--dangerously-skip-permissions",
+    ]
+    if agent.session_id:
+        cmd += ["-s", agent.session_id]
+    if reasoning:
+        variant = backend_adapter("opencode").reasoning_map.get(reasoning, reasoning)
+        if variant:
+            cmd += ["--variant", variant]
+    if agent.model:
+        cmd += ["-m", agent.model]
+    cmd += agent.extra_args
+    cmd.append(full_prompt)
+    rc, out, err = _agent_run(
+        cmd,
+        backend="opencode",
+        cwd=eff_cwd,
+        stdin=None,
+        timeout=timeout,
+        stderr_log_path=stderr_log_path,
+        pid_file_path=pid_file_path,
+    )
+    if rc != 0:
+        reason = FINISHED_TIMEOUT if rc == 124 else FINISHED_AGENT_ERROR
+        raise AgentRunError(reason, f"opencode exited {rc}\nstderr:\n{err}")
+    text, new_sid, error_message = _parse_opencode_jsonl(out)
+    # `opencode run` exits 0 even when the model/tool errored; the failure is an
+    # error event in the JSONL stream. Surface it as agent_error rather than
+    # forwarding an empty or partial reply.
+    if error_message:
+        raise AgentRunError(
+            FINISHED_AGENT_ERROR,
+            f"opencode reported an error event: {error_message}",
+        )
+    if not new_sid:
+        raise AgentRunError(
+            FINISHED_AGENT_ERROR,
+            "opencode JSONL output did not include a sessionID; duet requires an "
+            "OpenCode CLI build that emits JSON session events for multi-turn memory.",
+        )
+    return text, new_sid
+
+
 def _call_claude_backend(agent: Agent, system_prompt: str, message: str,
                          cfg: DuetConfig, first_turn: bool,
                          stderr_log_path: Optional[pathlib.Path],
@@ -1566,6 +1721,24 @@ def _call_copilot_backend(agent: Agent, system_prompt: str, message: str,
     )
 
 
+def _call_opencode_backend(agent: Agent, system_prompt: str, message: str,
+                           cfg: DuetConfig, first_turn: bool,
+                           stderr_log_path: Optional[pathlib.Path],
+                           pid_file_path: Optional[pathlib.Path],
+                           reasoning: Optional[str]) -> tuple[str, Optional[str]]:
+    # OpenCode's `run` operates on the whole project under `--dir`; it has no
+    # per-call extra-root flag, so cfg.add_dirs is intentionally not plumbed
+    # through (mirrors Codex, which also ignores add_dirs).
+    return call_opencode(
+        agent, system_prompt, message, cfg.cwd,
+        cfg.per_turn_timeout, cfg.dry_run,
+        first_turn=first_turn,
+        reasoning=reasoning,
+        stderr_log_path=stderr_log_path,
+        pid_file_path=pid_file_path,
+    )
+
+
 BACKENDS = {
     "claude": BackendAdapter(
         name="claude",
@@ -1596,6 +1769,13 @@ BACKENDS = {
         reasoning_map=COPILOT_REASONING_MAP,
         reasoning_prompt_prefix=COPILOT_REASONING_PROMPT_PREFIX,
     ),
+    "opencode": BackendAdapter(
+        name="opencode",
+        binary="opencode",
+        call=_call_opencode_backend,
+        reasoning_map=OPENCODE_REASONING_MAP,
+        reasoning_prompt_prefix=OPENCODE_REASONING_PROMPT_PREFIX,
+    ),
 }
 SUPPORTED_BACKENDS = set(BACKENDS)
 
@@ -3368,9 +3548,9 @@ def _build_arg_parser() -> argparse.ArgumentParser:
     ap.add_argument("--task-from-cmd", metavar="CMD",
                     help="run shell command with cwd=--cwd and use stdout as the task")
     ap.add_argument("--partner", default="codex:coder",
-                    help="partner agent spec, e.g. codex:coder, claude:reviewer, gemini:coder, copilot:coder (default codex:coder)")
+                    help="partner agent spec, e.g. codex:coder, claude:reviewer, gemini:coder, copilot:coder, opencode:coder (default codex:coder)")
     ap.add_argument("--lead", default="claude:planner",
-                    help="lead agent spec, e.g. claude:planner, gemini:reviewer, copilot:planner (default; ignored if --resume-claude given)")
+                    help="lead agent spec, e.g. claude:planner, gemini:reviewer, copilot:planner, opencode:planner (default; ignored if --resume-claude given)")
     ap.add_argument("--lead-model", metavar="MODEL", default=None,
                     help="model name to pass to the lead agent's backend via --model")
     ap.add_argument("--partner-model", metavar="MODEL", default=None,
@@ -3387,9 +3567,9 @@ def _build_arg_parser() -> argparse.ArgumentParser:
                          "proposals; YAML key: `verify_cmd:`.")
     ap.add_argument("--runs-dir", default=None, help="where to save transcripts")
     ap.add_argument("--sandbox", default="workspace-write",
-                    help="codex --sandbox: read-only|workspace-write|danger-full-access. No-op for claude/gemini/copilot.")
+                    help="codex --sandbox: read-only|workspace-write|danger-full-access. No-op for claude/gemini/copilot/opencode.")
     ap.add_argument("--permission-mode", default="acceptEdits",
-                    help="claude --permission-mode; gemini maps default/acceptEdits/plan/bypassPermissions to --approval-mode. No-op for copilot.")
+                    help="claude --permission-mode; gemini maps default/acceptEdits/plan/bypassPermissions to --approval-mode. No-op for copilot/opencode.")
     ap.add_argument("--config", help="optional YAML/JSON config (overrides flags except --resume-*)")
     ap.add_argument("--worktree", action="store_true",
                     help="run the partner agent in a throwaway git worktree on a fresh branch; "

{duet_cli-0.2.5 → duet_cli-0.2.6/duet_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duet-cli
-Version: 0.2.5
+Version: 0.2.6
 Summary: Two CLI agents in conversation. One Python file. Stdlib only.
 Author: Volkan Altan
 License-Expression: MIT
@@ -24,12 +24,12 @@ Dynamic: license-file
 **Two CLI agents in conversation. One Python file. Stdlib only.**
 
 `duet` runs two command-line coding agents in alternating turns until they
-agree. By default that is Claude and Codex; Gemini and Copilot are also
-supported, and you can pair two agents from the same backend. One agent plans
-or reviews while the other implements; each keeps its own session memory across
-turns, and every run leaves a transcript you can inspect.
+agree. By default that is Claude and Codex; Gemini, Copilot, and OpenCode are
+also supported, and you can pair two agents from the same backend. One agent
+plans or reviews while the other implements; each keeps its own session memory
+across turns, and every run leaves a transcript you can inspect.
 
-## Use it three ways
+## Use it four ways
 
 ### 1. Inside Claude Code — `/duet`
 
@@ -93,7 +93,26 @@ CLI, so install that first (see below) and make sure `command -v duet` passes in
 Codex's shell. Full guide:
 [docs/CODEX_PLUGIN.md](https://github.com/volkan/duet/blob/main/docs/CODEX_PLUGIN.md).
 
-### 3. From the terminal — `duet`
+### 3. Inside OpenCode — `/duet`
+
+OpenCode custom commands are drop-in files — no marketplace step:
+
+```bash
+mkdir -p ~/.config/opencode/command
+cp plugins/duet-opencode/command/duet.md ~/.config/opencode/command/duet.md
+```
+
+Then invoke `/duet` in the OpenCode TUI (or `opencode run --command duet "..."`
+non-interactively). Like the other plugins it shells out to the `duet` CLI, so
+install that first and make sure `command -v duet` passes in OpenCode's shell.
+The command runs on OpenCode's `build` agent; plain `/duet` runs the same
+`claude -p /review` kickoff, and `/duet 'npm test 2>&1' --turns 4` seeds from
+any command. Full guide:
+[docs/OPENCODE_PLUGIN.md](https://github.com/volkan/duet/blob/main/docs/OPENCODE_PLUGIN.md).
+(duet can also drive OpenCode as a backend — `--partner opencode:coder` — so
+OpenCode can be one of the two looped agents too.)
+
+### 4. From the terminal — `duet`
 
 ```bash
 pipx install duet-cli        # recommended; the command it installs is `duet`
@@ -172,8 +191,9 @@ coder fixes them). Run one with `duet --config examples/pr-review.yaml`.
 ## How it works
 
 Each agent keeps its own conversation memory across turns (Claude via
-`--resume`, Codex via `codex exec resume`, Gemini and Copilot via their JSON
-session ids). On each turn duet sends one agent's latest reply to the other.
+`--resume`, Codex via `codex exec resume`, Gemini, Copilot, and OpenCode via
+their JSON session ids). On each turn duet sends one agent's latest reply to the
+other.
 
 To converge, an agent must include an `LGTM rationale:` explaining why the work
 is done, followed by the sentinel `<<<LGTM>>>` on its own line — a bare
@@ -186,7 +206,7 @@ stderr logs, and the `wt/` worktree when `--worktree` is on. Inspect a run with
 `duet --status <run-id>`, list runs with `duet --list`, and start a fresh run
 from saved state with `duet --continue <run> --task "next thing"`.
 
-- **Backends:** `claude`, `codex`, `gemini`, `copilot`
+- **Backends:** `claude`, `codex`, `gemini`, `copilot`, `opencode`
 - **Roles:** `planner`, `coder`, `reviewer`, `triage-reviewer`, or a custom one
 - **Reasoning:** `--reasoning minimal|low|medium|high|xhigh|max`
 

{duet_cli-0.2.5 → duet_cli-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "duet-cli"
-version = "0.2.5"
+version = "0.2.6"
 description = "Two CLI agents in conversation. One Python file. Stdlib only."
 readme = "README.md"
 requires-python = ">=3.9"

{duet_cli-0.2.5 → duet_cli-0.2.6}/tests/test_duet.py

@@ -454,6 +454,130 @@ class TestAgentFinishReasons(unittest.TestCase):
         self.assertEqual(ctx.exception.finished_reason, duet.FINISHED_AGENT_ERROR)
         self.assertIn("copilot exited 2", str(ctx.exception))
 
+    def test_opencode_error_event_maps_to_agent_error(self) -> None:
+        # `opencode run` exits 0 on a model error, so call_opencode must catch
+        # the error event in the JSONL stream and not forward a broken reply.
+        def fake_run(cmd, **kwargs):
+            return (
+                0,
+                '{"type":"error","sessionID":"ses_x","error":{"data":{"message":"boom"}}}',
+                "",
+            )
+
+        agent = duet.Agent(name="opencode-partner", backend="opencode", role="coder")
+        with mock.patch.object(duet, "_run", fake_run):
+            with self.assertRaises(duet.AgentRunError) as ctx:
+                duet.call_opencode(
+                    agent, "sys", "msg", _ROOT, 60,
+                    dry=False, first_turn=True,
+                )
+
+        self.assertEqual(ctx.exception.finished_reason, duet.FINISHED_AGENT_ERROR)
+        self.assertIn("boom", str(ctx.exception))
+
+    def test_opencode_missing_session_id_maps_to_agent_error(self) -> None:
+        def fake_run(cmd, **kwargs):
+            return (
+                0,
+                '{"type":"text","part":{"type":"text","text":"ok","id":"p1"}}',
+                "",
+            )
+
+        agent = duet.Agent(name="opencode-partner", backend="opencode", role="coder")
+        with mock.patch.object(duet, "_run", fake_run):
+            with self.assertRaises(duet.AgentRunError) as ctx:
+                duet.call_opencode(
+                    agent, "sys", "msg", _ROOT, 60,
+                    dry=False, first_turn=True,
+                )
+
+        self.assertEqual(ctx.exception.finished_reason, duet.FINISHED_AGENT_ERROR)
+        self.assertIn("sessionID", str(ctx.exception))
+
+    def test_opencode_rc_124_maps_to_timeout(self) -> None:
+        def fake_run(cmd, **kwargs):
+            return 124, "", "[duet] TIMEOUT after 1s"
+
+        agent = duet.Agent(name="opencode-partner", backend="opencode", role="coder")
+        with mock.patch.object(duet, "_run", fake_run):
+            with self.assertRaises(duet.AgentRunError) as ctx:
+                duet.call_opencode(
+                    agent, "sys", "msg", _ROOT, 1,
+                    dry=False, first_turn=True,
+                )
+
+        self.assertEqual(ctx.exception.finished_reason, duet.FINISHED_TIMEOUT)
+        self.assertIn("opencode exited 124", str(ctx.exception))
+
+    def test_opencode_error_event_precedes_missing_session_id(self) -> None:
+        # An error event with no sessionID must surface the error text, not the
+        # generic missing-sessionID message — locks the check ordering in
+        # call_opencode (mirrors the Gemini precedence test).
+        def fake_run(cmd, **kwargs):
+            return (
+                0,
+                '{"type":"error","error":{"data":{"message":"boom"}}}',
+                "",
+            )
+
+        agent = duet.Agent(name="opencode-partner", backend="opencode", role="coder")
+        with mock.patch.object(duet, "_run", fake_run):
+            with self.assertRaises(duet.AgentRunError) as ctx:
+                duet.call_opencode(
+                    agent, "sys", "msg", _ROOT, 60,
+                    dry=False, first_turn=True,
+                )
+
+        self.assertEqual(ctx.exception.finished_reason, duet.FINISHED_AGENT_ERROR)
+        self.assertIn("boom", str(ctx.exception))
+        self.assertNotIn("sessionID", str(ctx.exception))
+
+    def test_opencode_command_construction_and_resume(self) -> None:
+        # Capture the constructed argv to pin the flags the reasoning-check and
+        # dry-run exit codes can't see: the `-s` resume flag, whose silent loss
+        # would orphan multi-turn memory while still returning rc=0, and the
+        # `-m provider/model` form OpenCode requires for model selection.
+        captured: list[list[str]] = []
+
+        def fake_run(cmd, **kwargs):
+            captured.append(list(cmd))
+            return (
+                0,
+                '{"type":"text","sessionID":"ses_new","part":{"type":"text","text":"ok","id":"p1"}}',
+                "",
+            )
+
+        agent = duet.Agent(
+            name="opencode-partner",
+            backend="opencode",
+            role="coder",
+            model="anthropic/claude-sonnet-4-6",
+        )
+        with mock.patch.object(duet, "_run", fake_run):
+            # First turn: no session_id yet.
+            duet.call_opencode(agent, "sys", "msg", _ROOT, 60,
+                               dry=False, first_turn=True)
+            first = captured[-1]
+            self.assertEqual(first[:2], ["opencode", "run"])
+            self.assertIn("--format", first)
+            self.assertEqual(first[first.index("--format") + 1], "json")
+            self.assertIn("--dir", first)
+            self.assertIn("--dangerously-skip-permissions", first)
+            self.assertIn("-m", first)
+            self.assertEqual(first[first.index("-m") + 1], "anthropic/claude-sonnet-4-6")
+            self.assertNotIn("-s", first)  # nothing to resume on turn 1
+            # The prompt is the trailing positional arg (options come first).
+            self.assertIn("=== MESSAGE FROM PARTNER ===", first[-1])
+            self.assertTrue(first[-1].rstrip().endswith("msg"))
+
+            # Second turn: resume by the parsed session id.
+            agent.session_id = "ses_prev"
+            duet.call_opencode(agent, "sys", "msg2", _ROOT, 60,
+                               dry=False, first_turn=False)
+            second = captured[-1]
+            self.assertIn("-s", second)
+            self.assertEqual(second[second.index("-s") + 1], "ses_prev")
+
 
 # ---------- _parse_codex_session_id ----------
 
@@ -572,6 +696,102 @@ class TestParseCopilotJsonl(unittest.TestCase):
             duet._parse_copilot_jsonl("not json")
 
 
+# ---------- _parse_opencode_jsonl ----------
+
+
+class TestParseOpencodeJsonl(unittest.TestCase):
+    def test_extracts_text_and_session_id(self) -> None:
+        out = "\n".join([
+            '{"type":"step_start","sessionID":"ses_abc","part":{"type":"step-start"}}',
+            '{"type":"text","sessionID":"ses_abc","part":{"type":"text","text":"PONG","id":"p1"}}',
+            '{"type":"step_finish","sessionID":"ses_abc","part":{"type":"step-finish"}}',
+        ])
+
+        text, session_id, error = duet._parse_opencode_jsonl(out)
+
+        self.assertEqual(text, "PONG")
+        self.assertEqual(session_id, "ses_abc")
+        self.assertIsNone(error)
+
+    def test_concatenates_multiple_distinct_text_parts(self) -> None:
+        # Text split around a tool call arrives as two parts with distinct ids;
+        # both are kept, in arrival order.
+        out = "\n".join([
+            '{"type":"text","sessionID":"ses_x","part":{"type":"text","text":"Let me check.","id":"p1"}}',
+            '{"type":"text","sessionID":"ses_x","part":{"type":"text","text":"Done.","id":"p2"}}',
+        ])
+
+        text, session_id, error = duet._parse_opencode_jsonl(out)
+
+        self.assertEqual(text, "Let me check.\nDone.")
+        self.assertEqual(session_id, "ses_x")
+        self.assertIsNone(error)
+
+    def test_streamed_part_last_write_wins(self) -> None:
+        # A part re-emitted as it grows (same id) must not duplicate; last wins.
+        out = "\n".join([
+            '{"type":"text","sessionID":"ses_x","part":{"type":"text","text":"PO","id":"p1"}}',
+            '{"type":"text","sessionID":"ses_x","part":{"type":"text","text":"PONG","id":"p1"}}',
+        ])
+
+        text, _, _ = duet._parse_opencode_jsonl(out)
+
+        self.assertEqual(text, "PONG")
+
+    def test_error_event_is_surfaced(self) -> None:
+        # `opencode run` exits 0 even on model errors; the failure is an error
+        # event in the stream, so the parser must report it.
+        out = ('{"type":"error","sessionID":"ses_x","error":{"name":"UnknownError",'
+               '"data":{"message":"Model not found: foo."}}}')
+
+        text, session_id, error = duet._parse_opencode_jsonl(out)
+
+        self.assertEqual(text, "")
+        self.assertEqual(session_id, "ses_x")
+        self.assertEqual(error, "Model not found: foo.")
+
+    def test_non_json_banner_lines_are_skipped(self) -> None:
+        # A fresh machine can print a one-time DB-migration banner; tolerate it
+        # rather than treating the whole turn as malformed.
+        out = "\n".join([
+            "Performing one time database migration...",
+            '{"type":"text","sessionID":"ses_x","part":{"type":"text","text":"ok","id":"p1"}}',
+        ])
+
+        text, session_id, error = duet._parse_opencode_jsonl(out)
+
+        self.assertEqual(text, "ok")
+        self.assertEqual(session_id, "ses_x")
+        self.assertIsNone(error)
+
+    def test_string_error_payload_is_surfaced(self) -> None:
+        # OpenCode documents a dict error payload, but a plain-string one must
+        # surface verbatim rather than degrading to "unknown error".
+        out = '{"type":"error","sessionID":"ses_x","error":"Model not found: foo"}'
+
+        text, session_id, error = duet._parse_opencode_jsonl(out)
+
+        self.assertEqual(text, "")
+        self.assertEqual(session_id, "ses_x")
+        self.assertEqual(error, "Model not found: foo")
+
+    def test_idless_part_does_not_alias_real_id(self) -> None:
+        # An id-less text part must not collide with a real part whose id is the
+        # bare integer the old `len(parts)` fallback would have produced ("0").
+        # Both texts must survive, in arrival order.
+        out = "\n".join([
+            '{"type":"text","sessionID":"ses_x","part":{"type":"text","text":"A"}}',
+            '{"type":"text","sessionID":"ses_x","part":{"type":"text","text":"B","id":"0"}}',
+        ])
+
+        text, _, _ = duet._parse_opencode_jsonl(out)
+
+        self.assertEqual(text, "A\nB")
+
+    def test_empty_returns_no_session(self) -> None:
+        self.assertEqual(duet._parse_opencode_jsonl(""), ("", None, None))
+
+
 # ---------- _parse_gemini_session_id ----------
 
 
@@ -758,9 +978,11 @@ class TestReasoningHelpers(unittest.TestCase):
                 self.assertIn(level, duet.CODEX_REASONING_MAP)
                 self.assertIn(level, duet.GEMINI_REASONING_MAP)
                 self.assertIn(level, duet.COPILOT_REASONING_MAP)
+                self.assertIn(level, duet.OPENCODE_REASONING_MAP)
                 self.assertIn(level, duet.CLAUDE_REASONING_PROMPT_PREFIX)
                 self.assertIn(level, duet.GEMINI_REASONING_PROMPT_PREFIX)
                 self.assertIn(level, duet.COPILOT_REASONING_PROMPT_PREFIX)
+                self.assertIn(level, duet.OPENCODE_REASONING_PROMPT_PREFIX)
 
     def test_codex_max_maps_to_xhigh(self) -> None:
         # Codex documents `xhigh` but not `max`; duet keeps `max` as a
@@ -784,6 +1006,13 @@ class TestReasoningHelpers(unittest.TestCase):
             with self.subTest(level=level):
                 self.assertEqual(duet.GEMINI_REASONING_MAP[level], "")
 
+    def test_opencode_reasoning_map_is_identity(self) -> None:
+        # OpenCode tolerates/ignores unknown `--variant` values, so duet passes
+        # each level through unchanged for forward-compatibility.
+        for level in duet.REASONING_LEVELS:
+            with self.subTest(level=level):
+                self.assertEqual(duet.OPENCODE_REASONING_MAP[level], level)
+
 
 # ---------- parse_partner ----------