crewly 1.11.3 → 1.11.4

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

@@ -979,7 +979,19 @@ export class AgentRegistrationService {
                 content = await readFile(templatePath, 'utf8');
                 this.promptCache.set(templatePath, content);
             }
-            await writeFile(config.outputPath, content, { flag: 'wx' }).catch(() => {
+            // Substitute path placeholders before writing (#209). The cache holds
+            // the RAW template; resolve into a per-project copy so skill-script and
+            // project paths in the provisioned config file point at real locations
+            // (mirrors the placeholder substitution done for the registration prompt).
+            const agentSkillsPath = path.join(this.projectRoot, 'config', 'skills', 'agent');
+            const orchestratorSkillsPath = path.join(this.projectRoot, 'config', 'skills', 'orchestrator');
+            const marketplaceSkillsPath = path.join(os.homedir(), '.crewly', 'marketplace', 'skills');
+            const resolved = content
+                .replace(/\{\{PROJECT_PATH\}\}/g, projectPath)
+                .replace(/\{\{AGENT_SKILLS_PATH\}\}/g, agentSkillsPath)
+                .replace(/\{\{ORCHESTRATOR_SKILLS_PATH\}\}/g, orchestratorSkillsPath)
+                .replace(/\{\{MARKETPLACE_SKILLS_PATH\}\}/g, marketplaceSkillsPath);
+            await writeFile(config.outputPath, resolved, { flag: 'wx' }).catch(() => {
                 // File already exists — no action needed
             });
         }
@@ -3494,6 +3506,8 @@ Loop until done, blocked, or explicitly reassigned:
                             await delay(CONFIRM_INTERVAL_MS);
                             confirmAttempt++;
                             const loopOutput = sessionHelper.capturePane(sessionName);
+                            const loopBottom = loopOutput.split('\n').slice(-10).join(' ').replace(/\s+/g, ' ');
+                            const textStuck = loopBottom.includes(confirmSnippet);
                             // Spinner or working indicator → delivered
                             if (containsSpinnerOrWorkingIndicator(loopOutput)) {
                                 this.logger.info('Confirmation loop: processing detected', {
@@ -3502,7 +3516,28 @@ Loop until done, blocked, or explicitly reassigned:
                                 claudeDelivered = true;
                                 break;
                             }
-                            // Fast-response detection: output changed since send → delivered
+                            // Text still stuck → Enter was dropped, NOT delivered. Try
+                            // Tab+Enter recovery and re-check next iteration. This is
+                            // checked BEFORE the output-change shortcut below: when our
+                            // own pasted message is echoed at the prompt the output DID
+                            // change vs the pre-send baseline, but that change is the
+                            // stuck echo, not a response — treating it as "delivered"
+                            // is the false-positive that masked the orc 假死 (#686
+                            // follow-up: a hung session looked "delivered" forever).
+                            if (textStuck) {
+                                this.logger.warn('Confirmation loop: text still stuck, pressing Tab+Enter', {
+                                    sessionName, attempt, confirmAttempt,
+                                });
+                                await sessionHelper.sendKey(sessionName, 'Tab');
+                                await delay(200);
+                                await sessionHelper.sendEnter(sessionName);
+                                await delay(500);
+                                await sessionHelper.sendEnter(sessionName); // backup
+                                continue;
+                            }
+                            // Fast-response detection: output changed since send AND our
+                            // message text is NOT stuck at the prompt → a real response
+                            // landed and returned to prompt before we looked. Delivered.
                             if (loopOutput !== beforeOutput) {
                                 this.logger.info('Confirmation loop: output changed from pre-send — fast response confirmed', {
                                     sessionName, attempt, confirmAttempt,
@@ -3511,25 +3546,13 @@ Loop until done, blocked, or explicitly reassigned:
                                 break;
                             }
                             // Not at prompt and text not stuck → delivered
-                            const loopBottom = loopOutput.split('\n').slice(-10).join(' ').replace(/\s+/g, ' ');
-                            if (!this.isClaudeAtPrompt(loopOutput, runtimeType) && !loopBottom.includes(confirmSnippet)) {
+                            if (!this.isClaudeAtPrompt(loopOutput, runtimeType)) {
                                 this.logger.info('Confirmation loop: prompt gone, text cleared', {
                                     sessionName, attempt, confirmAttempt,
                                 });
                                 claudeDelivered = true;
                                 break;
                             }
-                            // Text still stuck → Tab+Enter recovery
-                            if (loopBottom.includes(confirmSnippet)) {
-                                this.logger.warn('Confirmation loop: text still stuck, pressing Tab+Enter', {
-                                    sessionName, attempt, confirmAttempt,
-                                });
-                                await sessionHelper.sendKey(sessionName, 'Tab');
-                                await delay(200);
-                                await sessionHelper.sendEnter(sessionName);
-                                await delay(500);
-                                await sessionHelper.sendEnter(sessionName); // backup
-                            }
                         }
                         if (!claudeDelivered) {
                             this.logger.error('Confirmation loop exhausted — delivery unconfirmed', {
@@ -4390,12 +4413,12 @@ Loop until done, blocked, or explicitly reassigned:
                 // Send the kickoff / file-read instruction
                 await sessionHelper.sendMessage(sessionName, messageToSend);
                 // Claude Code: rapid-check verification.
-                // Check every 1s for up to 8s whether Claude started processing.
+                // Check every 1s for up to 24s (Claude v2 first-token can be slow: MCP/skill load) whether Claude started processing.
                 // If Claude leaves the prompt at any point, the message was received.
                 // This avoids the old length-comparison approach which was unreliable
                 // (Claude's TUI redraws change output length unpredictably).
                 if (isClaudeCode) {
-                    for (let i = 0; i < 8; i++) {
+                    for (let i = 0; i < 24; i++) {
                         await delay(1000);
                         if (abortSignal?.aborted)
                             return false;
@@ -4418,9 +4441,22 @@ Loop until done, blocked, or explicitly reassigned:
                     // Claude still at prompt after 8s — message likely not received.
                     // For Claude Code with --append-system-prompt-file, don't retry
                     // (would cause duplicate). Log warning and return false.
-                    this.logger.warn('Kickoff delivery unconfirmed — Claude still at prompt after 8s (not retrying)', {
-                        sessionName, runtimeType,
-                    });
+                    // Still at prompt — the kickoff was likely typed but not submitted (PTY submit
+                    // can be dropped). A missing agent costs far more than a duplicate kickoff
+                    // (idempotent: it just re-reads the prompt file), so resend ONCE and re-poll.
+                    this.logger.warn('Kickoff unconfirmed after 24s — resending once', { sessionName, runtimeType });
+                    await sessionHelper.sendMessage(sessionName, messageToSend);
+                    for (let j = 0; j < 12; j++) {
+                        await delay(1000);
+                        if (abortSignal?.aborted)
+                            return false;
+                        const out2 = sessionHelper.capturePane(sessionName);
+                        if (containsSpinnerOrWorkingIndicator(out2) || !this.isClaudeAtPrompt(out2, RUNTIME_TYPES.CLAUDE_CODE)) {
+                            this.logger.debug('Kickoff delivered on resend', { sessionName, checkIndex: j });
+                            return true;
+                        }
+                    }
+                    this.logger.warn('Kickoff delivery unconfirmed after resend — giving up', { sessionName, runtimeType });
                     return false;
                 }
                 // Gemini CLI / other runtimes: trust the PTY delivery.