commandmate 0.31.3 → 0.32.0

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

@@ -0,0 +1,343 @@
+"use strict";
+/**
+ * The relay ledger's CRUD (Issue #2377, table from migration v60).
+ *
+ * Every state change a relay can undergo is a statement in this file, and each
+ * one that must happen at most once is written as a GUARDED update that reports
+ * whether it won. That is not a style choice: the turn's end is judged by two
+ * independent producers (the Stop hook and the poller) and the delivery pump can
+ * be re-entered by a timer while a first pass is still awaiting a send, so
+ * "read, decide, write" would deliver some replies twice. `better-sqlite3` is
+ * synchronous, so a single `UPDATE … WHERE <precondition>` plus `changes === 1`
+ * is a compare-and-set with no window in it.
+ *
+ * Shapes come from `@/lib/relay/types`, which knows nothing about SQL — the
+ * browser hook reads the same interfaces.
+ *
+ * @module lib/db/relay-db
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRelay = createRelay;
+exports.getRelayById = getRelayById;
+exports.listOpenRelaysTo = listOpenRelaysTo;
+exports.listOpenRelaysFrom = listOpenRelaysFrom;
+exports.getSessionRelaySummary = getSessionRelaySummary;
+exports.listOpenRelaysForWorktree = listOpenRelaysForWorktree;
+exports.countOpenRelaysBetween = countOpenRelaysBetween;
+exports.stashRelayPayload = stashRelayPayload;
+exports.listRelaysWithPendingPayload = listRelaysWithPendingPayload;
+exports.clearRelayPending = clearRelayPending;
+exports.markRelayDelivered = markRelayDelivered;
+exports.markRelayPromptNotified = markRelayPromptNotified;
+exports.getRelayPromptSignature = getRelayPromptSignature;
+exports.markRelayExpired = markRelayExpired;
+exports.listExpiredOpenRelays = listExpiredOpenRelays;
+exports.cancelRelay = cancelRelay;
+exports.countRelays = countRelays;
+const crypto_1 = require("crypto");
+const types_1 = require("../../lib/relay/types");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('relay-db');
+/** Every column, in one place, so the readers cannot drift from each other. */
+const RELAY_COLUMNS = `
+  id, from_worktree_id, from_instance_id, to_worktree_id, to_instance_id,
+  state, hops, sent_request_id, pending_kind, pending_body, prompt_signature,
+  created_at, updated_at, expires_at, delivered_at
+`;
+function mapRelay(row) {
+    return {
+        id: row.id,
+        from: { worktreeId: row.from_worktree_id, instanceId: row.from_instance_id },
+        to: { worktreeId: row.to_worktree_id, instanceId: row.to_instance_id },
+        state: row.state,
+        hops: row.hops,
+        sentRequestId: row.sent_request_id,
+        pendingKind: row.pending_kind ?? null,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        expiresAt: row.expires_at,
+        deliveredAt: row.delivered_at,
+    };
+}
+/** Insert a new `pending` relay and hand it back. */
+function createRelay(db, input) {
+    const id = (0, crypto_1.randomUUID)();
+    const now = input.now ?? Date.now();
+    db.prepare(`
+    INSERT INTO session_relays
+      (id, from_worktree_id, from_instance_id, to_worktree_id, to_instance_id,
+       state, hops, sent_request_id, pending_kind, pending_body, prompt_signature,
+       created_at, updated_at, expires_at, delivered_at)
+    VALUES (?, ?, ?, ?, ?, 'pending', ?, NULL, NULL, NULL, NULL, ?, ?, ?, NULL)
+  `).run(id, input.from.worktreeId, input.from.instanceId, input.to.worktreeId, input.to.instanceId, input.hops, now, now, input.expiresAt);
+    return {
+        id,
+        from: { ...input.from },
+        to: { ...input.to },
+        state: 'pending',
+        hops: input.hops,
+        sentRequestId: null,
+        pendingKind: null,
+        createdAt: now,
+        updatedAt: now,
+        expiresAt: input.expiresAt,
+        deliveredAt: null,
+    };
+}
+/** One relay by id, or null. */
+function getRelayById(db, id) {
+    const row = db
+        .prepare(`SELECT ${RELAY_COLUMNS} FROM session_relays WHERE id = ?`)
+        .get(id);
+    return row ? mapRelay(row) : null;
+}
+/** Placeholders for an `IN (…)` over the open states. */
+const OPEN_STATE_PLACEHOLDERS = types_1.OPEN_RELAY_STATES.map(() => '?').join(', ');
+/** Every still-open relay this session must answer (it is the `to` end). */
+function listOpenRelaysTo(db, endpoint) {
+    const rows = db
+        .prepare(`
+      SELECT ${RELAY_COLUMNS} FROM session_relays
+      WHERE to_worktree_id = ? AND to_instance_id = ?
+        AND state IN (${OPEN_STATE_PLACEHOLDERS})
+      ORDER BY created_at ASC
+    `)
+        .all(endpoint.worktreeId, endpoint.instanceId, ...types_1.OPEN_RELAY_STATES);
+    return rows.map(mapRelay);
+}
+/** Every still-open relay this session is waiting on (it is the `from` end). */
+function listOpenRelaysFrom(db, endpoint) {
+    const rows = db
+        .prepare(`
+      SELECT ${RELAY_COLUMNS} FROM session_relays
+      WHERE from_worktree_id = ? AND from_instance_id = ?
+        AND state IN (${OPEN_STATE_PLACEHOLDERS})
+      ORDER BY created_at ASC
+    `)
+        .all(endpoint.worktreeId, endpoint.instanceId, ...types_1.OPEN_RELAY_STATES);
+    return rows.map(mapRelay);
+}
+/** Both halves of {@link SessionRelaySummary} in one call. */
+function getSessionRelaySummary(db, endpoint) {
+    return {
+        owed: listOpenRelaysTo(db, endpoint),
+        awaiting: listOpenRelaysFrom(db, endpoint),
+    };
+}
+/** Every open relay in a worktree, whichever end it belongs to. */
+function listOpenRelaysForWorktree(db, worktreeId) {
+    const rows = db
+        .prepare(`
+      SELECT ${RELAY_COLUMNS} FROM session_relays
+      WHERE (from_worktree_id = ? OR to_worktree_id = ?)
+        AND state IN (${OPEN_STATE_PLACEHOLDERS})
+      ORDER BY created_at ASC
+    `)
+        .all(worktreeId, worktreeId, ...types_1.OPEN_RELAY_STATES);
+    return rows.map(mapRelay);
+}
+/**
+ * How many open relays already run from `from` to `to`.
+ *
+ * The Issue's "a from→to pair must not sit at two pending relays at once": a
+ * second standing instruction to the same session says nothing the first one
+ * does not, and both would fire on the same finished turn.
+ */
+function countOpenRelaysBetween(db, from, to) {
+    const row = db
+        .prepare(`
+      SELECT COUNT(*) AS n FROM session_relays
+      WHERE from_worktree_id = ? AND from_instance_id = ?
+        AND to_worktree_id = ? AND to_instance_id = ?
+        AND state IN (${OPEN_STATE_PLACEHOLDERS})
+    `)
+        .get(from.worktreeId, from.instanceId, to.worktreeId, to.instanceId, ...types_1.OPEN_RELAY_STATES);
+    return row.n;
+}
+/**
+ * Record a payload that has been decided and not yet delivered.
+ *
+ * Guarded on `pending_kind IS NULL`, which is what makes two producers finding
+ * the same finished turn cost ONE delivery: the second one loses the race and
+ * returns false rather than queueing a duplicate. The guard is released by
+ * {@link clearRelayPending} once the payload has actually gone out, so the same
+ * relay can carry a prompt notice now and a reply later.
+ *
+ * @returns Whether this call is the one that stashed it
+ */
+function stashRelayPayload(db, id, kind, body, now = Date.now()) {
+    const result = db
+        .prepare(`
+      UPDATE session_relays
+      SET pending_kind = ?, pending_body = ?, updated_at = ?
+      WHERE id = ? AND pending_kind IS NULL
+        AND state IN (${OPEN_STATE_PLACEHOLDERS})
+    `)
+        .run(kind, body, now, id, ...types_1.OPEN_RELAY_STATES);
+    return result.changes === 1;
+}
+/** Every relay carrying an undelivered payload, oldest first. */
+function listRelaysWithPendingPayload(db) {
+    const rows = db
+        .prepare(`
+      SELECT ${RELAY_COLUMNS} FROM session_relays
+      WHERE pending_kind IS NOT NULL
+      ORDER BY updated_at ASC
+    `)
+        .all();
+    return rows
+        .filter((row) => row.pending_body !== null && row.pending_kind !== null)
+        .map((row) => ({
+        relay: mapRelay(row),
+        kind: row.pending_kind,
+        body: row.pending_body,
+    }));
+}
+/** Drop an undelivered payload (it went out, or it was superseded). */
+function clearRelayPending(db, id, now = Date.now()) {
+    db.prepare(`
+    UPDATE session_relays
+    SET pending_kind = NULL, pending_body = NULL, updated_at = ?
+    WHERE id = ?
+  `).run(now, id);
+}
+/**
+ * Close the relay as delivered, exactly once.
+ *
+ * Two clauses, and they guard different things — worth separating, because a
+ * later reader who notices that the second is redundant *for one relay id* will
+ * otherwise delete the one that is not.
+ *
+ *  - `state IN (open)` is what makes a SECOND call for the same relay answer
+ *    false: the first call left it `delivered`, which is not an open state.
+ *  - `sent_request_id IS NULL`, together with the column's UNIQUE index, is what
+ *    makes the delivery id itself unrepeatable ACROSS relays and across
+ *    processes. It is the idempotency key the Issue names, and it is why this
+ *    function catches: the index refusing a write is the answer "somebody else
+ *    got there first", and that answer must not arrive as an exception inside a
+ *    delivery path.
+ *
+ * @returns Whether this call is the one that closed it
+ */
+function markRelayDelivered(db, id, sentRequestId, now = Date.now()) {
+    try {
+        const result = db
+            .prepare(`
+        UPDATE session_relays
+        SET state = 'delivered', sent_request_id = ?, delivered_at = ?,
+            pending_kind = NULL, pending_body = NULL, updated_at = ?
+        WHERE id = ? AND sent_request_id IS NULL
+          AND state IN (${OPEN_STATE_PLACEHOLDERS})
+      `)
+            .run(sentRequestId, now, now, id, ...types_1.OPEN_RELAY_STATES);
+        return result.changes === 1;
+    }
+    catch (error) {
+        // The UNIQUE index refusing the write IS the answer "somebody else got
+        // there first", and it must not become an exception in a delivery path.
+        logger.warn('relay-deliver-conflict', {
+            relayId: id,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+}
+/**
+ * Note that A is being told B is waiting on a confirmation.
+ *
+ * Leaves the relay OPEN — `prompt` is an open state, so answering the dialog
+ * lets B finish and the reply is stashed and delivered from here — and leaves
+ * any stashed payload alone: this records the DECISION to notify, while
+ * `clearRelayPending` records that the notice went out. `prompt_signature` is
+ * what stops a twenty-minute wait from producing a notice on every poll.
+ */
+function markRelayPromptNotified(db, id, signature, now = Date.now()) {
+    db.prepare(`
+    UPDATE session_relays
+    SET state = 'prompt', prompt_signature = ?, updated_at = ?
+    WHERE id = ?
+  `).run(signature, now, id);
+}
+/** The confirmation notice already sent for this relay, or null. */
+function getRelayPromptSignature(db, id) {
+    const row = db
+        .prepare('SELECT prompt_signature FROM session_relays WHERE id = ?')
+        .get(id);
+    return row?.prompt_signature ?? null;
+}
+/**
+ * Close the relay as expired, exactly once.
+ *
+ * The once-ness is the point: the Issue asks for ONE line of notice, and the
+ * state transition is what the notice is written from.
+ *
+ * @returns Whether this call is the one that expired it
+ */
+function markRelayExpired(db, id, now = Date.now()) {
+    const result = db
+        .prepare(`
+      UPDATE session_relays
+      SET state = 'expired', updated_at = ?
+      WHERE id = ? AND state IN (${OPEN_STATE_PLACEHOLDERS})
+    `)
+        .run(now, id, ...types_1.OPEN_RELAY_STATES);
+    return result.changes === 1;
+}
+/** Every open relay whose deadline has passed. */
+function listExpiredOpenRelays(db, now = Date.now()) {
+    const rows = db
+        .prepare(`
+      SELECT ${RELAY_COLUMNS} FROM session_relays
+      WHERE state IN (${OPEN_STATE_PLACEHOLDERS}) AND expires_at <= ?
+      ORDER BY expires_at ASC
+    `)
+        .all(...types_1.OPEN_RELAY_STATES, now);
+    return rows.map(mapRelay);
+}
+/** Withdraw a relay. Returns false when it was already closed or absent. */
+function cancelRelay(db, id, now = Date.now()) {
+    const result = db
+        .prepare(`
+      UPDATE session_relays
+      SET state = 'cancelled', pending_kind = NULL, pending_body = NULL, updated_at = ?
+      WHERE id = ? AND state IN (${OPEN_STATE_PLACEHOLDERS})
+    `)
+        .run(now, id, ...types_1.OPEN_RELAY_STATES);
+    return result.changes === 1;
+}
+/**
+ * Count relays per state.
+ *
+ * The shape `commandmate task show` and `report metrics` print. Counting in SQL
+ * rather than reading rows because a long-lived server accumulates thousands
+ * and both callers want five integers.
+ */
+function countRelays(db, filter = {}) {
+    const clauses = [];
+    const params = [];
+    if (filter.worktreeId) {
+        if (filter.instanceId) {
+            clauses.push('((from_worktree_id = ? AND from_instance_id = ?) OR (to_worktree_id = ? AND to_instance_id = ?))');
+            params.push(filter.worktreeId, filter.instanceId, filter.worktreeId, filter.instanceId);
+        }
+        else {
+            clauses.push('(from_worktree_id = ? OR to_worktree_id = ?)');
+            params.push(filter.worktreeId, filter.worktreeId);
+        }
+    }
+    if (filter.since !== undefined) {
+        clauses.push('created_at >= ?');
+        params.push(filter.since);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : '';
+    const rows = db
+        .prepare(`SELECT state, COUNT(*) AS n FROM session_relays ${where} GROUP BY state`)
+        .all(...params);
+    const counts = (0, types_1.emptyRelayCounts)();
+    for (const row of rows) {
+        if (row.state in counts) {
+            counts[row.state] = row.n;
+        }
+    }
+    return counts;
+}

package/dist/server/src/lib/detection/ansi.js

@@ -11,7 +11,9 @@
  * Covers:
  * - SGR sequences: ESC[Nm (colors, bold, underline, etc.)
  * - OSC sequences: ESC]...BEL and ESC]...ST (ESC \\) - window title, and the
- *   OSC 8 hyperlinks that claude/codex/copilot emit (Issue #1912)
+ *   OSC 8 hyperlinks that claude/codex/copilot emit (Issue #1912). Also
+ *   available on its own as {@link stripOsc} (Issue #2369), for a consumer that
+ *   renders SGR and must not render OSC.
  * - CSI sequences: ESC[...letter (cursor movement, erase, etc.)
  *
  * Known limitations (SEC-002): 8-bit CSI (0x9B), DEC private modes (ESC[?25h),
@@ -19,14 +21,49 @@
  * practice tmux capture-pane output rarely contains these.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ANSI_PATTERN = void 0;
+exports.ANSI_PATTERN = exports.OSC_PATTERN = void 0;
 exports.stripAnsi = stripAnsi;
+exports.stripOsc = stripOsc;
 exports.extractAnsiSequences = extractAnsiSequences;
-exports.ANSI_PATTERN = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\[[0-9;]*m/g;
+/**
+ * One OSC sequence: `ESC ]`, a payload, and either terminator (BEL or ST).
+ *
+ * Split out of {@link ANSI_PATTERN} by Issue #2369 so a second consumer can
+ * strip OSC **without** stripping SGR. `sanitizeTerminalOutput`
+ * (`lib/security/sanitize.ts`) is that consumer: it hands the frame to
+ * `ansi-to-html`, which turns SGR into colour and does not know OSC at all — so
+ * before this split, Command Code's `/usage` panel rendered its breakdown link
+ * as the literal text `]8;;https://commandcode.ai/…\` beside the label. Calling
+ * `stripAnsi` there would have thrown the colour away with it.
+ *
+ * The payload class excludes ESC as well as BEL (Issue #1912) so a sequence
+ * ended by ST cannot run on to a BEL later in the buffer and swallow the visible
+ * link text between them. An OSC with no terminator at all matches nothing and
+ * is left in place, which is the safe answer: eating the rest of the frame is
+ * worse than showing one stray escape.
+ *
+ * The source is shared with {@link ANSI_PATTERN} rather than restated, so the
+ * two cannot drift about which terminators exist.
+ */
+const OSC_SOURCE = '\\x1b\\][^\\x07\\x1b]*(?:\\x07|\\x1b\\\\)';
+/** {@link OSC_SOURCE} as a reusable global pattern. */
+exports.OSC_PATTERN = new RegExp(OSC_SOURCE, 'g');
+exports.ANSI_PATTERN = new RegExp(`\\x1b\\[[0-9;]*[a-zA-Z]|${OSC_SOURCE}|\\[[0-9;]*m`, 'g');
 /** Remove all ANSI escape sequences from a string. */
 function stripAnsi(str) {
     return str.replace(exports.ANSI_PATTERN, '');
 }
+/**
+ * Remove OSC sequences only, leaving SGR (colour) and CSI untouched.
+ *
+ * For OSC 8 hyperlinks — `ESC ] 8 ; ; <url> ST <label> ESC ] 8 ; ; ST` — this
+ * drops both halves of the pair and keeps `<label>`, which is the text the
+ * terminal itself shows. See {@link OSC_PATTERN} for who needs this and why
+ * `stripAnsi` is not the answer for them.
+ */
+function stripOsc(str) {
+    return str.replace(exports.OSC_PATTERN, '');
+}
 /**
  * Extract the ANSI escape sequences from a string, in order, discarding all
  * other characters. Reuses the same tested pattern as {@link stripAnsi} so the

package/dist/server/src/lib/detection/selection-shape.js

@@ -64,7 +64,8 @@
  * written once.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMMAND_CODE_SELECTION_LIST_FOOTER = exports.SET_AS_DEFAULT_FOOTER_PATTERN = exports.SESSION_SCOPE_FOOTER_PATTERN = exports.MAX_OPTION_NUMBER = exports.SELECTION_SHAPE_TAIL_LINE_COUNT = void 0;
+exports.DISMISSABLE_PANEL_FOOTER_PATTERN = exports.COMMAND_CODE_SELECTION_LIST_FOOTER = exports.SET_AS_DEFAULT_FOOTER_PATTERN = exports.SESSION_SCOPE_FOOTER_PATTERN = exports.MAX_OPTION_NUMBER = exports.SELECTION_SHAPE_TAIL_LINE_COUNT = void 0;
+exports.hasDismissablePanelFooter = hasDismissablePanelFooter;
 exports.extractCommandCodeSelectionListFrame = extractCommandCodeSelectionListFrame;
 exports.readSelectionListShape = readSelectionListShape;
 exports.shouldOfferOptionNumbers = shouldOfferOptionNumbers;
@@ -150,6 +151,76 @@ const FILTER_INPUT_PATTERN = /\btype\s+to\s+search\b|\bsearch\s+\w+\s*(?:…|\.\
  * settled on for the same reason.
  */
 exports.COMMAND_CODE_SELECTION_LIST_FOOTER = /\benter\s+to\s+select\b\s*[·•]\s*esc\s+to\s+cancel\b/i;
+/**
+ * The footer of an overlay whose ONLY exit is the dismiss (Issue #2369).
+ *
+ * Measured on Command Code 1.49's `/usage`, whose last row is verbatim
+ * `Press Esc to close`. The panel above it is read-only — a plan header, two
+ * meters, a breakdown URL — so there is no highlight to move and no key to
+ * confirm with. Before this pattern existed nothing matched the screen, it
+ * reached the `default` floor, and the chat surface answered an
+ * eighteen-button `unclassified` card to a panel with one working key.
+ *
+ * ## Why it is this narrow
+ *
+ * Three narrowings, and each one is there because this predicate SUPPRESSES
+ * controls — a false positive takes the arrow pad and the answer keys away from
+ * a screen that needed them:
+ *
+ *  - **a verb before the key.** `Press`/`Hit`/`Type`, or nothing at all, but not
+ *    an arbitrary run of prose. `esc to cancel` on its own is the tail of every
+ *    picker footer in this file, including
+ *    {@link COMMAND_CODE_SELECTION_LIST_FOOTER}, and those screens have a
+ *    highlight;
+ *  - **`close`/`dismiss`/`exit`, never `cancel` or `go back`.** The distinction
+ *    is measured rather than stylistic: `cancel` is what a screen with a
+ *    COMMITTABLE choice calls its escape (claude's `/model`, codex's picker,
+ *    Command Code's own), while `close` is what a panel that decided nothing
+ *    calls it;
+ *  - **the whole row.** Anchored at both ends (leading/trailing space aside), so
+ *    a hint bar that offers a dismiss ALONGSIDE something else — `↑/↓ navigate ·
+ *    enter to select · esc to close` — does not match, and keeps the arrows the
+ *    other half of its sentence promises.
+ *
+ * Case-insensitive because the measured row is `Press Esc to close` and Command
+ * Code writes its picker hints in lower case; nothing rests on which it uses.
+ */
+exports.DISMISSABLE_PANEL_FOOTER_PATTERN = /^\s*(?:press|hit|type)?\s*(?:<)?esc(?:ape)?(?:>)?\s+to\s+(?:close|dismiss|exit)\b[\s.·•]*$/im;
+/**
+ * How many rows from the end of the content the dismiss footer is looked for.
+ *
+ * The same 15-row tail the detection chain hands a tool module as
+ * `NormalizedFrame.lastLines` (`STATUS_CHECK_LINE_COUNT`), restated as a number
+ * here because this module is a browser-safe leaf and `tools/frame.ts` pulls in
+ * `cli-patterns`. `detect.ts` reads `frame.lastLines` and never this constant,
+ * so the two cannot disagree about the detector's own window; this one bounds
+ * the CLIENT-side reading in {@link hasDismissablePanelFooter}.
+ */
+const DISMISSABLE_PANEL_TAIL_LINE_COUNT = 15;
+/**
+ * Whether the tail of this frame is a dismiss-only panel (Issue #2369).
+ *
+ * The same question `commandCodeStatusDetector.afterPrompt` asks of
+ * `frame.lastLines`, asked of a raw capture, so the chat surface can answer for
+ * a frame whose server verdict has not reached it. The pattern is shared rather
+ * than restated — one expression, two call sites, exactly as
+ * {@link COMMAND_CODE_SELECTION_LIST_FOOTER} is shared between the detector and
+ * the dialog card.
+ *
+ * @param frame - a raw `capture-pane -p -e` frame, ANSI intact
+ */
+function hasDismissablePanelFooter(frame) {
+    if (!frame)
+        return false;
+    const lines = (0, ansi_1.stripAnsi)(frame.replace(/\r\n/g, '\n')).split('\n');
+    let last = lines.length - 1;
+    while (last >= 0 && lines[last].trim() === '')
+        last -= 1;
+    if (last < 0)
+        return false;
+    const tail = lines.slice(Math.max(0, last + 1 - DISMISSABLE_PANEL_TAIL_LINE_COUNT), last + 1);
+    return tail.some((line) => exports.DISMISSABLE_PANEL_FOOTER_PATTERN.test(line));
+}
 /**
  * The horizontal rule Command Code draws directly above a full-screen dialog.
  *

package/dist/server/src/lib/detection/status-reason.js

@@ -64,6 +64,34 @@ exports.STATUS_REASON = {
      * `Type to search models...` box.
      */
     COMMAND_CODE_SELECTION_LIST: 'command_code_selection_list',
+    /**
+     * Issue #2369: a Command Code overlay that only Esc leaves.
+     *
+     * `/usage` opens a read-only panel — a plan header, two usage meters, a
+     * breakdown URL — whose last row is `Press Esc to close`. There is no
+     * highlight to move, no numbered option and no confirm key; the ONE thing the
+     * screen accepts is the dismiss.
+     *
+     * Distinct from {@link STATUS_REASON.COMMAND_CODE_SELECTION_LIST} because the
+     * two screens want different controls, and that is the whole of this Issue:
+     * before it, this panel matched no rule at all, reached the `default` floor
+     * and so raised `isUnclassifiedActive` — which the chat surface answers with
+     * `TerminalEscapeHatch` plus `PromptAnswerKeys`, eighteen buttons (arrows,
+     * Enter, Esc, `1`-`9`, `y`, `n`) of which exactly one does anything. Reporting
+     * the selection-list token instead would put the arrow pad on the card and
+     * tell an operator reading `capture --json` that a moving highlight had been
+     * read off a panel that has none.
+     *
+     * Deliberately NOT a member of `SELECTION_LIST_REASONS`
+     * (`lib/detection/status-detector.ts`): that set is what `isSelectionListActive`
+     * — and therefore the arrow pad — is derived from. The flag this one feeds is
+     * `isDismissablePanelActive`, published beside it.
+     *
+     * The vocabulary is Command Code's alone for now (方針書 §4 D2's tool-by-tool
+     * rule): the SHAPE "an overlay whose footer offers only a dismiss" is general,
+     * the sentence that identifies it was measured on one tool.
+     */
+    COMMAND_CODE_DISMISSABLE_PANEL: 'command_code_dismissable_panel',
     COPILOT_SELECTION_LIST: 'copilot_selection_list',
     CODEX_SELECTION_LIST: 'codex_selection_list',
     /** Issue #1017: Codex pager / edit-previous (transcript) mode. */

package/dist/server/src/lib/detection/tools/antigravity/dialog.js

@@ -38,13 +38,19 @@
  *
  * ## Who calls it
  *
- * Both producers of the wire, so that they cannot disagree about one screen:
- * `antigravity/detect.ts` (the status verdict `/current-output` publishes) and
- * `polling/response-checker.ts` (the `prompt` row the poller stores and the
- * push notification it raises). The Auto-Yes poller is deliberately NOT a
- * caller: with Auto-Yes on, agy's `PreToolUse` hook answers the permission
- * request before the dialog is drawn (Issue #1779), so the dialogs this module
- * reads only appear when nothing is going to auto-answer them.
+ * Every producer of the wire, so that they cannot disagree about one screen:
+ * `antigravity/detect.ts` (the status verdict `/current-output` publishes),
+ * `polling/response-checker.ts` (`detectPromptOnCleanFrame` — the `prompt` row
+ * the poller stores, the push notification it raises, AND the Auto-Yes poller's
+ * reading) and the `prompt-response` route's re-verification.
+ *
+ * Issue #2364 left the Auto-Yes poller on the generic pass, on the premise that
+ * agy's `PreToolUse` hook answers the permission request before the dialog is
+ * drawn. Measured false (#2368): agy 1.1.27 ignores a hook `allow` in
+ * interactive mode and draws the dialog anyway (#1779), so agy's Auto-Yes
+ * depends entirely on this TUI reading — and without it every wrapped Bash
+ * approval sat unanswered while `/current-output` published it as waiting.
+ * #2368 put that poller on the same entry.
  *
  * Deliberately NOT a change to the generic multiple-choice parser: folding
  * continuation rows there would change what every other tool's dialogs read

package/dist/server/src/lib/detection/tools/command-code/detect.js

@@ -55,6 +55,13 @@
  * numbered-response path, because Command Code fires `PreToolUse` AFTER the
  * dialog is answered, so a hook-driven permission decision cannot dismiss it.
  *
+ * Issue #2369 added a second `afterPrompt` branch for the other screen the
+ * shared chain could not read: the `/usage` panel, whose last row is
+ * `Press Esc to close`. It is not a picker — nothing moves, nothing commits —
+ * so it gets a reason of its own rather than the selection-list token, and the
+ * chat surface answers it with the one key it accepts. See
+ * `STATUS_REASON.COMMAND_CODE_DISMISSABLE_PANEL`.
+ *
  * `afterPrompt` arrived with Issue #2297, for the one screen the shared chain
  * genuinely could not read: the picker `/model` opens. It is a provider-grouped
  * list of model NAMES — no option numbers — over a `› Type to search models...`
@@ -106,6 +113,32 @@ exports.commandCodeStatusDetector = (0, run_detection_1.createToolStatusDetector
     tool: 'command-code',
     verifiedAgainst: exports.VERIFIED_AGAINST,
     afterPrompt(frame) {
+        // Issue #2369. `/usage` opens a READ-ONLY panel: a plan header, two usage
+        // meters, a breakdown URL, and `Press Esc to close` as its last row. It is
+        // matched before the picker footer below because the two are mutually
+        // exclusive sentences and this one is the more specific — a whole row that
+        // offers a dismiss and nothing else.
+        //
+        // `waiting` rather than `running`, which is the half of this branch that
+        // fixes the reported defect: `isUnclassifiedFrame` (`session/status-evidence`)
+        // is `status === 'running' && <floor reason>`, so a `waiting` verdict takes
+        // `isUnclassifiedActive` down with it and the chat surface stops answering
+        // an eighteen-button card to a one-key panel. The reason is deliberately NOT
+        // in `SELECTION_LIST_REASONS`: there is no highlight here, so the arrow pad
+        // would be as wrong as the answer keys were. `current-output-builder`
+        // publishes it as `isDismissablePanelActive` instead.
+        //
+        // A human still has to press the key, so `waiting` is also the honest word:
+        // nothing on this pane will move until they do.
+        if (selection_shape_1.DISMISSABLE_PANEL_FOOTER_PATTERN.test(frame.lastLines)) {
+            return {
+                status: 'waiting',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.COMMAND_CODE_DISMISSABLE_PANEL,
+                hasActivePrompt: false,
+                evidence: 'positive',
+            };
+        }
         // Issue #2297. Command Code's pickers (`/model` measured live on v1.40.1 at
         // 200x1000) are arrow-driven overlays with a search box and a lower-case
         // hint-bar footer. Nothing in the shared chain reads that footer, so before