commandmate 0.1.11 → 0.2.0

package/dist/server/src/lib/claude-poller.js

@@ -0,0 +1,337 @@
+"use strict";
+/**
+ * Claude response polling
+ * Periodically checks tmux sessions for Claude responses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startPolling = startPolling;
+exports.stopPolling = stopPolling;
+exports.stopAllPolling = stopAllPolling;
+exports.getActivePollers = getActivePollers;
+const claude_session_1 = require("./claude-session");
+const db_instance_1 = require("./db-instance");
+const db_1 = require("./db");
+const ws_server_1 = require("./ws-server");
+const prompt_detector_1 = require("./prompt-detector");
+const conversation_logger_1 = require("./conversation-logger");
+/**
+ * Polling interval in milliseconds (default: 2 seconds)
+ */
+const POLLING_INTERVAL = 2000;
+/**
+ * Maximum polling duration in milliseconds (default: 5 minutes)
+ */
+const MAX_POLLING_DURATION = 5 * 60 * 1000;
+/**
+ * Active pollers map: worktreeId -> NodeJS.Timeout
+ */
+const activePollers = new Map();
+/**
+ * Polling start times map: worktreeId -> timestamp
+ */
+const pollingStartTimes = new Map();
+/**
+ * Extract Claude response from tmux output
+ * Detects when Claude has completed a response by looking for the prompt
+ *
+ * @param output - Full tmux output
+ * @param lastCapturedLine - Number of lines previously captured
+ * @returns Extracted response or null if incomplete
+ */
+function extractClaudeResponse(output, lastCapturedLine) {
+    // Trim trailing empty lines from the output before processing
+    // This prevents the "last 20 lines" from being all empty due to tmux buffer padding
+    const rawLines = output.split('\n');
+    let trimmedLength = rawLines.length;
+    while (trimmedLength > 0 && rawLines[trimmedLength - 1].trim() === '') {
+        trimmedLength--;
+    }
+    const lines = rawLines.slice(0, trimmedLength);
+    const totalLines = lines.length;
+    // No new output (with buffer to handle newline inconsistencies)
+    if (totalLines < lastCapturedLine - 5) {
+        return null;
+    }
+    // Always check the last 20 lines for completion pattern (more robust than tracking line numbers)
+    const checkLineCount = 20;
+    const startLine = Math.max(0, totalLines - checkLineCount);
+    const linesToCheck = lines.slice(startLine);
+    const outputToCheck = linesToCheck.join('\n');
+    // Check if Claude has returned to prompt (indicated by the prompt symbols)
+    // Claude shows "> " or "❯ " or "─────" when waiting for input
+    // Supports both legacy '>' and new '❯' (U+276F) prompt characters
+    // Issue #132: Also matches prompts with recommended commands (e.g., "❯ /work-plan")
+    const promptPattern = /^[>❯](\s*$|\s+\S)/m;
+    const separatorPattern = /^─{50,}$/m;
+    // Check for thinking/processing indicators
+    // Claude shows various animations while thinking: ✻ Herding…, · Choreographing…, ∴ Thinking…, ✢ Doing…, ✳ Cascading…, etc.
+    // Match lines that contain: symbol + word + … OR just the symbol alone
+    const thinkingPattern = /[✻✽⏺·∴✢✳]/m;
+    const hasPrompt = promptPattern.test(outputToCheck);
+    const hasSeparator = separatorPattern.test(outputToCheck);
+    const isThinking = thinkingPattern.test(outputToCheck);
+    // Only consider complete if we have prompt + separator AND Claude is NOT thinking
+    if (hasPrompt && hasSeparator && !isThinking) {
+        // Claude has completed response
+        // Extract the response content from lastCapturedLine to the separator (not just last 20 lines)
+        const responseLines = [];
+        // Handle tmux buffer scrolling: if lastCapturedLine >= totalLines, the buffer has scrolled
+        // In this case, we need to find the response in the current visible buffer
+        let startIndex;
+        if (lastCapturedLine >= totalLines - 5) {
+            // Buffer may have scrolled - look for the start of the new response
+            // Find the last user input prompt ("> ...") to identify where the response starts
+            let foundUserPrompt = -1;
+            for (let i = totalLines - 1; i >= Math.max(0, totalLines - 50); i--) {
+                // Look for user input line (starts with "> " or "❯ " followed by content)
+                if (/^[>❯]\s+\S/.test(lines[i])) {
+                    foundUserPrompt = i;
+                    break;
+                }
+            }
+            // Start extraction from after the user prompt, or from a safe earlier point
+            startIndex = foundUserPrompt >= 0 ? foundUserPrompt + 1 : Math.max(0, totalLines - 40);
+        }
+        else {
+            // Normal case: start from lastCapturedLine
+            startIndex = Math.max(0, lastCapturedLine);
+        }
+        for (let i = startIndex; i < totalLines; i++) {
+            const line = lines[i];
+            // Skip separator lines
+            if (/^─{50,}$/.test(line)) {
+                continue;
+            }
+            // Stop at new prompt (supports both '>' and '❯')
+            if (/^[>❯]\s*$/.test(line)) {
+                break;
+            }
+            // Skip thinking/processing status lines (spinner char + activity text ending with …)
+            // Note: ⏺ is also used as a response marker, so we only skip if it looks like a thinking line
+            // Thinking line example: "✳ UIからジョブ再実行中… (esc to interrupt · 33m 44s · thinking)"
+            // Response line example: "⏺ 何かお手伝いできることはありますか？" (should NOT be skipped)
+            if (/[✻✽·∴✢✳⦿◉●○◌◎⊙⊚⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s*\S+…/.test(line) || /to interrupt\)/.test(line)) {
+                continue;
+            }
+            // Skip tip lines and decoration lines
+            if (/^\s*[⎿⏋]\s+Tip:/.test(line) || /^\s*Tip:/.test(line)) {
+                continue;
+            }
+            responseLines.push(line);
+        }
+        const response = responseLines.join('\n').trim();
+        // Additional check: ensure response doesn't contain thinking indicators
+        // This prevents saving intermediate states as final responses
+        if (thinkingPattern.test(response)) {
+            console.warn(`[Poller] Response contains thinking indicators, treating as incomplete`);
+            return {
+                response: '',
+                isComplete: false,
+                lineCount: totalLines,
+            };
+        }
+        return {
+            response,
+            isComplete: true,
+            lineCount: totalLines,
+        };
+    }
+    // Check if this is an interactive prompt (yes/no or multiple choice)
+    // Interactive prompts don't have the ">" prompt and separator, so we need to detect them separately
+    if (!isThinking) {
+        const fullOutput = lines.join('\n');
+        const promptDetection = (0, prompt_detector_1.detectPrompt)(fullOutput);
+        if (promptDetection.isPrompt) {
+            // This is an interactive prompt - consider it complete
+            return {
+                response: fullOutput,
+                isComplete: true,
+                lineCount: totalLines,
+            };
+        }
+    }
+    // Response not yet complete
+    return {
+        response: '',
+        isComplete: false,
+        lineCount: totalLines,
+    };
+}
+/**
+ * Check for Claude response once
+ *
+ * @param worktreeId - Worktree ID
+ * @returns True if response was found and processed
+ */
+async function checkForResponse(worktreeId) {
+    const db = (0, db_instance_1.getDbInstance)();
+    try {
+        // Get worktree to retrieve CLI tool ID
+        const worktree = (0, db_1.getWorktreeById)(db, worktreeId);
+        if (!worktree) {
+            console.error(`Worktree ${worktreeId} not found, stopping poller`);
+            stopPolling(worktreeId);
+            return false;
+        }
+        const cliToolId = worktree.cliToolId || 'claude';
+        // Check if Claude session is running
+        const running = await (0, claude_session_1.isClaudeRunning)(worktreeId);
+        if (!running) {
+            console.log(`Claude session not running for ${worktreeId}, stopping poller`);
+            stopPolling(worktreeId);
+            return false;
+        }
+        // Get session state (last captured line count)
+        const sessionState = (0, db_1.getSessionState)(db, worktreeId, cliToolId);
+        const lastCapturedLine = sessionState?.lastCapturedLine || 0;
+        // Capture current output
+        const output = await (0, claude_session_1.captureClaudeOutput)(worktreeId, 10000);
+        // Extract response
+        const result = extractClaudeResponse(output, lastCapturedLine);
+        if (!result) {
+            // No new output
+            return false;
+        }
+        if (!result.isComplete) {
+            return false;
+        }
+        // Response is complete! Check if it's a prompt
+        const promptDetection = (0, prompt_detector_1.detectPrompt)(result.response);
+        if (promptDetection.isPrompt) {
+            // This is a prompt - save as prompt message
+            console.log(`✓ Detected prompt for ${worktreeId}:`, promptDetection.promptData?.question);
+            const message = (0, db_1.createMessage)(db, {
+                worktreeId,
+                role: 'assistant',
+                content: promptDetection.cleanContent,
+                messageType: 'prompt',
+                promptData: promptDetection.promptData,
+                timestamp: new Date(),
+                cliToolId,
+            });
+            // Update session state
+            (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount);
+            // Broadcast to WebSocket
+            (0, ws_server_1.broadcastMessage)('message', {
+                worktreeId,
+                message,
+            });
+            console.log(`✓ Saved prompt message for ${worktreeId}`);
+            // Stop polling - waiting for user response
+            stopPolling(worktreeId);
+            return true;
+        }
+        // Normal response (not a prompt)
+        console.log(`✓ Detected Claude response for ${worktreeId}`);
+        // Validate response content is not empty
+        if (!result.response || result.response.trim() === '') {
+            console.warn(`⚠ Empty response detected for ${worktreeId}, continuing polling...`);
+            // Update session state but don't save the message
+            // Continue polling in case a prompt appears next
+            (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount);
+            return false;
+        }
+        // Create Markdown log file for the conversation pair
+        if (result.response) {
+            await (0, conversation_logger_1.recordClaudeConversation)(db, worktreeId, result.response, 'claude');
+        }
+        // Create Claude message in database
+        const message = (0, db_1.createMessage)(db, {
+            worktreeId,
+            role: 'assistant',
+            content: result.response,
+            messageType: 'normal',
+            timestamp: new Date(),
+            cliToolId,
+        });
+        // Update session state
+        (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount);
+        // Broadcast message to WebSocket clients
+        (0, ws_server_1.broadcastMessage)('message', {
+            worktreeId,
+            message,
+        });
+        console.log(`✓ Saved Claude response for ${worktreeId}`);
+        // Stop polling since we got the response
+        stopPolling(worktreeId);
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`Error checking for response (${worktreeId}):`, errorMessage);
+        return false;
+    }
+}
+/**
+ * Start polling for Claude response
+ *
+ * @param worktreeId - Worktree ID
+ *
+ * @example
+ * ```typescript
+ * startPolling('feature-foo');
+ * ```
+ */
+function startPolling(worktreeId) {
+    // Stop existing poller if any
+    stopPolling(worktreeId);
+    console.log(`Starting poller for ${worktreeId}`);
+    // Record start time
+    pollingStartTimes.set(worktreeId, Date.now());
+    // Start polling
+    const interval = setInterval(async () => {
+        console.log(`[Poller] Checking for response: ${worktreeId}`);
+        const startTime = pollingStartTimes.get(worktreeId);
+        // Check if max duration exceeded
+        if (startTime && Date.now() - startTime > MAX_POLLING_DURATION) {
+            console.log(`Polling timeout for ${worktreeId}, stopping`);
+            stopPolling(worktreeId);
+            return;
+        }
+        // Check for response
+        try {
+            await checkForResponse(worktreeId);
+        }
+        catch (error) {
+            console.error(`[Poller] Error in checkForResponse:`, error);
+        }
+    }, POLLING_INTERVAL);
+    activePollers.set(worktreeId, interval);
+}
+/**
+ * Stop polling for a worktree
+ *
+ * @param worktreeId - Worktree ID
+ *
+ * @example
+ * ```typescript
+ * stopPolling('feature-foo');
+ * ```
+ */
+function stopPolling(worktreeId) {
+    const interval = activePollers.get(worktreeId);
+    if (interval) {
+        clearInterval(interval);
+        activePollers.delete(worktreeId);
+        pollingStartTimes.delete(worktreeId);
+        console.log(`Stopped poller for ${worktreeId}`);
+    }
+}
+/**
+ * Stop all active pollers
+ * Used for cleanup on server shutdown
+ */
+function stopAllPolling() {
+    console.log(`Stopping all pollers (${activePollers.size} active)`);
+    for (const worktreeId of activePollers.keys()) {
+        stopPolling(worktreeId);
+    }
+}
+/**
+ * Get list of active pollers
+ *
+ * @returns Array of worktree IDs currently being polled
+ */
+function getActivePollers() {
+    return Array.from(activePollers.keys());
+}

