funolio-agent 1.0.47 → 1.0.49

package/dist/orchestrator.js

@@ -89,6 +89,9 @@ class OrchestratorAgent {
         this.clerk = clerk;
         this.workflowEngine = workflowEngine;
     }
+    isLocalDesktopRuntime() {
+        return this.workflowEngine.getRuntimeMode() === 'local_desktop';
+    }
     getLastResponseMeta() {
         return this.lastResponseMeta;
     }
@@ -112,6 +115,54 @@ class OrchestratorAgent {
             }
         }
     }
+    getAgentRoutingReferences(agent) {
+        const refs = new Set();
+        const add = (value) => {
+            const trimmed = String(value || '').trim();
+            if (trimmed)
+                refs.add(trimmed);
+        };
+        add(agent.name);
+        const modelProviderText = `${agent.provider || ''} ${agent.model || ''}`.toLowerCase();
+        if (modelProviderText.includes('claude'))
+            add('Claude');
+        if (modelProviderText.includes('codex'))
+            add('Codex');
+        if (/\bgpt\b|gpt-/.test(modelProviderText))
+            add('GPT');
+        return Array.from(refs);
+    }
+    describeAgentResponsibilities(agent) {
+        const candidates = [
+            agent.purpose_md,
+            agent.identity_summary,
+            agent.skills_md,
+            agent.role_label,
+            agent.role_class,
+        ].map((value) => String(value || '').replace(/\s+/g, ' ').trim()).filter(Boolean);
+        for (const candidate of candidates) {
+            const cleaned = candidate
+                .replace(/^#+\s*/g, '')
+                .replace(/^\-\s*/g, '')
+                .replace(/^you are\s+/i, '')
+                .replace(/^role:\s*/i, '')
+                .trim();
+            if (cleaned) {
+                return cleaned.length > 180 ? `${cleaned.slice(0, 177).trim()}...` : cleaned;
+            }
+        }
+        const normalizedRole = String(agent.role_class || agent.role_label || '').trim().toLowerCase();
+        if (normalizedRole === 'code' || normalizedRole === 'coding') {
+            return 'implementation, code changes, fixes, and app changes';
+        }
+        if (normalizedRole === 'qa') {
+            return 'QA, review, verification, and testing';
+        }
+        if (normalizedRole === 'research') {
+            return 'brainstorming, research, planning, and evaluation';
+        }
+        return 'general assistance';
+    }
     /**
      * Main entry point. User sends a message, O handles everything.
      * Returns O's response to display to the user.
@@ -1498,11 +1549,15 @@ class OrchestratorAgent {
             .map((agent) => ({
             name: agent.name,
             roleLabel: agent.role_label || agent.role_class || 'general',
+            references: this.getAgentRoutingReferences(agent),
+            responsibilities: this.describeAgentResponsibilities(agent),
         }));
         const signalSpecialists = allProfiles
             .map((agent) => ({
             name: agent.name,
             roleLabel: agent.role_label || agent.role_class || 'general',
+            references: this.getAgentRoutingReferences(agent),
+            responsibilities: this.describeAgentResponsibilities(agent),
         }));
         // Build workflow names list from enabled templates
         const workflowNames = [];
@@ -1521,16 +1576,17 @@ class OrchestratorAgent {
             roleAssignments,
         });
         const normalizeName = (value) => String(value || '').trim().toLowerCase();
-        const fastDecision = this.buildFastFrontDoorDecision(prompt, frontDoorSignals, promptAssignments, roleAssignments);
-        if (fastDecision) {
-            this.recordOrchestrationAudit(state, 'understand_request', 'path_selected', fastDecision.reason, {
-                decisionMode: fastDecision.mode,
-                delegateTarget: fastDecision.delegate_target || null,
-                delegateRole: fastDecision.delegate_role || null,
-                fastPath: true,
+        const systemSuggestion = this.buildFrontDoorSystemSuggestion(prompt, frontDoorSignals, promptAssignments, roleAssignments);
+        if (systemSuggestion) {
+            this.recordOrchestrationAudit(state, 'understand_request', 'path_selected', systemSuggestion.reason, {
+                decisionMode: systemSuggestion.mode,
+                delegateTarget: systemSuggestion.delegateTarget || null,
+                delegateRole: systemSuggestion.delegateRole || null,
+                suggestionConfidence: systemSuggestion.confidence || null,
+                fastPath: false,
             });
-            return this.handleFrontDoorDecision(fastDecision, prompt, conversationId, opts, orchestratorBot, projectId, project, policy, promptAssignments, roleAssignments, overview, state, signalSpecialists, workflowNames);
         }
+        const useSinglePassOrchestrator = this.isLocalDesktopRuntime();
         const operatingPrompt = (0, orchestrator_operating_prompt_1.buildOrchestratorOperatingPrompt)({
             orchestratorName: orchestratorBot.name,
             primaryRole: orchestratorBot.role_label || orchestratorBot.role_class || null,
@@ -1545,6 +1601,7 @@ class OrchestratorAgent {
                 explicitWorkflowKeyword: frontDoorSignals.explicitWorkflowKeyword,
                 explicitDelegationKeyword: frontDoorSignals.explicitDelegationKeyword,
             },
+            systemSuggestion,
             projectName: overview?.project.name || project?.name || null,
             projectFolder: project?.folder || overview?.project.folder || null,
             effectivePolicy: (0, policy_prompt_1.buildEffectivePolicyPromptSection)(policy, {
@@ -1553,6 +1610,7 @@ class OrchestratorAgent {
             }),
             recentSummary: recentSummaryText,
             lastFiveTurns: recentTurnsText,
+            decisionOnly: !useSinglePassOrchestrator,
         });
         const decisionPrompt = [
             'This is a routing decision only. Do not perform the task.',
@@ -1569,15 +1627,44 @@ class OrchestratorAgent {
             this.reportHiddenRoleProgress(opts, 'orchestrator', 'Still understanding the request');
         }, 8_000);
         try {
-            const result = await this.runNodeWithRetry('understand_request', state, async () => this.workflowEngine.execute(decisionPrompt, null, orchestratorBot.id, {
-                disableDecomposition: true,
-                disableTools: true,
-                disallowCliRuntime: true,
-                projectId: projectId || null,
-                workspacePath: project?.folder?.trim() || undefined,
-                systemPromptOverride: operatingPrompt,
-            }));
-            decision = (0, orchestrator_operating_prompt_1.parseOrchestratorFrontDoorDecision)(result.mergedResult);
+            if (useSinglePassOrchestrator) {
+                const result = await this.runNodeWithRetry('understand_request', state, async () => this.workflowEngine.execute(prompt, conversationId, orchestratorBot.id, {
+                    disableDecomposition: true,
+                    isOrchestrated: false,
+                    projectId: projectId || null,
+                    workspacePath: project?.folder?.trim() || undefined,
+                    persistConversationMessages: false,
+                    workerMode: false,
+                    systemPromptOverride: operatingPrompt,
+                    onWorkerChunk: opts.onWorkerChunk,
+                    onProgress: (progress) => {
+                        if (progress.event === 'step-failed') {
+                            this.reportHiddenRoleProgress(opts, 'orchestrator', `${progress.step.agentName} hit an issue while working on the request`);
+                        }
+                    },
+                }));
+                const parsed = (0, orchestrator_operating_prompt_1.parseOrchestratorFrontDoorDecision)(result.mergedResult);
+                if (parsed && ['delegate', 'workflow', 'clarify', 'respond'].includes(parsed.mode)) {
+                    decision = parsed;
+                }
+                else if (parsed?.mode === 'execute_self') {
+                    decision = parsed;
+                }
+                else {
+                    clearInterval(understandingHeartbeat);
+                    return (await this.finalizeOwnedExecutionResult(result, prompt, conversationId, orchestratorBot, roleAssignments, project, opts, state)).response;
+                }
+            }
+            else {
+                const result = await this.runNodeWithRetry('understand_request', state, async () => this.workflowEngine.execute(decisionPrompt, null, orchestratorBot.id, {
+                    disableDecomposition: true,
+                    disableTools: true,
+                    projectId: projectId || null,
+                    workspacePath: project?.folder?.trim() || undefined,
+                    systemPromptOverride: operatingPrompt,
+                }));
+                decision = (0, orchestrator_operating_prompt_1.parseOrchestratorFrontDoorDecision)(result.mergedResult);
+            }
         }
         catch {
             decision = null;
@@ -1585,9 +1672,19 @@ class OrchestratorAgent {
         finally {
             clearInterval(understandingHeartbeat);
         }
+        if (!decision && systemSuggestion) {
+            decision = {
+                mode: systemSuggestion.mode,
+                reason: systemSuggestion.reason,
+                delegate_target: systemSuggestion.delegateTarget || undefined,
+                delegate_role: systemSuggestion.delegateRole || undefined,
+                delegate_request: systemSuggestion.mode === 'delegate' ? prompt : undefined,
+                workflow_request: systemSuggestion.mode === 'workflow' ? prompt : undefined,
+            };
+        }
         if (!decision) {
-            const fallbackTaskType = (0, front_door_policy_1.inferFrontDoorTaskType)(prompt);
             const promptAssignedRoles = [promptAssignments.coding, promptAssignments.qa, promptAssignments.research].filter(Boolean).length;
+            const fallbackTaskType = (0, front_door_policy_1.inferFrontDoorTaskType)(prompt);
             if (frontDoorSignals.preferredMode === 'workflow') {
                 decision = {
                     mode: 'workflow',
@@ -1617,82 +1714,42 @@ class OrchestratorAgent {
                     delegate_request: prompt,
                 };
             }
-            else if (fallbackTaskType === 'coding' && roleAssignments.coding) {
-                decision = {
-                    mode: 'delegate',
-                    reason: 'Code-based front door recovered routing for a coding task owned by the coding worker.',
-                    delegate_target: roleAssignments.coding,
-                    delegate_role: 'coding',
-                    delegate_request: prompt,
-                };
-            }
-            else if (fallbackTaskType === 'qa' && roleAssignments.qa) {
-                decision = {
-                    mode: 'delegate',
-                    reason: 'Code-based front door recovered routing for a QA task owned by the QA worker.',
-                    delegate_target: roleAssignments.qa,
-                    delegate_role: 'qa',
-                    delegate_request: prompt,
-                };
-            }
-            else if (fallbackTaskType === 'research' && roleAssignments.research) {
+            else {
                 decision = {
-                    mode: 'delegate',
-                    reason: 'Code-based front door recovered routing for a research task owned by the research worker.',
-                    delegate_target: roleAssignments.research,
-                    delegate_role: 'research',
-                    delegate_request: prompt,
+                    mode: 'execute_self',
+                    reason: 'No strong routing evidence was found. Handle the request directly.',
                 };
             }
         }
         return this.handleFrontDoorDecision(decision, prompt, conversationId, opts, orchestratorBot, projectId, project, policy, promptAssignments, roleAssignments, overview, state, signalSpecialists, workflowNames);
     }
-    buildFastFrontDoorDecision(prompt, frontDoorSignals, promptAssignments, roleAssignments) {
+    buildFrontDoorSystemSuggestion(prompt, frontDoorSignals, promptAssignments, roleAssignments) {
         const normalizeName = (value) => String(value || '').trim().toLowerCase();
         const taskType = (0, front_door_policy_1.inferFrontDoorTaskType)(prompt);
-        const normalizedPrompt = prompt.trim().toLowerCase();
-        if (taskType === 'conversation') {
-            if (/\b(hello|hi|hey|are you there|good morning|good afternoon|good evening)\b/i.test(normalizedPrompt)) {
-                return {
-                    mode: 'respond',
-                    reason: 'Code-first front door handled a simple greeting conversationally.',
-                    response: "I'm here and ready. Tell me what you want me to coordinate.",
-                };
-            }
-            if (/\b(thanks|thank you|great work|good work|nice work|well done|awesome|perfect|just complementing you|just complimenting you|complimenting you|nothing else)\b/i.test(normalizedPrompt)) {
-                return {
-                    mode: 'respond',
-                    reason: 'Code-first front door handled a simple conversational compliment without invoking workflow routing.',
-                    response: "Thanks. I'm here when you need me.",
-                };
-            }
+        if (taskType === 'policy' || taskType === 'status' || taskType === 'conversation')
+            return null;
+        if (/\bwhat do you think|can we|should we|do you agree|need to discuss|discuss more|is this a good idea|thoughts\??|recommend(?:ation)?\b/i.test(prompt)) {
+            return null;
         }
+        if ((0, front_door_policy_1.isContextualWorkerReferencePrompt)(prompt))
+            return null;
         const promptAssignedRoles = [promptAssignments.coding, promptAssignments.qa, promptAssignments.research].filter(Boolean).length;
-        const multiWorkerRequested = taskType === 'mixed'
+        const multiWorkerRequested = frontDoorSignals.matchedWorkflowNames.length > 0
+            || frontDoorSignals.preferredMode === 'workflow'
+            || taskType === 'mixed'
             || promptAssignedRoles >= 2
             || frontDoorSignals.matchedBots.length >= 2
-            || frontDoorSignals.matchedRoles.length >= 2
-            || frontDoorSignals.matchedWorkflowNames.length > 0
-            || frontDoorSignals.preferredMode === 'workflow';
+            || frontDoorSignals.matchedRoles.length >= 2;
         if (multiWorkerRequested) {
             return {
                 mode: 'workflow',
                 reason: frontDoorSignals.matchedWorkflowNames.length > 0
-                    ? 'Code-first front door fast-pathed a named or selected workflow request without waiting on orchestrator routing.'
-                    : 'Code-first front door fast-pathed an obvious staged multi-worker request without waiting on orchestrator routing.',
-                workflow_request: prompt,
+                    ? 'Code-based front door suggests workflow because the prompt names an available workflow.'
+                    : 'Code-based front door suggests workflow because the prompt clearly points to multi-worker or staged work.',
+                confidence: frontDoorSignals.matchedWorkflowNames.length > 0 || frontDoorSignals.explicitOrchestrationRequested ? 'high' : 'medium',
             };
         }
-        if (taskType === 'policy' || taskType === 'status' || taskType === 'conversation')
-            return null;
-        if (/\bwhat do you think|can we|should we|do you agree|need to discuss|discuss more|is this a good idea|thoughts\??|recommend(?:ation)?\b/i.test(prompt)) {
-            return null;
-        }
-        const preferredTarget = frontDoorSignals.preferredTarget
-            || (taskType === 'coding' ? roleAssignments.coding
-                : taskType === 'qa' ? roleAssignments.qa
-                    : taskType === 'research' ? roleAssignments.research
-                        : null);
+        const preferredTarget = frontDoorSignals.preferredTarget;
         if (!preferredTarget)
             return null;
         const delegateRole = frontDoorSignals.matchedRoles[0]
@@ -1702,11 +1759,11 @@ class OrchestratorAgent {
         return {
             mode: 'delegate',
             reason: frontDoorSignals.explicitOrchestrationRequested
-                ? 'Code-first front door fast-pathed an explicit single-worker request without waiting on orchestrator routing.'
-                : 'Code-first front door fast-pathed a single-worker task to the assigned specialist.',
-            delegate_target: preferredTarget,
-            delegate_role: delegateRole,
-            delegate_request: prompt,
+                ? 'Code-based front door suggests delegate because the prompt explicitly requests worker assignment or TODO handling.'
+                : 'Code-based front door suggests delegate because the prompt clearly assigns one available worker or role.',
+            confidence: frontDoorSignals.explicitOrchestrationRequested ? 'high' : 'medium',
+            delegateTarget: preferredTarget,
+            delegateRole,
         };
     }
     async handleFrontDoorDecision(decision, prompt, conversationId, opts, orchestratorBot, projectId, project, policy, promptAssignments, roleAssignments, overview, state, signalSpecialists, workflowNames) {
@@ -2402,6 +2459,9 @@ class OrchestratorAgent {
                 }
             },
         }));
+        return this.finalizeOwnedExecutionResult(result, prompt, conversationId, orchestratorBot, roleAssignments, project, opts, state, options);
+    }
+    async finalizeOwnedExecutionResult(result, prompt, conversationId, orchestratorBot, roleAssignments, project, opts, state, options) {
         const response = this.stripWorkerProtocol(result.mergedResult);
         const footer = (0, status_parser_1.parseStructuredFooter)(result.mergedResult);
         const failureStep = result.steps.find((step) => step.status === 'failed');