commandmate 0.1.12 → 0.2.1

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

@@ -8,6 +8,25 @@ exports.detectPrompt = detectPrompt;
 exports.getAnswerInput = getAnswerInput;
 const logger_1 = require("./logger");
 const logger = (0, logger_1.createLogger)('prompt-detector');
+/**
+ * Yes/no pattern definitions for data-driven matching.
+ * Each entry defines a regex pattern and its associated default option.
+ * Patterns are evaluated in order; the first match wins.
+ *
+ * Pattern format:
+ *   - regex: Must have a capture group (1) for the question text
+ *   - defaultOption: 'yes', 'no', or undefined (no default)
+ */
+const YES_NO_PATTERNS = [
+    // (y/n) - no default
+    { regex: /^(.+)\s+\(y\/n\)\s*$/m },
+    // [y/N] - default no
+    { regex: /^(.+)\s+\[y\/N\]\s*$/m, defaultOption: 'no' },
+    // [Y/n] - default yes
+    { regex: /^(.+)\s+\[Y\/n\]\s*$/m, defaultOption: 'yes' },
+    // (yes/no) - no default
+    { regex: /^(.+)\s+\(yes\/no\)\s*$/m },
+];
 /**
  * Detect if output contains an interactive prompt
  *
@@ -29,7 +48,7 @@ const logger = (0, logger_1.createLogger)('prompt-detector');
  * // result.promptData.question === 'Do you want to proceed?'
  * ```
  */
