commandmate 0.31.3 → 0.32.1

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)
@@ -274,15 +303,26 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
     // that placeholder is drawn with the same `❯ <text>` shape as a transcript
     // echo, so without the boundary `findRecentUserPromptIndex` anchors the turn
     // on the FOOTER and every reply extracts as empty (#1289's defect, verbatim).
+    //
+    // Issue #2400: codex is the fifth, and the one that had been missing. It pins
+    // the same two rows — `› Ask Codex to do anything` and the `model · cwd`
+    // status bar — and without a boundary the saturated-window anchor (#1670)
+    // walked into them: the newest `›` in the pane was the COMPOSER, so extraction
+    // started on the status bar and every reply on a saturated pane was saved as
+    // that one row. `findCodexChromeStart` reads the composer by its SGR
+    // attributes (#2310) rather than by its placeholder wording, which is what the
+    // previous guard did and why it stopped working at codex 0.15x.
     const chromeStart = cliToolId === 'claude'
         ? (0, cli_patterns_1.findClaudeChromeStart)(lines)
         : cliToolId === 'copilot'
             ? (0, cli_patterns_1.findCopilotChromeStart)(lines)
             : cliToolId === 'command-code'
                 ? (0, cli_patterns_1.findCommandCodeChromeStart)(lines)
-                : openCodeCleanLines
-                    ? (0, cli_patterns_1.findOpenCodeChromeStart)(openCodeCleanLines)
-                    : -1;
+                : cliToolId === 'codex'
+                    ? (0, cli_patterns_1.findCodexChromeStart)(lines)
+                    : openCodeCleanLines
+                        ? (0, cli_patterns_1.findOpenCodeChromeStart)(openCodeCleanLines)
+                        : -1;
     const contentEnd = chromeStart >= 0 ? chromeStart : totalLines;
     const BUFFER_RESET_TOLERANCE = 25;
     const bufferShrank = totalLines > 0 && lastCapturedLine > BUFFER_RESET_TOLERANCE && (totalLines + BUFFER_RESET_TOLERANCE) < lastCapturedLine;
