commandmate 0.34.1 → 0.35.0

package/dist/lib/detection/tools/verified-against.d.ts

@@ -109,6 +109,26 @@ export declare const ANTIGRAVITY_VERIFIED_AGAINST: {
  * tmux socket at the production geometry — the default pane size does not
  * reproduce the 200-column rules that fence the composer, and the status row
  * drops its `esc to interrupt` tail below 72 columns.
+ *
+ * ## Deliberately NOT advanced by Issues #2521 / #2522
+ *
+ * Both read the `AskUserQuestion` screen, and both did it from the anonymised
+ * capture in `tests/fixtures/command-code-askuserquestion-2521/` — whose rows
+ * 410-423 are verbatim from a live pane, but whose version is what the reporting
+ * session SAID it was (1.53.0) rather than something re-probed. #2522's own
+ * fixture directory is synthetic throughout, and the send mode
+ * (`submitMode: 'answer_only'`) was chosen from a STATIC reading of a locally
+ * installed 1.53.1 `QuestionPrompt` plus the safe-direction argument in
+ * `tools/command-code/dialog.ts` — not from a keystroke sent at a live pane.
+ *
+ * None of that is the measurement this stamp records. #2304 set the precedent in
+ * the other direction: seven frames re-captured live on 1.49.0 changed no rule,
+ * and the stamp still says 1.40.1 because that is the build the rules were READ
+ * OFF. Advancing it here on a reported version, a synthetic fixture and a
+ * package read off disk would make `getDetectorFreshness` claim a measurement
+ * nobody took. When a live 1.53.x session is probed — the question screen, the
+ * keys it accepts and what one of them advances — bump this to that exact
+ * version with its own `capturedAt`.
  */
 export declare const COMMAND_CODE_VERIFIED_AGAINST: {
     readonly version: "1.40.1";

package/dist/lib/detection/tools/verified-against.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verified-against.d.ts","sourceRoot":"","sources":["../../../../src/lib/detection/tools/verified-against.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,iEAAiE;AACjE,eAAO,MAAM,uBAAuB;;;;CAI1B,CAAC;AAEX,4EAA4E;AAC5E,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB;;;;CAI5B,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,4BAA4B;;;;CAI/B,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B;;;;CAIhC,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B;;;;CAI9B,CAAC;AAEX,iFAAiF;AACjF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CASpF,CAAC"}
+{"version":3,"file":"verified-against.d.ts","sourceRoot":"","sources":["../../../../src/lib/detection/tools/verified-against.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,iEAAiE;AACjE,eAAO,MAAM,uBAAuB;;;;CAI1B,CAAC;AAEX,4EAA4E;AAC5E,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB;;;;CAI5B,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,4BAA4B;;;;CAI/B,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,6BAA6B;;;;CAIhC,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B;;;;CAI9B,CAAC;AAEX,iFAAiF;AACjF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CASpF,CAAC"}

package/dist/lib/detection/tools/verified-against.js

@@ -112,6 +112,26 @@ exports.ANTIGRAVITY_VERIFIED_AGAINST = {
  * tmux socket at the production geometry — the default pane size does not
  * reproduce the 200-column rules that fence the composer, and the status row
  * drops its `esc to interrupt` tail below 72 columns.
+ *
+ * ## Deliberately NOT advanced by Issues #2521 / #2522
+ *
+ * Both read the `AskUserQuestion` screen, and both did it from the anonymised
+ * capture in `tests/fixtures/command-code-askuserquestion-2521/` — whose rows
+ * 410-423 are verbatim from a live pane, but whose version is what the reporting
+ * session SAID it was (1.53.0) rather than something re-probed. #2522's own
+ * fixture directory is synthetic throughout, and the send mode
+ * (`submitMode: 'answer_only'`) was chosen from a STATIC reading of a locally
+ * installed 1.53.1 `QuestionPrompt` plus the safe-direction argument in
+ * `tools/command-code/dialog.ts` — not from a keystroke sent at a live pane.
+ *
+ * None of that is the measurement this stamp records. #2304 set the precedent in
+ * the other direction: seven frames re-captured live on 1.49.0 changed no rule,
+ * and the stamp still says 1.40.1 because that is the build the rules were READ
+ * OFF. Advancing it here on a reported version, a synthetic fixture and a
+ * package read off disk would make `getDetectorFreshness` claim a measurement
+ * nobody took. When a live 1.53.x session is probed — the question screen, the
+ * keys it accepts and what one of them advances — bump this to that exact
+ * version with its own `capturedAt`.
  */
 exports.COMMAND_CODE_VERIFIED_AGAINST = {
     version: '1.40.1',

package/dist/server/src/config/websocket-config.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * WebSocket heartbeat / reconnect constants shared by the server and the browser.
+ *
+ * Issue #2502: the socket had no liveness probe at all, so a half-open path — a
+ * phone that walked out of range, a laptop resuming from sleep, a Wi-Fi/LTE
+ * handover — stayed `connected` on both ends while every frame fell on the
+ * floor. TCP alone does not notice: without traffic neither side gets a RST,
+ * and `readyState` keeps answering OPEN. The only way out is to put bytes on
+ * the wire on a schedule and treat silence as a disconnect.
+ *
+ * Server and client read the same numbers from here because the two halves are
+ * a single protocol: the client's patience has to be a multiple of the server's
+ * beat, or a healthy connection gets killed between beats.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WS_HALF_OPEN_CLOSE_CODE = exports.WS_RECONNECT_JITTER_RATIO = exports.WS_RECONNECT_MAX_DELAY_MS = exports.WS_RECONNECT_BASE_DELAY_MS = exports.WS_CLIENT_LIVENESS_TIMEOUT_MS = exports.WS_CLIENT_LIVENESS_CHECK_INTERVAL_MS = exports.WS_HEARTBEAT_MESSAGE_TYPE = exports.WS_SERVER_HEARTBEAT_INTERVAL_MS = void 0;
+/**
+ * How often the server pings every client and emits an application-level beat.
+ *
+ * 30s is the `ws` library's own recipe cadence and stays well inside the idle
+ * timeouts of the proxies CommandMate is tunnelled through (Cloudflare Quick
+ * Tunnel, Tailscale Serve), which is a second reason to send it at all.
+ */
+exports.WS_SERVER_HEARTBEAT_INTERVAL_MS = 30_000;
+/**
+ * Server → client application-level beat (Issue #2502).
+ *
+ * A protocol-level ping is invisible to a browser: the WebSocket API answers
+ * pings automatically and gives page JavaScript no way to observe either the
+ * ping or its own pong. So the server sends this frame alongside the protocol
+ * ping — same cadence, same sweep — purely so the tab has something it CAN see.
+ * The client consumes it for liveness and does not forward it to listeners.
+ */
+exports.WS_HEARTBEAT_MESSAGE_TYPE = 'heartbeat';
+/** How often the client checks how long it has been since anything arrived. */
+exports.WS_CLIENT_LIVENESS_CHECK_INTERVAL_MS = 5_000;
+/**
+ * Silence, in ms, after which the client declares the socket half-open.
+ *
+ * 2.5x the server beat: one lost or late heartbeat must not tear down a healthy
+ * connection, but two in a row is not something a live path does. Anything
+ * inbound refreshes the clock — a broadcast, a terminal chunk, the beat — so a
+ * busy socket never gets near this.
+ */
+exports.WS_CLIENT_LIVENESS_TIMEOUT_MS = 75_000;
+/** Default base delay for the client's reconnect backoff. */
+exports.WS_RECONNECT_BASE_DELAY_MS = 1_000;
+/** Default ceiling for the client's reconnect backoff. */
+exports.WS_RECONNECT_MAX_DELAY_MS = 30_000;
+/**
+ * Fraction of the computed backoff the client randomises by, +/- (Issue #2502).
+ *
+ * Without it every tab that was connected to a restarting server retries on the
+ * identical 1s/2s/4s grid and the thundering herd lands on the first socket the
+ * new process opens. +/-20% is enough to smear the herd across the window while
+ * keeping the backoff's shape recognisable.
+ */
+exports.WS_RECONNECT_JITTER_RATIO = 0.2;
+/**
+ * Close code the client uses when it gives up on a silent socket.
+ *
+ * In the application-private 4000-4999 range (1000-2999 are reserved by the
+ * protocol and browsers throw on most of them), so a server-side close log can
+ * tell "the tab decided this path was dead" apart from an ordinary goodbye.
+ */
+exports.WS_HALF_OPEN_CLOSE_CODE = 4001;

package/dist/server/src/lib/auto-yes-poller.js

@@ -49,6 +49,7 @@ exports.clearAllPollerStates = clearAllPollerStates;
 exports.getLastServerResponseTimestamp = getLastServerResponseTimestamp;
 exports.isPollerActive = isPollerActive;
 exports.validatePollingContext = validatePollingContext;
+exports.capturePollerFrame = capturePollerFrame;
 exports.captureAndCleanOutput = captureAndCleanOutput;
 exports.processStopConditionDelta = processStopConditionDelta;
 exports.detectAndRespondToPrompt = detectAndRespondToPrompt;
@@ -224,9 +225,28 @@ function validatePollingContext(compositeKey, pollerState) {
     }
     return 'valid';
 }
+/**
+ * Capture tmux session output once, keeping both spellings (Issue #2522).
+ *
+ * @internal Exported for testing purposes only.
+ * @param worktreeId - Worktree identifier
+ * @param cliToolId - CLI tool type being polled
+ * @param captureLines - Optional number of lines to capture
+ * @param instanceId - Optional agent instance ID (Issue #896; defaults to primary session)
+ * @returns The tick's raw capture and its cleaned form
+ */
+async function capturePollerFrame(worktreeId, cliToolId, captureLines, instanceId) {
+    const lines = captureLines ?? auto_yes_config_1.FULL_CAPTURE_LINES;
+    const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, lines, instanceId);
+    return { raw: output, clean: (0, cli_patterns_1.stripBoxDrawing)((0, cli_patterns_1.stripAnsi)(output)) };
+}
 /**
  * Capture tmux session output and strip ANSI escape codes.
  *
+ * Kept as the cleaned half of {@link capturePollerFrame} so the many callers and
+ * tests that only ever wanted that string are untouched; `pollAutoYes` takes the
+ * pair. `stripBoxDrawing` still runs exactly once per capture either way.
+ *
  * @internal Exported for testing purposes only.
  * @param worktreeId - Worktree identifier
  * @param cliToolId - CLI tool type being polled
@@ -235,9 +255,7 @@ function validatePollingContext(compositeKey, pollerState) {
  * @returns Cleaned output string (ANSI stripped)
  */
 async function captureAndCleanOutput(worktreeId, cliToolId, captureLines, instanceId) {
-    const lines = captureLines ?? auto_yes_config_1.FULL_CAPTURE_LINES;
-    const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, lines, instanceId);
-    return (0, cli_patterns_1.stripBoxDrawing)((0, cli_patterns_1.stripAnsi)(output));
+    return (await capturePollerFrame(worktreeId, cliToolId, captureLines, instanceId)).clean;
 }
 /**
  * Process stop condition check using delta-based approach.
@@ -276,9 +294,12 @@ function processStopConditionDelta(compositeKey, pollerState, cleanOutput) {
  * @param cleanOutput - ANSI-stripped terminal output
  * @param precomputedLines - Optional pre-split lines to reuse
  * @param instanceId - Optional agent instance ID (Issue #896; defaults to primary session)
+ * @param rawOutput - The SAME tick's capture with its box drawing intact
+ *   (Issue #2522). Omitting it costs Command Code's `AskUserQuestion` and
+ *   nothing else; see {@link capturePollerFrame}.
  * @returns 'responded' | 'no_prompt' | 'duplicate' | 'no_answer' | 'error'
  */
-async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, cleanOutput, precomputedLines, instanceId) {
+async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, cleanOutput, precomputedLines, instanceId, rawOutput) {
     const compositeKey = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
     try {
         // 1. Detect prompt.
@@ -301,7 +322,15 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
         // `cleanOutput` is handed over already stripped, and the clean-frame entry
         // is the one that does not strip again (`stripBoxDrawing` is not
         // idempotent), so this poller and the response poller judge identical text.
-        const promptDetection = (0, response_checker_1.detectPromptOnCleanFrame)(cleanOutput, cliToolId, precomputedLines);
+        //
+        // Issue #2522 adds the fourth argument, and it is a WIRING change rather
+        // than a reader one: Command Code's `AskUserQuestion` is anchored on the
+        // rule row `captureAndCleanOutput` blanks, so teaching
+        // `detectPromptOnCleanFrame` to read it changed nothing on this path until
+        // the same tick's raw capture reached it. `precomputedLines` stays the split
+        // of `cleanOutput` — the stop-condition delta and every other tool's reading
+        // are measured on that string and must not move.
+        const promptDetection = (0, response_checker_1.detectPromptOnCleanFrame)(cleanOutput, cliToolId, precomputedLines, rawOutput);
         if (!promptDetection.isPrompt || !promptDetection.promptData) {
             pollerState.lastAnsweredPromptKey = null;
             pollerState.lastAnsweredAt = null;
@@ -519,14 +548,18 @@ async function pollAutoYes(worktreeId, cliToolId, instanceId) {
         const captureLines = autoYesState?.stopPattern
             ? auto_yes_config_1.FULL_CAPTURE_LINES
             : auto_yes_config_1.REDUCED_CAPTURE_LINES;
-        const cleanOutput = await captureAndCleanOutput(worktreeId, cliToolId, captureLines, instanceId);
+        // Issue #2522: one capture, both spellings. The cleaned string drives every
+        // step below exactly as it did; the raw one is carried to the prompt reading
+        // so a dialog anchored on box drawing is not invisible to the one path that
+        // can answer it without a human.
+        const { raw: rawOutput, clean: cleanOutput } = await capturePollerFrame(worktreeId, cliToolId, captureLines, instanceId);
         const lines = cleanOutput.split('\n');
         // 3. Stop condition delta check (Issue #314)
         if (processStopConditionDelta(compositeKey, pollerState, cleanOutput)) {
             return;
         }
         // 4. Detect and respond to prompt
-        const result = await detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, cleanOutput, lines, instanceId);
+        const result = await detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, cleanOutput, lines, instanceId, rawOutput);
         if (result === 'responded') {
             scheduleNextPoll(worktreeId, cliToolId, instanceId, auto_yes_state_1.COOLDOWN_INTERVAL_MS);
             return;

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

@@ -66,6 +66,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 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.readCommandCodeQuestionRegion = readCommandCodeQuestionRegion;
+exports.hasCommandCodeQuestionChrome = hasCommandCodeQuestionChrome;
 exports.extractCommandCodeSelectionListFrame = extractCommandCodeSelectionListFrame;
 exports.readSelectionListShape = readSelectionListShape;
 exports.shouldOfferOptionNumbers = shouldOfferOptionNumbers;
@@ -249,6 +251,344 @@ const COMMAND_CODE_RULE_ROW_PATTERN = /^\u2500+$/;
  * `tests/fixtures/`.
  */
 const COMMAND_CODE_RULE_MIN_COLUMNS = 40;
+/**
+ * The cursor glyph Command Code draws against the highlighted option.
+ *
+ * U+276F, measured on the capture Issue #2521 was raised from. Only this one,
+ * and not codex's `›` or gemini's `●`: {@link readCommandCodeQuestionRegion}
+ * counts cursors to decide whether the region holds ONE live dialog, and a
+ * wider alphabet would start counting glyphs that are not cursors at all.
+ */
+const COMMAND_CODE_CURSOR_GLYPH = '❯';
+/**
+ * The markers Command Code paints on a question screen's tab strip.
+ *
+ * Measured row: `● Dispatch | ◯ Review` — a filled disc on the tab that has the
+ * screen and a hollow ring on the one that does not. The names are NOT part of
+ * the reading (a different question draws different tabs); what is read is the
+ * strip's structure, which is what {@link isCommandCodeQuestionTabRow} states.
+ *
+ * Two families rather than one alphabet, because "one of these is filled and one
+ * of these is not" is the whole signal. A list of bullets (`● item one`) carries
+ * the first family and nothing else, and a bullet list is the thing this
+ * reading must never mistake for a dialog.
+ */
+const COMMAND_CODE_TAB_SELECTED_MARKERS = '●◉⦿';
+/** The hollow half of {@link COMMAND_CODE_TAB_SELECTED_MARKERS}'s pair. */
+const COMMAND_CODE_TAB_UNSELECTED_MARKERS = '◯○◌⚪';
+/** One `<marker> <label>` cell of the tab strip. */
+const COMMAND_CODE_TAB_SEGMENT_PATTERN = new RegExp(`^\\s*([${COMMAND_CODE_TAB_SELECTED_MARKERS}${COMMAND_CODE_TAB_UNSELECTED_MARKERS}])\\s+\\S`);
+/**
+ * Is this row Command Code's question-screen tab strip?
+ *
+ * Three conditions, and each one is a bullet list this predicate has to refuse:
+ *
+ *  - **two or more `|`-separated cells.** `● Dispatch` on its own is a bullet;
+ *    `● Dispatch | ◯ Review` is a strip. The separator is the cheapest part of
+ *    the structure and the one prose never has in this position;
+ *  - **every cell is `<marker> <label>`.** A row that is a strip for its first
+ *    cell and prose for its second is prose;
+ *  - **at least one filled marker and at least one hollow one.** A tab strip
+ *    says which tab has the screen. A row of identical bullets does not, and
+ *    `● one | ● two` is exactly the list-with-a-pipe this rules out.
+ */
+function isCommandCodeQuestionTabRow(line) {
+    const segments = line.split('|');
+    if (segments.length < 2)
+        return false;
+    let selected = 0;
+    let unselected = 0;
+    for (const segment of segments) {
+        const match = COMMAND_CODE_TAB_SEGMENT_PATTERN.exec(segment);
+        if (match === null)
+            return false;
+        if (COMMAND_CODE_TAB_SELECTED_MARKERS.includes(match[1]))
+            selected += 1;
+        else
+            unselected += 1;
+    }
+    return selected > 0 && unselected > 0;
+}
+/**
+ * Rows that mean the region spans more than the one dialog on screen now.
+ *
+ * Issue #2521's condition 4: the tab strip and its options have to be the
+ * SAME screen, with no other turn's generating or completion UI between them.
+ * Structurally that is mostly settled by taking the LAST rule row as the top
+ * edge — a new turn repaints the composer, and the composer's own lower rule
+ * then becomes that edge — so this pattern is the belt to that braces, for a
+ * frame captured mid-repaint.
+ *
+ * Two rows, both restated here rather than imported: `cli-patterns` owns
+ * Command Code's busy and marker vocabularies and pulls the logger and the tool
+ * registry in with them, and this module is the browser-safe leaf the chat
+ * surface imports (see the module docblock).
+ *
+ *  - `esc to interrupt`, the tail Command Code appends to every status row
+ *    (`COMMAND_CODE_INTERRUPT_HINT_PATTERN`). A turn is in flight;
+ *  - a row that OPENS with U+273B and a word — `✻ Thought for 1 second`,
+ *    `✻ Worked for 4s`. Matched by shape rather than by the two English verbs,
+ *    so a reworded or localised marker still ends the region.
+ */
+const COMMAND_CODE_QUESTION_REGION_REJECT_PATTERN = /\besc\s+to\s+interrupt\b|^[^\S\n]*✻[^\S\n]+\S/im;
+/**
+ * Where a footer-less Command Code question screen sits on a pane (Issue #2521).
+ *
+ * ## The frame this exists for
+ *
+ * Command Code's `AskUserQuestion` draws no hint-bar footer. It draws a rule,
+ * a tab strip, the question, and the options — and when an option's description
+ * WRAPS, the continuation row begins with a single space:
+ *
+ *     ────────────────────────────… (200 columns of U+2500)
+ *     ● Dispatch | ◯ Review
+ *
+ *     Approve proceeding from the plan into worktree creation and dispatch?
+ *
+ *     ❯ 1. Prepare worktrees + dispatch (Recommended)
+ *          I create the worktrees and pause for you to
+ *      answer).
+ *       2. Worktrees only, then pause
+ *     …
+ *
+ * Measured 2026-09-12 on a pane reported as Command Code 1.53.0 at the
+ * production 200x1000; the anonymised capture is
+ * `tests/fixtures/command-code-askuserquestion-2521/`. Nothing read it:
+ * `detectPrompt` stops its scan at ` answer).` and never reaches option 1, and
+ * the selection-list branch below wants a footer this screen does not draw. So
+ * the frame fell through to the generic composer check — which matches, because
+ * `COMMAND_CODE_PROMPT_PATTERN` is `^❯(\s*$|\s+\S)` and `❯ 1. Prepare …` is a
+ * `❯` followed by a space and a glyph — and the pane was published as
+ * `ready` / `input_prompt`. `wait` read that as a finished turn and exited 0 on
+ * a session that was asking a question (Issue #2521's "偽完了").
+ *
+ * ## What this function is NOT
+ *
+ * It is not a general reading of footer-less dialogs, and it deliberately does
+ * not make `optionCount` into a dialog test. {@link readSelectionListShape}
+ * counts the numbers in the tail of ANY frame, an ordinary numbered answer
+ * included, and the whole point of the conditions below is that a number list
+ * on its own proves nothing. Five things have to line up:
+ *
+ *  1. the LAST rule row that qualifies as the seam ({@link
+ *     COMMAND_CODE_RULE_ROW_PATTERN} at {@link COMMAND_CODE_RULE_MIN_COLUMNS} or
+ *     wider) is the top edge, and the last row carrying content is the bottom.
+ *     Taking the LAST one is what keeps an older dialog higher up the pane out:
+ *     a new turn repaints the composer, whose own rules sit below the old
+ *     dialog, and the region is then the composer's hint row;
+ *  2. the first row under that rule is a tab strip
+ *     ({@link isCommandCodeQuestionTabRow}) and a non-blank question body
+ *     follows it before the first option;
+ *  3. the options are a STRICT run `1.` … `N.`, 2 ≤ N ≤ {@link
+ *     MAX_OPTION_NUMBER}. A gap, a repeat or a list that starts at `2` is not
+ *     this screen;
+ *  4. exactly one {@link COMMAND_CODE_CURSOR_GLYPH} in the region, and it is on
+ *     an option row. Two cursors means two screens — typically a composer's own
+ *     `❯` under the dialog — and none means the highlight is elsewhere;
+ *  5. no filter box, no `/model` footer, no dismiss-only footer and no other
+ *     turn's UI in the region ({@link FILTER_INPUT_PATTERN},
+ *     {@link COMMAND_CODE_SELECTION_LIST_FOOTER},
+ *     {@link DISMISSABLE_PANEL_FOOTER_PATTERN},
+ *     {@link COMMAND_CODE_QUESTION_REGION_REJECT_PATTERN}). `Type something...`
+ *     is an OPTION on this screen, not a filter, and the filter pattern is
+ *     narrow enough to tell them apart.
+ *
+ * `null` for anything else, which leaves every existing verdict and every
+ * existing crop exactly as they were.
+ *
+ * ## Tool-id-free and browser-safe, on purpose
+ *
+ * Three call sites read the same answer: the command-code detector's
+ * `afterPrompt`, {@link extractCommandCodeSelectionListFrame} (which runs for
+ * every CLI, with no tool id in hand) and `ChatSurface`, a client component.
+ * So this takes a raw frame and nothing else, and imports nothing but
+ * `./ansi` — the same trade the rest of this module makes.
+ *
+ * ## The one spelling it cannot answer on
+ *
+ * A capture that has been through `stripBoxDrawing` — which blanks a pure-U+2500
+ * row, so condition 1 finds no seam and this returns `null`. Same limitation
+ * `extractOpenCodeModalOverlayFrame` records for the same reason. Issue #2522
+ * did not weaken the reading to work around it: the three consumers that clean
+ * their frames (the response poller, Auto-Yes, `/prompt-response`) now keep the
+ * same tick's RAW capture and hand that here, so both spellings of one capture
+ * exist and the right one is passed.
+ *
+ * ## Issue #2522: the structural half is shared
+ *
+ * Conditions 1, 2, 3-minus-strictness and 5 moved into
+ * {@link scanCommandCodeQuestionScreen}, which {@link hasCommandCodeQuestionChrome}
+ * also reads. This function is exactly that scan plus the two conditions that
+ * are about the LIST — a strict run and a single cursor — so every verdict it
+ * gave before is the verdict it gives now.
+ *
+ * @param frame - a raw `capture-pane -p -e` frame, ANSI intact (CRLF tolerated)
+ * @returns the region's line indices into the LF-normalised frame, or `null`
+ */
+function readCommandCodeQuestionRegion(frame) {
+    const screen = scanCommandCodeQuestionScreen(frame);
+    if (screen === null)
+        return null;
+    // 3 (continued). A STRICT run. The numbers were collected in the order they
+    // are drawn and are compared against the run, rather than restarted on every
+    // fresh `1` the way `countTrailingOptionRun` does: that function is reading a
+    // tail that may hold two lists, and this one is asserting that the region
+    // holds exactly one.
+    if (!screen.numbers.every((value, index) => value === index + 1))
+        return null;
+    // 4 (continued). Exactly ONE cursor. Two means two screens — typically a
+    // composer's own `❯` under the dialog, or a frame caught mid-repaint.
+    if (screen.cursorCount !== 1)
+        return null;
+    return {
+        ruleLineIndex: screen.ruleLineIndex,
+        firstLineIndex: screen.firstLineIndex,
+        lastLineIndex: screen.lastLineIndex,
+        tabLineIndex: screen.tabLineIndex,
+        cursorLineIndex: screen.cursorLineIndex,
+        optionCount: screen.numbers.length,
+    };
+}
+/**
+ * Is Command Code's question CHROME on this frame, whatever its numbering says?
+ * (Issue #2522)
+ *
+ * The same five conditions {@link readCommandCodeQuestionRegion} applies, minus
+ * the two that are about the LIST rather than about the screen: the run need not
+ * be a strict `1.`…`N.`, and there may be more than one cursor on it.
+ *
+ * ## Why the weaker reading is worth having
+ *
+ * Issue #2522 確定仕様 B needs three answers where #2521 had two. "Not this
+ * screen" keeps every existing verdict; "read in full" produces an answerable
+ * prompt; and **"this screen, unreadable"** — a gap in the numbering, a repeated
+ * row, a list that starts at `2`, a second cursor from a half-finished repaint —
+ * has to reach the manual-operation fallback rather than the `ready` the generic
+ * composer check would otherwise publish off the dialog's own `❯` row. That is
+ * the very failure both Issues exist for: `wait` exiting 0 on a pane that is
+ * asking a human a question.
+ *
+ * It is deliberately NOT a relaxation of the strict reading. Nothing that was
+ * `null` becomes a REGION, so no partial option list is produced anywhere and no
+ * existing crop, card or prompt payload changes. What this adds is the ability
+ * to say "declined for a numbering reason" out loud.
+ *
+ * ## Why it is still narrow
+ *
+ * Every structural condition stays: the last qualifying rule row, a genuine tab
+ * strip as the first row under it ({@link isCommandCodeQuestionTabRow} — one
+ * filled marker, one hollow, `|`-separated), a non-blank question body before
+ * the first option, at least two numbered rows, at least one `❯` ON one of them,
+ * and none of the pickers, panels or other-turn UI the other branches own. An
+ * assistant answering in a numbered list carries none of that, and a frame with
+ * one option or with the `❯` on a composer row is still `false` — the two cases
+ * #2521 recorded as "the highlight is elsewhere".
+ *
+ * @param frame - a raw `capture-pane -p -e` frame, ANSI intact (CRLF tolerated)
+ */
+function hasCommandCodeQuestionChrome(frame) {
+    return scanCommandCodeQuestionScreen(frame) !== null;
+}
+/**
+ * The structural half of the question-screen reading, shared by the strict
+ * {@link readCommandCodeQuestionRegion} and the weaker
+ * {@link hasCommandCodeQuestionChrome} (Issue #2522 split them apart).
+ *
+ * Written once rather than twice on purpose: the conditions below are what make
+ * the reading safe for every other CLI's frames, and a second copy of them is a
+ * second thing to forget to narrow.
+ */
+function scanCommandCodeQuestionScreen(frame) {
+    if (!frame)
+        return null;
+    // Stripped per line off the same split, so every index below is valid against
+    // the ANSI-bearing rows the cropper slices.
+    const lines = frame.replace(/\r\n/g, '\n').split('\n').map(ansi_1.stripAnsi);
+    let last = lines.length - 1;
+    while (last >= 0 && lines[last].trim() === '')
+        last -= 1;
+    // A region needs a rule above it, so the last content row cannot be row 0.
+    if (last < 1)
+        return null;
+    let ruleLineIndex = -1;
+    for (let i = last - 1; i >= 0; i -= 1) {
+        const row = lines[i].trim();
+        if (row.length < COMMAND_CODE_RULE_MIN_COLUMNS)
+            continue;
+        if (!COMMAND_CODE_RULE_ROW_PATTERN.test(row))
+            continue;
+        ruleLineIndex = i;
+        break;
+    }
+    if (ruleLineIndex < 0)
+        return null;
+    const region = lines.slice(ruleLineIndex + 1, last + 1);
+    const body = region.join('\n');
+    // 5. The screens this reading must not take over.
+    if (FILTER_INPUT_PATTERN.test(body))
+        return null;
+    if (exports.COMMAND_CODE_SELECTION_LIST_FOOTER.test(body))
+        return null;
+    if (exports.DISMISSABLE_PANEL_FOOTER_PATTERN.test(body))
+        return null;
+    if (COMMAND_CODE_QUESTION_REGION_REJECT_PATTERN.test(body))
+        return null;
+    // 2. The tab strip opens the region.
+    const tabOffset = region.findIndex((line) => line.trim() !== '');
+    if (tabOffset < 0)
+        return null;
+    if (!isCommandCodeQuestionTabRow(region[tabOffset]))
+        return null;
+    // 3. Numbered rows under it.
+    const numbers = [];
+    let firstOptionOffset = -1;
+    for (let i = tabOffset + 1; i < region.length; i += 1) {
+        const match = OPTION_ROW_PATTERN.exec(region[i]);
+        if (match === null)
+            continue;
+        if (firstOptionOffset < 0)
+            firstOptionOffset = i;
+        numbers.push(Number(match[1]));
+    }
+    // Two is the floor: one numbered row under a tab strip is not a choice. The
+    // ceiling is {@link MAX_OPTION_NUMBER} and it is {@link OPTION_ROW_PATTERN}'s
+    // rather than a length check — that pattern captures a SINGLE digit, so a
+    // `10.` row is not read as an option at all and an eleven-option screen
+    // reports its first nine. Recognising such a screen and under-counting it is
+    // the right failure: declining it would put the pane back on the `ready` that
+    // made `wait` exit 0. (Issue #2522's reader cross-checks the count against its
+    // own block reading and declines to ANSWER such a screen; what it must not do
+    // is hand the pane back to the composer check.)
+    if (numbers.length < 2)
+        return null;
+    // 2 (continued). The question itself. A tab strip sitting straight on top of
+    // its options is some other screen.
+    if (!region.slice(tabOffset + 1, firstOptionOffset).some((line) => line.trim() !== '')) {
+        return null;
+    }
+    // 4. A cursor, on an option row.
+    let cursorCount = 0;
+    let cursorOffset = -1;
+    for (let i = 0; i < region.length; i += 1) {
+        const inRow = region[i].split(COMMAND_CODE_CURSOR_GLYPH).length - 1;
+        if (inRow === 0)
+            continue;
+        cursorCount += inRow;
+        if (OPTION_ROW_PATTERN.test(region[i]))
+            cursorOffset = i;
+    }
+    if (cursorCount === 0 || cursorOffset < 0)
+        return null;
+    return {
+        ruleLineIndex,
+        firstLineIndex: ruleLineIndex + 1,
+        lastLineIndex: last,
+        tabLineIndex: ruleLineIndex + 1 + tabOffset,
+        numbers,
+        cursorCount,
+        cursorLineIndex: ruleLineIndex + 1 + cursorOffset,
+    };
+}
 /**
  * The rows of a Command Code dialog, cut out of the pane it is painted on
  * (Issue #2326).
@@ -290,7 +630,11 @@ const COMMAND_CODE_RULE_MIN_COLUMNS = 40;
  *  - **no footer** — the picker was closed between the flags being read and the
  *    pane being captured, or the frame is some other dialog. Cropping on a
  *    guess would blank the card, which Issue #2326 calls out as worse than
- *    showing too much;
+ *    showing too much. Issue #2521 carved ONE screen out of this: a frame that
+ *    {@link readCommandCodeQuestionRegion} positively recognises is cropped to
+ *    that region, because `AskUserQuestion` draws no footer at all and its card
+ *    was otherwise the whole pane. The carve-out is a positive reading, not a
+ *    relaxation — everything it declines still lands here;
  *  - **a footer but no rule above it** — copilot's `/model` footer is
  *    `↑/↓ to navigate · … · enter to select · esc to cancel` and matches the
  *    same pattern, but copilot draws its picker in a corner-bordered box, so no
@@ -314,8 +658,22 @@ function extractCommandCodeSelectionListFrame(frame) {
             break;
         }
     }
-    if (footer < 0)
-        return null;
+    // Issue #2521: no footer is no longer unconditionally "do not crop". One
+    // screen draws none — `AskUserQuestion` — and it is the screen whose
+    // uncropped card was 409 rows of transcript with the question below the fold.
+    // The reading is the narrow one, so every other footer-less frame (a closed
+    // picker, a permission dialog, another CLI's overlay) still takes the `null`
+    // path and is returned untouched. Checked only when the footer is absent, so
+    // a picker's own crop is decided exactly as #2326 left it.
+    if (footer < 0) {
+        const region = readCommandCodeQuestionRegion(frame);
+        if (region === null)
+            return null;
+        // The rule row itself is the transcript's boundary and not the dialog's
+        // first row — the same edge the footer path takes — and `lastLineIndex` is
+        // the last row with content, so the pane's trailing padding is left out.
+        return lines.slice(region.firstLineIndex, region.lastLineIndex + 1).join('\n');
+    }
     for (let i = footer - 1; i >= 0; i -= 1) {
         const row = (0, ansi_1.stripAnsi)(lines[i]).trim();
         if (row.length < COMMAND_CODE_RULE_MIN_COLUMNS)