commandmate 0.19.0 → 0.20.0

package/dist/server/src/lib/polling/response-checker.js

@@ -17,6 +17,7 @@ const claude_output_1 = require("../../lib/claude-output");
 const cli_patterns_1 = require("../../lib/detection/cli-patterns");
 const logger_1 = require("../../lib/logger");
 const thinking_constants_1 = require("../../config/thinking-constants");
+const tmux_capture_cache_1 = require("../../lib/tmux/tmux-capture-cache");
 const logger = (0, logger_1.createLogger)('response-poller');
 // Sub-module imports
 const response_extractor_1 = require("../response-extractor");
@@ -52,10 +53,12 @@ function incompleteResult(lineCount) {
  * @param bufferReset - External buffer reset flag
  * @param cliToolId - CLI tool identifier
  * @param findRecentUserPromptIndex - Callback to locate the most recent user prompt
+ * @param promptDetection - Prompt detection result to carry on the extraction result
+ * @param captureWindowSaturated - True when the capture was clipped by the capture window (#1670)
  * @returns ExtractionResult with isComplete: true and ANSI-stripped response
  */
-function buildPromptExtractionResult(lines, lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, promptDetection) {
-    const startIndex = (0, response_extractor_1.resolveExtractionStartIndex)(lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex);
+function buildPromptExtractionResult(lines, lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, promptDetection, captureWindowSaturated = false) {
+    const startIndex = (0, response_extractor_1.resolveExtractionStartIndex)(lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, captureWindowSaturated);
     const extractedLines = lines.slice(startIndex);
     return {
         response: (0, cli_patterns_1.stripAnsi)(extractedLines.join('\n')),
@@ -63,6 +66,7 @@ function buildPromptExtractionResult(lines, lastCapturedLine, totalLines, buffer
         lineCount: totalLines,
         promptDetection,
         bufferReset,
+        captureWindowSaturated,
     };
 }
 /**
@@ -89,9 +93,12 @@ function detectPromptWithOptions(output, cliToolId) {
  * @param output - Full tmux output
  * @param lastCapturedLine - Number of lines previously captured
  * @param cliToolId - CLI tool ID (claude, codex, gemini)
+ * @param captureWindowLines - Size of the capture window `output` was produced with.
+ *   Used only to decide whether the capture came back clipped (Issue #1670);
+ *   defaults to the window `checkForResponse()` uses.
  * @returns Extracted response or null if incomplete
  */
-function extractResponse(output, lastCapturedLine, cliToolId) {
+function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines = tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES) {
     // Trim trailing empty lines from the output before processing
     const rawLines = output.split('\n');
     let trimmedLength = rawLines.length;
@@ -100,6 +107,12 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
     }
     const lines = rawLines.slice(0, trimmedLength);
     const totalLines = lines.length;
+    // Issue #1670: measured on the RAW capture, before the trailing-blank trim —
+    // the clip happens in sliceOutput(), so it is the untrimmed row count that
+    // reveals it. Once this is true the line count is pinned at the window size and
+    // `lastCapturedLine` stops being a position in `lines`; see
+    // isCaptureWindowSaturated() for why raising the window only relocates it.
+    const captureWindowSaturated = (0, tmux_capture_cache_1.isCaptureWindowSaturated)(rawLines.length, captureWindowLines);
     // Issue #1289: Claude Code pins a footer (rotating hint row, input box, status
     // bar) to the bottom of the pane. It is chrome, not transcript, and its hint
     // row rotates while the conversation is idle — so letting it reach the saved
@@ -164,21 +177,29 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
         const fullOutput = lines.join('\n');
         const promptDetection = detectPromptWithOptions(fullOutput, cliToolId);
         if (promptDetection.isPrompt) {
-            return buildPromptExtractionResult(lines, lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, promptDetection);
+            return buildPromptExtractionResult(lines, lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, promptDetection, captureWindowSaturated);
         }
     }
     // Strip ANSI codes before pattern matching
     const cleanOutputToCheck = (0, cli_patterns_1.stripAnsi)(outputToCheck);
     const hasPrompt = promptPattern.test(cleanOutputToCheck);
     const hasSeparator = separatorPattern.test(cleanOutputToCheck);
-    const isThinking = thinkingPattern.test(cleanOutputToCheck);
+    // Issue #1671: Codex's activity markers are past-tense transcript records that
+    // never leave the scrollback, so testing them against this fixed tail window
+    // reports "still thinking" for a finished turn whenever its final message was
+    // short enough to keep the last "• Ran <cmd>" row inside the window. Codex gets
+    // a liveness check that keys off the status line it repaints above the composer
+    // instead; every other tool keeps the tail-window match.
+    const isThinking = cliToolId === 'codex'
+        ? (0, cli_patterns_1.isCodexTurnActive)(lines, checkLineCount)
+        : thinkingPattern.test(cleanOutputToCheck);
     // Prompt-based completion logic
     const isPromptBasedComplete = (cliToolId === 'codex' || cliToolId === 'gemini' || cliToolId === 'vibe-local' || cliToolId === 'copilot' || cliToolId === 'antigravity') && hasPrompt && !isThinking;
     const isClaudeComplete = cliToolId === 'claude' && hasPrompt && hasSeparator && !isThinking;
     const isOpenCodeDone = cliToolId === 'opencode' && (0, response_extractor_1.isOpenCodeComplete)(cleanOutputToCheck);
     if (isPromptBasedComplete || isClaudeComplete || isOpenCodeDone) {
         const responseLines = [];
-        const startIndex = (0, response_extractor_1.resolveExtractionStartIndex)(lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex);
+        const startIndex = (0, response_extractor_1.resolveExtractionStartIndex)(lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, captureWindowSaturated);
         let endIndex = totalLines;
         // `contentEnd` bounds the content only; `endIndex` keeps reporting the full
         // buffer so lineCount bookkeeping in session_states is unchanged (#1289).
@@ -274,6 +295,7 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
             isComplete: true,
             lineCount: endIndex,
             bufferReset,
+            captureWindowSaturated,
         };
     }
     // Check if this is an interactive prompt
@@ -281,13 +303,16 @@ function extractResponse(output, lastCapturedLine, cliToolId) {
         const fullOutput = lines.join('\n');
         const promptDetection = detectPromptWithOptions(fullOutput, cliToolId);
         if (promptDetection.isPrompt) {
-            return buildPromptExtractionResult(lines, lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, promptDetection);
+            return buildPromptExtractionResult(lines, lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, promptDetection, captureWindowSaturated);
         }
     }
     // Partial response in progress
     const responseLines = [];
     const endIndex = totalLines;
-    const partialBufferReset = bufferReset || lastCapturedLine >= endIndex - 5;
+    // Issue #1670: a saturated window makes lastCapturedLine meaningless here too —
+    // starting the partial slice at it would stream an arbitrary tail fragment
+    // instead of the turn so far. Re-anchor on the echoed user prompt.
+    const partialBufferReset = bufferReset || captureWindowSaturated || lastCapturedLine >= endIndex - 5;
     const recentPromptIndex = partialBufferReset ? findRecentUserPromptIndex(80) : -1;
     const startIndex = partialBufferReset
         ? (recentPromptIndex >= 0 ? recentPromptIndex + 1 : Math.max(0, endIndex - 80))
@@ -351,15 +376,17 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // Get session state (last captured line count)
         const sessionState = (0, db_1.getSessionState)(db, worktreeId, resolvedInstanceId);
         const lastCapturedLine = sessionState?.lastCapturedLine || 0;
-        // Capture current output
-        const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, 10000, instanceId);
+        // Capture current output. The requested width IS the capture window, so it is
+        // taken from the same constant extractResponse() measures saturation against
+        // (Issue #1670) — a literal here would silently decouple the two.
+        const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES, instanceId);
         // Layer 2: Accumulate TUI content for full-screen TUI tools (for overlap tracking only).
         if (cliToolId === 'opencode' || cliToolId === 'copilot') {
             const pollerKey = (0, response_poller_core_1.getPollerKey)(worktreeId, cliToolId, instanceId);
             (0, tui_accumulator_1.accumulateTuiContent)(pollerKey, output, cliToolId);
         }
         // Extract response
