commandmate 0.47.0 → 0.48.0

package/dist/server/src/lib/detection/prompt-detector.js

@@ -10,6 +10,7 @@ exports.detectPrompt = detectPrompt;
 exports.resetDetectPromptCache = resetDetectPromptCache;
 const logger_1 = require("../../lib/logger");
 const prompt_detect_multiple_choice_1 = require("./prompt-detect-multiple-choice");
+const prompt_detect_multiple_choice_approval_context_1 = require("./prompt-detect-multiple-choice-approval-context");
 const tui_detection_frame_1 = require("./tui-detection-frame");
 const truncate_raw_content_1 = require("./truncate-raw-content");
 const logger = (0, logger_1.createLogger)('prompt-detector');
@@ -29,7 +30,13 @@ let lastOutputTail = null;
 /**
  * Yes/no pattern definitions for data-driven matching.
  * Each entry defines a regex pattern and its associated default option.
- * Patterns are evaluated in order; the first match wins.
+ *
+ * Issue #3881 (H-4): every pattern's every match in the tail window is a
+ * candidate, and the LATEST one (the lowest on the pane) is the prompt — see
+ * {@link findYesNoCandidates}. Before, the patterns were tried in this order
+ * and the first match of the first pattern won, so an older `(y/n)` quoted in
+ * the transcript beat the live `[y/N]` under it, and the deny patterns were
+ * judged against the old prompt's rows.
  *
  * Pattern format:
  *   - regex: Must have a capture group (1) for the question text
@@ -59,6 +66,49 @@ function locateMatchLines(tailText, tailStart, match) {
     const startLine = tailStart + countNewlines(tailText.slice(0, offset));
     return { startLine, endLine: startLine + countNewlines(match[0]) };
 }
+/**
+ * Pattern 5: `Approve?` on its own line or at the end of one. A candidate on
+ * the same terms as {@link YES_NO_PATTERNS} (Issue #3881, review N1), after
+ * them in the tie-break order.
+ */
+const APPROVE_PATTERN = /^(.*?)Approve\?\s*$/m;
+/**
+ * Every yes/no match in the tail window, oldest first (Issue #3881, H-4).
+ *
+ * Matched against the same joined window with the same patterns as before, so
+ * a line reads as a candidate exactly when it read as a prompt before; only
+ * which candidate wins changed. Sorted by the row the match ends on, then by
+ * where it starts, then by pattern order (a row cannot end in two spellings,
+ * so the last key only keeps the order deterministic).
+ *
+ * Review N1: `Approve?` is one of the five spellings, not a fallback tried
+ * only when the four found nothing — that let an older `Old? (y/n)` beat the
+ * live `Approve?` under it, and left `Approve?`s in one block uncompared.
+ */
+function findYesNoCandidates(lastLines, tailStart) {
+    const candidates = [];
+    const spellings = [
+        ...YES_NO_PATTERNS.map(p => ({ regex: p.regex, defaultOption: p.defaultOption, approve: false })),
+        { regex: APPROVE_PATTERN, defaultOption: undefined, approve: true },
+    ];
+    spellings.forEach((pattern, order) => {
+        const global = new RegExp(pattern.regex.source, `${pattern.regex.flags}g`);
+        for (const match of lastLines.matchAll(global)) {
+            const { startLine, endLine } = locateMatchLines(lastLines, tailStart, match);
+            candidates.push({
+                match,
+                defaultOption: pattern.defaultOption,
+                approve: pattern.approve,
+                startLine,
+                endLine,
+                offset: match.index ?? 0,
+                order,
+            });
+        }
+    });
+    candidates.sort((a, b) => a.endLine - b.endLine || a.offset - b.offset || a.order - b.order);
+    return candidates;
+}
 /**
  * What a yes/no prompt is asking approval for (Issue #1699).
  *
@@ -68,9 +118,24 @@ function locateMatchLines(tailText, tailStart, match) {
  * directly above its `(y/n)` — the case the deny patterns were written for —
  * still lands inside; a command approved in an earlier turn does not.
  */
