commandmate 0.42.1 → 0.43.0

package/dist/server/src/lib/hooks/sources/registry.js

@@ -41,6 +41,7 @@ const source_4 = require("./antigravity/source");
 const source_5 = require("./codex/source");
 const source_6 = require("./opencode/source");
 const source_7 = require("./command-code/source");
+const source_8 = require("./opencode-v2/source");
 const registered = (globalThis.__agentEventSources ??= new Map());
 /** Memoised compatibility sources, so repeated lookups return one object. */
 const legacy = (globalThis.__agentEventLegacySources ??= new Map());
@@ -113,3 +114,4 @@ registerAgentEventSource(source_6.opencodeAgentEventSource);
 // Issue #2251, Epic #2249 Phase B. The seventh, and the last line of "adding a
 // tool" — its own directory plus this.
 registerAgentEventSource(source_7.commandCodeAgentEventSource);
+registerAgentEventSource(source_8.opencodeV2AgentEventSource);

package/dist/server/src/lib/hooks/structured-decision-response.js

@@ -157,13 +157,22 @@ function verdictFor(optionNumber) {
 /**
  * Resolve an answer against the option list.
  *
+ * Issue #2951: with `cliToolId`, the labels matched are the tool's own
+ * (`structuredDecisionOptionsFor`) — OpenCode V2's `Always allow` — and the
+ * option returned carries that label. The shared spelling (`Allow always`) is
+ * still accepted there as an alias of the same number, so nothing that
+ * resolved before stops resolving.
+ *
+ * @param answer - An option number, a label, a `reply` word or an alias
+ * @param cliToolId - The tool the approval belongs to; omitted = the shared list
  * @returns The option, or null when nothing matched
  */
-function resolveStructuredDecisionOption(answer) {
+function resolveStructuredDecisionOption(answer, cliToolId) {
     const normalized = answer.trim().toLowerCase();
     if (normalized === '')
         return null;
-    for (const option of structured_prompt_1.STRUCTURED_DECISION_OPTIONS) {
+    const options = cliToolId === undefined ? structured_prompt_1.STRUCTURED_DECISION_OPTIONS : (0, structured_prompt_1.structuredDecisionOptionsFor)(cliToolId);
+    for (const option of options) {
         if (normalized === String(option.number))
             return option;
         if (normalized === option.label.toLowerCase())
@@ -407,16 +416,16 @@ async function answerStructuredDecision({ worktreeId, cliToolId, instanceId, ans
             kind: 'refused',
             reason: 'unresolvable_answer',
             message: '--default cannot answer a structured approval: the agent publishes no default verdict. ' +
-                `Send a number instead — ${structured_prompt_1.STRUCTURED_DECISION_OPTIONS.map((option) => `${option.number} = ${option.label}`).join(', ')}.`,
+                `Send a number instead — ${(0, structured_prompt_1.structuredDecisionOptionsFor)(cliToolId).map((option) => `${option.number} = ${option.label}`).join(', ')}.`,
         };
     }
-    const option = answer === undefined ? null : resolveStructuredDecisionOption(answer);
+    const option = answer === undefined ? null : resolveStructuredDecisionOption(answer, cliToolId);
     if (!option) {
         return {
             kind: 'refused',
             reason: 'answer_out_of_range',
             message: `'${answer ?? ''}' is not one of the verdicts this approval accepts. ` +
-                structured_prompt_1.STRUCTURED_DECISION_OPTIONS.map((each) => `${each.number} = ${each.label} (${each.reply})`).join(', ') +
+                (0, structured_prompt_1.structuredDecisionOptionsFor)(cliToolId).map((each) => `${each.number} = ${each.label} (${each.reply})`).join(', ') +
                 '.',
         };
     }

package/dist/server/src/lib/job-executor.js

@@ -116,7 +116,8 @@ function recoverRunningLogs() {
  * - **the CMATE.md CLI Tool column**, read by
  *   {@link resolveScheduleCommandOptions} — `--model` for every tool in
  *   `TOOLS_WITH_MODEL_SUPPORT`, plus opencode's `--agent` / `--variant` /
- *   `--continue` / `--title` for the ids in `TOOLS_WITH_RUN_OPTIONS`;
+ *   `--continue` / `--title` for the ids in `TOOLS_WITH_RUN_OPTIONS`
+ *   (opencode and, since Issue #2982, opencode-v2);
  * - **the DB** (`worktree.vibe_local_model`), for vibe-local, whose model is
  *   chosen in the worktree's Agent settings rather than written in the file.
  *

package/dist/server/src/lib/polling/auto-yes-dialog-gate.js

@@ -71,7 +71,7 @@ exports.AUTO_YES_DIALOG_GATE_MODES = ['enforce', 'legacy'];
 /**
  * The rollout state each tool ships in.
  *
- * `enforce` is set only for the four tools with a dialog rule measured from
+ * `enforce` is set only for the five tools with a dialog rule measured from
  * their own live captures, each with a positive fixture and a mutation fixture
  * (`tests/unit/detection/tools/dialogs.test.ts`):
  *
@@ -81,6 +81,7 @@ exports.AUTO_YES_DIALOG_GATE_MODES = ['enforce', 'legacy'];
  * | codex    | `Press enter to confirm …` under the options, above the status bar, not stale | #1628 / #1160 |
  * | copilot  | the bottom status bar is GONE and the option run carries a picker footer | #1885 / #1895 |
  * | opencode | the `Allow once / Allow always / Reject` strip, or a picker header    | #1893 / #1896 |
+ * | opencode-v2 | the `Allow once / Always allow / Reject` strip, the question form's key hints, or a dialog title row | #2984 |
  *
  * The rest are `legacy` because nobody has measured them:
  *
@@ -125,6 +126,19 @@ exports.AUTO_YES_DIALOG_GATE_DEFAULT_MODE = {
     // Promote only once both dialogs are recognised on both spellings, with a
     // `/prompt-response` test pinning that the question is still answered.
     'command-code': 'legacy',
+    // Issue #2984: enforced. The screen path DOES run for OpenCode V2 — nothing
+    // in `startAutoYesPolling` / `pollAutoYes` (`auto-yes-poller.ts`) excludes a
+    // tool, and `buildDetectPromptOptions` gives v2 the default options
+    // (`cli-patterns.ts`), so any `❯ 1.`-shaped rows in the last 50 read as
+    // `multiple_choice`. Measured on 2.0.18 (`tests/fixtures/opencode-v2-dialogs-2984/`):
+    // a reply that quotes a Claude dialog (`❯ 1. Yes / 2. No`) is exactly such a
+    // candidate, and under `legacy` Auto-Yes would have typed `1` + Enter into
+    // the composer — #1896 again. v2's own dialogs never are: the approval strip
+    // and the question form draw no `❯`, so the generic parser finds nothing on
+    // them, and they are answered over the API (#2945 / #2951,
+    // `sources/opencode-v2/ingest`) as before. Enforcing therefore takes nothing
+    // away from Auto-Yes and refuses the quoted list.
+    'opencode-v2': 'enforce',
 };
 /**
  * The kill switch (§13.1 DR3-016).

package/dist/server/src/lib/polling/structured-history-gate.js

@@ -72,6 +72,7 @@ exports.captureStructuredHistoryTurn = captureStructuredHistoryTurn;
 exports.hasStructuredHistoryTranscript = hasStructuredHistoryTranscript;
 const logger_1 = require("../../lib/logger");
 const subscription_1 = require("../../lib/hooks/sources/opencode/subscription");
+const subscription_2 = require("../../lib/hooks/sources/opencode-v2/subscription");
 const history_1 = require("../../lib/hooks/sources/claude/history");
 const history_2 = require("../../lib/hooks/sources/codex/history");
 const history_3 = require("../../lib/hooks/sources/antigravity/history");
@@ -239,11 +240,24 @@ function transcriptHistoryModeOf(cliToolId) {
 function isPullTranscriptHistory(cliToolId) {
     return transcriptHistoryModeOf(cliToolId) === 'pull';
 }
+/**
+ * The push-mode writers' liveness probes, by tool (Issue #2940).
+ *
+ * The counterpart of {@link PULL_TRANSCRIPT_READERS}: a push source declares
+ * `transcriptHistory: 'push'` in its own `source.ts` and adds its probe here.
+ * A push source with no row of its own is asked opencode's probe, which is
+ * what every push declaration was asked before this table existed — the
+ * branch follows the declaration, not the tool name (#2197).
+ */
+const PUSH_TRANSCRIPT_WRITERS = {
+    opencode: (target) => (0, subscription_1.isOpencodeStructuredHistoryLive)(target),
+    'opencode-v2': (target) => (0, subscription_2.isOpencodeV2StructuredHistoryLive)(target),
+};
 /**
  * Whether the agent's own server is recording this instance's replies.
  *
  * False for every tool whose source does not declare `transcriptHistory: 'push'`
- * — today that is all of them but opencode — and false for an opencode instance
+ * — today that is all of them but opencode and opencode-v2 — and false for an instance
  * whose subscription is anything other than `live`; see
  * {@link isOpencodeStructuredHistoryLive} for why `lost` counts as "nobody is
  * writing this down" rather than as "somebody will". The fallback direction is
@@ -259,10 +273,10 @@ function isStructuredHistoryWriterLive(worktreeId, cliToolId, instanceId) {
     if (transcriptHistoryModeOf(cliToolId) !== 'push')
         return false;
     try {
-        // One probe, because there is one push source. A second one adds a table
-        // here of the shape `PULL_TRANSCRIPT_READERS` already has; it does not add
-        // another `cliToolId ===`.
-        return (0, subscription_1.isOpencodeStructuredHistoryLive)({
+        // Issue #2940 added the second push source, and with it the table the
+        // single probe used to stand in for.
+        const probe = PUSH_TRANSCRIPT_WRITERS[cliToolId] ?? subscription_1.isOpencodeStructuredHistoryLive;
+        return probe({
             worktreeId,
             cliToolId,
             instanceId: instanceId ?? cliToolId,

package/dist/server/src/lib/relay/relay-delivery.js

@@ -103,7 +103,7 @@ const SYSTEM_ROW_REQUEST_ID_PREFIXES = [
 /**
  * Whether this tool's reply is read out of a transcript rather than off a screen.
  *
- * For the five that answer `true` the ledger is authoritative: a row with no
+ * For the six that answer `true` the ledger is authoritative: a row with no
  * turn marker was written by the SCRAPER, and for these tools a scraped row is
  * never the answer — it is a footer line, a half-drawn frame or the ANSI dump
  * the send path flushes (Issues #2398 / #2400). The relay may therefore hold
@@ -130,6 +130,9 @@ const TRANSCRIPT_READER_TOOLS = {
     copilot: false,
     gemini: false,
     'vibe-local': false,
+    // Issue #2940: OpenCode V2's replies are written from its server
+    // (`GET /api/session/{id}/message`) under `oc-turn:`, like opencode's.
+    'opencode-v2': true,
 };
 /**
  * How long the scrape path holds out for the transcript row.

package/dist/server/src/lib/session/agent-event-state.js

@@ -56,6 +56,7 @@ exports.getAwaitingInstruction = getAwaitingInstruction;
 exports.isAwaitingInstruction = isAwaitingInstruction;
 exports.getLastAgentEvent = getLastAgentEvent;
 exports.getLastKnownAgentModel = getLastKnownAgentModel;
+exports.recordAgentReportedModel = recordAgentReportedModel;
 exports.recordCapturedModelInfo = recordCapturedModelInfo;
 exports.getLastCapturedModelInfo = getLastCapturedModelInfo;
 exports.getResolvedAgentModelInfo = getResolvedAgentModelInfo;
@@ -1348,6 +1349,29 @@ function getLastAgentEvent(worktreeId, cliToolId, instanceId) {
 function getLastKnownAgentModel(worktreeId, cliToolId, instanceId) {
     return lastAgentModel.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
 }
+/**
+ * Latch the model the agent named for itself outside an agent event
+ * (Issue #2964).
+ *
+ * The hook channel's latch — the one {@link recordAgentEvent} writes from
+ * `record.model` — for a source whose model arrives on something that is not
+ * one of the seven event words. OpenCode V2 is that source: its `session.*`
+ * frames carry no model, and the model it actually answered with is read off
+ * the assistant messages of `GET /api/session/{id}/message` after the turn.
+ *
+ * Latch, never clear ({@link latchAgentModel}'s rule), and judged for a change
+ * exactly as a hook-borne model is, so #2357's broadcast and push fire for it.
+ *
+ * @param model - The model name, or null/empty to leave the latch alone
+ */
+function recordAgentReportedModel(worktreeId, cliToolId, instanceId, model, at = Date.now()) {
+    if (typeof model !== 'string' || model === '')
+        return;
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
+    lastAgentModel.set(key, model.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH));
+    lastAgentModelAt.set(key, at);
+    observeAgentModel(worktreeId, cliToolId, instanceId, 'hook', at);
+}
 /**
  * Latch what a terminal capture showed for this instance (Issue #1784).
  *

package/dist/server/src/lib/session/claude-executor.js

@@ -3,8 +3,10 @@
  * CLI Command Executor (non-interactive mode)
  * Issue #294: Executes CLI tool commands for scheduled executions
  * Issue #379: Added OpenCode support (opencode run)
+ * Issue #2974: Added OpenCode V2 support (opencode2 run --standalone)
  *
- * Supported tools: claude, codex, gemini, vibe-local, opencode, copilot, antigravity, command-code
+ * Supported tools: claude, codex, gemini, vibe-local, opencode, copilot, antigravity, command-code,
+ * opencode-v2
  *
  * Security:
  * - Uses execFile (not exec) to prevent shell injection
@@ -19,6 +21,8 @@ exports.getCommandForTool = getCommandForTool;
 exports.truncateOutput = truncateOutput;
 exports.buildCliArgs = buildCliArgs;
 exports.extractOpencodeFinalText = extractOpencodeFinalText;
+exports.findOpencodeTrailingError = findOpencodeTrailingError;
+exports.describeOpencodeV2Failure = describeOpencodeV2Failure;
 exports.extractCommandCodeResult = extractCommandCodeResult;
 exports.readCommandCodeStream = readCommandCodeStream;
 exports.describeCommandCodeBlockedToolCalls = describeCommandCodeBlockedToolCalls;
@@ -31,6 +35,7 @@ const env_sanitizer_1 = require("../../lib/security/env-sanitizer");
 const cli_patterns_1 = require("../../lib/detection/cli-patterns");
 const types_1 = require("../../lib/cli-tools/types");
 const schedule_config_1 = require("../../config/schedule-config");
+const opencode_executable_1 = require("../../lib/cli-tools/opencode-executable");
 // =============================================================================
 // Constants
 // =============================================================================
@@ -77,6 +82,11 @@ function getCommandForTool(cliToolId) {
         // cannot drift.
         case 'command-code':
             return 'commandcode';
+        // Issue #2974: the name only. `executeClaudeCommand` runs the path
+        // `resolveOpencodeV2Executable` answers, which also accepts an `opencode`
+        // that reports `opencode v2.x`.
+        case 'opencode-v2':
+            return opencode_executable_1.OPENCODE_V2_BINARY_NAME;
         default:
             return cliToolId;
     }
@@ -108,6 +118,7 @@ function truncateOutput(output) {
  * - gemini: -p <message>
  * - vibe-local: [-p <message> -y] or [--model <model> -p <message> -y]
  * - opencode: run --format json [-m <model>] [--agent <a>] [--variant <v>] [-c] [--title <t>] <message>
+ * - opencode-v2: run --standalone --format json [--auto] [-m <model>[#<variant>]] [--agent <a>] [-c] [--title <t>] -- <message>
  * - antigravity: -p <message> --dangerously-skip-permissions
  * - command-code: -p <message> --output-format json [--yolo | --permission-mode <permission>] --no-auto-update
  * - others: -p <message> (fallback)
@@ -175,6 +186,63 @@ function buildCliArgs(message, cliToolId, permission, options) {
             args.push(message);
             return args;
         }
+        case 'opencode-v2': {
+            // Issue #2974 (Epic #2370 Phase 4). Measured on OpenCode V2 2.0.18 in an
+            // isolated `HOME` / `XDG_*` (`tests/fixtures/opencode-v2-schedule-2974/`).
+            //
+            // ## `--standalone` is unconditional
+            //
+            // Without it `opencode2 run` connects to the *background service* — a
+            // shared `opencode serve --service` recorded in
+            // `~/.local/state/opencode/service.json`, starting one when there is
+            // none. That service is the operator's (their own TUI talks to it), it is
+            // not the schedule's child, and it outlives the run: in the isolated
+            // measurement the run spawned a detached `serve --service` (PPID 1) and
+            // then failed with "Timed out waiting for the background service to
+            // start" (exit 1). `--standalone` runs a private server for this one run;
+            // after it no `opencode2` process was left.
+            //
+            // ## `--format json` is unconditional
+            //
+            // For v1's reason (see the `opencode` case): the stream is the same NDJSON
+            // shape, so {@link extractOpencodeFinalText} reads both.
+            //
+            // ## `--auto`
+            //
+            // `auto` is the only Permission value that adds a flag. Without it an
+            // `ask` rule is auto-rejected and the run exits 1 (so the schedule is
+            // recorded as failed); with it the rule is approved. See
+            // OPENCODE_V2_PERMISSIONS for why the flag-less run is the default.
+            //
+            // ## Options, and `--` before the message
+            //
+            // `-m`, `--agent`, `-c` and `--title` exist with v1's meaning. There is
+            // no `--variant`: `opencode2 run --help` documents `-m` as
+            // `provider/model#variant` and `--variant` is "Unrecognized flag" (exit
+            // 1), so a variant rides on the model. A variant without a model has
+            // nothing to ride on and is not sent. Since Issue #2982 the CMATE.md
+            // column carries these options for opencode-v2 too, and the column parser
+            // and `cmate-writer` refuse a variant without a model before it gets here
+            // (`validateVariantHasModel`); the guard below stays for direct callers.
+            //
+            // Unlike v1, a message that begins with `-` is read as a flag ("-x reply"
+            // printed the usage; "--- list" was "Unrecognized flag"), so the message
+            // follows `--`, which v2 accepts.
+            const args = ['run', '--standalone', '--format', 'json'];
+            if (permission === schedule_config_1.OPENCODE_V2_AUTO_PERMISSION)
+                args.push('--auto');
+            if (options?.model) {
+                args.push('-m', options.variant ? `${options.model}#${options.variant}` : options.model);
+            }
+            if (options?.agent)
+                args.push('--agent', options.agent);
+            if (options?.continueSession)
+                args.push('-c');
+            if (options?.title)
+                args.push('--title', options.title);
+            args.push('--', message);
+            return args;
+        }
         case 'command-code': {
             // Issue #2253 (Epic #2249 Phase D): `commandcode -p <message>` runs one
             // prompt non-interactively. `--output-format json` is unconditional for
@@ -316,6 +384,12 @@ function buildCliArgs(message, cliToolId, permission, options) {
  * whole extraction, because `--print-logs` and a plugin's stray `console.log`
  * both land on the same stdout.
  *
+ * ## OpenCode V2 (Issue #2974)
+ *
+ * `opencode2 run --format json` (2.0.18) writes the same frames with the same
+ * `part.messageID` / `part.text`, so this reads it unchanged. Only the `error`
+ * frame differs — see {@link renderOpencodeErrorFrame}.
+ *
  * @param stdout - Raw stdout from `opencode run --format json`
  * @returns The assistant's final text, a one-line rendering of an `error`
  *   frame, or null when the stream carried neither
@@ -363,22 +437,76 @@ function extractOpencodeFinalText(stdout) {
 /**
  * One line describing an `{"type":"error"}` frame.
  *
- * The measured shape is `error: { name, data: { message, ref } }`; every field
- * is treated as optional because the only thing this layer knows for certain is
- * the `type`. Rendered rather than dropped so a failed opencode run says
- * something in the execution log instead of nothing.
+ * The measured v1 shape is `error: { name, data: { message, ref } }`; OpenCode
+ * V2 2.0.18 writes `error: { type, message }` (`{"type":"aborted","message":
+ * "Step interrupted"}` after an auto-rejected `ask`, `{"type":"unknown",
+ * "message":"Agent not found: …"}`, `{"type":"provider.no-route",…}`). Both are
+ * read; v1's fields win when present. Every field is treated as optional
+ * because the only thing this layer knows for certain is the `type`. Rendered
+ * rather than dropped so a failed opencode run says something in the execution
+ * log instead of nothing.
  */
 function renderOpencodeErrorFrame(record) {
     const error = typeof record.error === 'object' && record.error !== null
         ? record.error
         : {};
-    const name = typeof error.name === 'string' ? error.name : 'error';
+    const name = typeof error.name === 'string' ? error.name
+        : typeof error.type === 'string' ? error.type
+            : 'error';
     const data = typeof error.data === 'object' && error.data !== null
         ? error.data
         : {};
-    const message = typeof data.message === 'string' ? data.message : '';
+    const message = typeof data.message === 'string' ? data.message
+        : typeof error.message === 'string' ? error.message
+            : '';
     return message ? `opencode error: ${name}: ${message}` : `opencode error: ${name}`;
 }
+/**
+ * The `error` frame an opencode stream *ends* with, rendered, or null.
+ *
+ * Issue #2974: the measured OpenCode V2 failures (an auto-rejected `ask`, an
+ * unknown agent, an unavailable model) all end the stream in an `error` frame
+ * and exit 1. The exit code is what fails the schedule; this is the second
+ * half, so a run that ever exits 0 after an `error` frame is not recorded as
+ * completed either. "Ends with" rather than "contains": a stream whose last
+ * word is the assistant's answer did finish.
+ *
+ * @param stdout - Raw stdout from `opencode2 run --format json`
+ * @returns The rendered error, or null when the last frame is not an error
+ */
+function findOpencodeTrailingError(stdout) {
+    let last = null;
+    for (const line of stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{'))
+            continue;
+        try {
+            const frame = JSON.parse(trimmed);
+            if (typeof frame === 'object' && frame !== null)
+                last = frame;
+        }
+        catch {
+            continue;
+        }
+    }
+    return last && last.type === 'error' ? renderOpencodeErrorFrame(last) : null;
+}
+/**
+ * The `Reason:` line for a failed OpenCode V2 run, or null.
+ *
+ * Measured on 2.0.18: an `ask` rule without `--auto` prints
+ * `! permission requested: <permission> (<target>); auto-rejecting` on stderr
+ * and exits 1. That line is the one that says what to change, so it is named;
+ * any other failure is described by its trailing `error` frame.
+ */
+function describeOpencodeV2Failure(stdout, stderr) {
+    if (/permission requested: .*auto-rejecting/.test((0, cli_patterns_1.stripAnsi)(stderr))) {
+        return 'Reason: opencode-v2 auto-rejected a permission request (an `ask` rule);'
+            + ' set the schedule\'s Permission to `auto` to approve it unattended';
+    }
+    const trailing = findOpencodeTrailingError(stdout);
+    return trailing ? `Reason: ${trailing}` : null;
+}
 // =============================================================================
 // command-code `--output-format json` extraction (Issue #2253)
 // =============================================================================
@@ -679,11 +807,35 @@ async function executeClaudeCommand(message, cwd, cliToolId = 'claude', permissi
         ? message.substring(0, exports.MAX_MESSAGE_LENGTH)
         : message;
     const args = buildCliArgs(truncatedMessage, cliToolId, permission, options);
+    // Issue #2974: OpenCode V2 runs the binary `resolveOpencodeV2Executable`
+    // answers for (`opencode2`, or an `opencode` that reports v2) — the same
+    // resolution the interactive launch uses, so a v1 `opencode` is never handed
+    // v2's flags.
+    let command = getCommandForTool(cliToolId);
+    if (cliToolId === 'opencode-v2') {
+        const resolution = await (0, opencode_executable_1.resolveOpencodeV2Executable)();
+        if (!resolution.executable) {
+            const error = 'OpenCode V2 not found: no `opencode2` (or `opencode` reporting v2) on PATH';
+            return { output: error, exitCode: null, status: 'failed', error };
+        }
+        command = resolution.executable.path;
+    }
+    // Issue #2979: `execFile`'s `cwd` does not touch `PWD`, so the child inherits
+    // the server's (the main checkout it was started from). OpenCode V2 takes its
+    // project directory from `PWD`, not `process.cwd()`: measured on 2.0.18 in a
+    // throwaway repo + `git worktree`, the write landed wherever `PWD` pointed
+    // (cwd=worktree / PWD=main → main; cwd=main / PWD=worktree → worktree;
+    // PWD unset → cwd), for a plain repo and a worktree alike, and the
+    // `opencode.json` read was the one under `PWD`. `opencode2 run` has no `--dir`
+    // (v1 has), so the child's `PWD` is set to `cwd`. Other tools keep the
+    // environment they had.
+    const env = cliToolId === 'opencode-v2'
+        ? { ...(0, env_sanitizer_1.sanitizeEnvForChildProcess)(), PWD: cwd }
+        : (0, env_sanitizer_1.sanitizeEnvForChildProcess)();
     return new Promise((resolve) => {
-        const command = getCommandForTool(cliToolId);
         const child = (0, child_process_1.execFile)(command, args, {
             cwd,
-            env: (0, env_sanitizer_1.sanitizeEnvForChildProcess)(),
+            env,
             maxBuffer: exports.MAX_OUTPUT_SIZE,
             timeout: options?.timeoutMs ?? exports.EXECUTION_TIMEOUT_MS,
         }, (error, stdout, stderr) => {
@@ -713,6 +865,7 @@ async function executeClaudeCommand(message, cwd, cliToolId = 'claude', permissi
                     ? describeCommandCodeBlockedToolCalls(commandCodeStream)
                     : null;
                 const exitCodeNumber = typeof errCode === 'number' ? errCode : null;
+                const isOpencodeV2 = cliToolId === 'opencode-v2';
                 const errorSummary = [
                     ...(blockedWarning ?? []),
                     `Error: ${error.message}`,
@@ -722,6 +875,7 @@ async function executeClaudeCommand(message, cwd, cliToolId = 'claude', permissi
                     cliToolId === 'command-code'
                         ? describeCommandCodeFailure(exitCodeNumber, commandCodeResult)
                         : null,
+                    isOpencodeV2 ? describeOpencodeV2Failure(stdout || '', stderr || '') : null,
                 ]
                     .filter((line) => line !== null)
                     .join('\n');
@@ -729,9 +883,14 @@ async function executeClaudeCommand(message, cwd, cliToolId = 'claude', permissi
                 // before it could write a result line (an unknown `--model` exits 1
                 // with empty stdout and the message on stderr) reports what it did
                 // write rather than an empty body.
+                //
+                // Issue #2974: OpenCode V2 likewise decodes its NDJSON, so the body is
+                // the answer (or the rendered `error` frame), not the event dump.
                 const decodedStdout = commandCodeResult
                     ? commandCodeResult.finalText
-                    : (stdout || '');
+                    : isOpencodeV2
+                        ? extractOpencodeFinalText(stdout || '') ?? (stdout || '')
+                        : (stdout || '');
                 const rawOutput = (0, cli_patterns_1.stripAnsi)([
                     errorSummary,
                     decodedStdout ? `\n--- stdout ---\n${decodedStdout}` : '',
@@ -781,6 +940,21 @@ async function executeClaudeCommand(message, cwd, cliToolId = 'claude', permissi
                 });
                 return;
             }
+            // Issue #2974: exit 0 is not the whole verdict for OpenCode V2 — a
+            // stream that ends in an `error` frame did not finish, whatever the
+            // exit code says (see findOpencodeTrailingError).
+            if (cliToolId === 'opencode-v2') {
+                const trailingError = findOpencodeTrailingError(stdout || '');
+                const body = extractOpencodeFinalText(stdout || '') ?? (stdout || '');
+                const head = trailingError ? [`Reason: ${trailingError}`] : [];
+                resolve({
+                    output: truncateOutput((0, cli_patterns_1.stripAnsi)([...head, body].join('\n'))),
+                    exitCode: 0,
+                    status: trailingError ? 'failed' : 'completed',
+                    ...(trailingError ? { error: trailingError } : {}),
+                });
+                return;
+            }
             const decoded = cliToolId === 'opencode'
                 ? extractOpencodeFinalText(stdout || '') ?? stdout ?? ''
                 : stdout || '';

package/dist/server/src/lib/session/current-output-builder.js

@@ -301,6 +301,9 @@ function summarizeAskUserQuestion(episode) {
         question: first.question,
         labels: first.choices.map((choice) => choice.label),
         questionCount: episode.spec.questions.length,
+        // Issue #2951: a question that takes a typed answer, so the panel and the
+        // phone sheet can offer an input for it.
+        ...(first.custom ? { custom: true } : {}),
     };
 }
 /**
@@ -999,7 +1002,10 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     // same way `structuredEvents.pendingDecisions[].kind` is, through the one
     // reader in `pending-decision-kind`.
     const addressesQuestion = promptWaiting !== null && (0, pending_decision_kind_1.pendingDecisionKind)(promptWaiting.toolName) === 'question';
-    const decisionOptions = addressableDecisionId !== null && !addressesQuestion ? structured_prompt_1.STRUCTURED_DECISION_OPTIONS : null;
+    const decisionOptions = addressableDecisionId !== null && !addressesQuestion
+        ? // Issue #2951: in the tool's own words (OpenCode V2: `Always allow`).
+            (0, structured_prompt_1.structuredDecisionOptionsFor)(cliToolId)
+        : null;
     const structuredFacts = promptWaiting === null
         ? null
         : {
@@ -1096,7 +1102,16 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     // an unclassified frame, and writing a "detection failed" row for a turn the
     // agent itself told us had ended would put a false stall into the audit trail
     // `capture --prompts` prints.
-    const unclassifiedVerdict = (0, unclassified_frame_tracker_1.observeUnclassifiedFrame)(compositeKey, merged.isUnclassifiedActive);
+    //
+    // Issue #2965: not while the agent holds a decision this server can answer by
+    // id (OpenCode V2 / opencode approvals and questions). The frame may still be
+    // one the scraper cannot read, but "nothing could answer it" is false then,
+    // and the row landed in the chat as a meaningless assistant line. Fed to the
+    // tracker as "not unclassified" rather than merely not written, so the run —
+    // and the 60 seconds — start afresh if the frame is still unreadable once the
+    // decision is gone (answered, expired, or the source dropped).
+    const answerableOverAgentApi = (0, structured_prompt_1.hasApiAnswerableDecision)(eventSource.capabilities.eventIdentity, structuredEvents.pendingDecisions ?? []);
+    const unclassifiedVerdict = (0, unclassified_frame_tracker_1.observeUnclassifiedFrame)(compositeKey, merged.isUnclassifiedActive && !answerableOverAgentApi);
     if (unclassifiedVerdict.shouldRecord) {
         recordUnclassifiedFrame(db, {
             worktreeId,
@@ -1136,7 +1151,16 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     }
     // Issue #1725: the structured layer saw a dialog the scraper did not. That
     // gap is the fact worth keeping — see recordStructuredPrompt.
-    if (promptWaiting !== null && structuredFacts !== null && !scraperPromptWaiting && !promptWaiting.recorded) {
+    //
+    // Issue #2965: except while that dialog can be answered over the agent's API
+    // — the live payload already carries its id and replies, so the row says
+    // nothing true. Not marked recorded either: should the decision expire with
+    // the dialog still open, the row is written then (the safe side).
+    if (promptWaiting !== null &&
+        structuredFacts !== null &&
+        !scraperPromptWaiting &&
+        !promptWaiting.recorded &&
+        !answerableOverAgentApi) {
         (0, agent_event_state_1.markStructuredPromptRecorded)(worktreeId, cliToolId, instanceId);
         recordStructuredPrompt(db, {
             worktreeId,

package/dist/server/src/lib/session/send-user-message.js

@@ -47,6 +47,7 @@ const logger_1 = require("../../lib/logger");
 const worktree_session_ownership_1 = require("../../lib/cli-tools/worktree-session-ownership");
 const session_name_1 = require("../../lib/cli-tools/session-name");
 const prompt_waiting_guard_1 = require("../../lib/session/prompt-waiting-guard");
+const session_start_error_1 = require("../../lib/session/session-start-error");
 const opencode_1 = require("../../lib/cli-tools/opencode");
 const logger = (0, logger_1.createLogger)('session/send-user-message');
 function getErrorMessage(error) {
@@ -313,6 +314,9 @@ async function sendUserMessage(db, params) {
     }
     catch (error) {
         logger.error('failed-to-send-message-to:', { error: getErrorMessage(error) });
+        if ((0, session_start_error_1.isSessionStartTimeoutError)(error)) {
+            return { ok: false, stage: 'send', error: error.message, code: session_start_error_1.SESSION_STARTING_CODE };
+        }
         return { ok: false, stage: 'send', error: getErrorMessage(error) };
     }
     // 5. Create user message in database (History source: chat_messages).