commandmate 0.47.2 → 0.49.0

package/dist/server/src/lib/detection/prompt-detect-multiple-choice-approval-context.js

@@ -0,0 +1,290 @@
+"use strict";
+/** Approval-context boundary logic split out of prompt-detect-multiple-choice.ts (Issue #3866). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APPROVAL_TARGET_MAX_LOOKBACK = exports.SEPARATOR_LINE_PATTERN = void 0;
+exports.indentOf = indentOf;
+exports.panelFrameIndent = panelFrameIndent;
+exports.findApprovalContextStart = findApprovalContextStart;
+exports.findApprovalContextRange = findApprovalContextRange;
+exports.findYesNoApprovalContextRange = findYesNoApprovalContextRange;
+exports.joinApprovalTarget = joinApprovalTarget;
+/**
+ * Pattern for separator lines (horizontal rules).
+ * Matches lines consisting only of dash (-) or em-dash (─) characters.
+ * Used to skip separator lines in question extraction and non-option line handling.
+ * Anchored at both ends -- ReDoS safe (S4-001).
+ */
+exports.SEPARATOR_LINE_PATTERN = /^[-─]+$/;
+/**
+ * Lines that mean "the previous turn ended here" when scanning upward.
+ *
+ * Every supported CLI renders its transcript as marker-prefixed rows — Claude's
+ * tool-use `⏺` and result `⎿`, Codex's activity `•`, its approval receipts `✔`
+ * / `✗`, the user's own `›` / `❯` / `>` echo, and its output continuation `└`.
+ * The lines a prompt panel puts above its question (a header such as "Bash
+ * command", the command itself, a one-line description) never carry one, which
+ * is what makes this usable as the panel's upper edge after `stripBoxDrawing`
+ * has erased the real box border.
+ *
+ * Horizontal rules count too: Codex draws one between turns.
+ *
+ * [Issue #3817] Not inside the panel's own frame: the command a panel shows can
+ * carry the same glyphs (a here-document's `> quoted` rows), drawn deeper than
+ * the panel's header, question and option rows. See
+ * {@link findApprovalContextStart}.
+ *
+ * Anchored at the start of the trimmed line — ReDoS safe (no repetition).
+ */
+const TURN_BOUNDARY_PATTERN = /^[⏺⎿●○•✔✓✖✗✘›»❯└├>]/;
+/**
+ * How far above the question the approval context may reach (Issue #1699).
+ *
+ * The boundary marker above is the actual fix; this cap only exists so a frame
+ * that happens to contain no marker at all (a bare shell `(y/n)` prompt under
+ * plain command output) cannot drag an unbounded scrollback window into the
+ * deny surface the way the old fixed 19-line lookback did. Sized for the
+ * tallest real permission panel measured: header + blank + a wrapped multi-line
+ * command + description + blank.
+ */
+exports.APPROVAL_TARGET_MAX_LOOKBACK = 12;
+/**
+ * A previous tool call's result row (Issue #3817): claude's `⎿`, codex's `└` /
+ * `├` output continuation. Never the user's echo or a quote (`>`).
+ */
+const RESULT_MARKER_PATTERN = /^[⎿└├]/;
+/** Width of a row's leading whitespace. */
+function indentOf(line) {
+    return line.length - line.trimStart().length;
+}
+/**
+ * The column the dialog's own frame is drawn at (Issue #3817): the least
+ * indented non-blank row from the question down to `panelEnd`. Those rows are
+ * the question, the option block and the footer — claude puts them at column 1
+ * and the command at column 3, codex its `› 1.` cursor at column 0.
+ */
+function panelFrameIndent(lines, questionLineIndex, panelEnd) {
+    let indent = Infinity;
+    for (let i = questionLineIndex; i < Math.min(panelEnd, lines.length); i++) {
+        const line = lines[i];
+        if (line === undefined || line.trim() === '')
+            continue;
+        indent = Math.min(indent, indentOf(line));
+    }
+    return indent === Infinity ? 0 : indent;
+}
+/** True when this line carries a transcript marker or is a rule. */
+function isTurnBoundaryLine(rawLine) {
+    if (rawLine === undefined)
+        return false;
+    const line = rawLine.trim();
+    if (line === '')
+        return false;
+    return TURN_BOUNDARY_PATTERN.test(line) || exports.SEPARATOR_LINE_PATTERN.test(line);
+}
+/**
+ * First line index that still belongs to *this* prompt, scanning upward.
+ *
+ * Walks up from `questionLineIndex - 1` and stops just below the nearest turn
+ * boundary; with no boundary in reach it falls back to the lookback cap.
+ * Everything above the returned index is a previous turn and must never reach a
+ * deny pattern — that poisoning is Issue #1699.
+ *
+ * [Issue #3817] A marker row indented deeper than the dialog's frame
+ * ({@link panelFrameIndent}) is the body of the command the panel asks about
+ * when a frame row sits above it — the `> quoted` rows of a here-document
+ * under a claude panel's ` Bash command` header. Cutting there took the command
+ * rows above it out of the deny surface. The previous turn's markers are drawn
+ * at or left of the frame (`⏺`, the user's `> msg` / `❯ msg` echo, a rule), or
+ * deeper with no frame row above them (claude's `  ⎿` result right under its
+ * `⏺`), and both still end the scan.
+ *
+ * A frame row cannot be told from a body row drawn at the frame's column (a
+ * shell here-document's `EOF`), so a frame row is taken as an older panel's
+ * header only in one shape: a tool-use block — a marker row at the frame's
+ * column, then that row, then deeper rows that are all result markers
+ * ({@link RESULT_MARKER_PATTERN}). Anything else between two frame rows is read
+ * as body: when the screen cannot tell, the deny surface is taken wide.
+ *
+ * [Issue #3832] That shape also needs the older header to be one the current
+ * panel draws below it (agy's `Command` above `  ⎿ User declined the tool
+ * call` above its current `Command`). A body can take the shape too — a
+ * 0-column command whose output is an indented `└──` tree, under a `●` row —
+ * and cutting there dropped the command from the deny surface. A body that
+ * repeats the current header word for word is still cut; the screen cannot
+ * tell that one apart.
+ *
+ * Known limits, measured absent on the claude / codex / agy / copilot /
+ * opencode fixtures and the production log (Issue #3832) and left alone:
+ * - An older block's result with a row that is not a result marker (an
+ *   unmarked continuation `     b` under `  ⎿ a`) under a header the current
+ *   panel repeats is read as body: the previous turn enters the deny surface
+ *   (over-suppresses).
+ * - A body row carrying a marker at the frame's own column (a here-document's
+ *   `> ` drawn at column 0 under a yes/no `(y/n)`) still ends the scan; the
+ *   screen cannot tell it from the previous turn's echo. The command rows
+ *   above the `> ` leave `approvalTarget`, and a yes/no `question` is the
+ *   prompt line alone. Issue #3881 (the second half) no longer lets that be
+ *   an answer: the yes/no path ({@link findYesNoApprovalContextRange}) reads
+ *   a scan that stopped on a `>` row as `truncated`, so a deny miss withholds
+ *   instead of passing. The boundary itself is left where it was.
+ * - agy's older panel under a header the current one does not draw is read as
+ *   body (over-suppresses), as is the first limit above; both stay.
+ *
+ * Shared by both detector paths: multiple_choice passes its `questionEndIndex`,
+ * yes_no the line its pattern matched on.
+ *
+ * @param lines - Full frame, already ANSI/box stripped
+ * @param questionLineIndex - Line the prompt's own question sits on
+ * @param panelEnd - Exclusive end of the dialog's own rows (Issue #3817); their
+ *   least indented row is the frame. Defaults to the question row alone.
+ * @returns Index of the first line of the current prompt's own block
+ */
+function findApprovalContextStart(lines, questionLineIndex, panelEnd = questionLineIndex + 1) {
+    return findApprovalContextRange(lines, questionLineIndex, panelEnd).start;
+}
+/**
+ * Where {@link findApprovalContextStart} put the top of the approval context,
+ * and whether that top is a boundary (Issue #3881, H-3).
+ *
+ * The start index alone cannot say it. A scan that runs out at
+ * {@link APPROVAL_TARGET_MAX_LOOKBACK} returns the same kind of number as one
+ * that stopped at the previous turn's marker, and `joinApprovalTarget` turns
+ * either into an ordinary string — so a deny pattern whose only match is the
+ * 13th row above a yes/no question missed, and the resolver took the miss as
+ * a pass. The completeness travels with the start instead:
+ *
+ * - `complete` — the scan stopped at a boundary (a marker at the frame, an
+ *   older tool-use block);
+ * - `truncated` — it ran out at the cap with a non-blank row still above it;
+ * - `top-unknown` — it reached the frame's first row without a boundary.
+ *
+ * A scan that ran out at the cap over blank rows only is `complete`: nothing
+ * above it could belong to the panel.
+ */
+function findApprovalContextRange(lines, questionLineIndex, panelEnd = questionLineIndex + 1) {
+    const { start, completeness } = scanApprovalContext(lines, questionLineIndex, panelEnd);
+    return { start, completeness };
+}
+/** {@link findApprovalContextRange}, with the row the scan stopped on (Issue #3881). */
+function scanApprovalContext(lines, questionLineIndex, panelEnd) {
+    const floor = Math.max(0, questionLineIndex - exports.APPROVAL_TARGET_MAX_LOOKBACK);
+    const frameIndent = panelFrameIndent(lines, questionLineIndex, panelEnd);
+    // The lowest deeper marker row with no frame row found above it yet.
+    let unenclosed = -1;
+    // The deeper rows since the last frame row: are they all result markers?
+    let segmentRows = 0;
+    let segmentAllResults = true;
+    // Frame rows already passed: the current panel's header among them.
+    const framesBelow = new Set();
+    for (let i = questionLineIndex - 1; i >= floor; i--) {
+        const line = lines[i];
+        if (line === undefined || line.trim() === '')
+            continue;
+        const atFrame = indentOf(line) <= frameIndent;
+        const marker = isTurnBoundaryLine(line);
+        if (marker && atFrame) {
+            return { start: (unenclosed >= 0 ? unenclosed : i) + 1, completeness: 'complete', cutFrom: i };
+        }
+        if (!atFrame) {
+            if (marker && unenclosed < 0)
+                unenclosed = i;
+            segmentRows++;
+            segmentAllResults &&= RESULT_MARKER_PATTERN.test(line.trim());
+            continue;
+        }
+        // A frame row: an older tool-use block's header only in that one shape,
+        // and only when the current panel draws the same header (Issue #3832).
+        const frameText = line.trim();
+        if (unenclosed >= 0 && segmentRows > 0 && segmentAllResults && framesBelow.has(frameText)
+            && isMarkerRowAtFrameAbove(lines, i, floor, frameIndent)) {
+            return { start: unenclosed + 1, completeness: 'complete', cutFrom: i };
+        }
+        framesBelow.add(frameText);
+        unenclosed = -1;
+        segmentRows = 0;
+        segmentAllResults = true;
+    }
+    return {
+        start: unenclosed >= 0 ? unenclosed + 1 : floor,
+        completeness: scanEndCompleteness(lines, floor),
+        cutFrom: floor,
+    };
+}
+/**
+ * A here-document's continuation rows, or a quotation: `>` at the start of a
+ * row is the one marker a shell's own output draws (PS2), so a scan that
+ * stops on it may have stopped inside the command (Issue #3881).
+ */
+const AMBIGUOUS_BOUNDARY_PATTERN = /^>/;
+/**
+ * {@link findApprovalContextRange} for a yes/no prompt (Issue #3881, the
+ * second half: limit 3 of #3832).
+ *
+ * A yes/no prompt has no panel of its own, so its frame is the prompt line's
+ * column, and a here-document's `> ` continuation rows drawn at that column
+ * end the scan exactly like the previous turn's `> msg` echo: the screen
+ * cannot tell the two apart. The same holds for a deeper `> ` row that set
+ * the start under a `●` boundary (a here-document indented under its command,
+ * review N2). Cut at such a row, the boundary is not known
+ * to be the previous turn's, so the target is `truncated` — not the whole
+ * request: a deny pattern that misses it withholds as `deny-pattern-unusable`
+ * rather than passing (the resolver's `approvalTargetCompleteness`). The
+ * boundary is not moved: widening the target past a real echo would put the
+ * previous turn's text on the deny surface (#1699).
+ *
+ * Multiple choice keeps {@link findApprovalContextRange}: its panels draw the
+ * command deeper than their frame (#3817), and claude's legacy `> msg` echo at
+ * the frame is a real boundary there.
+ */
+function findYesNoApprovalContextRange(lines, promptLine, panelEnd) {
+    const { start, completeness, cutFrom } = scanApprovalContext(lines, promptLine, panelEnd);
+    // Review N2: every row that was cut, not only the row the scan stopped on —
+    // a deeper `> ` row (a here-document indented under its command) sets the
+    // start below the boundary, and the command above it is cut with it.
+    const cutByQuote = lines
+        .slice(cutFrom, start)
+        .some(row => row !== undefined && AMBIGUOUS_BOUNDARY_PATTERN.test(row.trim()));
+    // Review N4: whatever the scan's own end said. A scan that ran up to the
+    // frame's first row (`top-unknown`) still cut those rows inside the frame,
+    // and a capture known to start at the history's top would otherwise clear
+    // it (`withCaptureTopCompleteness` adds nothing to a `history-start`): the
+    // cut is a fact about rows on screen, not about the capture's top.
+    if (cutByQuote) {
+        return { start, completeness: 'truncated' };
+    }
+    return { start, completeness };
+}
+/** How complete a scan that ran down to `floor` without a boundary is (Issue #3881). */
+function scanEndCompleteness(lines, floor) {
+    if (floor === 0)
+        return 'top-unknown';
+    for (let i = 0; i < floor; i++) {
+        const line = lines[i];
+        if (line !== undefined && line.trim() !== '')
+            return 'truncated';
+    }
+    return 'complete';
+}
+/** True when the nearest non-blank row above `row` is a marker row at the frame's column. */
+function isMarkerRowAtFrameAbove(lines, row, floor, frameIndent) {
+    for (let i = row - 1; i >= floor; i--) {
+        const line = lines[i];
+        if (line === undefined || line.trim() === '')
+            continue;
+        return indentOf(line) <= frameIndent && isTurnBoundaryLine(line);
+    }
+    return false;
+}
+/**
+ * Join a slice of the frame into an approval-target string.
+ *
+ * @returns The trimmed block, or undefined when it is empty
+ */
+function joinApprovalTarget(lines, start, end) {
+    const joined = lines
+        .slice(start, end)
+        .map(l => l.trimEnd())
+        .join('\n')
+        .trim();
+    return joined.length > 0 ? joined : undefined;
+}

