commandmate 0.12.0 → 0.12.1

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

@@ -13,7 +13,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AntigravityTool = void 0;
 const base_1 = require("./base");
 const tmux_1 = require("../tmux/tmux");
-const pasted_text_helper_1 = require("../pasted-text-helper");
+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 logger_1 = require("../../lib/logger");
@@ -217,18 +217,13 @@ class AntigravityTool extends base_1.BaseCLITool {
         try {
             // Verify agy is at a ready prompt before sending
             await this.waitForPrompt(sessionName);
-            // Send message text (without Enter)
-            await (0, tmux_1.sendKeys)(sessionName, message, false);
-            // Wait a moment for the text to be typed
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS));
-            // Send Enter key separately
-            await (0, tmux_1.sendSpecialKey)(sessionName, 'C-m');
-            // Wait a moment for the message to be processed
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_MESSAGE_PROCESSED_WAIT_MS));
-            // Detect [Pasted text] and resend Enter for multi-line messages
-            if (message.includes('\n')) {
-                await (0, pasted_text_helper_1.detectAndResendIfPastedText)(sessionName);
-            }
+            // Issue #1471: Body/Enter separation + read-back submit verification via the
+            // shared helper (replaces the old type -> C-m -> `\n`-gated paste recovery).
+            await (0, submit_verified_sender_1.sendMessageWithSubmitVerification)({
+                sessionName,
+                message,
+                cliToolId: 'antigravity',
+            });
             // Invalidate cache after sending message (required so the poller re-reads)
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
             logger.info('sent-message-to-antigravity-session');

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

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodexTool = void 0;
 const base_1 = require("./base");
 const tmux_1 = require("../tmux/tmux");
-const pasted_text_helper_1 = require("../pasted-text-helper");
+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 logger_1 = require("../../lib/logger");
@@ -209,19 +209,13 @@ class CodexTool extends base_1.BaseCLITool {
         try {
             // Verify Codex is at prompt state before sending
             await this.waitForPrompt(sessionName);
-            // Send message to Codex (without Enter)
-            await (0, tmux_1.sendKeys)(sessionName, message, false);
-            // Wait a moment for the text to be typed
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS));
-            // Send Enter key separately
-            await (0, tmux_1.sendSpecialKey)(sessionName, 'C-m');
-            // Wait a moment for the message to be processed
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_MESSAGE_PROCESSED_WAIT_MS));
-            // Issue #212: Detect [Pasted text] and resend Enter for multi-line messages
-            // MF-001: Single-line messages skip detection (+0ms overhead)
-            if (message.includes('\n')) {
-                await (0, pasted_text_helper_1.detectAndResendIfPastedText)(sessionName);
-            }
+            // Issue #1471: Body/Enter separation + read-back submit verification via the
+            // shared helper (replaces the old type -> C-m -> `\n`-gated paste recovery).
+            await (0, submit_verified_sender_1.sendMessageWithSubmitVerification)({
+                sessionName,
+                message,
+                cliToolId: 'codex',
+            });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
             logger.info('sent-message-to-codex-session:sessionnam');

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

@@ -12,7 +12,7 @@ exports.CopilotTool = void 0;
 const child_process_1 = require("child_process");
 const base_1 = require("./base");
 const tmux_1 = require("../tmux/tmux");
-const pasted_text_helper_1 = require("../pasted-text-helper");
+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 copilot_constants_1 = require("../../config/copilot-constants");
@@ -246,18 +246,17 @@ class CopilotTool extends base_1.BaseCLITool {
                 logger.info('sent-selection-list-command-to-copilot', { command: slashCmd });
                 return;
             }
