commandmate 0.47.0 → 0.48.0

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

@@ -16,6 +16,7 @@ exports.buildCompositeKey = buildCompositeKey;
 exports.extractWorktreeId = extractWorktreeId;
 exports.extractCliToolId = extractCliToolId;
 exports.extractInstanceId = extractInstanceId;
+exports.autoYesAnswerModeOf = autoYesAnswerModeOf;
 exports.isAutoYesExpired = isAutoYesExpired;
 exports.getAutoYesState = getAutoYesState;
 exports.setAutoYesEnabled = setAutoYesEnabled;
@@ -36,12 +37,14 @@ exports.getCompositeKeysByWorktree = getCompositeKeysByWorktree;
 exports.deleteAutoYesStateByWorktree = deleteAutoYesStateByWorktree;
 exports.getEnabledAutoYesByWorktree = getEnabledAutoYesByWorktree;
 exports.getRestartReleasedAutoYesByWorktree = getRestartReleasedAutoYesByWorktree;
+exports.getEnabledAutoYesAnswerModeByWorktree = getEnabledAutoYesAnswerModeByWorktree;
 exports.migrateAutoYesStateWorktreeIds = migrateAutoYesStateWorktreeIds;
 exports.calculateBackoffInterval = calculateBackoffInterval;
 const auto_yes_config_1 = require("../config/auto-yes-config");
 const path_validator_1 = require("./security/path-validator");
 const types_1 = require("./cli-tools/types");
 const logger_1 = require("../lib/logger");
+const auto_yes_answer_mode_1 = require("../types/auto-yes-answer-mode");
 const global_state_1 = require("./global-state");
 const logger = (0, logger_1.createLogger)('auto-yes-state');
 // =============================================================================
@@ -124,6 +127,14 @@ function extractInstanceId(compositeKey) {
     // parts[2] = alias instanceId; fall back to parts[1] (cliToolId) for primary keys.
     return parts[2] ?? parts[1] ?? null;
 }
+/**
+ * The answer mode a state stands for (Issue #3863): its own, or
+ * `recommended` for a state that predates the field. Not meaningful on a
+ * disabled state, whose mode a later enable does not inherit.
+ */
+function autoYesAnswerModeOf(state) {
+    return state.answerMode ?? auto_yes_answer_mode_1.DEFAULT_AUTO_YES_ANSWER_MODE;
+}
 /** In-memory storage for auto-yes states (globalThis for hot reload persistence) */
 const autoYesStates = (0, global_state_1.getOrInitGlobal)('__autoYesStates', () => new Map());
 // =============================================================================
