crewly 1.2.1 → 1.2.4

package/dist/backend/backend/src/services/agent/agent-registration.service.js

@@ -4,16 +4,20 @@ import { readFile, readdir, stat, mkdir, writeFile, access } from 'fs/promises';
 import { LoggerService } from '../core/logger.service.js';
 import { createSessionCommandHelper, getSessionBackendSync, createSessionBackend, getSessionStatePersistence, } from '../session/index.js';
 import { RuntimeServiceFactory } from './runtime-service.factory.js';
-import { CREWLY_CONSTANTS, ENV_CONSTANTS, AGENT_TIMEOUTS, ORCHESTRATOR_SESSION_NAME, ORCHESTRATOR_ROLE, RUNTIME_TYPES, SESSION_COMMAND_DELAYS, EVENT_DELIVERY_CONSTANTS, TERMINAL_PATTERNS, GEMINI_SHELL_MODE_CONSTANTS, } from '../../constants.js';
+import { CREWLY_CONSTANTS, ENV_CONSTANTS, AGENT_TIMEOUTS, ORCHESTRATOR_SESSION_NAME, ORCHESTRATOR_ROLE, RUNTIME_TYPES, SESSION_COMMAND_DELAYS, EVENT_DELIVERY_CONSTANTS, TERMINAL_PATTERNS, GEMINI_SHELL_MODE_CONSTANTS, GEMINI_STUCK_CONNECTIVITY_PATTERN, GEMINI_ERROR_STATE_CONSTANTS, } from '../../constants.js';
 import { WEB_CONSTANTS } from '../../../../config/constants.js';
 import { delay } from '../../utils/async.utils.js';
 import { getSettingsService } from '../settings/settings.service.js';
 import { SessionMemoryService } from '../memory/session-memory.service.js';
 import { RuntimeExitMonitorService } from './runtime-exit-monitor.service.js';
 import { ContextWindowMonitorService } from './context-window-monitor.service.js';
+import { OAuthReloginMonitorService } from './oauth-relogin-monitor.service.js';
 import { SubAgentMessageQueue } from '../messaging/sub-agent-message-queue.service.js';
 import { AgentSuspendService } from './agent-suspend.service.js';
+import { PromptBuilderService } from '../ai/prompt-builder.service.js';
 import { stripAnsiCodes } from '../../utils/terminal-output.utils.js';