-            // Send message to Copilot (without Enter)
-            await (0, tmux_1.sendKeys)(sessionName, message, false);
-            // Wait a moment for the text to be typed
-            await new Promise((resolve) => setTimeout(resolve, copilot_constants_1.COPILOT_TEXT_INPUT_DELAY_MS));
-            // Send Enter key separately
-            await (0, tmux_1.sendSpecialKey)(sessionName, 'C-m');
-            // Wait a moment for the message to be processed
-            await new Promise((resolve) => setTimeout(resolve, copilot_constants_1.COPILOT_SEND_ENTER_DELAY_MS));
-            // Detect [Pasted text] and resend Enter for multi-line messages
-            if (message.includes('\n')) {
-                await (0, pasted_text_helper_1.detectAndResendIfPastedText)(sessionName);
-            }
+            // Issue #1471: Body/Enter separation + read-back submit verification via the
+            // shared helper (replaces the old type -> C-m -> `\n`-gated paste recovery).
+            // Copilot's own text-input / post-Enter delays are preserved. The selection
+            // list slash-command branch above is intentionally NOT routed through here.
+            await (0, submit_verified_sender_1.sendMessageWithSubmitVerification)({
+                sessionName,
+                message,
+                cliToolId: 'copilot',
+                textInputWaitMs: copilot_constants_1.COPILOT_TEXT_INPUT_DELAY_MS,
+                verifyDelayMs: copilot_constants_1.COPILOT_SEND_ENTER_DELAY_MS,
+            });
             // Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
             logger.info('sent-message-to-copilot-session');

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

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeminiTool = exports.GEMINI_PANE_HEIGHT = void 0;
 const base_1 = require("./base");
 const tmux_1 = require("../tmux/tmux");
-const pasted_text_helper_1 = require("../pasted-text-helper");
+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 logger_1 = require("../../lib/logger");
@@ -167,18 +167,13 @@ class GeminiTool extends base_1.BaseCLITool {
         try {
             // Verify Gemini is at prompt state before sending
             await this.waitForPrompt(sessionName);
-            // Send message to Gemini (without Enter)
-            await (0, tmux_1.sendKeys)(sessionName, message, false);
-            // Wait a moment for the text to be typed
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS));
-            // Send Enter key separately
-            await (0, tmux_1.sendSpecialKey)(sessionName, 'C-m');
-            // Wait a moment for the message to be processed
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_MESSAGE_PROCESSED_WAIT_MS));
-            // Detect [Pasted text] and resend Enter for multi-line messages
-            if (message.includes('\n')) {
-                await (0, pasted_text_helper_1.detectAndResendIfPastedText)(sessionName);
-            }
+            // Issue #1471: Body/Enter separation + read-back submit verification via the
+            // shared helper (replaces the old type -> C-m -> `\n`-gated paste recovery).
+            await (0, submit_verified_sender_1.sendMessageWithSubmitVerification)({
+                sessionName,
+                message,
+                cliToolId: 'gemini',
+            });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
             logger.info('sent-message-to-gemini-session:sessionna');

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

@@ -13,7 +13,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenCodeTool = exports.OPENCODE_INIT_WAIT_MS = exports.OPENCODE_PANE_HEIGHT = exports.OPENCODE_EXIT_COMMAND = void 0;
 const base_1 = require("./base");
 const tmux_1 = require("../tmux/tmux");
-const pasted_text_helper_1 = require("../pasted-text-helper");
+const submit_verified_sender_1 = require("./submit-verified-sender");
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const opencode_config_1 = require("./opencode-config");
 const child_process_1 = require("child_process");
