commandmate 0.27.1 → 0.29.0

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

@@ -56,12 +56,15 @@ exports.getLastKnownAgentModel = getLastKnownAgentModel;
 exports.recordCapturedModelInfo = recordCapturedModelInfo;
 exports.getLastCapturedModelInfo = getLastCapturedModelInfo;
 exports.getResolvedAgentModelInfo = getResolvedAgentModelInfo;
+exports.recordAgentReportedEffort = recordAgentReportedEffort;
+exports.getLastReportedAgentEffort = getLastReportedAgentEffort;
 exports.getLastKnownAgentEffort = getLastKnownAgentEffort;
 exports.beginAgentEventGeneration = beginAgentEventGeneration;
 exports.getAgentEventGenerationStartedAt = getAgentEventGenerationStartedAt;
 exports.discardAgentEventState = discardAgentEventState;
 exports.getStructuredSessionState = getStructuredSessionState;
 exports.reportPermissionRequestPending = reportPermissionRequestPending;
+exports.reportQuestionPending = reportQuestionPending;
 exports.getStructuredPromptWaiting = getStructuredPromptWaiting;
 exports.corroborateStructuredPromptWaiting = corroborateStructuredPromptWaiting;
 exports.markStructuredPromptRecorded = markStructuredPromptRecorded;
@@ -76,7 +79,12 @@ exports.getRecentEventIdentityCount = getRecentEventIdentityCount;
 exports.clearAgentStopEvents = clearAgentStopEvents;
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
 const agent_event_types_1 = require("../../lib/hooks/agent-event-types");
-const permission_request_payload_1 = require("../../lib/hooks/permission-request-payload");
+// Issue #2100: the shared list of tool names that mean "a human is being asked
+// to CHOOSE". Pure — its own only import is `permission-request-payload`, which
+// this module already reached for `ASK_USER_QUESTION_TOOL` — and importing it
+// here rather than repeating `'question'` is what keeps the release rule below
+// and `pendingDecisionKind`'s reader from drifting apart.
+const pending_decision_kind_1 = require("../../lib/hooks/pending-decision-kind");
 // Issue #1784: the terminal-frame half of "which model / effort is this on".
 const model_info_extractor_1 = require("../../lib/detection/model-info-extractor");
 const status_mapping_1 = require("../../lib/session/status-mapping");
@@ -180,6 +188,34 @@ const lastAgentModel = globalThis.__agentEventLastModel ??
  */
 const capturedModelInfo = globalThis.__agentCapturedModelInfo ??
     (globalThis.__agentCapturedModelInfo = new Map());