package/dist/server/src/lib/detection/prompt-detect-multiple-choice-chrome.js

@@ -0,0 +1,193 @@
+"use strict";
+/** Claude chrome (task panel, session-diff HUD, preview pane) split out of prompt-detect-multiple-choice.ts (Issue #3924). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUMMARY_LINE_PATTERN = void 0;
+exports.findClaudeTaskPanelLines = findClaudeTaskPanelLines;
+exports.findClaudeChrome = findClaudeChrome;
+exports.maskClaudeChrome = maskClaudeChrome;
+const picker_chrome_1 = require("./tools/claude/picker-chrome");
+/**
+ * [Issue #704] Pattern for Claude Code v2.1.142 prompt summary lines such as
+ *   "  … +1 pending"
+ *   "  +2 pending"
+ *   "  ↑3 more"
+ *   "  ↓1 more"
+ * These lines are rendered BELOW the real options when Claude collapses the
+ * remaining choices. They are not selectable options and must be skipped by
+ * Pass 2 — otherwise NORMAL_OPTION_PATTERN matches them as option N with
+ * label "pending"/"more", and the resulting (number, label) tuple poisons
+ * isValidPrecedingOption() so that the real 1./2./3. options above are all
+ * rejected (collectedOptions ends up with length 1 and Layer 4 returns
+ * no_prompt).
+ *
+ * Scope of the pattern (FP suppression is critical):
+ *   - Anchored at line start (^) and requires the trailing keyword to be
+ *     `pending` or `more` followed by a word boundary (\b). This intentionally
+ *     prevents matching legitimate option labels that mention these words
+ *     mid-sentence (e.g. `2. Postpone (will remain pending)`,
+ *     `3. Show me more`) — those still flow through NORMAL_OPTION_PATTERN.
+ *   - Optional leading ellipsis (… U+2026) and optional collapse direction
+ *     marker (+ - ↑ ↓ ⏵ ⏷) accept the variants observed in the wild.
+ *   - [Issue #1708] `completed` joined `pending`/`more` after a live capture
+ *     (fixtures/claude-live-1708) showed the task panel collapsing FINISHED
+ *     rows as `… +2 completed`. That wording was outside the #704 guard, so it
+ *     reached Pass 2 and was collected as `option 2 / label='completed'` —
+ *     poisoning isValidPrecedingOption() exactly as `… +1 pending` used to.
+ *   - The pattern deliberately omits any free `(.+)` capture — it must
+ *     short-circuit, not extract data.
+ *
+ * Pattern shape: linear regex with no nested quantifiers — ReDoS safe (S4-001).
+ */
+exports.SUMMARY_LINE_PATTERN = /^\s*[…]?\s*[+\-↑↓⏵⏷]?\s*\d+\s+(?:pending|more|completed)\b/i;
+/**
+ * [Issue #1708] Header row of Claude Code's bottom-anchored task panel, e.g.
+ *   "  7 tasks (0 done, 1 in progress, 6 open)"
+ *
+ * The panel is an overlay pinned to the LAST rows of the pane, structurally
+ * unrelated to whatever the agent is currently blocked on. In a production pane
+ * (200x1000, alternate screen) a prompt dialog therefore renders near the top and
+ * the panel ~880 blank rows below it — rows `compactBlankRows` collapses to one,
+ * putting the panel squarely inside Pass 2's 50-line reverse-scan window.
+ *
+ * That is only harmless while something trims it away. #704/#807 trim at a
+ * footer, but the AskUserQuestion *confirmation* step ("Ready to submit your
+ * answers?") renders NEITHER footer, so nothing trims and the panel is the first
+ * thing the reverse scan meets. Measured on the live capture in
+ * fixtures/claude-live-1708/askuserquestion-submit-taskpanel.txt, two of its rows
+ * match NORMAL_OPTION_PATTERN independently:
+ *   - this header      → option 7,  label "tasks (2 done, 1 in progress, 4 open)"
+ *   - "… +2 completed" → option 2,  label "completed"
+ * Either one alone is enough to make isValidPrecedingOption() reject the real
+ * `❯ 1. Submit answers` / `2. Cancel` above it, so collectedOptions never reaches
+ * 2 and the frame is published as "no prompt" — Issue #1708's silent timeout.
+ *
+ * Anchored at line start and requires the literal `tasks (` + `<n> done`, which
+ * no option label produced by any supported CLI carries. ReDoS safe (S4-001):
+ * bounded repetition, no nesting.
+ */
+const CLAUDE_TASK_PANEL_HEADER_PATTERN = /^\s*\d{1,3}\s+tasks?\s+\(\d+\s+done\b/i;
+/**
+ * [Issue #1708] A single task row of the panel described above, e.g. "  ◼ Phase 3".
+ *
+ * Today these rows are inert — `isContinuationLine()` already absorbs them — but
+ * only because none of the observed titles begins with a digit. A title like
+ * "2. Fix the parser" would render as "  ◻ 2. Fix the parser" and be collected as
+ * option 2, reintroducing the same poisoning from a direction no single-line
+ * guard anticipates. Skipping the whole panel block closes that off structurally
+ * instead of one wording at a time.
+ *
+ * The glyph set is exactly the two forms measured on a live pane — ◼ (in
+ * progress) and ◻ (open) — and nothing else. Every extra glyph is a line this
+ * guard can delete from the frame, so the set is an allowlist of things seen,
+ * not a guess at what the family might contain:
+ *
+ *   - ❯ ● › are DEFAULT_OPTION_PATTERN's cursor indicators.
+ *   - ⏺ ⎿ ✔ ✗ are the transcript markers TURN_BOUNDARY_PATTERN reads.
+ *   - ☐ ☑ ☒ are the natural rendering of a MULTI-SELECT choice, and
+ *     AskUserQuestion has a multiSelect mode. Measured: with those in the set,
+ *     `☐ 1. Blue / ☑ 2. Green / ☐ 3. Red` under a panel header is claimed as
+ *     panel content and the prompt above it disappears entirely
+ *     (isPrompt=false, zero options) — Issue #1708's own failure, recreated by
+ *     its fix. See the regression test.
+ *
+ * A completed row never appears (the panel collapses those into `… +N
+ * completed`, which SUMMARY_LINE_PATTERN handles), so no done-marker is needed.
+ * An unmatched glyph simply ends the block, which is the safe direction: those
+ * rows go back to being handled exactly as they were before this guard existed.
+ *
+ * To widen this, capture a live pane that actually renders the new glyph and add
+ * it as a fixture. Do not widen it from the shape of the character.
+ */
+const CLAUDE_TASK_PANEL_ROW_PATTERN = /^\s*[◼◻]\s/;
+/**
+ * [Issue #2468] Claude Code 2.1.267's session-diff HUD row, in the two
+ * spellings measured on a live pane (tests/fixtures/claude-live-2468):
+ *   "No changes this session"
+ *   "+28 files edited before this session (show)"
+ *
+ * Chrome like the task panel, but a single row and RIGHT-aligned: on a
+ * 200-column pane it is ~110 columns of padding and then the text. It is
+ * therefore matched on the trimmed row — a reader that slices the row from the
+ * left sees nothing but blanks.
+ *
+ * It broke two readers. Pass 2 below parses `+2 files edited …` as option 2,
+ * which poisons the real `1. / 2.` above it the way `… +2 completed` did in
+ * #1708. And `findClaudeTranscriptTail` took it for the last transcript row, so
+ * `detectClaudeDialog` read it as the footer of the AskUserQuestion
+ * confirmation screen — a dialog that draws no footer — and refused a dialog
+ * that was open on screen: Auto-Yes, the UI's answer and `commandmate respond`
+ * all got `prompt_no_longer_active`.
+ *
+ * `files?` is the one spelling not seen on a pane: a one-file session was not
+ * captured, and the singular is accepted so that it is not the case that
+ * regresses. Everything else is literal, for the same reason the glyph set
+ * above is an allowlist. Anchored at both ends, no nested quantifiers — ReDoS
+ * safe (S4-001).
+ */
+const CLAUDE_SESSION_DIFF_HUD_PATTERN = /^(?:No changes this session|\+\d+ files? edited before this session \(show\))$/;
+/**
+ * Line indices belonging to Claude's bottom-pinned panels within [start, end).
+ *
+ * Two panels, both chrome rather than transcript or prompt:
+ *  - the task panel (#1708). Walks down from each header row for as long as
+ *    rows keep looking like panel content (task rows or the collapsed `… +N …`
+ *    summary). The first line that is neither ends the block, so a panel that
+ *    abuts other content cannot swallow it.
+ *  - the session-diff HUD (#2468), a single row claimed on its own.
+ *
+ * Pass 2 here, `findClaudeTranscriptTail` and `detectClaudeDialog`'s footer
+ * guard all read this one set — through {@link findClaudeChrome}, which adds an
+ * AskUserQuestion preview pane to it (Issue #2486) — so they cannot disagree
+ * about which rows are chrome.
+ *
+ * @param lines - Full frame, already ANSI/box stripped
+ * @param start - First index to consider (inclusive)
+ * @param end - Last index to consider (exclusive)
+ * @returns Indices Pass 2 must treat as metadata rather than options
+ */
+function findClaudeTaskPanelLines(lines, start, end) {
+    const panelLines = new Set();
+    for (let i = Math.max(0, start); i < Math.min(end, lines.length); i++) {
+        if (CLAUDE_SESSION_DIFF_HUD_PATTERN.test(lines[i].trim())) {
+            panelLines.add(i);
+            continue;
+        }
+        if (!CLAUDE_TASK_PANEL_HEADER_PATTERN.test(lines[i]))
+            continue;
+        panelLines.add(i);
+        for (let j = i + 1; j < Math.min(end, lines.length); j++) {
+            const row = lines[j];
+            if (!CLAUDE_TASK_PANEL_ROW_PATTERN.test(row) && !exports.SUMMARY_LINE_PATTERN.test(row))
+                break;
+            panelLines.add(j);
+        }
+    }
+    return panelLines;
+}
+/**
+ * Claude's chrome within [start, end). See {@link ClaudeChrome}.
+ *
+ * @param lines - Full frame, ANSI stripped; box drawing optional
+ * @param start - First index to consider (inclusive)
+ * @param end - Last index to consider (exclusive)
+ */
+function findClaudeChrome(lines, start, end) {
+    const rows = findClaudeTaskPanelLines(lines, start, end);
+    const panes = (0, picker_chrome_1.findClaudePreviewPanes)(lines, start, end);
+    for (const row of panes.rows)
+        rows.add(row);
+    return { rows, cuts: panes.cuts };
+}
+/**
+ * The frame with Claude's chrome taken out: chrome rows blank, rows shared with
+ * the preview pane cut back to the options column. Row indices are unchanged,
+ * so a reader of the result can report positions in the original frame.
+ */
+function maskClaudeChrome(lines, chrome) {
+    return lines.map((line, i) => {
+        if (chrome.rows.has(i))
+            return '';
+        const cut = chrome.cuts.get(i);
+        return cut === undefined ? line : line.slice(0, cut).trimEnd();
+    });
+}