crewly 1.2.3 → 1.2.6

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

@@ -4,15 +4,17 @@ 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';
@@ -48,6 +50,12 @@ 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();
+    // In-process Crewly Agent runtimes (sessionName → runtime instance).
+    // Used for crewly-agent runtimeType agents that run without PTY sessions.
+    inProcessRuntimes = new Map();
     // Terminal patterns are now centralized in TERMINAL_PATTERNS constant
     // Keeping prompt chars as static getter for backwards compatibility within the class
     static get CLAUDE_PROMPT_INDICATORS() {
@@ -252,6 +260,16 @@ export class AgentRegistrationService {
     createRuntimeService(runtimeType) {
         return RuntimeServiceFactory.create(runtimeType, null, this.projectRoot);
     }
+    /**
+     * Get an in-process Crewly Agent runtime by session name.
+     * Used by the terminal controller for force-delivery to in-process agents.
+     *
+     * @param sessionName - Session name to look up
+     * @returns The CrewlyAgentRuntimeService if it exists, undefined otherwise
+     */
+    getInProcessRuntime(sessionName) {
+        return this.inProcessRuntimes.get(sessionName);
+    }
     /**
      * Get the check interval based on environment.
      * Uses shorter intervals in test environment for faster tests.
@@ -451,6 +469,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) {
@@ -687,6 +707,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 });
@@ -729,6 +751,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;
@@ -836,17 +860,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;
                     }
@@ -888,6 +918,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();
@@ -1440,6 +1517,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,
@@ -1453,6 +1532,40 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 await (await this.getSessionHelper()).killSession(sessionName);
                 await delay(1000); // Wait for cleanup
             }
+            // ===== In-process Crewly Agent branch =====
+            // Crewly Agent runs inside the Node.js process — no PTY session needed.
+            if (runtimeType === RUNTIME_TYPES.CREWLY_AGENT) {
+                this.logger.info('Starting in-process Crewly Agent runtime', { sessionName, role });
+                const crewlyRuntime = this.createRuntimeService(runtimeType);
+                // Determine role name for system prompt lookup
+                const roleName = role === ORCHESTRATOR_ROLE ? 'orchestrator' : role.toLowerCase().replace(/\s+/g, '-');
+                await crewlyRuntime.initializeInProcess(sessionName, undefined, roleName);
+                // Track the in-process runtime for message routing
+                this.inProcessRuntimes.set(sessionName, crewlyRuntime);
+                // Load and deliver registration prompt as the first message
+                try {
+                    const prompt = await this.loadRegistrationPrompt(role, sessionName, memberId);
+                    this.logger.info('Delivering registration prompt to Crewly Agent', {
+                        sessionName, promptLength: prompt.length,
+                    });
+                    await crewlyRuntime.handleMessage(prompt);
+                }
+                catch (promptError) {
+                    this.logger.warn('Registration prompt delivery failed (non-fatal for crewly-agent)', {
+                        sessionName,
+                        error: promptError instanceof Error ? promptError.message : String(promptError),
+                    });
+                }
+                // Start context window monitoring if applicable
+                if (role !== ORCHESTRATOR_ROLE && config.teamId && config.memberId) {
+                    ContextWindowMonitorService.getInstance().startSessionMonitoring(sessionName, config.memberId, config.teamId, role, runtimeType);
+                }
+                return {
+                    success: true,
+                    sessionName,
+                    message: 'Crewly Agent in-process runtime initialized and registered',
+                };
+            }
             // Create new session (same approach for both orchestrator and team members)
             const cwdToUse = projectPath || process.cwd();
             this.logger.info('Creating PTY session', {
@@ -1533,6 +1646,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,
@@ -1564,8 +1679,17 @@ 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);
+            // Shut down in-process Crewly Agent runtime if present
+            const inProcessRuntime = this.inProcessRuntimes.get(sessionName);
+            if (inProcessRuntime) {
+                inProcessRuntime.shutdown();
+                this.inProcessRuntimes.delete(sessionName);
+                this.logger.info('In-process Crewly Agent runtime shut down', { sessionName });
+            }
             // Get session helper once to avoid repeated async calls
             const sessionHelper = await this.getSessionHelper();
             const sessionExists = sessionHelper.sessionExists(sessionName);
@@ -1574,7 +1698,7 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 await sessionHelper.killSession(sessionName);
                 this.logger.info('Session terminated successfully', { sessionName });
             }
-            else {
+            else if (!inProcessRuntime) {
                 this.logger.info('Session already terminated or does not exist', { sessionName });
             }
             // Capture session end for memory persistence
@@ -1674,6 +1798,31 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             if (!runtimeType) {
                 runtimeType = await this.resolveSessionRuntimeType(sessionName);
             }
+            // ===== In-process Crewly Agent delivery =====
+            // Route directly to the in-process runtime, bypassing PTY entirely.
+            if (runtimeType === RUNTIME_TYPES.CREWLY_AGENT) {
+                const crewlyRuntime = this.inProcessRuntimes.get(sessionName);
+                if (!crewlyRuntime || !crewlyRuntime.isReady()) {
+                    return {
+                        success: false,
+                        error: `Crewly Agent runtime for '${sessionName}' is not initialized`,
+                    };
+                }
+                try {
+                    await crewlyRuntime.handleMessage(message);
+                    this.logger.info('Message delivered to in-process Crewly Agent', {
+                        sessionName, messageLength: message.length,
+                    });
+                    return { success: true, message: 'Message delivered to Crewly Agent' };
+                }
+                catch (agentError) {
+                    const errMsg = agentError instanceof Error ? agentError.message : String(agentError);
+                    this.logger.error('Crewly Agent message handling failed', {
+                        sessionName, error: errMsg,
+                    });
+                    return { success: false, error: `Crewly Agent error: ${errMsg}` };
+                }
+            }
             // Get session helper once for this method
             const sessionHelper = await this.getSessionHelper();
             // Check if session exists
@@ -1755,6 +1904,11 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
      * @returns true if agent is ready, false if timed out
      */
     async waitForAgentReady(sessionName, timeoutMs = EVENT_DELIVERY_CONSTANTS.AGENT_READY_TIMEOUT, runtimeType) {
+        // In-process Crewly Agent is always "ready" (no prompt to wait for)
+        const inProcessRuntime = this.inProcessRuntimes.get(sessionName);
+        if (inProcessRuntime) {
+            return inProcessRuntime.isReady();
+        }
         const sessionHelper = await this.getSessionHelper();
         // Check if session exists
         if (!sessionHelper.sessionExists(sessionName)) {
@@ -1834,256 +1988,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 = buffer.split('\n').some(line => line.trim().length > 0 && isPromptLine(line));
-                    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 = containsProcessingIndicator(buffer);
-                // Also check if prompt disappeared (Claude is working)
-                const promptStillVisible = buffer.split('\n').some(line => line.trim().length > 0 && isPromptLine(line));
-                // 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)
@@ -2114,6 +2018,17 @@ 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
@@ -2187,38 +2102,45 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                         // TUI re-render (SIGWINCH), then Tab to cycle Ink focus.
                         await sessionHelper.sendCtrlC(sessionName);
                         await delay(300);
-                        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 {
-                        // First attempt: lightweight focus nudge — Tab key cycles Ink's
-                        // focusNext() to ensure the InputPrompt is active. This prevents
-                        // the "write succeeds but TUI ignores it" failure mode without
-                        // the overhead of Ctrl+C or PTY resize.
-                        await sessionHelper.sendKey(sessionName, 'Tab');
-                        await delay(200);
+                    // 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) {
@@ -2244,19 +2166,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
@@ -2289,6 +2231,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
@@ -2299,6 +2285,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.
@@ -2365,11 +2356,17 @@ 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
@@ -2410,12 +2407,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
@@ -2735,8 +2734,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
@@ -2850,11 +2853,13 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                             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
@@ -2890,11 +2895,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