package/dist/server/src/lib/claude-session.js

@@ -4,19 +4,84 @@
  * Manages Claude CLI sessions within tmux for each worktree
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_PROMPT_POLL_INTERVAL = exports.CLAUDE_PROMPT_WAIT_TIMEOUT = exports.CLAUDE_POST_PROMPT_DELAY = exports.CLAUDE_INIT_POLL_INTERVAL = exports.CLAUDE_INIT_TIMEOUT = void 0;
 exports.getSessionName = getSessionName;
 exports.isClaudeInstalled = isClaudeInstalled;
 exports.isClaudeRunning = isClaudeRunning;
 exports.getClaudeSessionState = getClaudeSessionState;
+exports.waitForPrompt = waitForPrompt;
 exports.startClaudeSession = startClaudeSession;
 exports.sendMessageToClaude = sendMessageToClaude;
 exports.captureClaudeOutput = captureClaudeOutput;
 exports.stopClaudeSession = stopClaudeSession;
 exports.restartClaudeSession = restartClaudeSession;
 const tmux_1 = require("./tmux");
+const cli_patterns_1 = require("./cli-patterns");
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// ----- Helper Functions -----
+/**
+ * Extract error message from unknown error type
+ * Provides consistent error message extraction across the module (DRY)
+ *
+ * @param error - Unknown error object
+ * @returns Error message string
+ */
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+// ----- Timeout and Polling Constants (OCP-001) -----
+// These constants are exported to allow configuration and testing.
+// Changing these values affects Claude CLI session startup behavior.
+/**
+ * Claude CLI initialization max wait time (milliseconds)
+ *
+ * This timeout allows sufficient time for Claude CLI to:
+ * - Load and initialize its internal state
+ * - Authenticate with Anthropic servers (if needed)
+ * - Display the interactive prompt
+ *
+ * 15 seconds provides headroom for slower networks or cold starts.
+ */
+exports.CLAUDE_INIT_TIMEOUT = 15000;
+/**
+ * Initialization polling interval (milliseconds)
+ *
+ * How frequently we check if Claude CLI has finished initializing.
+ * 300ms balances responsiveness with avoiding excessive polling overhead.
+ */
+exports.CLAUDE_INIT_POLL_INTERVAL = 300;
+/**
+ * Stability delay after prompt detection (milliseconds)
+ *
+ * This delay is necessary because Claude CLI renders its UI progressively:
+ * 1. The prompt character (> or U+276F) appears first
+ * 2. Additional UI elements (tips, suggestions) may render afterward
+ * 3. Sending input too quickly can interrupt this rendering process
+ *
+ * The 500ms value was empirically determined to provide sufficient buffer
+ * for Claude CLI to complete its initialization rendering while maintaining
+ * responsive user experience. (DOC-001)
+ *
+ * @see Issue #152 - First message not being sent after session start
+ */
+exports.CLAUDE_POST_PROMPT_DELAY = 500;
+/**
+ * Prompt wait timeout before message send (milliseconds)
+ *
+ * When sending a message, we first verify Claude is at a prompt state.
+ * This timeout limits how long we wait for Claude to return to prompt
+ * if it's still processing a previous request.
+ */
+exports.CLAUDE_PROMPT_WAIT_TIMEOUT = 5000;
+/**
+ * Prompt wait polling interval (milliseconds)
+ *
+ * How frequently we check for prompt state before sending messages.
+ * 200ms provides quick response while minimizing CPU usage.
+ */
+exports.CLAUDE_PROMPT_POLL_INTERVAL = 200;
 /**
  * Cached Claude CLI path
  */
