crewly 1.3.31 → 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
      */
@@ -410,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 });
@@ -456,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) {
@@ -531,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();
@@ -618,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
@@ -631,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,
             });
@@ -700,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) {
@@ -877,6 +975,15 @@ export class AgentRegistrationService {
                     }
                     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;
                 }
             }
@@ -894,7 +1001,7 @@ export class AgentRegistrationService {
     /**
      * 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;
@@ -948,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);
@@ -994,6 +1082,7 @@ export class AgentRegistrationService {
                             name: subMember.name,
                             sessionName: subMember.sessionName || '',
                             role: subMember.role || 'developer',
+                            memberId: subMember.id || subId,
                         };
                     })
                         .filter((s) => s !== null);
@@ -1045,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) {
@@ -1252,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', {
@@ -1692,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 };
@@ -1734,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,
@@ -1898,25 +1992,53 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             // Route directly to the in-process runtime, bypassing PTY entirely.
             // Fire-and-forget: mirrors PTY runtimes where the write returns immediately.
             // The LLM processes the message asynchronously in the background.
-            if (runtimeType === RUNTIME_TYPES.CREWLY_AGENT) {
-                const crewlyRuntime = this.inProcessRuntimes.get(sessionName);
+            //
+            // 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`,
                     };
                 }
+                // 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)
-                    .then(() => {
+                crewlyRuntime.handleMessage(message, slackMetadata)
+                    .then((result) => {
                     this.logger.info('Crewly Agent finished processing message', {
                         sessionName, messageLength: message.length,
+                        responseLength: result.text?.length ?? 0,
                     });
+                    // 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),
                     });
                 });
                 this.logger.info('Message dispatched to in-process Crewly Agent', {