@@ -196,10 +207,17 @@ function getAutoYesState(worktreeId, cliToolId = 'claude', instanceId) {
  *                   Defaults to DEFAULT_AUTO_YES_DURATION (1 hour) when omitted.
  * @param stopPattern - Optional regex pattern for stop condition (Issue #314).
  * @param instanceId - Optional instance identifier (Issue #896; defaults to primary).
- */
-function setAutoYesEnabled(worktreeId, cliToolId, enabled, duration, stopPattern, instanceId) {
+ * @param answerMode - Issue #3863: how questions are answered. Omitted, an
+ *   enable over a LIVE grant keeps that grant's mode, and any other enable —
+ *   from off, or over a grant that has run out — starts at `recommended`.
+ *   Whether the grant is live is read through {@link getAutoYesState}, which
+ *   turns an expired grant into a disabled one first, so an enable at or after
+ *   the deadline is a new grant, not a continuation. Ignored when disabling.
+ */
+function setAutoYesEnabled(worktreeId, cliToolId, enabled, duration, stopPattern, instanceId, answerMode) {
     const key = buildCompositeKey(worktreeId, cliToolId, instanceId);
     if (enabled) {
+        const current = answerMode === undefined ? getAutoYesState(worktreeId, cliToolId, instanceId) : null;
         const now = Date.now();
         const effectiveDuration = duration ?? auto_yes_config_1.DEFAULT_AUTO_YES_DURATION;
         const state = {
@@ -207,6 +225,7 @@ function setAutoYesEnabled(worktreeId, cliToolId, enabled, duration, stopPattern
             enabledAt: now,
             expiresAt: now + effectiveDuration,
             stopPattern,
+            answerMode: answerMode ?? (current?.enabled ? autoYesAnswerModeOf(current) : auto_yes_answer_mode_1.DEFAULT_AUTO_YES_ANSWER_MODE),
         };
         autoYesStates.set(key, state);
         notifyChangeAfterShutdown();
@@ -681,6 +700,35 @@ function getRestartReleasedAutoYesByWorktree() {
     }
     return byWorktree;
 }
+/**
+ * The answer mode of every armed instance, grouped by worktree and keyed by
+ * instance, for the worktree list (Issue #3863).
+ *
+ * Its own map rather than a field on {@link getEnabledAutoYesByWorktree}'s
+ * entries, whose `{ enabled, expiresAt }` shape the list pins (#2512). The same
+ * instances that map holds (armed, read through {@link getAutoYesState} so an
+ * expiry resolved at read time drops out), each with the mode it runs under.
+ *
+ * @returns worktreeId -> instanceId -> mode; worktrees with nothing armed are absent
+ */
+function getEnabledAutoYesAnswerModeByWorktree() {
+    const byWorktree = new Map();
+    // A snapshot of the keys: an expired read below rewrites its own entry.
+    for (const key of Array.from(autoYesStates.keys())) {
+        const cliToolId = extractCliToolId(key);
+        if (!cliToolId)
+            continue;
+        const worktreeId = extractWorktreeId(key);
+        const instanceId = extractInstanceId(key) ?? cliToolId;
+        const state = getAutoYesState(worktreeId, cliToolId, instanceId);
+        if (!state?.enabled)
+            continue;
+        const entries = byWorktree.get(worktreeId) ?? {};
+        entries[instanceId] = autoYesAnswerModeOf(state);
+        byWorktree.set(worktreeId, entries);
+    }
+    return byWorktree;
+}
 /**
  * Re-key every auto-yes state whose worktree ID is being renamed
  * (Issue #1621 Phase 3).

package/dist/server/src/lib/cli-tools/submit-verified-sender.js

@@ -289,7 +289,7 @@ function withoutTrailingBlankRows(lines) {
         end--;
     return lines.slice(0, end);
 }
-/** Default bounded read-back attempts before giving up (throwing). */
+/** Default bounded recovery Enters (each read back) before giving up (throwing). */
 const DEFAULT_VERIFY_ATTEMPTS = 4;
 /**
  * First non-blank line of the message, trimmed. This is what a TUI shows on the
@@ -427,12 +427,61 @@ function comparePasteToken(token, message) {
  * and its first line is the input line. Every other frame (a one-row
  * composer, an empty or ghost one, none at all, another tool) is read exactly
  * as before.
+ *
+ * Issue #3880 (H-2): this is also the reader before Enter
+ * ({@link classifyPasteLanded}) and in the error text ({@link describeComposer}).
+ * The paste check used to read the twelve-row tail with {@link readComposer}
+ * alone, so a codex composer taller than that window (a 20-line paste, or 600
+ * bytes wrapped in a narrow pane) put its `›` row above the window — `unseen`,
+ * and the body that was in the composer was withdrawn and reported as not
+ * landed — and a continuation row starting with `>` (a Markdown quote) was taken
+ * for the input line — `mismatch`. The same frame read after Enter was
+ * `pending`. One reader on both sides of Enter keeps the two verdicts about the
+ * same composer.
+ */
+/**
+ * Everything a codex composer holds, for deciding that a pasted body arrived in
+ * full (Issue #3880).
+ *
+ * `extractComposerText` answers for the UI: its text stops at 2,000 characters,
+ * at 40 rows and at the composer's first blank row, so a composer that matches
+ * it may still be missing the rest of the body — or hold something after it.
+ * This reads the raw rows instead, from the `›` row down to the last block of
+ * the frame (codex's model / cwd footer), so a body with blank lines, more than
+ * 40 rows or more than 2,000 characters is compared whole, and anything typed
+ * after the body is part of what is compared.
  */
+function codexComposerRegion(output) {
+    const raw = output.split('\n');
+    const box = (0, composer_text_1.findCodexInputBox)(raw);
+    if (box === null)
+        return null;
+    const isBlank = (row) => (0, cli_patterns_1.stripAnsi)(row).trim() === '';
+    let end = raw.length - 1;
+    while (end >= 0 && isBlank(raw[end]))
+        end--;
+    let lastBlockStart = end;
+    while (lastBlockStart > 0 && !isBlank(raw[lastBlockStart - 1]))
+        lastBlockStart--;
+    const stop = lastBlockStart > box.lastRow ? lastBlockStart - 1 : end;
+    const rows = raw.slice(box.firstRow, stop + 1).map((row) => (0, cli_patterns_1.stripAnsi)(row));
+    rows[0] = rows[0].replace(/^\s*\u203A ?/, '');
+    return rows.join('\n');
+}
 function readSubmitComposer(output, cliToolId, reader, lines, windowLines) {
     if (cliToolId === 'codex' && reader === 'input-line-marker') {
         const read = (0, composer_text_1.extractComposerText)(output, cliToolId);
-        if (read.state === 'content' && read.text.includes('\n')) {
-            return { kind: 'text', text: firstNonBlankLine(read.text), rows: read.text.split('\n') };
+        if (read.state === 'content') {
+            const region = codexComposerRegion(output) ?? read.text;
+            if (read.text.includes('\n')) {
+                return { kind: 'text', text: firstNonBlankLine(read.text), rows: read.text.split('\n'), region };
+            }
+            // Issue #3880 (N1): a one-row excerpt is read as before for its verdict
+            // after Enter, but still carries the whole region — `head` with the rest of
+            // the body under a blank row is one excerpt row and must not pass for the
+            // whole body before Enter.
+            const single = readComposer(reader, lines, windowLines);
+            return single.kind === 'text' ? { ...single, region } : single;
         }
     }
     return readComposer(reader, lines, windowLines);
@@ -530,14 +579,48 @@ function isSubmitted(output, cliToolId, message, composerSpec = (0, composer_spe
  *   3. Anything else — the idle placeholder, a ghost suggestion, no composer —
  *      shows nothing of the body. `unseen`, which the caller decides about.
  *
- * Reads the same tail window as {@link classifySubmit}, so a history echo of an
- * earlier message above the composer is never mistaken for this one.
+ * Reads the composer the way {@link classifySubmit} does
+ * ({@link readSubmitComposer}), so a history echo of an earlier message above the
+ * composer is never mistaken for this one, and a frame both functions see holds
+ * the same composer for both (Issue #3880). A multi-row codex composer is
+ * compared as a whole ({@link codexComposerRegion}), whitespace removed
+ * (wrapping and continuation indent proof): only the WHOLE body is `landed`;
+ * the body's beginning alone is `pasting` (never enough to press Enter on), the
+ * body plus anything else or text from inside it is `mismatch`. The whole body
+ * is checked before placeholders, so a body that itself quotes
+ * `[Pasted Content 600 chars]` is its own text, not codex's placeholder; a real
+ * placeholder is only ever the composer's first row.
  */
 function classifyPasteLanded(output, cliToolId, message, composerSpec = (0, composer_spec_1.resolveComposerSpec)(cliToolId)) {
     const lines = withoutTrailingBlankRows((0, cli_patterns_1.stripAnsi)(output).split('\n'));
-    const composer = readComposer(composerSpec.reader, lines, lines.slice(-VERIFY_WINDOW_LINES));
+    const composer = readSubmitComposer(output, cliToolId, composerSpec.reader, lines, lines.slice(-VERIFY_WINDOW_LINES));
     if (composer.kind !== 'text')
         return 'unseen';
+    if (composer.region !== undefined) {
+        const shown = compactText(composer.region);
+        const body = compactText(message);
+        if (shown === body)
+            return 'landed';
+        const placeholder = findPasteTokens(composer.text);
+        if (placeholder.tokens.length > 0) {
+            // A placeholder plus anything else — on its row or under it — is not the body as sent.
+            const below = compactText(composer.region.split('\n').slice(1).join('\n'));
+            if (placeholder.tokens.length > 1 || placeholder.rest !== '' || below !== '')
+                return 'mismatch';
+            return comparePasteToken(placeholder.tokens[0], message);
+        }
+        if (body.startsWith(shown))
+            return 'pasting';
+        // The body's beginning followed by something else, the body plus more, or a
+        // piece from inside it: the composer holds something other than the body.
+        if (inputMatchesBody(composer.text, message) || shown.startsWith(body) || body.includes(shown)) {
+            return 'mismatch';
+        }
+        return 'unseen';
+    }
+    // The whole body on one row is the body, even when it quotes a placeholder.
+    if (compactText(composer.text) === compactText(message))
+        return 'landed';
     const { tokens, rest } = findPasteTokens(composer.text);
     if (tokens.length === 0) {
         if (inputMatchesBody(composer.text, message))
@@ -591,9 +674,9 @@ async function pasteBody(sessionName, message) {
     }
 }
 /** The composer's first row, for an error message a person has to act on. */
-function describeComposer(output, composerSpec) {
+function describeComposer(output, cliToolId, composerSpec) {
     const lines = withoutTrailingBlankRows((0, cli_patterns_1.stripAnsi)(output).split('\n'));
-    const composer = readComposer(composerSpec.reader, lines, lines.slice(-VERIFY_WINDOW_LINES));
+    const composer = readSubmitComposer(output, cliToolId, composerSpec.reader, lines, lines.slice(-VERIFY_WINDOW_LINES));
     if (composer.kind === 'absent')
         return 'no composer on screen';
     if (composer.kind === 'empty')
@@ -666,7 +749,7 @@ async function confirmPasteLanded(params) {
     }
     const bytes = Buffer.byteLength(message, 'utf8');
     const lineCount = message.split('\n').length;
-    const shown = describeComposer(output, composer);
+    const shown = describeComposer(output, cliToolId, composer);
     await withdrawUnsentBody(sessionName, cliToolId, composer);
     (0, tmux_capture_cache_1.invalidateCache)(sessionName);
     logger.error('paste-not-landed', { sessionName, cliToolId, state, bytes, lines: lineCount, shown });
@@ -730,7 +813,7 @@ async function confirmTypedBodyLanded(params) {
             return;
     }
     const bytes = Buffer.byteLength(message, 'utf8');
-    const shown = describeComposer(output, composer);
+    const shown = describeComposer(output, cliToolId, composer);
     await withdrawUnsentBody(sessionName, cliToolId, composer);
     (0, tmux_capture_cache_1.invalidateCache)(sessionName);
     logger.error('typed-body-not-landed', { sessionName, cliToolId, bytes, attempts, shown });
@@ -819,9 +902,10 @@ async function clearComposerBeforeSend(sessionName, cliToolId, composerSpec = (0
  *
  * The body and Enter are always separate tmux commands (never batched), so the
  * TUI cannot swallow the Enter inside a bracketed-paste buffer. After the
- * initial submit the pane is read back up to `verifyAttempts` times; each time
- * it is still pending an extra Enter is sent. If submit can never be confirmed
- * the function THROWS — callers must surface that as a failure, never as
+ * initial submit the pane is read back; each time it is still pending an extra
+ * Enter is sent, up to `verifyAttempts` of them, and every Enter — the last one
+ * included (Issue #3880) — is read back before a verdict. If submit can never
+ * be confirmed the function THROWS — callers must surface that as a failure, never as
  * success (Issues #1469/#1470/#1471).
  *
  * A body longer than {@link LITERAL_SEND_MAX_BYTES} is pasted instead of typed,
@@ -884,8 +968,14 @@ async function sendMessageWithSubmitVerification(params) {
     }
     // 4. Read-back verification: confirm the message left the input box, resend
     //    Enter while it is still pending, and throw if it never submits.
+    //
+    //    Every Enter is followed by a read (Issue #3880, H-1): `attempts` resends
+    //    take `attempts + 1` reads. The loop used to resend on its last pending read
+    //    and throw straight after, so a message that only that last Enter submitted
+    //    was reported "could not be confirmed" — a sent message as exit 99. The
+    //    last read sends nothing: no Enter goes out that is not read back.
     const attempts = Math.max(1, verifyAttempts);
-    for (let attempt = 0; attempt < attempts; attempt++) {
+    for (let attempt = 0; attempt <= attempts; attempt++) {
         await new Promise((resolve) => setTimeout(resolve, verifyDelayMs));
         const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -composer.verifyCaptureLines });
         const state = classifySubmit(output, cliToolId, message, composer);
@@ -913,6 +1003,9 @@ async function sendMessageWithSubmitVerification(params) {
             logger.error('submit-replaced-by-tui-completion', { sessionName, cliToolId, attempt });
             throw new Error(`Message was replaced by a TUI autocompletion for session ${sessionName}; the input no longer matches the sent text. Cleared the input line without submitting to avoid executing a different command.`);
         }
+        // state === 'pending' after the final resend's read-back: give up below.
+        if (attempt === attempts)
+            break;
         // state === 'pending' — still typed-but-unsent, resend a single Enter and re-check.
         logger.warn('submit-not-confirmed:resending-enter', {
             sessionName,

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

@@ -715,7 +715,11 @@ function recordAnsweredPrompt(db, params) {
     }
     const answeredAt = new Date().toISOString();
     if (target) {
-        const updated = { ...target.parsed, status: 'answered', answer, answeredAt, answeredBy };
+        // Issue #3881 (review P2-2): the row keeps the reading it was saved with;
+        // one saved without a reading (before #3881) takes the answerer's, so a
+        // row's classification does not depend on which writer came first.
+        const reading = target.parsed.reading === undefined && promptData.reading !== undefined ? { reading: promptData.reading } : {};
+        const updated = { ...target.parsed, ...reading, status: 'answered', answer, answeredAt, answeredBy };
         updatePromptData(db, target.id, updated);
         return { message: getMessageById(db, target.id), created: false };
     }

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

@@ -21,6 +21,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_RUN_HISTORY_DAYS = exports.MAX_RUN_HISTORY_LIMIT = exports.DEFAULT_RUN_HISTORY_LIMIT = exports.VERIFICATION_GATE_SOURCES = exports.VERIFICATION_TRIGGERS = void 0;
+exports.parseGateTiming = parseGateTiming;
 exports.createVerificationRun = createVerificationRun;
 exports.finishVerificationRun = finishVerificationRun;
 exports.createGateResult = createGateResult;
@@ -54,6 +55,20 @@ exports.VERIFICATION_TRIGGERS = ['manual', 'wait', 'api', 'task'];
  * The runtime tuple mirrors the CHECK constraint in migration v56.
  */
 exports.VERIFICATION_GATE_SOURCES = ['builtin', 'verify.yaml', 'contract'];
+/**
+ * How much of a gate's `log_tail` the history listing reads: enough for the
+ * `[timing]` line, which is the last line — never the log body.
+ */
+const TIMING_TAIL_CHARS = 200;
+/** The last line of `logEnd`, when it is the runner's `[timing]` line. */
+const TIMING_LINE = /(?:^|\n)\[timing\] queue=(\d+(?:\.\d+)?)s mutex=(\d+(?:\.\d+)?)s run=(\d+(?:\.\d+)?)s\s*$/;
+/** The {@link VerificationGateTiming} of a gate whose `log_tail` ends with `logEnd`, or null. */
+function parseGateTiming(logEnd) {
+    const match = TIMING_LINE.exec(logEnd ?? '');
+    if (!match)
+        return null;
+    return { queueSec: Number(match[1]), mutexSec: Number(match[2]), runSec: Number(match[3]) };
+}
 const RUN_COLUMNS = `
   id, worktree_id, instance_id, task_id, trigger, status, base_ref, started_at, finished_at
 `;
@@ -247,7 +262,8 @@ function clampInt(value, fallback, min, max) {
 }
 /**
  * Recent runs across worktrees, newest first, each with its gate verdicts but
- * no log bodies (Issue #1593).
+ * no log bodies (Issue #1593). A gate's `[timing]` line is the one piece of its
+ * log that is carried, parsed into numbers (`timing`, Issue #3884).
  *
  * `worktreeId` is optional because the advisor that consumes this (#1594) looks
  * at a repository's trend, not one worktree's. Ordering follows the same
@@ -285,7 +301,8 @@ function listVerificationRunsForPeriod(db, opts = {}) {
     const placeholders = runRows.map(() => '?').join(', ');
     const gateRows = db
         .prepare(`
-      SELECT run_id, gate_id, status, exit_code, duration_ms, source
+      SELECT run_id, gate_id, status, exit_code, duration_ms, source,
+             substr(log_tail, -${TIMING_TAIL_CHARS}) AS log_end
       FROM verification_gate_results
       WHERE run_id IN (${placeholders})
       ORDER BY started_at ASC, id ASC
@@ -300,6 +317,10 @@ function listVerificationRunsForPeriod(db, opts = {}) {
             durationMs: row.duration_ms,
             source: row.source ?? null,
         };
+        // Only the numbers leave this function: the log stays out of the listing (#3884).
+        const timing = parseGateTiming(row.log_end);
+        if (timing)
+            summary.timing = timing;
         const bucket = byRun.get(row.run_id);
         if (bucket)
             bucket.push(summary);

package/dist/server/src/lib/detection/option-recommendation.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Which option of a question the question itself recommends (Issue #3863).
+ *
+ * Auto-Yes's `recommended` answer mode answers a question with the option
+ * whose TITLE ends in a recommendation marker — `(Recommended)`, `（推奨）` or
+ * `(推奨)`. The title, not the label as a whole: on Claude's and Command
+ * Code's pickers an option is a title row and, under it, a description, and a
+ * description may end in the same words (`… see Recommended Next Actions`),
+ * or quote the marker. So the readers that still know where a title ends —
+ * the block reader, Command Code's question reader and Claude's
+ * AskUserQuestion parser — say per option what its title shows:
+ *
+ * - `true`: the title ends in a marker;
+ * - `false`: it does not;
+ * - `'unknown'`: the reader could not tell the title from what follows it
+ *   (a continuation row that may be the title wrapping or a description).
+ *
+ * A reader never answers `false` for a title it could not delimit: a marker
+ * on the part it could not place would make "no option is recommended" (the
+ * default is then answered) a guess.
+ *
+ * The labels themselves, and every text a contract's deny patterns are
+ * matched against, are left as they were read.
+ *
+ * Leaf module: imports nothing.
+ *
+ * @module lib/detection/option-recommendation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRecommendedTitle = isRecommendedTitle;
+exports.isRecommendationMarker = isRecommendationMarker;
+exports.upperBoundColumns = upperBoundColumns;
+exports.lowerBoundPaneColumns = lowerBoundPaneColumns;
+exports.cannotBeWrapOf = cannotBeWrapOf;
+/**
+ * A marker at the very end of a title, standing on its own: what precedes it
+ * is the start of the title, white space, or anything but an ASCII letter or
+ * digit (`dispatch (Recommended)`, `する（推奨）`), never a word it is glued
+ * to (`Not(Recommended)`). Case as the tools write it. Anchored, no nested
+ * quantifiers (ReDoS-safe).
+ */
+const RECOMMENDATION_MARKER_PATTERN = /(?:^|[^A-Za-z0-9])(?:\(Recommended\)|（推奨）|\(推奨\))$/;
+/**
+ * Whether a title — the option's whole title, wrapped rows joined — ends in a
+ * recommendation marker.
+ *
+ * @param title - The option's title, without its number or cursor
+ */
+function isRecommendedTitle(title) {
+    return RECOMMENDATION_MARKER_PATTERN.test(title.trim());
+}
+/** The markers, as a row holding nothing else spells them. */
+const RECOMMENDATION_MARKERS = new Set(['(Recommended)', '（推奨）', '(推奨)']);
+/**
+ * Whether a row holds a marker and nothing else — the tail of a title that
+ * wrapped right before its marker (`❯ 1. 整えた状態で続行` / `(Recommended)`).
+ */
+function isRecommendationMarker(row) {
+    return RECOMMENDATION_MARKERS.has(row.trim());
+}
+/** One code point that occupies no terminal column. */
+const COMBINING_MARK = /^\p{M}$/u;
+/**
+ * An UPPER bound on the columns a row occupies: printable ASCII is one
+ * column, a combining mark none, and anything else is counted as two (East
+ * Asian wide characters are two; no other code point is wider). Used with a
+ * LOWER bound on the pane width, so "it would have fit" is never claimed for
+ * a row that might not have.
+ */
+function upperBoundColumns(text) {
+    let columns = 0;
+    for (const char of text) {
+        const code = char.codePointAt(0) ?? 0;
+        if (code >= 0x20 && code < 0x7f)
+            columns += 1;
+        else if (!COMBINING_MARK.test(char))
+            columns += 2;
+    }
+    return columns;
+}
+/**
+ * A LOWER bound on the pane width: the widest row of the frame, counting one
+ * column per code point (combining marks none). A row the pane drew is never
+ * wider than the pane.
+ */
+function lowerBoundPaneColumns(rows) {
+    let widest = 0;
+    for (const row of rows) {
+        let columns = 0;
+        for (const char of row.trimEnd()) {
+            if (!COMBINING_MARK.test(char))
+                columns += 1;
+        }
+        if (columns > widest)
+            widest = columns;
+    }
+    return widest;
+}
+/**
+ * Whether `next` cannot be the wrapped tail of `row` — the pane would have
+ * kept `next`'s first word on `row`.
+ *
+ * Terminals word-wrap a title: a row ends early only when the following word
+ * would not fit. So when `row` plus a space plus that word fits inside the
+ * pane, `row` did not wrap there and `next` begins something else (the
+ * option's description). Judged with an upper bound on what the row and the
+ * word occupy and a lower bound on the pane, so a `true` is never a guess; a
+ * `false` only says the row MAY have wrapped.
+ *
+ * @param row - The option's row, as drawn (indent and number included)
+ * @param next - The row under it
+ * @param paneColumns - {@link lowerBoundPaneColumns} of the frame
+ */
+function cannotBeWrapOf(row, next, paneColumns) {
+    const firstWord = next.trim().split(/\s+/, 1)[0] ?? '';
+    if (firstWord === '')
+        return false;
+    return upperBoundColumns(row.trimEnd()) + 1 + upperBoundColumns(firstWord) <= paneColumns;
+}