commandmate 0.3.4 → 0.3.5

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

@@ -13,7 +13,7 @@ exports.isValidVibeLocalContextWindow = isValidVibeLocalContextWindow;
  * T2.1: Single source of truth for CLI tool IDs
  * CLIToolType is derived from this constant (DRY principle)
  */
-exports.CLI_TOOL_IDS = ['claude', 'codex', 'gemini', 'vibe-local'];
+exports.CLI_TOOL_IDS = ['claude', 'codex', 'gemini', 'vibe-local', 'opencode'];
 /**
  * CLI tool display names for UI rendering
  * Issue #368: Centralized display name mapping
@@ -26,6 +26,7 @@ exports.CLI_TOOL_DISPLAY_NAMES = {
     codex: 'Codex',
     gemini: 'Gemini',
     'vibe-local': 'Vibe Local',
+    opencode: 'OpenCode',
 };
 /**
  * Check if a string is a valid CLIToolType
@@ -99,10 +100,16 @@ function isValidVibeLocalContextWindow(value) {
         value <= exports.VIBE_LOCAL_CONTEXT_WINDOW_MAX);
 }
 /**
- * Ollama model name validation pattern.
- * Allows: alphanumeric start, followed by alphanumeric, dots, underscores, colons, slashes, hyphens.
- * Max 100 characters. Used for defense-in-depth validation at point of use.
+ * Ollama model name validation pattern (API/DB layer).
+ * Requires alphanumeric first character, followed by alphanumeric, dots, underscores,
+ * colons, slashes, hyphens. No explicit length limit (DB schema handles storage limits).
  *
- * [SEC-001] Shared between API route validation and CLI command construction
+ * [SEC-001] Shared between API route validation and CLI command construction.
+ *
+ * Note: opencode-config.ts has a separate OLLAMA_MODEL_PATTERN with a 100-character
+ * length limit (`{1,100}`) for DoS protection when parsing Ollama API responses.
+ * The patterns are intentionally different: this one enforces first-character constraints
+ * for user-facing validation, while the opencode-config version adds length limits
+ * for untrusted external API data.
  */
 exports.OLLAMA_MODEL_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:/-]*$/;

package/dist/server/src/lib/db.js

@@ -19,6 +19,7 @@ exports.getMessages = getMessages;
 exports.getLastUserMessage = getLastUserMessage;
 exports.getLastMessage = getLastMessage;
 exports.deleteAllMessages = deleteAllMessages;
+exports.deleteMessageById = deleteMessageById;
 exports.deleteMessagesByCliTool = deleteMessagesByCliTool;
 exports.getSessionState = getSessionState;
 exports.updateSessionState = updateSessionState;
@@ -480,6 +481,23 @@ function deleteAllMessages(db, worktreeId) {
     stmt.run(worktreeId);
     console.log(`[deleteAllMessages] Deleted all messages for worktree: ${worktreeId}`);
 }
