commandmate 0.1.12 → 0.2.1

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

@@ -0,0 +1,341 @@
+"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
+    // TODO [Issue #193]: This code path is unreachable (claude-poller.ts is superseded by response-poller.ts).
+    // When refactoring/removing claude-poller.ts, apply stripAnsi() + buildDetectPromptOptions() here.
+    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
+        // TODO [Issue #193]: This code path is unreachable (claude-poller.ts is superseded by response-poller.ts).
+        // When refactoring/removing claude-poller.ts, apply stripAnsi() + buildDetectPromptOptions() here.
+        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,7 +4,7 @@
  * 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.CLAUDE_PROMPT_POLL_INTERVAL = exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT = 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;
@@ -42,6 +42,9 @@ function getErrorMessage(error) {
  * - Authenticate with Anthropic servers (if needed)
  * - Display the interactive prompt
  *
+ * This timeout also covers trust dialog auto-response time (typically <1s).
+ * When reducing this value, consider dialog response overhead.
+ *
  * 15 seconds provides headroom for slower networks or cold starts.
  */
 exports.CLAUDE_INIT_TIMEOUT = 15000;
@@ -75,6 +78,24 @@ exports.CLAUDE_POST_PROMPT_DELAY = 500;
  * if it's still processing a previous request.
  */
 exports.CLAUDE_PROMPT_WAIT_TIMEOUT = 5000;
+/**
+ * Prompt wait timeout before message send (milliseconds).
+ *
+ * Used exclusively by sendMessageToClaude() to limit how long we wait
+ * for Claude to return to a prompt state before sending a user message.
+ * This is separate from CLAUDE_PROMPT_WAIT_TIMEOUT (5000ms, the default
+ * for waitForPrompt()) because sendMessageToClaude() may be called
+ * shortly after session initialization, where Claude CLI needs additional
+ * time to become ready.
+ *
+ * Relationship to other timeout constants:
+ * - CLAUDE_PROMPT_WAIT_TIMEOUT (5000ms): Default for waitForPrompt()
+ * - CLAUDE_SEND_PROMPT_WAIT_TIMEOUT (10000ms): sendMessageToClaude() specific
+ * - CLAUDE_INIT_TIMEOUT (15000ms): Session initialization timeout
+ *
+ * @see Issue #187 - Constant unification for sendMessageToClaude timeout
+ */
+exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT = 10000;
 /**
  * Prompt wait polling interval (milliseconds)
  *
@@ -227,7 +248,6 @@ async function waitForPrompt(sessionName, timeout = exports.CLAUDE_PROMPT_WAIT_T
  * await startClaudeSession({
  *   worktreeId: 'feature-foo',
  *   worktreePath: '/path/to/worktree',
- *   baseUrl: 'http://localhost:3000',
  * });
  * ```
  */
@@ -262,21 +282,33 @@ async function startClaudeSession(options) {
         const pollInterval = exports.CLAUDE_INIT_POLL_INTERVAL;
         const startTime = Date.now();
         let initialized = false;
+        let trustDialogHandled = 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 (DRY-001, DRY-002)
-                // Use patterns from cli-patterns.ts for consistency
+                // Claude is ready when we see the prompt (DRY-001)
+                // Use CLAUDE_PROMPT_PATTERN from cli-patterns.ts for consistency
                 // Strip ANSI escape sequences before pattern matching (Issue #152)
+                // Note: CLAUDE_SEPARATOR_PATTERN was removed from initialization check (Issue #187, P1-1)
+                // because separator early-detection caused premature returns before prompt was ready
                 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)) {
+                if (cli_patterns_1.CLAUDE_PROMPT_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;
                 }
+                // Issue #201: Detect trust dialog and auto-respond with Enter
+                // Condition order: CLAUDE_PROMPT_PATTERN (above) is checked first for shortest path
+                if (!trustDialogHandled && cli_patterns_1.CLAUDE_TRUST_DIALOG_PATTERN.test(cleanOutput)) {
+                    await (0, tmux_1.sendKeys)(sessionName, '', true);
+                    trustDialogHandled = true;
+                    // TODO: Log output method unification (console.log vs createLogger) to be addressed in a separate Issue (SF-002)
+                    console.log('Trust dialog detected, sending Enter to confirm');
+                    // Continue polling to wait for prompt detection
+                }
             }
             catch {
                 // Ignore capture errors during initialization
@@ -312,23 +344,21 @@ async function sendMessageToClaude(worktreeId, message) {
         throw new Error(`Claude session ${sessionName} does not exist. Start the session first.`);
     }
     // 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`);
-        }
+        // Path B: Prompt not detected - wait for it (P1: throw on timeout)
+        await waitForPrompt(sessionName, exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT);
     }
