commandmate 0.31.3 → 0.32.0

package/dist/server/src/lib/history/user-turn-recorder.js

@@ -27,6 +27,17 @@
  * 1. **The key is already on a row** — nothing happens. The callers are pollers,
  *    so being asked to record the same prompt again is the normal case rather
  *    than an error.
+ * 1b. **A RELAY delivery's row already holds this text** (Issue #2392) — the
+ *    same answer, reached without the key. A relay hands session A the reply
+ *    session B wrote by sending it into A's composer, and the row it writes
+ *    carries `relay:<ledgerId>` so that the ledger can be read back out of it
+ *    (#2387). Being keyed is exactly what put it beyond outcome 2's claim, so
+ *    until this Issue every delivery left the operator reading the reply twice.
+ *    The row is recognised here but deliberately **not** claimed: nothing is
+ *    written, its key stays `relay:<ledgerId>`, and the caller is told
+ *    `already-recorded` with that row's id — because re-pointing it at a
+ *    transcript key would take the loop guard's only route back to the ledger
+ *    away with it.
  * 2. **An unkeyed row already holds this text** — that row is *claimed*, not
  *    duplicated. This is the `/send` case, and it is the whole reason the
  *    recorder is not simply an insert: `sendUserMessage` wrote the operator's
@@ -203,37 +214,46 @@ async function recordUserTurn(target, key, content, timestampMs, options = {}) {
     }
 }
 /**
- * Claim the `/send` row for this prompt, if there is one.
+ * Recognise the row this prompt is already on, if there is one.
  *
- * The candidates come back newest first and are compared on normalised content;
- * the one nearest the agent's clock wins, which only matters when the operator
- * sent the same text twice inside the window and is the right tie-break then
- * too.
+ * One window, two kinds of row in it, and what may be done with them differs:
  *
- * The claim itself can lose — `setMessageRequestId` refuses a row that acquired
- * a key between the read and the write. Losing means some other producer got
- * there first, so the next candidate is tried and, if none is left, the caller
- * falls through to the insert. It cannot loop: each attempt either claims a row
- * or removes it from contention.
+ * 1. the `/send` row, which carries no key and is **claimed** — this is #2196's
+ *    case and the reason the recorder is not simply an insert;
+ * 2. a relay delivery's row, which carries `relay:<ledgerId>` and is **left
+ *    exactly as it is** — Issue #2392. `includeRelayDelivered` is what puts it
+ *    in the answer at all, and `requestId` is what tells the two apart.
  *
- * @returns The claimed row, or null when nothing here belongs to this prompt
+ * The claim is tried across every unkeyed candidate first, so the presence of a
+ * delivery cannot cost an orphan row its key. It can lose —
+ * `setMessageRequestId` refuses a row that acquired a key between the read and
+ * the write. Losing means some other producer got there first, so the next
+ * candidate is tried and, if none is left, the delivery is considered and then
+ * the caller falls through to the insert. It cannot loop: each attempt either
+ * claims a row or removes it from contention.
+ *
+ * @returns The row this prompt is on, or null when nothing here is this prompt's
  */
 function adoptExistingRow(chatDb, db, target, instanceId, key, normalized, at, options) {
     // `Math.min` and not a replacement: {@link RecordUserTurnOptions} may widen
     // the search backwards and may never narrow it, so a caller that supplies a
     // bound *inside* the standard window changes nothing.
     const fromMs = Math.min(at - exports.USER_TURN_ADOPTION_WINDOW_MS, options.adoptionFromMs ?? Number.POSITIVE_INFINITY);
-    const candidates = chatDb
-        .findUnkeyedUserMessages(db, {
+    const candidates = sameText(chatDb.findUnkeyedUserMessages(db, {
         worktreeId: target.worktreeId,
         cliToolId: target.cliToolId,
         instanceId,
         fromMs,
         toMs: at + exports.USER_TURN_ADOPTION_WINDOW_MS,
-    })
-        .filter((row) => normalizeUserTurnContent(row.content) === normalized)
-        .sort((a, b) => Math.abs(a.timestamp.getTime() - at) - Math.abs(b.timestamp.getTime() - at));
+        // Issue #2392. Without this the relay delivery's row is not in the answer
+        // at all, and the prompt it holds is inserted a second time.
+        includeRelayDelivered: true,
+    }), normalized, at);
     for (const candidate of candidates) {
+        // A relay delivery, kept for the pass below: claiming it would overwrite the
+        // `relay:<ledgerId>` the loop guard reads the ledger back out of.
+        if (candidate.requestId)
+            continue;
         if (!chatDb.setMessageRequestId(db, candidate.id, key))
             continue;
         logger.info('user-turn-adopted', {
@@ -248,5 +268,48 @@ function adoptExistingRow(chatDb, db, target, instanceId, key, normalized, at, o
             timestampMs: candidate.timestamp.getTime(),
         };
     }
+    // Issue #2392. Nothing is written here and that is the whole point: the row
+    // already says what this prompt says, and its `request_id` is the loop guard's
+    // only way back to the ledger entry that produced it (`findParentRelayHops`,
+    // #2387). So the prompt is reported as recorded on the row that holds it, and
+    // the insert below is not reached. `setMessageRequestId` would refuse the
+    // write anyway — it is a compare-and-set on `request_id IS NULL` — but the
+    // branch above says so explicitly rather than leaning on that.
+    //
+    // No direction test on the timestamp, unlike #2387's `isEchoOfRelayRow`: that
+    // one is deciding whether a row it can already see is an echo, while this is
+    // deciding whether to write a row at all, and a transcript whose clock rounds
+    // a prompt to a whole second would land just *before* the delivery and bring
+    // the duplicate straight back. The symmetric window is safe here because the
+    // text being matched is a relay body — `buildRelayReplyMessage`'s framing, not
+    // anything an operator types.
+    const delivered = candidates.find((candidate) => candidate.requestId);
+    if (delivered) {
+        logger.info('user-turn-already-relayed', {
+            ...describe(target),
+            requestId: key,
+            messageId: delivered.id,
+            relayRequestId: delivered.requestId ?? null,
+            driftMs: delivered.timestamp.getTime() - at,
+        });
+        return {
+            outcome: 'already-recorded',
+            messageId: delivered.id,
+            timestampMs: delivered.timestamp.getTime(),
+        };
+    }
     return null;
 }
+/**
+ * The rows here that hold this prompt's text, nearest the agent's clock first.
+ *
+ * Content is compared normalised, because that is the only comparison
+ * `chat_messages` cannot make for itself (see `findUnkeyedUserMessages`). The
+ * ordering only matters when the same text sits on two rows inside the window,
+ * and nearest-in-time is the right tie-break then too.
+ */
+function sameText(rows, normalized, at) {
+    return rows
+        .filter((row) => normalizeUserTurnContent(row.content) === normalized)
+        .sort((a, b) => Math.abs(a.timestamp.getTime() - at) - Math.abs(b.timestamp.getTime() - at));
+}

package/dist/server/src/lib/polling/response-checker.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.incompleteResult = incompleteResult;
 exports.buildPromptExtractionResult = buildPromptExtractionResult;
+exports.detectPromptOnCleanFrame = detectPromptOnCleanFrame;
 exports.detectPromptWithOptions = detectPromptWithOptions;
 exports.extractResponse = extractResponse;
 exports.checkForResponse = checkForResponse;
@@ -29,6 +30,7 @@ const prompt_dedup_1 = require("./prompt-dedup");
 const prompt_dedup_state_1 = require("./prompt-dedup-state");
 const response_dedup_1 = require("./response-dedup");
 const structured_history_gate_1 = require("./structured-history-gate");
+const relay_triggers_1 = require("../../lib/relay/relay-triggers");
 // Issue #2317 Phase D: while a human holds the pane's geometry, the frame is
 // their terminal (44 rows), not the 1000-row canvas every rule below was
 // measured against. See the block in `checkForResponse` for what that changes.
@@ -181,17 +183,25 @@ function buildPromptExtractionResult(lines, lastCapturedLine, totalLines, buffer
     };
 }
 /**
- * Internal helper: detect prompt with CLI-tool-specific options.
+ * The one reading of a frame that every consumer of it shares, for a capture
+ * that has ALREADY been through `stripBoxDrawing(stripAnsi(…))`.
  *
- * Centralizes the stripAnsi() + buildDetectPromptOptions() + detectPrompt() pipeline
- * to avoid repeating this 3-step sequence across extractResponse() and checkForResponse().
+ * Split out of {@link detectPromptWithOptions} by Issue #2368 so the Auto-Yes
+ * poller can reach it. That poller cleans its own capture once per tick
+ * (`captureAndCleanOutput`) and reuses the cleaned string and its line split for
+ * the stop-condition delta, the dialog gate and the thinking check, so handing
+ * it back through `detectPromptWithOptions` would clean it a SECOND time — and
+ * `stripBoxDrawing` is not idempotent (it removes one leading `│` per pass, so a
+ * doubly-bordered row loses a second character on the second pass). Taking the
+ * already-clean frame here is what keeps the two callers reading identical text.
  *
- * @param output - Raw or pre-stripped tmux output
+ * @param cleanOutput - tmux output with ANSI **and** box drawing already removed
  * @param cliToolId - CLI tool identifier for building detection options
+ * @param precomputedLines - `cleanOutput.split('\n')` when the caller already has it
+ *   (Issue #499 Item 4); must be the split of THIS string, not of the raw capture
  * @returns PromptDetectionResult with isPrompt, promptData, and cleanContent
  */
-function detectPromptWithOptions(output, cliToolId) {
-    const clean = (0, cli_patterns_1.stripBoxDrawing)((0, cli_patterns_1.stripAnsi)(output));
+function detectPromptOnCleanFrame(cleanOutput, cliToolId, precomputedLines) {
     // Issue #2364: agy's `↑/↓ Navigate` dialogs are read by agy's own reader
     // before the generic pass, on the same spelling `tools/antigravity/detect.ts`
     // reads them on. The generic multiple-choice parser takes one row per option
@@ -201,13 +211,32 @@ function detectPromptWithOptions(output, cliToolId) {
     // preview joined into it. One reader for both producers is what makes the
     // stored `prompt` row, the push notification's excerpt and `/current-output`
     // agree about one screen.
+    //
+    // Issue #2368: and the Auto-Yes poller, which was the one consumer #2364 left
+    // on the generic pass. agy's Bash approvals wrap their option labels with no
+    // indentation, `isContinuationLine` refuses those rows, and the frame came
+    // back `isPrompt: false` — so Auto-Yes sent nothing at all while the status
+    // API published the very same screen as an answerable four-option prompt.
     if (cliToolId === 'antigravity') {
-        const dialog = (0, dialog_1.detectAntigravityNumberedDialogPrompt)(clean);
+        const dialog = (0, dialog_1.detectAntigravityNumberedDialogPrompt)(cleanOutput);
         if (dialog !== null)
             return dialog;
     }
     const promptOptions = (0, cli_patterns_1.buildDetectPromptOptions)(cliToolId);
-    return (0, prompt_detector_1.detectPrompt)(clean, promptOptions);
+    return (0, prompt_detector_1.detectPrompt)(cleanOutput, precomputedLines ? { ...promptOptions, precomputedLines } : promptOptions);
+}
+/**
+ * Internal helper: detect prompt with CLI-tool-specific options.
+ *
+ * Centralizes the stripAnsi() + buildDetectPromptOptions() + detectPrompt() pipeline
+ * to avoid repeating this 3-step sequence across extractResponse() and checkForResponse().
+ *
+ * @param output - Raw or pre-stripped tmux output
+ * @param cliToolId - CLI tool identifier for building detection options
+ * @returns PromptDetectionResult with isPrompt, promptData, and cleanContent
+ */
+function detectPromptWithOptions(output, cliToolId) {
+    return detectPromptOnCleanFrame((0, cli_patterns_1.stripBoxDrawing)((0, cli_patterns_1.stripAnsi)(output)), cliToolId);
 }
 // ============================================================================
 // extractResponse (internal)
@@ -1046,6 +1075,14 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             });
             // Broadcast message to WebSocket clients
             (0, ws_server_1.broadcastMessage)('message', { worktreeId, message });
+            // Issue #2377: the scrape path's completion edge. `settled: false` is the
+            // whole difference from the gate's own announcement: this row was read off
+            // a SCREEN whose completion was judged by string analysis, so a relay
+            // waiting on this session re-reads after a few seconds of quiet before it
+            // delivers — the Issue's 「完了検知 + 数秒の静穏」 for the three tools that
+            // keep no transcript. Announced here rather than after the `if` because
+            // the suppressed branch means the gate already announced it, settled.
+            (0, relay_triggers_1.onRelayTurnCompleted)(worktreeId, cliToolId, resolvedInstanceId, false);
         }
         else {
             logger.info('structured-history-scrape-suppressed', {

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

@@ -81,6 +81,7 @@ const tool_id_2 = require("../../lib/hooks/sources/codex/tool-id");
 const tool_id_3 = require("../../lib/hooks/sources/antigravity/tool-id");
 const tool_id_4 = require("../../lib/hooks/sources/command-code/tool-id");
 const registry_1 = require("../../lib/hooks/sources/registry");
+const relay_triggers_1 = require("../../lib/relay/relay-triggers");
 const logger = (0, logger_1.createLogger)('lib/polling/structured-history-gate');
 /**
  * One in-flight capture per instance (Issue #2246).
@@ -286,7 +287,19 @@ async function captureStructuredHistoryTurn(worktreeId, cliToolId, instanceId, c
     const resolvedInstanceId = instanceId ?? cliToolId;
     return serializePerInstance(captureKeyOf(worktreeId, cliToolId, resolvedInstanceId), async () => {
         try {
-            return await reader.capture({ worktreeId, cliToolId, instanceId: resolvedInstanceId }, capture);
+            const captured = await reader.capture({ worktreeId, cliToolId, instanceId: resolvedInstanceId }, capture);
+            // Issue #2377: the moment a relay is waiting for. This is the single
+            // point BOTH triggers of a pull capture pass through — the poller's save
+            // path and the Stop hook receiver — which is why the relay needs one
+            // hook here and not one in each of them. The turn is closed by the
+            // agent's own account, so the delivery needs no quiet window.
+            //
+            // Announced only when the capture actually wrote something: a `false`
+            // means the scraper is still the writer for this turn, and the poller's
+            // own call below will announce it.
+            if (captured)
+                (0, relay_triggers_1.onRelayTurnCompleted)(worktreeId, cliToolId, resolvedInstanceId, true);
+            return captured;
         }
         catch (error) {
             logger.warn('structured-history-capture-unavailable', {

package/dist/server/src/lib/realtime/terminal-broadcast.js

@@ -65,6 +65,10 @@ function snapshotFingerprint(payload) {
         payload.isPromptWaiting ?? false,
         payload.isSelectionListActive ?? false,
         payload.isPagerActive ?? false,
+        // Issue #2369: in the fingerprint for the same reason `sessionStatus` is —
+        // a redraw whose only change is "the /usage panel closed" has to reach the
+        // client, or the Esc card outlives the panel it dismisses.
+        payload.isDismissablePanelActive ?? false,
         payload.isUnclassifiedActive ?? false,
     ]);
 }
@@ -94,6 +98,7 @@ function emitTerminalSnapshot(worktreeId, cliToolId, payload, instanceId) {
         promptData: payload.promptData ?? null,
         isSelectionListActive: payload.isSelectionListActive ?? false,
         isPagerActive: payload.isPagerActive ?? false,
+        isDismissablePanelActive: payload.isDismissablePanelActive ?? false,
         isUnclassifiedActive: payload.isUnclassifiedActive ?? false,
         version: nextVersion(key),
     });

package/dist/server/src/lib/realtime/waiting-broadcast.js

@@ -38,6 +38,7 @@ exports.startWaitingStatusBroadcast = startWaitingStatusBroadcast;
 exports.stopWaitingStatusBroadcast = stopWaitingStatusBroadcast;
 exports.isWaitingStatusBroadcastActive = isWaitingStatusBroadcastActive;
 const model_change_broadcast_1 = require("../../lib/realtime/model-change-broadcast");
+const relay_triggers_1 = require("../../lib/relay/relay-triggers");
 const waiting_episode_state_1 = require("../../lib/session/waiting-episode-state");
 /**
  * Translate a waiting crossing into the frame clients receive.
@@ -83,6 +84,14 @@ function startWaitingStatusBroadcast(publish) {
     });
     globalThis.__waitingStatusBroadcastUnsubscribe = unsubscribe;
     (0, model_change_broadcast_1.startModelChangeBroadcast)(publish);
+    // Issue #2377: and the relay subsystem, for the third time and the same
+    // reason. Its two background jobs — "tell the requester their worker stopped
+    // on a dialog" and "expire deadlines / retry deliveries a busy composer
+    // refused" — are the server's lifetime, not a request's, and this is the one
+    // function `setupWebSocket` calls to say the server is up. Unlike the two
+    // above it needs no publisher: a relay's delivery is a message written through
+    // `sendUserMessage`, which broadcasts its own row.
+    (0, relay_triggers_1.startRelayTriggers)();
     return unsubscribe;
 }
 /**
@@ -91,6 +100,8 @@ function startWaitingStatusBroadcast(publish) {
  * does not leave a listener pointed at a dead room map.
  *
  * Issue #2357: drops the model edge's subscription with it, for the same reason.
+ * Issue #2377: and the relay triggers, whose interval would otherwise keep
+ * ticking against a database the suite has closed.
  */
 function stopWaitingStatusBroadcast() {
     const existing = globalThis.__waitingStatusBroadcastUnsubscribe;
@@ -99,6 +110,7 @@ function stopWaitingStatusBroadcast() {
         globalThis.__waitingStatusBroadcastUnsubscribe = undefined;
     }
     (0, model_change_broadcast_1.stopModelChangeBroadcast)();
+    (0, relay_triggers_1.stopRelayTriggers)();
 }
 /** Whether a subscription is currently active. Test seam. */
 function isWaitingStatusBroadcastActive() {