commandmate 0.33.3 → 0.34.0

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':