@@ -134,18 +134,13 @@ class OpenCodeTool extends base_1.BaseCLITool {
             throw new Error(`OpenCode session ${sessionName} does not exist. Start the session first.`);
         }
         try {
-            // Send message to OpenCode (without Enter)
-            await (0, tmux_1.sendKeys)(sessionName, message, false);
-            // Wait a moment for the text to be typed
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS));
-            // Send Enter key separately
-            await (0, tmux_1.sendSpecialKey)(sessionName, 'C-m');
-            // Wait a moment for the message to be processed
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_MESSAGE_PROCESSED_WAIT_MS));
-            // Detect [Pasted text] and resend Enter for multi-line messages
-            if (message.includes('\n')) {
-                await (0, pasted_text_helper_1.detectAndResendIfPastedText)(sessionName);
-            }
+            // Issue #1471: Body/Enter separation + read-back submit verification via the
+            // shared helper (replaces the old type -> C-m -> `\n`-gated paste recovery).
+            await (0, submit_verified_sender_1.sendMessageWithSubmitVerification)({
+                sessionName,
+                message,
+                cliToolId: 'opencode',
+            });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
             logger.info('sent-message-to-opencode-session:session');

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

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Submit-verified message sender (Issues #1469, #1470, #1471).
+ *
+ * A single shared helper that replaces the seven near-identical
+ * "type body -> press Enter -> maybe recover paste" sequences previously
+ * duplicated across session-key-sender.ts and every cli-tools/*.ts sendMessage(),
+ * plus the terminal API route's raw `sendKeys(command)` batch send.
+ *
+ * Why this exists (root cause):
+ *   tmux `send-keys <body> C-m` batches the body and Enter into a SINGLE command.
+ *   ink/React TUIs (Claude Code, Codex, ...) treat the injected body as a
+ *   bracketed paste and swallow the trailing C-m as a newline inside the paste
+ *   buffer, so the message is typed but never submitted. The recovery that used
+ *   to guard this was gated on `message.includes('\n')` (single-line messages
+ *   skipped entirely), keyed off Claude's version-specific `[Pasted text #\d+`
+ *   string, and never verified that submit actually happened (fire-and-forget).
+ *
+ * This helper fixes all three:
+ *   1. Body and Enter are ALWAYS sent as separate tmux commands with a delay
+ *      between them (never a single body+C-m batch).
+ *   2. Recovery + verification apply to EVERY message (no `\n` gate).
+ *   3. After submit it reads the pane back and confirms the message actually
+ *      left the input box (empty input line) or the tool began generating.
+ *      If it is still pending it resends Enter, bounded; if it can never be
+ *      confirmed it THROWS (callers must not report success on a stuck send).
+ *
+ * The verification is intentionally NOT keyed off the version-specific
+ * `[Pasted text #\d+` placeholder. That placeholder is used only as one
+ * "still pending" positive signal (broadened to be version-resilient); the
+ * primary decision is "is the message still sitting on the input line?".
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSubmitted = isSubmitted;
+exports.sendMessageWithSubmitVerification = sendMessageWithSubmitVerification;
+const tmux_1 = require("../tmux/tmux");
+const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
+const cli_patterns_1 = require("../detection/cli-patterns");
+const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('cli-tools/submit-verified-sender');
+/**
+ * Version-resilient pasted-text placeholder.
+ *
+ * Broader than PASTED_TEXT_PATTERN (`/\[Pasted text #\d+/`) so it still matches
+ * when a CLI version drops the `#N` and renders `[Pasted text +46 lines]`
+ * (Issue #1469 condition 2). Used ONLY as a positive "still in the input box"
+ * signal — never as the sole submit gate — so applying it to every tool is safe:
+ * a tool that never renders it simply never matches.
+ */
+const PASTE_PLACEHOLDER_PATTERN = /\[Pasted text[\s#]/;
+/**
+ * Prompt input-line markers across the supported TUIs.
+ * claude/gemini/copilot: `>` or `❯`; codex: `›`; antigravity: `>`;
+ * vibe-local: `ctx:N% ❯`. Leading whitespace is tolerated (tmux padding).
+ */
+const INPUT_LINE_MARKER = /^\s*(?:ctx:\d+%\s*)?[>❯›]/;
+/** Lines of pane tail to inspect when verifying submit. */
+const VERIFY_WINDOW_LINES = 12;
+/** Default bounded read-back attempts before giving up (throwing). */
+const DEFAULT_VERIFY_ATTEMPTS = 4;
+/** Minimum fragment length used to decide the body is still on the input line. */
+const MIN_FRAGMENT_LENGTH = 3;
+const MAX_FRAGMENT_LENGTH = 24;
+/**
+ * First non-blank fragment of the message, used to decide whether the body is
+ * still sitting on the input line. Only the first line matters because that is
+ * what a TUI shows on the prompt line before folding into a paste placeholder.
+ */
+function comparableFragment(message) {
+    const firstLine = message
+        .split('\n')
+        .map((l) => l.trim())
+        .find((l) => l.length > 0);
+    if (!firstLine)
+        return '';
+    return firstLine.slice(0, MAX_FRAGMENT_LENGTH);
+}
+/**
+ * Locate the active input line within the pane tail: the last line that begins
+ * with a prompt marker. Scanned bottom-up so a status-bar/footer line rendered
+ * BELOW the input box (antigravity's "? for shortcuts", vibe-local's status bar)
+ * does not hide the real input line above it.
+ */
+function findInputLine(windowLines) {
+    for (let i = windowLines.length - 1; i >= 0; i--) {
+        if (INPUT_LINE_MARKER.test(windowLines[i])) {
+            return windowLines[i];
+        }
+    }
+    return null;
+}
+/**
+ * Decide whether a captured pane shows the message as submitted.
+ *
+ * Version-independent by design — does NOT require the paste placeholder:
+ *   A. The tool is generating a response          -> submitted.
+ *   B. A paste placeholder is on the input line    -> NOT submitted (Enter eaten).
+ *   C. The body fragment is still on the input line -> NOT submitted.
+ *   D. Otherwise (empty input line / moved to history) -> submitted.
+ *
+ * B and C are scoped to the input line only, so the user-message echo that a
+ * TUI prints into its history above the prompt never causes a false "pending".
+ */
+function isSubmitted(output, cliToolId, message) {
+    const clean = (0, cli_patterns_1.stripAnsi)(output);
+    const windowLines = clean.split('\n').slice(-VERIFY_WINDOW_LINES);
+    const windowStr = windowLines.join('\n');
+    // A. Actively generating a response => the message was accepted.
+    if ((0, cli_patterns_1.detectThinking)(cliToolId, windowStr)) {
+        return true;
+    }
+    const inputLine = findInputLine(windowLines);
+    if (inputLine) {
+        // B. A paste placeholder is still folded on the input line => not submitted.
+        if (PASTE_PLACEHOLDER_PATTERN.test(inputLine)) {
+            return false;
+        }
+        // C. The typed body is still sitting on the input line => not submitted.
+        const fragment = comparableFragment(message);
+        if (fragment.length >= MIN_FRAGMENT_LENGTH && inputLine.includes(fragment)) {
+            return false;
+        }
+    }
+    // D. Input line is clear (or absent) and nothing is generating => submitted.
+    return true;
+}
+/**
+ * Type a message body and submit it, then verify the submit actually happened.
+ *
+ * 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
+ * success (Issues #1469/#1470/#1471).
+ *
+ * @throws Error when submit cannot be confirmed within the bounded attempts.
+ */
+async function sendMessageWithSubmitVerification(params) {
+    const { sessionName, message, cliToolId, textInputWaitMs = cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS, submitEnterCount = 1, 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;
+    // 1. Type the body only — never send Enter in the same tmux command.
+    await (0, tmux_1.sendKeys)(sessionName, message, false);
+    // 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']);
+        if (i < submitEnterCount - 1) {
+            await new Promise((resolve) => setTimeout(resolve, interEnterWaitMs));
+        }
+    }
+    // 4. Read-back verification: confirm the message left the input box, resend
+    //    Enter while it is still pending, and throw if it never submits.
+    const attempts = Math.max(1, verifyAttempts);
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, verifyDelayMs));
+        const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -VERIFY_WINDOW_LINES });
+        if (isSubmitted(output, cliToolId, message)) {
+            (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+            return;
+        }
+        // Still typed-but-unsent — resend a single Enter and re-check.
+        logger.warn('submit-not-confirmed:resending-enter', {
+            sessionName,
+            cliToolId,
+            attempt,
+        });
+        await (0, tmux_1.sendSpecialKeys)(sessionName, ['Enter']);
+    }
+    (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+    logger.error('submit-verification-failed', { sessionName, cliToolId, attempts });
+    throw new Error(`Message submit could not be confirmed for session ${sessionName} after ${attempts} attempts (typed but unsent)`);
+}

