commandmate 0.2.10 → 0.2.12

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

@@ -9,16 +9,19 @@
  * 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;
 exports.getAutoYesState = getAutoYesState;
 exports.setAutoYesEnabled = setAutoYesEnabled;
+exports.disableAutoYes = disableAutoYes;
 exports.clearAllAutoYesStates = clearAllAutoYesStates;
 exports.getActivePollerCount = getActivePollerCount;
 exports.clearAllPollerStates = clearAllPollerStates;
 exports.getLastServerResponseTimestamp = getLastServerResponseTimestamp;
+exports.executeRegexWithTimeout = executeRegexWithTimeout;
+exports.checkStopCondition = checkStopCondition;
 exports.startAutoYesPolling = startAutoYesPolling;
 exports.stopAutoYesPolling = stopAutoYesPolling;
 exports.stopAllAutoYesPolling = stopAllAutoYesPolling;
@@ -29,11 +32,14 @@ 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 +58,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 +78,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 +90,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,27 +113,29 @@ 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);
     if (!state)
         return null;
-    // Auto-disable if expired
+    // Auto-disable if expired (Issue #314: delegate to disableAutoYes)
     if (isAutoYesExpired(state)) {
-        const disabledState = {
-            ...state,
-            enabled: false,
-        };
-        autoYesStates.set(worktreeId, disabledState);
-        return disabledState;
+        return disableAutoYes(worktreeId, 'expired');
     }
     return state;
 }