+import { isPromptLine, containsSpinnerOrWorkingIndicator, containsProcessingIndicator, containsBusyStatusBar, containsRewindMode, containsGeminiProcessingKeywords, extractChatPrefix, stripTuiLineBorders, matchTuiPromptLine, } from '../../utils/terminal-string-ops.js';
+import { PtyActivityTrackerService } from './pty-activity-tracker.service.js';
 /**
  * Service responsible for the complex, multi-step process of agent initialization and registration.
  * Isolates the complex state management of agent startup with progressive escalation.
@@ -46,17 +50,14 @@ export class AgentRegistrationService {
     // Prevents concurrent sendMessageWithRetry calls to the same session,
     // which causes multiple Ctrl+C presses that can crash the runtime.
     sessionDeliveryMutex = new Map();
+    // Per-session hash of last sent message to prevent duplicate writes (#128).
+    // Key: sessionName, Value: { hash, sentAt }
+    lastSentMessageHash = new Map();
     // Terminal patterns are now centralized in TERMINAL_PATTERNS constant
-    // Keeping these as static getters for backwards compatibility within the class
+    // Keeping prompt chars as static getter for backwards compatibility within the class
     static get CLAUDE_PROMPT_INDICATORS() {
         return TERMINAL_PATTERNS.PROMPT_CHARS;
     }
-    static get CLAUDE_PROMPT_STREAM_PATTERN() {
-        return TERMINAL_PATTERNS.PROMPT_STREAM;
-    }
-    static get CLAUDE_PROCESSING_INDICATORS() {
-        return TERMINAL_PATTERNS.PROCESSING_INDICATORS;
-    }
     constructor(_legacyTmuxService, // Legacy parameter for backwards compatibility
     projectRoot, storageService) {
         this.logger = LoggerService.getInstance().createComponentLogger('AgentRegistrationService');
@@ -455,6 +456,8 @@ export class AgentRegistrationService {
         // Must be before postInitialize and sendRegistrationPromptAsync so exits
         // during those phases are detected and the abort signal fires in time.
         RuntimeExitMonitorService.getInstance().startMonitoring(sessionName, runtimeType, role);
+        // Start OAuth relogin monitoring for automatic re-authentication
+        OAuthReloginMonitorService.getInstance().startMonitoring(sessionName, runtimeType);
         // Look up per-agent browser automation override from member config
         let browserAutomationOverride;
         if (memberId) {
@@ -691,6 +694,8 @@ export class AgentRegistrationService {
             }
             // Start runtime exit monitoring immediately after runtime is ready
             RuntimeExitMonitorService.getInstance().startMonitoring(sessionName, runtimeType, role);
+            // Start OAuth relogin monitoring for automatic re-authentication
+            OAuthReloginMonitorService.getInstance().startMonitoring(sessionName, runtimeType);
             // Additional verification: Use runtime detection to confirm runtime is responding
             // Wait a bit longer for runtime to fully load after showing welcome message
             this.logger.debug('Runtime ready detected for orchestrator, waiting for full startup before verification', { sessionName, runtimeType });
@@ -733,6 +738,8 @@ export class AgentRegistrationService {
             }
             // Start runtime exit monitoring immediately after runtime is ready
             RuntimeExitMonitorService.getInstance().startMonitoring(sessionName, runtimeType, role);
+            // Start OAuth relogin monitoring for automatic re-authentication
+            OAuthReloginMonitorService.getInstance().startMonitoring(sessionName, runtimeType);
         }
         // Look up per-agent browser automation override from member config
         let browserOverrideForRecreation;
@@ -840,17 +847,23 @@ export class AgentRegistrationService {
                 // For orchestrator or cases without member ID, remove the memberId parameter
                 prompt = prompt.replace(/,\s*"memberId":\s*"\{\{MEMBER_ID\}\}"/g, '');
             }
-            // Look up project path for team members
+            // Look up project path and TL hierarchy for team members
             let projectPath = process.cwd();
+            let foundTeam = null;
+            let foundMember = null;
             try {
                 const teams = await this.storageService.getTeams();
                 for (const team of teams) {
                     const member = team.members?.find((m) => m.sessionName === sessionName);
-                    if (member && team.projectIds[0]) {
-                        const projects = await this.storageService.getProjects();
-                        const project = projects.find((p) => p.id === team.projectIds[0]);
-                        if (project?.path) {
-                            projectPath = project.path;
+                    if (member) {
+                        foundTeam = team;
+                        foundMember = member;
+                        if (team.projectIds[0]) {
+                            const projects = await this.storageService.getProjects();
+                            const project = projects.find((p) => p.id === team.projectIds[0]);
+                            if (project?.path) {
+                                projectPath = project.path;
+                            }
                         }
                         break;
                     }
@@ -892,6 +905,53 @@ export class AgentRegistrationService {
             // Replace marketplace skills path placeholder
             const marketplaceSkillsPath = path.join(os.homedir(), '.crewly', 'marketplace', 'skills');
             prompt = prompt.replace(/\{\{MARKETPLACE_SKILLS_PATH\}\}/g, marketplaceSkillsPath);
+            // Inject Team Lead addon for members with canDelegate=true and subordinates
+            if (foundMember?.canDelegate && foundMember.subordinateIds && foundMember.subordinateIds.length > 0 && foundTeam) {
+                try {
+                    // Resolve subordinateIds to SubordinateInfo[]
+                    const subordinates = foundMember.subordinateIds
+                        .map((subId) => {
+                        const subMember = foundTeam.members?.find((m) => m.id === subId);
+                        if (!subMember)
+                            return null;
+                        return {
+                            name: subMember.name,
+                            sessionName: subMember.sessionName || '',
+                            role: subMember.role || 'developer',
+                        };
+                    })
+                        .filter((s) => s !== null);
+                    if (subordinates.length > 0) {
+                        const tlConfig = {
+                            name: sessionName,
+                            role: role,
+                            systemPrompt: '',
+                            projectPath,
+                            memberId,
+                            teamId: foundTeam.id,
+                            canDelegate: true,
+                            subordinates,
+                        };
+                        const promptBuilder = new PromptBuilderService(this.projectRoot);
+                        const tlSection = await promptBuilder.buildTeamLeadSection(tlConfig);
+                        if (tlSection) {
+                            prompt += `\n\n---\n\n${tlSection}`;
+                            this.logger.info('TL addon injected into init prompt', {
+                                sessionName,
+                                subordinateCount: subordinates.length,
+                                subordinateNames: subordinates.map((s) => s.name),
+                                tlSectionLength: tlSection.length,
+                            });
+                        }
+                    }
+                }
+                catch (tlError) {
+                    this.logger.warn('Failed to inject TL addon (non-critical)', {
+                        sessionName,
+                        error: tlError instanceof Error ? tlError.message : String(tlError),
+                    });
+                }
+            }
             // Generate and inject startup briefing from session memory
             try {
                 const sessionMemoryService = SessionMemoryService.getInstance();
@@ -1444,6 +1504,8 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                     if (role !== ORCHESTRATOR_ROLE && config.teamId && config.memberId) {
                         ContextWindowMonitorService.getInstance().startSessionMonitoring(sessionName, config.memberId, config.teamId, role, runtimeType);
                     }
+                    // Start OAuth relogin monitoring for recovered session
+                    OAuthReloginMonitorService.getInstance().startMonitoring(sessionName, runtimeType);
                     return {
                         success: true,
                         sessionName,
@@ -1508,6 +1570,14 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.CREWLY_SESSION_NAME, sessionName);
             await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.CREWLY_ROLE, role);
             await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.CREWLY_API_URL, `http://localhost:${WEB_CONSTANTS.PORTS.BACKEND}`);
+            // Pass Gemini API key to gemini-cli agents so they authenticate
+            // with the paid API key instead of the free-tier Google login.
+            if (runtimeType === RUNTIME_TYPES.GEMINI_CLI) {
+                const geminiApiKey = process.env[ENV_CONSTANTS.GEMINI_API_KEY];
+                if (geminiApiKey) {
+                    await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.GEMINI_API_KEY, geminiApiKey);
+                }
+            }
             this.logger.info('Agent session created and environment variables set, initializing with registration', {
                 sessionName,
                 role,
@@ -1529,6 +1599,8 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             if (role !== ORCHESTRATOR_ROLE && config.teamId && config.memberId) {
                 ContextWindowMonitorService.getInstance().startSessionMonitoring(sessionName, config.memberId, config.teamId, role, runtimeType);
             }
+            // Start OAuth relogin monitoring for newly created session
+            OAuthReloginMonitorService.getInstance().startMonitoring(sessionName, runtimeType);
             return {
                 success: true,
                 sessionName,
@@ -1560,6 +1632,8 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             this.logger.info('Terminating agent session (unified approach)', { sessionName, role });
             // Stop runtime exit monitoring before killing the session
             RuntimeExitMonitorService.getInstance().stopMonitoring(sessionName);
+            // Stop OAuth relogin monitoring before killing the session
+            OAuthReloginMonitorService.getInstance().stopMonitoring(sessionName);
             // Stop context window monitoring before killing the session
             ContextWindowMonitorService.getInstance().stopSessionMonitoring(sessionName);
             // Get session helper once to avoid repeated async calls
@@ -1701,9 +1775,9 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             if (!delivered) {
                 // Check if the agent is actively processing (busy) — the queue
                 // processor can re-queue instead of permanently failing the message.
-                const busyOutput = sessionHelper.capturePane(sessionName).slice(-2000);
-                const isBusy = TERMINAL_PATTERNS.BUSY_STATUS_BAR.test(busyOutput) ||
-                    TERMINAL_PATTERNS.PROCESSING_WITH_TEXT.test(busyOutput);
+                // Use PTY idle time instead of regex patterns for robust cross-runtime detection.
+                const idleMs = PtyActivityTrackerService.getInstance().getIdleTimeMs(sessionName);
+                const isBusy = idleMs < SESSION_COMMAND_DELAYS.AGENT_BUSY_IDLE_THRESHOLD_MS;
                 return {
                     success: false,
                     error: isBusy
@@ -1768,9 +1842,6 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
         if (!session) {
             return false;
         }
-        // Use runtime-specific pattern for stream detection to avoid false positives
-        // (e.g. Gemini's `> ` pattern matching markdown blockquotes in Claude Code output)
-        const streamPattern = this.getPromptPatternForRuntime(runtimeType);
         return new Promise((resolve) => {
             let resolved = false;
             const pollInterval = EVENT_DELIVERY_CONSTANTS.AGENT_READY_POLL_INTERVAL;
@@ -1817,9 +1888,11 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 if (resolved)
                     return;
                 // Strip ANSI escape sequences before testing — raw PTY data contains
-                // cursor positioning, color codes, etc. that break regex matching (#106)
+                // cursor positioning, color codes, etc. that break pattern matching (#106)
                 const cleanData = stripAnsiCodes(data);
-                if (streamPattern.test(cleanData)) {
+                // Check each line for prompt pattern (string-based, no regex)
+                const hasPromptInStream = cleanData.split('\n').some(line => line.trim().length > 0 && isPromptLine(line, runtimeType));
+                if (hasPromptInStream) {
                     // Double-check with capturePane to avoid false positives from partial data
                     const output = sessionHelper.capturePane(sessionName);
                     if (this.isClaudeAtPrompt(output, runtimeType)) {
@@ -1831,256 +1904,6 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             });
         });
     }
-    /**
-     * @deprecated Replaced by SessionCommandHelper.sendMessage() in sendMessageWithRetry.
-     * Complex event-driven state machine was fragile — Enter key often got lost.
-     * Kept as dead code for reference during transition.
-     */
-    async _deprecated_sendMessageEventDriven(sessionName, message, timeoutMs = EVENT_DELIVERY_CONSTANTS.TOTAL_DELIVERY_TIMEOUT) {
-        const sessionHelper = await this.getSessionHelper();
-        const session = sessionHelper.getSession(sessionName);
-        if (!session) {
-            this.logger.error('Session not found for event-driven delivery', { sessionName });
-            return false;
-        }
-        return new Promise((resolve) => {
-            let buffer = '';
-            let messageSent = false;
-            let enterSent = false;
-            let enterAccepted = false;
-            let deliveryConfirmed = false;
-            let resolved = false;
-            // Track all timeouts to prevent memory leaks (P1.1 fix)
-            const pendingTimeouts = [];
-            const scheduleTimeout = (fn, delayMs) => {
-                const id = setTimeout(fn, delayMs);
-                pendingTimeouts.push(id);
-                return id;
-            };
-            const cleanup = () => {
-                // Immediately mark as resolved to prevent race conditions (P1.2 fix)
-                const wasResolved = resolved;
-                resolved = true;
-                if (!wasResolved) {
-                    // Clear all pending timeouts to prevent memory leaks
-                    pendingTimeouts.forEach((id) => clearTimeout(id));
-                    clearTimeout(timeoutId);
-                    unsubscribe();
-                }
-            };
-            // Use centralized patterns from TERMINAL_PATTERNS
-            const PASTE_PATTERN = TERMINAL_PATTERNS.PASTE_INDICATOR;
-            const PROCESSING_PATTERN = TERMINAL_PATTERNS.PROCESSING;
-            // Use centralized timing from EVENT_DELIVERY_CONSTANTS
-            const INITIAL_DELAY = EVENT_DELIVERY_CONSTANTS.INITIAL_MESSAGE_DELAY;
-            const PASTE_CHECK_DELAY = EVENT_DELIVERY_CONSTANTS.PASTE_CHECK_DELAY;
-            const ENTER_RETRY_DELAY = EVENT_DELIVERY_CONSTANTS.ENTER_RETRY_DELAY;
-            const MAX_ENTER_RETRIES = EVENT_DELIVERY_CONSTANTS.MAX_ENTER_RETRIES;
-            const MAX_BUFFER_SIZE = EVENT_DELIVERY_CONSTANTS.MAX_BUFFER_SIZE;
-            // Helper to send the message when prompt is detected
-            const sendMessageNow = () => {
-                if (messageSent || resolved)
-                    return;
-                this.logger.debug('Claude at prompt, sending message', {
-                    sessionName,
-                    messageLength: message.length,
-                    isMultiLine: message.includes('\n'),
-                });
-                // Send the message text
-                session.write(message);
-                messageSent = true;
-                const isMultiLine = message.includes('\n');
-                // Track Enter key state
-                let enterAttempts = 0;
-                let processingDetected = false;
-                const bufferAtSend = buffer;
-                // Function to send Enter and track attempts
-                const sendEnterKey = (reason) => {
-                    if (resolved || processingDetected)
-                        return;
-                    enterAttempts++;
-                    session.write('\r');
-                    enterSent = true;
-                    this.logger.debug('Enter key sent', {
-                        sessionName,
-                        attempt: enterAttempts,
-                        reason,
-                    });
-                };
-                // Function to check if Enter was accepted (processing started)
-                const checkProcessingStarted = () => {
-                    const newData = buffer.slice(bufferAtSend.length);
-                    return PROCESSING_PATTERN.test(newData);
-                };
-                // Function to check for paste indicator
-                const checkPasteIndicator = () => {
-                    const newData = buffer.slice(bufferAtSend.length);
-                    return PASTE_PATTERN.test(newData);
-                };
-                // Strategy: Send Enter with progressive timing, retry if not accepted
-                const attemptEnter = (attemptNum) => {
-                    if (resolved || processingDetected)
-                        return;
-                    // Check if processing already started
-                    if (checkProcessingStarted()) {
-                        processingDetected = true;
-                        enterAccepted = true;
-                        this.logger.debug('Processing detected, message accepted', { sessionName, attemptNum });
-                        buffer = ''; // Reset for processing indicator detection
-                        return;
-                    }
-                    if (attemptNum > MAX_ENTER_RETRIES) {
-                        this.logger.warn('Max Enter retries reached, verifying message acceptance', { sessionName });
-                        scheduleTimeout(async () => {
-                            if (resolved)
-                                return;
-                            const stuck = await this.isMessageStuckAtPrompt(sessionName, message);
-                            if (stuck) {
-                                this.logger.warn('Message stuck at prompt after all Enter retries', { sessionName });
-                                const stuckHelper = await this.getSessionHelper();
-                                await stuckHelper.clearCurrentCommandLine(sessionName);
-                                enterAccepted = false;
-                            }
-                            else {
-                                this.logger.debug('Message appears accepted (no longer at prompt)', { sessionName });
-                                enterAccepted = true;
-                                buffer = '';
-                            }
-                        }, EVENT_DELIVERY_CONSTANTS.POST_ENTER_VERIFICATION_DELAY);
-                        return;
-                    }
-                    sendEnterKey(attemptNum === 1 ? 'initial' : `retry-${attemptNum}`);
-                    // Schedule check and possible retry (using tracked timeout to prevent leaks)
-                    scheduleTimeout(() => {
-                        if (resolved)
-                            return;
-                        if (checkProcessingStarted()) {
-                            processingDetected = true;
-                            enterAccepted = true;
-                            this.logger.debug('Processing detected after Enter', { sessionName, attemptNum });
-                            buffer = '';
-                        }
-                        else {
-                            // Not accepted yet, retry
-                            this.logger.debug('Enter may not have been accepted, retrying', {
-                                sessionName,
-                                attemptNum,
-                                bufferLength: buffer.length,
-                            });
-                            attemptEnter(attemptNum + 1);
-                        }
-                    }, ENTER_RETRY_DELAY);
-                };
-                // For multi-line messages, wait longer for paste indicator
-                // For single-line messages, send Enter sooner
-                const initialWait = isMultiLine ? PASTE_CHECK_DELAY : INITIAL_DELAY;
-                scheduleTimeout(() => {
-                    if (resolved)
-                        return;
-                    // For multi-line: check if paste indicator appeared
-                    if (isMultiLine && checkPasteIndicator()) {
-                        this.logger.debug('Paste indicator detected', { sessionName });
-                    }
-                    // Start Enter key attempts
-                    attemptEnter(1);
-                }, initialWait);
-            };
-            const timeoutId = setTimeout(async () => {
-                this.logger.debug('Event-driven delivery timed out', {
-                    sessionName,
-                    messageSent,
-                    enterSent,
-                    enterAccepted,
-                    deliveryConfirmed,
-                    bufferLength: buffer.length,
-                });
-                // If Enter was sent but not confirmed accepted, verify via terminal capture
-                if (enterSent && !enterAccepted && !deliveryConfirmed) {
-                    const timeoutHelper = await this.getSessionHelper();
-                    const stuck = await this.isMessageStuckAtPrompt(sessionName, message);
-                    if (stuck) {
-                        this.logger.warn('Timeout: message stuck at prompt, clearing and failing', { sessionName });
-                        await timeoutHelper.clearCurrentCommandLine(sessionName);
-                        cleanup();
-                        resolve(false);
-                        return;
-                    }
-                    this.logger.debug('Timeout: message not at prompt, treating as accepted', { sessionName });
-                }
-                cleanup();
-                resolve(enterAccepted || deliveryConfirmed);
-            }, timeoutMs);
-            // IMPORTANT: Check current terminal state, but wait for output to settle first.
-            // If the orchestrator just finished outputting (greeting, notification, status bar),
-            // the prompt may not be cleanly detectable. We capture the pane, wait briefly,
-            // and re-capture. If output is still changing, wait again before checking prompt.
-            // Use 50 lines to account for status bars and notifications that can
-            // wrap across many lines and push the prompt out of a smaller window.
-            const waitForSettled = async () => {
-                let prevOutput = sessionHelper.capturePane(sessionName);
-                for (let i = 0; i < 5; i++) { // Max 5 checks, 500ms apart = 2.5s max
-                    if (resolved)
-                        return;
-                    await delay(500);
-                    if (resolved)
-                        return;
-                    const currentOutput = sessionHelper.capturePane(sessionName);
-                    if (currentOutput === prevOutput) {
-                        // Output settled
-                        if (this.isClaudeAtPrompt(currentOutput)) {
-                            this.logger.debug('Claude at prompt after output settled', { sessionName, settleChecks: i + 1 });
-                            sendMessageNow();
-                        }
-                        return;
-                    }
-                    prevOutput = currentOutput;
-                }
-                // Output still changing after 2.5s - check anyway
-                if (!resolved && this.isClaudeAtPrompt(prevOutput)) {
-                    this.logger.debug('Claude at prompt (output still changing, checking anyway)', { sessionName });
-                    sendMessageNow();
-                }
-            };
-            waitForSettled();
-            const unsubscribe = session.onData((data) => {
-                if (resolved)
-                    return;
-                // Accumulate data with size limit to prevent memory exhaustion (P2.3 fix)
-                buffer += data;
-                if (buffer.length > MAX_BUFFER_SIZE) {
-                    buffer = buffer.slice(-MAX_BUFFER_SIZE);
-                }
-                // Phase 1: Wait for Claude to be at prompt before sending
-                if (!messageSent) {
-                    const isAtPrompt = AgentRegistrationService.CLAUDE_PROMPT_STREAM_PATTERN.test(buffer);
-                    if (isAtPrompt) {
-                        sendMessageNow();
-                    }
-                    return;
-                }
-                // Phase 2: Only check for processing indicators AFTER Enter has been sent
-                if (!enterSent) {
-                    return; // Wait for Enter to be sent
-                }
-                // Look for processing indicators confirming delivery
-                const hasProcessingIndicator = AgentRegistrationService.CLAUDE_PROCESSING_INDICATORS.some((pattern) => pattern.test(buffer));
-                // Also check if prompt disappeared (Claude is working)
-                const promptStillVisible = AgentRegistrationService.CLAUDE_PROMPT_STREAM_PATTERN.test(buffer);
-                // Use constant for minimum buffer check (P3.2 fix)
-                if (hasProcessingIndicator || (!promptStillVisible && buffer.length > EVENT_DELIVERY_CONSTANTS.MIN_BUFFER_FOR_PROCESSING_DETECTION)) {
-                    this.logger.debug('Message delivery confirmed (event-driven)', {
-                        sessionName,
-                        hasProcessingIndicator,
-                        promptStillVisible,
-                        bufferLength: buffer.length,
-                    });
-                    deliveryConfirmed = true;
-                    cleanup();
-                    resolve(true);
-                }
-            });
-        });
-    }
     /**
      * Send message with retry logic for reliable delivery to Claude Code.
      * Uses SessionCommandHelper.sendMessage() (proven two-step write pattern)
@@ -2111,15 +1934,24 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 });
                 // Verify agent is at prompt before sending
                 const output = sessionHelper.capturePane(sessionName);
+                // Gemini CLI stuck-connectivity guard (#128): If the CLI is in a
+                // "Trying to reach <model>" retry loop, it will never process
+                // new messages. Bail out immediately so the caller gets a clear
+                // failure signal and the runtime-exit-monitor can trigger recovery.
+                if (runtimeType === RUNTIME_TYPES.GEMINI_CLI && GEMINI_STUCK_CONNECTIVITY_PATTERN.test(output)) {
+                    this.logger.warn('Gemini CLI stuck in connectivity retry loop, aborting message delivery (#128)', {
+                        sessionName,
+                        attempt,
+                    });
+                    return false;
+                }
                 if (!this.isClaudeAtPrompt(output, runtimeType)) {
                     if (attempt === maxAttempts) {
                         // On the final attempt, check if the agent is DEFINITELY busy
-                        // before force-delivering. If we see "esc to interrupt" or
-                        // processing indicators, the agent is actively working and
-                        // force-delivery risks corrupting its current task.
-                        const tailForBusyCheck = output.slice(-2000);
-                        const isBusy = TERMINAL_PATTERNS.BUSY_STATUS_BAR.test(tailForBusyCheck) ||
-                            TERMINAL_PATTERNS.PROCESSING_WITH_TEXT.test(tailForBusyCheck);
+                        // before force-delivering. Use PTY idle time for robust
+                        // cross-runtime detection instead of fragile regex patterns.
+                        const idleMs = PtyActivityTrackerService.getInstance().getIdleTimeMs(sessionName);
+                        const isBusy = idleMs < SESSION_COMMAND_DELAYS.AGENT_BUSY_IDLE_THRESHOLD_MS;
                         if (isBusy) {
                             this.logger.warn('Agent is busy (processing indicators detected), skipping force delivery', {
                                 sessionName,
@@ -2182,20 +2014,49 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 //    for focus cycling and overlay dismissal.
                 if (isClaudeCode) {
                     if (attempt > 1) {
+                        // On retry: Ctrl+C to cancel stale input, then PTY resize to force
+                        // TUI re-render (SIGWINCH), then Tab to cycle Ink focus.
                         await sessionHelper.sendCtrlC(sessionName);
                         await delay(300);
                     }
+                    // PTY resize on ALL attempts to force SIGWINCH → Ink TUI re-render.
+                    // Claude Code's Ink TUI can lose internal input focus after stop hooks
+                    // (especially ones that error), state transitions, or idle periods.
+                    // When defocused, the `❯` prompt is visible in the terminal buffer
+                    // but writes are silently consumed by the framework — NOT routed to
+                    // the InputPrompt. Tab alone was insufficient; PTY resize forces a
+                    // full TUI re-render that reliably restores focus state.
+                    // This matches the manual workaround where pressing a key in the
+                    // frontend terminal "wakes up" the input handler.
+                    try {
+                        const session = sessionHelper.getSession(sessionName);
+                        if (session) {
+                            session.resize(81, 25);
+                            await delay(200);
+                            session.resize(80, 24);
+                            await delay(300);
+                        }
+                    }
+                    catch { /* non-fatal */ }
+                    await sessionHelper.sendKey(sessionName, 'Tab');
+                    await delay(300);
                 }
                 else {
                     // Detect recent /compress — Ink TUI loses internal focus after
                     // /compress re-renders, causing subsequent messages to be silently
                     // dropped even though the prompt `>` is visible (#114).
                     // Always force PTY resize on attempt 1 if /compress detected.
+                    // Also detect ✖ error state (#130) — MCP connection errors
+                    // cause a persistent error indicator that steals TUI focus.
                     const recentOutput = sessionHelper.capturePane(sessionName, 40);
                     const compressDetected = recentOutput.includes('/compress') ||
                         recentOutput.includes('Context compressed') ||
                         recentOutput.includes('Compressing context');
-                    const needsResize = attempt > 1 || compressDetected;
+                    // Check for Gemini CLI error indicators in the status bar area (#130).
+                    const statusArea = recentOutput.split('\n').slice(-GEMINI_ERROR_STATE_CONSTANTS.STATUS_AREA_LINES).join('\n');
+                    const errorStateDetected = recentOutput.includes(GEMINI_ERROR_STATE_CONSTANTS.ERROR_MARKER) ||
+                        GEMINI_ERROR_STATE_CONSTANTS.ERROR_COUNT_PATTERN.test(statusArea);
+                    const needsResize = attempt > 1 || compressDetected || errorStateDetected;
                     // Force a PTY resize to trigger SIGWINCH, making Ink
                     // re-render the TUI and potentially restore focus state.
                     if (needsResize) {
@@ -2221,19 +2082,39 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                             });
                         }
                     }
