crewly 1.3.30 → 1.4.0

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

@@ -56,6 +56,8 @@ export class AgentRegistrationService {
     // In-process Crewly Agent runtimes (sessionName → runtime instance).
     // Used for crewly-agent runtimeType agents that run without PTY sessions.
     inProcessRuntimes = new Map();
+    /** #167: Optional scheduler service for DLQ drain on agent activation. */
+    schedulerService = null;
     // 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() {
@@ -76,6 +78,14 @@ export class AgentRegistrationService {
             }
         });
     }
+    /**
+     * #167: Inject scheduler service for dead-letter queue drain on agent activation.
+     *
+     * @param scheduler - Scheduler service with drainDeadLetterQueue method
+     */
+    setSchedulerService(scheduler) {
+        this.schedulerService = scheduler;
+    }
     /**
      * Cancel a pending registration prompt for a session.
      * Called by RuntimeExitMonitorService when a runtime exit is detected.
@@ -159,8 +169,52 @@ export class AgentRegistrationService {
                 error: error instanceof Error ? error.message : String(error),
             });
         }
+        // Check in-process runtimes before defaulting to CLAUDE_CODE.
+        // crewly-agent runtimes may not have a team config entry yet.
+        if (this.inProcessRuntimes.has(sessionName)) {
+            return RUNTIME_TYPES.CREWLY_AGENT;
+        }
         return RUNTIME_TYPES.CLAUDE_CODE;
     }
+    /**
+     * Route a crewly-agent in-process response to the originating chat conversation.
+     *
+     * PTY-based runtimes emit [NOTIFY] markers that the terminal gateway parses.
+     * In-process crewly-agents have no terminal output, so this method provides
+     * the equivalent routing for their text responses.
+     *
+     * @param sessionName - Agent session that produced the response
+     * @param text - Response text from the agent
+     * @param conversationId - Chat conversation to route the response to
+     */
+    routeInProcessResponseToChat(sessionName, text, conversationId) {
+        // Lazy import to avoid circular dependencies at module load time
+        import('../../websocket/chat.gateway.js')
+            .then(({ getChatGateway }) => {
+            const chatGateway = getChatGateway();
+            if (!chatGateway) {
+                this.logger.debug('ChatGateway not available, skipping response routing', {
+                    sessionName, conversationId,
+                });
+                return;
+            }
+            return chatGateway.processNotifyMessage(sessionName, text, conversationId, { source: 'crewly-agent' });
+        })
+            .then((chatMessage) => {
+            if (chatMessage) {
+                this.logger.debug('Routed in-process agent response to chat', {
+                    sessionName, conversationId,
+                    messageId: typeof chatMessage === 'object' ? chatMessage.id : undefined,
+                });
+            }
+        })
+            .catch((err) => {
+            this.logger.warn('Failed to route in-process agent response to chat', {
+                sessionName, conversationId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        });
+    }
     /**
      * Find the project root by looking for package.json
      */
@@ -270,6 +324,19 @@ export class AgentRegistrationService {
     getInProcessRuntime(sessionName) {
         return this.inProcessRuntimes.get(sessionName);
     }
+    /**
+     * Check if an in-process Crewly Agent runtime is active and ready for a given session.
+     *
+     * Used by team status resolution to correctly report active status for
+     * crewly-agent runtimes that have no PTY session.
+     *
+     * @param sessionName - The session name to check
+     * @returns True if an in-process runtime exists and is ready
+     */
+    isInProcessRuntimeActive(sessionName) {
+        const runtime = this.inProcessRuntimes.get(sessionName);
+        return runtime !== undefined && runtime.isReady();
+    }
     /**
      * Get the check interval based on environment.
      * Uses shorter intervals in test environment for faster tests.
@@ -397,7 +464,7 @@ export class AgentRegistrationService {
         // Clear any pending slash command from detection. Claude detection already
         // exits slash mode. Gemini CLI: skip — Ctrl+C at empty prompt exits CLI,
         // Escape defocuses TUI, Ctrl+U is ignored. The prompt should be clean.
-        const prompt = await this.loadRegistrationPrompt(role, sessionName, memberId);
+        const prompt = await this.loadRegistrationPrompt(role, sessionName, memberId, runtimeType);
         const promptDelivered = await this.sendPromptRobustly(sessionName, prompt, runtimeType);
         if (!promptDelivered) {
             this.logger.warn('Failed to deliver registration prompt', { sessionName, role });
@@ -443,7 +510,7 @@ export class AgentRegistrationService {
         let promptFilePath;
         if (runtimeType === RUNTIME_TYPES.CLAUDE_CODE) {
             try {
-                const prompt = await this.loadRegistrationPrompt(role, sessionName, memberId);
+                const prompt = await this.loadRegistrationPrompt(role, sessionName, memberId, runtimeType);
                 promptFilePath = await this.writePromptFile(sessionName, prompt);
             }
             catch (promptError) {
@@ -518,16 +585,6 @@ export class AgentRegistrationService {
             role,
             runtimeType,
         });
-        // Register Gemini CLI sessions with terminal gateway so NOTIFY
-        // marker processing is skipped (Gemini TUI garbles markers).
-        if (runtimeType === RUNTIME_TYPES.GEMINI_CLI) {
-            import('../../websocket/terminal.gateway.js').then(({ getTerminalGateway }) => {
-                const tg = getTerminalGateway();
-                if (tg) {
-                    tg.registerGeminiCliSession(sessionName);
-                }
-            }).catch(() => { });
-        }
         // Background: detect and store session ID for resume-on-restart
         if (runtimeType === RUNTIME_TYPES.CLAUDE_CODE) {
             const detectPath = projectPath || process.cwd();
@@ -605,6 +662,60 @@ export class AgentRegistrationService {
             });
         }
     }
+    /**
+     * Provision the runtime-specific project config file.
+     *
+     * Each agent CLI reads a different file for project configuration:
+     * - Claude Code  → .crewly/CLAUDE.md
+     * - Gemini CLI   → GEMINI.md (project root)
+     * - Codex        → AGENTS.md (project root)
+     *
+     * Uses 'wx' flag to avoid overwriting existing files.
+     *
+     * @param projectPath - Project directory path
+     * @param runtimeType - Agent runtime type
+     */
+    async provisionRuntimeConfigFile(projectPath, runtimeType) {
+        // Map runtime type to template file and output path
+        const configMap = {
+            [RUNTIME_TYPES.CLAUDE_CODE]: {
+                template: 'agent-claude-md.md',
+                outputPath: path.join(projectPath, '.crewly', 'CLAUDE.md'),
+            },
+            [RUNTIME_TYPES.GEMINI_CLI]: {
+                template: 'agent-gemini-md.md',
+                outputPath: path.join(projectPath, 'GEMINI.md'),
+            },
+            [RUNTIME_TYPES.CODEX_CLI]: {
+                template: 'agent-agents-md.md',
+                outputPath: path.join(projectPath, 'AGENTS.md'),
+            },
+        };
+        const config = configMap[runtimeType];
+        if (!config)
+            return; // Unknown runtime — skip
+        try {
+            // Ensure parent directory exists
+            const dir = path.dirname(config.outputPath);
+            await mkdir(dir, { recursive: true });
+            const templatePath = path.join(this.projectRoot, 'config', 'templates', config.template);
+            let content = this.promptCache.get(templatePath);
+            if (!content) {
+                content = await readFile(templatePath, 'utf8');
+                this.promptCache.set(templatePath, content);
+            }
+            await writeFile(config.outputPath, content, { flag: 'wx' }).catch(() => {
+                // File already exists — no action needed
+            });
+        }
+        catch (err) {
+            this.logger.warn('Could not provision runtime config file (non-critical)', {
+                runtimeType,
+                outputPath: config.outputPath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
     /**
      * Send registration prompt asynchronously (non-blocking).
      * Uses an AbortController so the operation can be cancelled if the
@@ -618,7 +729,7 @@ export class AgentRegistrationService {
             this.logger.info('Loading registration prompt', { sessionName, role, runtimeType });
             if (controller.signal.aborted)
                 return;
-            const prompt = await this.loadRegistrationPrompt(role, sessionName, memberId);
+            const prompt = await this.loadRegistrationPrompt(role, sessionName, memberId, runtimeType);
             this.logger.info('Registration prompt loaded, sending to agent', {
                 sessionName, role, runtimeType, promptLength: prompt.length,
             });
@@ -687,7 +798,7 @@ export class AgentRegistrationService {
         let promptFilePath;
         if (runtimeType === RUNTIME_TYPES.CLAUDE_CODE) {
             try {
-                const prompt = await this.loadRegistrationPrompt(role, sessionName, memberId);
+                const prompt = await this.loadRegistrationPrompt(role, sessionName, memberId, runtimeType);
                 promptFilePath = await this.writePromptFile(sessionName, prompt);
             }
             catch (promptError) {
@@ -838,10 +949,59 @@ export class AgentRegistrationService {
         }
         return true;
     }
+    /**
+     * Register a crewly-agent member as active by updating its team config directly.
+     * In-process agents cannot run bash scripts, so this performs the registration
+     * that the register-self skill would normally do for PTY-based runtimes.
+     *
+     * @param sessionName - Agent session name
+     * @param role - Agent role
+     * @param memberId - Optional member UUID
+     * @returns True if registration succeeded
+     */
+    async registerMemberActive(sessionName, role, memberId) {
+        try {
+            const teams = await this.storageService.getTeams();
+            for (const team of teams) {
+                const member = team.members.find((m) => (m.sessionName === sessionName) ||
+                    (memberId !== undefined && m.id === memberId));
+                if (member) {
+                    member.agentStatus = 'active';
+                    member.workingStatus = 'idle';
+                    member.updatedAt = new Date().toISOString();
+                    // Pre-populate sessionName so register_self tool can find this member
+                    if (!member.sessionName && sessionName) {
+                        member.sessionName = sessionName;
+                    }
+                    await this.storageService.saveTeam(team);
+                    this.logger.info('Member registered as active', { sessionName, teamId: team.id });
+                    // #167: Drain dead-letter queue for newly active agent
+                    if (this.schedulerService) {
+                        this.schedulerService.drainDeadLetterQueue(sessionName).catch((err) => {
+                            this.logger.warn('Failed to drain DLQ on activation (non-critical)', {
+                                sessionName,
+                                error: err.message,
+                            });
+                        });
+                    }
+                    return true;
+                }
+            }
+            this.logger.warn('Could not find member to register as active', { sessionName, memberId });
+            return false;
+        }
+        catch (error) {
+            this.logger.error('Failed to register member as active', {
+                sessionName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
     /**
      * Load registration prompt from config files (with caching to prevent file I/O contention)
      */
-    async loadRegistrationPrompt(role, sessionName, memberId) {
+    async loadRegistrationPrompt(role, sessionName, memberId, runtimeType = RUNTIME_TYPES.CLAUDE_CODE) {
         try {
             // Cache key is role only - the template file is the same regardless of memberId
             const cacheKey = role;
@@ -895,30 +1055,11 @@ export class AgentRegistrationService {
             catch {
                 // Non-critical - use default project path
             }
-            // Write .crewly/CLAUDE.md in the project directory so Claude Code
+            // Write runtime-specific project config file so the agent CLI
             // recognizes Crewly as a legitimate project configuration (fixes #33)
+            // Claude Code → .crewly/CLAUDE.md, Gemini CLI → GEMINI.md, Codex → AGENTS.md
             if (role !== ORCHESTRATOR_ROLE) {
-                try {
-                    const crewlyDir = path.join(projectPath, '.crewly');
-                    const claudeMdPath = path.join(crewlyDir, 'CLAUDE.md');
-                    await mkdir(crewlyDir, { recursive: true });
-                    const templatePath = path.join(this.projectRoot, 'config', 'templates', 'agent-claude-md.md');
-                    let claudeMdContent = this.promptCache.get(templatePath);
-                    if (!claudeMdContent) {
-                        claudeMdContent = await readFile(templatePath, 'utf8');
-                        this.promptCache.set(templatePath, claudeMdContent);
-                    }
-                    await writeFile(claudeMdPath, claudeMdContent, { flag: 'wx' }).catch(() => {
-                        // File already exists — no action needed
-                    });
-                }
-                catch (claudeMdError) {
-                    this.logger.warn('Could not provision .crewly/CLAUDE.md for agent trust (non-critical)', {
-                        templatePath: path.join(this.projectRoot, 'config', 'templates', 'agent-claude-md.md'),
-                        projectPath,
-                        error: claudeMdError instanceof Error ? claudeMdError.message : String(claudeMdError),
-                    });
-                }
+                await this.provisionRuntimeConfigFile(projectPath, runtimeType);
             }
             // Replace project path placeholder (must happen after project path lookup above)
             prompt = prompt.replace(/\{\{PROJECT_PATH\}\}/g, projectPath);
@@ -941,6 +1082,7 @@ export class AgentRegistrationService {
                             name: subMember.name,
                             sessionName: subMember.sessionName || '',
                             role: subMember.role || 'developer',
+                            memberId: subMember.id || subId,
                         };
                     })
                         .filter((s) => s !== null);
@@ -992,6 +1134,19 @@ export class AgentRegistrationService {
                     error: briefingError instanceof Error ? briefingError.message : String(briefingError),
                 });
             }
+            // Inject mandatory session recovery protocol (recall + get-my-context)
+            try {
+                const recoveryBuilder = new PromptBuilderService(this.projectRoot);
+                const recoverySection = recoveryBuilder.buildSessionRecoverySection(sessionName, role, projectPath);
+                prompt += `\n\n---\n\n${recoverySection}`;
+                this.logger.info('Session recovery protocol injected into prompt', { sessionName, role });
+            }
+            catch (recoveryError) {
+                this.logger.warn('Failed to inject session recovery protocol (non-critical)', {
+                    sessionName,
+                    error: recoveryError instanceof Error ? recoveryError.message : String(recoveryError),
+                });
+            }
             // Append identity section so the agent knows its session name and project path
             prompt += `\n\n---\n\n## Your Identity\n- **Session Name:** ${sessionName}\n- **Project Path:** ${projectPath}`;
             if (memberId) {
@@ -1199,7 +1354,7 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                     });
                 }
                 // Step 3: Send system prompt with robust delivery mechanism
-                const prompt = await this.loadRegistrationPrompt(role, sessionName, memberId);
+                const prompt = await this.loadRegistrationPrompt(role, sessionName, memberId, runtimeType);
                 const promptDelivered = await this.sendPromptRobustly(sessionName, prompt, runtimeType);
                 if (!promptDelivered) {
                     this.logger.warn('Failed to deliver system prompt reliably', {
@@ -1549,23 +1704,35 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 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);
+                await crewlyRuntime.initializeInProcess(sessionName, { projectPath }, roleName);
                 // Track the in-process runtime for message routing
                 this.inProcessRuntimes.set(sessionName, crewlyRuntime);
-                // Load and deliver registration prompt as the first message
+                // Auto-register agent as active — crewly-agent cannot run bash scripts,
+                // so we register on its behalf instead of relying on the register_self tool.
                 try {
-                    const prompt = await this.loadRegistrationPrompt(role, sessionName, memberId);
-                    this.logger.info('Delivering registration prompt to Crewly Agent', {
-                        sessionName, promptLength: prompt.length,
+                    const registerResult = await this.registerMemberActive(sessionName, role, memberId);
+                    this.logger.info('Auto-registered crewly-agent as active', {
+                        sessionName, role, success: registerResult,
                     });
-                    await crewlyRuntime.handleMessage(prompt);
                 }
-                catch (promptError) {
-                    this.logger.warn('Registration prompt delivery failed (non-fatal for crewly-agent)', {
+                catch (registerErr) {
+                    this.logger.warn('Auto-registration failed (non-fatal)', {
                         sessionName,
-                        error: promptError instanceof Error ? promptError.message : String(promptError),
+                        error: registerErr instanceof Error ? registerErr.message : String(registerErr),
                     });
                 }
+                // For crewly-agent, the system prompt is already loaded during initializeInProcess().
+                // Do NOT deliver the full registration prompt as a message — that would trigger
+                // a redundant generateText call (60K chars → rate limits). Instead, send a
+                // lightweight activation message that tells the agent to start working.
+                crewlyRuntime.handleMessage(`You are now active as "${role}" (session: ${sessionName}). ` +
+                    'Your system prompt is already loaded. Begin by calling register_self, ' +
+                    'then wait for tasks.').catch(promptError => {
+                    this.logger.warn('Initial activation message 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);
@@ -1627,6 +1794,8 @@ 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}`);
+            // #187: Set project path so memory skills can auto-inject it
+            await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.CREWLY_PROJECT_PATH, cwdToUse);
             // Inject API keys from settings (with override chain) for all runtimes
             const settingsService = getSettingsService();
             const runtimeContext = { runtime: runtimeType };
@@ -1669,16 +1838,6 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             }
             // Start OAuth relogin monitoring for newly created session
             OAuthReloginMonitorService.getInstance().startMonitoring(sessionName, runtimeType);
-            // Register Gemini CLI sessions with terminal gateway so NOTIFY
-            // marker processing is skipped (Gemini TUI garbles markers).
-            if (runtimeType === RUNTIME_TYPES.GEMINI_CLI) {
-                import('../../websocket/terminal.gateway.js').then(({ getTerminalGateway }) => {
-                    const tg = getTerminalGateway();
-                    if (tg) {
-                        tg.registerGeminiCliSession(sessionName);
-                    }
-                }).catch(() => { });
-            }
             return {
                 success: true,
                 sessionName,
@@ -1831,28 +1990,61 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             }
             // ===== 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);
+            // Fire-and-forget: mirrors PTY runtimes where the write returns immediately.
+            // The LLM processes the message asynchronously in the background.
+            //
+            // IMPORTANT: Always check inProcessRuntimes map first, regardless of
+            // the runtimeType parameter. This makes delivery robust against runtime
+            // type misresolution — e.g., when storage lookup fails and defaults to
+            // claude-code for what is actually a crewly-agent session. Without this
+            // fallback, messages to crewly-agent sessions silently fail when routed
+            // through the PTY path (no PTY session exists).
+            const crewlyRuntime = this.inProcessRuntimes.get(sessionName);
+            if (crewlyRuntime || runtimeType === RUNTIME_TYPES.CREWLY_AGENT) {
                 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', {
+                // Extract conversationId from [CHAT:xxx] prefix for response routing
+                const chatPrefixMatch = message.match(/^\[CHAT:([^\]]+)\]\s*/);
+                const incomingConversationId = chatPrefixMatch?.[1];
+                // Extract Slack context from [SLACK:channelId:threadTs] marker if present (Bug 5).
+                // This allows crewly-agent to auto-fill reply_slack with the correct thread.
+                let slackMetadata;
+                const slackPrefixMatch = message.match(/\[SLACK:([^:\]]+)(?::([^\]]+))?\]/);
+                if (slackPrefixMatch) {
+                    slackMetadata = { channelId: slackPrefixMatch[1] };
+                    if (slackPrefixMatch[2])
+                        slackMetadata.threadTs = slackPrefixMatch[2];
+                }
+                // Process message asynchronously — don't block the caller
+                crewlyRuntime.handleMessage(message, slackMetadata)
+                    .then((result) => {
+                    this.logger.info('Crewly Agent finished processing message', {
                         sessionName, messageLength: message.length,
+                        responseLength: result.text?.length ?? 0,
                     });
-                    return { success: true, message: 'Message delivered to Crewly Agent' };
-                }
-                catch (agentError) {
+                    // Route response text back to the originating chat conversation.
+                    // Without this, crewly-agent responses are discarded — the agent
+                    // has no terminal output for the NOTIFY pathway used by PTY runtimes.
+                    if (result.text && incomingConversationId) {
+                        this.routeInProcessResponseToChat(sessionName, result.text, incomingConversationId);
+                    }
+                })
+                    .catch(agentError => {
                     const errMsg = agentError instanceof Error ? agentError.message : String(agentError);
                     this.logger.error('Crewly Agent message handling failed', {
                         sessionName, error: errMsg,
+                        messageLength: message.length,
+                        messagePreview: message.substring(0, 200),
                     });
-                    return { success: false, error: `Crewly Agent error: ${errMsg}` };
-                }
+                });
+                this.logger.info('Message dispatched to in-process Crewly Agent', {
+                    sessionName, messageLength: message.length,
+                });
+                return { success: true, message: 'Message delivered to Crewly Agent' };
             }
             // Get session helper once for this method
             const sessionHelper = await this.getSessionHelper();