commandmate 0.27.0 → 0.28.0

package/dist/server/src/lib/hooks/sources/opencode/history.js

@@ -0,0 +1,480 @@
+"use strict";
+/**
+ * Writing opencode's own words into conversation history (Issue #2041).
+ *
+ * The second writer of `chat_messages` for an agent turn. The first is
+ * `lib/polling/response-checker`, which captures the pane and cleans it; this
+ * one reads the text off the SSE stream CommandMate is already subscribed to,
+ * and the two are mutually exclusive — the poller stands down on
+ * `isOpencodeStructuredHistoryLive` (declared in `./subscription`, which owns
+ * the liveness this module is downstream of).
+ *
+ * ## Why a second writer rather than a better cleaner
+ *
+ * `cleanOpenCodeResponse` has to undo a rendering. The pane is 200 columns, the
+ * agent's paragraph is 967 characters (measured), and by the time the poller
+ * sees it the text has been hard-wrapped, gutter-prefixed and — if the turn
+ * outgrew the pane — had its head scrolled off. #1911 is three separate defects
+ * from exactly that, and the Layer-2 accumulator that patches the third one is
+ * documented as preferring "a possible duplicate over a guaranteed truncation".
+ * None of those problems exist on the source text, so this path does not solve
+ * them; it does not have them.
+ *
+ * ## Two ways in, one renderer
+ *
+ * - **Live.** `./subscription` hands every `message.updated` /
+ *   `message.part.updated` frame to {@link recordOpencodeTranscriptFrame`}, and
+ *   `session.idle` flushes with {@link flushOpencodeTurn}.
+ * - **Backfill.** {@link backfillOpencodeHistory} reads
+ *   `GET /session/:id/message` after a (re)connect. Necessary rather than
+ *   belt-and-braces: a fresh subscription to `/event` replays **nothing**
+ *   (measured — one `server.connected` and then silence), so every turn that
+ *   ran while CommandMate was down is unreachable from the stream.
+ *
+ * Both build the same {@link OpencodeTurnAccumulator} and call the same
+ * `renderOpencodeTurn`, and both derive the row's id with
+ * `opencodeTurnRequestId`, so the second one to arrive finds the row already
+ * there and does nothing.
+ *
+ * ## Nothing here throws
+ *
+ * Same contract as `./ingest`, for the same reason: a history row is a record
+ * of a session that is still running, and failing to write it must cost the
+ * record, never the session. The database imports are dynamic for the reason
+ * `./ingest` documents — `../registry` statically imports `./source`, and
+ * anything in that graph puts `better-sqlite3` into every import of
+ * `@/lib/hooks/sources`.
+ *
+ * @module lib/hooks/sources/opencode/history
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_OPENCODE_BACKFILLED_TURNS = exports.MAX_OPENCODE_OPEN_TURNS = void 0;
+exports.recordOpencodeTranscriptFrame = recordOpencodeTranscriptFrame;
+exports.peekOpencodeTurn = peekOpencodeTurn;
+exports.flushOpencodeTurn = flushOpencodeTurn;
+exports.forgetOpencodeTranscripts = forgetOpencodeTranscripts;
+exports.resetOpencodeTranscripts = resetOpencodeTranscripts;
+exports.backfillOpencodeHistory = backfillOpencodeHistory;
+const auto_yes_state_1 = require("../../../../lib/auto-yes-state");
+const logger_1 = require("../../../../lib/logger");
+const agent_transcript_1 = require("../../../../types/agent-transcript");
+const event_mapper_1 = require("../event-mapper");
+const client_1 = require("./client");
+const transcript_1 = require("./transcript");
+const logger = (0, logger_1.createLogger)('lib/hooks/sources/opencode/history');
+/**
+ * Cap on turns held in memory for one instance.
+ *
+ * A turn is dropped from the map the moment it is flushed, so this only bounds
+ * turns that never ended — a session abandoned mid-reply, or one whose
+ * `session.idle` was lost with the connection. Small on purpose: an unflushed
+ * turn is recoverable from `GET /session/:id/message`, so forgetting one costs
+ * a round trip and never the text.
+ */
+exports.MAX_OPENCODE_OPEN_TURNS = 16;
+/**
+ * Cap on turns one backfill pass will write.
+ *
+ * The document comes off a server CommandMate did not start and a long-lived
+ * session accumulates without bound. Bounded, newest first, and the overflow is
+ * logged — the same treatment `MAX_RESYNCED_DECISIONS` gets, and for the same
+ * reason.
+ */
+exports.MAX_OPENCODE_BACKFILLED_TURNS = 50;
+/**
+ * On `globalThis` for the reason every shared map in this subsystem is (#1736):
+ * under `next dev` the subscription's bundle and the poller's bundle would
+ * otherwise each get a private copy, and the turn accumulated by one would be
+ * invisible to the other.
+ */
+const transcripts = (globalThis.__opencodeTranscripts ??= new Map());
+function keyOf(target) {
+    return (0, auto_yes_state_1.buildCompositeKey)(target.worktreeId, target.cliToolId, target.instanceId);
+}
+/** The turns held for one instance, created on demand. */
+function turnsFor(target) {
+    const key = keyOf(target);
+    let turns = transcripts.get(key);
+    if (!turns) {
+        turns = new Map();
+        transcripts.set(key, turns);
+    }
+    return turns;
+}
+/**
+ * Drop the oldest turns until the map is within {@link MAX_OPENCODE_OPEN_TURNS}.
+ *
+ * Insertion order, so what goes is what has been open longest — which is the
+ * one least likely to still be receiving parts.
+ */
+function boundOpenTurns(target, turns) {
+    while (turns.size > exports.MAX_OPENCODE_OPEN_TURNS) {
+        const oldest = turns.keys().next();
+        if (oldest.done)
+            break;
+        turns.delete(oldest.value);
+        logger.info('opencode-transcript-turn-evicted', {
+            worktreeId: target.worktreeId,
+            instanceId: target.instanceId ?? target.cliToolId,
+            sessionId: oldest.value,
+            reason: 'max-open-turns',
+        });
+    }
+}
+/**
+ * Take in one frame that may carry part of a reply.
+ *
+ * Two frame types matter and they arrive in this order:
+ *
+ *  - `message.updated` with `info.role === "assistant"` **opens** the turn. It
+ *    is the only frame that names the `parentID` the turn is keyed on; a part
+ *    carries its `messageID` but never its parent, so a part that arrives for a
+ *    turn this has not opened has nowhere to go and is counted rather than
+ *    guessed at. Measured on 1.18.22: the assistant `message.updated` precedes
+ *    its first part by 3.5 s in turn 1 and 1.7 s in turn 2, so the ordering is
+ *    not a race being relied on.
+ *  - `message.part.updated` fills a slot. `message.part.delta` is deliberately
+ *    **not** read — see `./transcript` for the measurement that decided it.
+ *
+ * A `message.updated` whose role is `user` is skipped: its text is the prompt,
+ * which `send` has already written as the user half of the pair.
+ *
+ * Never throws.
+ *
+ * @param target - The instance the subscription belongs to
+ * @param frame - `{ id, type, properties }`, straight off the stream
+ * @param receivedAt - Epoch ms
+ */
+function recordOpencodeTranscriptFrame(target, frame, receivedAt) {
+    try {
+        const type = (0, event_mapper_1.readStringField)(frame, 'type');
+        const properties = (0, event_mapper_1.isPlainObject)(frame.properties) ? frame.properties : {};
+        const sessionId = (0, event_mapper_1.readStringField)(properties, 'sessionID');
+        if (!sessionId)
+            return;
+        if (type === 'message.updated') {
+            const info = (0, event_mapper_1.isPlainObject)(properties.info) ? properties.info : null;
+            if (!info || info.role !== 'assistant')
+                return;
+            const userMessageId = (0, event_mapper_1.readStringField)(info, 'parentID');
+            if (!userMessageId)
+                return;
+            const turns = turnsFor(target);
+            const existing = turns.get(sessionId);
+            // A second assistant message inside one turn keeps the open accumulator —
+            // measured, the tool-calling turn produced two, and closing the first
+            // here would split one reply across two rows.
+            const turn = existing?.userMessageId === userMessageId
+                ? existing
+                : (0, transcript_1.createOpencodeTurn)(sessionId, userMessageId, receivedAt);
+            if (turn !== existing) {
+                // A new turn while the previous one is still open means its
+                // `session.idle` never arrived — the stream dropped mid-turn, or the
+                // flush lost a race with the next prompt. What was accumulated is
+                // abandoned rather than merged into the wrong prompt's reply; the
+                // backfill is what recovers it.
+                if (existing) {
+                    logger.info('opencode-transcript-turn-superseded', {
+                        worktreeId: target.worktreeId,
+                        instanceId: target.instanceId ?? target.cliToolId,
+                        sessionId,
+                        abandoned: existing.userMessageId,
+                    });
+                }
+                turns.set(sessionId, turn);
+                boundOpenTurns(target, turns);
+            }
+            const messageId = (0, event_mapper_1.readStringField)(info, 'id');
+            if (messageId)
+                (0, transcript_1.claimOpencodeMessage)(turn, messageId);
+            return;
+        }
+        if (type !== 'message.part.updated')
+            return;
+        const part = (0, transcript_1.readOpencodePart)(properties.part);
+        if (!part)
+            return;
+        const turn = turnsFor(target).get(sessionId);
+        // The ownership check is the one that keeps the operator's own prompt out of
+        // the reply that answers it: the user's text part travels on this same
+        // stream, and nothing but `assistantMessageIds` distinguishes it from the
+        // agent's. Measured, it arrives before the turn is even open — but this way
+        // the outcome does not depend on that staying true.
+        if (!turn || !(0, transcript_1.ownsOpencodeMessage)(turn, part.messageId)) {
+            // The stream opened mid-turn, or the part belongs to the user's own
+            // message (whose `message.updated` this deliberately ignores). Either way
+            // the backfill is what recovers it.
+            logger.debug('opencode-transcript-part-unattached', {
+                worktreeId: target.worktreeId,
+                instanceId: target.instanceId ?? target.cliToolId,
+                sessionId,
+                partType: part.type,
+                reason: turn ? 'foreign-message' : 'no-open-turn',
+            });
+            return;
+        }
+        if (!(0, transcript_1.addOpencodePart)(turn, part)) {
+            logger.warn('opencode-transcript-turn-overflow', {
+                worktreeId: target.worktreeId,
+                instanceId: target.instanceId ?? target.cliToolId,
+                sessionId,
+                partType: part.type,
+            });
+        }
+    }
+    catch (error) {
+        logger.error('opencode-transcript-record-failed', {
+            worktreeId: target.worktreeId,
+            instanceId: target.instanceId ?? target.cliToolId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+/**
+ * The turn currently open on this session, for tests and for callers that need
+ * to know whether a flush would do anything.
+ */
+function peekOpencodeTurn(target, sessionId) {
+    return transcripts.get(keyOf(target))?.get(sessionId) ?? null;
+}
+/**
+ * Close the turn on this session and write it.
+ *
+ * Called from `session.idle`, which is where opencode says a turn is over — the
+ * same frame `./turn-gate` publishes as `stop`. Deliberately *not* gated on the
+ * gate's verdict: the gate suppresses the **second** `session.idle` of an abort
+ * (19-23 ms after the first, #1758 §5.3.2) so a `wait` is not resolved twice,
+ * and a suppressed repeat here is a no-op anyway because the accumulator has
+ * already been taken. Reading the frame keeps the two decisions independent, the
+ * same way `watchOpencodeSessionIdle` does (#2034).
+ *
+ * Never throws.
+ *
+ * @param target - The instance
+ * @param sessionId - `ses_…` from the `session.idle` frame
+ * @returns Whether a row was written
+ */
+async function flushOpencodeTurn(target, sessionId) {
+    const turns = transcripts.get(keyOf(target));
+    const turn = turns?.get(sessionId);
+    if (!turn || !turns)
+        return false;
+    // Taken before the await: a second `session.idle` for the same session must
+    // not find the accumulator still there and race a duplicate insert past the
+    // existence check below.
+    turns.delete(sessionId);
+    return writeOpencodeTurn(target, (0, transcript_1.renderOpencodeTurn)(turn), turn.startedAt, 'stream');
+}
+/**
+ * Forget everything held for one instance.
+ *
+ * Called when the subscription closes, on the same terms as
+ * `forgetAgentSessionTelemetry` (#2040): the accumulator describes a reply a
+ * process was in the middle of writing, and a process that is gone will not
+ * finish it. Anything already produced is still in `opencode.db` and is
+ * recovered by the backfill on the next attach.
+ */
+function forgetOpencodeTranscripts(target) {
+    transcripts.delete(keyOf(target));
+}
+/** Drop every instance's turns. Test seam. */
+function resetOpencodeTranscripts() {
+    transcripts.clear();
+}
+/**
+ * Write one rendered turn, unless it is already there.
+ *
+ * The existence check and the insert are not in a transaction, and do not need
+ * to be: both writers derive the same `request_id` from the same `parentID`, so
+ * the worst a lost race can produce is two identical rows — and the two writers
+ * that exist cannot run concurrently, because the stream path is a single
+ * subscription's callback and the backfill runs before it starts delivering.
+ *
+ * @param origin - `stream` or `backfill`, for the log only
+ * @returns Whether a row was written
+ */
+async function writeOpencodeTurn(target, rendered, timestampMs, origin) {
+    const instanceId = target.instanceId ?? target.cliToolId;
+    try {
+        if (rendered.body.length === 0) {
+            // A turn that produced only bookkeeping parts — an abort before the first
+            // token, or a `session.idle` for a session that was never this pane's.
+            // Nothing to say, and an empty row would show as a blank reply forever.
+            logger.info('opencode-transcript-turn-empty', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                sessionId: rendered.sessionId,
+                origin,
+            });
+            return false;
+        }
+        if (rendered.unknownPartTypes.length > 0) {
+            // C8's rule applied to parts: a shape this reader has no words for is
+            // counted, never guessed at. The tally is how a later opencode's new part
+            // variant becomes visible instead of silently vanishing from history.
+            logger.info('opencode-transcript-unknown-parts', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                sessionId: rendered.sessionId,
+                partTypes: rendered.unknownPartTypes,
+            });
+        }
+        const requestId = (0, agent_transcript_1.opencodeTurnRequestId)(rendered.userMessageId);
+        const [{ getDbInstance }, { createMessage, findMessageByRequestId }, { broadcastMessage }] = await Promise.all([
+            Promise.resolve().then(() => __importStar(require('../../../../lib/db/db-instance'))),
+            Promise.resolve().then(() => __importStar(require('../../../../lib/db'))),
+            Promise.resolve().then(() => __importStar(require('../../../../lib/ws-server'))),
+        ]);
+        const db = getDbInstance();
+        if (findMessageByRequestId(db, target.worktreeId, requestId)) {
+            logger.debug('opencode-transcript-turn-already-saved', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                requestId,
+                origin,
+            });
+            return false;
+        }
+        const message = createMessage(db, {
+            worktreeId: target.worktreeId,
+            role: 'assistant',
+            content: rendered.body,
+            messageType: 'normal',
+            // The agent's own clock where it gave one (`info.time.created` on the
+            // backfill path), so a run of rows rebuilt after a restart keeps the order
+            // the conversation happened in rather than the order it was recovered in.
+            timestamp: new Date(timestampMs > 0 ? timestampMs : Date.now()),
+            cliToolId: target.cliToolId,
+            instanceId,
+            requestId,
+        });
+        broadcastMessage('message', { worktreeId: target.worktreeId, message });
+        logger.info('opencode-transcript-turn-saved', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            sessionId: rendered.sessionId,
+            requestId,
+            origin,
+            bodyLength: rendered.body.length,
+            textParts: rendered.textParts,
+            toolParts: rendered.toolParts,
+        });
+        return true;
+    }
+    catch (error) {
+        logger.error('opencode-transcript-write-failed', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            sessionId: rendered.sessionId,
+            origin,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+}
+/**
+ * Recover every turn of a session that is not in history yet.
+ *
+ * Runs after a (re)connect. The turns already saved are skipped by the same
+ * `request_id` check the live path uses, so this is safe to run on every
+ * connect rather than only on the first — and it has to be, because the case it
+ * covers is not only "CommandMate restarted" but also "the stream dropped
+ * mid-turn and the `session.idle` was lost with it".
+ *
+ * Never throws.
+ *
+ * @param target - The instance
+ * @param port - Its server
+ * @param sessionId - `ses_…`; the caller resolves which session is this pane's
+ * @returns How many rows were written
+ */
+async function backfillOpencodeHistory(target, port, sessionId) {
+    const instanceId = target.instanceId ?? target.cliToolId;
+    try {
+        const body = await (0, client_1.fetchOpencodeSessionMessages)(port, sessionId);
+        if (body === null) {
+            logger.info('opencode-transcript-backfill-unavailable', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                port,
+                sessionId,
+            });
+            return 0;
+        }
+        const turns = (0, transcript_1.buildOpencodeTurnsFromMessages)(body, sessionId);
+        // Newest first, so a session past the cap keeps the turns a reader is
+        // actually looking at rather than the ones it has scrolled away from.
+        const ordered = [...turns].sort((a, b) => b.startedAt - a.startedAt);
+        const kept = ordered.slice(0, exports.MAX_OPENCODE_BACKFILLED_TURNS);
+        if (ordered.length > kept.length) {
+            logger.warn('opencode-transcript-backfill-truncated', {
+                worktreeId: target.worktreeId,
+                instanceId,
+                sessionId,
+                examined: kept.length,
+                skipped: ordered.length - kept.length,
+                limit: exports.MAX_OPENCODE_BACKFILLED_TURNS,
+            });
+        }
+        let written = 0;
+        // Oldest of the kept ones first, so the rows are inserted in conversation
+        // order and `updateWorktreeTimestamp` ends on the newest.
+        for (const turn of [...kept].reverse()) {
+            const saved = await writeOpencodeTurn(target, (0, transcript_1.renderOpencodeTurn)(turn), turn.startedAt, 'backfill');
+            if (saved)
+                written += 1;
+        }
+        logger.info('opencode-transcript-backfill-done', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            port,
+            sessionId,
+            turns: turns.length,
+            written,
+        });
+        return written;
+    }
+    catch (error) {
+        logger.error('opencode-transcript-backfill-failed', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            port,
+            sessionId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return 0;
+    }
+}

package/dist/server/src/lib/hooks/sources/opencode/ingest.js

@@ -25,6 +25,18 @@
  * then. (`./source` does not import this module at all; the runtime wires the
  * two together.)
  *
+ * ## Why the phone is notified from here (Issue #2045)
+ *
+ * For every other tool a prompt notification is raised from the waiting edge,
+ * which is only observed by a status probe — so a wait notifies when somebody
+ * is already looking. opencode cannot afford that: after `question.asked` the
+ * session stays `busy` forever and nothing in this process answers it, so the
+ * turn is stopped until a human acts. Two events therefore notify through
+ * `./push` directly, and only these two: `question.asked` and
+ * `session.error`. The call is closed to opencode by construction — the other
+ * five tools arrive through `POST /api/hooks/agent-event`, which does not
+ * import this module.
+ *
  * Nothing here throws. An event is a fact about a session that is still
  * running, and a failure to record it must cost the record, never the session.
  *
@@ -68,12 +80,14 @@ exports.ingestOpencodeEvent = ingestOpencodeEvent;
 const logger_1 = require("../../../../lib/logger");
 const agent_event_types_1 = require("../../../../lib/hooks/agent-event-types");
 const permission_adjudication_1 = require("../../../../lib/hooks/permission-adjudication");
+const pending_decision_kind_1 = require("../../../../lib/hooks/pending-decision-kind");
 const agent_event_state_1 = require("../../../../lib/session/agent-event-state");
 const structured_prompt_1 = require("../../../../lib/session/structured-prompt");
 const event_mapper_1 = require("../event-mapper");
 const registry_1 = require("../registry");
 const mappers_1 = require("./mappers");
 const payloads_1 = require("./payloads");
+const push_1 = require("./push");
 const tool_id_1 = require("./tool-id");
 const logger = (0, logger_1.createLogger)('lib/hooks/sources/opencode/ingest');
 /** The one-line human-facing summary for a notification, or null. */
@@ -167,12 +181,26 @@ function replyReleasesPrompt(target, instanceId) {
  * be read off the screen (#1708), while opencode publishes the questions and
  * their choices as data (#1758 §5.2.4).
  *
- * `reportPermissionRequestPending` is called alongside because that is the only
- * exported way to tell the detection layer a human is blocked, and a question
- * blocks exactly as an approval does — the session reads `busy` and no
- * `session.idle` arrives until it is answered (§5.3.1). It is recorded as
- * provisional, so it expires unless the scraper corroborates it, which is the
- * same treatment Claude's pre-dialog prediction gets.
+ * `reportQuestionPending` is called alongside to tell the detection layer a
+ * human is blocked, because a question blocks exactly as an approval does — the
+ * session reads `busy` and no `session.idle` arrives until it is answered
+ * (§5.3.1, re-measured on 1.18.23 in §27.4).
+ *
+ * ## Issue #2100: the id goes ON the record
+ *
+ * This used to call `reportPermissionRequestPending`, which opens a *forecast*:
+ * anonymous, `source: 'permission-request'`, and bounded at 20 s. The `que_…`
+ * parsed one line above — `spec.promptId`, the very id
+ * `POST /question/:id/reply` takes — was thrown away, so the browser was told
+ * `decisionId: null` about a decision this server could name, and the record
+ * vanished 20 s into a wait that has no timeout at all. The choices went the
+ * same way for a different reason; see `agent-event-state`'s
+ * `applyAskUserQuestionTransition`.
+ *
+ * Nothing about the *reply* path changed: a question is still answered by
+ * `answerPendingQuestion` against `listPending()`, which reads the agent's own
+ * `GET /question` rather than this record. What the record now carries is the
+ * id that lets a surface address one without asking which of several is meant.
  */
 function recordQuestion(target, event, instanceId) {
     const source = (0, registry_1.getAgentEventSource)(tool_id_1.OPENCODE_CLI_TOOL_ID);
@@ -180,10 +208,25 @@ function recordQuestion(target, event, instanceId) {
     if (!spec)
         return;
     (0, agent_event_state_1.recordAskUserQuestion)(target.worktreeId, tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId, spec, event.receivedAt);
-    (0, agent_event_state_1.reportPermissionRequestPending)(target.worktreeId, tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId, 'question', event.receivedAt);
+    (0, agent_event_state_1.reportQuestionPending)(target.worktreeId, tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId, {
+        // Issue #2040: the marker `structuredEvents.pendingDecisions[].kind` is
+        // recovered from, named once in `pending-decision-kind` so the writer here
+        // and the reader in `current-output-builder` cannot drift apart.
+        toolName: pending_decision_kind_1.OPENCODE_QUESTION_TOOL_NAME,
+        // Issue #2100. `parseOpencodeQuestion` refuses a payload with no `id`, so
+        // this is non-null for every question that got this far; the null branch
+        // exists because the type says it can be, not because a frame was seen
+        // without one.
+        decisionId: spec.promptId,
+        detail: mappers_1.OPENCODE_QUESTION_DETAIL,
+    }, event.receivedAt);
     logger.info('opencode-question-recorded', {
         worktreeId: target.worktreeId,
         instanceId,
+        // Issue #2100: logged so a live run says whether the id reached the record.
+        // It was the missing half — the count and the option counts below were
+        // already right while `pendingDecisions[0].id` read null.
+        decisionId: spec.promptId,
         questionCount: spec.questions.length,
         optionCounts: spec.questions.map((question) => question.choices.length),
     });
@@ -299,6 +342,15 @@ async function ingestOpencodeEvent(target, event) {
             // Issue #1898: the verdict leaves BEFORE the record is written. See the
             // docblock above for what recording first cost.
             record.decisionId = (0, event_mapper_1.readStringField)((0, event_mapper_1.isPlainObject)(event.raw.properties) ? event.raw.properties : {}, 'id');
+            // Issue #2031: what the dialog is FOR, carried on the record because the
+            // frame itself cannot answer it. The tool name lives in the
+            // `message.part.updated` correlation this module's `payloads` holds, and
+            // `patterns` is the rule an `Allow always` would save — the one verdict
+            // whose effect outlives the dialog, and therefore the one the browser
+            // must be able to show the size of before it is pressed.
+            const subject = (0, payloads_1.readOpencodePermissionSubject)(event.raw, event.receivedAt);
+            record.toolName = subject?.toolName ?? null;
+            record.decisionPatterns = subject?.patterns ?? null;
             record.promptSettled = await adjudicatePermission(target, event, instanceId);
             (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId, record, options);
             return;
@@ -321,12 +373,29 @@ async function ingestOpencodeEvent(target, event) {
         (0, agent_event_state_1.recordAgentEvent)(target.worktreeId, tool_id_1.OPENCODE_CLI_TOOL_ID, instanceId, record, options);
         if (event.event === 'notification' && event.detail === mappers_1.OPENCODE_QUESTION_DETAIL) {
             recordQuestion(target, event, instanceId);
+            // Issue #2045: after the record, so the notification cannot describe a
+            // wait the rest of the process has not been told about yet — and after it
+            // for a second, load-bearing reason: `recordQuestion` is what makes the
+            // wait visible to `peekPromptWaiting`, whose `structured.at` is the very
+            // `receivedAt` passed below. The two producers name the wait identically
+            // only if both read the same record. See `./push`.
+            await (0, push_1.notifyOpencodeQuestionPush)(target, instanceId, record.message ?? null, event.receivedAt);
             return;
         }
         if (event.event === 'stop') {
             await applyStop(target, instanceId);
             return;
         }
+        if (event.event === 'notification' && event.detail === mappers_1.OPENCODE_ERROR_DETAIL) {
+            // Issue #2045. Deliberately not a generic `notification` / `error` hook:
+            // this is the opencode ingest, the other five tools reach
+            // `recordAgentEvent` through `POST /api/hooks/agent-event`, and nothing
+            // there imports this module — so their push counts cannot move.
+            await (0, push_1.notifyOpencodeSessionErrorPush)(target, instanceId, (0, event_mapper_1.readNestedString)((0, event_mapper_1.isPlainObject)(event.raw.properties) ? event.raw.properties : {}, [
+                'error',
+                'name',
+            ]), record.message ?? null, event.conversationId, event.receivedAt);
+        }
         logger.info('opencode-event-received', {
             worktreeId: target.worktreeId,
             instanceId,