-        const result = extractResponse(output, lastCapturedLine, cliToolId);
+        const result = extractResponse(output, lastCapturedLine, cliToolId, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES);
         if (!result || !result.isComplete) {
             // DR-004 windowing: Only check tail lines
             const { thinkingPattern } = (0, cli_patterns_1.getCliToolPatterns)(cliToolId);
@@ -381,7 +408,15 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // `lineCount <= lastCapturedLine` and drop the response forever — leaving
         // History stuck on "Waiting for response..." while the terminal shows the
         // reply. Those tools dedup on response content instead (see below).
-        const lineCountIsCursor = !(0, types_1.usesAlternateScreen)(cliToolId);
+        //
+        // Issue #1670: the scrollback tools reach the SAME dead end from the other
+        // side. Their buffer does grow — but only until it outgrows the capture
+        // window, after which the capture is clipped, the count is pinned at the
+        // window size, and the cursor can never be overtaken again. #1268 fixed
+        // saturation at pane height; this is saturation at the capture window, and it
+        // disables the cursor for exactly as long as the clipping lasts (a session
+        // restart or a cleared pane un-saturates it and the cursor comes back).
+        const lineCountIsCursor = !(0, types_1.usesAlternateScreen)(cliToolId) && !result.captureWindowSaturated;
         // Duplicate prevention
         if (lineCountIsCursor && !result.bufferReset && result.lineCount === lastCapturedLine && !sessionState?.inProgressMessageId) {
             return false;
@@ -483,7 +518,12 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
         // every subsequent poll re-extracts byte-identical content; save it once.
         // The cache is cleared by stopPolling(), i.e. per polling cycle, so an
         // identical response in a later turn is still recorded.
-        if ((0, types_1.usesAlternateScreen)(cliToolId)) {
+        //
+        // Issue #1670: keyed off `lineCountIsCursor` rather than the tool trait, so a
+        // scrollback tool whose capture window has saturated gets the same substitute.
+        // Without this the disabled cursor would leave nothing suppressing re-saves and
+        // the poller would append the same finished reply every 2 s.
+        if (!lineCountIsCursor) {
             const pollerKey = (0, response_poller_core_1.getPollerKey)(worktreeId, cliToolId, instanceId);
             if ((0, response_dedup_1.isDuplicateResponse)(pollerKey, cleanedResponse)) {
                 (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount, resolvedInstanceId);

package/dist/server/src/lib/polling/response-dedup.js

@@ -21,6 +21,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDuplicateResponse = isDuplicateResponse;
 exports.clearResponseHashCache = clearResponseHashCache;
+exports.renameResponseHashCacheKey = renameResponseHashCacheKey;
 const crypto_1 = require("crypto");
 /**
  * In-memory cache: pollerKey -> SHA-256 hash of the last saved response content.
@@ -52,3 +53,24 @@ function isDuplicateResponse(pollerKey, content) {
 function clearResponseHashCache(pollerKey) {
     responseHashCache.delete(pollerKey);
 }
+/**
+ * Move the cached hash from one pollerKey to another.
+ *
+ * Used when a worktree ID is renamed underneath a running poller
+ * (Issue #1621 Phase 3). The cache answers "did I already save this screen
+ * during THIS turn?", and the turn does not end just because the ID moved —
+ * dropping it would re-save the screen currently on display.
+ *
+ * No-op when nothing is cached under `oldKey`.
+ *
+ * @param oldKey - Poller key the cache entry lives under
+ * @param newKey - Poller key it should live under
+ */
+function renameResponseHashCacheKey(oldKey, newKey) {
+    if (oldKey === newKey)
+        return;
+    const hash = responseHashCache.get(oldKey);
+    responseHashCache.delete(oldKey);
+    if (hash !== undefined)
+        responseHashCache.set(newKey, hash);
+}

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

@@ -8,6 +8,7 @@ exports.scheduleNextResponsePoll = scheduleNextResponsePoll;
 exports.stopPolling = stopPolling;
 exports.stopAllPolling = stopAllPolling;
 exports.getActivePollers = getActivePollers;
+exports.migrateResponsePollerWorktreeIds = migrateResponsePollerWorktreeIds;
 const logger_1 = require("../../lib/logger");
 const tui_accumulator_1 = require("../tui-accumulator");
 const prompt_dedup_1 = require("./prompt-dedup");
@@ -176,3 +177,109 @@ function stopAllPolling() {
 function getActivePollers() {
     return Array.from(exports.activePollers.keys());
 }
+/** Split a poller key into its worktree and instance halves. */
+function splitPollerKey(pollerKey) {
+    const separatorIndex = pollerKey.indexOf(':');
+    // A worktree ID never contains ':' (isValidWorktreeId), so the first one is
+    // always the boundary.
+    if (separatorIndex <= 0 || separatorIndex === pollerKey.length - 1)
+        return null;
+    return {
+        worktreeId: pollerKey.slice(0, separatorIndex),
+        instanceId: pollerKey.slice(separatorIndex + 1),
+    };
+}
+/**
+ * Move every running response poller from a renamed worktree ID to the new one
+ * (Issue #1621 Phase 3).
+ *
+ * Re-keying the maps alone is **not** enough, and this is the subtle part: the
+ * `setTimeout` chain in {@link scheduleNextResponsePoll} closes over
+ * `worktreeId` and recomputes its key on every tick. A poller left running
+ * would go on capturing `mcbd-<cli>-<OLD id>` (a session that no longer exists
+ * after the rename), writing its messages against an ID no row carries, and
+ * re-registering the old key the moment it fired. So each poller is torn down
+ * and restarted under the new ID, with everything that represents *progress*
+ * carried across:
+ *
+ * - `pollingStartTimes`, so MAX_POLLING_DURATION still measures from when the
+ *   turn actually began rather than restarting the 30-minute budget;
+ * - the prompt and response dedup hashes, so the screen currently on display is
+ *   not saved a second time as a new message.
+ *
+ * The TUI accumulator (opencode / copilot only) is re-initialised empty at the
+ * new key instead of carried over: `tui-accumulator.ts` exposes no way to write
+ * a buffer back, and it is outside this Issue's allowed scope. The cost is that
+ * one in-flight TUI response may be truncated at the rename boundary; the next
+ * turn accumulates normally.
+ *
+ * Takes the whole batch because IDs can swap (A→B, B→A): every source key is
+ * removed before any destination key is written.
+ *
+ * @param renames - Worktree ID pairs being applied
+ * @param resolveCliToolId - Maps a poller's (worktree, instance) back to its CLI
+ *   tool, which the poller key does not encode for alias instances. Callers pass
+ *   a roster-backed lookup; returning null skips that poller (it is stopped
+ *   rather than left pointing at a dead ID).
+ * @returns One entry per poller that was moved
+ */
+function migrateResponsePollerWorktreeIds(renames, resolveCliToolId) {
+    const targets = new Map();
+    for (const { oldId, newId } of renames) {
+        if (!oldId || !newId || oldId === newId)
+            continue;
+        targets.set(oldId, newId);
+    }
+    if (targets.size === 0)
+        return [];
+    const moves = [];
+    const abandoned = [];
+    for (const pollerKey of Array.from(exports.activePollers.keys())) {
+        const parts = splitPollerKey(pollerKey);
+        if (!parts)
+            continue;
+        const newWorktreeId = targets.get(parts.worktreeId);
+        if (!newWorktreeId)
+            continue;
+        const cliToolId = resolveCliToolId(parts.worktreeId, parts.instanceId);
+        if (!cliToolId) {
+            abandoned.push(pollerKey);
+            continue;
+        }
+        moves.push({
+            oldKey: pollerKey,
+            newKey: getPollerKey(newWorktreeId, cliToolId, parts.instanceId),
+            newWorktreeId,
+            cliToolId,
+            instanceId: parts.instanceId,
+        });
+    }
+    // Phase 1: stop every affected timer and lift the state off the old keys.
+    // Done for the whole batch before any write so a swap cannot self-collide.
+    const carried = new Map();
+    for (const move of moves) {
+        const timerId = exports.activePollers.get(move.oldKey);
+        if (timerId)
+            clearTimeout(timerId);
+        exports.activePollers.delete(move.oldKey);
+        carried.set(move.newKey, { startedAt: exports.pollingStartTimes.get(move.oldKey) });
+        exports.pollingStartTimes.delete(move.oldKey);
+        (0, prompt_dedup_1.renamePromptHashCacheKey)(move.oldKey, move.newKey);
+        (0, response_dedup_1.renameResponseHashCacheKey)(move.oldKey, move.newKey);
+        (0, tui_accumulator_1.clearTuiAccumulator)(move.oldKey);
+    }
+    for (const pollerKey of abandoned) {
+        stopPollingByKey(pollerKey);
+        logger.warn('poller:migrate-abandoned', { pollerKey });
+    }
+    // Phase 2: restart each poller under its new identity.
+    for (const move of moves) {
+        const startedAt = carried.get(move.newKey)?.startedAt;
+        exports.pollingStartTimes.set(move.newKey, startedAt ?? Date.now());
+        if (move.cliToolId === 'opencode' || move.cliToolId === 'copilot') {
+            (0, tui_accumulator_1.initTuiAccumulator)(move.newKey);
+        }
+        scheduleNextResponsePoll(move.newWorktreeId, move.cliToolId, move.instanceId);
+    }
+    return moves;
+}

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

@@ -10,7 +10,7 @@
  * @internal functions from being unintentionally exposed.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizePromptForDedup = exports.clearPromptHashCache = exports.isDuplicatePrompt = exports.clearTuiAccumulator = exports.getAccumulatedContent = exports.accumulateTuiContent = exports.initTuiAccumulator = exports.findOverlapIndex = exports.normalizeCopilotLine = exports.extractCopilotContentLines = exports.extractTuiContentLines = exports.truncateMessage = exports.cleanCopilotResponse = exports.cleanOpenCodeResponse = exports.cleanGeminiResponse = exports.cleanClaudeResponse = exports.isOpenCodeComplete = exports.resolveExtractionStartIndex = exports.getActivePollers = exports.stopAllPolling = exports.stopPolling = exports.startPolling = void 0;
+exports.normalizePromptForDedup = exports.renamePromptHashCacheKey = exports.clearPromptHashCache = exports.isDuplicatePrompt = exports.clearTuiAccumulator = exports.getAccumulatedContent = exports.accumulateTuiContent = exports.initTuiAccumulator = exports.findOverlapIndex = exports.normalizeCopilotLine = exports.extractCopilotContentLines = exports.extractTuiContentLines = exports.truncateMessage = exports.cleanCopilotResponse = exports.cleanOpenCodeResponse = exports.cleanGeminiResponse = exports.cleanClaudeResponse = exports.isOpenCodeComplete = exports.resolveExtractionStartIndex = exports.migrateResponsePollerWorktreeIds = exports.getActivePollers = exports.stopAllPolling = exports.stopPolling = exports.startPolling = void 0;
 // ============================================================================
 // Named re-exports from sub-modules (barrel pattern, D4-001: no export *)
 // ============================================================================
@@ -20,6 +20,8 @@ Object.defineProperty(exports, "startPolling", { enumerable: true, get: function
 Object.defineProperty(exports, "stopPolling", { enumerable: true, get: function () { return response_poller_core_1.stopPolling; } });
 Object.defineProperty(exports, "stopAllPolling", { enumerable: true, get: function () { return response_poller_core_1.stopAllPolling; } });
 Object.defineProperty(exports, "getActivePollers", { enumerable: true, get: function () { return response_poller_core_1.getActivePollers; } });
+// Issue #1621 Phase 3: follow a worktree ID rename without dropping the turn
+Object.defineProperty(exports, "migrateResponsePollerWorktreeIds", { enumerable: true, get: function () { return response_poller_core_1.migrateResponsePollerWorktreeIds; } });
 // response-extractor public API
 var response_extractor_1 = require("../response-extractor");
 Object.defineProperty(exports, "resolveExtractionStartIndex", { enumerable: true, get: function () { return response_extractor_1.resolveExtractionStartIndex; } });
@@ -45,4 +47,5 @@ Object.defineProperty(exports, "clearTuiAccumulator", { enumerable: true, get: f
 var prompt_dedup_1 = require("./prompt-dedup");
 Object.defineProperty(exports, "isDuplicatePrompt", { enumerable: true, get: function () { return prompt_dedup_1.isDuplicatePrompt; } });
 Object.defineProperty(exports, "clearPromptHashCache", { enumerable: true, get: function () { return prompt_dedup_1.clearPromptHashCache; } });
+Object.defineProperty(exports, "renamePromptHashCacheKey", { enumerable: true, get: function () { return prompt_dedup_1.renamePromptHashCacheKey; } });
 Object.defineProperty(exports, "normalizePromptForDedup", { enumerable: true, get: function () { return prompt_dedup_1.normalizePromptForDedup; } });

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

@@ -34,9 +34,10 @@ function isOpenCodeComplete(output) {
  * Determine the start index for response extraction based on buffer state.
  * Shared between normal response extraction and prompt detection paths.
  *
- * Implements a 5-branch decision tree for startIndex determination:
+ * Implements a 6-branch decision tree for startIndex determination:
  *   1. bufferWasReset  -> findRecentUserPromptIndex(40) + 1, or 0 if not found
  *   2a. cliToolId === 'opencode' | 'copilot' -> findRecentUserPromptIndex(totalLines) + 1, or 0
+ *   2a''. captureWindowSaturated -> findRecentUserPromptIndex(totalLines) + 1, or 0
  *   2a'. cliToolId === 'antigravity' -> findRecentUserPromptIndex(totalLines) + 1, or lastCapturedLine
  *   2b. cliToolId === 'codex' -> Math.max(0, lastCapturedLine)
  *   3. lastCapturedLine >= totalLines - 5 (scroll boundary) ->
@@ -64,11 +65,14 @@ function isOpenCodeComplete(output) {
  * @param findRecentUserPromptIndex - Callback that searches the tmux buffer backwards
  *   for the most recent user prompt line within a given window size.
  *   Returns the line index (>= 0) if found, or -1 if not found.
+ * @param captureWindowSaturated - True when the capture came back clipped by the capture
+ *   window (Issue #1670), i.e. `lastCapturedLine` no longer indexes into `lines`.
+ *   Defaults to false so existing callers keep their behavior.
  * @returns The 0-based line index from which response extraction should begin.
  *
  * @internal Exported for testing only
  */
-function resolveExtractionStartIndex(lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex) {
+function resolveExtractionStartIndex(lastCapturedLine, totalLines, bufferReset, cliToolId, findRecentUserPromptIndex, captureWindowSaturated = false) {
     // 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
@@ -80,6 +84,22 @@ function resolveExtractionStartIndex(lastCapturedLine, totalLines, bufferReset,
         const foundUserPrompt = findRecentUserPromptIndex(totalLines);
         return foundUserPrompt >= 0 ? foundUserPrompt + 1 : 0;
     }
+    // Branch 2a'' (Issue #1670): the capture window is saturated, so the buffer no
+    // longer grows under the cursor — it slides. `lastCapturedLine` was recorded
+    // against a window that has since scrolled by an unknown amount, so it is not a
+    // position in `lines` any more and using it would slice off an arbitrary prefix
+    // of the turn. Anchor on the newest echoed user prompt instead, exactly as the
+    // alternate-screen branch above does for the same reason (#1268), and fall back
+    // to the whole window when the echo has scrolled out (a single turn longer than
+    // the window) — dropping it would be the very defect this branch fixes.
+    //
+    // Placed AFTER the opencode/copilot branch so the #1268 path is untouched, and
+    // BEFORE the antigravity branch because the two agree wherever an echo exists;
+    // only agy's `lastCapturedLine` fallback would still trust the stale cursor.
+    if (captureWindowSaturated) {
+        const foundUserPrompt = findRecentUserPromptIndex(totalLines);
+        return foundUserPrompt >= 0 ? foundUserPrompt + 1 : 0;
+    }
     // Branch 2a' (Antigravity / agy, Issue #988): agy is inline-rendered (scrollback
     // retained, like Codex), so lastCapturedLine is meaningful. But the user echo
     // ("> <message>") is reliably present in the captured buffer and gives a cleaner

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

@@ -26,6 +26,7 @@ const promises_1 = require("fs/promises");
 const logger_1 = require("../../lib/logger");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const types_1 = require("../../lib/cli-tools/types");
+const session_start_error_1 = require("../../lib/session/session-start-error");
 const logger = (0, logger_1.createLogger)('claude-session');
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 // ----- Helper Functions -----
@@ -71,9 +72,35 @@ const SHELL_PROMPT_ENDINGS = ['$', '%', '#'];
  * This timeout also covers trust dialog auto-response time (typically <1s).
  * When reducing this value, consider dialog response overhead.
  *
- * 15 seconds provides headroom for slower networks or cold starts.
+ * Issue #1637: raised from 15s to 60s. Measured on the reporter's machine
+ * (macOS, Claude Code v2, private tmux socket, the same detection predicates
+ * this module uses — `Yes, I trust this folder` for the dialog and
+ * CLAUDE_PROMPT_PATTERN for readiness):
+ *
+ *   - idle, already-trusted repository worktree : 1443 / 1470 ms
+ *   - idle, fresh directory (trust dialog shown): 1885 / 1896 / 1902 ms
+ *     (dialog visible at ~940 ms, prompt ~950 ms after it is answered)
+ *   - six cold starts launched concurrently     : 2845 / 3450 / 3488 / 4206 /
+ *                                                 4215 / 4850 ms
+ *
+ * So a healthy cold start costs ~2s idle and ~5s at six-way concurrency, and
+ * 15s left under 4x headroom over the concurrent case. That is what the six
+ * production failures spent: the machine was running an orchestration (several
+ * agent sessions plus test suites and builds), and the Issue's own reproduction
+ * — re-send ~30s later succeeds — puts the real ready time in that run above
+ * 15s and at or below ~45s. 60s covers it with margin and is the same order of
+ * magnitude as the window Codex already allows (3s + 30 x 1s polls ≈ 33s).
+ *
+ * Waiting longer costs nothing on the healthy path (the loop exits as soon as
+ * the prompt appears) and a session whose output already shows a terminal error
+ * fails immediately rather than consuming the budget — see the error-pattern
+ * check in startClaudeSession().
+ *
+ * This is the *first start* budget only. Sending to a session that already
+ * exists is bounded separately by CLAUDE_SEND_PROMPT_WAIT_TIMEOUT (10s), which
+ * is unchanged.
  */
-exports.CLAUDE_INIT_TIMEOUT = 15000;
+exports.CLAUDE_INIT_TIMEOUT = 60000;
 /**
  * Initialization polling interval (milliseconds)
  *
@@ -117,7 +144,7 @@ exports.CLAUDE_PROMPT_WAIT_TIMEOUT = 5000;
  * Relationship to other timeout constants:
  * - CLAUDE_PROMPT_WAIT_TIMEOUT (5000ms): Default for waitForPrompt()
  * - CLAUDE_SEND_PROMPT_WAIT_TIMEOUT (10000ms): sendMessageToClaude() specific
- * - CLAUDE_INIT_TIMEOUT (15000ms): Session initialization timeout
+ * - CLAUDE_INIT_TIMEOUT (60000ms): first-start initialization budget (Issue #1637)
  *
  * @see Issue #187 - Constant unification for sendMessageToClaude timeout
  */
@@ -256,6 +283,39 @@ async function getCleanPaneOutput(sessionName, lines = 50) {
     const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -lines });
     return (0, cli_patterns_1.stripAnsi)(output);
 }
+/**
+ * The terminal error pattern visible in the tail of `cleanOutput`, or null.
+ *
+ * Extracted from isSessionHealthy() so the initialization loop can apply the
+ * same judgement (Issue #1637): with a 60s start budget, a session that has
+ * already printed "Claude Code cannot be launched inside another Claude Code
+ * session" must not sit there burning the whole budget before saying so.
+ *
+ * Only the last {@link HEALTH_CHECK_ERROR_TAIL_LINES} lines are searched, so a
+ * historical error that has scrolled up cannot condemn a session that recovered.
+ *
+ * @param cleanOutput - ANSI-stripped pane output
+ * @returns The matched pattern (or regex source) for the log, or null
+ */
+function findSessionErrorPattern(cleanOutput) {
+    const allLines = cleanOutput
+        .trim()
+        .split('\n')
+        .filter((line) => line.trim() !== '');
+    const tailText = allLines.slice(-HEALTH_CHECK_ERROR_TAIL_LINES).join('\n');
+    // 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 (tailText.includes(pattern)) {
+            return pattern;
+        }
+    }
+    for (const regex of cli_patterns_1.CLAUDE_SESSION_ERROR_REGEX_PATTERNS) {
+        if (regex.test(tailText)) {
+            return regex.source;
+        }
+    }
+    return null;
+}
 /**
  * Verify that Claude CLI is actually running inside a tmux session
  * Detects broken sessions where tmux exists but Claude failed to start
@@ -291,18 +351,9 @@ async function isSessionHealthy(sessionName) {
         // Only the last HEALTH_CHECK_ERROR_TAIL_LINES lines are searched, so
         // historical errors that have scrolled up do not trigger false negatives.
         const allLines = trimmed.split('\n').filter(line => line.trim() !== '');
-        const tailLines = allLines.slice(-HEALTH_CHECK_ERROR_TAIL_LINES);
-        const tailText = tailLines.join('\n');
-        // 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 (tailText.includes(pattern)) {
-                return { healthy: false, reason: `error pattern: ${pattern}` };
-            }
-        }
-        for (const regex of cli_patterns_1.CLAUDE_SESSION_ERROR_REGEX_PATTERNS) {
-            if (regex.test(tailText)) {
-                return { healthy: false, reason: `error pattern: ${regex.source}` };
-            }
+        const errorPattern = findSessionErrorPattern(trimmed);
+        if (errorPattern !== null) {
+            return { healthy: false, reason: `error pattern: ${errorPattern}` };
         }
         // S2-F002: Extract last line after empty line filtering
         const lastLine = allLines[allLines.length - 1]?.trim() ?? '';
@@ -525,35 +576,57 @@ async function startClaudeSession(options) {
         let trustDialogHandled = false;
         while (Date.now() - startTime < maxWaitTime) {
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            // SF-001: Use getCleanPaneOutput helper (DRY)
+            let cleanOutput = null;
             try {
-                // SF-001: Use getCleanPaneOutput helper (DRY)
-                const cleanOutput = await getCleanPaneOutput(sessionName);
-                // Claude is ready when we see the prompt (DRY-001)
-                // Use CLAUDE_PROMPT_PATTERN from cli-patterns.ts for consistency
-                // Note: CLAUDE_SEPARATOR_PATTERN was removed from initialization check (Issue #187, P1-1)
-                if (cli_patterns_1.CLAUDE_PROMPT_PATTERN.test(cleanOutput)) {
-                    // Wait for stability after prompt detection (CONS-007, DOC-001)
-                    await new Promise((resolve) => setTimeout(resolve, exports.CLAUDE_POST_PROMPT_DELAY));
-                    logger.info('claude-initialized-in');
-                    initialized = true;
-                    break;
-                }
-                // Issue #201: Detect trust dialog and auto-respond with Enter
-                // Condition order: CLAUDE_PROMPT_PATTERN (above) is checked first for shortest path
-                if (!trustDialogHandled && cli_patterns_1.CLAUDE_TRUST_DIALOG_PATTERN.test(cleanOutput)) {
+                cleanOutput = await getCleanPaneOutput(sessionName);
+            }
+            catch {
+                // Ignore capture errors during initialization
+            }
+            if (cleanOutput === null) {
+                continue;
+            }
+            // Claude is ready when we see the prompt (DRY-001)
+            // Use CLAUDE_PROMPT_PATTERN from cli-patterns.ts for consistency
+            // Note: CLAUDE_SEPARATOR_PATTERN was removed from initialization check (Issue #187, P1-1)
+            if (cli_patterns_1.CLAUDE_PROMPT_PATTERN.test(cleanOutput)) {
+                // Wait for stability after prompt detection (CONS-007, DOC-001)
+                await new Promise((resolve) => setTimeout(resolve, exports.CLAUDE_POST_PROMPT_DELAY));
+                logger.info('claude-initialized-in');
+                initialized = true;
+                break;
+            }
+            // Issue #201: Detect trust dialog and auto-respond with Enter
+            // Condition order: CLAUDE_PROMPT_PATTERN (above) is checked first for shortest path
+            if (!trustDialogHandled && cli_patterns_1.CLAUDE_TRUST_DIALOG_PATTERN.test(cleanOutput)) {
+                try {
                     await (0, tmux_1.sendKeys)(sessionName, '', true);
                     trustDialogHandled = true;
                     logger.info('trust-dialog-detected');
-                    // Continue polling to wait for prompt detection
                 }
+                catch {
+                    // Left unhandled so the next poll answers the dialog again
+                }
+                // Continue polling to wait for prompt detection
             }
-            catch {
-                // Ignore capture errors during initialization
+            // Issue #1637: fail fast on a start that cannot succeed. The budget is
+            // 60s of patience for a *slow* start; a session already showing a
+            // terminal error is not slow, and waiting out the budget would only
+            // delay the same answer by 45 more seconds. Checked after the trust
+            // dialog so a dialog still on screen is answered first.
+            const errorPattern = findSessionErrorPattern(cleanOutput);
+            if (errorPattern !== null) {
+                throw new session_start_error_1.SessionStartFailedError('Claude Code', sessionName, errorPattern);
             }
         }
-        // Throw error on timeout instead of silently continuing (CONS-005, IMP-001)
+        // Issue #1637: not "failed to start" — the session and the CLI process both
+        // exist and are still initializing, and they are deliberately left running
+        // so the retry the caller is about to make is cheap. The distinction is
+        // carried to the caller by the error type rather than lost in a generic
+        // message (CONS-005, IMP-001).
         if (!initialized) {
-            throw new Error(`Claude initialization timeout (${exports.CLAUDE_INIT_TIMEOUT}ms)`);
+            throw new session_start_error_1.SessionStartTimeoutError('Claude Code', sessionName, exports.CLAUDE_INIT_TIMEOUT);
         }
         logger.info('started-claude-session:sessionname');
     }
@@ -562,6 +635,15 @@ async function startClaudeSession(options) {
         clearCachedClaudePath();
         // SEC-SF-002: Log detailed error server-side, throw generic message to client
         logger.error('session:start-failed', { error: error instanceof Error ? error.message : String(error) });
+        // Issue #1637: the one exception to SEC-SF-002. These two messages are
+        // assembled from a tool name, the tmux session name, a fixed pattern string
+        // and a number — no filesystem path, no captured CLI output — so they are
+        // safe to hand to the caller, and they are the whole reason the caller can
+        // tell "still starting" from "broken" instead of being told to read a log
+        // it may not have.
+        if ((0, session_start_error_1.isSafeSessionStartError)(error)) {
+            throw error;
+        }
         throw new Error('Failed to start Claude session');
     }
 }

package/dist/server/src/lib/session/current-output-builder.js

@@ -15,6 +15,7 @@ const cli_session_1 = require("../../lib/session/cli-session");
 const status_detector_1 = require("../../lib/detection/status-detector");
 const auto_yes_manager_1 = require("../../lib/polling/auto-yes-manager");
 const status_capture_config_1 = require("../../config/status-capture-config");
+const tmux_capture_cache_1 = require("../../lib/tmux/tmux-capture-cache");
 const agent_event_state_1 = require("../../lib/session/agent-event-state");
 /**
  * Build the current-output payload for a worktree session.
@@ -46,7 +47,19 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
     const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, status_capture_config_1.STATUS_CAPTURE_LINES, instanceId);
     const lines = output.split('\n');
     const totalLines = lines.length;
-    const newLines = lines.slice(Math.max(0, lastCapturedLine));
+    // Issue #1670: `content` is "everything the poller has not saved yet", which
+    // only works while `lastCapturedLine` indexes into `lines`. Once the capture is
+    // clipped by the window the cursor is stale by an unknown amount, and slicing at
+    // it collapses `content` to the last row or two — which is what `commandmate
+    // capture <id>` prints, so a long-lived codex session returned an empty capture.
+    // The window can only have slid forward, so 0 is the sole safe clamp; the result
+    // is a superset (it may repeat already-saved rows) and never drops new output.
+    //
+    // The effective window is the smaller of what this path asks for and what the
+    // capture layer will ever fetch — captureSessionOutput() reads at most
+    // CACHE_MAX_CAPTURE_LINES regardless of the request.
+    const captureWindowSaturated = (0, tmux_capture_cache_1.isCaptureWindowSaturated)(totalLines, Math.min(status_capture_config_1.STATUS_CAPTURE_LINES, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES));
+    const newLines = captureWindowSaturated ? lines : lines.slice(Math.max(0, lastCapturedLine));
     const newContent = newLines.join('\n');
     const compositeKey = (0, auto_yes_manager_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
     const lastServerResponseTimestamp = (0, auto_yes_manager_1.getLastServerResponseTimestamp)(compositeKey);