@@ -304,7 +344,22 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
     const findRecentUserPromptIndex = (windowSize = 60) => {
         let userPromptPattern;
         if (cliToolId === 'codex') {
-            userPromptPattern = /^›\s+(?!Implement|Find and fix|Type|Summarize)/;
+            // Issue #2400: codex's three uses of `›` are separated by their SGR
+            // attributes, not by their text (#2310). This branch used to exclude the
+            // composer with a negative lookahead over its placeholder strings
+            // (`Implement`, `Find and fix`, `Type`, `Summarize`) — codex 0.1x wording,
+            // none of which 0.15x draws. `Ask Codex to do anything` passed the guard,
+            // became the newest "echo", and on a saturated pane (#1670) — the only
+            // path where this anchor decides where extraction STARTS — every reply was
+            // saved as the single status-bar row below it.
+            //
+            // Two independent things now keep the composer out, and the reader needs
+            // both because neither covers the other's frames: `contentEnd` cuts the
+            // composer off structurally when `findCodexChromeStart` located it, and
+            // when it did not, `findCodexUserEchoIndex` steps over the bottom-most
+            // `›` row instead. The second is what still answers on an ANSI-stripped
+            // capture, where none of #2310's attributes survive to be read.
+            return (0, cli_patterns_1.findCodexUserEchoIndex)(lines, contentEnd, windowSize, chromeStart >= 0);
         }
         else if (openCodeCleanLines) {
             // Issue #1911: anchor on the newest ECHOED USER PROMPT, not on the
@@ -424,9 +479,20 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
     if (isPromptBasedComplete || isClaudeComplete || isCommandCodeComplete || isOpenCodeDone) {
         const responseLines = [];
         const startIndex = (0, response_extractor_1.resolveExtractionStartIndex)(lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, captureWindowSaturated);
-        let endIndex = totalLines;
         // `contentEnd` bounds the content only; `endIndex` keeps reporting the full
         // buffer so lineCount bookkeeping in session_states is unchanged (#1289).
+        //
+        // Issue #2400: codex is the exception, and it is the pre-existing behaviour
+        // rather than a new rule. Before this Issue the loop below stopped on the
+        // composer's `›` and wrote that row's index into `endIndex`; now the composer
+        // is outside `contentEnd`, so the break can no longer fire on it and
+        // `endIndex` would silently advance ~3 rows further. Those rows matter for
+        // codex specifically: it renders INLINE, and it repaints the composer band in
+        // place — the next turn's transcript is printed over exactly the rows the
+        // composer occupied in this capture. A cursor parked past them would skip
+        // real content on the following poll. So the cursor stops where the content
+        // stops, which is what it did before.
+        let endIndex = cliToolId === 'codex' ? contentEnd : totalLines;
         for (let i = startIndex; i < contentEnd; i++) {
             const line = lines[i];
             const cleanLine = (0, cli_patterns_1.stripAnsi)(line);
@@ -669,6 +735,26 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
 // ============================================================================
 // checkForResponse (exported for response-poller-core.ts)
 // ============================================================================
+/**
+ * Record what the structured writers said about this turn, for the ticks that
+ * will not get to ask (Issue #2399).
+ *
+ * One line either way, but named because the two calls are a pair and the
+ * failure mode of writing only one of them is silent: mark without settle and
+ * the reader is re-asked forever after a turn it already recorded; settle
+ * without mark and the fix does not exist.
+ *
+ * @param pollerKey - Poller key ("worktreeId:instanceId")
+ * @param recorded - Whether a structured writer owns this turn
+ */
+function markOrSettleStructuredHistoryRecheck(pollerKey, recorded) {
+    if (recorded) {
+        (0, response_dedup_1.settleStructuredHistoryRecheck)(pollerKey);
+    }
+    else {
+        (0, response_dedup_1.markStructuredHistoryRecheckPending)(pollerKey);
+    }
+}
 /**
  * Check for CLI tool response once
  *
@@ -965,6 +1051,66 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
                 // are found by one grep.
                 logger.info('duplicate-response-skipped', { worktreeId, cliToolId, instanceId: resolvedInstanceId });
                 (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount, resolvedInstanceId);
+                // Issue #2399: the skip above is about the SCREEN, and until this Issue
+                // it also ended the tick for the TRANSCRIPT READER 100 lines below —
+                // which is the one consumer for whom "the frame has not changed" is not
+                // evidence of anything. A pull-mode agent closes its turn in its own
+                // file AFTER the pane has gone quiet, so the reader's single ask (on the
+                // poll that saved the scrape) is systematically too early, and every
+                // later poll returned here. Measured on codex 2026-09-07: one
+                // `codex-transcript-turn-open`, `task_complete` appended 1.8 s later,
+                // and then `duplicate-response-skipped` every 2 s until
+                // `MAX_POLLING_DURATION` ran out. The Markdown row was never written and
+                // the only thing left in History was the scrape — for a saturated pane,
+                // a single footer line.
+                //
+                // So the reader is re-asked from inside the skip, throttled by
+                // `claimStructuredHistoryRecheck` (once on the first duplicate tick,
+                // then every third — see `./response-dedup`). Deliberately the reader
+                // and nothing else: the scrape stays suppressed, the cursor has already
+                // been advanced above, and none of the bookkeeping the guard skips has a
+                // second producer to be asked about.
+                //
+                // Order over the alternative in the Issue (hoist the reader above the
+                // guard): the reader is a WRITE, and hoisting it would run that write on
+                // every one of the 900 ticks of a 30-minute cycle instead of on the ones
+                // that are owed an answer — the same argument the #2317 Phase D comment
+                // below makes for not letting the delegation test short-circuit it.
+                //
+                // What this does NOT do is retract the scraped row the earlier tick
+                // saved. Three reasons, and the first is decisive: nothing here can
+                // identify that row. The hash this guard matched is per pollerKey, not
+                // per turn — it survives the `resume` of a chain paused on a prompt —
+                // so the row it stands for may belong to an earlier turn entirely, and
+                // a scraped row carries no turn key to join on. Second, `archived` in
+                // this schema is the tombstone of an operator clearing History (#168),
+                // written by `archiveMessages` for a whole worktree; reusing it for
+                // "superseded" would make a clear and a handover indistinguishable in
+                // the table. Third, the scrape is not always junk — when a turn is
+                // interrupted the pane holds text the transcript's closed turn does not
+                // — and a duplicated row is visible and recoverable where a deleted one
+                // is neither. Two rows for one turn is the failure this trades for, and
+                // #2401 has already stopped the junk one being picked as a relay's
+                // answer.
+                if ((0, response_dedup_1.claimStructuredHistoryRecheck)(pollerKey)) {
+                    const recaptured = await (0, structured_history_gate_1.captureStructuredHistoryTurn)(worktreeId, cliToolId, instanceId, {
+                        worktreePath: worktree.path,
+                        transcriptPathHint: claudeMetadata?.logFilePath ?? null,
+                    });
+                    if (recaptured) {
+                        (0, response_dedup_1.settleStructuredHistoryRecheck)(pollerKey);
+                        logger.info('structured-history-recheck-captured', {
+                            worktreeId,
+                            cliToolId,
+                            instanceId: resolvedInstanceId,
+                        });
+                        // The turn IS now in History, as the agent's own Markdown, so this
+                        // tick recorded something and says so. Inert for the poller either
+                        // way: `runPollTick` only reads this value after a stop the tick
+                        // raised itself, and this branch raises none.
+                        return true;
+                    }
+                }
                 return false;
             }
         }
@@ -991,6 +1137,13 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
                 worktreePath: worktree.path,
                 transcriptPathHint: claudeMetadata?.logFilePath ?? null,
             }));
+        // Issue #2399: remember which way that went, because the next tick may not
+        // get here. A `false` is the reader saying "not yet, or not mine", and the
+        // dedup guard above turns every following poll of the same static frame into
+        // a return — so unless the fact is written down now, the ask never happens
+        // again. A `true` settles it: the turn is recorded and there is nothing left
+        // to re-ask about.
+        markOrSettleStructuredHistoryRecheck((0, response_poller_core_1.getPollerKey)(worktreeId, cliToolId, instanceId), structuredHistoryLive);
         // Issue #2317 Phase D: the scrape is dropped while the geometry is
         // delegated, and the transcript capture above is what makes that safe.
         //
@@ -1046,6 +1199,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/response-dedup.js

@@ -17,14 +17,69 @@
  * during THIS turn?" and deliberately does NOT persist across turns: an
  * identical response in a later turn is a real response and must be saved.
  * Suppressing it would reproduce the very bug this module fixes.
+ *
+ * ## The second cache: what the dedup skip owes the transcript reader (#2399)
+ *
+ * The guard above answers a question about the SCREEN, and `response-checker`
+ * used to read its answer as a question about the TURN — a duplicate frame ended
+ * the tick before `captureStructuredHistoryTurn` was reached, so for a pull-mode
+ * tool (claude, codex, antigravity, command-code) the transcript reader was
+ * asked exactly once per turn: on the poll that saved the scrape. For a reader
+ * the premise is backwards. "The screen stopped changing" is precisely the
+ * moment BEFORE the agent's own file closes the turn, so the one ask lands too
+ * early, answers false, and the 900 ticks that follow — 30 minutes of
+ * `MAX_POLLING_DURATION` at 2 s each — all return at the guard. Measured on
+ * codex 2026-09-07: `codex-transcript-turn-open` once, then
+ * `duplicate-response-skipped` until the poller's budget ran out, with the
+ * rollout's `task_complete` appended 1.8 s after the single ask.
+ *
+ * So the dedup verdict now carries a caveat, and it lives here rather than in
+ * `response-checker` for one reason: its lifetime is the response hash's
+ * lifetime exactly. `stopPolling`, the `resume` that keeps a paused chain's
+ * hash, and the worktree rename all have to treat the two the same, and the
+ * only way to guarantee that without touching `response-poller-core` (which
+ * owns those three calls) is for one function to clear both.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRUCTURED_HISTORY_RECHECK_TICK_INTERVAL = void 0;
 exports.isDuplicateResponse = isDuplicateResponse;
+exports.markStructuredHistoryRecheckPending = markStructuredHistoryRecheckPending;
+exports.settleStructuredHistoryRecheck = settleStructuredHistoryRecheck;
+exports.claimStructuredHistoryRecheck = claimStructuredHistoryRecheck;
 exports.clearResponseHashCache = clearResponseHashCache;
 exports.renameResponseHashCacheKey = renameResponseHashCacheKey;
 const crypto_1 = require("crypto");
 const responseHashCache = globalThis.__responseHashCache ??
     (globalThis.__responseHashCache = new Map());
+/**
+ * In-memory cache: pollerKey -> ticks still to wait before the transcript reader
+ * is asked again (Issue #2399). Absence means nothing is owed.
+ *
+ * On `globalThis` for the same reason `responseHashCache` is, and populated and
+ * cleared at exactly the same moments — see the module comment.
+ */
+const structuredHistoryRecheckCache = globalThis.__structuredHistoryRecheckCache ??
+    (globalThis.__structuredHistoryRecheckCache = new Map());
+/**
+ * How many duplicate ticks separate two asks of the transcript reader (#2399).
+ *
+ * The reader's work is a tail read of the agent's transcript — 4 MiB for codex
+ * — parsed and rendered, so asking on all 900 ticks of a 30-minute cycle is not
+ * free even though the poller has nothing else to do with them. Three is chosen
+ * against the two numbers that bracket it:
+ *
+ *  - the FIRST duplicate tick always asks (the countdown starts at zero), so in
+ *    the ordinary case — the turn closed between the scrape and the next poll —
+ *    the Markdown row lands ~2 s later and the throttle never applies at all;
+ *  - a turn that closes late is then re-asked every ~6 s, which is inside the
+ *    window where a missing reply is still an operator's "it hasn't shown up
+ *    yet" rather than a lost turn.
+ *
+ * The cost this bounds is only ever paid while a turn is BOTH finished on screen
+ * and still open in the transcript; the moment either the reader writes the row
+ * or the cycle ends, the entry is gone.
+ */
+exports.STRUCTURED_HISTORY_RECHECK_TICK_INTERVAL = 3;
 /**
  * Check whether the given response content was already saved during the current
  * polling cycle for the same pollerKey. If it is new, updates the cache.
@@ -41,15 +96,88 @@ function isDuplicateResponse(pollerKey, content) {
     responseHashCache.set(pollerKey, hash);
     return false;
 }
+/**
+ * Note that the transcript reader has unfinished business for this pollerKey
+ * (Issue #2399).
+ *
+ * Called by `response-checker` on every poll that gets PAST the guard above and
+ * finds neither structured writer willing to own the turn — i.e. the push
+ * subscription is not live and the pull reader answered false. That false is the
+ * one the poller used to treat as final, and this records that it was not.
+ *
+ * Idempotent, and deliberately does not restart the countdown: a turn that has
+ * been waiting five ticks for its transcript to close must not be pushed back to
+ * the end of the queue by a sixth poll that learned nothing new.
+ *
+ * The tool is not consulted. `captureStructuredHistoryTurn` answers "does this
+ * tool keep a transcript at all?" in a map lookup and returns false for gemini,
+ * copilot and opencode without touching a file, so an entry for one of them
+ * costs a lookup every third tick and duplicating the gate's own dispatch here
+ * would cost a second place for it to go stale.
+ *
+ * @param pollerKey - Poller key ("worktreeId:instanceId")
+ */
+function markStructuredHistoryRecheckPending(pollerKey) {
+    if (!structuredHistoryRecheckCache.has(pollerKey)) {
+        structuredHistoryRecheckCache.set(pollerKey, 0);
+    }
+}
+/**
+ * Forget the outstanding recheck for this pollerKey (Issue #2399).
+ *
+ * Called when the question has an answer: the reader wrote the row, or a push
+ * subscription turned out to own the turn after all. Nothing is owed and the
+ * next duplicate tick returns at the guard exactly as it did before this Issue.
+ *
+ * @param pollerKey - Poller key ("worktreeId:instanceId")
+ */
+function settleStructuredHistoryRecheck(pollerKey) {
+    structuredHistoryRecheckCache.delete(pollerKey);
+}
+/**
+ * Take this tick's turn at asking the transcript reader again (Issue #2399).
+ *
+ * A claim rather than a query, because the throttle has to be spent exactly once
+ * per tick and the caller is the only thing that knows a tick happened: this
+ * both answers "ask now?" and advances the countdown, so two calls in one tick
+ * would ask twice as often rather than twice.
+ *
+ * False when nothing is owed for this key ({@link markStructuredHistoryRecheckPending}
+ * was never called, or {@link settleStructuredHistoryRecheck} has since run) and
+ * false on the ticks the throttle swallows. True on the first duplicate tick
+ * after a pending mark, and every
+ * {@link STRUCTURED_HISTORY_RECHECK_TICK_INTERVAL} ticks after that.
+ *
+ * @param pollerKey - Poller key ("worktreeId:instanceId")
+ * @returns true when the caller should ask the reader on this tick
+ */
+function claimStructuredHistoryRecheck(pollerKey) {
+    const ticksToWait = structuredHistoryRecheckCache.get(pollerKey);
+    if (ticksToWait === undefined)
+        return false;
+    if (ticksToWait > 0) {
+        structuredHistoryRecheckCache.set(pollerKey, ticksToWait - 1);
+        return false;
+    }
+    structuredHistoryRecheckCache.set(pollerKey, exports.STRUCTURED_HISTORY_RECHECK_TICK_INTERVAL - 1);
+    return true;
+}
 /**
  * Clear the response hash cache for a specific pollerKey.
  * Called during session cleanup / stopPolling, so each new user turn starts
  * with a clean slate.
  *
+ * Issue #2399: the outstanding recheck goes with it. The caveat is a note about
+ * one particular cached hash — "the screen behind it was static before the
+ * transcript closed" — so it can outlive neither the hash nor the cycle, and
+ * carrying it into a new turn would spend reads asking about a turn that is
+ * over.
+ *
  * @param pollerKey - Poller key ("worktreeId:instanceId")
  */
 function clearResponseHashCache(pollerKey) {
     responseHashCache.delete(pollerKey);
+    structuredHistoryRecheckCache.delete(pollerKey);
 }
 /**
  * Move the cached hash from one pollerKey to another.
@@ -71,4 +199,12 @@ function renameResponseHashCacheKey(oldKey, newKey) {
     responseHashCache.delete(oldKey);
     if (hash !== undefined)
         responseHashCache.set(newKey, hash);
+    // Issue #2399: the recheck caveat moves with the hash it is about. Leaving it
+    // behind would strand a turn whose transcript is still open — the new key
+    // starts owing nothing, so every later tick returns at the dedup guard and the
+    // Markdown row is never written.
+    const ticksToWait = structuredHistoryRecheckCache.get(oldKey);
+    structuredHistoryRecheckCache.delete(oldKey);
+    if (ticksToWait !== undefined)
+        structuredHistoryRecheckCache.set(newKey, ticksToWait);
 }

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() {