+/**
+ * Delete a single message by its ID
+ * Used to clean up orphaned user messages (e.g., when a user re-sends a message
+ * after the previous one received no response).
+ *
+ * @param db - Database instance
+ * @param messageId - ID of the message to delete
+ * @returns True if a message was deleted, false otherwise
+ */
+function deleteMessageById(db, messageId) {
+    const stmt = db.prepare(`
+    DELETE FROM chat_messages
+    WHERE id = ?
+  `);
+    const result = stmt.run(messageId);
+    return result.changes > 0;
+}
 /**
  * Delete messages for a specific CLI tool in a worktree
  * Issue #4: T4.2 - Individual CLI tool session termination (MF3-001)

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

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * CLI Tool response polling.
- * Periodically checks tmux sessions for CLI tool responses (Claude, Codex, Gemini).
+ * Periodically checks tmux sessions for CLI tool responses (Claude, Codex, Gemini, Vibe Local, OpenCode).
  *
  * Key responsibilities:
  * - Extract completed responses from tmux output (extractResponse)
@@ -13,10 +13,23 @@
  * - 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
+ *
+ * Issue #379 additions:
+ * - OpenCode completion detection via Build summary line (isOpenCodeComplete)
+ * - OpenCode response cleaning (cleanOpenCodeResponse)
+ * - OpenCode extraction stop conditions (OPENCODE_PROMPT_PATTERN, OPENCODE_PROMPT_AFTER_RESPONSE)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTuiContentLines = extractTuiContentLines;
+exports.findOverlapIndex = findOverlapIndex;
+exports.initTuiAccumulator = initTuiAccumulator;
+exports.accumulateTuiContent = accumulateTuiContent;
+exports.getAccumulatedContent = getAccumulatedContent;
+exports.clearTuiAccumulator = clearTuiAccumulator;
 exports.cleanClaudeResponse = cleanClaudeResponse;
 exports.cleanGeminiResponse = cleanGeminiResponse;
+exports.isOpenCodeComplete = isOpenCodeComplete;
+exports.cleanOpenCodeResponse = cleanOpenCodeResponse;
 exports.resolveExtractionStartIndex = resolveExtractionStartIndex;
 exports.startPolling = startPolling;
 exports.stopPolling = stopPolling;
@@ -101,6 +114,163 @@ function buildPromptExtractionResult(lines, lastCapturedLine, totalLines, buffer
         bufferReset,
     };
 }
+/**
+ * Number of lines from the end of accumulated content to use as
+ * fingerprint for overlap detection with the next capture.
+ */
+const OVERLAP_FINGERPRINT_SIZE = 10;
+/**
+ * Per-session TUI response accumulator storage.
+ * Key: pollerKey ("worktreeId:cliToolId")
+ */
+const tuiResponseAccumulator = new Map();
+/**
+ * Normalize a single OpenCode TUI line by removing ANSI codes and border glyphs.
+ * Returns an empty string when the line has no meaningful content after cleanup.
+ */
+function normalizeOpenCodeLine(line) {
+    return (0, cli_patterns_1.stripBoxDrawing)((0, cli_patterns_1.stripAnsi)(line))
+        .replace(/^\u2503\s?/, '')
+        .replace(/\s*\u2503$/, '')
+        .trim();
+}
+/**
+ * Extract meaningful content lines from raw TUI output.
+ * Strips ANSI codes, box-drawing characters, and lines matching OPENCODE_SKIP_PATTERNS.
+ *
+ * @param rawOutput - Raw tmux capture-pane output
+ * @returns Array of cleaned, non-empty content lines
+ *
+ * @internal Exported for unit testing
+ */
+function extractTuiContentLines(rawOutput) {
+    const lines = rawOutput.split('\n');
+    const contentLines = [];
+    for (const line of lines) {
+        const cleaned = normalizeOpenCodeLine(line);
+        if (!cleaned)
+            continue;
+        const shouldSkip = cli_patterns_1.OPENCODE_SKIP_PATTERNS.some(pattern => pattern.test(cleaned));
+        if (shouldSkip)
+            continue;
+        // Also skip the Build summary line (completion indicator)
+        if (cli_patterns_1.OPENCODE_RESPONSE_COMPLETE.test(cleaned))
+            continue;
+        contentLines.push(cleaned);
+    }
+    return contentLines;
+}
+/**
+ * Find the overlap index between previously accumulated lines and newly captured lines.
+ * Searches for the longest suffix of `previous` that matches a prefix of `current`.
+ *
+ * @param previous - Previously accumulated lines (fingerprint subset)
+ * @param current - Newly captured content lines
+ * @returns Number of overlapping lines (0 if no overlap found)
+ *
+ * @internal Exported for unit testing
+ */
+function findOverlapIndex(previous, current) {
+    if (previous.length === 0 || current.length === 0)
+        return 0;
+    // Try decreasing overlap sizes: full fingerprint down to 1 line
+    const maxOverlap = Math.min(previous.length, current.length);
+    for (let overlapSize = maxOverlap; overlapSize >= 1; overlapSize--) {
+        // Check if the last `overlapSize` lines of previous match
+        // the first `overlapSize` lines of current
+        const prevSlice = previous.slice(-overlapSize);
+        const currSlice = current.slice(0, overlapSize);
+        let matches = true;
+        for (let i = 0; i < overlapSize; i++) {
+            if (prevSlice[i] !== currSlice[i]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches) {
+            return overlapSize;
+        }
+    }
+    return 0;
+}
+/**
+ * Initialize the TUI accumulator for a polling session.
+ *
+ * @param pollerKey - Poller key ("worktreeId:cliToolId")
+ *
+ * @internal Exported for unit testing
+ */
+function initTuiAccumulator(pollerKey) {
+    tuiResponseAccumulator.set(pollerKey, {
+        lines: [],
+        lastFingerprint: [],
+        pollCount: 0,
+    });
+}
+/**
+ * Accumulate TUI content from a new capture into the session buffer.
+ * Detects overlap with previous capture and appends only new lines.
+ *
+ * @param pollerKey - Poller key ("worktreeId:cliToolId")
+ * @param rawOutput - Raw tmux capture-pane output
+ *
+ * @internal Exported for unit testing
+ */
+function accumulateTuiContent(pollerKey, rawOutput) {
+    const state = tuiResponseAccumulator.get(pollerKey);
+    if (!state)
+        return;
+    const contentLines = extractTuiContentLines(rawOutput);
+    if (contentLines.length === 0)
+        return;
+    state.pollCount++;
+    if (state.lines.length === 0) {
+        // First capture: seed with all content
+        state.lines = [...contentLines];
+    }
+    else {
+        // Subsequent captures: find overlap and append new lines
+        const overlapCount = findOverlapIndex(state.lastFingerprint, contentLines);
+        if (overlapCount > 0) {
+            // Append only lines after the overlap
+            const newLines = contentLines.slice(overlapCount);
+            state.lines.push(...newLines);
+        }
+        else {
+            // No overlap found: append all content (completeness over dedup)
+            state.lines.push(...contentLines);
+        }
+    }
+    // Update fingerprint for next poll
+    state.lastFingerprint = contentLines.slice(-OVERLAP_FINGERPRINT_SIZE);
+}
+/**
+ * Get the accumulated content as a single string.
+ *
+ * @param pollerKey - Poller key ("worktreeId:cliToolId")
+ * @returns Accumulated content joined by newlines, or empty string if no accumulator
+ *
+ * @internal Exported for unit testing
+ */
+function getAccumulatedContent(pollerKey) {
+    const state = tuiResponseAccumulator.get(pollerKey);
+    if (!state || state.lines.length === 0)
+        return '';
+    return state.lines.join('\n');
+}
+/**
+ * Clear the TUI accumulator for a polling session.
+ *
+ * @param pollerKey - Poller key ("worktreeId:cliToolId")
+ *
+ * @internal Exported for unit testing
+ */
+function clearTuiAccumulator(pollerKey) {
+    tuiResponseAccumulator.delete(pollerKey);
+}
+// ============================================================================
+// Poller State Management
+// ============================================================================
 /**
  * Active pollers map: "worktreeId:cliToolId" -> NodeJS.Timeout
  */
@@ -252,13 +422,91 @@ function cleanGeminiResponse(response) {
     }
     return cleanedLines.join('\n').trim();
 }