+                    // If error state detected (✖), dismiss the error overlay first (#130).
+                    // F12 toggles the error details panel in Gemini CLI, Enter dismisses
+                    // any overlay/notification, and the combination restores the TUI to a
+                    // state where the InputPrompt can accept input.
+                    if (errorStateDetected) {
+                        this.logger.info('Gemini CLI error state detected (✖), dismissing before delivery (#130)', {
+                            sessionName,
+                            attempt,
+                        });
+                        // F12 to close error details panel if open
+                        await sessionHelper.sendKey(sessionName, 'F12');
+                        await delay(300);
+                        // Enter to dismiss any remaining overlay/notification
+                        await sessionHelper.sendEnter(sessionName);
+                        await delay(500);
+                    }
                     // Send Tab to cycle Ink focus. In Ink v6, Tab triggers
                     // focusNext() in FocusContext, which moves focus to the next
                     // focusable component (InputPrompt). This works even when the
                     // input is defocused because the Tab handler runs at the Ink
                     // framework level, not the component level.
+                    // Send two Tabs to cycle through error/notification components
+                    // that may be in the focus chain (#130).
+                    await sessionHelper.sendKey(sessionName, 'Tab');
+                    await delay(200);
                     await sessionHelper.sendKey(sessionName, 'Tab');
                     await delay(300);
                     // Then Enter to dismiss any notification overlay and ensure
                     // the input is engaged. Enter on an empty `> ` prompt is a
                     // safe no-op (just shows a new blank prompt line).
                     await sessionHelper.sendEnter(sessionName);
