crewly 1.20.196 → 1.20.198

package/dist/backend/backend/src/services/session/session-command-helper.js

@@ -16,11 +16,13 @@
  * @module session-command-helper
  */
 import { LoggerService } from '../core/logger.service.js';
-import { SESSION_COMMAND_DELAYS, EVENT_DELIVERY_CONSTANTS, TERMINAL_PATTERNS, PLAN_MODE_DISMISS_PATTERNS } from '../../constants.js';
+import { SESSION_COMMAND_DELAYS, EVENT_DELIVERY_CONSTANTS, PLAN_MODE_DISMISS_PATTERNS, TUI_INPUT_GUARD } from '../../constants.js';
 import { delay } from '../../utils/async.utils.js';
 import { assertNotSecretEnvKey } from '../../utils/secret-env.js';
 import { quietShellLine } from '../../utils/shell-history.js';
 import { PtyActivityTrackerService } from '../agent/pty-activity-tracker.service.js';
+import { classifyTuiInput, isPasteMarker, TuiInputGuardError } from './tui-input-guard.js';
+import { noteHarnessWrite } from '../trace/turn-origin.js';
 /**
  * Key code mappings for special keys
  */
@@ -66,6 +68,43 @@ export const KEY_CODES = {
 export class SessionCommandHelper {
     logger;
     backend;
+    /**
+     * Per session: the collapsed paste marker ("[Pasted text #1 +29 lines]",
+     * "[Pasted Content 1234 chars]") the runtime showed right after the
+     * harness pasted `message`. Proof that a marker still in the box later is
+     * ours, so a lost Enter can be recovered. Shared across helper instances.
+     */
+    static ownPasteMarkers = new Map();
+    /** Clock for the marker record (tests). */
+    static now = Date.now;
+    /**
+     * Forget the recorded paste marker of a session: its runtime is being
+     * (re)started, a shell line is typed, or the session is created/killed —
+     * Claude Code's paste counter restarts at #1, and Codex markers carry only
+     * a character count, so an old record could match the owner's paste.
+     *
+     * @param sessionName - The session
+     */
+    static forgetOwnPaste(sessionName) {
+        SessionCommandHelper.ownPasteMarkers.delete(sessionName);
+    }
+    /**
+     * The recorded marker, while it may still be ours: at most
+     * OWN_MARKER_TTL_MS after our paste.
+     *
+     * @param sessionName - The session
+     * @returns The marker, or undefined
+     */
+    static ownMarkerFor(sessionName) {
+        const rec = SessionCommandHelper.ownPasteMarkers.get(sessionName);
+        if (!rec)
+            return undefined;
+        if (SessionCommandHelper.now() - rec.at > TUI_INPUT_GUARD.OWN_MARKER_TTL_MS) {
+            SessionCommandHelper.ownPasteMarkers.delete(sessionName);
+            return undefined;
+        }
+        return rec.marker;
+    }
     constructor(backend) {
         this.logger = LoggerService.getInstance().createComponentLogger('SessionCommandHelper');
         this.backend = backend;
@@ -97,46 +136,258 @@ export class SessionCommandHelper {
         return this.backend.getSession(sessionName);
     }
     /**
-     * Send a message to a session with Enter key.
-     * For multi-line messages, sends the text first then Enter separately
-     * to avoid bracketed paste mode issues where Enter is treated as part of the paste.
+     * Send a message to an agent session and submit it with Enter — guarded.
+     *
+     * The harness only submits its own text (2026-10-03 phantom-input
+     * incident: a predicted "owner" message sitting in Claude Code's input
+     * was submitted with a delivery):
+     *
+     * 1. Before typing, the input box must be readable and empty. A leftover
+     *    exact copy of this message (an earlier attempt) is cleared; anything
+     *    else — someone's half-typed text, an unreadable screen — is left
+     *    untouched and nothing is typed.
+     * 2. The message is pasted (bracketed paste) without Enter.
+     * 3. Enter is pressed only when the box holds exactly the message (or the
+     *    runtime's collapsed "[Pasted text …]" marker). Otherwise nothing is
+     *    submitted and nothing is cleared: text we cannot prove is ours is
+     *    never wiped.
+     *
+     * A refusal throws `TuiInputGuardError`; agent delivery keeps the message
+     * queued and retries (AgentRegistrationService). Shell command lines
+     * typed before a runtime starts use {@link sendShellLine} instead.
      *
      * @param sessionName - The session to send to
      * @param message - The message to send
      * @throws Error if session does not exist
+     * @throws TuiInputGuardError when the box is unreadable or not ours
      */
-    async sendMessage(sessionName, message) {
+    async sendMessage(sessionName, message, options = {}) {
         const session = this.getSessionOrThrow(sessionName);
         this.logger.debug('Sending message to session', {
             sessionName,
             messageLength: message.length,
             isMultiLine: message.includes('\n'),
         });
-        // Wrap message in bracketed paste mode markers (\x1b[200~ ... \x1b[201~).
-        // This tells TUI applications (Gemini CLI, Codex CLI, Claude Code) to treat
-        // the input as pasted text rather than typed keystrokes. Without this, special
-        // characters like (), $, `, and " can trigger shell mode or be interpreted as
-        // key sequences in Gemini CLI (#292, #293).
-        const bracketedMessage = `\x1b[200~${message}\x1b[201~`;
-        // Send text first (in bracketed paste), then Enter separately to ensure submission
-        session.write(bracketedMessage);
+        // Step 1: the box must be readable and empty before we type.
+        let before = this.readInputBox(sessionName, message, 'before-write');
+        if (before.ownPasteMarker) {
+            // An earlier delivery of ours is still in the box (its Enter was
+            // lost): submit it first, then deliver this one.
+            this.logger.warn('An earlier paste of ours is still in the input box — submitting it before this message', { sessionName });
+            await this.ensureOwnPasteSubmitted(sessionName);
+            before = this.readInputBox(sessionName, message, 'before-write');
+        }
+        if (before.state === 'ours' && !before.ownPasteMarker) {
+            // Our own earlier paste of this very message: safe to clear.
+            before = await this.clearInputBox(sessionName, message, before);
+        }
+        if (before.state !== 'empty') {
+            this.logger.warn('Not typing into the input box: it is unreadable or holds text the harness did not write', {
+                sessionName,
+                state: before.state,
+                layout: before.layout,
+                inputPreview: before.text.slice(0, 80),
+            });
+            throw new TuiInputGuardError('before-write', before);
+        }
+        // Step 2: paste. Wrap the message in bracketed paste markers
+        // (\x1b[200~ ... \x1b[201~) so TUI applications (Gemini CLI, Codex CLI,
+        // Claude Code) treat it as pasted text rather than typed keystrokes.
+        // Without this, special characters like (), $, `, and " can trigger
+        // shell mode or be read as key sequences in Gemini CLI (#292, #293).
+        session.write(`\x1b[200~${message}\x1b[201~`);
         // Scale delay based on message size: large prompts (e.g. 409-line registration
         // prompts) need more time for Claude Code to process the bracketed paste.
         // Base delay + 1ms per 10 characters, capped at 5 seconds.
         const scaledDelay = Math.min(SESSION_COMMAND_DELAYS.MESSAGE_DELAY + Math.ceil(message.length / 10), 5000);
         await delay(scaledDelay);
+        // Step 3: submit only our own text.
+        let after = this.readInputBox(sessionName, message, 'after-paste');
+        for (const waitMs of TUI_INPUT_GUARD.PASTE_RENDER_RETRY_MS) {
+            if (after.state !== 'empty')
+                break;
+            await delay(waitMs); // the paste may not have rendered yet
+            after = this.readInputBox(sessionName, message, 'after-paste');
+        }
+        // Remember the collapsed marker only for callers that check the box
+        // after delivery (sendMessageWithRetry → ensureOwnPasteSubmitted);
+        // other paths leave no record that could outlive the paste.
+        if (options.recordPasteMarker && after.state === 'ours' && isPasteMarker(after.text)) {
+            SessionCommandHelper.ownPasteMarkers.set(sessionName, { marker: after.text.trim(), message, at: SessionCommandHelper.now() });
+        }
+        if (after.state !== 'ours') {
+            this.logger.warn('Input box does not hold exactly our text after the paste — not pressing Enter, not clearing', {
+                sessionName,
+                state: after.state,
+                layout: after.layout,
+                inputPreview: after.text.slice(0, 80),
+            });
+            throw new TuiInputGuardError('before-submit', after);
+        }
+        // The prompt this Enter submits is a harness delivery: a submitted
+        // prompt with no such write before it is recorded as unsolicited.
+        noteHarnessWrite(sessionName);
         // Send Enter explicitly as a separate keystroke
         // Use \r (carriage return) which is the standard Enter key in terminals
         session.write('\r');
         // Additional delay for Enter to be processed
         await delay(SESSION_COMMAND_DELAYS.KEY_DELAY);
-        // Log that we finished sending
         this.logger.debug('Message sent with Enter key', {
             sessionName,
             messageLength: message.length,
             pasteDelay: scaledDelay,
+            layout: after.layout,
         });
     }
+    /**
+     * After a delivery: if the box still holds the collapsed marker of our
+     * own paste, the Enter was lost — press Enter once and look again. Runs
+     * whatever the caller's success checks said: a fast-reply or weak-signal
+     * check can report "delivered" while the marker is still sitting there.
+     *
+     * @param sessionName - The session
+     * @returns `clear` (no marker of ours in the box), `submitted` (Enter took
+     *   it), or `stuck` (still there after one Enter — not delivered)
+     */
+    async ensureOwnPasteSubmitted(sessionName) {
+        const reading = this.readInputBox(sessionName, '', 'recovery');
+        if (!reading.ownPasteMarker)
+            return 'clear';
+        const session = this.getSessionOrThrow(sessionName);
+        noteHarnessWrite(sessionName);
+        session.write('\r');
+        await delay(TUI_INPUT_GUARD.OWN_MARKER_SUBMIT_SETTLE_MS);
+        const after = this.readInputBox(sessionName, '', 'recovery');
+        // One Enter on it, whatever happened: never press Enter on that marker
+        // again from this record.
+        SessionCommandHelper.ownPasteMarkers.delete(sessionName);
+        if (after.ownPasteMarker || (after.state === 'foreign' && after.text.trim() === reading.text.trim())) {
+            this.logger.warn('Our pasted message is still in the input box after Enter — not delivered', { sessionName });
+            return 'stuck';
+        }
+        this.logger.info('Submitted our own paste whose Enter had been lost', { sessionName });
+        return 'submitted';
+    }
+    /**
+     * Forget recorded paste markers (tests).
+     */
+    static resetOwnPasteMarkersForTesting() {
+        SessionCommandHelper.ownPasteMarkers.clear();
+    }
+    /**
+     * Type a command line into a plain shell and run it (paste + Enter).
+     *
+     * Only for the lines Crewly types into a session's login shell before a
+     * runtime starts there (history off, `cd`, PATH, the launch command). It
+     * does not read an input box: a shell has none. Never use it to talk to
+     * an agent — that is {@link sendMessage}.
+     *
+     * @param sessionName - The session
+     * @param line - The command line
+     */
+    async sendShellLine(sessionName, line) {
+        const session = this.getSessionOrThrow(sessionName);
+        // A shell line means the runtime is (re)starting in this session.
+        SessionCommandHelper.forgetOwnPaste(sessionName);
+        session.write(`\x1b[200~${line}\x1b[201~`);
+        await delay(Math.min(SESSION_COMMAND_DELAYS.MESSAGE_DELAY + Math.ceil(line.length / 10), 5000));
+        session.write('\r');
+        await delay(SESSION_COMMAND_DELAYS.KEY_DELAY);
+    }
+    /**
+     * Read what an agent's input box really holds, relative to a message.
+     *
+     * Uses the backend's faint-free screen view, so ghost text (Claude Code's
+     * prompt suggestion, placeholders) reads as an empty box. Returns
+     * `unknown` when the backend has no styled capture or no input box of a
+     * known layout is on screen.
+     *
+     * @param sessionName - The session to read
+     * @param message - The harness's message to compare against ('' for none)
+     * @param stage - Why it is read (see classifyTuiInput)
+     * @returns The reading
+     */
+    readInputBox(sessionName, message, stage = 'recovery') {
+        const capture = this.backend.captureInputView;
+        if (typeof capture !== 'function')
+            return { state: 'unknown', text: '', lineCount: 0 };
+        try {
+            const view = capture.call(this.backend, sessionName);
+            if (!view)
+                return { state: 'unknown', text: '', lineCount: 0 };
+            // The marker of our own recent paste is ours whatever we send next —
+            // and the record ends the moment the box shows anything else.
+            const own = SessionCommandHelper.ownMarkerFor(sessionName);
+            const reading = classifyTuiInput(view, message, stage, own);
+            if (own && reading.state !== 'unknown' && !reading.ownPasteMarker) {
+                SessionCommandHelper.ownPasteMarkers.delete(sessionName);
+            }
+            return reading;
+        }
+        catch {
+            return { state: 'unknown', text: '', lineCount: 0 };
+        }
+    }
+    /**
+     * Empty the input box — only call it for text proven to be the harness's
+     * own. Sends Ctrl+U then Backspace (clear the line, join the empty line to
+     * the one above), re-reading after each pair, until the box reads empty;
+     * one pair per line plus a margin (verified live on Claude Code, Codex
+     * and Gemini). A box that stops being readable is not "cleared": the
+     * final reading is then `unknown`, and callers treat only `empty` as
+     * success. Never sends Escape (cancels a running Claude Code turn; twice
+     * opens Rewind) or Ctrl+C (twice exits).
+     *
+     * @param sessionName - The session
+     * @param message - The harness's message, for classification
+     * @param current - A reading just taken (saves one re-read)
+     * @returns The final reading (`empty` when cleared)
+     */
+    async clearInputBox(sessionName, message, current) {
+        const session = this.getSessionOrThrow(sessionName);
+        let reading = current ?? this.readInputBox(sessionName, message, 'before-write');
+        if (reading.state === 'empty' || reading.state === 'unknown')
+            return reading;
+        const lines = Math.max(reading.lineCount, message.split('\n').length, 1);
+        const budget = Math.min(lines + TUI_INPUT_GUARD.CLEAR_PAIRS_EXTRA, TUI_INPUT_GUARD.CLEAR_PAIRS_MAX);
+        for (let i = 0; i < budget; i++) {
+            session.write(TUI_INPUT_GUARD.CLEAR_KEY);
+            session.write(TUI_INPUT_GUARD.JOIN_KEY);
+            await delay(TUI_INPUT_GUARD.CLEAR_SETTLE_MS);
+            reading = this.readInputBox(sessionName, message, 'before-write');
+            if (reading.state === 'empty' || reading.state === 'unknown')
+                break;
+        }
+        if (reading.state !== 'empty') {
+            this.logger.warn('Input box did not clear', { sessionName, state: reading.state, budget });
+        }
+        return reading;
+    }
+    /**
+     * Press Enter only when the input box holds exactly the harness's text.
+     * The safe replacement for "press Enter / Tab+Enter to recover a stuck
+     * message": an empty box (which may show a ghost suggestion) or a box
+     * with anyone else's text is never submitted.
+     *
+     * @param sessionName - The session
+     * @param message - The message the harness wrote
+     * @returns The reading; Enter was pressed only when its state is `ours`
+     */
+    async submitIfInputIsOurs(sessionName, message) {
+        const reading = this.readInputBox(sessionName, message, 'recovery');
+        if (reading.state !== 'ours') {
+            this.logger.debug('Not pressing Enter — input box does not hold our text', {
+                sessionName,
+                state: reading.state,
+            });
+            return reading;
+        }
+        const session = this.getSessionOrThrow(sessionName);
+        noteHarnessWrite(sessionName);
+        session.write('\r');
+        await delay(SESSION_COMMAND_DELAYS.KEY_DELAY);
+        return reading;
+    }
     /**
      * Send a key to a session
      *
@@ -188,61 +439,6 @@ export class SessionCommandHelper {
         this.logger.debug('Sent Escape to session', { sessionName });
         await delay(SESSION_COMMAND_DELAYS.KEY_DELAY);
     }
-    /**
-     * Gemini-specific message delivery (#130).
-     *
-     * Handles Ink TUI quirks:
-     * 1. Sends Escape to exit sub-modes (shell mode, error overlay)
-     * 2. Writes the message text
-     * 3. Uses a longer delay before Enter (Ink TUI needs processing time)
-     * 4. Verifies the message text left the input area (accepted)
-     *
-     * @param sessionName - The session to send to
-     * @param message - The message to send
-     * @returns true if post-write verification shows message was accepted
-     */
-    async sendMessageGemini(sessionName, message) {
-        const session = this.getSessionOrThrow(sessionName);
-        this.logger.debug('Gemini-specific message delivery', {
-            sessionName,
-            messageLength: message.length,
-        });
-        // Step 1: Escape to ensure we're not in a sub-mode
-        session.write('\x1b');
-        await delay(200);
-        // Step 2: Write the message text wrapped in bracketed paste markers.
-        // This prevents special characters from triggering shell mode (#292, #293).
-        session.write(`\x1b[200~${message}\x1b[201~`);
-        // Step 3: Longer delay for Ink TUI to process the paste
-        const scaledDelay = Math.min(SESSION_COMMAND_DELAYS.MESSAGE_DELAY + Math.ceil(message.length / 10), 5000);
-        await delay(scaledDelay);
-        // Step 4: Send Enter with extra delay for Ink TUI
-        session.write('\r');
-        await delay(SESSION_COMMAND_DELAYS.KEY_DELAY * 2);
-        // Step 5: Verify — check if message text disappeared from input area
-        try {
-            const postOutput = this.capturePane(sessionName, 10);
-            const msgSnippet = (message.length > 30
-                ? message.substring(0, 60)
-                : message).replace(/\s+/g, ' ').trim();
-            const bottomLines = postOutput.split('\n').slice(-5).join(' ').replace(/\s+/g, ' ');
-            const textStillPresent = bottomLines.includes(msgSnippet);
-            if (textStillPresent) {
-                this.logger.warn('Gemini message text still in input after send — Enter may have been dropped', {
-                    sessionName,
-                });
-                return false;
-            }
-            this.logger.debug('Gemini message delivery verified — text accepted', {
-                sessionName,
-            });
-            return true;
-        }
-        catch {
-            // Verification failed, but message may have been delivered
-            return true;
-        }
-    }
     /**
      * Detect and dismiss interactive prompts (e.g., plan mode) before message delivery.
      * Checks the last terminal output for plan mode patterns and sends Escape to exit
@@ -341,6 +537,7 @@ export class SessionCommandHelper {
      * Kill a session
      */
     async killSession(sessionName) {
+        SessionCommandHelper.forgetOwnPaste(sessionName);
         await this.backend.killSession(sessionName);
         this.logger.info('Session killed', { sessionName });
     }
@@ -354,6 +551,7 @@ export class SessionCommandHelper {
      */
     async createSession(sessionName, cwd, options) {
         this.logger.info('Creating session', { sessionName, cwd });
+        SessionCommandHelper.forgetOwnPaste(sessionName);
         // Default to shell if no command specified
         const command = options?.command || process.env.SHELL || '/bin/bash';
         const session = await this.backend.createSession(sessionName, {
@@ -567,235 +765,6 @@ export class SessionCommandHelper {
             });
         });
     }
-    /**
-     * Send message and wait for delivery confirmation via events.
-     *
-     * This is the core event-driven message delivery method. It:
-     * 1. Sends the message to the terminal
-     * 2. Subscribes to output to detect confirmation patterns
-     * 3. Resolves when confirmation is detected or timeout occurs
-     *
-     * @param sessionName - The session to send to
-     * @param message - The message to send
-     * @param confirmationPattern - Pattern indicating successful delivery
-     * @param timeoutMs - Maximum time to wait for confirmation
-     * @returns Promise resolving to true if confirmed, false if timeout
-     *
-     * @example
-     * ```typescript
-     * // Send message and wait for processing indicator
-     * const confirmed = await helper.sendMessageWithConfirmation(
-     *   'agent-1',
-     *   'Hello Claude',
-     *   /⠋|⠙|⠹|Thinking/,
-     *   5000
-     * );
-     * ```
-     */
-    async sendMessageWithConfirmation(sessionName, message, confirmationPattern, timeoutMs = EVENT_DELIVERY_CONSTANTS.DELIVERY_CONFIRMATION_TIMEOUT) {
-        const session = this.getSessionOrThrow(sessionName);
-        return new Promise((resolve) => {
-            let confirmed = false;
-            let resolved = false;
-            const cleanup = () => {
-                if (!resolved) {
-                    resolved = true;
-                    clearTimeout(timeoutId);
-                    unsubscribe();
-                }
-            };
-            const timeoutId = setTimeout(() => {
-                this.logger.debug('sendMessageWithConfirmation timed out', {
-                    sessionName,
-                    messageLength: message.length,
-                    confirmed,
-                });
-                cleanup();
-                resolve(confirmed);
-            }, timeoutMs);
-            const unsubscribe = session.onData((data) => {
-                if (resolved)
-                    return;
-                const match = typeof confirmationPattern === 'string'
-                    ? data.includes(confirmationPattern)
-                    : confirmationPattern.test(data);
-                if (match) {
-                    this.logger.debug('Message delivery confirmed', {
-                        sessionName,
-                        pattern: confirmationPattern.toString(),
-                    });
-                    confirmed = true;
-                    cleanup();
-                    resolve(true);
-                }
-            });
-            // Send the message
-            this.logger.debug('Sending message with confirmation tracking', {
-                sessionName,
-                messageLength: message.length,
-            });
-            session.write(message);
-            // Send Enter after a brief delay (for bracketed paste mode)
-            setTimeout(() => {
-                if (!resolved) {
-                    session.write('\r');
-                }
-            }, SESSION_COMMAND_DELAYS.MESSAGE_DELAY);
-        });
-    }
-    /**
-     * Smart message sending with event-driven paste detection.
-     *
-     * This method intelligently handles bracketed paste mode by:
-     * 1. Sending the message text
-     * 2. Waiting for "[Pasted text" indicator (paste received)
-     * 3. Sending Enter key only after paste is confirmed
-     * 4. Optionally waiting for processing indicators
-     *
-     * This is much more reliable than fixed delays because it detects
-     * the actual terminal state rather than guessing timing.
-     *
-     * @param sessionName - The session to send to
-     * @param message - The message to send
-     * @param options - Configuration options
-     * @returns Promise with delivery result
-     *
-     * @example
-     * ```typescript
-     * const result = await helper.sendMessageSmart('agent-1', 'Hello', {
-     *   waitForProcessing: true,
-     *   pasteTimeout: 3000,
-     * });
-     * if (result.pasteDetected && result.processingStarted) {
-     *   console.log('Message delivered and being processed');
-     * }
-     * ```
-     */
-    async sendMessageSmart(sessionName, message, options = {}) {
-        const session = this.getSessionOrThrow(sessionName);
-        const { pasteTimeout = 3000, processingTimeout = 5000, waitForProcessing = false, pastePattern = TERMINAL_PATTERNS.PASTE_INDICATOR, processingPattern = TERMINAL_PATTERNS.PROCESSING, fallbackDelay = 1500, } = options;
-        const result = {
-            pasteDetected: false,
-            enterSent: false,
-            processingStarted: false,
-            usedFallback: false,
-        };
-        this.logger.debug('Smart message send starting', {
-            sessionName,
-            messageLength: message.length,
-            isMultiLine: message.includes('\n'),
-        });
-        // Step 1: Send the message text (without Enter)
-        session.write(message);
-        // Step 2: Wait for paste detection or fallback
-        try {
-            await this.waitForPattern(sessionName, pastePattern, pasteTimeout);
-            result.pasteDetected = true;
-            this.logger.debug('Paste detected via pattern', { sessionName });
-        }
-        catch {
-            // Paste pattern not detected within timeout - use fallback delay
-            this.logger.debug('Paste pattern not detected, using fallback delay', {
-                sessionName,
-                fallbackDelay,
-            });
-            await delay(fallbackDelay);
-            result.usedFallback = true;
-        }
-        // Step 3: Send Enter key
-        session.write('\r');
-        result.enterSent = true;
-        this.logger.debug('Enter key sent', { sessionName });
-        // Step 4: Optionally wait for processing indicators
-        if (waitForProcessing) {
-            try {
-                await this.waitForPattern(sessionName, processingPattern, processingTimeout);
-                result.processingStarted = true;
-                this.logger.debug('Processing started', { sessionName });
-            }
-            catch {
-                this.logger.debug('Processing pattern not detected within timeout', {
-                    sessionName,
-                });
-            }
-        }
-        this.logger.debug('Smart message send complete', {
-            sessionName,
-            result,
-        });
-        return result;
-    }
-    /**
-     * Send message with retry logic using smart detection.
-     *
-     * Attempts to deliver a message with intelligent retry behavior:
-     * - Uses event-driven paste detection
-     * - Retries with Enter key if message appears stuck
-     * - Detects common failure modes (prompt still visible, no response)
-     *
-     * @param sessionName - The session to send to
-     * @param message - The message to send
-     * @param maxRetries - Maximum number of retry attempts
-     * @returns Promise resolving to true if message was successfully processed
-     */
-    async sendMessageWithSmartRetry(sessionName, message, maxRetries = 3) {
-        const session = this.getSessionOrThrow(sessionName);
-        // Dismiss plan mode if detected before attempting message delivery
-        await this.dismissInteractivePromptIfNeeded(sessionName);
-        // Use centralized patterns for consistency
-        const stuckPattern = TERMINAL_PATTERNS.PASTE_STUCK;
-        const processingPattern = TERMINAL_PATTERNS.PROCESSING;
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            this.logger.debug('Smart retry attempt', { sessionName, attempt, maxRetries });
-            if (attempt === 1) {
-                // First attempt: use smart send
-                const result = await this.sendMessageSmart(sessionName, message, {
-                    waitForProcessing: true,
-                    pasteTimeout: 3000,
-                    processingTimeout: 5000,
-                });
-                if (result.processingStarted) {
-                    this.logger.debug('Message delivered on first attempt', { sessionName });
-                    return true;
-                }
-            }
-            else {
-                // Retry attempts: just send Enter and check
-                this.logger.debug('Sending retry Enter', { sessionName, attempt });
-                session.write('\r');
-            }
-            // Wait a moment and check terminal state
-            await delay(1000);
-            // Capture current output to check state
-            const output = this.backend.captureOutput(sessionName, 10);
-            // Check if stuck (paste indicator still visible)
-            if (stuckPattern.test(output)) {
-                this.logger.debug('Message appears stuck, will retry with Enter', {
-                    sessionName,
-                    attempt,
-                });
-                continue;
-            }
-            // Check if processing started
-            if (processingPattern.test(output)) {
-                this.logger.debug('Processing detected after retry', { sessionName, attempt });
-                return true;
-            }
-            // Check if prompt appeared (message may have been processed already)
-            if (output.includes('❯') && !output.includes('[Pasted text')) {
-                this.logger.debug('Prompt visible without paste indicator - likely processed', {
-                    sessionName,
-                    attempt,
-                });
-                return true;
-            }
-        }
-        this.logger.warn('Message delivery failed after all retries', {
-            sessionName,
-            maxRetries,
-        });
-        return false;
-    }
     /**
      * Write raw data to session without Enter key.
      *