+/**
+ * Check if OpenCode has completed its response.
+ * Detects the Build summary line pattern (e.g., "&#x25A3; Build . model . 2.5s").
+ * [D2-002] Independent completion detection for OpenCode.
+ *
+ * Unlike Claude (prompt + separator) or Codex/Gemini (prompt + not thinking),
+ * OpenCode signals completion via the Build summary line, which includes
+ * the model name and generation timing.
+ *
+ * @param output - Cleaned tmux output to check (ANSI-stripped)
+ * @returns True if OpenCode response is complete
+ *
+ * @internal Exported for unit testing (response-poller-opencode.test.ts)
+ */
+function isOpenCodeComplete(output) {
+    // Must have a Build completion marker AND must NOT be actively processing.
+    // The "esc interrupt" indicator appears in the TUI footer during model processing.
+    // Without this check, old Build markers from previous Q&As cause false completions.
+    return cli_patterns_1.OPENCODE_RESPONSE_COMPLETE.test(output) && !cli_patterns_1.OPENCODE_PROCESSING_INDICATOR.test(output);
+}
+/**
+ * Clean OpenCode TUI response by removing decoration characters and status lines,
+ * and trimming to only the latest response.
+ * [D2-009] Removes box-drawing characters, Build summary, loading indicators,
+ * prompt patterns, and processing indicators.
+ *
+ * Cleaning pipeline:
+ * 1. Split response into lines
+ * 2. Trim to latest response: find Build markers (▣ Build · model · time)
+ *    and discard all content before the second-to-last marker.
+ *    OpenCode TUI accumulates conversation history; each Q&A exchange ends
+ *    with a Build marker. Without this trimming, savePendingAssistantResponse
+ *    and Layer 2 accumulator would include previous Q&As in the response.
+ * 3. Skip empty lines
+ * 4. Skip lines matching any OPENCODE_SKIP_PATTERNS (TUI artifacts)
+ * 5. Skip Build summary line (OPENCODE_RESPONSE_COMPLETE, the completion indicator)
+ * 6. Join remaining lines
+ *
+ * @param response - Raw OpenCode response (may contain TUI decoration)
+ * @returns Cleaned response with TUI artifacts removed
+ *
+ * @internal Exported for unit testing (response-poller-opencode.test.ts)
+ */
+function cleanOpenCodeResponse(response) {
+    const lines = response.split('\n');
+    // Step 2: Trim to latest response by finding Build markers.
+    // Each Q&A exchange ends with "▣ Build · model · time".
+    // If 2+ markers exist, only include content after the second-to-last marker.
+    const buildIndices = [];
+    for (let i = 0; i < lines.length; i++) {
+        const cleanLine = normalizeOpenCodeLine(lines[i]);
+        if (cleanLine && cli_patterns_1.OPENCODE_RESPONSE_COMPLETE.test(cleanLine)) {
+            buildIndices.push(i);
+        }
+    }
+    let startLine = 0;
+    if (buildIndices.length >= 2) {
+        startLine = buildIndices[buildIndices.length - 2] + 1;
+    }
+    const cleanedLines = [];
+    for (let i = startLine; i < lines.length; i++) {
+        // Strip ANSI escape codes and TUI border characters before pattern matching.
+        // Without this, embedded ANSI codes and heavy borders can break regex matches.
+        const cleanLine = normalizeOpenCodeLine(lines[i]);
+        if (!cleanLine)
+            continue;
+        // Skip lines matching any OpenCode skip pattern
+        const shouldSkip = cli_patterns_1.OPENCODE_SKIP_PATTERNS.some(pattern => pattern.test(cleanLine));
+        if (shouldSkip)
+            continue;
+        // Skip the Build summary line (completion indicator)
+        if (cli_patterns_1.OPENCODE_RESPONSE_COMPLETE.test(cleanLine))
+            continue;
+        cleanedLines.push(cleanLine);
+    }
+    return cleanedLines.join('\n').trim();
+}
 /**
  * Determine the start index for response extraction based on buffer state.
  * Shared between normal response extraction and prompt detection paths.
  *
- * Implements a 4-branch decision tree for startIndex determination:
+ * Implements a 5-branch decision tree for startIndex determination:
  *   1. bufferWasReset  -> findRecentUserPromptIndex(40) + 1, or 0 if not found
- *   2. cliToolId === 'codex' -> Math.max(0, lastCapturedLine)
+ *   2a. cliToolId === 'opencode' -> findRecentUserPromptIndex(totalLines) + 1, or 0
+ *   2b. cliToolId === 'codex' -> Math.max(0, lastCapturedLine)
  *   3. lastCapturedLine >= totalLines - 5 (scroll boundary) ->
  *        findRecentUserPromptIndex(50) + 1, or totalLines - 40 if not found
  *   4. Normal case -> Math.max(0, lastCapturedLine)
@@ -291,6 +539,15 @@ function cleanGeminiResponse(response) {
 function resolveExtractionStartIndex(lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex) {
     // Defensive validation: clamp negative values to 0 (Stage 4 SF-001)
     lastCapturedLine = Math.max(0, lastCapturedLine);
+    // Branch 2a (highest priority for OpenCode): OpenCode runs in alternate screen mode
+    // (fixed-size buffer, no scrollback). lastCapturedLine is meaningless because the buffer
+    // doesn't grow — it's always ~PANE_HEIGHT lines. bufferWasReset is often true because
+    // lastCapturedLine ≈ totalLines. Must execute BEFORE Branch 1 to avoid Branch 1's small
+    // window (40 lines) which fails to find the second-to-last Build marker in a 200-line pane.
+    if (cliToolId === 'opencode') {
+        const foundUserPrompt = findRecentUserPromptIndex(totalLines);
+        return foundUserPrompt >= 0 ? foundUserPrompt + 1 : 0;
+    }
     // Compute bufferWasReset internally (MF-001: responsibility boundary)
     const bufferWasReset = lastCapturedLine >= totalLines || bufferReset;
     // Branch 1: Buffer was reset - find the most recent user prompt as anchor
@@ -298,7 +555,7 @@ function resolveExtractionStartIndex(lastCapturedLine, totalLines, bufferReset,
         const foundUserPrompt = findRecentUserPromptIndex(40);
         return foundUserPrompt >= 0 ? foundUserPrompt + 1 : 0;
     }
-    // Branch 2: Codex uses lastCapturedLine directly (Codex-specific TUI behavior)
+    // Branch 2b: Codex uses lastCapturedLine directly (Codex-specific TUI behavior)
     if (cliToolId === 'codex') {
         return Math.max(0, lastCapturedLine);
     }
@@ -339,18 +596,47 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
     if (!bufferReset && totalLines < lastCapturedLine - 5) {
         return null;
     }
-    // Always check the last 20 lines for completion pattern (more robust than tracking line numbers)
+    // Check recent lines for completion pattern.
+    // OpenCode TUI: content area + many empty padding lines + status bar at bottom.
+    // The trailing-empty-line trim above removes trailing newlines but NOT the internal
+    // padding between content and status bar. For OpenCode, the Build completion marker
+    // can be far above the last 20 lines, so we must check the full buffer.
     const checkLineCount = 20;
     const startLine = Math.max(0, totalLines - checkLineCount);
     const linesToCheck = lines.slice(startLine);
-    const outputToCheck = linesToCheck.join('\n');
+    const outputToCheck = cliToolId === 'opencode'
+        ? (0, cli_patterns_1.stripAnsi)(lines.join('\n'))
+        : linesToCheck.join('\n');
     // Get tool-specific patterns from shared module
     const { promptPattern, separatorPattern, thinkingPattern, skipPatterns } = (0, cli_patterns_1.getCliToolPatterns)(cliToolId);
     const findRecentUserPromptIndex = (windowSize = 60) => {
         // User prompt pattern: supports legacy '>' and new '❯' for Claude
-        const userPromptPattern = cliToolId === 'codex'
-            ? /^›\s+(?!Implement|Find and fix|Type|Summarize)/
-            : /^[>❯]\s+\S/;
+        let userPromptPattern;
+        if (cliToolId === 'codex') {
+            userPromptPattern = /^›\s+(?!Implement|Find and fix|Type|Summarize)/;
+        }
+        else if (cliToolId === 'opencode') {
+            // OpenCode TUI accumulates conversation history in a single screen.
+            // Each Q&A exchange ends with a "▣ Build · model · time" marker.
+            // "Ask anything..." does NOT appear in tmux capture content area.
+            // Instead, find the SECOND-TO-LAST Build marker (= end of previous exchange)
+            // to use as the extraction boundary. The first Build marker found (searching
+            // backwards) is the current response's completion; the second is the boundary.
+            let buildCount = 0;
+            for (let i = totalLines - 1; i >= Math.max(0, totalLines - windowSize); i--) {
+                const cleanLine = (0, cli_patterns_1.stripAnsi)(lines[i]);
+                if (cli_patterns_1.OPENCODE_RESPONSE_COMPLETE.test(cleanLine)) {
+                    buildCount++;
+                    if (buildCount === 2) {
+                        return i;
+                    }
+                }
+            }
+            return -1;
+        }
+        else {
+            userPromptPattern = /^[>❯]\s+\S/;
+        }
         for (let i = totalLines - 1; i >= Math.max(0, totalLines - windowSize); i--) {
             const cleanLine = (0, cli_patterns_1.stripAnsi)(lines[i]);
             if (userPromptPattern.test(cleanLine)) {
@@ -387,7 +673,9 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
     // Claude: require both prompt and separator
     const isCodexOrGeminiComplete = (cliToolId === 'codex' || cliToolId === 'gemini' || cliToolId === 'vibe-local') && hasPrompt && !isThinking;
     const isClaudeComplete = cliToolId === 'claude' && hasPrompt && hasSeparator && !isThinking;
-    if (isCodexOrGeminiComplete || isClaudeComplete) {
+    // [D2-002] OpenCode completion: detected via Build summary line pattern (independent of prompt/separator)
+    const isOpenCodeDone = cliToolId === 'opencode' && isOpenCodeComplete(cleanOutputToCheck);
+    if (isCodexOrGeminiComplete || isClaudeComplete || isOpenCodeDone) {
         // CLI tool has completed response
         // Extract the response content from lastCapturedLine to the separator (not just last 20 lines)
         const responseLines = [];
@@ -408,6 +696,13 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
                 endIndex = i;
                 break;
             }
+            // [D2-003] For OpenCode: stop at prompt or status bar patterns
+            if (cliToolId === 'opencode') {
+                if (cli_patterns_1.OPENCODE_PROMPT_PATTERN.test(cleanLine) || cli_patterns_1.OPENCODE_PROMPT_AFTER_RESPONSE.test(cleanLine)) {
+                    endIndex = i;
+                    break;
+                }
+            }
             // Skip lines matching any skip pattern (check against clean line)
             const shouldSkip = skipPatterns.some(pattern => pattern.test(cleanLine));
             if (shouldSkip) {
@@ -470,6 +765,21 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
                 return incompleteResult(totalLines);
             }
         }
+        // OpenCode banner defense: initial startup screen should not be treated as a response
+        if (cliToolId === 'opencode') {
+            const cleanResponse = (0, cli_patterns_1.stripAnsi)(response);
+            // If the output is very short and contains only TUI elements, treat as startup banner
+            if (cleanResponse.length < 50 || !cli_patterns_1.OPENCODE_RESPONSE_COMPLETE.test(cleanOutputToCheck)) {
+                // Check if there's actual content (not just TUI decoration)
+                const contentLines = cleanResponse.split('\n').filter(line => {
+                    const trimmed = line.trim();
+                    return trimmed && !cli_patterns_1.OPENCODE_SKIP_PATTERNS.some(p => p.test(trimmed));
+                });
+                if (contentLines.length === 0) {
+                    return incompleteResult(totalLines);
+                }
+            }
+        }
         return {
             response,
             isComplete: true,
@@ -479,12 +789,18 @@ 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 = detectPromptWithOptions(fullOutput, cliToolId);
-    if (promptDetection.isPrompt) {
-        // Prompt detection uses full buffer for accuracy, but return only lastCapturedLine onwards
-        // stripAnsi is applied inside buildPromptExtractionResult (Stage 4 MF-001: XSS risk mitigation)
-        return buildPromptExtractionResult(lines, lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, promptDetection);
+    // [Issue #379] Skip general prompt detection for OpenCode when response is incomplete.
+    // OpenCode's "Ask anything..." prompt pattern can cause false positive prompt detection
+    // when combined with user input text visible in the TUI buffer, leading to duplicate
+    // message creation. OpenCode prompts are only relevant when completion is detected above.
+    if (cliToolId !== 'opencode') {
+        const fullOutput = lines.join('\n');
+        const promptDetection = detectPromptWithOptions(fullOutput, cliToolId);
+        if (promptDetection.isPrompt) {
+            // Prompt detection uses full buffer for accuracy, but return only lastCapturedLine onwards
+            // stripAnsi is applied inside buildPromptExtractionResult (Stage 4 MF-001: XSS risk mitigation)
+            return buildPromptExtractionResult(lines, lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, promptDetection);
+        }
     }
     // Not a prompt, but we may have a partial response in progress (even if Claude shows a spinner)
     const responseLines = [];
@@ -543,6 +859,11 @@ async function checkForResponse(worktreeId, cliToolId) {
         const lastCapturedLine = sessionState?.lastCapturedLine || 0;
         // Capture current output
         const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, 10000);
+        // Layer 2: Accumulate TUI content for OpenCode (for overlap tracking only).
+        if (cliToolId === 'opencode') {
+            const pollerKey = getPollerKey(worktreeId, cliToolId);
+            accumulateTuiContent(pollerKey, output);
+        }
         // Extract response
         const result = extractResponse(output, lastCapturedLine, cliToolId);
         if (!result || !result.isComplete) {
@@ -564,17 +885,22 @@ async function checkForResponse(worktreeId, cliToolId) {
             }
             return false;
         }
+        // Issue #379: OpenCode uses a full-screen TUI with fixed buffer size (~200 lines).
+        // The tmux pane doesn't grow (no scrollback); each response overwrites the same pane,
+        // so lineCount is always approximately equal to lastCapturedLine. Skip line-based
+        // duplicate detection entirely for full-screen TUIs.
+        const isFullScreenTui = cliToolId === 'opencode';
         // CRITICAL FIX: If lineCount == lastCapturedLine AND there's no in-progress message,
         // this response has already been saved. Skip to prevent duplicates.
         // Issue #372: Skip when buffer reset detected (TUI redraw may coincidentally match lineCount).
-        if (!result.bufferReset && result.lineCount === lastCapturedLine && !sessionState?.inProgressMessageId) {
+        if (!isFullScreenTui && !result.bufferReset && result.lineCount === lastCapturedLine && !sessionState?.inProgressMessageId) {
             return false;
         }
         // Additional duplicate prevention: check if savePendingAssistantResponse
         // already saved this content by comparing line counts.
         // Issue #372: Skip this check when buffer reset is detected (TUI redraw, screen clear).
         // Codex TUI redraws cause totalLines to shrink, making lineCount < lastCapturedLine.
-        if (!result.bufferReset && result.lineCount <= lastCapturedLine) {
+        if (!result.bufferReset && !isFullScreenTui && result.lineCount <= lastCapturedLine) {
             console.log(`[checkForResponse] Already saved up to line ${lastCapturedLine}, skipping (result: ${result.lineCount})`);
             return false;
         }
@@ -611,6 +937,7 @@ async function checkForResponse(worktreeId, cliToolId) {
             ? (0, claude_output_1.parseClaudeOutput)(result.response)
             : undefined;
         // Clean up responses (remove shell prompts, setup commands, and errors)
+        // [D2-009] Each tool has its own clean function for tool-specific artifacts
         let cleanedResponse = result.response;
         if (cliToolId === 'gemini') {
             cleanedResponse = cleanGeminiResponse(result.response);
@@ -618,6 +945,14 @@ async function checkForResponse(worktreeId, cliToolId) {
         else if (cliToolId === 'claude') {
             cleanedResponse = cleanClaudeResponse(result.response);
         }
+        else if (cliToolId === 'opencode') {
+            cleanedResponse = cleanOpenCodeResponse(result.response);
+            // Clear accumulator for next response cycle (Layer 2 data not used for final content;
+            // accumulatedContent includes all past Q&A history from the fixed-size TUI, causing
+            // old responses to leak into the saved message even after cleanOpenCodeResponse trimming).
+            const pollerKey = getPollerKey(worktreeId, cliToolId);
+            clearTuiAccumulator(pollerKey);
+        }
         // If cleaned response is empty or just "[No content]", skip saving
         // This prevents creating messages for shell setup commands that get filtered out
         if (!cleanedResponse || cleanedResponse.trim() === '' || cleanedResponse === '[No content]') {
@@ -637,8 +972,9 @@ async function checkForResponse(worktreeId, cliToolId) {
         }
         // Race condition prevention: re-check session state before saving
         // savePendingAssistantResponse may have already saved this content concurrently
+        // Issue #379: Skip for OpenCode full-screen TUI (fixed buffer size, lineCount never advances)
         const currentSessionState = (0, db_1.getSessionState)(db, worktreeId, cliToolId);
-        if (currentSessionState && result.lineCount <= currentSessionState.lastCapturedLine) {
+        if (!isFullScreenTui && currentSessionState && result.lineCount <= currentSessionState.lastCapturedLine) {
             console.log(`[checkForResponse] Race condition detected, skipping save (result: ${result.lineCount}, current: ${currentSessionState.lastCapturedLine})`);
             return false;
         }
@@ -659,6 +995,12 @@ async function checkForResponse(worktreeId, cliToolId) {
         (0, ws_server_1.broadcastMessage)('message', { worktreeId, message });
         // Update session state
         (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount);
+        // For full-screen TUIs (OpenCode), stop polling after saving the response.
+        // Line-count based duplicate prevention doesn't work because the pane size is fixed,
+        // so lineCount never advances. Polling restarts when the user sends the next message.
+        if (isFullScreenTui) {
+            stopPolling(worktreeId, cliToolId);
+        }
         return true;
     }
     catch (error) {
@@ -684,6 +1026,10 @@ function startPolling(worktreeId, cliToolId) {
     stopPolling(worktreeId, cliToolId);
     // Record start time
     pollingStartTimes.set(pollerKey, Date.now());
+    // Initialize TUI accumulator for OpenCode (Layer 2 safety net)
+    if (cliToolId === 'opencode') {
+        initTuiAccumulator(pollerKey);
+    }
     // Start polling with setTimeout chain to prevent race conditions
     scheduleNextResponsePoll(worktreeId, cliToolId);
 }
@@ -731,6 +1077,8 @@ function stopPolling(worktreeId, cliToolId) {
         activePollers.delete(pollerKey);
         pollingStartTimes.delete(pollerKey);
     }
+    // Clean up TUI accumulator if present
+    clearTuiAccumulator(pollerKey);
 }
 /**
  * Stop all active pollers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commandmate",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Git worktree management with Claude CLI and tmux sessions",
   "keywords": [
     "claude-code",
@@ -65,6 +65,7 @@
     "react": "^18.3.0",
     "react-dom": "^18.3.0",
     "react-markdown": "^10.1.0",
+    "react-qr-code": "^2.0.18",
     "rehype-highlight": "^7.0.2",
     "rehype-sanitize": "^6.0.0",
     "remark-gfm": "^4.0.1",