package/dist/server/src/lib/cli-tools/vibe-local.js

@@ -13,7 +13,7 @@ exports.VibeLocalTool = void 0;
 const base_1 = require("./base");
 const types_1 = require("./types");
 const tmux_1 = require("../tmux/tmux");
-const pasted_text_helper_1 = require("../pasted-text-helper");
+const submit_verified_sender_1 = require("./submit-verified-sender");
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const db_instance_1 = require("../db/db-instance");
 const db_1 = require("../db");
@@ -121,22 +121,17 @@ class VibeLocalTool extends base_1.BaseCLITool {
             throw new Error(`Vibe Local session ${sessionName} does not exist. Start the session first.`);
         }
         try {
-            // Send message to vibe-local (without Enter)
-            await (0, tmux_1.sendKeys)(sessionName, message, false);
-            // Wait a moment for the text to be typed
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_TEXT_INPUT_WAIT_MS));
-            // vibe-local uses IME mode: first Enter creates a new line,
-            // second Enter on empty line submits the message.
-            // Send Enter twice with a short delay between.
-            await (0, tmux_1.sendSpecialKey)(sessionName, 'C-m');
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.VIBE_LOCAL_DOUBLE_ENTER_WAIT_MS));
-            await (0, tmux_1.sendSpecialKey)(sessionName, 'C-m');
-            // Wait a moment for the message to be processed
-            await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_MESSAGE_PROCESSED_WAIT_MS));
-            // Detect [Pasted text] and resend Enter for multi-line messages
-            if (message.includes('\n')) {
-                await (0, pasted_text_helper_1.detectAndResendIfPastedText)(sessionName);
-            }
+            // Issue #1471: Body/Enter separation + read-back submit verification via the
+            // shared helper. vibe-local's IME mode needs TWO Enter presses (first Enter
+            // inserts a newline, the second submits), preserved via submitEnterCount: 2
+            // + the same inter-press wait (VIBE_LOCAL_DOUBLE_ENTER_WAIT_MS).
+            await (0, submit_verified_sender_1.sendMessageWithSubmitVerification)({
+                sessionName,
+                message,
+                cliToolId: 'vibe-local',
+                submitEnterCount: 2,
+                interEnterWaitMs: cli_tool_timing_config_1.VIBE_LOCAL_DOUBLE_ENTER_WAIT_MS,
+            });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
             logger.info('sent-message-to-vibe-local-session:sessi');