@@ -122,6 +187,35 @@ async function getClaudeSessionState(worktreeId) {
         lastActivity: new Date(),
     };
 }
+/**
+ * Wait for session to be at prompt state
+ * Polls for prompt detection using CLAUDE_PROMPT_PATTERN (DRY-001)
+ *
+ * @param sessionName - tmux session name
+ * @param timeout - Timeout in milliseconds (default: CLAUDE_PROMPT_WAIT_TIMEOUT)
+ * @throws {Error} If prompt is not detected within timeout
+ *
+ * @example
+ * ```typescript
+ * await waitForPrompt('mcbd-claude-feature-foo');
+ * // Session is now ready to receive input
+ * ```
+ */
+async function waitForPrompt(sessionName, timeout = exports.CLAUDE_PROMPT_WAIT_TIMEOUT) {
+    const startTime = Date.now();
+    const pollInterval = exports.CLAUDE_PROMPT_POLL_INTERVAL;
+    while (Date.now() - startTime < timeout) {
+        // Use -50 lines to capture more context including status bars
+        const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -50 });
+        // DRY-001: Use CLAUDE_PROMPT_PATTERN from cli-patterns.ts
+        // Strip ANSI escape sequences before pattern matching (Issue #152)
+        if (cli_patterns_1.CLAUDE_PROMPT_PATTERN.test((0, cli_patterns_1.stripAnsi)(output))) {
+            return; // Prompt detected
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Prompt detection timeout (${timeout}ms)`);
+}
 /**
  * Start a Claude CLI session in tmux
  *
@@ -162,18 +256,25 @@ async function startClaudeSession(options) {
         const claudePath = await getClaudePath();
         // Start Claude CLI in interactive mode using dynamically resolved path
         await (0, tmux_1.sendKeys)(sessionName, claudePath, true);
-        // Wait for Claude to initialize with dynamic detection
-        // Check for Claude prompt instead of fixed delay
-        const maxWaitTime = 10000; // 10 seconds max
-        const pollInterval = 500; // Check every 500ms
+        // Wait for Claude to initialize with dynamic detection (OCP-001)
+        // Use constants instead of hardcoded values
+        const maxWaitTime = exports.CLAUDE_INIT_TIMEOUT;
+        const pollInterval = exports.CLAUDE_INIT_POLL_INTERVAL;
         const startTime = Date.now();
+        let initialized = false;
         while (Date.now() - startTime < maxWaitTime) {
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
             try {
                 const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -50 });
-                // Claude is ready when we see the prompt (> ) or separator line
-                if (/^>\s*$/m.test(output) || /^─{10,}$/m.test(output)) {
-                    console.log(`✓ Claude initialized in ${Date.now() - startTime}ms`);
+                // Claude is ready when we see the prompt or separator line (DRY-001, DRY-002)
+                // Use patterns from cli-patterns.ts for consistency
+                // Strip ANSI escape sequences before pattern matching (Issue #152)
+                const cleanOutput = (0, cli_patterns_1.stripAnsi)(output);
+                if (cli_patterns_1.CLAUDE_PROMPT_PATTERN.test(cleanOutput) || cli_patterns_1.CLAUDE_SEPARATOR_PATTERN.test(cleanOutput)) {
+                    // Wait for stability after prompt detection (CONS-007, DOC-001)
+                    await new Promise((resolve) => setTimeout(resolve, exports.CLAUDE_POST_PROMPT_DELAY));
+                    console.log(`Claude initialized in ${Date.now() - startTime}ms`);
+                    initialized = true;
                     break;
                 }
             }
@@ -181,11 +282,14 @@ async function startClaudeSession(options) {
                 // Ignore capture errors during initialization
             }
         }
-        console.log(`✓ Started Claude session: ${sessionName}`);
+        // Throw error on timeout instead of silently continuing (CONS-005, IMP-001)
+        if (!initialized) {
+            throw new Error(`Claude initialization timeout (${exports.CLAUDE_INIT_TIMEOUT}ms)`);
+        }
+        console.log(`Started Claude session: ${sessionName}`);
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to start Claude session: ${errorMessage}`);
+        throw new Error(`Failed to start Claude session: ${getErrorMessage(error)}`);
     }
 }
 /**
@@ -207,21 +311,25 @@ async function sendMessageToClaude(worktreeId, message) {
     if (!exists) {
         throw new Error(`Claude session ${sessionName} does not exist. Start the session first.`);
     }
-    try {
-        // Send message to Claude (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, 100));
-        // Send Enter key to submit (single Enter submits in Claude Code CLI)
-        await execAsync(`tmux send-keys -t "${sessionName}" C-m`);
-        // Wait a moment for the message to be processed
-        await new Promise((resolve) => setTimeout(resolve, 200));
-        console.log(`✓ Sent message to Claude session: ${sessionName}`);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to send message to Claude: ${errorMessage}`);
+    // Verify prompt state before sending (CONS-006, DRY-001)
+    // Use -50 lines to ensure we capture the prompt even with status bars
+    const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -50 });
+    // Strip ANSI escape sequences before pattern matching (Issue #152)
+    if (!cli_patterns_1.CLAUDE_PROMPT_PATTERN.test((0, cli_patterns_1.stripAnsi)(output))) {
+        // Wait for prompt if not at prompt state
+        // Use longer timeout (10s) to handle slow responses
+        try {
+            await waitForPrompt(sessionName, 10000);
+        }
+        catch {
+            // Log warning but don't block - Claude might be in a special state
+            console.warn(`[sendMessageToClaude] Prompt not detected, sending anyway`);
+        }
     }
+    // Send message using sendKeys consistently (CONS-001)
+    await (0, tmux_1.sendKeys)(sessionName, message, false); // Message without Enter
+    await (0, tmux_1.sendKeys)(sessionName, '', true); // Enter key
+    console.log(`Sent message to Claude session: ${sessionName}`);
 }
 /**
  * Capture Claude session output
@@ -247,8 +355,7 @@ async function captureClaudeOutput(worktreeId, lines = 1000) {
         return await (0, tmux_1.capturePane)(sessionName, { startLine: -lines });
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to capture Claude output: ${errorMessage}`);
+        throw new Error(`Failed to capture Claude output: ${getErrorMessage(error)}`);
     }
 }
 /**
@@ -282,8 +389,7 @@ async function stopClaudeSession(worktreeId) {
         return killed;
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`Error stopping Claude session: ${errorMessage}`);
+        console.error(`Error stopping Claude session: ${getErrorMessage(error)}`);
         return false;
     }
 }

package/dist/server/src/lib/cli-patterns.js

@@ -28,8 +28,9 @@ exports.CLAUDE_THINKING_PATTERN = new RegExp(`[${exports.CLAUDE_SPINNER_CHARS.jo
 /**
  * Codex thinking pattern
  * Matches activity indicators like "• Planning", "• Searching", etc.
+ * T1.1: Extended to include "Ran" and "Deciding"
  */