-                    // Extra settling time after /compress to let Ink TUI stabilize
-                    await delay(compressDetected ? 1000 : 500);
+                    // Extra settling time after /compress or error state to let Ink TUI stabilize
+                    await delay((compressDetected || errorStateDetected) ? 1000 : 500);
                 }
                 // For Gemini CLI: detect and gently escape interactive modes before
                 // sending the message. Avoid Ctrl-C here — Gemini interprets it as
@@ -2266,6 +2147,50 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 // border redraws that can cause length changes unrelated to delivery.
                 const beforeOutput = sessionHelper.capturePane(sessionName, 20);
                 const beforeLength = beforeOutput.length;
+                // Deduplication guard (#128): Check if the agent is already
+                // processing on ALL attempts (not just retries). A previous
+                // write may have succeeded but verification failed. Re-writing
+                // the same message creates a duplicate in the input buffer.
+                {
+                    const preWriteCheck = sessionHelper.capturePane(sessionName);
+                    const hasSpinner = containsSpinnerOrWorkingIndicator(preWriteCheck);
+                    if (hasSpinner) {
+                        // Hash-based dedup: if the same message was recently sent
+                        // and the agent is processing, it's very likely our message.
+                        const msgHash = message.substring(0, 200);
+                        const lastSent = this.lastSentMessageHash.get(sessionName);
+                        const isRecentDuplicate = lastSent
+                            && lastSent.hash === msgHash
+                            && (Date.now() - lastSent.sentAt) < 60000;
+                        if (isRecentDuplicate || attempt > 1) {
+                            this.logger.info('Agent already processing — skipping write to prevent duplicate (#128)', {
+                                sessionName,
+                                attempt,
+                                isRecentDuplicate: !!isRecentDuplicate,
+                            });
+                            return true;
+                        }
+                    }
+                    // On retries: also check if agent is not at prompt AND our
+                    // message text is NOT stuck at the bottom.
+                    if (attempt > 1) {
+                        const notAtPrompt = !this.isClaudeAtPrompt(preWriteCheck, runtimeType);
+                        if (notAtPrompt) {
+                            const msgSnippet = (message.length > 20
+                                ? message.substring(0, 80)
+                                : message).replace(/\s+/g, ' ').trim();
+                            const bottomLines = preWriteCheck.split('\n').slice(-10).join(' ').replace(/\s+/g, ' ');
+                            const textStuck = bottomLines.includes(msgSnippet);
+                            if (!textStuck) {
+                                this.logger.info('Agent not at prompt and message not stuck — skipping re-write (#128)', {
+                                    sessionName,
+                                    attempt,
+                                });
+                                return true;
+                            }
+                        }
+                    }
+                }
                 // Use SessionCommandHelper.sendMessage() — proven two-step write:
                 // 1. session.write(message)    — triggers bracketed paste
                 // 2. await delay(scaled)       — waits for paste processing