+/**
+ * compositeKey -> the effort the *agent itself* last reported (Issue #2048).
+ *
+ * The third source, and until #2048 there was no such thing: #1784's whole
+ * premise was that "no hook payload of any tool carries an effort field", which
+ * was true of the five push tools and stayed true of opencode's own screen —
+ * `model-info-extractor` still records that opencode prints no effort anywhere
+ * in its pane, across 17 live frames.
+ *
+ * What changed is the *channel*, not the screen. opencode calls it a **variant**
+ * and publishes it on the frames CommandMate is subscribed to —
+ * `Session.model.variant` on `session.updated` and `info.variant` on
+ * `message.updated`, measured on 1.18.22 in an isolated `HOME`
+ * (`docs/design/opencode-server-live-verification.md` §20.4). The names in that
+ * catalogue are `low` / `medium` / `high` / `max` / `minimal` / `none` /
+ * `xhigh`, and each one's entry carries an `effort` (or `reasoningEffort`) equal
+ * to itself — so the value is an effort in opencode's own vocabulary as well as
+ * in this map's.
+ *
+ * Kept apart from {@link capturedModelInfo} for the reason that map is kept
+ * apart from {@link lastAgentModel}: there is a precedence between them
+ * ({@link getResolvedAgentModelInfo}), and merging on write would lose it.
+ * Latched the same way, and never written with null — a turn that reports no
+ * variant is opencode running the model's default, not the previous choice
+ * being withdrawn.
+ */
+const reportedEffort = globalThis.__agentEventLastEffort ??
+    (globalThis.__agentEventLastEffort = new Map());
 /**
  * How long two identical events count as one delivery.
  *
@@ -872,7 +908,13 @@ function applyNotificationToTurn(key, record, generation) {
             source: 'notification',
             at: record.at,
             message: record.message ?? null,
-            toolName: null,
+            // Issue #2031. Was a hard `null`, which is what left an opencode approval
+            // reaching the browser with no statement of what it was for: the tool
+            // name is not in `permission.asked` and has to be carried on the record
+            // by whoever correlated it. Absent still means "this source had nothing
+            // to say", and `openDecision` leaves an earlier name in place for that.
+            toolName: record.toolName ?? null,
+            patterns: record.decisionPatterns ?? null,
             decisionId: record.decisionId ?? null,
             bootstrapDisplay: displayOf(record),
         });
@@ -993,6 +1035,11 @@ function openDecision(key, generation, input) {
         // age bound are measured from — and take the confirmation.
         existing.message = (0, provisional_turn_1.boundDecisionMessage)(input.message) ?? existing.message;
         existing.toolName = (0, provisional_turn_1.boundDecisionToolName)(input.toolName) ?? existing.toolName;
+        // Issue #2031, same rule as the two lines above it: a second sighting that
+        // knows the rules fills them in, one that does not leaves the earlier
+        // answer alone. The measured pair is exactly this — the `PermissionRequest`
+        // forecast carries no patterns, the `Notification` that confirms it does.
+        existing.patterns = (0, provisional_turn_1.boundDecisionPatterns)(input.patterns) ?? existing.patterns;
         existing.decisionId ??= decisionId;
         if (confirmed) {
             existing.source = 'notification';
@@ -1013,6 +1060,7 @@ function openDecision(key, generation, input) {
         source: input.source,
         message: (0, provisional_turn_1.boundDecisionMessage)(input.message),
         toolName: (0, provisional_turn_1.boundDecisionToolName)(input.toolName),
+        patterns: (0, provisional_turn_1.boundDecisionPatterns)(input.patterns),
         confirmedAt: confirmed ? input.at : null,
         scraperCorroborated: false,
         recorded: false,
@@ -1137,7 +1185,42 @@ function getLastCapturedModelInfo(worktreeId, cliToolId, instanceId) {
  * emitting null — see `CliToolSessionStatus`.
  */
 function getResolvedAgentModelInfo(worktreeId, cliToolId, instanceId) {
-    return (0, model_info_extractor_1.mergeModelInfo)(cliToolId, getLastKnownAgentModel(worktreeId, cliToolId, instanceId), getLastCapturedModelInfo(worktreeId, cliToolId, instanceId));
+    return (0, model_info_extractor_1.mergeModelInfo)(cliToolId, getLastKnownAgentModel(worktreeId, cliToolId, instanceId), getLastCapturedModelInfo(worktreeId, cliToolId, instanceId), 
+    // Issue #2048: the third source. Null for every tool but opencode and for
+    // every opencode session running on a model's default, so every other
+    // surface's string is byte-identical to pre-#2048.
+    getLastReportedAgentEffort(worktreeId, cliToolId, instanceId));
+}
+/**
+ * Latch the effort (opencode's *variant*) the agent named for itself (#2048).
+ *
+ * Latch, never clear — {@link latchAgentModel}'s rule, and for the same reason:
+ * `session.updated` omits `Session.model.variant` entirely when the session is
+ * on a model's default, and `message.updated` omits `info.variant` on the
+ * assistant message a turn opens with. Reading either absence as "the variant
+ * is now unknown" would blank the display between frames of the same turn.
+ *
+ * Called by the tool's own reader — `lib/hooks/sources/opencode/subscription` —
+ * rather than from the generic event path, because the value lives on frames
+ * that map to none of the seven event words.
+ *
+ * @param effort - The variant name, or null/empty to leave the latch alone
+ */
+function recordAgentReportedEffort(worktreeId, cliToolId, instanceId, effort) {
+    if (typeof effort !== 'string' || effort === '')
+        return;
+    reportedEffort.set((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId), effort.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH));
+}
+/**
+ * The effort the agent last reported for this instance, or null (#2048).
+ *
+ * The raw latched value, before precedence — {@link getResolvedAgentModelInfo}
+ * is what callers publishing to the UI or the API want. Exported so a test can
+ * tell "the agent said" apart from "the screen said", the same way
+ * {@link getLastCapturedModelInfo} lets it.
+ */
+function getLastReportedAgentEffort(worktreeId, cliToolId, instanceId) {
+    return reportedEffort.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
 }
 /**
  * The reasoning effort this instance is running at, or null (Issue #1784).
@@ -1203,6 +1286,9 @@ function beginAgentEventGeneration(worktreeId, cliToolId, instanceId, at = Date.
     // a relaunch would show the old process's effort with no frame left that
     // could contradict it. The next poll re-reads a live footer immediately.
     capturedModelInfo.delete(key);
+    // Issue #2048: and the variant the agent named, for exactly #1783's reason —
+    // the new process may have been launched with a different one, or with none.
+    reportedEffort.delete(key);
     // Issue #1899: the ids claimed for this key were issued by the process that
     // has just been replaced. Unlike the time-window keys, they never expire on
     // their own, so a generation is the only thing that retires them.
@@ -1239,6 +1325,8 @@ function discardAgentEventState(worktreeId, cliToolId, instanceId) {
     lastAgentModel.delete(key);
     // Issue #1784: nor does the pane its footer was read from.
     capturedModelInfo.delete(key);
+    // Issue #2048: nor the variant that session was running at.
+    reportedEffort.delete(key);
     // Issue #1899: nor do the frame ids that session issued.
     recentEventIdentities.delete(key);
 }
@@ -1352,6 +1440,10 @@ function reportPermissionRequestPending(worktreeId, cliToolId, instanceId, toolN
         at,
         message: null,
         toolName,
+        // A forecast has no payload behind it: the hook that fires it names the
+        // tool and nothing else, so there are no `Allow always` rules to state yet.
+        // The `Notification` that confirms this record supplies them (Issue #2031).
+        patterns: null,
         decisionId: null,
         // A forecast carries no event of its own, so the record it bootstraps is
         // described by the thing it is forecasting. `structuredEvents.lastEventType`
@@ -1359,6 +1451,61 @@ function reportPermissionRequestPending(worktreeId, cliToolId, instanceId, toolN
         bootstrapDisplay: { event: 'notification', at, detail: 'permission_prompt' },
     });
 }
+/**
+ * Report that a QUESTION dialog is open, naming the decision it is answered by
+ * (Issue #2100).
+ *
+ * ## Why this is not {@link reportPermissionRequestPending}
+ *
+ * That function is a *forecast*: `source: 'permission-request'`, no id, no
+ * payload, and `confirmedAt: null`, which bounds the record at
+ * {@link DIALOG_PENDING_MAX_MS}`.predicted` — 20 seconds — until something
+ * corroborates it. It was the only exported way to say "a human is blocked", so
+ * opencode's ingest called it for `question.asked` too, and that one call cost
+ * three separate facts:
+ *
+ *  1. the `que_…` the frame carried was **discarded** (`decisionId: null`), so
+ *     `current-output-builder`'s addressable-decision gate could never pass and
+ *     `promptData.decisionId` was null while the server was holding the id;
+ *  2. `source` read `permission-request` — "a dialog is about to be drawn" — for
+ *     an event that is the agent's own proof that one **is** drawn;
+ *  3. the record **expired after 20 s**. Measured on 1.18.23: at t+20 s
+ *     `pendingDecisions` emptied, `dedupDropped.dialogTimedOut` incremented and
+ *     `sessionStatus` flipped from `waiting` back to `ready` with the question
+ *     still on screen and the agent still blocked — opencode publishes no
+ *     `session.idle` at all while a question is pending (§27.4).
+ *
+ * A question is proof, so it is opened as `'notification'`: confirmed on
+ * arrival, bounded by `DIALOG_PENDING_MAX_MS.confirmed`, and released by the
+ * `post_tool_use` the answer produces exactly as an approval is.
+ *
+ * Names no tool and no event word — both arrive as values, from the ingest that
+ * owns them — so this module keeps the property that it can be read without
+ * knowing which agent is on the other end.
+ *
+ * @param toolName - The marker `pendingDecisionKind` recovers the kind from
+ * @param decisionId - The agent's own id for the question, or null when the
+ *   payload named none (the record is then anonymous, as before)
+ * @param detail - The event detail a bootstrapped display record carries
+ * @param at - Epoch ms; defaults to now
+ */
+function reportQuestionPending(worktreeId, cliToolId, instanceId, input, at = Date.now()) {
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
+    openDecision(key, currentGeneration(key), {
+        source: 'notification',
+        at,
+        // The question TEXT is not the dialog's `message`: it is published as
+        // `promptData.askUserQuestion`, from the episode `recordAskUserQuestion`
+        // holds, so that one parse feeds the summary and the answerable numbers.
+        message: null,
+        toolName: input.toolName,
+        // A question grants nothing that outlives it — there is no `Allow always`
+        // to state the size of.
+        patterns: null,
+        decisionId: input.decisionId,
+        bootstrapDisplay: { event: 'notification', at, detail: input.detail },
+    });
+}
 /**
  * The open dialog this instance's structured events imply, or null.
  *
@@ -1477,8 +1624,24 @@ function applyAskUserQuestionTransition(key, record) {
             // reachable when the operator's own settings.json registers a wider
             // matcher than the injected `AskUserQuestion` one — the two files are
             // concatenated, not substituted (#1722).
-            if (record.detail !== permission_request_payload_1.ASK_USER_QUESTION_TOOL)
+            //
+            // Issue #2100: the exemption is the whole QUESTION vocabulary, not
+            // Claude's one spelling. opencode names its question tool `question`, and
+            // it publishes a tool part for the same call: measured on 1.18.23 in an
+            // isolated HOME, `question.asked` and
+            // `message.part.updated(tool=question, status=running)` arrive **in the
+            // same millisecond**, in that order (§27.3). Under the old test the
+            // second frame read as "the agent moved on to another tool" and deleted
+            // the episode 1 ms after the ingest recorded it, which is why
+            // `pendingDecisions[].questionOptions` and `promptData.askUserQuestion`
+            // were null for every opencode question. Claude is unaffected —
+            // `AskUserQuestion` is the first member of the same list — and the cost
+            // is that a hook tool literally named `question` no longer releases the
+            // episode, which is the same name `pendingDecisionKind` already reads as
+            // "this record is a question" for every tool.
+            if (!pending_decision_kind_1.QUESTION_DECISION_TOOL_NAMES.includes(record.detail ?? '')) {
                 askUserQuestion.delete(key);
+            }
             return;
         case 'notification':
             if (record.detail === 'idle_prompt')
@@ -1753,4 +1916,6 @@ function clearAgentStopEvents() {
     lastAgentModel.clear();
     // Issue #1784: and the same for the scraped half.
     capturedModelInfo.clear();
+    // Issue #2048: and for the variant the agent reported.
+    reportedEffort.clear();
 }

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

@@ -18,6 +18,7 @@ exports.ALLOWED_CLI_TOOLS = exports.MAX_MESSAGE_LENGTH = exports.EXECUTION_TIMEO
 exports.getCommandForTool = getCommandForTool;
 exports.truncateOutput = truncateOutput;
 exports.buildCliArgs = buildCliArgs;
+exports.extractOpencodeFinalText = extractOpencodeFinalText;
 exports.executeClaudeCommand = executeClaudeCommand;
 exports.getActiveProcesses = getActiveProcesses;
 const child_process_1 = require("child_process");
@@ -91,7 +92,7 @@ function truncateOutput(output) {
  * - codex: exec <message> --sandbox <permission>
  * - gemini: -p <message>
  * - vibe-local: [-p <message> -y] or [--model <model> -p <message> -y]
- * - opencode: [run <message>] or [run -m <provider/model> <message>]
+ * - opencode: run --format json [-m <model>] [--agent <a>] [--variant <v>] [-c] [--title <t>] <message>
  * - antigravity: -p <message> --dangerously-skip-permissions
  * - others: -p <message> (fallback)
  *
@@ -112,7 +113,7 @@ function buildCliArgs(message, cliToolId, permission, options) {
                 return ['--model', options.model, '-p', message, '-y'];
             }
             return ['-p', message, '-y'];
-        case 'opencode':
+        case 'opencode': {
             // [D2-007] When model is not specified, OpenCode uses opencode.json default model.
             //
             // Issue #1914: the model is passed through **verbatim**. It used to be
@@ -126,18 +127,38 @@ function buildCliArgs(message, cliToolId, permission, options) {
             //    difference between "the user asked for Ollama" and "the code assumed
             //    it".
             //
-            // The excuse is that it never ran. `resolveModelOption()` answered
-            // `undefined` for opencode, and the only other caller
-            // (`daily-summary-generator`) is gated by `SUMMARY_ALLOWED_TOOLS`, which
-            // does not list opencode either — so there is no stored CMATE.md value
-            // that the removed prefix was keeping correct. The branch is kept rather
-            // than deleted because this Issue makes it reachable; deleting it would
-            // mean `opencode --model x` in CMATE.md parses, validates, and is then
-            // silently ignored, which is the same class of bug one layer down.
-            if (options?.model) {
-                return ['run', '-m', options.model, message];
-            }
-            return ['run', message];
+            // Issue #2044 adds `--format json` and the four run options the CMATE.md
+            // column can now carry.
+            //
+            // ## Why `--format json` is unconditional
+            //
+            // `--format default` writes a *formatted* transcript — box drawing, the
+            // tool calls, the model banner — and recovering the assistant's answer
+            // from it means guessing which decorations to strip, in a layout that is
+            // free to change between releases. `--format json` emits one JSON event
+            // per line and the answer is a field (measured on 1.18.22; see
+            // `docs/design/opencode-server-live-verification.md` §15). Making it a
+            // per-caller flag would leave the guessing path alive for whoever forgot
+            // to pass it, so there is only the one path and
+            // {@link extractOpencodeFinalText} reads it.
+            //
+            // Order: options first, message last. `opencode run` declares `message`
+            // as a variadic positional (`[message..]`), so a message that begins with
+            // `-` is still the message and never eats a flag.
+            const args = ['run', '--format', 'json'];
+            if (options?.model)
+                args.push('-m', options.model);
+            if (options?.agent)
+                args.push('--agent', options.agent);
+            if (options?.variant)
+                args.push('--variant', options.variant);
+            if (options?.continueSession)
+                args.push('-c');
+            if (options?.title)
+                args.push('--title', options.title);
+            args.push(message);
+            return args;
+        }
         case 'antigravity':
             // Issue #990 (Phase C): `agy -p <message>` runs a single prompt non-interactively.
             // --dangerously-skip-permissions auto-approves tool use so the process does not
@@ -162,6 +183,115 @@ function buildCliArgs(message, cliToolId, permission, options) {
             return ['-p', message, '--output-format', 'text', '--permission-mode', permission ?? 'acceptEdits'];
     }
 }
+// =============================================================================
+// opencode `--format json` extraction (Issue #2044)
+// =============================================================================
+/**
+ * The assistant's answer, pulled out of `opencode run --format json` stdout.
+ *
+ * ## The measured stream
+ *
+ * One JSON object per line, no `event:` framing, no wrapping array. Measured on
+ * opencode 1.18.22 inside an isolated `HOME`
+ * (`docs/design/opencode-server-live-verification.md` §15):
+ *
+ * ```text
+ * {"type":"step_start","sessionID":"ses_…","part":{…,"type":"step-start"}}
+ * {"type":"tool_use","sessionID":"ses_…","part":{…,"tool":"read"}}
+ * {"type":"text","sessionID":"ses_…","part":{"messageID":"msg_…","type":"text","text":"…"}}
+ * {"type":"step_finish","sessionID":"ses_…","part":{…,"tokens":{…},"cost":0.0038181}}
+ * ```
+ *
+ * and, when the run fails (exit 1, **empty stderr**):
+ *
+ * ```text
+ * {"type":"error","sessionID":"ses_…","error":{"name":"UnknownError","data":{…}}}
+ * ```
+ *
+ * ## Why the last *message*, not the last *event*
+ *
+ * A run that calls a tool produces two assistant messages: the one that decided
+ * to call the tool, and the one that answered afterwards. Each carries its own
+ * `messageID`, and only the second is the answer. Taking the last `text` event
+ * alone would be right today — the measured runs put one text part in the final
+ * message — but a message may hold several text parts, and returning the last
+ * fragment of an answer while dropping its beginning is a silent truncation that
+ * would look exactly like a short reply. So: every `text` part whose
+ * `messageID` matches the final one, in arrival order, joined by a blank line.
+ * Parts with no `messageID` fall back to "the last one", which is the same
+ * answer for a stream that never names its messages.
+ *
+ * ## Why it never throws and never returns ""
+ *
+ * A caller that gets `null` keeps the raw stdout, so a stream shape this
+ * function does not recognise degrades to "unformatted output" rather than to
+ * "the report is empty". Unparseable lines are skipped rather than failing the
+ * whole extraction, because `--print-logs` and a plugin's stray `console.log`
+ * both land on the same stdout.
+ *
+ * @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
+ */
+function extractOpencodeFinalText(stdout) {
+    const texts = [];
+    let lastError = null;
+    for (const line of stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{'))
+            continue;
+        let frame;
+        try {
+            frame = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (typeof frame !== 'object' || frame === null)
+            continue;
+        const record = frame;
+        const part = typeof record.part === 'object' && record.part !== null
+            ? record.part
+            : null;
+        if (record.type === 'text' && part && typeof part.text === 'string') {
+            texts.push({
+                messageId: typeof part.messageID === 'string' ? part.messageID : null,
+                text: part.text,
+            });
+            continue;
+        }
+        if (record.type === 'error') {
+            lastError = renderOpencodeErrorFrame(record);
+        }
+    }
+    if (texts.length > 0) {
+        const finalMessageId = texts[texts.length - 1].messageId;
+        const belonging = finalMessageId === null
+            ? [texts[texts.length - 1]]
+            : texts.filter((entry) => entry.messageId === finalMessageId);
+        return belonging.map((entry) => entry.text).join('\n\n');
+    }
+    return lastError;
+}
+/**
+ * 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.
+ */
+function renderOpencodeErrorFrame(record) {
+    const error = typeof record.error === 'object' && record.error !== null
+        ? record.error
+        : {};
+    const name = typeof error.name === 'string' ? error.name : 'error';
+    const data = typeof error.data === 'object' && error.data !== null
+        ? error.data
+        : {};
+    const message = typeof data.message === 'string' ? data.message : '';
+    return message ? `opencode error: ${name}: ${message}` : `opencode error: ${name}`;
+}
 /**
  * Execute a CLI command in a worktree directory.
  *
@@ -224,7 +354,14 @@ async function executeClaudeCommand(message, cwd, cliToolId = 'claude', permissi
                 });
                 return;
             }
-            const rawOutput = (0, cli_patterns_1.stripAnsi)(stdout || '');
+            // Issue #2044: opencode speaks NDJSON now (`--format json`), so the
+            // stored output is the assistant's answer rather than the event log.
+            // `?? stdout` on purpose: an unrecognised stream is reported verbatim,
+            // never swallowed.
+            const decoded = cliToolId === 'opencode'
+                ? extractOpencodeFinalText(stdout || '') ?? stdout ?? ''
+                : stdout || '';
+            const rawOutput = (0, cli_patterns_1.stripAnsi)(decoded);
             const output = truncateOutput(rawOutput);
             resolve({
                 output,