+    // P0: Stability delay after prompt detection (both Path A and Path B)
+    // Same delay as startClaudeSession() to ensure Claude CLI input handler is ready
+    // NOTE: This 500ms delay also applies to 2nd+ messages. Currently acceptable since
+    // Claude CLI response time (seconds to tens of seconds) dwarfs this overhead.
+    // If future batch-send use cases arise, this could be optimized to first-message-only,
+    // but that optimization is deferred per YAGNI principle. (ref: F-3)
+    await new Promise((resolve) => setTimeout(resolve, exports.CLAUDE_POST_PROMPT_DELAY));
     // 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
+    await (0, tmux_1.sendKeys)(sessionName, message, false);
+    await (0, tmux_1.sendKeys)(sessionName, '', true);
     console.log(`Sent message to Claude session: ${sessionName}`);
 }
 /**
@@ -403,7 +433,6 @@ async function stopClaudeSession(worktreeId) {
  * await restartClaudeSession({
  *   worktreeId: 'feature-foo',
  *   worktreePath: '/path/to/worktree',
- *   baseUrl: 'http://localhost:3000',
  * });
  * ```
  */

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

@@ -4,10 +4,11 @@
  * Shared between response-poller.ts and API routes
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GEMINI_PROMPT_PATTERN = exports.CODEX_SEPARATOR_PATTERN = exports.CODEX_PROMPT_PATTERN = exports.CLAUDE_SEPARATOR_PATTERN = exports.CLAUDE_PROMPT_PATTERN = exports.CODEX_THINKING_PATTERN = exports.CLAUDE_THINKING_PATTERN = exports.CLAUDE_SPINNER_CHARS = void 0;
+exports.GEMINI_PROMPT_PATTERN = exports.CODEX_SEPARATOR_PATTERN = exports.CODEX_PROMPT_PATTERN = exports.CLAUDE_TRUST_DIALOG_PATTERN = exports.CLAUDE_SEPARATOR_PATTERN = exports.CLAUDE_PROMPT_PATTERN = exports.CODEX_THINKING_PATTERN = exports.CLAUDE_THINKING_PATTERN = exports.CLAUDE_SPINNER_CHARS = void 0;
 exports.detectThinking = detectThinking;
 exports.getCliToolPatterns = getCliToolPatterns;
 exports.stripAnsi = stripAnsi;
+exports.buildDetectPromptOptions = buildDetectPromptOptions;
 const logger_1 = require("./logger");
 const logger = (0, logger_1.createLogger)('cli-patterns');
 /**
@@ -23,13 +24,20 @@ exports.CLAUDE_SPINNER_CHARS = [
  * Claude thinking pattern
  * Matches spinner character followed by activity text ending with …
  * The text can contain spaces (e.g., "Verifying implementation (dead code detection)…")
+ *
+ * Alternative 2: "esc to interrupt" status bar text (Issue #XXX)
+ * Claude Code shows "esc to interrupt" in the terminal status bar during active processing.
+ * Previous pattern required closing paren `to interrupt\)` matching `(esc to interrupt)`,
+ * but Claude Code v2.x status bar format uses `· esc to interrupt ·` without parens.
+ * Updated to match `esc to interrupt` which covers both formats.
  */