@@ -2276,6 +2201,11 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 // If progressive verification below misses an Enter drop, the
                 // background scanner will catch it within 30s.
                 this.trackSentMessage(sessionName, message);
+                // Track message hash for deduplication on retry (#128)
+                this.lastSentMessageHash.set(sessionName, {
+                    hash: message.substring(0, 200),
+                    sentAt: Date.now(),
+                });
                 // Wait for agent to start processing, then verify delivery.
                 // TUI runtimes need a longer delay (3s) for the TUI to redraw
                 // and show processing indicators after accepting input.
@@ -2318,7 +2248,7 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                         //    definitive proof the agent accepted and is working.
                         //    Only check spinner/⏺ chars — NOT text words like
                         //    "thinking" which appear in historical response text.
-                        if (TERMINAL_PATTERNS.PROCESSING.test(currentOutput)) {
+                        if (containsSpinnerOrWorkingIndicator(currentOutput)) {
                             this.logger.debug('Processing indicators detected — message accepted', {
                                 sessionName,
                                 attempt,
@@ -2342,18 +2272,24 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                                 : message).replace(/\s+/g, ' ').trim();
                             const promptBottomLines = currentOutput.split('\n').slice(-10).join(' ').replace(/\s+/g, ' ');
                             if (promptBottomLines.includes(promptMsgSnippet)) {
-                                this.logger.warn('At prompt with message text at bottom — pressing Enter', {
+                                this.logger.warn('At prompt with message text at bottom — pressing Tab+Enter', {
                                     sessionName,
                                     attempt,
                                     intervalMs,
                                 });
+                                // Tab restores Ink TUI focus before Enter — without this,
+                                // Enter may be consumed by the framework but not routed to
+                                // the input component if focus was lost during a re-render
+                                // (e.g., after stop hooks, state transitions).
+                                await sessionHelper.sendKey(sessionName, 'Tab');
+                                await delay(200);
                                 await sessionHelper.sendEnter(sessionName);
                                 await delay(500);
                                 await sessionHelper.sendEnter(sessionName); // backup
                                 await delay(SESSION_COMMAND_DELAYS.MESSAGE_PROCESSING_DELAY);
                                 // Verify recovery
                                 const postEnterOutput = sessionHelper.capturePane(sessionName);
-                                if (TERMINAL_PATTERNS.PROCESSING.test(postEnterOutput) ||
+                                if (containsSpinnerOrWorkingIndicator(postEnterOutput) ||
                                     !this.isClaudeAtPrompt(postEnterOutput, runtimeType)) {
                                     this.logger.info('Enter recovery from prompt successful', {
                                         sessionName,
@@ -2387,12 +2323,14 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                             // Message text is at the bottom of the terminal but the
                             // prompt is no longer in its idle form — Enter was dropped.
                             // Instead of waiting and doing a full Ctrl+C + resend retry,
-                            // press Enter immediately to submit the already-pasted text.
-                            this.logger.warn('Message text stuck at bottom — pressing Enter to recover', {
+                            // use Tab to restore TUI focus, then Enter to submit.
+                            this.logger.warn('Message text stuck at bottom — pressing Tab+Enter to recover', {
                                 sessionName,
                                 attempt,
                                 intervalMs,
                             });
+                            await sessionHelper.sendKey(sessionName, 'Tab');
+                            await delay(200);
                             await sessionHelper.sendEnter(sessionName);
                             await delay(500);
                             await sessionHelper.sendEnter(sessionName); // backup Enter
@@ -2400,7 +2338,7 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                             await delay(SESSION_COMMAND_DELAYS.MESSAGE_PROCESSING_DELAY);
                             // Verify recovery: check if processing started
                             const recoveryOutput = sessionHelper.capturePane(sessionName);
-                            if (TERMINAL_PATTERNS.PROCESSING.test(recoveryOutput)) {
+                            if (containsSpinnerOrWorkingIndicator(recoveryOutput)) {
                                 this.logger.info('Enter recovery successful — processing started', {
                                     sessionName,
                                     attempt,
@@ -2487,9 +2425,9 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                                 .filter((line) => !beforeLines.has(line))
                                 .join('\n');
                         }
-                        const hasProcessingIndicators = TERMINAL_PATTERNS.PROCESSING_WITH_TEXT.test(newContent || afterOutput.slice(-500));
+                        const hasProcessingIndicators = containsProcessingIndicator(newContent || afterOutput.slice(-500));
                         const hasGeminiIndicators = newContent.length > 0
-                            && /reading|thinking|processing|analyzing|generating|searching/i.test(newContent);
+                            && containsGeminiProcessingKeywords(newContent);
                         const significantLengthChange = Math.abs(lengthDiff) > 10;
                         // For Gemini CLI, contentChanged alone is sufficient evidence of
                         // delivery. The TUI redraws minimally (lengthDiff can be as low as
@@ -2568,19 +2506,11 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 }
             }
         }
-        // Verification failed, but the message was physically written to the PTY.
-        // If the session is still alive, the agent will likely process it — return
-        // true to avoid false "Failed to deliver" errors shown to users (#99).
-        const backend = getSessionBackendSync();
-        const childAlive = backend?.isChildProcessAlive?.(sessionName);
-        if (childAlive !== false) {
-            this.logger.warn('Message delivery verification inconclusive but session alive — assuming success', {
-                sessionName,
-                maxAttempts,
-                messageLength: message.length,
-            });
-            return true;
-        }
+        this.logger.warn('Message delivery verification failed — all attempts exhausted', {
+            sessionName,
+            maxAttempts,
+            messageLength: message.length,
+        });
         this.logger.error('Message delivery failed after all retry attempts', {
             sessionName,
             maxAttempts,
@@ -2608,13 +2538,13 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             }
             // Extract a search token from the message:
             // Strip [CHAT:uuid] prefix if present, then take the first 40 chars
-            const chatPrefixMatch = message.match(/^\[CHAT:[^\]]+\]\s*/);
-            const contentAfterPrefix = chatPrefixMatch
-                ? message.slice(chatPrefixMatch[0].length)
+            const { prefixLength } = extractChatPrefix(message);
+            const contentAfterPrefix = prefixLength > 0
+                ? message.slice(prefixLength)
                 : message;
             const searchToken = contentAfterPrefix.slice(0, 40).trim();
             // Also use [CHAT: as a secondary token if message has a CHAT prefix
-            const chatToken = chatPrefixMatch ? '[CHAT:' : null;
+            const chatToken = prefixLength > 0 ? '[CHAT:' : null;
             // Check last 20 non-empty lines for either token.
             // Gemini CLI TUI has status bars at the bottom (branch, sandbox, model info)
             // that push input content further up. 5 lines was insufficient.
@@ -2622,7 +2552,7 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             const linesToCheck = lines.slice(-20);
             const isStuck = linesToCheck.some((line) => {
                 // Strip TUI box-drawing borders before checking (Gemini CLI wraps content in │...│)
-                const stripped = line.replace(/^[│┃║|\s]+/, '').replace(/[│┃║|\s]+$/, '');
+                const stripped = stripTuiLineBorders(line);
                 if (searchToken && (line.includes(searchToken) || stripped.includes(searchToken)))
                     return true;
                 if (chatToken && (line.includes(chatToken) || stripped.includes(chatToken)))
@@ -2672,9 +2602,9 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 return false;
             // Extract search token: first 30 chars of the message content
             // (after stripping any [CHAT:uuid] prefix)
-            const chatPrefixMatch = message.match(/^\[CHAT:[^\]]+\]\s*/);
-            const contentAfterPrefix = chatPrefixMatch
-                ? message.slice(chatPrefixMatch[0].length)
+            const { prefixLength } = extractChatPrefix(message);
+            const contentAfterPrefix = prefixLength > 0
+                ? message.slice(prefixLength)
                 : message;
             const searchToken = contentAfterPrefix.slice(0, 30).trim();
             if (!searchToken)
@@ -2684,14 +2614,13 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             // Or without borders: > text
             // The prompt line is the line with `> ` followed by actual content.
             const lines = output.split('\n');
-            const promptLineRegex = /^[│┃║|\s]*>\s+(.+)/;
             for (let i = lines.length - 1; i >= Math.max(0, lines.length - 25); i--) {
                 const line = lines[i];
-                const match = line.match(promptLineRegex);
-                if (match) {
-                    const promptContent = match[1].replace(/[│┃║|\s]+$/, '').trim();
+                const promptContent = matchTuiPromptLine(line);
+                if (promptContent !== null) {
+                    const trimmedContent = stripTuiLineBorders(promptContent).trim();
                     // Check if the prompt line content contains our message text
-                    if (promptContent.length > 5 && promptContent.includes(searchToken)) {
+                    if (trimmedContent.length > 5 && trimmedContent.includes(searchToken)) {
                         this.logger.warn('Text stuck at TUI prompt — Enter was not pressed', {
                             sessionName,
                             searchToken: searchToken.slice(0, 20),
@@ -2721,8 +2650,12 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
      */
     async recoverStuckTuiMessage(sessionName, message) {
         const sessionHelper = await this.getSessionHelper();
-        // Press Enter to submit the stuck text
-        this.logger.info('Pressing Enter to recover stuck TUI message', { sessionName });
+        // Tab restores Ink TUI focus, then Enter to submit the stuck text.
+        // Without Tab, Enter may be consumed by the framework but not routed
+        // to the input component if focus was lost during a re-render.
+        this.logger.info('Pressing Tab+Enter to recover stuck TUI message', { sessionName });
+        await sessionHelper.sendKey(sessionName, 'Tab');
+        await delay(200);
         await sessionHelper.sendEnter(sessionName);
         await delay(500);
         // Double-tap: send a backup Enter in case the first was consumed
@@ -2797,7 +2730,7 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
         for (const sessionName of sessionHelper.listSessions()) {
             try {
                 const output = sessionHelper.capturePane(sessionName);
-                if (TERMINAL_PATTERNS.REWIND_MODE.test(output)) {
+                if (containsRewindMode(output)) {
                     this.logger.warn('Rewind mode detected, sending q to exit', { sessionName });
                     sessionHelper.writeRaw(sessionName, 'q');
                     await delay(500);
@@ -2820,27 +2753,29 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                     continue;
                 // Look for any text sitting on the prompt line
                 const lines = output.split('\n');
-                const promptLineRegex = /^[│┃║|\s]*>\s+(.+)/;
                 for (let i = lines.length - 1; i >= Math.max(0, lines.length - 25); i--) {
-                    const match = lines[i].match(promptLineRegex);
-                    if (match) {
-                        const promptContent = match[1].replace(/[│┃║|\s]+$/, '').trim();
+                    const promptContent = matchTuiPromptLine(lines[i]);
+                    if (promptContent !== null) {
+                        const trimmedContent = stripTuiLineBorders(promptContent).trim();
                         // Only act on substantial text (> 10 chars) to avoid false positives
                         // from TUI rendering artifacts or short status text
-                        if (promptContent.length > 10) {
+                        if (trimmedContent.length > 10) {
                             // Skip known Gemini CLI idle placeholder text that sits at
                             // the `> ` prompt when no user input is present. These are
                             // NOT stuck messages — they are TUI decoration.
-                            const isPlaceholder = /^Type your message/i.test(promptContent) ||
-                                /^@[\w/.]+/.test(promptContent); // e.g., "@path/to/file"
+                            const lowerContent = trimmedContent.toLowerCase();
+                            const isPlaceholder = lowerContent.startsWith('type your message') ||
+                                trimmedContent.startsWith('@'); // e.g., "@path/to/file"
                             if (isPlaceholder) {
                                 break;
                             }
-                            this.logger.warn('Background scan: text stuck at TUI prompt, pressing Enter', {
+                            this.logger.warn('Background scan: text stuck at TUI prompt, pressing Tab+Enter', {
                                 sessionName,
                                 promptContent: promptContent.slice(0, 80),
                             });
-                            // Press Enter to submit the stuck text
+                            // Tab restores Ink TUI focus before Enter
+                            await sessionHelper.sendKey(sessionName, 'Tab');
+                            await delay(200);
                             await sessionHelper.sendEnter(sessionName);
                             await delay(500);
                             // Backup Enter
@@ -2876,11 +2811,14 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                     if (now - entry.sentAt < MIN_AGE_MS)
                         continue;
                     if (bottomText.includes(entry.snippet)) {
-                        this.logger.warn('Background scan: tracked message stuck, pressing Enter', {
+                        this.logger.warn('Background scan: tracked message stuck, pressing Tab+Enter', {
                             sessionName,
                             snippet: entry.snippet.slice(0, 50),
                             ageMs: now - entry.sentAt,
                         });
+                        // Tab restores Ink TUI focus before Enter
+                        await sessionHelper.sendKey(sessionName, 'Tab');
+                        await delay(200);
                         await sessionHelper.sendEnter(sessionName);
                         await delay(500);
                         await sessionHelper.sendEnter(sessionName); // backup
@@ -2927,8 +2865,8 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
      */
     trackSentMessage(sessionName, message) {
         // Extract a search snippet: skip [CHAT:uuid] prefix, take first 80 chars
-        const prefixMatch = message.match(/^\[CHAT:[^\]]+\]\s*/);
-        const contentStart = prefixMatch ? prefixMatch[0].length : 0;
+        const { prefixLength } = extractChatPrefix(message);
+        const contentStart = prefixLength;
         // Normalize whitespace: messages may contain \n from enhanced templates.
         // Terminal bottom text is join(' '), so \n in snippet would never match.
         const snippet = message.slice(contentStart, contentStart + 80).replace(/\s+/g, ' ').trim();
@@ -2942,27 +2880,10 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
         // Ensure the background scanner is running
         this.startStuckMessageDetector();
     }
-    /**
-     * Get the runtime-specific prompt regex pattern.
-     * Avoids false positives by using narrow patterns when runtime is known.
-     *
-     * @param runtimeType - The runtime type (claude-code, gemini-cli, etc.)
-     * @returns The appropriate prompt detection regex
-     */
-    getPromptPatternForRuntime(runtimeType) {
-        if (runtimeType === RUNTIME_TYPES.CLAUDE_CODE)
-            return TERMINAL_PATTERNS.CLAUDE_CODE_PROMPT;
-        if (runtimeType === RUNTIME_TYPES.GEMINI_CLI)
-            return TERMINAL_PATTERNS.GEMINI_CLI_PROMPT;
-        if (runtimeType === RUNTIME_TYPES.CODEX_CLI)
-            return TERMINAL_PATTERNS.CODEX_CLI_PROMPT;
-        return TERMINAL_PATTERNS.PROMPT_STREAM;
-    }
     /**
      * Check if the agent appears to be at an input prompt.
-     * Looks for prompt indicators (❯, ⏵, $, ❯❯, ⏵⏵) in terminal output.
-     * Also checks for busy indicators (esc to interrupt, spinners, ⏺)
-     * to avoid false negatives when the agent is processing.
+     * Delegates to the regex-free isAgentAtPrompt() from terminal-string-ops,
+     * with additional logging and per-line prompt detection using isPromptLine().
      *
      * @param terminalOutput - The terminal output to check
      * @param runtimeType - The runtime type for pattern selection
@@ -2979,57 +2900,12 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
         // Use 5000 chars to accommodate large tool outputs that push the prompt
         // further back in the buffer (#106).
         const tailSection = terminalOutput.slice(-5000);
-        const isGemini = runtimeType === RUNTIME_TYPES.GEMINI_CLI;
-        const isClaudeCode = runtimeType === RUNTIME_TYPES.CLAUDE_CODE;
-        const isCodex = runtimeType === RUNTIME_TYPES.CODEX_CLI;
-        const streamPattern = this.getPromptPatternForRuntime(runtimeType);
         // Check for prompt FIRST. Processing indicators like "thinking" or "analyzing"
         // can appear in the agent's previous response text and persist in the terminal
         // scroll buffer, causing false negatives if checked before the prompt.
-        if (streamPattern.test(tailSection)) {
-            return true;
-        }
-        // Fallback: check last several lines for prompt indicators.
-        // The prompt may not be on the very last line due to status bars,
-        // notifications, or terminal wrapping below the prompt.
         const lines = tailSection.split('\n').filter((line) => line.trim().length > 0);
         const linesToCheck = lines.slice(-10);
-        const hasPrompt = linesToCheck.some((line) => {
-            const trimmed = line.trim();
-            // Strip TUI box-drawing borders that Gemini CLI and other TUI frameworks
-            // wrap around prompts. Covers full Unicode box-drawing range (#106).
-            const stripped = trimmed
-                .replace(/^[\u2500-\u257F|+\-═║╭╮╰╯]+\s*/, '')
-                .replace(/\s*[\u2500-\u257F|+\-═║╭╮╰╯]+$/, '');
-            // Claude Code prompts: ❯, ⏵, $ alone on a line
-            if (!isGemini && !isCodex) {
-                if (['❯', '⏵', '$'].some(ch => trimmed === ch || stripped === ch)) {
-                    return true;
-                }
-                // ❯❯ = bypass permissions prompt (idle).
-                // Matches "❯❯", "❯❯ ", and "❯❯ bypass permissions on (shift+tab to cycle)".
-                // Note: ⏵⏵ appears in the status bar but is visible both when idle AND
-                // busy, so it cannot be used as a reliable prompt indicator.
-                if (trimmed.startsWith('❯❯')) {
-                    return true;
-                }
-            }
-            // Gemini CLI prompts: > or ! followed by space
-            if (!isClaudeCode) {
-                if (isCodex) {
-                    // Codex prompt uses `›`; avoid plain `> ` to prevent false-positives
-                    // from markdown blockquotes in agent output.
-                    if (trimmed.startsWith('› ') || stripped.startsWith('› ')) {
-                        return true;
-                    }
-                }
-                else if (trimmed.startsWith('> ') || trimmed.startsWith('! ') ||
-                    stripped.startsWith('> ') || stripped.startsWith('! ')) {
-                    return true;
-                }
-            }
-            return false;
-        });
+        const hasPrompt = linesToCheck.some(line => isPromptLine(line, runtimeType));
         if (hasPrompt) {
             return true;
         }
@@ -3037,14 +2913,14 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
         // Check last 10 lines (not just 5) because tool output can push processing
         // indicators further up while the status bar stays at the bottom.
         const recentLines = linesToCheck.join('\n');
-        if (TERMINAL_PATTERNS.PROCESSING_WITH_TEXT.test(recentLines)) {
+        if (containsProcessingIndicator(recentLines)) {
             this.logger.debug('Processing indicators present near bottom of output');
             return false;
         }
         // Check for "esc to interrupt" in the status bar — this is a definitive
         // busy signal. Claude Code only shows this text while actively processing.
         // It disappears when the agent returns to idle at the prompt.
-        if (TERMINAL_PATTERNS.BUSY_STATUS_BAR.test(recentLines)) {
+        if (containsBusyStatusBar(recentLines)) {
             this.logger.debug('Busy status bar detected (esc to interrupt)');
             return false;
         }
@@ -3302,7 +3178,7 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                             return false;
                         const currentOutput = sessionHelper.capturePane(sessionName);
                         // Processing indicators (spinners) = definitive success
-                        if (TERMINAL_PATTERNS.PROCESSING.test(currentOutput)) {
+                        if (containsSpinnerOrWorkingIndicator(currentOutput)) {
                             this.logger.debug('Kickoff delivered — processing indicators detected', {
                                 sessionName, checkIndex: i,
                             });