commandmate 0.2.9 → 0.2.11

package/dist/server/src/lib/auto-yes-manager.js

@@ -9,7 +9,7 @@
  * auto-yes responses when browser tabs are in background.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.THINKING_CHECK_LINE_COUNT = exports.MAX_CONCURRENT_POLLERS = exports.MAX_CONSECUTIVE_ERRORS = exports.MAX_BACKOFF_MS = exports.POLLING_INTERVAL_MS = void 0;
+exports.THINKING_CHECK_LINE_COUNT = exports.MAX_CONCURRENT_POLLERS = exports.MAX_CONSECUTIVE_ERRORS = exports.MAX_BACKOFF_MS = exports.COOLDOWN_INTERVAL_MS = exports.POLLING_INTERVAL_MS = void 0;
 exports.isValidWorktreeId = isValidWorktreeId;
 exports.calculateBackoffInterval = calculateBackoffInterval;
 exports.isAutoYesExpired = isAutoYesExpired;
@@ -25,15 +25,18 @@ exports.stopAllAutoYesPolling = stopAllAutoYesPolling;
 const cli_session_1 = require("./cli-session");
 const prompt_detector_1 = require("./prompt-detector");
 const auto_yes_resolver_1 = require("./auto-yes-resolver");
-const tmux_1 = require("./tmux");
+const prompt_answer_sender_1 = require("./prompt-answer-sender");
 const manager_1 = require("./cli-tools/manager");
 const cli_patterns_1 = require("./cli-patterns");
 const auto_yes_config_1 = require("../config/auto-yes-config");
+const prompt_key_1 = require("./prompt-key");
 // =============================================================================
 // Constants (Issue #138)
 // =============================================================================
 /** Polling interval in milliseconds */
 exports.POLLING_INTERVAL_MS = 2000;
+/** Cooldown interval after successful response (milliseconds) (Issue #306) */
+exports.COOLDOWN_INTERVAL_MS = 5000;
 /** Maximum backoff interval in milliseconds (60 seconds) */
 exports.MAX_BACKOFF_MS = 60000;
 /** Number of consecutive errors before applying backoff */
@@ -52,6 +55,16 @@ exports.MAX_CONCURRENT_POLLERS = 50;
 exports.THINKING_CHECK_LINE_COUNT = 50;
 /** Worktree ID validation pattern (security: prevent command injection) */
 const WORKTREE_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+/**
+ * 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, or 'Unknown error' for non-Error values
+ */
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : 'Unknown error';
+}
 /** In-memory storage for auto-yes states (globalThis for hot reload persistence) */
 const autoYesStates = globalThis.__autoYesStates ??
     (globalThis.__autoYesStates = new Map());