-function yesNoApprovalTarget(lines, tailText, tailStart, match) {
+function yesNoApprovalTarget(lines, tailText, tailStart, match, olderCandidates = []) {
     const { startLine, endLine } = locateMatchLines(tailText, tailStart, match);
-    return (0, prompt_detect_multiple_choice_1.joinApprovalTarget)(lines, (0, prompt_detect_multiple_choice_1.findApprovalContextStart)(lines, startLine), endLine + 1);
+    // Issue #3881: a here-document's `> ` row at the prompt's column is not a
+    // known boundary (limit 3 of #3832) — `truncated`, not complete.
+    const range = (0, prompt_detect_multiple_choice_approval_context_1.findYesNoApprovalContextRange)(lines, startLine, endLine + 1);
+    // Issue #3881 (H-4): another yes/no prompt inside this prompt's own block
+    // means the block holds two questions, and which rows the live one asks
+    // about cannot be told from the screen — not the whole request either.
+    const contested = olderCandidates.some(c => c.endLine >= range.start && c.endLine < startLine);
+    return {
+        approvalTarget: (0, prompt_detect_multiple_choice_1.joinApprovalTarget)(lines, range.start, endLine + 1),
+        // Issue #3881 (H-3): whether the scan above stopped at a boundary.
+        approvalContext: {
+            startRow: range.start,
+            endRow: endLine + 1,
+            completeness: contested ? 'truncated' : range.completeness,
+        },
+    };
 }
 /**
  * Creates a yes/no prompt detection result.
@@ -80,11 +145,12 @@ function yesNoApprovalTarget(lines, tailText, tailStart, match) {
  * @param question - The question text
  * @param cleanContent - The clean content string
  * @param rawContent - The raw content string (last 20 lines, trimmed)
- * @param approvalTarget - Issue #1699 deny-match surface for this prompt
+ * @param approvalBlock - Issue #1699 deny-match surface for this prompt, and
+ *   (Issue #3881) the rows it was cut from and whether its top is a boundary
  * @param defaultOption - Optional default option ('yes' or 'no')
  * @returns PromptDetectionResult with isPrompt: true and yes_no prompt data
  */
-function yesNoPromptResult(question, cleanContent, rawContent, approvalTarget, defaultOption) {
+function yesNoPromptResult(question, cleanContent, rawContent, { approvalTarget, approvalContext }, defaultOption) {
     return {
         isPrompt: true,
         promptData: {
@@ -99,9 +165,15 @@ function yesNoPromptResult(question, cleanContent, rawContent, approvalTarget, d
             // apart is the whole fix — the wide window is a scrollback view and a
             // deny pattern matched against it fires on turns that are already done.
             ...(approvalTarget !== undefined && { approvalTarget }),
+            // Issue #3881 (H-3): a target the line cap cut short is not the whole
+            // request, and the resolver must not take a deny miss on it as a pass.
+            ...(approvalTarget !== undefined && approvalContext.completeness === 'truncated' && {
+                approvalTargetCompleteness: 'truncated',
+            }),
         },
         cleanContent,
         rawContent,
+        approvalContext,
     };
 }
 /**
@@ -169,24 +241,23 @@ function detectPrompt(output, options) {
         }
         return multipleChoiceResult;
     }
-    // Patterns 1-4: Yes/no patterns (data-driven matching)
+    // Patterns 1-5: the yes/no spellings and `Approve?` (data-driven matching).
+    // Issue #3881 (H-4, review N1): the latest candidate in the window among all
+    // five, not the first pattern's first match, and the older ones are what its
+    // block is checked against.
     const trimmedLastLines = lastLines.trim();
-    for (const pattern of YES_NO_PATTERNS) {
-        const match = lastLines.match(pattern.regex);
-        if (match) {
-            const question = match[1].trim();
-            return yesNoPromptResult(question, question, trimmedLastLines, yesNoApprovalTarget(lines, lastLines, tailStart, match), pattern.defaultOption);
+    const yesNoCandidates = findYesNoCandidates(lastLines, tailStart);
+    const live = yesNoCandidates[yesNoCandidates.length - 1];
+    if (live) {
+        const block = yesNoApprovalTarget(lines, lastLines, tailStart, live.match, yesNoCandidates.slice(0, -1));
+        if (live.approve) {
+            const content = live.match[1].trim();
+            // If there's content before "Approve?", include it in the question
+            const question = content ? `${content} Approve?` : 'Approve?';
+            return yesNoPromptResult(question, content || 'Approve?', trimmedLastLines, block);
         }
-    }
-    // Pattern 5: Approve?
-    // Matches "Approve?" on its own line or at the end of a line
-    const approvePattern = /^(.*?)Approve\?\s*$/m;
-    const approveMatch = lastLines.match(approvePattern);
-    if (approveMatch) {
-        const content = approveMatch[1].trim();
-        // If there's content before "Approve?", include it in the question
-        const question = content ? `${content} Approve?` : 'Approve?';
-        return yesNoPromptResult(question, content || 'Approve?', trimmedLastLines, yesNoApprovalTarget(lines, lastLines, tailStart, approveMatch));
+        const question = live.match[1].trim();
+        return yesNoPromptResult(question, question, trimmedLastLines, block, live.defaultOption);
     }
     // No prompt detected
     // D2-005: Suppress duplicate complete log

package/dist/server/src/lib/detection/prompt-screen-key.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Which prompt a screen shows, as one string (Issue #3706, moved here by #3798).
+ *
+ * Written for the Auto-Yes poller's stopped answers (`partialAnswerScreenKey`,
+ * which `polling/auto-yes-poller-state` still re-exports under that name). The
+ * waiting episodes (Issue #3798) need the same question — "is this frame the
+ * confirmation that wait closed on, or another one?" — from the session layer,
+ * which must not reach into `polling/`, so the reading lives in the detection
+ * layer both can import.
+ *
+ * @module lib/detection/prompt-screen-key
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptScreenKey = promptScreenKey;
+const prompt_key_1 = require("./prompt-key");
+const appearance_1 = require("../prompt-observation/appearance");
+/**
+ * Which prompt a stopped answer is about (Issue #3706): the type, the question,
+ * the option labels and `approvalTarget` — what `promptFrameKey` (auto-yes-poller-state) tells
+ * apart — but NOT where the cursor is. The keys that were sent may have moved
+ * the cursor themselves (a `Down` whose Enter was withheld), and that must not
+ * make the same list read as a new one; a different list or a different command
+ * under the same question is a new prompt and is answered.
+ */
+function promptScreenKey(promptData) {
+    const options = promptData.type === 'multiple_choice'
+        ? promptData.options.map((o) => `${o.number}.${o.label}`).join('\n')
+        : promptData.options.join('\n');
+    return [(0, prompt_key_1.generatePromptKey)(promptData), options, withoutCursorMarks(promptData)].join('\u0000');
+}
+/**
+ * `approvalTarget` with the cursor taken out: the generic parser copies the
+ * option panel into it, `❯` row included, so a moved cursor would otherwise
+ * read as another prompt.
+ *
+ * [Issue #3817] Only the rows the block reader adopted as the options are
+ * aligned (`approvalTargetWithOptionRowsAligned`, the reading #3812 gives the
+ * strict respond), so two commands whose bodies differ by an indent or a `>`
+ * are two screens. A label the block reader read may run longer than the
+ * prompt's — it folds wrapped rows and the footer in — so it only has to start
+ * with it. A yes/no prompt has no cursor and is read as it is. A list whose
+ * rows cannot be told that way keeps the old reading below: two bodies then
+ * read as one screen, which holds the prompt for a human rather than typing
+ * the answer twice.
+ */
+function withoutCursorMarks(promptData) {
+    const target = promptData.approvalTarget ?? '';
+    if (promptData.type !== 'multiple_choice')
+        return target;
+    const aligned = (0, appearance_1.approvalTargetWithOptionRowsAligned)(target, promptData.options.map((o) => o.label), (read, named) => read.startsWith(named));
+    return aligned ?? withoutLeadingMarks(target);
+}
+/** Every row's leading marks and indentation taken out (the reading before #3817). */
+function withoutLeadingMarks(text) {
+    return text
+        .split('\n')
+        .map((line) => line.replace(/^[\s❯›>▶►●○◉→]+/u, ''))
+        .join('\n');
+}

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

@@ -66,6 +66,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readAntigravityNumberedDialog = readAntigravityNumberedDialog;
 exports.detectAntigravityNumberedDialogPrompt = detectAntigravityNumberedDialogPrompt;
 exports.isAntigravityUnvouchedNumberedScreen = isAntigravityUnvouchedNumberedScreen;
+exports.isAntigravityUnansweredNumberedScreen = isAntigravityUnansweredNumberedScreen;
+exports.isAntigravityFeedbackMenuScreen = isAntigravityFeedbackMenuScreen;
 const cli_patterns_1 = require("../../cli-patterns");
 const prompt_detect_multiple_choice_1 = require("../../prompt-detect-multiple-choice");
 const tui_detection_frame_1 = require("../../tui-detection-frame");
@@ -219,6 +221,7 @@ function detectAntigravityNumberedDialogPrompt(text) {
     const dialog = readAntigravityNumberedDialog(lines);
     if (dialog === null)
         return null;
+    const range = (0, prompt_detect_multiple_choice_1.findApprovalContextRange)(lines, dialog.questionRow, dialog.footerRow);
     return (0, prompt_detect_multiple_choice_1.buildMultipleChoiceResult)(dialog.question, dialog.options.map((label, index) => ({
         number: index + 1,
         label,
@@ -229,7 +232,9 @@ function detectAntigravityNumberedDialogPrompt(text) {
         // turn's boundary and below at the footer, so the command in the
         // `Requesting permission for:` block and in the labels is judged and
         // nothing from an earlier, already-answered approval is.
-        approvalTarget: (0, prompt_detect_multiple_choice_1.joinApprovalTarget)(lines, (0, prompt_detect_multiple_choice_1.findApprovalContextStart)(lines, dialog.questionRow), dialog.footerRow),
+        approvalTarget: (0, prompt_detect_multiple_choice_1.joinApprovalTarget)(lines, range.start, dialog.footerRow),
+        // Issue #3881: and whether its top is a boundary.
+        approvalContext: { startRow: range.start, endRow: dialog.footerRow, completeness: range.completeness },
     }, normalized, truncate_raw_content_1.truncateRawContent);
 }
 /**
@@ -247,8 +252,89 @@ const OPTION_ROW_PATTERN = /^\s*(>)?\s*(\d+)\.\s+\S/;
  * so the same words inside an option label or a quoted command never match.
  */
 const FEEDBACK_MENU_FOOTER_PATTERN = /^\s*esc Cancel\s*·\s*\d+-\d+\s+Select\b/;
+/**
+ * Any piece of agy's `↑/↓ Navigate` footer (`↑/↓ Navigate · tab Amend`, a footer
+ * a narrow pane cut at `↑/↓ Nav`, another version's `↑/↓ Navigate · enter
+ * Select`). Only looked for UNDER the last option, so a footer left in the
+ * scrollback by an earlier, answered dialog does not count.
+ */
+const NAVIGATE_FOOTER_PATTERN = /↑\/↓/;
 /** How far above the bottom option row the run down from `1.` may reach. */
 const OPTION_RUN_MAX_ROWS = 40;
+/**
+ * agy's permission-panel heading rows (`Requesting permission for:`, `Do you
+ * want to proceed?` — `antigravity-live-2364/dialog-bash-*.txt`, agy 1.1.27).
+ * Whole-row matches, so the same words inside a reply's sentence do not count.
+ */
+const PERMISSION_HEADING_PATTERN = /^\s*(?:Requesting permission for:|Do you want to proceed\?)\s*$/;
+/**
+ * Read the bottom run of options, or null when the frame has none or a bare
+ * `>` composer is drawn under it — agy paints none while a screen replaces it,
+ * so those options are a quotation (the #3183 quotation veto judges them).
+ *
+ * The run is read upward while the numbers descend: a number that does not (a
+ * different list above) or a boundary row ends it.
+ */
+function readBottomOptionRun(text) {
+    const lines = (0, tui_detection_frame_1.normalizeTuiFrameForDetection)(text).split('\n');
+    let last = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (patterns_1.ANTIGRAVITY_PROMPT_PATTERN.test(lines[i]))
+            return null;
+        if (OPTION_ROW_PATTERN.test(lines[i])) {
+            last = i;
+            break;
+        }
+    }
+    if (last < 0)
+        return null;
+    const bottomRow = OPTION_ROW_PATTERN.exec(lines[last]);
+    const bottom = Number(bottomRow[2]);
+    let lowest = bottom;
+    let highlighted = bottomRow[1] !== undefined;
+    let gap = false;
+    let top = last;
+    const floor = Math.max(0, last - OPTION_RUN_MAX_ROWS);
+    for (let i = last - 1; i >= floor && lowest > 1; i--) {
+        const match = OPTION_ROW_PATTERN.exec(lines[i]);
+        if (match === null) {
+            if (cli_patterns_1.ANTIGRAVITY_DIALOG_BOUNDARY_PATTERN.test(lines[i]))
+                break;
+            continue;
+        }
+        const number = Number(match[2]);
+        if (number >= lowest)
+            break;
+        if (number !== lowest - 1)
+            gap = true;
+        lowest = number;
+        top = i;
+        if (match[1] !== undefined)
+            highlighted = true;
+    }
+    // The panel above the run: up to the boundary row that opens it (the `●`
+    // tool-call row, a rule, the previous turn's `>`), or as far as the run may reach.
+    let permissionHeading = false;
+    for (let i = top - 1; i >= Math.max(0, top - OPTION_RUN_MAX_ROWS); i--) {
+        if (cli_patterns_1.ANTIGRAVITY_DIALOG_BOUNDARY_PATTERN.test(lines[i]))
+            break;
+        if (PERMISSION_HEADING_PATTERN.test(lines[i])) {
+            permissionHeading = true;
+            break;
+        }
+    }
+    const below = lines.slice(last + 1).filter(row => row.trim() !== '');
+    return {
+        lines,
+        bottom,
+        lowest,
+        gap,
+        highlighted,
+        feedbackFooter: below.length > 0 && FEEDBACK_MENU_FOOTER_PATTERN.test(below[0]),
+        navigateFooter: below.some(row => NAVIGATE_FOOTER_PATTERN.test(row)),
+        permissionHeading,
+    };
+}
 /**
  * Is this an agy screen with numbered options that the permission reader does
  * NOT vouch for? (Issue #3808)
@@ -268,46 +354,83 @@ const OPTION_RUN_MAX_ROWS = 40;
  * False for the `/feedback` menu (its `esc Cancel · 1-6 Select` footer directly
  * under the last option), which keeps the generic reading #2364 left it.
  *
- * Callers treat true as "no prompt to answer": a human drives the screen.
+ * The STATUS verdict's rule (`antigravity/detect.ts`: such a frame is
+ * unclassified, not `prompt_detected`). Whether a frame may be ANSWERED is the
+ * wider {@link isAntigravityUnansweredNumberedScreen} (#3818): a screen this
+ * rule leaves to the generic parser can still be one a human is waiting on.
  *
  * @param text - ANSI-stripped capture, box drawing optional
  */
 function isAntigravityUnvouchedNumberedScreen(text) {
-    const lines = (0, tui_detection_frame_1.normalizeTuiFrameForDetection)(text).split('\n');
-    let last = -1;
-    for (let i = lines.length - 1; i >= 0; i--) {
-        if (patterns_1.ANTIGRAVITY_PROMPT_PATTERN.test(lines[i]))
-            return false;
-        if (OPTION_ROW_PATTERN.test(lines[i])) {
-            last = i;
-            break;
-        }
-    }
-    if (last < 0)
+    const run = readBottomOptionRun(text);
+    if (run === null || run.bottom < 2)
         return false;
-    // The run, read upward from the bottom option: N., N-1., … 1.
-    let expected = Number(OPTION_ROW_PATTERN.exec(lines[last])[2]);
-    if (expected < 2)
+    if (run.lowest !== 1 || run.gap || !run.highlighted)
         return false;
-    let highlighted = OPTION_ROW_PATTERN.exec(lines[last])[1] !== undefined;
-    const floor = Math.max(0, last - OPTION_RUN_MAX_ROWS);
-    for (let i = last - 1; i >= floor && expected > 1; i--) {
-        const match = OPTION_ROW_PATTERN.exec(lines[i]);
-        if (match === null) {
-            if (cli_patterns_1.ANTIGRAVITY_DIALOG_BOUNDARY_PATTERN.test(lines[i]))
-                return false;
-            continue;
-        }
-        if (Number(match[2]) !== expected - 1)
-            return false;
-        expected--;
-        if (match[1] !== undefined)
-            highlighted = true;
-    }
-    if (expected !== 1 || !highlighted)
+    if (run.feedbackFooter)
         return false;
-    const footer = lines.slice(last + 1).find(row => row.trim() !== '');
-    if (footer !== undefined && FEEDBACK_MENU_FOOTER_PATTERN.test(footer))
+    return readAntigravityNumberedDialog(run.lines) === null;
+}
+/**
+ * May CommandMate NOT answer this agy numbered screen? (Issue #3818)
+ *
+ * The rule of every surface that sends a key — the Auto-Yes entry
+ * (`detectPromptOnCleanFrame`), `/prompt-response`'s re-verification
+ * (`assessPromptAnswerability`) and agent-health's `readsAsAutoYesPrompt` —
+ * asked after {@link readAntigravityNumberedDialog} declined the frame. Not the
+ * status verdict's: that one says whether a human is waiting, and keeps
+ * {@link isAntigravityUnvouchedNumberedScreen}.
+ *
+ * On agy the generic multiple-choice parser's reading is answered only for the
+ * two shapes vouched for here:
+ *
+ * - the `/feedback` menu (its `esc Cancel · 1-6 Select` footer directly under
+ *   the last option), which #2364 left to the generic parser;
+ * - a reply's numbered list (#1928's legacy reading): options `1.` … `N.`,
+ *   consecutive with no number missing, none wearing agy's `>` cursor, no
+ *   `↑/↓` footer under them, and no agy permission heading (`Requesting
+ *   permission for:` / `Do you want to proceed?`) above them in the same panel.
+ *
+ * Every other run of options numbered up to `N.` (N ≥ 2) is declined — not by
+ * listing what is wrong with it, which is how #3808 left holes: a run with a
+ * number missing (`> 1.` / `3.`, which the generic parser's single-gap
+ * tolerance reads as a prompt), a run that does not reach `1.` (the cursor row
+ * pushed off the top of the pane), a run under a `↑/↓` footer the reader would
+ * not take (the login-method screen, a footer a narrow pane cut), a run
+ * wearing a cursor whose footer is below the pane, and a permission dialog
+ * whose footer AND `>` row (option 3 or 4) are below the pane — its `1.` / `2.`
+ * rows wear no cursor, so only the heading above them tells it from a reply.
+ *
+ * False when the bottom option row is `1.` (a single `> 1. …` row — a sent
+ * message echoed above the spinner — is not a run) or when a bare `>` composer
+ * is drawn under the options (a quotation, judged by the #3183 veto).
+ *
+ * @param text - ANSI-stripped capture, box drawing optional
+ */
+function isAntigravityUnansweredNumberedScreen(text) {
+    const run = readBottomOptionRun(text);
+    if (run === null || run.bottom < 2)
+        return false;
+    if (run.feedbackFooter)
+        return false;
+    const replyList = run.lowest === 1 && !run.gap && !run.highlighted && !run.navigateFooter
+        && !run.permissionHeading;
+    if (replyList)
         return false;
-    return readAntigravityNumberedDialog(lines) === null;
+    return readAntigravityNumberedDialog(run.lines) === null;
+}
+/**
+ * Is this agy frame the `/feedback` menu — its `esc Cancel · 1-6 Select`
+ * footer directly under the bottom run of options? (Issue #3881)
+ *
+ * The one numbered agy screen the generic multiple-choice parser is left to
+ * read (#2364) that is a known menu of agy's own rather than a list a reply
+ * drew. The answering entry asks it when a hook receipt is all that would
+ * otherwise vouch for a generic reading (`response-checker-dialog-gate`'s
+ * `isAntigravityGenericReadingOnScreen`).
+ *
+ * @param text - ANSI-stripped capture, box drawing optional
+ */
+function isAntigravityFeedbackMenuScreen(text) {
+    return readBottomOptionRun(text)?.feedbackFooter === true;
 }

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

@@ -61,10 +61,19 @@ function findClaudeTranscriptTail(contentLines) {
     }
     return index;
 }
-/** The confirmation page's question, as the whole row (Issue #3748). */
-const CLAUDE_SUBMIT_CONFIRM_QUESTION_ROW = /^\s*Ready to submit your answers\?\s*$/;
+/** The confirmation page's question (Issue #3748), the whole of its paragraph. */
+const CLAUDE_SUBMIT_CONFIRM_QUESTION = 'Ready to submit your answers?';
+/**
+ * How many rows the question may wrap onto (Issue #3791): two at 24 and at 16
+ * columns, measured; the bound keeps a long paragraph from being joined.
+ */
+const CLAUDE_SUBMIT_CONFIRM_QUESTION_MAX_ROWS = 3;
 /** Its option 1, as the whole row, cursor or not. */
 const CLAUDE_SUBMIT_ANSWERS_OPTION_ROW = /^\s*(?:❯\s*)?1\.\s+Submit answers\s*$/;
+/** Option 1 wrapped under its label (Issue #3791, measured at 16 columns): `❯ 1. Submit` … */
+const CLAUDE_SUBMIT_ANSWERS_WRAPPED_HEAD_ROW = /^\s*(?:❯\s*)?1\.\s+Submit\s*$/;
+/** … then `answers`, indented, on the next row. */
+const CLAUDE_SUBMIT_ANSWERS_WRAPPED_TAIL_ROW = /^\s+answers\s*$/;
 /** Its option 2, as the whole row, cursor or not. */
 const CLAUDE_SUBMIT_CANCEL_OPTION_ROW = /^\s*(?:❯\s*)?2\.\s+Cancel\s*$/;
 /** The multi-question tab bar's `✔ Submit` tab — only that bar leads to this page. */
@@ -74,6 +83,24 @@ const CLAUDE_SUBMIT_TAB_PATTERN = /✔\s*Submit/;
  * question and answer (`● …` / `→ …`) between them, wrapped at the pane width.
  */
 const CLAUDE_SUBMIT_CONFIRM_TAB_LOOKBACK = 200;
+/** The heading of the page's answer list (Issue #3791), the whole of its paragraph. */
+const CLAUDE_SUBMIT_REVIEW_HEADING = 'Review your answers';
+/** How many rows the heading may wrap onto: two at 16 columns, measured. */
+const CLAUDE_SUBMIT_REVIEW_HEADING_MAX_ROWS = 2;
+/**
+ * A row of the answer list between the heading and the question (Issue
+ * #3791), as measured at 16 to 200 columns: ` ● question`, ` │ ● question` and
+ * ` │   …` (a long question's gutter), and the question's continuation and its
+ * `→ answer` indented three columns.
+ */
+const CLAUDE_SUBMIT_REVIEW_LIST_ROW = /^ (?:[●│] | {2,}\S)/;
+/**
+ * The tab bar wrapped onto two rows (Issue #3791, measured at 16 columns):
+ * the arrow and the checkboxes on the first, `✔` closing it …
+ */
+const CLAUDE_SUBMIT_TAB_WRAPPED_GLYPH_ROW = /^\s?←(?:\s*[☐☒☑])+\s*✔\s*$/;
+/** … and the headings on the second, `Submit→` closing it. */
+const CLAUDE_SUBMIT_TAB_WRAPPED_LABEL_ROW = /^[^←→☐☒☑✔]*\bSubmit\s*→\s*$/;
 /** The nearest non-blank row above `row`, or -1. */
 function previousNonBlankRow(lines, row) {
     for (let i = row - 1; i >= 0; i--) {
@@ -82,6 +109,63 @@ function previousNonBlankRow(lines, row) {
     }
     return -1;
 }
+/**
+ * The paragraph whose last row is `lastRow`: its first row, and its rows
+ * trimmed and joined with one space — how a sentence wrapped at the pane width
+ * reads again. At most `maxRows` rows; a longer paragraph reads as null text.
+ */
+function paragraphEndingAt(lines, lastRow, maxRows) {
+    let top = lastRow;
+    while (top > 0 && lines[top - 1].trim() !== '')
+        top--;
+    if (lastRow - top + 1 > maxRows)
+        return { top, text: null };
+    const text = lines.slice(top, lastRow + 1).map(row => row.trim()).join(' ');
+    return { top, text };
+}
+/** The first row of option 1 right above `cancelRow` (whole, or wrapped as measured), or -1. */
+function submitOptionTopRow(lines, cancelRow) {
+    const row = cancelRow - 1;
+    if (row < 0)
+        return -1;
+    if (CLAUDE_SUBMIT_ANSWERS_OPTION_ROW.test(lines[row]))
+        return row;
+    if (row >= 1 &&
+        CLAUDE_SUBMIT_ANSWERS_WRAPPED_TAIL_ROW.test(lines[row]) &&
+        CLAUDE_SUBMIT_ANSWERS_WRAPPED_HEAD_ROW.test(lines[row - 1])) {
+        return row - 1;
+    }
+    return -1;
+}
+/** Whether `row` ends the tab bar: the whole bar, or its wrapped second row under its first. */
+function endsSubmitTabBar(lines, row) {
+    if ((0, picker_chrome_1.isAskUserQuestionTabRow)(lines[row]) && CLAUDE_SUBMIT_TAB_PATTERN.test(lines[row]))
+        return true;
+    return (row >= 1 &&
+        CLAUDE_SUBMIT_TAB_WRAPPED_LABEL_ROW.test(lines[row]) &&
+        CLAUDE_SUBMIT_TAB_WRAPPED_GLYPH_ROW.test(lines[row - 1]));
+}
+/**
+ * The page read from the question up through its answer list (Issue #3791),
+ * where the tab bar is not within {@link CLAUDE_SUBMIT_CONFIRM_TAB_LOOKBACK}
+ * rows or not on screen at all. Every row between the question and the top of
+ * the list is a row of the list ({@link CLAUDE_SUBMIT_REVIEW_LIST_ROW}); above
+ * the list is the `Review your answers` heading with the tab bar right above
+ * it, or nothing: a pane shorter than the page shows its bottom only (measured
+ * at 40x30 and 200x12), so the list or the heading is then the frame's top.
+ */
+function readsUpThroughReviewList(lines, questionTop) {
+    let row = questionTop - 1;
+    while (row >= 0 && (lines[row].trim() === '' || CLAUDE_SUBMIT_REVIEW_LIST_ROW.test(lines[row])))
+        row--;
+    if (row < 0)
+        return true;
+    const heading = paragraphEndingAt(lines, row, CLAUDE_SUBMIT_REVIEW_HEADING_MAX_ROWS);
+    if (heading.text !== CLAUDE_SUBMIT_REVIEW_HEADING)
+        return false;
+    const tabRow = previousNonBlankRow(lines, heading.top);
+    return tabRow < 0 || endsSubmitTabBar(lines, tabRow);
+}
 /**
  * Is this frame Claude's `AskUserQuestion` confirmation page? (Issue #3748)
  *
@@ -90,10 +174,20 @@ function previousNonBlankRow(lines, row) {
  *  1. the transcript's last row ({@link findClaudeTranscriptTail}, which steps
  *     over Claude's chrome) is `2. Cancel`, the row above it `1. Submit
  *     answers`, and the cursor `❯` is on one of the two;
- *  2. the nearest non-blank row above the options IS `Ready to submit your
- *     answers?` — the whole row, not a row that contains it;
+ *  2. the nearest paragraph above the options IS `Ready to submit your
+ *     answers?` — the whole paragraph, not one that contains it;
  *  3. the multi-question tab bar (`←  ☒ …  ✔ Submit  →`) sits above that.
  *
+ * Issue #3791 reads the shapes a live Claude 2.1.310 drew
+ * (`tests/fixtures/claude-confirm-live-3791/`), and only those: in a narrow
+ * pane the question, the heading and option 1 wrap at the pane width and the
+ * tab bar wraps onto two rows; long questions put the tab bar more than 200
+ * rows up; a pane shorter than the page cuts its head off, tab bar included.
+ * The last two are read up through the answer list
+ * ({@link readsUpThroughReviewList}) and only on a frame with no input box —
+ * the page replaces it. An unknown footer under `2. Cancel` was never drawn,
+ * so a frame with one is still not this page.
+ *
  * Deliberately NOT `detectClaudeDialog`'s `ask_user` kind: that classifies by a
  * substring of the four rows above the options, so a Bash approval whose command
  * is `grep -rn "review your answers" src`, an Edit approval whose diff holds
@@ -108,16 +202,23 @@ function isClaudeAskUserQuestionConfirmPage(frame) {
     const cancelRow = findClaudeTranscriptTail(lines);
     if (cancelRow < 0 || !CLAUDE_SUBMIT_CANCEL_OPTION_ROW.test(lines[cancelRow]))
         return false;
-    const submitRow = cancelRow - 1;
-    if (submitRow < 0 || !CLAUDE_SUBMIT_ANSWERS_OPTION_ROW.test(lines[submitRow]))
+    const submitRow = submitOptionTopRow(lines, cancelRow);
+    if (submitRow < 0)
         return false;
     if (!lines[submitRow].includes('❯') && !lines[cancelRow].includes('❯'))
         return false;
-    const questionRow = previousNonBlankRow(lines, submitRow);
-    if (questionRow < 0 || !CLAUDE_SUBMIT_CONFIRM_QUESTION_ROW.test(lines[questionRow]))
+    const questionEnd = previousNonBlankRow(lines, submitRow);
+    if (questionEnd < 0)
+        return false;
+    const question = paragraphEndingAt(lines, questionEnd, CLAUDE_SUBMIT_CONFIRM_QUESTION_MAX_ROWS);
+    if (question.text !== CLAUDE_SUBMIT_CONFIRM_QUESTION)
+        return false;
+    const tabRow = (0, picker_chrome_1.findAskUserQuestionTabRow)(lines, question.top, CLAUDE_SUBMIT_CONFIRM_TAB_LOOKBACK);
+    if (tabRow >= 0 && CLAUDE_SUBMIT_TAB_PATTERN.test(lines[tabRow]))
+        return true;
+    if ((0, composer_text_1.findClaudeInputBox)(lines) !== null)
         return false;
-    const tabRow = (0, picker_chrome_1.findAskUserQuestionTabRow)(lines, questionRow, CLAUDE_SUBMIT_CONFIRM_TAB_LOOKBACK);
-    return tabRow >= 0 && CLAUDE_SUBMIT_TAB_PATTERN.test(lines[tabRow]);
+    return readsUpThroughReviewList(lines, question.top);
 }
 /**
  * §4 D1 決定 1: does this frame positively show that Claude's turn is over?