funolio-agent 0.16.4 → 0.17.2

package/dist/orchestrator.js

@@ -9,7 +9,7 @@
  * 4. Verifies results against success criteria
  * 5. Reports concise status back to the user
  *
- * The user sees ONLY their conversation with O.
+ * The user sees ONLY their conversation with the orchestrator.
  * Worker LLM conversations happen behind the scenes.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -67,7 +67,7 @@ const ORCHESTRATION_NODE_RETRY_LIMITS = {
     understand_request: 0,
     risk_gate: 0,
     choose_path: 0,
-    execute_direct: 0,
+    execute_direct: 1,
     delegate_specialist: 1,
     run_workflow: 1,
     verify_result: 2,
@@ -164,12 +164,37 @@ class OrchestratorAgent {
                 }
             }
         }
-        if (this.isOrchestratorV2Enabled() && selectedOrchestrator) {
-            const v2Response = await this.handleOrchestratorFrontDoor(prompt, conversationId, opts, selectedOrchestrator, conversationProjectId, initialProject, initialPolicy, promptAssignments, initialAssignments, initialOverview, orchestrationState);
-            if (v2Response) {
-                return v2Response;
+        // ─── Single-Call Orchestrator ─────────────────────────
+        // Ben always does the work first. If user named another bot, delegate AFTER.
+        if (selectedOrchestrator) {
+            orchestrationState.intent = 'execute_self';
+            (0, state_1.setOrchestrationPath)(orchestrationState, 'direct', 'direct');
+            this.recordOrchestrationAudit(orchestrationState, 'choose_path', 'path_selected', 'Orchestrator executes directly (single-call model).');
+            // Check for delegation targets before executing
+            const mentionedOtherBots = this.getMentionedAgents(prompt)
+                .filter((a) => a.id !== selectedOrchestrator.id);
+            // Step 1: Ben does the work — if delegating, tell Ben to skip the delegate's role
+            let executionPrompt = prompt;
+            if (mentionedOtherBots.length > 0) {
+                const botNames = mentionedOtherBots.map((b) => b.name).join(', ');
+                const role = this.inferDelegationRole(prompt);
+                executionPrompt = `${prompt}\n\n[System: ${botNames} will handle ${role} after you finish. Do YOUR work only — do not perform ${role} yourself. Complete your task and return your deliverable.]`;
+            }
+            const directResult = await this.executeOrchestratorOwnedWork(executionPrompt, conversationId, selectedOrchestrator, initialAssignments, initialProject, opts, orchestrationState);
+            if (mentionedOtherBots.length > 0 && directResult.ok) {
+                const delegateBot = mentionedOtherBots[0];
+                this.recordOrchestrationAudit(orchestrationState, 'delegate_specialist', 'delegated', `Delegating to ${delegateBot.name} after orchestrator completed work.`, { delegateBot: delegateBot.name });
+                try {
+                    const delegateResponse = await this.executeDelegation(directResult.response, prompt, delegateBot, conversationId, initialProject, opts, orchestrationState);
+                    return delegateResponse;
+                }
+                catch (err) {
+                    // If delegation fails, still return Ben's result
+                    this.recordOrchestrationAudit(orchestrationState, 'delegate_specialist', 'blocked', `Delegation to ${delegateBot.name} failed: ${err?.message || err}. Returning orchestrator result.`);
+                    return directResult.response;
+                }
             }
-            orchestrationState.fallbackUsed = true;
+            return directResult.response;
         }
         this.reportHiddenRoleProgress(opts, 'intent_classifier', 'Classifying request');
         (0, state_1.addHelperRoleUsage)(orchestrationState, 'intent_classifier');
@@ -943,15 +968,9 @@ class OrchestratorAgent {
         return lines.join('\n\n');
     }
     getAgentReferenceTerms(agent) {
-        const terms = [agent.name];
-        const normalized = agent.name.trim().toLowerCase();
-        if (normalized === 'brain')
-            terms.push('gpt');
-        if (normalized === 'ben')
-            terms.push('claude');
-        if (normalized === 'john')
-            terms.push('codex');
-        return Array.from(new Set(terms.map((term) => term.trim()).filter(Boolean)));
+        // Only use exact bot names — no aliases.
+        // Aliases like "claude" → "Ben" cause false matches on every prompt.
+        return [agent.name.trim()].filter(Boolean);
     }
     /**
      * Interpret user intent using the clerk.
@@ -1420,13 +1439,6 @@ class OrchestratorAgent {
             .replace(/\n?STATUS:\s*(PASS|FAIL|COMPLETE|BLOCKED|UNKNOWN)\s*$/i, '')
             .trim() || rawText.trim();
     }
-    isOrchestratorV2Enabled() {
-        const envValue = String(process.env.ORCH_V2_ENABLED || '').trim().toLowerCase();
-        if (envValue === '1' || envValue === 'true' || envValue === 'yes' || envValue === 'on') {
-            return true;
-        }
-        return data.getSetting('orchestrator_v2_enabled') === 'true';
-    }
     resolveSelectedOrchestratorBot(conversation) {
         const conversationBotId = conversation?.agent_id;
         if (conversationBotId) {
@@ -1526,22 +1538,10 @@ class OrchestratorAgent {
             explicitWorkflowRequested: normalizedDecision.explicitWorkflowRequested,
             corrected: normalizedDecision.corrected,
         });
+        // Clarify should never reach here (parser + policy convert to execute_self),
+        // but if it somehow does, treat it as execute_self — just do the work.
         if (decision.mode === 'clarify') {
-            (0, state_1.setOrchestrationPath)(state, 'clarify');
-            this.recordOrchestrationAudit(state, 'require_confirmation', 'clarification_requested', decision.reason || 'Orchestrator requested clarification.', { clarificationQuestions: decision.clarification_questions || [] });
-            return this.formatClarificationResponse({
-                primaryMode: 'DIRECT_CONVERSATION',
-                secondaryModes: [],
-                executionOrder: ['DIRECT_CONVERSATION'],
-                userFacingMode: 'DIRECT_RESPONSE',
-                targetScope: 'SELF',
-                confidence: 'HIGH',
-                intent: 'question',
-                isMultiStep: false,
-                reasoning: decision.reason,
-                needsClarification: true,
-                clarificationQuestions: decision.clarification_questions || ['Can you clarify what you want me to do?'],
-            }, overview);
+            decision.mode = 'execute_self';
         }
         if (decision.mode === 'respond') {
             const response = decision.response?.trim() || this.handleDirectConversation(prompt, overview, roleAssignments, state);
@@ -1550,39 +1550,10 @@ class OrchestratorAgent {
             return response;
         }
         if (decision.mode === 'execute_self') {
-            const directIntent = {
-                primaryMode: 'DIRECT_CONVERSATION',
-                secondaryModes: [],
-                executionOrder: ['DIRECT_CONVERSATION'],
-                userFacingMode: 'DIRECT_RESPONSE',
-                targetScope: 'SELF',
-                confidence: 'HIGH',
-                intent: this.inferFrontDoorIntent(normalizedDecision.taskType, decision),
-                isMultiStep: false,
-                reasoning: decision.reason,
-            };
-            const frontDoorEffectivePolicy = this.buildFrontDoorEffectivePolicy(policy, orchestratorBot, roleAssignments, normalizedDecision.taskType);
-            const validation = this.validateIntentExecution(prompt, directIntent, frontDoorEffectivePolicy);
-            if (!validation.ok) {
-                return validation.clarificationQuestions?.length
-                    ? this.formatClarificationResponse({ ...directIntent, clarificationQuestions: validation.clarificationQuestions }, overview)
-                    : null;
-            }
-            const guardrailQuestions = this.buildDeterministicGuardrailQuestions(validation.executionSpec, roleAssignments, directIntent);
-            if (guardrailQuestions.length > 0) {
-                return this.formatClarificationResponse({ ...directIntent, clarificationQuestions: guardrailQuestions }, overview);
-            }
-            this.applyExecutionSpecToState(state, validation.executionSpec);
-            if (validation.executionSpec.requiresConfirmation) {
-                return this.createConfirmationCheckpoint(prompt, conversationId, directIntent, validation.executionSpec, projectId, roleAssignments, state);
-            }
+            // No guardrails, no confirmation checkpoints, no validation blocking.
+            // Ben just does the work — like Claude CLI.
+            (0, state_1.setOrchestrationPath)(state, 'direct', 'direct');
             const directResult = await this.executeOrchestratorOwnedWork(prompt, conversationId, orchestratorBot, roleAssignments, project, opts, state);
-            if (directResult.ok && directIntent.intent === 'build' && state.requestedArtifactTargets.length > 0) {
-                const artifactValidation = this.validateRequestedArtifactTargets(state, project);
-                if (!artifactValidation.ok) {
-                    return `${orchestratorBot.name} encountered an issue: ${artifactValidation.message}`;
-                }
-            }
             return directResult.response;
         }
         if (decision.mode === 'delegate') {
@@ -1736,11 +1707,11 @@ class OrchestratorAgent {
         this.reportHiddenRoleProgress(opts, 'orchestrator', `${orchestratorBot.name} is working on the request`);
         const result = await this.runNodeWithRetry('execute_direct', state, async () => this.workflowEngine.execute(prompt, conversationId, orchestratorBot.id, {
             disableDecomposition: true,
-            isOrchestrated: true,
+            isOrchestrated: false,
             projectId: project?.id || state.projectId || null,
             workspacePath: project?.folder?.trim() || undefined,
-            persistConversationMessages: false,
-            workerMode: true,
+            persistConversationMessages: true,
+            workerMode: false,
             onWorkerChunk: opts.onWorkerChunk,
             onProgress: (progress) => {
                 if (progress.event === 'step-started') {
@@ -1790,6 +1761,59 @@ class OrchestratorAgent {
         this.recordOrchestrationAudit(state, 'finalize_response', 'completed', 'Completed orchestrator-owned execution.');
         return { ok: true, response: reviewed, rawResult: result };
     }
+    /**
+     * Delegate Ben's completed work to another bot (e.g., John for QA, Brain for research).
+     * Called AFTER executeOrchestratorOwnedWork completes.
+     */
+    async executeDelegation(benResult, originalPrompt, delegateBot, conversationId, project, opts, state) {
+        const role = this.inferDelegationRole(originalPrompt);
+        const roleLabel = role === 'qa' ? 'QA / review' : role === 'research' ? 'research / analysis' : 'review';
+        const delegationPrompt = [
+            `The user's original request:\n${originalPrompt}`,
+            '',
+            `The orchestrator (Ben) completed the following work:\n${benResult.length > 8000 ? benResult.slice(0, 8000) + '\n...(truncated)' : benResult}`,
+            '',
+            `Your task: Perform ${roleLabel} on the completed work above.`,
+            role === 'qa'
+                ? 'Review the work against the original request. Report what passes and what fails. Be specific about any issues found.'
+                : role === 'research'
+                    ? 'Analyze the work and provide insights, suggestions, or additional research as requested.'
+                    : 'Review and provide your feedback on the completed work.',
+        ].join('\n');
+        this.reportHiddenRoleProgress(opts, 'orchestrator', `Sending work to ${delegateBot.name} for ${roleLabel}`);
+        (0, state_1.addHelperRoleUsage)(state, 'dispatch_controller');
+        (0, state_1.addDelegateTarget)(state, delegateBot.name);
+        const result = await this.runNodeWithRetry('delegate_specialist', state, async () => this.workflowEngine.execute(delegationPrompt, conversationId, delegateBot.id, {
+            disableDecomposition: true,
+            isOrchestrated: false,
+            workerMode: false,
+            projectId: project?.id || state.projectId || null,
+            workspacePath: project?.folder?.trim() || undefined,
+            persistConversationMessages: true,
+            onWorkerChunk: opts.onWorkerChunk,
+            onProgress: (progress) => {
+                if (progress.event === 'step-started') {
+                    this.reportHiddenRoleProgress(opts, 'orchestrator', `${delegateBot.name} is reviewing the work`);
+                }
+                else if (progress.event === 'step-completed') {
+                    this.reportHiddenRoleProgress(opts, 'orchestrator', `${delegateBot.name} completed review`);
+                }
+            },
+        }));
+        const delegateResponse = this.stripWorkerProtocol(result.mergedResult);
+        this.reportHiddenRoleProgress(opts, 'orchestrator', `${delegateBot.name} completed ${roleLabel}`);
+        this.recordOrchestrationAudit(state, 'finalize_response', 'completed', `Delegation to ${delegateBot.name} completed.`);
+        // Return combined response
+        return `${benResult}\n\n---\n\n**${delegateBot.name} (${roleLabel}):**\n\n${delegateResponse}`;
+    }
+    inferDelegationRole(prompt) {
+        const lower = prompt.toLowerCase();
+        if (/\b(qa|test|review|check|verify|audit|pass\/fail)\b/.test(lower))
+            return 'qa';
+        if (/\b(research|brainstorm|analyze|investigate|evaluate)\b/.test(lower))
+            return 'research';
+        return 'discuss';
+    }
     inferRequestedWorkflowRoles(prompt, roleAssignments) {
         const normalized = String(prompt || '').toLowerCase();
         const explicitResearch = /\b(brain|gpt|research(?:es|ed|ing)?|investigat(?:e|es|ed|ing)|analy[sz](?:e|es|ed|ing)|analysis|sound idea|review the idea|pressure[- ]?test|brainstorm(?:ed|ing)?)\b/.test(normalized)
@@ -2421,6 +2445,9 @@ class OrchestratorAgent {
             if (state && workflowTemplate) {
                 state.preferredWorkflowUsed = true;
             }
+            // TODO: planWorkflow uses the cheap clerk (GPT-4o-mini). Per architecture doc,
+            // workflow planning should be done by the orchestrator LLM, not the clerk.
+            // The clerk should only do summaries, extraction, and compression.
             const plannedSteps = !workflowTemplate
                 ? await this.clerk.planWorkflow({
                     prompt,