commandmate 0.26.1 → 0.27.0

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

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * The reason vocabulary a status verdict can carry.
+ *
+ * Split out of `status-detector.ts` by Issue #1927 for a mechanical reason: the
+ * facade now imports the per-tool detectors, and every tool module needs these
+ * constants, so leaving them in the facade made the graph
+ * `status-detector -> tools/* -> status-detector` — a cycle that resolves to
+ * `undefined` at module-evaluation time rather than to a value. A leaf module
+ * with no imports of its own cannot participate in one.
+ *
+ * Re-exported from `status-detector.ts`, which is where every existing importer
+ * reads it from.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATUS_REASON = void 0;
+/**
+ * Reason string constants for StatusDetectionResult.reason.
+ * Shared between status-detector.ts and current-output/route.ts to prevent typos (DR2-003).
+ */
+exports.STATUS_REASON = {
+    PROMPT_DETECTED: 'prompt_detected',
+    THINKING_INDICATOR: 'thinking_indicator',
+    OPENCODE_PROCESSING_INDICATOR: 'opencode_processing_indicator',
+    OPENCODE_SELECTION_LIST: 'opencode_selection_list',
+    /** Issue #1893: opencode's permission dialog — an arrow-key button strip. */
+    OPENCODE_PERMISSION_PROMPT: 'opencode_permission_prompt',
+    CLAUDE_SELECTION_LIST: 'claude_selection_list',
+    COPILOT_SELECTION_LIST: 'copilot_selection_list',
+    CODEX_SELECTION_LIST: 'codex_selection_list',
+    /** Issue #1017: Codex pager / edit-previous (transcript) mode. */
+    CODEX_PAGER: 'codex_pager',
+    /** Issue #1829: Codex's hooks review screens, which only `t`/`esc` leave. */
+    CODEX_HOOKS_REVIEW: 'codex_hooks_review',
+    ANTIGRAVITY_SELECTION_LIST: 'antigravity_selection_list',
+    OPENCODE_RESPONSE_COMPLETE: 'opencode_response_complete',
+    INPUT_PROMPT: 'input_prompt',
+    NO_RECENT_OUTPUT: 'no_recent_output',
+    /**
+     * A tool's own detector looked at this frame and recognised nothing
+     * (Issue #1927, §6.1).
+     *
+     * Distinct from {@link STATUS_REASON.DEFAULT} on purpose, and the distinction
+     * is operational rather than cosmetic. `default` is the generic floor: no
+     * pattern matched anywhere, including the shared composer check, so nothing
+     * in particular is missing. `unknown_frame` is what a tool that OPTS OUT of
+     * the shared composer check reports — copilot and opencode, whose own rules
+     * are the only rules that run for them. Seeing it means "this tool's measured
+     * rules could not read this frame", which names an action: capture the frame
+     * and add it to that tool's fixtures.
+     *
+     * Both are `running` on the wire with `evidence: 'none'`, so a consumer that
+     * does not care about the difference sees no change.
+     */
+    UNKNOWN_FRAME: 'unknown_frame',
+    DEFAULT: 'default',
+};

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

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Antigravity (agy) status detector (Issue #1927, 方針書 §4 D2).
+ *
+ * A verbatim lift of the `cliToolId === 'antigravity'` blocks (priorities 0.9
+ * and 2.8) out of `detectSessionStatus`.
+ *
+ * No `readIdleEvidence`: agy's idle branch reads the same always-visible `> `
+ * input box that #1885 showed is not evidence on its own, and this repository
+ * holds no live agy capture to measure a better rule from. Per §4 D1 決定 1's
+ * tool-by-tool rollout (DR2-002) a tool without a measured rule keeps the
+ * pre-#1927 reading, and its rule must be read off ITS OWN frames rather than
+ * inferred from another tool's — which is exactly the mistake #1979 corrected.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.antigravityStatusDetector = exports.VERIFIED_AGAINST = void 0;
+const cli_patterns_1 = require("../../cli-patterns");
+const status_reason_1 = require("../../status-reason");
+const run_detection_1 = require("../run-detection");
+const verified_against_1 = require("../verified-against");
+/** agy build these rules were read off (Issue #988 / #995; value in ../verified-against, #1929). */
+exports.VERIFIED_AGAINST = verified_against_1.ANTIGRAVITY_VERIFIED_AGAINST;
+exports.antigravityStatusDetector = (0, run_detection_1.createToolStatusDetector)({
+    tool: 'antigravity',
+    verifiedAgainst: exports.VERIFIED_AGAINST,
+    beforePrompt(frame) {
+        // 0.9. Antigravity: selection list detection BEFORE thinking detection (Issue #995)
+        // agy's "Switch Model" (and other) selection TUIs render an "esc to cancel"
+        // footer that ANTIGRAVITY_THINKING_PATTERN also matches, so the generic thinking
+        // check (and the footer branch below) would otherwise misreport the selection
+        // screen as "generating" and NavigationButtons would never be shown. Detecting the
+        // selection list here — ahead of thinking — is the fix. Mirrors the Copilot /
+        // Codex early-detection pattern.
+        if (cli_patterns_1.ANTIGRAVITY_SELECTION_LIST_PATTERN.test(frame.lastLines)) {
+            return {
+                status: 'waiting',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.ANTIGRAVITY_SELECTION_LIST,
+                hasActivePrompt: false,
+                evidence: 'positive',
+            };
+        }
+        return null;
+    },
+    afterThinking(frame) {
+        // 2.8. Antigravity (agy) footer-based detection (Issue #988)
+        // agy renders inline (scrollback retained), with the status bar as the last
+        // non-empty line and a bare "> " input box always visible just above it — even
+        // while generating. So the always-visible "> " would make the generic composer
+        // check report ready during generation. The footer is the source of
+        // truth: "esc to cancel" + braille spinner / "Generating..." while running,
+        // "? for shortcuts" when idle. Resolve running explicitly here first, then idle.
+        if ((0, cli_patterns_1.detectThinking)('antigravity', frame.lastLines)) {
+            return {
+                status: 'running',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.THINKING_INDICATOR,
+                hasActivePrompt: false,
+                evidence: 'positive',
+            };
+        }
+        // Idle: bare "> " input prompt visible and the response has completed.
+        const { promptPattern } = (0, cli_patterns_1.getCliToolPatterns)('antigravity');
+        if (promptPattern.test(frame.lastLines)) {
+            return {
+                status: 'ready',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.INPUT_PROMPT,
+                hasActivePrompt: false,
+                evidence: 'positive',
+            };
+        }
+        return null;
+    },
+});

package/dist/server/src/lib/detection/tools/claude/detect.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Claude Code's status detector (Issue #1927, 方針書 §4 D2).
+ *
+ * Two of the three branches here are lifts of existing `status-detector.ts`
+ * blocks, unchanged: the selection-list footer (priority 1.5) and the
+ * interrupt-hint status bar (priority 2.6). The third — {@link readIdleEvidence}
+ * — is what #1927 adds, and the whole reason Claude needed a module of its own.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeStatusDetector = void 0;
+exports.findClaudeTranscriptTail = findClaudeTranscriptTail;
+exports.readIdleEvidence = readIdleEvidence;
+const cli_patterns_1 = require("../../cli-patterns");
+const composer_text_1 = require("../../composer-text");
+const prompt_detect_multiple_choice_1 = require("../../prompt-detect-multiple-choice");
+const status_reason_1 = require("../../status-reason");
+const prompt_1 = require("./prompt");
+const run_detection_1 = require("../run-detection");
+const patterns_1 = require("./patterns");
+/**
+ * Where Claude's transcript ends in this frame, or -1.
+ *
+ * Everything Claude pins to the bottom of the pane is chrome, not transcript:
+ * the input box, the model/effort chip above it, and the task panel above that
+ * (#1708 already had to identify the panel as a block, and its finder is reused
+ * here rather than restated). The transcript tail is the first row above all of
+ * them, which after `compactBlankRows` is a handful of rows up even when the
+ * live pane put ~870 blank rows in between.
+ *
+ * Returning an index rather than a boolean keeps this usable by anything else
+ * that needs "the last thing Claude actually said".
+ */
+function findClaudeTranscriptTail(contentLines) {
+    const lines = contentLines;
+    const box = (0, composer_text_1.findClaudeInputBox)(lines);
+    const end = box ? box.openingSeparator : lines.length;
+    const panelRows = (0, prompt_detect_multiple_choice_1.findClaudeTaskPanelLines)(lines, 0, end);
+    let index = end - 1;
+    while (index >= 0 &&
+        (lines[index].trim() === '' ||
+            panelRows.has(index) ||
+            patterns_1.CLAUDE_EFFORT_CHIP_PATTERN.test(lines[index]))) {
+        index--;
+    }
+    return index;
+}
+/**
+ * §4 D1 決定 1: does this frame positively show that Claude's turn is over?
+ *
+ * Two acceptable answers, both measured (see `patterns.ts`):
+ *
+ *  - **item 2, a positively confirmed idle state**: the transcript tail is the
+ *    duration-bearing completion marker `✻ <Verb> for <N>s`. Claude writes it
+ *    when a turn ends and nowhere else — an in-flight turn's row is the
+ *    present-participle form with no duration, and a streaming turn's tail is
+ *    prose or a tool result.
+ *  - **item 4, not-started**: the startup banner is on screen and no user turn
+ *    has been echoed under it. A session that has never opened a turn is `ready`
+ *    by construction, and this is the positive form of saying so — the banner
+ *    proves the frame still shows the beginning of the session, so the missing
+ *    user turn means "none was ever sent" rather than "it scrolled off".
+ *
+ * Everything else is `'none'`: an unrecognised overlay, a frame captured
+ * mid-repaint, or — the case that matters — a generating turn whose busy marker
+ * this build of Claude spells differently than
+ * {@link CLAUDE_INTERRUPT_HINT_PATTERN} expects. That last one is what the
+ * mutation fixture in `tests/unit/detection/tools/claude/` pins: change one word
+ * of `esc to interrupt` and the frame must lose its evidence, not fall through
+ * to a confident `ready`.
+ */
+function readIdleEvidence(frame) {
+    const tail = findClaudeTranscriptTail(frame.contentLines);
+    if (tail >= 0 && patterns_1.CLAUDE_TURN_COMPLETE_PATTERN.test(frame.contentLines[tail])) {
+        return 'positive';
+    }
+    const box = (0, composer_text_1.findClaudeInputBox)(frame.contentLines);
+    const transcript = frame.contentLines.slice(0, box ? box.openingSeparator : undefined);
+    const hasBanner = transcript.some(line => patterns_1.CLAUDE_BANNER_PATTERN.test(line));
+    const hasUserTurn = transcript.some(line => patterns_1.CLAUDE_TRANSCRIPT_USER_TURN_PATTERN.test(line));
+    if (hasBanner && !hasUserTurn)
+        return 'positive';
+    return 'none';
+}
+exports.claudeStatusDetector = (0, run_detection_1.createToolStatusDetector)({
+    tool: 'claude',
+    verifiedAgainst: patterns_1.VERIFIED_AGAINST,
+    afterPrompt(frame) {
+        // 1.5. Claude CLI selection list detection
+        // Claude CLI's multi-select/checkbox prompts (e.g., AskUserQuestion with checkboxes)
+        // use arrow keys + Enter to navigate and toggle, not number input.
+        // The 15-line window may miss the question line, causing SEC-001a rejection above.
+        // Detect via the footer instruction pattern and show NavigationButtons instead of PromptPanel.
+        if (cli_patterns_1.CLAUDE_SELECTION_LIST_FOOTER.test(frame.lastLines)) {
+            return {
+                status: 'waiting',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.CLAUDE_SELECTION_LIST,
+                hasActivePrompt: false,
+                evidence: 'positive',
+            };
+        }
+        return null;
+    },
+    afterThinking(frame) {
+        // 2.6. Claude status-bar "esc to interrupt" detection — wider STATUS_CHECK_LINE_COUNT window (Issue #805)
+        // When Claude runs a subagent Task (e.g., /pm-auto-dev + general-purpose subagent), the
+        // bottom-of-screen task panel ("⏺ main" / "◯ general-purpose ... 55s" rows) pushes BOTH the
+        // "✶ Running…" spinner (top of the footer) and the "esc to interrupt" status bar above the
+        // narrow THINKING_TAIL_LINE_COUNT (5) window used by step 2. The visible "❯" input box then
+        // matches the input-prompt check at step 3, so the session was misreported as Ready.
+        //
+        // The "esc to interrupt" status bar appears only while Claude is actively processing (idle
+        // sessions show "? for shortcuts" or the mode chip instead) and is repainted live rather than
+        // lingering in scrollback, so matching it in the wider 15-line footer window is a safe running
+        // signal and does not reintroduce the Issue #188 spinner-summary false positive (only the
+        // spinner+ellipsis branch is restricted to the 5-line window).
+        if (cli_patterns_1.CLAUDE_INTERRUPT_HINT_PATTERN.test(frame.lastLines)) {
+            return {
+                status: 'running',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.THINKING_INDICATOR,
+                hasActivePrompt: false,
+                evidence: 'positive',
+            };
+        }
+        return null;
+    },
+    readIdleEvidence,
+    // §4 D1 決定 4 (Issue #1928): the seam Auto-Yes reads. The region is measured
+    // here and parsed there, so the dialog rule and the idle rule agree about
+    // where Claude's chrome starts and `prompt.ts` needs no import from this file.
+    detectDialog(frame) {
+        return (0, prompt_1.detectClaudeDialog)(frame, {
+            transcriptTail: findClaudeTranscriptTail(frame.contentLines),
+        });
+    },
+    // No `unreadableReason`: Claude does NOT opt out of the generic composer
+    // check, so a Claude frame only reaches the floor when there was no composer
+    // row to read either. That is the generic "nothing matched anywhere" case
+    // `default` has always named, not a statement about Claude's own rules —
+    // `unknown_frame` belongs to the two tools whose chain is the only chain
+    // (copilot, opencode).
+});

package/dist/server/src/lib/detection/tools/claude/patterns.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Claude Code's own detection patterns (Issue #1927).
+ *
+ * The regexes shared with other tools stay in `cli-patterns.ts`; what lives here
+ * is what Issue #1927 had to measure to give Claude a §4 D1 idle rule, plus the
+ * provenance of that measurement.
+ *
+ * ## Why Claude needed a new rule at all
+ *
+ * The design policy's first draft said Claude already had a completion marker
+ * (`⏺` plus the composer). It does not: `⏺` is one of `CLAUDE_SPINNER_CHARS`,
+ * i.e. a RUNNING signal, and the composer `❯` is drawn throughout a turn. So the
+ * pre-#1927 route to `ready` was the generic `promptPattern` matching a composer
+ * row that is on screen during generation too — the "absence of a negative"
+ * §4 D1 forbids and #1885 reported for copilot.
+ *
+ * ## What was measured (claude-cli 2.1.240, 200x1000 pane, 2026-08-23)
+ *
+ * The bottom status row is NOT the answer here, unlike copilot's. Measured
+ * across all four permission modes, idle and generating:
+ *
+ * | mode         | idle                                              | generating                                                       |
+ * |--------------|---------------------------------------------------|------------------------------------------------------------------|
+ * | manual       | `⏸ manual mode on · ? for shortcuts · ⇥ for agents` | `⏸ manual mode on · esc to interrupt · ⇥ for agents`             |
+ * | auto         | `⏵⏵ auto mode on (shift+tab to cycle) · ⇥ for agents` | `⏵⏵ auto mode on (shift+tab to cycle) · esc to interrupt · ⇥ for agents` |
+ * | plan         | `⏸ plan mode on (shift+tab to cycle) · ⇥ for agents` | —                                                                |
+ * | accept edits | `⏵⏵ accept edits on (shift+tab to cycle) · ⇥ for agents` | —                                                            |
+ *
+ * In auto mode the row is byte-identical either side of `esc to interrupt`, so
+ * an idle allowlist built from it would vouch for a generating frame. The row
+ * discriminates in exactly one direction — `esc to interrupt` means busy — which
+ * is `CLAUDE_INTERRUPT_HINT_PATTERN`'s job and not an idle rule.
+ *
+ * The transcript IS the answer. Every completed turn measured ends with a
+ * duration-bearing marker as the last transcript row:
+ *
+ *   `✻ Brewed for 14s`   `✻ Baked for 20s`   `✻ Sautéed for 4s`
+ *   `✻ Cooked for 8s · 5 messages hidden (/focus to show)`
+ *
+ * while a running turn ends with response prose, a tool result, or the
+ * present-participle form of the same row — `✻ Manifesting… (3s · thinking with
+ * xhigh effort)`, `· Enchanting… (5s · …)` — which carries no `for <duration>`.
+ * The duration is what makes it evidence rather than decoration, the same
+ * argument #1893 used to make opencode's `▣ … · 2.3s` duration mandatory.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERIFIED_AGAINST = exports.CLAUDE_EFFORT_CHIP_PATTERN = exports.CLAUDE_TRANSCRIPT_USER_TURN_PATTERN = exports.CLAUDE_BANNER_PATTERN = exports.CLAUDE_TURN_COMPLETE_PATTERN = void 0;
+/**
+ * Claude's turn-completion marker: a spinner glyph, a verb, and a duration.
+ *
+ * The glyph rotates through `CLAUDE_SPINNER_CHARS` while a turn runs and settles
+ * on `✻` when it ends, so the glyph is NOT the discriminator and the whole set
+ * is accepted here. The discriminator is `for <duration>` in the past tense:
+ * the in-flight row is `<Verb>… (Ns · …)`, whose ellipsis and parenthetical the
+ * pattern cannot match.
+ *
+ * `\d+m\s*` covers the minute form of a long turn. No `/g` (keeps `.test()`
+ * stateless) and no nested quantifiers (ReDoS-safe).
+ */
+exports.CLAUDE_TURN_COMPLETE_PATTERN = /^\s*[✻✽✶✢✳⦿◉●·⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s+\S+\s+for\s+(?:\d+m\s*)?\d+(?:\.\d+)?s(?:\s|$|\s*·)/;
+/**
+ * Claude's startup banner — the top edge of a session that has not run a turn.
+ *
+ * `╭─── Claude Code v2.1.240 ───…╮`. Paired with
+ * {@link CLAUDE_TRANSCRIPT_USER_TURN_PATTERN} below it, this is the positive
+ * form of §4 D1 決定 1 item 4 ("未開始"): the banner says the frame still shows
+ * the start of the session, and the absence of a user turn UNDER a visible start
+ * is a statement about the whole session rather than about what scrolled off.
+ */
+exports.CLAUDE_BANNER_PATTERN = /^\s*╭─+\s*Claude Code v/;
+/**
+ * A user turn in the transcript: `❯ <text>` outside the composer box.
+ *
+ * Claude echoes every submitted message this way. Callers must exclude the
+ * composer rows before scanning, since the composer wears the same glyph — see
+ * `findClaudeInputBox`.
+ */
+exports.CLAUDE_TRANSCRIPT_USER_TURN_PATTERN = /^\s*[>❯]\s+\S/;
+/**
+ * The right-aligned model/effort chip Claude draws directly above its input box.
+ *
+ * `◍ xhigh · /effort` / `● high · /effort`. It is chrome, not transcript, so the
+ * walk that looks for the transcript tail has to step over it — without this the
+ * tail of every frame that shows the chip is the chip itself and no completion
+ * marker is ever reached. Anchored on the trailing `· /effort` because the glyph
+ * varies with the reasoning level.
+ */
+exports.CLAUDE_EFFORT_CHIP_PATTERN = /·\s*\/effort\s*$/;
+/**
+ * Which build these rules were read off.
+ *
+ * The value itself lives in `../verified-against` so §4 D2's staleness probe can
+ * read every tool's stamp as data (Issue #1929); it is re-exported here so a
+ * reader of these patterns still finds it next to them.
+ */
+var verified_against_1 = require("../verified-against");
+Object.defineProperty(exports, "VERIFIED_AGAINST", { enumerable: true, get: function () { return verified_against_1.CLAUDE_VERIFIED_AGAINST; } });

package/dist/server/src/lib/detection/tools/claude/prompt.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Claude Code's positive dialog detection (Issue #1928, 方針書 §4 D1 決定 4).
+ *
+ * The seam Auto-Yes reads. Everything here answers ONE question — "is the block
+ * at the bottom of this frame a dialog Claude is drawing, or is it text Claude
+ * wrote?" — because that is the distinction `detectPrompt` cannot make and the
+ * one #1896 turned on: an agent that lists `1. / 2. / 3.` in its ANSWER
+ * satisfies the generic numbered-list inference, and Auto-Yes used to type `1`
+ * at it.
+ *
+ * ## What was measured (claude-cli 2.1.240 / 2.1.218, 200x1000 pane)
+ *
+ * Claude draws exactly two shapes of numbered dialog, both with the selection
+ * cursor `❯` on the highlighted row
+ * (`tests/unit/lib/detection/fixtures/claude-live-1708/`):
+ *
+ * | frame                              | rows                                                              |
+ * |------------------------------------|-------------------------------------------------------------------|
+ * | `bash-approval-taskpanel.txt`      | ` Do you want to proceed?` / ` ❯ 1. Yes` … / ` Esc to cancel · Tab to amend · ctrl+e to explain` |
+ * | `askuserquestion-submit-taskpanel.txt` | `Ready to submit your answers?` / `❯ 1. Submit answers` / `  2. Cancel` — **no footer at all** |
+ *
+ * and the `/model` overlay of #1495, whose footer is `Enter to set as default ·
+ * s to use this session only · Esc to cancel`.
+ *
+ * So neither the footer alone nor the cursor alone covers the measured set: the
+ * AskUserQuestion submit screen has no footer, and every frame has the cursor.
+ * The cursor is therefore REQUIRED and the footer is required only when there is
+ * one — which is the shape of the two guards below.
+ *
+ * ## Why the cursor must be `❯`, not "any selection glyph"
+ *
+ * `●` is in {@link findNumberedOptionBlock}'s glyph union because codex and
+ * copilot draw a filled radio, but Claude uses `●` for an ordinary transcript
+ * bullet — ` ● Which color scheme do you prefer?` is a live row of
+ * `askuserquestion-submit-taskpanel.txt`. Accepting it here would let Claude's
+ * own prose vouch for itself, which is the #1896 failure with a different glyph.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectClaudeDialog = detectClaudeDialog;
+const cli_patterns_1 = require("../../cli-patterns");
+const dialog_block_1 = require("../dialog-block");
+/**
+ * Claude's dialog footers, in every spelling measured.
+ *
+ * `Esc to cancel` is the permission dialog's and the `/model` overlay's; the
+ * `Enter to …` alternatives are {@link CLAUDE_SELECTION_LIST_FOOTER}'s three
+ * forms restated as a single test, because here they are being used to VOUCH
+ * for a block rather than to classify a frame.
+ *
+ * Case-insensitive because 2.1.218 draws `Esc` and 2.1.240 draws `esc` in
+ * different rows of the same UI. No `/g`, no nested quantifiers.
+ */
+const CLAUDE_DIALOG_FOOTER_PATTERN = /esc\s+to\s+cancel|enter\s+to\s+(?:select|confirm|set\s+as\s+default)/i;
+/** The selection cursor Claude puts on the highlighted option. */
+const CLAUDE_SELECTION_GLYPHS = new Set(['❯', '>']);
+/** How many non-blank rows above the options may hold the question. */
+const QUESTION_SCAN_ROWS = 4;
+/** The permission dialog's question, in the spellings 2.1.x draws. */
+const CLAUDE_PERMISSION_QUESTION_PATTERN = /do you want to\b|allow\b.*\?$/i;
+/** The AskUserQuestion review screen's closing question. */
+const CLAUDE_ASK_USER_QUESTION_PATTERN = /ready to submit your answers\?|review your answers/i;
+/** The `/model` overlay's footer verb (Issue #1495). */
+const CLAUDE_PICKER_FOOTER_PATTERN = /set\s+as\s+default/i;
+/** The non-blank rows immediately above `firstRow`, nearest first. */
+function readContextAbove(lines, firstRow) {
+    const rows = [];
+    for (let i = firstRow - 1; i >= 0 && rows.length < QUESTION_SCAN_ROWS; i--) {
+        const row = lines[i].trim();
+        if (row === '')
+            continue;
+        rows.push(row);
+    }
+    return rows.join('\n');
+}
+function classify(context, footer) {
+    if (CLAUDE_ASK_USER_QUESTION_PATTERN.test(context))
+        return 'ask_user';
+    if (CLAUDE_PICKER_FOOTER_PATTERN.test(footer))
+        return 'picker';
+    if (CLAUDE_PERMISSION_QUESTION_PATTERN.test(context))
+        return 'permission';
+    return 'dialog';
+}
+/**
+ * Does this frame carry a Claude dialog?
+ *
+ * @param frame - The normalised capture
+ * @param context - What `detect.ts` measured; see {@link ClaudeDialogContext}
+ * @returns The dialog, or null — which for a gated tool means Auto-Yes must not
+ *   answer, whatever `detectPrompt` inferred from the same rows
+ */
+function detectClaudeDialog(frame, context) {
+    if (context.transcriptTail < 0)
+        return null;
+    // `stripBoxDrawing` maps line-for-line, so an index taken from
+    // `frame.contentLines` is valid here too — and a frame whose gutter the
+    // Auto-Yes poller already removed parses to the same rows.
+    const lines = (0, cli_patterns_1.stripBoxDrawing)(frame.clean).split('\n');
+    const block = (0, dialog_block_1.findNumberedOptionBlock)(lines, context.transcriptTail + 1);
+    if (!block)
+        return null;
+    // Guard 1: the selection cursor. Claude puts it on the highlighted option of
+    // every dialog it draws and on nothing it writes.
+    if (block.selectedGlyph === null || !CLAUDE_SELECTION_GLYPHS.has(block.selectedGlyph)) {
+        return null;
+    }
+    // Guard 2: whatever sits between the options and the end of the transcript
+    // must be one of Claude's dialog footers, or nothing at all. A completion
+    // marker (`✻ Brewed for 24s`) or a fresh line of prose there means the block
+    // is finished output with something after it, not an open dialog.
+    const footer = block.footer.trim();
+    if (footer !== '' && !CLAUDE_DIALOG_FOOTER_PATTERN.test(footer))
+        return null;
+    return {
+        kind: classify(readContextAbove(lines, block.firstRow), footer),
+        options: block.options,
+        // Claude's menus take ↑/↓ + Enter, and `sendPromptAnswer` already knows
+        // that: it NAVIGATES to the numbered option for claude rather than typing
+        // the digit (`isCursorNavMultiChoice`). The answer is still expressed as a
+        // number, which is what this field is about.
+        answerMode: 'numbered',
+    };
+}