-exports.CODEX_THINKING_PATTERN = /•\s*(Planning|Searching|Exploring|Running|Thinking|Working|Reading|Writing|Analyzing)/m;
+exports.CODEX_THINKING_PATTERN = /•\s*(Planning|Searching|Exploring|Running|Thinking|Working|Reading|Writing|Analyzing|Ran|Deciding)/m;
 /**
  * Claude prompt pattern (waiting for input)
  * Supports both legacy '>' and new '❯' (U+276F) prompt characters
@@ -46,8 +47,9 @@ exports.CLAUDE_PROMPT_PATTERN = /^[>❯](\s*$|\s+\S)/m;
 exports.CLAUDE_SEPARATOR_PATTERN = /^─{10,}$/m;
 /**
  * Codex prompt pattern
+ * T1.2: Improved to detect empty prompts as well
  */
-exports.CODEX_PROMPT_PATTERN = /^›\s+.+/m;
+exports.CODEX_PROMPT_PATTERN = /^›\s*/m;
 /**
  * Codex separator pattern
  */
@@ -114,6 +116,11 @@ function getCliToolPatterns(cliToolId) {
                     /^\s*for shortcuts$/, // Shortcuts hint
                     /╭─+╮/, // Box drawing (top)
                     /╰─+╯/, // Box drawing (bottom)
+                    // T1.3: Additional skip patterns for Codex
+                    /•\s*Ran\s+/, // Command execution lines
+                    /^\s*└/, // Tree output (completion indicator)
+                    /^\s*│/, // Continuation lines
+                    /\(.*esc to interrupt\)/, // Interrupt hint
                 ],
             };
         case 'gemini':

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

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseCLITool = void 0;
 const child_process_1 = require("child_process");
 const util_1 = require("util");