package/dist/server/src/lib/session-key-sender.js

@@ -15,7 +15,7 @@ exports.sendMessageToSession = sendMessageToSession;
 exports.stopSession = stopSession;
 const tmux_1 = require("./tmux/tmux");
 const cli_patterns_1 = require("./detection/cli-patterns");
-const pasted_text_helper_1 = require("./pasted-text-helper");
+const submit_verified_sender_1 = require("./cli-tools/submit-verified-sender");
 const tmux_capture_cache_1 = require("./tmux/tmux-capture-cache");
 const errors_1 = require("./errors");
 const cli_tool_timing_config_1 = require("../config/cli-tool-timing-config");
@@ -112,14 +112,16 @@ async function sendMessageToSession(sessionName, message, postPromptDelay, promp
     }
     // Stability delay after prompt detection
     await new Promise((resolve) => setTimeout(resolve, postPromptDelay));
-    // Send message using sendKeys consistently (CONS-001)
-    await (0, tmux_1.sendKeys)(sessionName, message, false);
-    await (0, tmux_1.sendKeys)(sessionName, '', true);
-    // Issue #212: Detect [Pasted text] and resend Enter for multi-line messages
-    // MF-001: Single-line messages skip detection (+0ms overhead)
-    if (message.includes('\n')) {
-        await (0, pasted_text_helper_1.detectAndResendIfPastedText)(sessionName);
-    }
+    // Issue #1469: Body and Enter are sent as SEPARATE tmux commands (never a
+    // single body+C-m batch) and the submit is read-back verified. This replaces
+    // the old fire-and-forget `sendKeys(message,false)` + `sendKeys('',true)` that
+    // let Claude's ink TUI swallow the trailing C-m as a bracketed-paste newline,
+    // leaving the message typed but unsent. Throws if submit cannot be confirmed.
+    await (0, submit_verified_sender_1.sendMessageWithSubmitVerification)({
+        sessionName,
+        message,
+        cliToolId: 'claude',
+    });
     // Issue #405: Invalidate cache after sending message
     (0, tmux_capture_cache_1.invalidateCache)(sessionName);
     logger.info('sent-message-to-session', { sessionName });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commandmate",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "A local control plane for agent CLIs — orchestration and visibility for Claude Code, Codex, Gemini CLI, and more across Git worktrees",
   "keywords": [
     "claude-code",

package/dist/server/src/lib/pasted-text-helper.js

@@ -1,58 +0,0 @@
-"use strict";
-/**
- * Pasted text detection + Enter resend helper
- *
- * Shared helper for claude-session.ts and codex.ts to detect
- * [Pasted text #N +XX lines] in tmux output and automatically
- * resend Enter to start processing.
- *
- * @see Issue #212
- * @designNote SF-001: Extracted as common helper to eliminate code duplication
- *   between claude-session.ts and codex.ts.
- * @designNote MF-S4-001: sessionName is expected to be generated by
- *   getSessionName() in fixed format ('mcbd-{cli}-{worktreeId}').
- *   tmux.ts provides double-quote escaping as a defense layer.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectAndResendIfPastedText = detectAndResendIfPastedText;
-const tmux_1 = require("./tmux/tmux");
-const cli_patterns_1 = require("./detection/cli-patterns");
-const logger_1 = require("./logger");
-// SF-S2-002: Logger is generated internally, not injected from callers
-const logger = (0, logger_1.createLogger)('pasted-text');
-/**
- * Detect [Pasted text] in tmux buffer and resend Enter if found.
- *
- * Called after sending a multi-line message to handle Claude CLI's
- * paste detection behavior. The caller is responsible for the
- * message.includes('\n') guard condition.
- *
- * @param sessionName - tmux session name, generated by getSessionName()
- * @returns Promise<void>
- *
- * @designNote PASTE-HELPER: Caller responsibilities vs helper responsibilities:
- *   Caller: message.includes('\n') guard + call timing control
- *   Helper: detect loop (setTimeout wait -> capturePane -> test -> Enter resend)
- * @designNote SF-S2-005: Uses setTimeout+Promise pattern (project convention)
- */
-async function detectAndResendIfPastedText(sessionName) {
-    for (let attempt = 0; attempt < cli_patterns_1.MAX_PASTED_TEXT_RETRIES; attempt++) {
-        // SF-S2-005: Project-standard delay pattern
-        await new Promise(resolve => setTimeout(resolve, cli_patterns_1.PASTED_TEXT_DETECT_DELAY));
-        // PASTE-002: Read only last 10 lines -- [Pasted text] appears in recent output
-        const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -10 });
-        if (!cli_patterns_1.PASTED_TEXT_PATTERN.test((0, cli_patterns_1.stripAnsi)(output))) {
-            return; // Normal: no Pasted text detected
-        }
-        // Pasted text detected -- resend Enter
-        await (0, tmux_1.sendKeys)(sessionName, '', true);
-        if (attempt === cli_patterns_1.MAX_PASTED_TEXT_RETRIES - 1) {
-            // SF-S4-001: Log with attempt count for traceability
-            logger.warn('Pasted text detection: max retries reached', {
-                sessionName,
-                maxRetries: cli_patterns_1.MAX_PASTED_TEXT_RETRIES,
-                finalAttempt: attempt,
-            });
-        }
-    }
-}