@@ -62,8 +75,11 @@ const autoYesPollerStates = globalThis.__autoYesPollerStates ??
 // Utility Functions
 // =============================================================================
 /**
- * Validate worktree ID format (security measure)
+ * Validate worktree ID format (security measure).
  * Only allows alphanumeric characters, hyphens, and underscores.
+ *
+ * @param worktreeId - Worktree ID to validate
+ * @returns true if the ID matches the allowed pattern
  */
 function isValidWorktreeId(worktreeId) {
     if (!worktreeId || worktreeId.length === 0)
@@ -71,7 +87,12 @@ function isValidWorktreeId(worktreeId) {
     return WORKTREE_ID_PATTERN.test(worktreeId);
 }
 /**
- * Calculate backoff interval based on consecutive errors
+ * Calculate backoff interval based on consecutive errors.
+ * Returns the normal polling interval when errors are below the threshold,
+ * and applies exponential backoff (capped at MAX_BACKOFF_MS) above it.
+ *
+ * @param consecutiveErrors - Number of consecutive errors encountered
+ * @returns Polling interval in milliseconds
  */
 function calculateBackoffInterval(consecutiveErrors) {
     if (consecutiveErrors < exports.MAX_CONSECUTIVE_ERRORS) {
@@ -89,14 +110,21 @@ function calculateBackoffInterval(consecutiveErrors) {
 // Auto-Yes State Management (Existing)
 // =============================================================================
 /**
- * Check if an auto-yes state has expired
+ * Check if an auto-yes state has expired.
+ * Compares current time against the expiresAt timestamp.
+ *
+ * @param state - Auto-yes state to check
+ * @returns true if the current time is past the expiration time
  */
 function isAutoYesExpired(state) {
     return Date.now() > state.expiresAt;
 }
 /**
- * Get the auto-yes state for a worktree
- * Returns null if no state exists or if expired (auto-disables on expiry)
+ * Get the auto-yes state for a worktree.
+ * Returns null if no state exists. If expired, auto-disables and returns the disabled state.
+ *
+ * @param worktreeId - Worktree identifier
+ * @returns Current auto-yes state, or null if no state exists
  */
 function getAutoYesState(worktreeId) {
     const state = autoYesStates.get(worktreeId);
@@ -142,7 +170,8 @@ function setAutoYesEnabled(worktreeId, enabled, duration) {
     }
 }
 /**
- * Clear all auto-yes states (for testing)
+ * Clear all auto-yes states.
+ * @internal Exported for testing purposes only.
  */
 function clearAllAutoYesStates() {
     autoYesStates.clear();
@@ -151,28 +180,38 @@ function clearAllAutoYesStates() {
 // Server-side Polling (Issue #138)
 // =============================================================================
 /**
- * Get the number of active pollers
+ * Get the number of active pollers.
+ *
+ * @returns Count of currently active polling instances
  */
 function getActivePollerCount() {
     return autoYesPollerStates.size;
 }
 /**
- * Clear all poller states (for testing)
+ * Clear all poller states.
+ * Stops all active pollers before clearing state.
+ * @internal Exported for testing purposes only.
  */
 function clearAllPollerStates() {
     stopAllAutoYesPolling();
     autoYesPollerStates.clear();
 }
 /**
- * Get the last server response timestamp for a worktree
- * Used by clients to prevent duplicate responses
+ * Get the last server response timestamp for a worktree.
+ * Used by clients to prevent duplicate responses.
+ *
+ * @param worktreeId - Worktree identifier
+ * @returns Timestamp (Date.now()) of the last server response, or null if none
  */
 function getLastServerResponseTimestamp(worktreeId) {
     const pollerState = autoYesPollerStates.get(worktreeId);
     return pollerState?.lastServerResponseTimestamp ?? null;
 }
 /**
- * Update the last server response timestamp
+ * Update the last server response timestamp.
+ *
+ * @param worktreeId - Worktree identifier
+ * @param timestamp - Timestamp value (Date.now())
  */
 function updateLastServerResponseTimestamp(worktreeId, timestamp) {
     const pollerState = autoYesPollerStates.get(worktreeId);
@@ -181,7 +220,9 @@ function updateLastServerResponseTimestamp(worktreeId, timestamp) {
     }
 }
 /**
- * Reset error count for a poller
+ * Reset error count for a poller and restore the default polling interval.
+ *
+ * @param worktreeId - Worktree identifier
  */
 function resetErrorCount(worktreeId) {
     const pollerState = autoYesPollerStates.get(worktreeId);
@@ -191,7 +232,9 @@ function resetErrorCount(worktreeId) {
     }
 }
 /**
- * Increment error count and apply backoff if needed
+ * Increment error count and apply backoff if the threshold is exceeded.
+ *
+ * @param worktreeId - Worktree identifier
  */
 function incrementErrorCount(worktreeId) {
     const pollerState = autoYesPollerStates.get(worktreeId);
@@ -201,7 +244,26 @@ function incrementErrorCount(worktreeId) {
     }
 }
 /**
- * Internal polling function (setTimeout recursive)
+ * Check if the given prompt has already been answered.
+ * Extracted from pollAutoYes() to reduce responsibility concentration (F005/SRP).
+ *
+ * @param pollerState - Current poller state containing the last answered prompt key
+ * @param promptKey - Composite key of the current prompt (generated by generatePromptKey)
+ * @returns true if the prompt key matches the last answered prompt key
+ */
+function isDuplicatePrompt(pollerState, promptKey) {
+    return pollerState.lastAnsweredPromptKey === promptKey;
+}
+/**
+ * Internal polling function that recursively schedules itself via setTimeout.
+ * Captures tmux output, detects prompts, and sends auto-responses when appropriate.
+ *
+ * Includes duplicate prevention (Issue #306): skips prompts that have already
+ * been answered (tracked via lastAnsweredPromptKey) and applies a cooldown
+ * interval (COOLDOWN_INTERVAL_MS) after successful responses.
+ *
+ * @param worktreeId - Worktree identifier
+ * @param cliToolId - CLI tool type being polled
  */
 async function pollAutoYes(worktreeId, cliToolId) {
     // Check if poller was stopped
@@ -224,7 +286,7 @@ async function pollAutoYes(worktreeId, cliToolId) {
         // while Claude is actively processing (thinking/planning).
         //
         // Issue #191: Apply windowing to detectThinking() to prevent stale thinking
-        // summary lines (e.g., "· Simmering…") from blocking prompt detection.
+        // summary lines (e.g., "· Simmering...") from blocking prompt detection.
         // Window size matches detectPrompt()'s multiple_choice scan range (50 lines).
         //
         // Safety: Claude CLI does not emit prompts during thinking, so narrowing
@@ -246,7 +308,14 @@ async function pollAutoYes(worktreeId, cliToolId) {
         const promptOptions = (0, cli_patterns_1.buildDetectPromptOptions)(cliToolId);
         const promptDetection = (0, prompt_detector_1.detectPrompt)(cleanOutput, promptOptions);
         if (!promptDetection.isPrompt || !promptDetection.promptData) {
-            // No prompt detected, schedule next poll
+            // No prompt detected - reset lastAnsweredPromptKey (Issue #306)
+            pollerState.lastAnsweredPromptKey = null;
+            scheduleNextPoll(worktreeId, cliToolId);
+            return;
+        }
+        // Issue #306: Check for duplicate prompt before responding
+        const promptKey = (0, prompt_key_1.generatePromptKey)(promptDetection.promptData);
+        if (isDuplicatePrompt(pollerState, promptKey)) {
             scheduleNextPoll(worktreeId, cliToolId);
             return;
         }
@@ -261,94 +330,60 @@ async function pollAutoYes(worktreeId, cliToolId) {
         const manager = manager_1.CLIToolManager.getInstance();
         const cliTool = manager.getTool(cliToolId);
         const sessionName = cliTool.getSessionName(worktreeId);
-        // Issue #193: Claude Code AskUserQuestion uses cursor-based navigation
-        // (Arrow/Space/Enter), not number input. Detect multi-choice and send
-        // appropriate key sequence instead of typing the number.
-        const isClaudeMultiChoice = cliToolId === 'claude'
-            && promptDetection.promptData?.type === 'multiple_choice'
-            && /^\d+$/.test(answer);
-        if (isClaudeMultiChoice && promptDetection.promptData?.type === 'multiple_choice') {
-            const targetNum = parseInt(answer, 10);
-            const mcOptions = promptDetection.promptData.options;
-            const defaultOption = mcOptions.find(o => o.isDefault);
-            const defaultNum = defaultOption?.number ?? 1;
-            const offset = targetNum - defaultNum;
-            // Detect multi-select (checkbox) prompts by checking for [ ] in option labels.
-            const isMultiSelect = mcOptions.some(o => /^\[[ x]\] /.test(o.label));
-            if (isMultiSelect) {
-                // Multi-select: toggle checkbox, then navigate to "Next" and submit
-                const checkboxCount = mcOptions.filter(o => /^\[[ x]\] /.test(o.label)).length;
-                const keys = [];
-                // 1. Navigate to target option
-                if (offset > 0) {
-                    for (let i = 0; i < offset; i++)
-                        keys.push('Down');
-                }
-                else if (offset < 0) {
-                    for (let i = 0; i < Math.abs(offset); i++)
-                        keys.push('Up');
-                }
-                // 2. Space to toggle checkbox
-                keys.push('Space');
-                // 3. Navigate to "Next" button (positioned right after all checkbox options)
-                const downToNext = checkboxCount - targetNum + 1;
-                for (let i = 0; i < downToNext; i++)
-                    keys.push('Down');
-                // 4. Enter to submit
-                keys.push('Enter');
-                await (0, tmux_1.sendSpecialKeys)(sessionName, keys);
-            }
-            else {
-                // Single-select: navigate and Enter to select
-                const keys = [];
-                if (offset > 0) {
-                    for (let i = 0; i < offset; i++)
-                        keys.push('Down');
-                }
-                else if (offset < 0) {
-                    for (let i = 0; i < Math.abs(offset); i++)
-                        keys.push('Up');
-                }
-                keys.push('Enter');
-                await (0, tmux_1.sendSpecialKeys)(sessionName, keys);
-            }
-        }
-        else {
-            // Standard CLI prompt: send text + Enter (y/n, Approve?, etc.)
-            await (0, tmux_1.sendKeys)(sessionName, answer, false);
-            await new Promise(resolve => setTimeout(resolve, 100));
-            await (0, tmux_1.sendKeys)(sessionName, '', true);
-        }
+        // Issue #287 Bug2: Uses shared sendPromptAnswer() to unify logic
+        // with route.ts, including cursor-key navigation for Claude Code
+        // multiple-choice prompts and fallback handling.
+        await (0, prompt_answer_sender_1.sendPromptAnswer)({
+            sessionName,
+            answer,
+            cliToolId,
+            promptData: promptDetection.promptData,
+        });
         // 6. Update timestamp
         updateLastServerResponseTimestamp(worktreeId, Date.now());
         // 7. Reset error count on success
         resetErrorCount(worktreeId);
+        // Issue #306: Record answered prompt key and apply cooldown
+        pollerState.lastAnsweredPromptKey = promptKey;
         // Log success (without sensitive content)
         console.info(`[Auto-Yes Poller] Sent response for worktree: ${worktreeId}`);
+        // Issue #306: Apply cooldown interval after successful response (early return)
+        scheduleNextPoll(worktreeId, cliToolId, exports.COOLDOWN_INTERVAL_MS);
+        return;
     }
     catch (error) {
         // Increment error count on failure
         incrementErrorCount(worktreeId);
         // Log error (without sensitive details)
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        console.warn(`[Auto-Yes Poller] Error for worktree ${worktreeId}: ${errorMessage}`);
+        console.warn(`[Auto-Yes Poller] Error for worktree ${worktreeId}: ${getErrorMessage(error)}`);
     }
-    // Schedule next poll
+    // Schedule next poll (catch block fallthrough or other paths)
     scheduleNextPoll(worktreeId, cliToolId);
 }
 /**
  * Schedule the next polling iteration
+ * @param overrideInterval - Optional interval in milliseconds (S2-F009: type definition).
+ *   When provided (e.g., COOLDOWN_INTERVAL_MS), overrides pollerState.currentInterval.
+ *   Type: number | undefined (optional parameter).
  */
-function scheduleNextPoll(worktreeId, cliToolId) {
+function scheduleNextPoll(worktreeId, cliToolId, overrideInterval) {
     const pollerState = autoYesPollerStates.get(worktreeId);
     if (!pollerState)
         return;
+    // S4-F003: Floor guard - polling interval must not be below POLLING_INTERVAL_MS
+    const interval = Math.max(overrideInterval ?? pollerState.currentInterval, exports.POLLING_INTERVAL_MS);
     pollerState.timerId = setTimeout(() => {
         pollAutoYes(worktreeId, cliToolId);
-    }, pollerState.currentInterval);
+    }, interval);
 }
 /**
- * Start server-side auto-yes polling for a worktree
+ * Start server-side auto-yes polling for a worktree.
+ * Validates the worktree ID, checks auto-yes state, enforces concurrent poller limits,
+ * and begins the polling loop.
+ *
+ * @param worktreeId - Worktree identifier (must match WORKTREE_ID_PATTERN)
+ * @param cliToolId - CLI tool type to poll for
+ * @returns Result indicating whether the poller was started, with reason if not
  */
 function startAutoYesPolling(worktreeId, cliToolId) {
     // Validate worktree ID (security)
@@ -377,6 +412,7 @@ function startAutoYesPolling(worktreeId, cliToolId) {
         consecutiveErrors: 0,
         currentInterval: exports.POLLING_INTERVAL_MS,
         lastServerResponseTimestamp: null,
+        lastAnsweredPromptKey: null, // S2-F003: initialized to null
     };
     autoYesPollerStates.set(worktreeId, pollerState);
     // Start polling immediately
@@ -387,7 +423,10 @@ function startAutoYesPolling(worktreeId, cliToolId) {
     return { started: true };
 }
 /**
- * Stop server-side auto-yes polling for a worktree
+ * Stop server-side auto-yes polling for a worktree.
+ * Clears the timer and removes the poller state.
+ *
+ * @param worktreeId - Worktree identifier
  */
 function stopAutoYesPolling(worktreeId) {
     const pollerState = autoYesPollerStates.get(worktreeId);
@@ -402,7 +441,8 @@ function stopAutoYesPolling(worktreeId) {
     console.info(`[Auto-Yes Poller] Stopped for worktree: ${worktreeId}`);
 }
 /**
- * Stop all server-side auto-yes polling (graceful shutdown)
+ * Stop all server-side auto-yes polling (graceful shutdown).
+ * Clears all timers and removes all poller states.
  */
 function stopAllAutoYesPolling() {
     for (const [worktreeId, pollerState] of autoYesPollerStates.entries()) {

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

@@ -6,6 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 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.clearCachedClaudePath = clearCachedClaudePath;
+exports.isSessionHealthy = isSessionHealthy;
 exports.getSessionName = getSessionName;
 exports.isClaudeInstalled = isClaudeInstalled;
 exports.isClaudeRunning = isClaudeRunning;
@@ -124,6 +125,17 @@ exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT = 10000;
  * 200ms provides quick response while minimizing CPU usage.
  */
 exports.CLAUDE_PROMPT_POLL_INTERVAL = 200;
+/**
+ * Maximum expected length of a shell prompt line (characters)
+ *
+ * Shell prompts are typically under 40 characters (e.g., "user@host:~/project$" ~30 chars).
+ * Lines at or above this threshold are not considered shell prompts, preventing
+ * false positives from Claude CLI output that happens to end with $, %, or #.
+ *
+ * Used by isSessionHealthy() to distinguish shell prompts from CLI output.
+ * 40 is an empirical threshold with safety margin.
+ */
+const MAX_SHELL_PROMPT_LENGTH = 40;
 /**
  * Cached Claude CLI path
  */
@@ -229,45 +241,69 @@ async function getCleanPaneOutput(sessionName, lines = 50) {
     const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -lines });
     return (0, cli_patterns_1.stripAnsi)(output);
 }
-// ----- Health Check Functions (Bug 2) -----
 /**
  * Verify that Claude CLI is actually running inside a tmux session
  * Detects broken sessions where tmux exists but Claude failed to start
  *
+ * @internal Exported for testing purposes only.
+ * Follows clearCachedClaudePath() precedent (L148-156).
+ *
  * @param sessionName - tmux session name
- * @returns true if Claude CLI is responsive (prompt detected or initializing)
+ * @returns HealthCheckResult with healthy status and optional reason
  */
 async function isSessionHealthy(sessionName) {
     try {
         // SF-001: Use shared helper instead of inline capturePane + stripAnsi
         const cleanOutput = await getCleanPaneOutput(sessionName);
-        // MF-001: Check error patterns from cli-patterns.ts (SRP - pattern management centralized)
-        for (const pattern of cli_patterns_1.CLAUDE_SESSION_ERROR_PATTERNS) {
-            if (cleanOutput.includes(pattern)) {
-                return false;
-            }
-        }
-        for (const regex of cli_patterns_1.CLAUDE_SESSION_ERROR_REGEX_PATTERNS) {
-            if (regex.test(cleanOutput)) {
-                return false;
-            }
-        }
         // MF-002: Check shell prompt endings from extensible array (OCP)
         const trimmed = cleanOutput.trim();
+        // S2-F010: Empty output judgment (HealthCheckResult format)
         // C-S2-001: Empty output means tmux session exists but Claude CLI has no output.
         // This is treated as unhealthy because a properly running Claude CLI always
         // produces output (prompt, spinner, or response). An empty pane indicates
         // the CLI process has exited or failed to start.
         if (trimmed === '') {
-            return false;
+            return { healthy: false, reason: 'empty output' };
         }
-        if (SHELL_PROMPT_ENDINGS.some(ending => trimmed.endsWith(ending))) {
-            return false;
+        // S2-F010: Error pattern detection (HealthCheckResult format)
+        // MF-001: Check error patterns from cli-patterns.ts (SRP - pattern management centralized)
+        for (const pattern of cli_patterns_1.CLAUDE_SESSION_ERROR_PATTERNS) {
+            if (trimmed.includes(pattern)) {
+                return { healthy: false, reason: `error pattern: ${pattern}` };
+            }
         }
-        return true;
+        for (const regex of cli_patterns_1.CLAUDE_SESSION_ERROR_REGEX_PATTERNS) {
+            if (regex.test(trimmed)) {
+                return { healthy: false, reason: `error pattern: ${regex.source}` };
+            }
+        }
+        // S2-F002: Extract last line after empty line filtering
+        const lines = trimmed.split('\n').filter(line => line.trim() !== '');
+        const lastLine = lines[lines.length - 1]?.trim() ?? '';
+        // F006: Line length check BEFORE SHELL_PROMPT_ENDINGS check (early return)
+        if (lastLine.length >= MAX_SHELL_PROMPT_LENGTH) {
+            // Long lines are not shell prompts -> treat as healthy (early return)
+            return { healthy: true };
+        }
+        // F003: Individual pattern exclusions for SHELL_PROMPT_ENDINGS
+        // NOTE(F003): If new false positive patterns are found in the future,
+        // consider refactoring to a structure that associates exclusionPattern
+        // with each SHELL_PROMPT_ENDINGS entry. Currently only % needs exclusion (YAGNI).
+        if (SHELL_PROMPT_ENDINGS.some(ending => {
+            if (!lastLine.endsWith(ending))
+                return false;
+            // Exclude N% pattern (e.g., "Context left until auto-compact: 7%")
+            if (ending === '%' && /\d+%$/.test(lastLine))
+                return false;
+            return true;
+        })) {
+            return { healthy: false, reason: `shell prompt ending detected: ${lastLine}` };
+        }
+        return { healthy: true };
     }
     catch {
-        return false;
+        // S3-F001: Catch block also returns HealthCheckResult format
+        return { healthy: false, reason: 'capture error' };
     }
 }
 /**
@@ -279,8 +315,9 @@ async function isSessionHealthy(sessionName) {
  * @returns true if session is healthy and can be reused, false if it was killed
  */
 async function ensureHealthySession(sessionName) {
-    const healthy = await isSessionHealthy(sessionName);
-    if (!healthy) {
+    const result = await isSessionHealthy(sessionName);
+    if (!result.healthy) {
+        console.warn(`[health-check] Session ${sessionName} unhealthy: ${result.reason}`);
         await (0, tmux_1.killSession)(sessionName);
         return false;
     }
@@ -376,7 +413,9 @@ async function isClaudeRunning(worktreeId) {
         return false;
     }
     // MF-S3-001: Verify session health to avoid reporting broken sessions as running
-    return isSessionHealthy(sessionName);
+    // S2-F001: await + extract .healthy to maintain boolean return type
+    const result = await isSessionHealthy(sessionName);
+    return result.healthy;
 }
 /**
  * Get Claude session state

package/dist/server/src/lib/prompt-answer-sender.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Shared prompt answer sender for cursor-key and text-based tmux input.
+ *
+ * Issue #287 Bug2: Extracted from route.ts and auto-yes-manager.ts to
+ * eliminate code duplication and ensure consistent behavior (including
+ * the promptType/defaultOptionNumber fallback introduced in Bug1).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendPromptAnswer = sendPromptAnswer;
+const tmux_1 = require("./tmux");
+/** Regex pattern to detect checkbox-style multi-select options */
+const CHECKBOX_OPTION_PATTERN = /^\[[ x]\] /;
+/**
+ * Build navigation key array for cursor movement.
+ * @param offset - positive = Down, negative = Up
+ */
+function buildNavigationKeys(offset) {
+    if (offset === 0)
+        return [];
+    const direction = offset > 0 ? 'Down' : 'Up';
+    return Array.from({ length: Math.abs(offset) }, () => direction);
+}
+/**
+ * Send an answer to a tmux session, using cursor-key navigation for
+ * Claude Code multiple-choice prompts and text input for everything else.
+ *
+ * This function unifies the logic previously duplicated in:
+ * - src/app/api/worktrees/[id]/prompt-response/route.ts (L114-187)
+ * - src/lib/auto-yes-manager.ts (L340-399)
+ */
+async function sendPromptAnswer(params) {
+    const { sessionName, answer, cliToolId, promptData, fallbackPromptType, fallbackDefaultOptionNumber } = params;
+    // Determine if this is a Claude Code multiple-choice prompt requiring cursor navigation
+    const isClaudeMultiChoice = cliToolId === 'claude'
+        && (promptData?.type === 'multiple_choice' || fallbackPromptType === 'multiple_choice')
+        && /^\d+$/.test(answer);
+    if (isClaudeMultiChoice) {
+        const targetNum = parseInt(answer, 10);
+        let defaultNum;
+        let mcOptions = null;
+        if (promptData?.type === 'multiple_choice') {
+            // Primary path: use fresh promptData
+            mcOptions = promptData.options;
+            const defaultOption = mcOptions.find(o => o.isDefault);
+            defaultNum = defaultOption?.number ?? 1;
+        }
+        else {
+            // Fallback path (Issue #287): promptData is undefined or type mismatch, use fallback fields
+            defaultNum = fallbackDefaultOptionNumber ?? 1;
+        }
+        const offset = targetNum - defaultNum;
+        // Detect multi-select (checkbox) prompts by checking for [ ] in option labels.
+        // Multi-select prompts require: Space to toggle checkbox -> navigate to "Next" -> Enter.
+        // Single-select prompts require: navigate to option -> Enter.
+        // Note: multi-select detection is only possible when promptData succeeded (mcOptions available).
+        const isMultiSelect = mcOptions !== null && mcOptions.some(o => CHECKBOX_OPTION_PATTERN.test(o.label));
+        if (isMultiSelect && mcOptions !== null) {
+            // Multi-select: toggle checkbox, then navigate to "Next" and submit
+            const checkboxCount = mcOptions.filter(o => CHECKBOX_OPTION_PATTERN.test(o.label)).length;
+            const keys = [
+                ...buildNavigationKeys(offset), // 1. Navigate to target option
+                'Space', // 2. Toggle checkbox
+            ];
+            // 3. Navigate to "Next" button (positioned right after all checkbox options)
+            const downToNext = checkboxCount - targetNum + 1;
+            keys.push(...buildNavigationKeys(downToNext));
+            // 4. Enter to submit
+            keys.push('Enter');
+            await (0, tmux_1.sendSpecialKeys)(sessionName, keys);
+        }
+        else {
+            // Single-select: navigate and Enter to select
+            const keys = [
+                ...buildNavigationKeys(offset),
+                'Enter',
+            ];
+            await (0, tmux_1.sendSpecialKeys)(sessionName, keys);
+        }
+    }
+    else {
+        // Standard CLI prompt: send text + Enter (y/n, Approve?, etc.)
+        await (0, tmux_1.sendKeys)(sessionName, answer, false);
+        // Wait a moment for the input to be processed
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Send Enter
+        await (0, tmux_1.sendKeys)(sessionName, '', true);
+    }
+}

package/dist/server/src/lib/prompt-detector.js

@@ -561,6 +561,15 @@ function detectMultipleChoicePrompt(output, options) {
             collectedOptions.unshift({ number, label, isDefault: false });
             continue;
         }
+        // [Issue #287 Bug3] User input prompt barrier:
+        // When no options have been collected yet and the line starts with ❯ (U+276F)
+        // but did NOT match DEFAULT_OPTION_PATTERN above, this line is a Claude Code
+        // user input prompt (e.g., "❯ 1", "❯ /command") or idle prompt ("❯").
+        // Anything above this line in the scrollback is historical conversation text,
+        // not an active prompt. Stop scanning to prevent false positives.
+        if (collectedOptions.length === 0 && line.startsWith('\u276F')) {
+            return noPromptResult(output);
+        }
         // Non-option line handling
         if (collectedOptions.length > 0 && line && !SEPARATOR_LINE_PATTERN.test(line)) {
             // [MF-001 / Issue #256] Check if line is a question-like line BEFORE

package/dist/server/src/lib/prompt-key.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePromptKey = generatePromptKey;
+/**
+ * Generate a composite key for prompt deduplication.
+ *
+ * Used by both client-side (useAutoYes.ts) and server-side (auto-yes-manager.ts)
+ * to ensure consistent prompt identification across the duplicate prevention system.
+ *
+ * The key format is `{type}:{question}`, which uniquely identifies a prompt
+ * by combining its type and question text.
+ *
+ * @param promptData - Prompt data containing type and question fields
+ * @returns Composite key string in the format "type:question"
+ *
+ * @internal Used for in-memory comparison only. Do NOT use for logging,
+ * persistence, or external output. If the return value is ever used in
+ * log output, DB storage, or HTML rendering, apply appropriate sanitization
+ * (CR/LF escaping, prepared statements, HTML escaping respectively).
+ * See SEC: S4-F001.
+ *
+ * @example
+ * ```typescript
+ * const key = generatePromptKey({ type: 'yes_no', question: 'Continue?' });
+ * // Returns 'yes_no:Continue?'
+ * ```
+ */
+function generatePromptKey(promptData) {
+    return `${promptData.type}:${promptData.question}`;
+}

package/package.json

@@ -1,7 +1,18 @@
 {
   "name": "commandmate",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Git worktree management with Claude CLI and tmux sessions",
+  "keywords": [
+    "claude-code",
+    "codex-cli",
+    "terminal",
+    "session-manager",
+    "tmux",
+    "git-worktree",
+    "ai-coding",
+    "cli",
+    "developer-tools"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/Kewton/CommandMate.git"