+const validation_1 = require("./validation");
 const tmux_1 = require("../tmux");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 /**
@@ -31,11 +32,16 @@ class BaseCLITool {
      * Generate session name for a worktree
      * Format: mcbd-{cli_tool_id}-{worktree_id}
      *
+     * T2.3: Added validation to prevent command injection (MF4-001)
+     *
      * @param worktreeId - Worktree ID
      * @returns Session name
+     * @throws Error if the resulting session name is invalid
      */
     getSessionName(worktreeId) {
-        return `mcbd-${this.id}-${worktreeId}`;
+        const sessionName = `mcbd-${this.id}-${worktreeId}`;
+        (0, validation_1.validateSessionName)(sessionName);
+        return sessionName;
     }
     /**
      * Interrupt processing by sending Escape key

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

@@ -10,6 +10,12 @@ const tmux_1 = require("../tmux");
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Codex initialization timing constants
+ * T2.6: Extracted as constants for maintainability
+ */
+const CODEX_INIT_WAIT_MS = 3000; // Wait for Codex to start
+const CODEX_MODEL_SELECT_WAIT_MS = 200; // Wait between model selection keystrokes
 /**
  * Codex CLI tool implementation
  * Manages Codex sessions using tmux
@@ -59,11 +65,17 @@ class CodexTool extends base_1.BaseCLITool {
             // Start Codex CLI in interactive mode
             await (0, tmux_1.sendKeys)(sessionName, 'codex', true);
             // Wait for Codex to initialize (and potentially show update notification)
-            await new Promise((resolve) => setTimeout(resolve, 3000));
+            await new Promise((resolve) => setTimeout(resolve, CODEX_INIT_WAIT_MS));
             // Auto-skip update notification if present (select option 2: Skip)
             await (0, tmux_1.sendKeys)(sessionName, '2', true);
             // Wait a moment for the selection to process
-            await new Promise((resolve) => setTimeout(resolve, 500));
+            await new Promise((resolve) => setTimeout(resolve, CODEX_MODEL_SELECT_WAIT_MS));
+            // T2.6: Skip model selection dialog by sending Down arrow + Enter
+            // This selects the default model and proceeds to the prompt
+            await execAsync(`tmux send-keys -t "${sessionName}" Down`);
+            await new Promise((resolve) => setTimeout(resolve, CODEX_MODEL_SELECT_WAIT_MS));
+            await execAsync(`tmux send-keys -t "${sessionName}" Enter`);
+            await new Promise((resolve) => setTimeout(resolve, CODEX_MODEL_SELECT_WAIT_MS));
             console.log(`✓ Started Codex session: ${sessionName}`);
         }
         catch (error) {