@@ -117,8 +143,10 @@ function getAutoYesState(worktreeId) {
  * Set the auto-yes enabled state for a worktree
  * @param duration - Optional duration in milliseconds (must be an ALLOWED_DURATIONS value).
  *                   Defaults to DEFAULT_AUTO_YES_DURATION (1 hour) when omitted.
+ * @param stopPattern - Optional regex pattern for stop condition (Issue #314).
+ *                      When terminal output matches this pattern, auto-yes is automatically disabled.
  */
-function setAutoYesEnabled(worktreeId, enabled, duration) {
+function setAutoYesEnabled(worktreeId, enabled, duration, stopPattern) {
     if (enabled) {
         const now = Date.now();
         const effectiveDuration = duration ?? auto_yes_config_1.DEFAULT_AUTO_YES_DURATION;
@@ -126,23 +154,41 @@ function setAutoYesEnabled(worktreeId, enabled, duration) {
             enabled: true,
             enabledAt: now,
             expiresAt: now + effectiveDuration,
+            stopPattern,
         };
         autoYesStates.set(worktreeId, state);
         return state;
     }
     else {
-        const existing = autoYesStates.get(worktreeId);
-        const state = {
-            enabled: false,
-            enabledAt: existing?.enabledAt ?? 0,
-            expiresAt: existing?.expiresAt ?? 0,
-        };
-        autoYesStates.set(worktreeId, state);
-        return state;
+        // Issue #314: Delegate disable path to disableAutoYes()
+        return disableAutoYes(worktreeId);
     }
 }
 /**
- * Clear all auto-yes states (for testing)
+ * Disable auto-yes for a worktree with an optional reason.
+ * Preserves existing state fields (enabledAt, expiresAt, stopPattern) for inspection.
+ *
+ * Issue #314: Centralized disable logic for expiration, stop pattern match, and manual disable.
+ *
+ * @param worktreeId - Worktree identifier
+ * @param reason - Optional reason for disabling ('expired' | 'stop_pattern_matched')
+ * @returns Updated auto-yes state
+ */
+function disableAutoYes(worktreeId, reason) {
+    const existing = autoYesStates.get(worktreeId);
+    const state = {
+        enabled: false,
+        enabledAt: existing?.enabledAt ?? 0,
+        expiresAt: existing?.expiresAt ?? 0,
+        stopPattern: existing?.stopPattern,
+        stopReason: reason,
+    };
+    autoYesStates.set(worktreeId, state);
+    return state;
+}
+/**
+ * Clear all auto-yes states.
+ * @internal Exported for testing purposes only.
  */
 function clearAllAutoYesStates() {
     autoYesStates.clear();
@@ -151,28 +197,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 +237,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 +249,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 +261,97 @@ 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;
+}
+// =============================================================================
+// Stop Condition (Issue #314)
+// =============================================================================
+/**
+ * Execute a regex test with timeout protection.
+ * Uses synchronous execution with safe-regex2 pre-validation as the primary defense.
+ *
+ * Note: Node.js is single-threaded, so true async timeout requires Worker threads.
+ * The safe-regex2 pre-validation in validateStopPattern() prevents catastrophic
+ * backtracking patterns from reaching this function. The timeoutMs parameter is
+ * reserved for future Worker thread implementation.
+ *
+ * @internal Exported for testing purposes only.
+ * @param regex - Pre-compiled RegExp to test
+ * @param text - Text to test against
+ * @param _timeoutMs - Reserved for future timeout implementation (default: 100ms)
+ * @returns true/false for match result, null if execution failed
+ */
+function executeRegexWithTimeout(regex, text, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_timeoutMs = 100) {
+    try {
+        return regex.test(text);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if the terminal output matches the stop condition pattern.
+ * If matched, disables auto-yes and stops polling for the worktree.
+ *
+ * Security: Pattern is re-validated before execution to handle cases where
+ * a previously valid pattern becomes invalid (e.g., state corruption).
+ *
+ * @internal Exported for testing purposes only.
+ * @param worktreeId - Worktree identifier
+ * @param cleanOutput - ANSI-stripped terminal output to check
+ * @returns true if stop condition matched and auto-yes was disabled
+ */
+function checkStopCondition(worktreeId, cleanOutput) {
+    const autoYesState = getAutoYesState(worktreeId);
+    if (!autoYesState?.stopPattern)
+        return false;
+    const validation = (0, auto_yes_config_1.validateStopPattern)(autoYesState.stopPattern);
+    if (!validation.valid) {
+        console.warn('[Auto-Yes] Invalid stop pattern, disabling', { worktreeId });
+        disableAutoYes(worktreeId);
+        return false;
+    }
+    try {
+        const regex = new RegExp(autoYesState.stopPattern);
+        const matched = executeRegexWithTimeout(regex, cleanOutput);
+        if (matched === null) {
+            // Execution failed - disable to prevent future errors
+            console.warn('[Auto-Yes] Stop condition check failed, disabling pattern', { worktreeId });
+            disableAutoYes(worktreeId);
+            return false;
+        }
+        if (matched) {
+            disableAutoYes(worktreeId, 'stop_pattern_matched');
+            stopAutoYesPolling(worktreeId);
+            console.warn('[Auto-Yes] Stop condition matched, auto-yes disabled', { worktreeId });
+            return true;
+        }
+    }
+    catch {
+        console.warn('[Auto-Yes] Stop condition check error', { worktreeId });
+    }
+    return false;
+}
+/**
+ * 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 +374,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
@@ -242,11 +392,48 @@ async function pollAutoYes(worktreeId, cliToolId) {
             scheduleNextPoll(worktreeId, cliToolId);
             return;
         }
+        // 2.7. Check stop condition (Issue #314)
+        // After thinking check, before prompt detection: if terminal output matches
+        // the stop pattern, disable auto-yes and stop polling immediately.
+        //
+        // Delta-based check: Only check NEW output since Auto-Yes was enabled.
+        // On the first poll, establish the baseline output length (skip check to
+        // avoid matching pre-existing terminal content like shell prompts or paths).
+        // On subsequent polls, check only the output delta (new content appended).
+        // If the buffer shrank (tmux scrollback shifted), reset baseline and skip
+        // that cycle to avoid false positives from old content.
+        if (pollerState.stopCheckBaselineLength < 0) {
+            // First poll: set baseline, skip stop condition check
+            pollerState.stopCheckBaselineLength = cleanOutput.length;
+        }
+        else {
+            const baseline = pollerState.stopCheckBaselineLength;
+            if (cleanOutput.length > baseline) {
+                // Output grew: check only new content (delta)
+                const newContent = cleanOutput.substring(baseline);
+                pollerState.stopCheckBaselineLength = cleanOutput.length;
+                if (checkStopCondition(worktreeId, newContent)) {
+                    return;
+                }
+            }
+            else if (cleanOutput.length < baseline) {
+                // Buffer shrank (old lines dropped from scrollback): reset baseline
+                pollerState.stopCheckBaselineLength = cleanOutput.length;
+            }
+            // If length unchanged: no new content, skip check
+        }
         // 3. Detect prompt
         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;
         }
@@ -274,32 +461,47 @@ async function pollAutoYes(worktreeId, cliToolId) {
         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)
@@ -328,6 +530,8 @@ function startAutoYesPolling(worktreeId, cliToolId) {
         consecutiveErrors: 0,
         currentInterval: exports.POLLING_INTERVAL_MS,
         lastServerResponseTimestamp: null,
+        lastAnsweredPromptKey: null, // S2-F003: initialized to null
+        stopCheckBaselineLength: -1, // Issue #314 fix: -1 = first poll (baseline not set)
     };
     autoYesPollerStates.set(worktreeId, pollerState);
     // Start polling immediately
@@ -338,7 +542,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);
@@ -353,7 +560,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-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}`;
+}