-exports.CLAUDE_THINKING_PATTERN = new RegExp(`[${exports.CLAUDE_SPINNER_CHARS.join('')}]\\s+.+…|to interrupt\\)`, 'm');
+exports.CLAUDE_THINKING_PATTERN = new RegExp(`[${exports.CLAUDE_SPINNER_CHARS.join('')}]\\s+.+…|esc to interrupt`, 'm');
 /**
  * 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
@@ -44,10 +52,24 @@ exports.CLAUDE_PROMPT_PATTERN = /^[>❯](\s*$|\s+\S)/m;
  * Claude separator pattern
  */
 exports.CLAUDE_SEPARATOR_PATTERN = /^─{10,}$/m;
+/**
+ * Claude trust dialog pattern (Issue #201)
+ *
+ * Matches the "Quick safety check" dialog displayed by Claude CLI v2.x
+ * when accessing a workspace for the first time.
+ *
+ * Intentionally uses partial matching (no line-start anchor ^):
+ * Other pattern constants (CLAUDE_PROMPT_PATTERN, CLAUDE_SEPARATOR_PATTERN, etc.)
+ * use line-start anchors (^), but this pattern needs to match at any position
+ * within the tmux output buffer because the dialog text may appear after
+ * tmux padding or other output. (SF-001)
+ */
+exports.CLAUDE_TRUST_DIALOG_PATTERN = /Yes, I trust this folder/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 +136,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':
@@ -133,10 +160,46 @@ function getCliToolPatterns(cliToolId) {
     }
 }
 /**
- * Strip ANSI escape codes from a string
- * Optimized version at module level for performance
+ * Strip ANSI escape codes from a string.
+ * Optimized version at module level for performance.
+ *
+ * Covers:
+ * - SGR sequences: ESC[Nm (colors, bold, underline, etc.)
+ * - OSC sequences: ESC]...BEL (window title, hyperlinks, etc.)
+ * - CSI sequences: ESC[...letter (cursor movement, erase, etc.)
+ *
+ * Known limitations (SEC-002):
+ * - 8-bit CSI (0x9B): C1 control code form of CSI is not covered
+ * - DEC private modes: ESC[?25h and similar are not covered
+ * - Character set switching: ESC(0, ESC(B are not covered
+ * - Some RGB color forms: ESC[38;2;r;g;bm may not be fully matched
+ *
+ * In practice, tmux capture-pane output rarely contains these sequences,
+ * so the risk is low. Future consideration: adopt the `strip-ansi` npm package
+ * for more comprehensive coverage.
  */
 const ANSI_PATTERN = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07|\[[0-9;]*m/g;
 function stripAnsi(str) {
     return str.replace(ANSI_PATTERN, '');
 }
+/**
+ * Build DetectPromptOptions for a given CLI tool.
+ * Centralizes cliToolId-to-options mapping logic (DRY - MF-001).
+ *
+ * prompt-detector.ts remains CLI tool independent (Issue #161 principle);
+ * this function lives in cli-patterns.ts which already depends on CLIToolType.
+ *
+ * [Future extension memo (C-002)]
+ * If CLI tool count grows significantly (currently 3), consider migrating
+ * to a CLIToolConfig registry pattern where tool-specific settings
+ * (including promptDetectionOptions) are managed in a Record<CLIToolType, CLIToolConfig>.
+ *
+ * @param cliToolId - CLI tool identifier
+ * @returns DetectPromptOptions for the tool, or undefined for default behavior
+ */
+function buildDetectPromptOptions(cliToolId) {
+    if (cliToolId === 'claude') {
+        return { requireDefaultIndicator: false };
+    }
+    return undefined; // Default behavior (requireDefaultIndicator = true)
+}

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) {