commandmate 0.33.3 → 0.34.1

package/dist/server/src/lib/cli-tools/antigravity.js

@@ -8,14 +8,19 @@
  *   conversation area (grows downward) | bare "> " input box | status bar
  * The status bar reads "? for shortcuts ... <model>" when idle and
  * "esc to cancel ..." while generating. Patterns confirmed on a real machine.
+ * agy 1.2.1 leaves the idle half of that bar blank after a turn that used a
+ * tool (Issue #2478), so readiness is read off the input box — see
+ * {@link isAntigravityReady}.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AntigravityTool = void 0;
+exports.isAntigravityReady = isAntigravityReady;
 const base_1 = require("./base");
 const tmux_1 = require("../tmux/tmux");
 const submit_verified_sender_1 = require("./submit-verified-sender");
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const cli_patterns_1 = require("../detection/cli-patterns");
+const frame_1 = require("../detection/tools/frame");
 const sources_1 = require("../../lib/hooks/sources");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const logger_1 = require("../../lib/logger");
@@ -51,10 +56,14 @@ const ANTIGRAVITY_INIT_MAX_ATTEMPTS = 30;
 /** Timeout for waiting for the prompt before sending a message. */
 const ANTIGRAVITY_PROMPT_WAIT_TIMEOUT_MS = 15000;
 /**
- * Idle REPL footer marker. agy shows "? for shortcuts" in the status bar ONLY
- * when the input prompt is live and ready — not during the startup trust dialog
- * (which shows "↑/↓ Navigate · enter Confirm") nor while generating (which shows
- * "esc to cancel"). So this is a reliable "ready" signal. (Confirmed on machine.)
+ * agy's own word for "idle", drawn on the status row under the input box
+ * ("? for shortcuts … <model>"). While generating the same row reads "esc to
+ * cancel"; the trust screen and the dialogs draw their own footers instead.
+ *
+ * Issue #2478: sufficient, no longer required. agy 1.2.1 does not redraw it
+ * after a turn that used a tool — the row keeps only the right-aligned model
+ * label (`tests/fixtures/antigravity-live-2478/after-tool-turn.txt`) — and a
+ * send that waited for it timed out on every later turn of that session.
  */
 const ANTIGRAVITY_READY_FOOTER_PATTERN = /\?\s+for\s+shortcuts/;
 /**
@@ -69,12 +78,88 @@ const ANTIGRAVITY_READY_FOOTER_PATTERN = /\?\s+for\s+shortcuts/;
  */
 const ANTIGRAVITY_TRUST_DIALOG_PATTERN = /Do you trust the contents of this project\?/;
 /**
- * Decide whether agy is at a genuine, ready input prompt.
- * The idle footer is present AND no trust dialog is awaiting confirmation.
+ * Read agy's input box off the bottom of a frame (Issue #2478).
+ *
+ * agy draws the box — a bare `>` between two rules, its status row under the
+ * lower one — as the last thing on the screen, and everything else it can show
+ * either replaces the box (the permission dialogs, the trust screen, the
+ * post-answer survey) or is drawn below it (the `/model` picker, the slash
+ * command popup, `/feedback`'s category menu). So a frame that ENDS in the box
+ * is one whose input box is live, and a `>` row with more than the status row
+ * under it is not a box anyone can type into.
+ *
+ * This is stricter than the status detector's `promptPattern.test(lastLines)`
+ * (`detection/tools/antigravity/detect.ts`), which accepts the `>` anywhere in
+ * the 15-row tail: the detector tells `/feedback`'s menu apart only in the
+ * shared generic prompt step that runs before it, and this check does not run
+ * that step. The rows between the `>` and the lower rule may be blank — agy
+ * 1.2.1 leaves the box three rows tall after a tool turn.
+ *
+ * @param contentLines - ANSI-stripped rows, trailing blank rows dropped
+ * @returns The status row under the box ('' when agy drew none), or null when
+ *   the frame does not end in the box
+ */
+function readInputBoxStatusRow(contentLines) {
+    const rows = contentLines.map((row) => row.trim());
+    const isRule = (i) => i >= 0 && cli_patterns_1.ANTIGRAVITY_SEPARATOR_PATTERN.test(rows[i]);
+    const skipBlank = (from) => {
+        let i = from;
+        while (i >= 0 && rows[i] === '')
+            i--;
+        return i;
+    };
+    let i = rows.length - 1;
+    let statusRow = '';
+    if (i >= 0 && !isRule(i)) {
+        statusRow = rows[i];
+        i = skipBlank(i - 1);
+    }
+    if (!isRule(i))
+        return null;
+    i = skipBlank(i - 1);
+    if (i < 0 || !cli_patterns_1.ANTIGRAVITY_PROMPT_PATTERN.test(rows[i]))
+        return null;
+    return isRule(skipBlank(i - 1)) ? statusRow : null;
+}
+/**
+ * Decide whether a typed message would land in agy's input box (Issue #2478).
+ *
+ * Read on the status detector's evidence (`detection/tools/antigravity/detect.ts`)
+ * over the status detector's frame (`normalizeFrame`: ANSI stripped, padding
+ * dropped, the same 15-row tail):
+ *
+ *  1. No agy screen is up: the `Switch Model` / `↑/↓ Navigate` test its
+ *     `beforePrompt` makes (every branch after that test answers `waiting` or
+ *     `running`, so it covers the numbered dialogs too), and the trust
+ *     question. Both over the tail — with the pane 1000 rows tall the whole
+ *     transcript is in the capture, and a quoted question anywhere in it used
+ *     to block every send.
+ *  2. The frame ends in the input box ({@link readInputBoxStatusRow}).
+ *  3. agy is not generating. `? for shortcuts` on the status row settles it —
+ *     kept as a sufficient signal so a thought summary such as "Generating the
+ *     specified file" left in the tail cannot block a send the pre-#2478 rule
+ *     allowed. Without it, `afterThinking`'s reading: no spinner, `Generating`
+ *     or `esc to cancel` in the tail. The box stays on screen while agy
+ *     generates, so 2 alone would not do.
+ *
+ * Before #2478 the footer was required and the detector never read it, so the
+ * two disagreed on every frame agy 1.2.1 draws after a tool turn.
+ *
+ * @param output - A captured pane, raw or ANSI-stripped
+ * @returns True when the input box is live and agy is idle
  */
 function isAntigravityReady(output) {
-    return (ANTIGRAVITY_READY_FOOTER_PATTERN.test(output) &&
-        !ANTIGRAVITY_TRUST_DIALOG_PATTERN.test(output));
+    const frame = (0, frame_1.normalizeFrame)(output);
+    if (cli_patterns_1.ANTIGRAVITY_SELECTION_LIST_PATTERN.test(frame.lastLines))
+        return false;
+    if (ANTIGRAVITY_TRUST_DIALOG_PATTERN.test(frame.lastLines))
+        return false;
+    const statusRow = readInputBoxStatusRow(frame.contentLines);
+    if (statusRow === null)
+        return false;
+    if (ANTIGRAVITY_READY_FOOTER_PATTERN.test(statusRow))
+        return true;
+    return !(0, cli_patterns_1.detectThinking)('antigravity', frame.lastLines);
 }
 /**
  * Antigravity CLI tool implementation.
@@ -185,7 +270,7 @@ class AntigravityTool extends base_1.BaseCLITool {
      * Wait for agy to become ready (input prompt live).
      * Handles the first-run trust dialog ("Do you trust the contents of this
      * project?") by sending Enter to confirm the default "Yes, I trust this folder"
-     * selection. Polls until the idle footer is detected or max attempts reached.
+     * selection. Polls until {@link isAntigravityReady} or max attempts reached.
      */
     async waitForReady(sessionName) {
         // One-shot guard: capturePane keeps the dismissed dialog in scrollback, so
@@ -195,7 +280,7 @@ class AntigravityTool extends base_1.BaseCLITool {
             try {
                 const rawOutput = await (0, tmux_1.capturePane)(sessionName, 50);
                 const output = (0, cli_patterns_1.stripAnsi)(rawOutput);
-                // Ready: idle footer present and no trust dialog pending.
+                // Ready: the input box is live and no agy screen covers it.
                 if (isAntigravityReady(output)) {
                     logger.info('antigravity-prompt-detected');
                     return;

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

@@ -53,12 +53,62 @@
  * indistinguishable from a clean send by every signal a caller has. The
  * composer is therefore emptied and read back BEFORE the body is typed — see
  * {@link clearComposerBeforeSend}.
+ *
+ * Issue #2464 is the body itself going missing on the way in. A body longer
+ * than one pty read reaches the TUI as several reads — tmux delivers every byte
+ * (12,288 of 12,288 measured on a raw pane), but the reader gets them 1,022
+ * bytes at a time on macOS — and Claude Code 2.1.268 reassembles unbracketed
+ * input read by read and keeps only the LAST one. A 1 KB brief arrived as its
+ * final 2 bytes, a 4 KB one as its final 8, and the send still said `Message
+ * sent.`: the tail sits in the composer as ordinary text, Enter submits it, and
+ * nothing downstream can tell a tail from a message. Neither the #1880 clear nor
+ * the Enter timing is involved — both were switched off in controls and the
+ * loss was unchanged. So a long body is now PASTED ({@link pasteBody}: one
+ * bracketed paste, which the TUI reads as a unit), and Enter is withheld until
+ * the composer shows the whole of it ({@link classifyPasteLanded}). The
+ * measurements are in `docs/design/2464-long-body-repro-matrix.md`.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LITERAL_SEND_MAX_BYTES = void 0;
 exports.classifySubmit = classifySubmit;
 exports.isSubmitted = isSubmitted;
+exports.classifyPasteLanded = classifyPasteLanded;
 exports.clearComposerBeforeSend = clearComposerBeforeSend;
 exports.sendMessageWithSubmitVerification = sendMessageWithSubmitVerification;
+const childProcess = __importStar(require("child_process"));
 const tmux_1 = require("../tmux/tmux");
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const composer_spec_1 = require("./composer-spec");
@@ -77,6 +127,32 @@ const logger = (0, logger_1.createLogger)('cli-tools/submit-verified-sender');
  * a tool that never renders it simply never matches.
  */
 const PASTE_PLACEHOLDER_PATTERN = /\[Pasted text[\s#]/;
+/**
+ * Largest body typed as keystrokes (`send-keys -l`); anything longer is pasted
+ * (Issue #2464).
+ *
+ * The limit is the pty's, not tmux's. tmux hands the pane the whole argv —
+ * 16,320 bytes arrived intact on tmux 3.5a, and past ~16.3 KB `send-keys`
+ * refuses with `command too long`, loudly — but the TUI reads it back in
+ * pty-sized pieces, 1,022 bytes each on macOS. Claude Code keeps only the last
+ * piece of unbracketed input (`12288 mod 1022` = the 24 bytes that arrived of a
+ * 12 KB brief), so a body is only safe as keystrokes while it fits in a single
+ * read. Half the smallest read measured leaves room for multi-byte text and for
+ * a platform whose reads are shorter.
+ */
+exports.LITERAL_SEND_MAX_BYTES = 512;
+/**
+ * How often the composer is read while a pasted body is expected to appear in
+ * it. Claude, codex, Command Code and agy all drew the pasted body within
+ * 60 ms of `paste-buffer` on a 12 KB brief.
+ */
+const PASTE_LANDED_POLL_MS = 100;
+/** Composer reads before a paste that has not fully appeared is abandoned (2 s). */
+const DEFAULT_PASTE_LANDED_ATTEMPTS = 20;
+/** Per-command timeout for `load-buffer` / `paste-buffer`, as for every other tmux call. */
+const PASTE_COMMAND_TIMEOUT_MS = 5000;
+/** Makes each send's tmux paste buffer name unique within this process. */
+let pasteBufferSeq = 0;
 /**
  * A slash-command sitting on the input line (Issue #1501).
  *
@@ -107,6 +183,12 @@ const INPUT_LINE_MARKER = /^\s*(?:ctx:\d+%\s*)?[>❯›]/;
  * bottom of the pane, so it is read from a short tail even when the capture
  * itself is opencode's whole 200-row frame. Widening it to that frame would
  * match `esc interrupt` printed inside a reply.
+ *
+ * "The bottom" is the last row that holds anything (Issue #2464). codex,
+ * Command Code and agy draw inline from the TOP of the 1000-row pane, so the
+ * last twelve rows of the capture are blank padding — measured at rows 306,
+ * 297 and 286 of 1,002 — and reading them found no composer on any send to
+ * those three tools. See {@link withoutTrailingBlankRows}.
  */
 const VERIFY_WINDOW_LINES = 12;
 /**
@@ -161,6 +243,25 @@ function readComposer(reader, lines, windowLines) {
         return { kind: 'empty' };
     return { kind: 'text', text: stripped, rows: [inputLine] };
 }
+/**
+ * The captured rows without the blank rows under the last drawn one
+ * (Issue #2464).
+ *
+ * `capture-pane` returns every row of the pane, and a TUI that renders inline
+ * from the top (codex, Command Code, agy) fills only the first few hundred of
+ * the 1000 rows the session is created with. The composer is the last thing
+ * such a TUI draws, so "the tail of the pane" has to mean "the tail of what is
+ * drawn" — otherwise the tail window is all padding, no composer is ever found,
+ * and every send to those tools classifies as `submitted` whatever the
+ * composer actually holds. A bottom-anchored TUI (claude) has no trailing blank
+ * rows, so for it this is the identity.
+ */
+function withoutTrailingBlankRows(lines) {
+    let end = lines.length;
+    while (end > 0 && lines[end - 1].trim() === '')
+        end--;
+    return lines.slice(0, end);
+}
 /** Default bounded read-back attempts before giving up (throwing). */
 const DEFAULT_VERIFY_ATTEMPTS = 4;
 /**
@@ -213,6 +314,76 @@ function inputMatchesBody(strippedInput, message) {
         return false;
     return bodyFirstLine.startsWith(strippedInput);
 }
+/**
+ * Collapsed-paste placeholders, as measured at the production 200x1000
+ * geometry (Issue #2464, `tests/fixtures/long-body-2464/`):
+ *
+ *   claude 2.1.268  `[Pasted text #86 +59 lines]` for 60 lines, `[Pasted text #87]` for one
+ *   agy 1.2.0       `[Pasted text #5 +60 lines]` for 60 lines, `[Pasted text #6 12288 chars]` for one
+ *   codex 0.154.0   `[Pasted Content 12288 chars]`
+ *   Command Code 1.53.0  `[PROBE P12k… +60L]` — the first ten characters, then the line count
+ *
+ * The `#N` stays optional for #1469's version drift (`[Pasted text +46 lines]`).
+ */
+const PASTE_TOKEN_PATTERNS = [
+    {
+        pattern: /\[Pasted text(?: #\d+)?(?: \+(\d+) lines?| (\d+) chars?)?\]/g,
+        read: (m) => m[1] !== undefined ? { lines: Number(m[1]) } : m[2] !== undefined ? { chars: Number(m[2]) } : {},
+    },
+    { pattern: /\[Pasted Content (\d+) chars?\]/g, read: (m) => ({ chars: Number(m[1]) }) },
+    { pattern: /\[([^\]\n]*?)… \+(\d+)L\]/g, read: (m) => ({ head: m[1], lineTotal: Number(m[2]) }) },
+];
+/** Every paste placeholder on a composer row, and the text left around them. */
+function findPasteTokens(text) {
+    const tokens = [];
+    let rest = text;
+    for (const { pattern, read } of PASTE_TOKEN_PATTERNS) {
+        for (const match of text.matchAll(pattern)) {
+            tokens.push(read(match));
+            rest = rest.replace(match[0], '');
+        }
+    }
+    return { tokens, rest: rest.trim() };
+}
+/**
+ * Does one placeholder account for the whole body?
+ *
+ * Counts below the body's mean the paste is still arriving; counts above it mean
+ * the composer holds more than the body. The two units that differ between
+ * tools for the same `+M lines` wording (claude: 59 for a 60-line body, agy: 60)
+ * are both accepted — a bracketed paste arrives as one unit, so the failure this
+ * guards against is a count that is wildly short (the 24-byte tail of #2464),
+ * not one that is off by one line.
+ */
+function comparePasteToken(token, message) {
+    const newlines = (message.match(/\n/g) ?? []).length;
+    if (token.head !== undefined) {
+        const normalizedHead = token.head.replace(/\s+/g, ' ').trim();
+        if (!message.replace(/\s+/g, ' ').startsWith(normalizedHead))
+            return 'mismatch';
+    }
+    let observed;
+    let accepted;
+    if (token.chars !== undefined) {
+        observed = token.chars;
+        accepted = [[...message].length, message.length];
+    }
+    else if (token.lineTotal !== undefined) {
+        observed = token.lineTotal;
+        accepted = [newlines + 1];
+    }
+    else if (token.lines !== undefined) {
+        observed = token.lines;
+        accepted = [newlines, newlines + 1];
+    }
+    else {
+        // claude's bare `[Pasted text #N]` is what it draws for a single line.
+        return newlines === 0 ? 'landed' : 'pasting';
+    }
+    if (accepted.includes(observed))
+        return 'landed';
+    return observed < Math.min(...accepted) ? 'pasting' : 'mismatch';
+}
 /**
  * Classify a captured pane into submitted / pending / replaced (Issue #1501).
  *
@@ -234,6 +405,10 @@ function inputMatchesBody(strippedInput, message) {
  * no marker — that read was unreachable, so every send reached F (in fact B) and
  * this function has never returned anything but `submitted` for it.
  *
+ * Issue #2464: the tail window starts at the last drawn row, not at the last row
+ * of the pane ({@link withoutTrailingBlankRows}), and C recognises every tool's
+ * paste placeholder ({@link findPasteTokens}), not only claude's.
+ *
  * @param output - Captured pane, ANSI intact. For opencode this must be the
  *   whole pane; {@link ComposerSpec.verifyCaptureLines} is what asks tmux for it.
  * @param cliToolId - CLI tool id, for the "generating" detector
@@ -243,7 +418,7 @@ function inputMatchesBody(strippedInput, message) {
  */
 function classifySubmit(output, cliToolId, message, composerSpec = (0, composer_spec_1.resolveComposerSpec)(cliToolId)) {
     const clean = (0, cli_patterns_1.stripAnsi)(output);
-    const lines = clean.split('\n');
+    const lines = withoutTrailingBlankRows(clean.split('\n'));
     const windowLines = lines.slice(-VERIFY_WINDOW_LINES);
     const windowStr = windowLines.join('\n');
     // A. Actively generating a response => the message was accepted. Read from the
@@ -260,7 +435,7 @@ function classifySubmit(output, cliToolId, message, composerSpec = (0, composer_
         return 'submitted';
     }
     // C. A paste placeholder is still folded into the composer => body is there.
-    if (composer.rows.some((row) => PASTE_PLACEHOLDER_PATTERN.test(row))) {
+    if (composer.rows.some((row) => PASTE_PLACEHOLDER_PATTERN.test(row) || findPasteTokens(row).tokens.length > 0)) {
         return 'pending';
     }
     // D. The typed body is still sitting in the composer => resend Enter.
@@ -284,6 +459,172 @@ function classifySubmit(output, cliToolId, message, composerSpec = (0, composer_
 function isSubmitted(output, cliToolId, message, composerSpec = (0, composer_spec_1.resolveComposerSpec)(cliToolId)) {
     return classifySubmit(output, cliToolId, message, composerSpec) === 'submitted';
 }
+/**
+ * How much of a pasted body the composer shows, read BEFORE Enter (Issue #2464).
+ *
+ * The question #2464 needs answered is not "did Enter work" but "is what Enter
+ * would submit the message we sent". Claude kept the last 24 bytes of a 12 KB
+ * brief as ordinary composer text; every check that runs after Enter saw an
+ * empty box and a generating model, i.e. a perfect send. So the composer is
+ * judged here, while pressing Enter can still be withheld:
+ *
+ *   1. A collapsed placeholder is compared by the count the TUI prints — lines
+ *      for claude, agy and Command Code, characters for codex and agy's
+ *      single-line form ({@link comparePasteToken}).
+ *   2. Plain text is the body only if it is the body's BEGINNING. Text that
+ *      occurs in the body but not at its start is exactly the #2464 tail, and is
+ *      a mismatch rather than "not drawn yet".
+ *   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.
+ */
+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));
+    if (composer.kind !== 'text')
+        return 'unseen';
+    const { tokens, rest } = findPasteTokens(composer.text);
+    if (tokens.length === 0) {
+        if (inputMatchesBody(composer.text, message))
+            return 'landed';
+        if (message.includes(composer.text))
+            return 'mismatch';
+        return 'unseen';
+    }
+    if (tokens.length > 1 || rest !== '')
+        return 'mismatch';
+    return comparePasteToken(tokens[0], message);
+}
+/** Run one tmux command, optionally feeding it `input` on stdin. */
+function runTmux(args, input) {
+    return new Promise((resolve, reject) => {
+        const child = childProcess.execFile('tmux', args, { timeout: PASTE_COMMAND_TIMEOUT_MS }, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+        if (input !== undefined)
+            child.stdin?.end(input);
+    });
+}
+/**
+ * Put a body into the pane as ONE bracketed paste (Issue #2464).
+ *
+ * `load-buffer -` takes the body on stdin, so there is no argv ceiling (20 KB
+ * went through where `send-keys` refuses past ~16.3 KB). `paste-buffer -p`
+ * wraps it in `ESC[200~ … ESC[201~` when — and only when — the application
+ * has asked for bracketed paste; a TUI that has not receives exactly the bytes
+ * `send-keys -l` would have typed (both measured byte-for-byte on a raw pane).
+ * `-r` keeps LF as LF instead of tmux's default LF→CR, which would be an Enter
+ * per line for a TUI that did not ask for brackets. `-d` drops the buffer on
+ * success; a failure drops it here, so no body is left behind in the server.
+ *
+ * @throws Error when either tmux command fails
+ */
+async function pasteBody(sessionName, message) {
+    const bufferName = `cm-send-${process.pid}-${++pasteBufferSeq}`;
+    try {
+        await runTmux(['load-buffer', '-b', bufferName, '-'], message);
+        await runTmux(['paste-buffer', '-p', '-r', '-d', '-b', bufferName, '-t', (0, tmux_1.exactTarget)(sessionName)]);
+    }
+    catch (error) {
+        await runTmux(['delete-buffer', '-b', bufferName]).catch(() => undefined);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to paste message into tmux session: ${errorMessage}`);
+    }
+}
+/** The composer's first row, for an error message a person has to act on. */
+function describeComposer(output, composerSpec) {
+    const lines = withoutTrailingBlankRows((0, cli_patterns_1.stripAnsi)(output).split('\n'));
+    const composer = readComposer(composerSpec.reader, lines, lines.slice(-VERIFY_WINDOW_LINES));
+    if (composer.kind === 'absent')
+        return 'no composer on screen';
+    if (composer.kind === 'empty')
+        return 'an empty composer';
+    const text = composer.text.length > 80 ? `${composer.text.slice(0, 80)}…` : composer.text;
+    return JSON.stringify(text);
+}
+/**
+ * Take a body that did not arrive intact back out of the composer, best effort.
+ *
+ * Leaving it would put the fragment in front of the next message. claude and
+ * codex go through the verified #1879 loop (a paste can span rows); the rest
+ * get the single `C-u` the #1501 path already sends to them.
+ */
+async function withdrawUnsentBody(sessionName, cliToolId, composerSpec) {
+    try {
+        if (composerSpec.clearBeforeSend) {
+            await (0, composer_clear_1.clearComposer)(sessionName, cliToolId);
+        }
+        else {
+            await (0, tmux_1.clearInputLine)(sessionName);
+        }
+    }
+    catch (clearError) {
+        logger.error('paste-withdraw-failed', {
+            sessionName,
+            cliToolId,
+            error: clearError instanceof Error ? clearError.message : String(clearError),
+        });
+    }
+}
+/**
+ * Wait until the composer shows the whole pasted body; decide whether Enter
+ * may be pressed (Issue #2464).
+ *
+ * `pasting` keeps waiting — this is the "a placeholder is not a stuck body"
+ * branch: `[Pasted text #3 +20 lines]` for a 60-line brief is a paste still
+ * coming in, and Enter pressed now would submit twenty lines. `landed` returns.
+ * Everything else ends in a throw WITHOUT Enter, after taking the body back out:
+ *
+ *   - `mismatch`, at once — no amount of waiting turns a tail into a message;
+ *   - `pasting` that never completes within the attempts;
+ *   - `unseen` for a tool whose composer this module has measured
+ *     (`clearBeforeSend`: claude, codex). There, a composer that never shows
+ *     the body means it did not arrive, and Enter would submit nothing while
+ *     the caller printed `Message sent.`.
+ *
+ * `unseen` on any other tool proceeds, with a warning: those composers are
+ * drawn in ways this module has not measured, and refusing on them would turn
+ * "cannot see it" into "did not send it" for every long message they get.
+ *
+ * @throws Error when the body cannot be confirmed in the composer
+ */
+async function confirmPasteLanded(params) {
+    const { sessionName, message, cliToolId, composer, attempts } = params;
+    let state = 'unseen';
+    let output = '';
+    for (let attempt = 0; attempt < Math.max(1, attempts); attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, PASTE_LANDED_POLL_MS));
+        output = await (0, tmux_1.capturePane)(sessionName, { startLine: -composer.verifyCaptureLines });
+        state = classifyPasteLanded(output, cliToolId, message, composer);
+        if (state === 'landed' || state === 'mismatch')
+            break;
+    }
+    if (state === 'landed')
+        return;
+    if (state === 'unseen' && !composer.clearBeforeSend) {
+        logger.warn('paste-landed-unverified', { sessionName, cliToolId, bytes: Buffer.byteLength(message, 'utf8') });
+        return;
+    }
+    const bytes = Buffer.byteLength(message, 'utf8');
+    const lineCount = message.split('\n').length;
+    const shown = describeComposer(output, 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 });
+    const what = state === 'mismatch'
+        ? `the composer does not hold the message as sent (it shows ${shown})`
+        : state === 'pasting'
+            ? `the paste had not finished arriving after ${attempts * PASTE_LANDED_POLL_MS}ms (the composer shows ${shown})`
+            : `the message never appeared in the composer (${shown})`;
+    throw new Error(`Message body did not arrive intact for session ${sessionName}: ${what}; the message is ${bytes} bytes / ${lineCount} lines. ` +
+        'Enter was not pressed, so nothing was submitted (Issue #2464).');
+}
 /**
  * Empty the composer before the body is typed into it (Issue #1880).
  *
@@ -370,27 +711,47 @@ async function clearComposerBeforeSend(sessionName, cliToolId, composerSpec = (0
  * the function THROWS — callers must surface that as a failure, never as
  * success (Issues #1469/#1470/#1471).
  *
- * @throws Error when submit cannot be confirmed within the bounded attempts.
+ * A body longer than {@link LITERAL_SEND_MAX_BYTES} is pasted instead of typed,
+ * and Enter waits until the composer shows all of it (Issue #2464); a body that
+ * does not arrive intact THROWS before Enter, with nothing submitted.
+ *
+ * @throws Error when the body does not arrive intact, or submit cannot be
+ *   confirmed within the bounded attempts.
  */
 async function sendMessageWithSubmitVerification(params) {
-    const { sessionName, message, cliToolId, composer = (0, composer_spec_1.resolveComposerSpec)(cliToolId), textInputWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, interEnterWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, verifyAttempts = DEFAULT_VERIFY_ATTEMPTS, verifyDelayMs = cli_tool_timing_config_1.TUI_MESSAGE_PROCESSED_WAIT_MS, } = params;
+    const { sessionName, message, cliToolId, composer = (0, composer_spec_1.resolveComposerSpec)(cliToolId), textInputWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, interEnterWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, verifyAttempts = DEFAULT_VERIFY_ATTEMPTS, verifyDelayMs = cli_tool_timing_config_1.TUI_MESSAGE_PROCESSED_WAIT_MS, pasteLandedAttempts = DEFAULT_PASTE_LANDED_ATTEMPTS, } = params;
     const submitEnterCount = params.submitEnterCount ?? composer.submitEnterCount;
     // 0. Empty the composer first (Issue #1880). The body below is typed at the
     //    TUI's current cursor position, so anything already in the box would be
     //    spliced into it. Throws for a claude composer that could not be emptied.
     await clearComposerBeforeSend(sessionName, cliToolId, composer);
-    // 1. Type the body only — never send Enter in the same tmux command.
-    //
-    //    `{ literal: true }` is Issue #1933 受入条件 S9 and it is not decoration.
-    //    `tmux send-keys` resolves its argument against the key table first, so
-    //    until this flag existed a message body of exactly `Escape` interrupted
-    //    the agent (`1b`), `Enter` submitted an empty composer (`0d`) and `C-c`
-    //    sent SIGINT — and a body starting with `-` was eaten by getopt and sent
-    //    nowhere at all, with `rc 0`. All four measured on tmux 3.5a; the argv is
-    //    built in `lib/tmux/key-sequence.ts`, which carries the table.
-    await (0, tmux_1.sendKeys)(sessionName, message, false, { literal: true });
-    // 2. Let the TUI register the input before pressing Enter.
-    await new Promise((resolve) => setTimeout(resolve, textInputWaitMs));
+    if (Buffer.byteLength(message, 'utf8') > exports.LITERAL_SEND_MAX_BYTES) {
+        // 1'. A body that would reach the TUI as more than one pty read is pasted
+        //     as ONE bracketed paste, and Enter waits until the composer shows all
+        //     of it (Issue #2464). Typed, Claude Code would keep only its last read.
+        const pastedAt = Date.now();
+        await pasteBody(sessionName, message);
+        await confirmPasteLanded({ sessionName, message, cliToolId, composer, attempts: pasteLandedAttempts });
+        // 2'. Keep the tool's own registration delay as a floor.
+        const remaining = textInputWaitMs - (Date.now() - pastedAt);
+        if (remaining > 0) {
+            await new Promise((resolve) => setTimeout(resolve, remaining));
+        }
+    }
+    else {
+        // 1. Type the body only — never send Enter in the same tmux command.
+        //
+        //    `{ literal: true }` is Issue #1933 受入条件 S9 and it is not decoration.
+        //    `tmux send-keys` resolves its argument against the key table first, so
+        //    until this flag existed a message body of exactly `Escape` interrupted
+        //    the agent (`1b`), `Enter` submitted an empty composer (`0d`) and `C-c`
+        //    sent SIGINT — and a body starting with `-` was eaten by getopt and sent
+        //    nowhere at all, with `rc 0`. All four measured on tmux 3.5a; the argv is
+        //    built in `lib/tmux/key-sequence.ts`, which carries the table.
+        await (0, tmux_1.sendKeys)(sessionName, message, false, { literal: true });
+        // 2. Let the TUI register the input before pressing Enter.
+        await new Promise((resolve) => setTimeout(resolve, textInputWaitMs));
+    }
     // 3. Submit as a separate command (double Enter for vibe-local's IME mode).
     for (let i = 0; i < Math.max(1, submitEnterCount); i++) {
         await (0, tmux_1.sendSpecialKeys)(sessionName, ['Enter']);

package/dist/server/src/lib/cmate-parser.js

@@ -227,8 +227,15 @@ function parseSchedulesSection(rows) {
             // Issue #2250: its own case, not a fall-through. #1914's rule is that a
             // tool with a permission vocabulary names itself here; inheriting the
             // no-flag branch would silently blank a valid `plan` / `auto-accept` cell.
+            //
+            // Issue #2454: the column vocabulary is the six-value
+            // COMMAND_CODE_SCHEDULE_PERMISSIONS, not the five `--permission-mode`
+            // choices. An empty cell therefore resolves to `yolo` through
+            // `defaultPermission` above, which is the only value that lets
+            // `commandcode -p` write anything -- the five modes all leave print mode
+            // read-only while still reporting success.
             case 'command-code':
-                allowedValues = schedule_config_1.COMMAND_CODE_PERMISSIONS;
+                allowedValues = schedule_config_1.COMMAND_CODE_SCHEDULE_PERMISSIONS;
                 break;
             case 'gemini':
             case 'vibe-local':

package/dist/server/src/lib/db/agent-instances-db.js

@@ -136,6 +136,17 @@ function getAgentInstance(db, worktreeId, instanceId) {
  * conflict rather than silently overriding it: the roster is user-maintained
  * and a mismatch means one of the two is wrong. Callers surface it as an error.
  *
+ * @deprecated Issue #1925 made `resolveSessionTarget`
+ * (`src/lib/session/resolve-session-target.ts`) the one authority, and Issue
+ * #2491 moved the last two callers — `POST /send` and `resolveRelaySession` —
+ * onto it. **Do not give this function a new caller.** Step 2 above is exactly
+ * what #2487 corrected: with no roster row it takes `requestedCliTool` even
+ * when `instanceId` itself names a different tool, so a caller wired here gets
+ * `mcbd-<requested>-<wt>-<tool-named-id>` back instead of a conflict. It is
+ * kept only because its #1629 unit test
+ * (`tests/unit/db/agent-instances-resolve-cli-tool.test.ts`) still pins that
+ * behaviour; removing both is a separate change.
+ *
  * @param db - Database instance
  * @param worktreeId - Worktree ID
  * @param instanceId - Targeted agent instance ID (omitted for the primary instance)