-function detectPrompt(output) {
+function detectPrompt(output, options) {
     logger.debug('detectPrompt:start', { outputLength: output.length });
     const lines = output.split('\n');
     const lastLines = lines.slice(-10).join('\n');
@@ -39,7 +58,7 @@ function detectPrompt(output) {
     // ❯ 1. Yes
     //   2. No
     //   3. Cancel
-    const multipleChoiceResult = detectMultipleChoicePrompt(output);
+    const multipleChoiceResult = detectMultipleChoicePrompt(output, options);
     if (multipleChoiceResult.isPrompt) {
         logger.info('detectPrompt:multipleChoice', {
             isPrompt: true,
@@ -48,74 +67,30 @@ function detectPrompt(output) {
         });
         return multipleChoiceResult;
     }
-    // Pattern 1: (y/n)
-    const yesNoPattern = /^(.+)\s+\(y\/n\)\s*$/m;
-    const match1 = lastLines.match(yesNoPattern);
-    if (match1) {
-        return {
-            isPrompt: true,
-            promptData: {
-                type: 'yes_no',
-                question: match1[1].trim(),
-                options: ['yes', 'no'],
-                status: 'pending',
-            },
-            cleanContent: match1[1].trim(),
-        };
-    }
-    // Pattern 2: [y/N] (N is default)
-    const yesNoDefaultPattern = /^(.+)\s+\[y\/N\]\s*$/m;
-    const match2 = lastLines.match(yesNoDefaultPattern);
-    if (match2) {
-        return {
-            isPrompt: true,
-            promptData: {
-                type: 'yes_no',
-                question: match2[1].trim(),
-                options: ['yes', 'no'],
-                status: 'pending',
-                defaultOption: 'no',
-            },
-            cleanContent: match2[1].trim(),
-        };
-    }
-    // Pattern 3: [Y/n] (Y is default)
-    const yesDefaultPattern = /^(.+)\s+\[Y\/n\]\s*$/m;
-    const match3 = lastLines.match(yesDefaultPattern);
-    if (match3) {
-        return {
-            isPrompt: true,
-            promptData: {
-                type: 'yes_no',
-                question: match3[1].trim(),
-                options: ['yes', 'no'],
-                status: 'pending',
-                defaultOption: 'yes',
-            },
-            cleanContent: match3[1].trim(),
-        };
-    }
-    // Pattern 4: (yes/no)
-    const yesNoFullPattern = /^(.+)\s+\(yes\/no\)\s*$/m;
-    const match4 = lastLines.match(yesNoFullPattern);
-    if (match4) {
-        return {
-            isPrompt: true,
-            promptData: {
-                type: 'yes_no',
-                question: match4[1].trim(),
-                options: ['yes', 'no'],
-                status: 'pending',
-            },
-            cleanContent: match4[1].trim(),
-        };
+    // Patterns 1-4: Yes/no patterns (data-driven matching)
+    for (const pattern of YES_NO_PATTERNS) {
+        const match = lastLines.match(pattern.regex);
+        if (match) {
+            const question = match[1].trim();
+            return {
+                isPrompt: true,
+                promptData: {
+                    type: 'yes_no',
+                    question,
+                    options: ['yes', 'no'],
+                    status: 'pending',
+                    ...(pattern.defaultOption !== undefined && { defaultOption: pattern.defaultOption }),
+                },
+                cleanContent: question,
+            };
+        }
     }
     // Pattern 5: Approve?
     // Matches "Approve?" on its own line or at the end of a line
     const approvePattern = /^(.*?)Approve\?\s*$/m;
-    const match5 = lastLines.match(approvePattern);
-    if (match5) {
-        const content = match5[1].trim();
+    const approveMatch = lastLines.match(approvePattern);
+    if (approveMatch) {
+        const content = approveMatch[1].trim();
         // If there's content before "Approve?", include it in the question
         const question = content ? `${content} Approve?` : 'Approve?';
         return {
@@ -147,14 +122,175 @@ const TEXT_INPUT_PATTERNS = [
     /custom/i,
     /differently/i,
 ];
+/**
+ * Pattern for ❯ (U+276F) indicator lines used by Claude CLI to mark the default selection.
+ * Used in Pass 1 (existence check) and Pass 2 (option collection) of the 2-pass detection.
+ * Anchored at both ends -- ReDoS safe (S4-001).
+ */
+const DEFAULT_OPTION_PATTERN = /^\s*\u276F\s*(\d+)\.\s*(.+)$/;
+/**
+ * Pattern for normal option lines (no ❯ indicator, just leading whitespace + number).
+ * Only applied in Pass 2 when ❯ indicator existence is confirmed by Pass 1.
+ * Anchored at both ends -- ReDoS safe (S4-001).
+ */
+const NORMAL_OPTION_PATTERN = /^\s*(\d+)\.\s*(.+)$/;
+/**
+ * Pattern for separator lines (horizontal rules).
+ * Matches lines consisting only of dash (-) or em-dash (─) characters.
+ * Used to skip separator lines in question extraction and non-option line handling.
+ * Anchored at both ends -- ReDoS safe (S4-001).
+ */
+const SEPARATOR_LINE_PATTERN = /^[-─]+$/;
+/**
+ * Creates a "no prompt detected" result.
+ * Centralizes the repeated pattern of returning isPrompt: false with trimmed content.
+ *
+ * @param output - The original output text
+ * @returns PromptDetectionResult with isPrompt: false
+ */
+function noPromptResult(output) {
+    return {
+        isPrompt: false,
+        cleanContent: output.trim(),
+    };
+}
+/**
+ * Pattern for detecting question/selection keywords in question lines.
+ * CLI tools typically use these keywords in the line immediately before numbered choices.
+ *
+ * Keyword classification:
+ *   [Observed] select, choose, pick, which, what, enter, confirm
+ *     - Keywords confirmed in actual Claude Code / CLI tool prompts.
+ *   [Defensive additions] how, where, type, specify, approve, accept, reject, decide, preference, option
+ *     - Not yet observed in actual prompts, but commonly used in question sentences.
+ *       Added defensively to reduce False Negative risk.
+ *     - Slightly beyond YAGNI, but False Positive risk from these keywords is
+ *       extremely low (they rarely appear in normal list headings).
+ *     - Consider removing unused keywords if confirmed unnecessary in the future.
+ *
+ * No word boundaries (\b) used -- partial matches (e.g., "Selections:" matching "select")
+ * are acceptable because such headings followed by consecutive numbered lists are
+ * likely actual prompts. See design policy IC-004 for tradeoff analysis.
+ *
+ * Alternation-only pattern with no nested quantifiers -- ReDoS safe (SEC-S4-002).
+ * The pattern consists only of OR (alternation) within a non-capturing group,
+ * resulting in a linear-time structure (O(n)) with no backtracking risk.
+ * Follows the 'ReDoS safe (S4-001)' annotation convention of existing patterns.
+ */
+const QUESTION_KEYWORD_PATTERN = /(?:select|choose|pick|which|what|how|where|enter|type|specify|confirm|approve|accept|reject|decide|preference|option)/i;
+/**
+ * Validates whether a question line actually asks a question or requests a selection.
+ * Distinguishes normal heading lines ("Recommendations:", "Steps:", etc.) from
+ * actual question lines ("Which option?", "Select a mode:", etc.).
+ *
+ * Control character resilience (SEC-S4-004): The line parameter is passed via
+ * lines[questionEndIndex]?.trim(), so residual control characters from tmux
+ * capture-pane output (8-bit CSI (0x9B), DEC private modes, etc. not fully
+ * removed by stripAnsi()) may be present. However, endsWith('?') / endsWith(':')
+ * inspect only the last character, and QUESTION_KEYWORD_PATTERN.test() matches
+ * only English letter keywords, so residual control characters will not match
+ * any pattern and the function returns false (false-safe).
+ *
+ * Full-width colon (U+FF1A) is intentionally not supported. Claude Code/CLI
+ * prompts use ASCII colon. See design policy IC-008.
+ *
+ * @param line - The line to validate (trimmed)
+ * @returns true if the line is a question/selection request, false otherwise
+ */
+function isQuestionLikeLine(line) {
+    // Empty lines are not questions
+    if (line.length === 0)
+        return false;
+    // Pattern 1: Lines ending with question mark (English or full-width Japanese)
+    // Full-width question mark (U+FF1F) support is a defensive measure: Claude Code/CLI
+    // displays questions in English, but this covers future multi-language support
+    // and third-party tool integration.
+    if (line.endsWith('?') || line.endsWith('\uff1f'))
+        return true;
+    // Pattern 2: Lines ending with colon that contain a selection/input keyword
+    // Examples: "Select an option:", "Choose a mode:", "Pick one:"
+    if (line.endsWith(':')) {
+        if (QUESTION_KEYWORD_PATTERN.test(line))
+            return true;
+    }
+    return false;
+}
+/**
+ * Defensive check: protection against future unknown false positive patterns.
+ * Note: The actual false positive pattern in Issue #161 ("1. Create file\n2. Run tests")
+ * IS consecutive from 1, so this validation alone does not prevent it.
+ * The primary defense layers are: Layer 1 (thinking check in caller) + Layer 2 (2-pass
+ * cursor detection). This function provides Layer 3 defense against future unknown
+ * patterns with scattered/non-consecutive numbering.
+ *
+ * [S3-010] This validation assumes Claude CLI always uses consecutive numbering
+ * starting from 1. If in the future Claude CLI is observed to filter choices and
+ * output non-consecutive numbers (e.g., 1, 2, 4), consider relaxing this validation
+ * (e.g., only check starts-from-1, remove consecutive requirement).
+ */
+function isConsecutiveFromOne(numbers) {
+    if (numbers.length === 0)
+        return false;
+    if (numbers[0] !== 1)
+        return false;
+    for (let i = 1; i < numbers.length; i++) {
+        if (numbers[i] !== numbers[i - 1] + 1)
+            return false;
+    }
+    return true;
+}
+/**
+ * Continuation line detection for multiline option text wrapping.
+ * Detects lines that are part of a previous option's text, wrapped due to terminal width.
+ *
+ * Called within detectMultipleChoicePrompt() Pass 2 reverse scan, only when
+ * options.length > 0 (at least one option already detected):
+ *   const rawLine = lines[i];       // Original line with indentation preserved
+ *   const line = lines[i].trim();   // Trimmed line
+ *   if (options.length > 0 && line && !line.match(/^[-─]+$/)) {
+ *     if (isContinuationLine(rawLine, line)) { continue; }
+ *   }
+ *
+ * Each condition's responsibility:
+ *   - hasLeadingSpaces: Indented non-option line (label text wrapping with indentation).
+ *     Excludes lines ending with '?' to prevent question lines (e.g., "  Do you want
+ *     to proceed?") from being misclassified as continuation. Claude Bash tool outputs
+ *     question and options with identical 2-space indentation, so this exclusion allows
+ *     the question line to be recognized as questionEndIndex instead of being skipped.
+ *   - isShortFragment: Short fragment (< 5 chars, e.g., filename tail)
+ *   - isPathContinuation: Path string continuation (Issue #181)
+ *
+ * @param rawLine - Original line with indentation preserved (lines[i])
+ * @param line - Trimmed line (lines[i].trim())
+ * @returns true if the line should be treated as a continuation of a previous option
+ */
+function isContinuationLine(rawLine, line) {
+    // Indented non-option line.
+    // Excludes lines ending with '?' or '？' (U+FF1F) because those are typically question lines
+    // (e.g., "  Do you want to proceed?", "  コピーしたい対象はどれですか？") from CLI tool output
+    // where both the question and options are 2-space indented. Without this exclusion,
+    // the question line would be misclassified as a continuation line, causing
+    // questionEndIndex to remain -1 and Layer 5 SEC-001 to block detection.
+    const endsWithQuestion = line.endsWith('?') || line.endsWith('\uff1f');
+    const hasLeadingSpaces = rawLine.match(/^\s{2,}[^\d]/) && !rawLine.match(/^\s*\d+\./) && !endsWithQuestion;
+    // Short fragment (< 5 chars, excluding question-ending lines)
+    const isShortFragment = line.length < 5 && !endsWithQuestion;
+    // Path string continuation: lines starting with / or ~, or alphanumeric-only fragments (2+ chars)
+    const isPathContinuation = /^[\/~]/.test(line) || (line.length >= 2 && /^[a-zA-Z0-9_-]+$/.test(line));
+    return !!hasLeadingSpaces || isShortFragment || isPathContinuation;
+}
 /**
  * Detect multiple choice prompts (numbered list with ❯ indicator)
  *
- * This function scans the output from bottom to top looking for numbered options
- * with a selection indicator (❯). It requires at least 2 options and a default
- * indicator to be considered a valid prompt.
+ * Uses a 2-pass detection approach (Issue #161):
+ * - Pass 1: Scan 50-line window for ❯ indicator lines (defaultOptionPattern).
+ *   If no ❯ lines found, immediately return isPrompt: false.
+ * - Pass 2: Only if ❯ was found, re-scan collecting options using both
+ *   defaultOptionPattern (isDefault=true) and normalOptionPattern (isDefault=false).
+ *
+ * This prevents normal numbered lists from being accumulated in the options array.
  *
- * Example:
+ * Example of valid prompt:
  * Do you want to proceed?
  * ❯ 1. Yes
  *   2. No
@@ -163,38 +299,67 @@ const TEXT_INPUT_PATTERNS = [
  * @param output - The tmux output to analyze (typically captured from tmux pane)
  * @returns Detection result with prompt data if a valid multiple choice prompt is found
  */
-function detectMultipleChoicePrompt(output) {
+function detectMultipleChoicePrompt(output, options) {
+    // C-003: Use ?? true for readability instead of !== false double negation
+    const requireDefault = options?.requireDefaultIndicator ?? true;
     const lines = output.split('\n');
-    // Look for lines that match the pattern: [optional leading spaces] [❯ or spaces] [number]. [text]
-    // Note: ANSI codes sometimes cause spaces to be lost after stripping, so we use \s* instead of \s+
-    const optionPattern = /^\s*([❯ ]\s*)?(\d+)\.\s*(.+)$/;
-    const options = [];
+    // Strip trailing empty lines (tmux terminal padding) before computing scan window.
+    // tmux buffers often end with many empty padding lines that would shift the
+    // scan window away from the actual prompt content.
+    let effectiveEnd = lines.length;
+    while (effectiveEnd > 0 && lines[effectiveEnd - 1].trim() === '') {
+        effectiveEnd--;
+    }
+    // Calculate scan window: last 50 non-trailing-empty lines
+    const scanStart = Math.max(0, effectiveEnd - 50);
+    // ==========================================================================
+    // Pass 1: Check for ❯ indicator existence in scan window
+    // If no ❯ lines found and requireDefault is true, there is no multiple_choice prompt.
+    // When requireDefault is false, skip this gate entirely to allow ❯-less detection.
+    // ==========================================================================
+    if (requireDefault) {
+        let hasDefaultLine = false;
+        for (let i = scanStart; i < effectiveEnd; i++) {
+            const line = lines[i].trim();
+            if (DEFAULT_OPTION_PATTERN.test(line)) {
+                hasDefaultLine = true;
+                break;
+            }
+        }
+        if (!hasDefaultLine) {
+            return noPromptResult(output);
+        }
+    }
+    // ==========================================================================
+    // Pass 2: Collect options (executed when Pass 1 passes or is skipped)
+    // Scan from end to find options, using both patterns.
+    // ==========================================================================
+    const collectedOptions = [];
     let questionEndIndex = -1;
-    let firstOptionIndex = -1;
-    // Scan from the end to find options
-    // Increased from 20 to 50 to handle multi-line wrapped options
-    for (let i = lines.length - 1; i >= 0 && i >= lines.length - 50; i--) {
+    for (let i = effectiveEnd - 1; i >= scanStart; i--) {
         const line = lines[i].trim();
-        const rawLine = lines[i]; // Keep original indentation for checking
-        const match = line.match(optionPattern);
-        if (match) {
-            const hasDefault = Boolean(match[1] && match[1].includes('❯'));
-            const number = parseInt(match[2], 10);
-            const label = match[3].trim();
-            // Insert at beginning since we're scanning backwards
-            options.unshift({ number, label, isDefault: hasDefault });
-            if (firstOptionIndex === -1) {
-                firstOptionIndex = i;
-            }
+        // Try DEFAULT_OPTION_PATTERN first (❯ indicator)
+        const defaultMatch = line.match(DEFAULT_OPTION_PATTERN);
+        if (defaultMatch) {
+            const number = parseInt(defaultMatch[1], 10);
+            const label = defaultMatch[2].trim();
+            collectedOptions.unshift({ number, label, isDefault: true });
+            continue;
+        }
+        // Try NORMAL_OPTION_PATTERN (no ❯ indicator)
+        const normalMatch = line.match(NORMAL_OPTION_PATTERN);
+        if (normalMatch) {
+            const number = parseInt(normalMatch[1], 10);
+            const label = normalMatch[2].trim();
+            collectedOptions.unshift({ number, label, isDefault: false });
+            continue;
         }
-        else if (options.length > 0 && line && !line.match(/^[-─]+$/)) {
-            // Check if this is a continuation line (indented line between options)
-            // Continuation lines typically start with spaces (like "  work/github...")
-            // Also treat very short lines (< 5 chars) as potential word-wrap fragments
-            const hasLeadingSpaces = rawLine.match(/^\s{2,}[^\d]/) && !rawLine.match(/^\s*\d+\./);
-            const isShortFragment = line.length < 5 && !line.endsWith('?');
-            const isContinuationLine = hasLeadingSpaces || isShortFragment;
-            if (isContinuationLine) {
+        // Non-option line handling
+        if (collectedOptions.length > 0 && line && !SEPARATOR_LINE_PATTERN.test(line)) {
+            // Check if this is a continuation line (indented line between options,
+            // or path/filename fragments from terminal width wrapping - Issue #181)
+            const rawLine = lines[i]; // Original line with indentation preserved
+            if (isContinuationLine(rawLine, line)) {
                 // Skip continuation lines and continue scanning for more options
                 continue;
             }
@@ -203,13 +368,34 @@ function detectMultipleChoicePrompt(output) {
             break;
         }
     }
-    // Must have at least 2 options AND at least one with ❯ indicator to be considered a prompt
-    const hasDefaultIndicator = options.some(opt => opt.isDefault);
-    if (options.length < 2 || !hasDefaultIndicator) {
-        return {
-            isPrompt: false,
-            cleanContent: output.trim(),
-        };
+    // Layer 3: Consecutive number validation (defensive measure)
+    const optionNumbers = collectedOptions.map(opt => opt.number);
+    if (!isConsecutiveFromOne(optionNumbers)) {
+        return noPromptResult(output);
+    }
+    // Layer 4: Must have at least 2 options. When requireDefault is true,
+    // also require at least one option with ❯ indicator.
+    const hasDefaultIndicator = collectedOptions.some(opt => opt.isDefault);
+    if (collectedOptions.length < 2 || (requireDefault && !hasDefaultIndicator)) {
+        return noPromptResult(output);
+    }
+    // Layer 5 [SEC-001]: Enhanced question line validation for requireDefaultIndicator=false.
+    // When requireDefault is false, apply stricter validation to prevent false positives
+    // from normal numbered lists (e.g., "Recommendations:\n1. Add tests\n2. Update docs").
+    if (!requireDefault) {
+        // SEC-001a: No question line found (questionEndIndex === -1) - reject.
+        // Prevents generic question fallback from triggering Auto-Yes
+        // on plain numbered lists that happen to be consecutive from 1.
+        if (questionEndIndex === -1) {
+            return noPromptResult(output);
+        }
+        // SEC-001b: Question line exists but is not actually a question/selection request.
+        // Validates that the question line contains a question mark or a selection keyword
+        // with colon, distinguishing "Select an option:" from "Recommendations:".
+        const questionLine = lines[questionEndIndex]?.trim() ?? '';
+        if (!isQuestionLikeLine(questionLine)) {
+            return noPromptResult(output);
+        }
     }
     // Extract question text
     let question = '';
@@ -218,7 +404,7 @@ function detectMultipleChoicePrompt(output) {
         const questionLines = [];
         for (let i = Math.max(0, questionEndIndex - 5); i <= questionEndIndex; i++) {
             const line = lines[i].trim();
-            if (line && !line.match(/^[-─]+$/)) {
+            if (line && !SEPARATOR_LINE_PATTERN.test(line)) {
                 questionLines.push(line);
             }
         }
@@ -233,7 +419,7 @@ function detectMultipleChoicePrompt(output) {
         promptData: {
             type: 'multiple_choice',
             question: question.trim(),
-            options: options.map(opt => {
+            options: collectedOptions.map(opt => {
                 // Check if this option requires text input using module-level patterns
                 const requiresTextInput = TEXT_INPUT_PATTERNS.some(pattern => pattern.test(opt.label));
                 return {
@@ -272,7 +458,8 @@ function getAnswerInput(answer, promptType = 'yes_no') {
         if (/^\d+$/.test(normalized)) {
             return normalized;
         }
-        throw new Error(`Invalid answer for multiple choice: ${answer}. Expected a number.`);
+        // SEC-003: Fixed error message without user input to prevent log injection
+        throw new Error('Invalid answer for multiple choice prompt. Expected a number.');
     }
     // Handle yes/no prompts
     if (normalized === 'yes' || normalized === 'y') {
@@ -281,5 +468,6 @@ function getAnswerInput(answer, promptType = 'yes_no') {
     if (normalized === 'no' || normalized === 'n') {
         return 'n';
     }
-    throw new Error(`Invalid answer: ${answer}. Expected 'yes', 'no', 'y', or 'n'.`);
+    // SEC-003: Fixed error message without user input to prevent log injection
+    throw new Error("Invalid answer for yes/no prompt. Expected 'yes', 'no', 'y', or 'n'.");
 }

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

@@ -1,7 +1,18 @@
 "use strict";
 /**
- * CLI Tool response polling
- * Periodically checks tmux sessions for CLI tool responses (Claude, Codex, Gemini)
+ * CLI Tool response polling.
+ * Periodically checks tmux sessions for CLI tool responses (Claude, Codex, Gemini).
+ *
+ * Key responsibilities:
+ * - Extract completed responses from tmux output (extractResponse)
+ * - Detect interactive prompts and save as prompt messages
+ * - Clean tool-specific artifacts from response content
+ * - Manage polling lifecycle (start/stop/timeout)
+ *
+ * Issue #188 improvements:
+ * - DR-004: Tail-line windowing for thinking detection in extractResponse
+ * - MF-001 fix: Same windowing applied to checkForResponse thinking check
+ * - SF-003: RESPONSE_THINKING_TAIL_LINE_COUNT constant tracks STATUS_THINKING_LINE_COUNT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cleanClaudeResponse = cleanClaudeResponse;
@@ -26,6 +37,22 @@ const POLLING_INTERVAL = 2000;
  * Maximum polling duration in milliseconds (default: 5 minutes)
  */
 const MAX_POLLING_DURATION = 5 * 60 * 1000;
+/**
+ * Number of tail lines to check for active thinking indicators in response extraction.
+ *
+ * SF-003 coupling note: This value must track STATUS_THINKING_LINE_COUNT (5) in
+ * status-detector.ts. Both constants exist because they serve separate modules:
+ *   - RESPONSE_THINKING_TAIL_LINE_COUNT: response-poller.ts (response extraction)
+ *   - STATUS_THINKING_LINE_COUNT: status-detector.ts (UI status display)
+ * If STATUS_THINKING_LINE_COUNT changes, update this value accordingly.
+ *
+ * Why not a shared constant? status-detector.ts has no dependency on response-poller.ts
+ * and vice versa. Introducing a shared module would create a coupling that does not
+ * currently exist. The test suite validates consistency (SF-003 test).
+ *
+ * @constant
+ */
+const RESPONSE_THINKING_TAIL_LINE_COUNT = 5;
 /**
  * Active pollers map: "worktreeId:cliToolId" -> NodeJS.Timeout
  */
@@ -40,6 +67,26 @@ const pollingStartTimes = new Map();
 function getPollerKey(worktreeId, cliToolId) {
     return `${worktreeId}:${cliToolId}`;
 }
+/**
+ * Internal helper: detect prompt with CLI-tool-specific options.
+ *
+ * Centralizes the stripAnsi() + buildDetectPromptOptions() + detectPrompt() pipeline
+ * to avoid repeating this 3-step sequence across extractResponse() and checkForResponse().
+ *
+ * Design notes:
+ * - IA-001: stripAnsi() is applied uniformly inside this helper. It is idempotent,
+ *   so double-application on already-stripped input is safe.
+ * - SF-003: Uses buildDetectPromptOptions() from cli-patterns.ts for tool-specific
+ *   configuration (e.g., Claude's requireDefaultIndicator=false for Issue #193).
+ *
+ * @param output - Raw or pre-stripped tmux output
+ * @param cliToolId - CLI tool identifier for building detection options
+ * @returns PromptDetectionResult with isPrompt, promptData, and cleanContent
+ */
+function detectPromptWithOptions(output, cliToolId) {
+    const promptOptions = (0, cli_patterns_1.buildDetectPromptOptions)(cliToolId);
+    return (0, prompt_detector_1.detectPrompt)((0, cli_patterns_1.stripAnsi)(output), promptOptions);
+}
 /**
  * Clean up Claude response by removing shell setup commands, environment exports, ANSI codes, and banner
  * Also extracts only the LATEST response to avoid including conversation history
@@ -209,14 +256,12 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
     // Permission prompts appear after normal responses and need special handling
     if (cliToolId === 'claude') {
         const fullOutput = lines.join('\n');
-        // Strip ANSI codes before prompt detection
-        const cleanFullOutput = (0, cli_patterns_1.stripAnsi)(fullOutput);
-        const promptDetection = (0, prompt_detector_1.detectPrompt)(cleanFullOutput);
+        const promptDetection = detectPromptWithOptions(fullOutput, cliToolId);
         if (promptDetection.isPrompt) {
             // Return the full output as a complete interactive prompt
             // Use the cleaned output without ANSI codes
             return {
-                response: cleanFullOutput,
+                response: (0, cli_patterns_1.stripAnsi)(fullOutput),
                 isComplete: true,
                 lineCount: totalLines,
             };
@@ -285,9 +330,10 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
             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)) {
+        // DR-004: Check only the tail of the response for thinking indicators.
+        // Prevents false blocking when completed thinking summaries appear in the response body.
+        const responseTailLines = response.split('\n').slice(-RESPONSE_THINKING_TAIL_LINE_COUNT).join('\n');
+        if (thinkingPattern.test(responseTailLines)) {
             return {
                 response: '',
                 isComplete: false,
@@ -347,18 +393,13 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
                     lineCount: totalLines,
                 };
             }
-            // Check for auth/loading states that should not be treated as complete responses
-            if (response.includes('Waiting for auth') ||
-                response.includes('⠋') ||
-                response.includes('⠙') ||
-                response.includes('⠹') ||
-                response.includes('⠸') ||
-                response.includes('⠼') ||
-                response.includes('⠴') ||
-                response.includes('⠦') ||
-                response.includes('⠧') ||
-                response.includes('⠇') ||
-                response.includes('⠏')) {
+            // Check for auth/loading states that should not be treated as complete responses.
+            // Braille spinner characters are shared with CLAUDE_SPINNER_CHARS in cli-patterns.ts.
+            const LOADING_INDICATORS = [
+                'Waiting for auth',
+                '⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏',
+            ];
+            if (LOADING_INDICATORS.some(indicator => response.includes(indicator))) {
                 return {
                     response: '',
                     isComplete: false,
@@ -382,7 +423,7 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
     // 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
     const fullOutput = lines.join('\n');
-    const promptDetection = (0, prompt_detector_1.detectPrompt)(fullOutput);
+    const promptDetection = detectPromptWithOptions(fullOutput, cliToolId);
     if (promptDetection.isPrompt) {
         // This is an interactive prompt - consider it complete
         return {
@@ -454,12 +495,17 @@ async function checkForResponse(worktreeId, cliToolId) {
         // Extract response
         const result = extractResponse(output, lastCapturedLine, cliToolId);
         if (!result || !result.isComplete) {
-            // No new output or response not yet complete
-            // But if Claude is processing (thinking), mark any pending prompts as answered
-            // This handles cases where user responded to prompts directly via terminal
+            // No new output or response not yet complete.
+            // If CLI tool is actively thinking, mark any pending prompts as answered.
+            // This handles cases where user responded to prompts directly via terminal.
+            //
+            // DR-004 windowing: Only check tail lines (same as extractResponse thinking check)
+            // to avoid false matches on completed thinking summaries in scrollback.
+            // Previously (MF-001), full-text check caused false positives.
             const { thinkingPattern } = (0, cli_patterns_1.getCliToolPatterns)(cliToolId);
             const cleanOutput = (0, cli_patterns_1.stripAnsi)(output);
-            if (thinkingPattern.test(cleanOutput)) {
+            const tailLines = cleanOutput.split('\n').slice(-RESPONSE_THINKING_TAIL_LINE_COUNT).join('\n');
+            if (thinkingPattern.test(tailLines)) {
                 const answeredCount = (0, db_1.markPendingPromptsAsAnswered)(db, worktreeId, cliToolId);
                 if (answeredCount > 0) {
                     console.log(`Marked ${answeredCount} pending prompt(s) as answered (thinking detected) for ${worktreeId}`);
@@ -479,7 +525,7 @@ async function checkForResponse(worktreeId, cliToolId) {
             return false;
         }
         // Response is complete! Check if it's a prompt
-        const promptDetection = (0, prompt_detector_1.detectPrompt)(result.response);
+        const promptDetection = detectPromptWithOptions(result.response, cliToolId);
         if (promptDetection.isPrompt) {
             // This is a prompt - save as prompt message
             (0, db_1.clearInProgressMessageId)(db, worktreeId, cliToolId);