funolio-agent 0.17.8 → 1.0.3

package/dist/orchestrator.js

@@ -51,6 +51,11 @@ const status_parser_1 = require("./orchestration/status-parser");
 const front_door_policy_1 = require("./orchestration/front-door-policy");
 const deterministic_path_1 = require("./orchestration/deterministic-path");
 const orchestrator_operating_prompt_1 = require("./orchestration/orchestrator-operating-prompt");
+const policy_prompt_1 = require("./orchestration/policy-prompt");
+const orchestrator_blocked_prompt_1 = require("./orchestration/orchestrator-blocked-prompt");
+const orchestrator_final_response_prompt_1 = require("./orchestration/orchestrator-final-response-prompt");
+const worker_operating_prompt_1 = require("./orchestration/worker-operating-prompt");
+const policy_detection_1 = require("./policy-detection");
 const execution_contract_1 = require("./execution-contract");
 const state_1 = require("./orchestration/state");
 const orchestrator_profile_1 = require("./orchestrator-profile");
@@ -160,41 +165,37 @@ class OrchestratorAgent {
                 const validation = this.validateIntentExecution(prompt, workflowIntent, initialPolicy);
                 if (validation.ok) {
                     this.applyExecutionSpecToState(orchestrationState, validation.executionSpec);
-                    return this.handleOrchestratedRequest(prompt, conversationId, workflowIntent, validation.executionSpec, opts, initialAssignments, initialProject, orchestrationState, selectedOrchestrator);
+                    return await this.queueWorkflowTodoPlan(prompt, conversationId, workflowIntent, validation.executionSpec, opts, initialAssignments, initialProject, orchestrationState, selectedOrchestrator, template);
                 }
             }
         }
-        // ─── 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;
-                }
+        const namedWorkflowTemplate = selectedOrchestrator
+            ? this.resolveWorkflowTemplateByPrompt(conversationProjectId, prompt)
+            : undefined;
+        if (namedWorkflowTemplate && selectedOrchestrator) {
+            orchestrationState.intent = 'workflow';
+            this.recordOrchestrationAudit(orchestrationState, 'choose_path', 'path_selected', `User explicitly named workflow template: ${namedWorkflowTemplate.name}`, { workflowTemplateId: namedWorkflowTemplate.id });
+            const workflowIntent = {
+                primaryMode: 'WORKFLOW_MODE',
+                secondaryModes: [],
+                executionOrder: ['WORKFLOW_MODE'],
+                userFacingMode: 'FULL_WORKFLOW',
+                targetScope: 'MULTI_WORKER',
+                confidence: 'HIGH',
+                intent: 'build',
+                isMultiStep: true,
+                reasoning: `User named workflow template: ${namedWorkflowTemplate.name}`,
+            };
+            const validation = this.validateIntentExecution(prompt, workflowIntent, initialPolicy);
+            if (validation.ok) {
+                this.applyExecutionSpecToState(orchestrationState, validation.executionSpec);
+                return await this.queueWorkflowTodoPlan(prompt, conversationId, workflowIntent, validation.executionSpec, opts, initialAssignments, initialProject, orchestrationState, selectedOrchestrator, namedWorkflowTemplate);
             }
-            return directResult.response;
+        }
+        if (selectedOrchestrator) {
+            const frontDoorResult = await this.handleOrchestratorFrontDoor(prompt, conversationId, opts, selectedOrchestrator, conversationProjectId, initialProject, initialPolicy, promptAssignments, initialAssignments, initialOverview, orchestrationState);
+            if (frontDoorResult !== null)
+                return frontDoorResult;
         }
         this.reportHiddenRoleProgress(opts, 'intent_classifier', 'Classifying request');
         (0, state_1.addHelperRoleUsage)(orchestrationState, 'intent_classifier');
@@ -1458,7 +1459,13 @@ class OrchestratorAgent {
             ? `${contextWindow.carriedForward ? '(carried forward from the previous conversation in this topic)\n' : ''}${contextWindow.summary.summary_text.trim()}`
             : '(none)';
         // Build specialists list from non-orchestrator agent profiles
-        const specialists = (0, orchestrator_profile_1.filterOutOrchestratorProfiles)(data.listAgentProfiles())
+        const allProfiles = data.listAgentProfiles();
+        const specialists = (0, orchestrator_profile_1.filterOutOrchestratorProfiles)(allProfiles)
+            .map((agent) => ({
+            name: agent.name,
+            roleLabel: agent.role_label || agent.role_class || 'general',
+        }));
+        const signalSpecialists = allProfiles
             .map((agent) => ({
             name: agent.name,
             roleLabel: agent.role_label || agent.role_class || 'general',
@@ -1473,17 +1480,44 @@ class OrchestratorAgent {
             }
             catch { /* table may not exist yet */ }
         }
+        const frontDoorSignals = (0, front_door_policy_1.extractFrontDoorSignals)({
+            prompt,
+            specialists: signalSpecialists,
+            workflowNames,
+            roleAssignments,
+        });
+        const normalizeName = (value) => String(value || '').trim().toLowerCase();
         const operatingPrompt = (0, orchestrator_operating_prompt_1.buildOrchestratorOperatingPrompt)({
             orchestratorName: orchestratorBot.name,
             primaryRole: orchestratorBot.role_label || orchestratorBot.role_class || null,
             specialists,
             workflowNames,
+            entryMode: frontDoorSignals.explicitOrchestrationRequested ? 'orchestration_bias' : 'normal',
+            signalSummary: {
+                matchedBots: frontDoorSignals.matchedBots,
+                matchedRoles: frontDoorSignals.matchedRoles,
+                matchedWorkflows: frontDoorSignals.matchedWorkflowNames,
+                explicitTodoKeyword: frontDoorSignals.explicitTodoKeyword,
+                explicitWorkflowKeyword: frontDoorSignals.explicitWorkflowKeyword,
+                explicitDelegationKeyword: frontDoorSignals.explicitDelegationKeyword,
+            },
             projectName: overview?.project.name || project?.name || null,
             projectFolder: project?.folder || overview?.project.folder || null,
+            effectivePolicy: (0, policy_prompt_1.buildEffectivePolicyPromptSection)(policy, {
+                heading: '',
+                defaultLine: 'No confirmed special policy is set.',
+            }),
             recentSummary: recentSummaryText,
             lastFiveTurns: recentTurnsText,
         });
-        const decisionPrompt = [`User prompt:\n${prompt}`, '', 'Return strict JSON only.'].join('\n');
+        const decisionPrompt = [
+            'This is a routing decision only. Do not perform the task.',
+            'Do not claim to have created files, completed work, or used tools.',
+            '',
+            `User prompt:\n${prompt}`,
+            '',
+            'Return strict JSON only.',
+        ].join('\n');
         let decision = null;
         this.reportHiddenRoleProgress(opts, 'orchestrator', 'Understanding request');
         opts.onProgress('Understanding request...');
@@ -1506,6 +1540,66 @@ class OrchestratorAgent {
         finally {
             clearInterval(understandingHeartbeat);
         }
+        if (!decision) {
+            const fallbackTaskType = (0, front_door_policy_1.inferFrontDoorTaskType)(prompt);
+            const promptAssignedRoles = [promptAssignments.coding, promptAssignments.qa, promptAssignments.research].filter(Boolean).length;
+            if (frontDoorSignals.preferredMode === 'workflow') {
+                decision = {
+                    mode: 'workflow',
+                    reason: frontDoorSignals.matchedWorkflowNames.length > 0
+                        ? 'Code-based front door recovered routing by matching a named workflow.'
+                        : 'Code-based front door recovered routing from explicit TODO/workflow signals.',
+                    workflow_request: prompt,
+                };
+            }
+            else if (fallbackTaskType === 'mixed' || promptAssignedRoles >= 2 || frontDoorSignals.matchedBots.length >= 2 || frontDoorSignals.matchedRoles.length >= 2) {
+                decision = {
+                    mode: 'workflow',
+                    reason: 'Code-based front door recovered routing for a multi-worker or staged worker task.',
+                    workflow_request: prompt,
+                };
+            }
+            else if (frontDoorSignals.preferredMode === 'delegate' && frontDoorSignals.preferredTarget) {
+                const delegateRole = frontDoorSignals.matchedRoles[0]
+                    || (normalizeName(frontDoorSignals.preferredTarget) === normalizeName(roleAssignments.qa) ? 'qa'
+                        : normalizeName(frontDoorSignals.preferredTarget) === normalizeName(roleAssignments.research) ? 'research'
+                            : 'coding');
+                decision = {
+                    mode: 'delegate',
+                    reason: 'Code-based front door recovered routing from an explicit single-worker TODO/workflow signal.',
+                    delegate_target: frontDoorSignals.preferredTarget,
+                    delegate_role: delegateRole,
+                    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) {
+                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,
+                };
+            }
+        }
         if (!decision) {
             this.recordOrchestrationAudit(state, 'understand_request', 'blocked', 'Orchestrator-first decision phase did not return valid JSON. Falling back to legacy clerk chain.', { featureFlag: 'orchestrator_v2_enabled' });
             return null;
@@ -1520,6 +1614,8 @@ class OrchestratorAgent {
             orchestratorRoleClass: orchestratorBot.role_class,
             promptAssignments,
             roleAssignments,
+            specialists: signalSpecialists,
+            workflowNames,
             highRisk: highRiskPrompt,
         });
         if (normalizedDecision.corrected) {
@@ -1538,10 +1634,28 @@ 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') {
-            decision.mode = 'execute_self';
+            return this.formatClarificationResponse({
+                primaryMode: normalizedDecision.explicitWorkflowRequested ? 'WORKFLOW_MODE' : 'DIRECT_CONVERSATION',
+                secondaryModes: [],
+                executionOrder: [normalizedDecision.explicitWorkflowRequested ? 'WORKFLOW_MODE' : 'DIRECT_CONVERSATION'],
+                userFacingMode: normalizedDecision.explicitWorkflowRequested ? 'FULL_WORKFLOW' : 'DIRECT_RESPONSE',
+                targetScope: normalizedDecision.explicitWorkflowRequested ? 'MULTI_WORKER' : 'SELF',
+                confidence: 'MEDIUM',
+                intent: normalizedDecision.taskType === 'qa'
+                    ? 'review'
+                    : normalizedDecision.taskType === 'research'
+                        ? 'brainstorm'
+                        : normalizedDecision.taskType === 'coding' || normalizedDecision.taskType === 'workflow' || normalizedDecision.taskType === 'mixed'
+                            ? 'build'
+                            : 'question',
+                isMultiStep: normalizedDecision.explicitWorkflowRequested,
+                reasoning: decision.reason,
+                needsClarification: true,
+                clarificationQuestions: decision.clarification_questions?.length
+                    ? decision.clarification_questions
+                    : ['What exactly should I route to the workflow?'],
+            }, overview);
         }
         if (decision.mode === 'respond') {
             const response = decision.response?.trim() || this.handleDirectConversation(prompt, overview, roleAssignments, state);
@@ -1596,7 +1710,7 @@ class OrchestratorAgent {
             if (executionSpec.requiresConfirmation) {
                 return this.createConfirmationCheckpoint(delegatePrompt, conversationId, delegateIntent, executionSpec, projectId, roleAssignments, state);
             }
-            return this.handleProxyRequest(delegatePrompt, conversationId, delegateIntent, opts, executionSpec, roleAssignments, state);
+            return await this.queueDelegateTodo(delegatePrompt, conversationId, delegateIntent, opts, executionSpec, roleAssignments, state, orchestratorBot, delegateTarget);
         }
         if (decision.mode === 'workflow') {
             const workflowObjective = decision.workflow_request?.trim() || prompt;
@@ -1626,7 +1740,7 @@ class OrchestratorAgent {
                 return this.createConfirmationCheckpoint(prompt, conversationId, workflowIntent, validation.executionSpec, projectId, roleAssignments, state);
             }
             this.recordOrchestrationAudit(state, 'run_workflow', 'delegated', 'Workflow execution is using the original user prompt as the execution source of truth.', { workflowObjective });
-            return this.handleOrchestratedRequest(prompt, conversationId, workflowIntent, validation.executionSpec, opts, roleAssignments, project, state, orchestratorBot);
+            return await this.queueWorkflowTodoPlan(prompt, conversationId, workflowIntent, validation.executionSpec, opts, roleAssignments, project, state, orchestratorBot);
         }
         return null;
     }
@@ -1702,6 +1816,438 @@ class OrchestratorAgent {
             locked: true,
         };
     }
+    async queueDelegateTodo(prompt, conversationId, intent, opts, executionSpec, roleAssignments, state, orchestratorBot, delegateTarget) {
+        const projectId = opts.projectId || state.projectId || null;
+        const project = projectId ? data.getProject(projectId) : undefined;
+        const targetAgent = this.findAgentByName(delegateTarget, project?.id || undefined);
+        if (!targetAgent) {
+            return this.formatClarificationResponse({
+                ...intent,
+                needsClarification: true,
+                clarificationQuestions: [`I could not resolve the target bot "${delegateTarget}". Which worker should own this task?`],
+            }, projectId ? data.getProjectOverview(projectId) : undefined);
+        }
+        const step = this.buildSingleDelegateTodoStep(prompt, targetAgent, orchestratorBot, project?.name || null, project?.folder || null, data.getEffectiveOrchestrationPolicy(projectId || undefined));
+        const task = data.addTodoTask({
+            projectId,
+            conversationId,
+            title: step.title,
+            details: step.details,
+            participants: [step.owner.name],
+            successCriteria: step.successCriteria,
+            ownerBotId: step.owner.id,
+            ownerName: step.owner.name,
+            taskType: step.taskType,
+            profileName: 'Programming',
+            taskPrompt: step.taskPrompt,
+            actor: { actorType: 'orchestrator', actorId: orchestratorBot.id },
+        });
+        this.markConversationOrchestrated(conversationId);
+        this.recordOrchestrationAudit(state, 'delegate_specialist', 'delegated', `Queued delegated TODO for ${targetAgent.name}.`, {
+            todoTaskId: task.id,
+            targetAgent: targetAgent.name,
+            taskType: step.taskType,
+        });
+        (0, state_1.addDelegateTarget)(state, targetAgent.name);
+        this.applyExecutionSpecToState(state, executionSpec);
+        if (opts.autoDispatchTodos === false) {
+            state.finalResponseDraft = [
+                `I created 1 TODO for ${targetAgent.name}.`,
+                '',
+                `1. ${step.title}`,
+                `   Role: ${step.taskType}`,
+                `   Owner: ${targetAgent.name}`,
+            ].join('\n');
+            return state.finalResponseDraft;
+        }
+        return await this.dispatchQueuedTodoChain(conversationId, opts, state, orchestratorBot, project, { taskIds: [task.id], workflowName: null });
+    }
+    async queueWorkflowTodoPlan(prompt, conversationId, intent, executionSpec, opts, roleAssignments, project, state, orchestratorBot, workflowTemplate) {
+        const projectId = project?.id || opts.projectId || state.projectId || null;
+        const effectivePolicy = data.getEffectiveOrchestrationPolicy(projectId || undefined);
+        const plannedSteps = workflowTemplate
+            ? this.buildTodoStepsFromTemplate(prompt, workflowTemplate, orchestratorBot, project?.name || null, project?.folder || null, effectivePolicy)
+            : this.buildTodoStepsFromAssignments(prompt, roleAssignments, intent, orchestratorBot, projectId || undefined, project?.name || null, project?.folder || null, effectivePolicy);
+        if (plannedSteps.length === 0) {
+            const overview = projectId ? data.getProjectOverview(projectId) : undefined;
+            return this.formatClarificationResponse({
+                ...intent,
+                needsClarification: true,
+                clarificationQuestions: ['I do not have enough worker assignments to build the TODO workflow. Which bots should handle the requested stages?'],
+            }, overview);
+        }
+        const createdTasks = [];
+        for (let index = 0; index < plannedSteps.length; index += 1) {
+            const step = plannedSteps[index];
+            const next = plannedSteps[index + 1];
+            const task = data.addTodoTask({
+                projectId,
+                conversationId,
+                title: step.title,
+                details: step.details,
+                participants: [step.owner.name],
+                successCriteria: step.successCriteria,
+                ownerBotId: step.owner.id,
+                ownerName: step.owner.name,
+                taskType: step.taskType,
+                profileName: 'Programming',
+                nextWorkerBotId: next?.owner.id || null,
+                nextWorkerName: next?.owner.name || null,
+                nextWorkerRole: next ? (next.owner.role_label || next.owner.role_class || null) : null,
+                taskPrompt: step.taskPrompt,
+                actor: { actorType: 'orchestrator', actorId: orchestratorBot.id },
+            });
+            createdTasks.push(task);
+            (0, state_1.addDelegateTarget)(state, step.owner.name);
+        }
+        this.markConversationOrchestrated(conversationId);
+        this.applyExecutionSpecToState(state, executionSpec);
+        this.recordOrchestrationAudit(state, 'run_workflow', 'delegated', workflowTemplate
+            ? `Queued TODO workflow from template "${workflowTemplate.name}".`
+            : 'Queued TODO workflow from explicit orchestration request.', {
+            todoTaskIds: createdTasks.map((task) => task.id),
+            workflowTemplateId: workflowTemplate?.id || null,
+            stepCount: createdTasks.length,
+        });
+        if (opts.autoDispatchTodos === false) {
+            const lines = [
+                workflowTemplate
+                    ? `I created a ${createdTasks.length}-step TODO workflow from "${workflowTemplate.name}".`
+                    : `I created a ${createdTasks.length}-step TODO workflow.`,
+                '',
+            ];
+            for (const [index, step] of plannedSteps.entries()) {
+                lines.push(`${index + 1}. ${step.title}`);
+                lines.push(`   Owner: ${step.owner.name}`);
+                lines.push(`   Role: ${step.taskType}`);
+            }
+            state.finalResponseDraft = lines.join('\n');
+            return state.finalResponseDraft;
+        }
+        return await this.dispatchQueuedTodoChain(conversationId, opts, state, orchestratorBot, project, {
+            taskIds: createdTasks.map((task) => task.id),
+            workflowName: workflowTemplate?.name || null,
+        });
+    }
+    async dispatchQueuedTodoChain(conversationId, opts, state, orchestratorBot, project, context) {
+        const maxSteps = 20;
+        for (let iteration = 0; iteration < maxSteps; iteration += 1) {
+            const task = data.getNextActiveTodoForConversation(conversationId);
+            if (!task) {
+                return await this.finalizeQueuedTodoChain(conversationId, opts, state, orchestratorBot, project, context.workflowName);
+            }
+            const owner = task.owner_bot_id
+                ? data.getAgentProfile(task.owner_bot_id)
+                : this.findAgentByName(task.owner_name || undefined, project?.id || undefined);
+            if (!owner) {
+                const message = `I could not resolve the worker assigned to TODO #${task.id}.`;
+                state.finalResponseDraft = message;
+                this.recordOrchestrationAudit(state, 'delegate_specialist', 'blocked', message, { taskId: task.id, ownerName: task.owner_name || null });
+                return message;
+            }
+            const taskPrompt = task.task_prompt?.trim() || task.details || task.title;
+            const result = await this.runNodeWithRetry('run_workflow', state, async () => this.workflowEngine.execute(taskPrompt, conversationId, owner.id, {
+                apiKey: this.resolveApiKey(owner.provider),
+                taskId: task.id,
+                disableDecomposition: true,
+                isOrchestrated: true,
+                projectId: project?.id || opts.projectId || state.projectId || null,
+                workspacePath: project?.folder?.trim() || undefined,
+                persistConversationMessages: false,
+                onWorkerChunk: opts.onWorkerChunk,
+                onProgress: (progress) => {
+                    if (progress.event === 'step-started') {
+                        this.reportHiddenRoleProgress(opts, 'dispatch_controller', `${owner.name} is working on TODO: ${task.title}`);
+                    }
+                    else if (progress.event === 'step-completed') {
+                        this.reportHiddenRoleProgress(opts, 'dispatch_controller', `${owner.name} completed TODO: ${task.title}`);
+                    }
+                    else if (progress.event === 'step-failed') {
+                        this.reportHiddenRoleProgress(opts, 'dispatch_controller', `${owner.name} encountered an issue while working on TODO: ${task.title}`);
+                    }
+                },
+            }));
+            const stillActive = data.getTodoTask(task.id, 'active');
+            const completed = data.getTodoTask(task.id, 'completed');
+            if (stillActive?.blocker_summary && stillActive.blocker_question) {
+                this.recordOrchestrationAudit(state, 'run_workflow', 'blocked', `${owner.name} blocked on TODO: ${task.title}`, { taskId: task.id, blockerSummary: stillActive.blocker_summary });
+                return await this.handleBlockedTodoTask(stillActive, opts, state, orchestratorBot, project);
+            }
+            if (!completed) {
+                const error = result.steps.find((step) => step.error)?.error || this.stripWorkerProtocol(result.mergedResult || '') || 'Worker did not complete the queued task.';
+                const message = `${owner.name} encountered an issue: ${error}`;
+                state.finalResponseDraft = message;
+                this.recordOrchestrationAudit(state, 'run_workflow', 'blocked', message, { taskId: task.id });
+                return message;
+            }
+        }
+        const message = 'The workflow exceeded the automatic dispatch limit before completing.';
+        state.finalResponseDraft = message;
+        this.recordOrchestrationAudit(state, 'run_workflow', 'blocked', message, { maxSteps: 20 });
+        return message;
+    }
+    async handleBlockedTodoTask(task, opts, state, orchestratorBot, project) {
+        const policy = data.getEffectiveOrchestrationPolicy(project?.id || opts.projectId || state.projectId || undefined);
+        const artifacts = data.listTodoArtifactsForTask(task.id, 'active').map((item) => item.path_or_ref);
+        const workerRole = task.task_type || task.next_worker_role || 'general';
+        const blockedPrompt = (0, orchestrator_blocked_prompt_1.buildBlockedWorkerOrchestratorPrompt)({
+            orchestratorName: orchestratorBot.name,
+            workerName: task.owner_name || 'Worker',
+            workerRole,
+            taskTitle: task.title,
+            taskPrompt: task.task_prompt || task.details || task.title,
+            projectId: project?.id || opts.projectId || state.projectId || undefined,
+            projectName: project?.name || null,
+            workspacePath: project?.folder || null,
+            effectivePolicy: policy,
+            artifactRefs: artifacts,
+            blockerSummary: task.blocker_summary || 'Worker is blocked.',
+            checkedContext: task.blocker_checked || 'No checked context was recorded.',
+            userQuestion: task.blocker_question || 'What should happen next?',
+        });
+        const response = await this.runNodeWithRetry('finalize_response', state, async () => {
+            const result = await this.workflowEngine.execute(blockedPrompt, task.conversation_id || state.conversationId || '', orchestratorBot.id, {
+                apiKey: this.resolveApiKey(orchestratorBot.provider),
+                disableDecomposition: true,
+                disableTools: true,
+                workerMode: false,
+                persistConversationMessages: false,
+                onWorkerChunk: opts.onWorkerChunk,
+                workspacePath: project?.folder?.trim() || undefined,
+            });
+            return this.stripWorkerProtocol(result.mergedResult || '');
+        });
+        state.finalResponseDraft = response;
+        return response;
+    }
+    async finalizeQueuedTodoChain(conversationId, opts, state, orchestratorBot, project, workflowName) {
+        const completedTasks = data.listCompletedTodoTasksForConversation(conversationId);
+        if (completedTasks.length === 0) {
+            const fallback = workflowName
+                ? `The "${workflowName}" workflow finished without any completed worker output.`
+                : 'The queued workflow finished without any completed worker output.';
+            state.finalResponseDraft = fallback;
+            return fallback;
+        }
+        const policy = data.getEffectiveOrchestrationPolicy(project?.id || opts.projectId || state.projectId || undefined);
+        const finalPrompt = (0, orchestrator_final_response_prompt_1.buildOrchestratorFinalResponsePrompt)({
+            orchestratorName: orchestratorBot.name,
+            projectName: project?.name || null,
+            workspacePath: project?.folder || null,
+            effectivePolicy: policy,
+            completedTasks,
+        });
+        const response = await this.runNodeWithRetry('finalize_response', state, async () => {
+            const result = await this.workflowEngine.execute(finalPrompt, conversationId, orchestratorBot.id, {
+                apiKey: this.resolveApiKey(orchestratorBot.provider),
+                disableDecomposition: true,
+                disableTools: true,
+                workerMode: false,
+                persistConversationMessages: false,
+                onWorkerChunk: opts.onWorkerChunk,
+                workspacePath: project?.folder?.trim() || undefined,
+            });
+            return this.stripWorkerProtocol(result.mergedResult || '');
+        });
+        state.finalResponseDraft = response;
+        this.recordOrchestrationAudit(state, 'finalize_response', 'completed', workflowName
+            ? `Completed automatic TODO dispatch for workflow "${workflowName}".`
+            : 'Completed automatic TODO dispatch.', { completedTaskCount: completedTasks.length });
+        return response;
+    }
+    buildSingleDelegateTodoStep(prompt, owner, orchestratorBot, projectName, workspacePath, effectivePolicy) {
+        const taskType = this.normalizeTaskTypeForWorker(owner, 'coding');
+        return {
+            title: `${owner.name}: ${this.summarizeTodoTitle(prompt)}`,
+            details: `Delegated by ${orchestratorBot.name}. Complete this single-worker request directly.`,
+            owner,
+            taskType,
+            taskPrompt: this.buildWorkerTaskPrompt({
+                originalPrompt: prompt,
+                stepInstruction: 'Handle this delegated request directly.',
+                owner,
+                nextWorker: null,
+                projectName,
+                workspacePath,
+                effectivePolicy,
+            }),
+            successCriteria: `Complete the delegated ${taskType} task and return a concise result summary.`,
+        };
+    }
+    buildTodoStepsFromTemplate(prompt, workflowTemplate, orchestratorBot, projectName, workspacePath, effectivePolicy) {
+        const steps = workflowTemplate.steps
+            .sort((a, b) => a.order_index - b.order_index)
+            .map((step) => {
+            const owner = data.getAgentProfile(step.agent_id);
+            if (!owner)
+                return null;
+            const taskType = this.normalizeTaskTypeForWorker(owner, step.is_checkpoint === 1 ? 'qa' : null);
+            return {
+                owner,
+                instruction: step.instruction?.trim() || `Complete ${owner.name}'s workflow step.`,
+                taskType,
+            };
+        })
+            .filter((item) => Boolean(item));
+        return steps.map((step, index) => ({
+            title: `${step.owner.name}: ${this.summarizeTodoTitle(step.instruction)}`,
+            details: `Workflow template step ${index + 1} from ${workflowTemplate.name}.`,
+            owner: step.owner,
+            taskType: step.taskType,
+            taskPrompt: this.buildWorkerTaskPrompt({
+                originalPrompt: prompt,
+                stepInstruction: step.instruction,
+                owner: step.owner,
+                nextWorker: steps[index + 1]?.owner || null,
+                projectName,
+                workspacePath,
+                effectivePolicy,
+            }),
+            successCriteria: `Complete step ${index + 1} of "${workflowTemplate.name}" and hand off the necessary output.`,
+        }));
+    }
+    buildTodoStepsFromAssignments(prompt, roleAssignments, intent, orchestratorBot, projectId, projectName, workspacePath, effectivePolicy) {
+        const roleOrder = this.inferWorkflowRoleOrder(prompt, roleAssignments, intent);
+        const owners = roleOrder
+            .map((role) => {
+            const agentName = roleAssignments[role];
+            const agent = this.findAgentByName(agentName, projectId);
+            if (!agent)
+                return null;
+            return { role, agent };
+        })
+            .filter((item) => Boolean(item));
+        return owners.map((item, index) => ({
+            title: `${item.agent.name}: ${this.defaultTodoTitleForRole(item.role, prompt)}`,
+            details: `Workflow step assigned by ${orchestratorBot.name}.`,
+            owner: item.agent,
+            taskType: this.normalizeTaskTypeForWorker(item.agent, item.role === 'research' ? 'research' : item.role === 'qa' ? 'qa' : 'coding'),
+            taskPrompt: this.buildWorkerTaskPrompt({
+                originalPrompt: prompt,
+                stepInstruction: this.defaultStepInstructionForRole(item.role, prompt),
+                owner: item.agent,
+                nextWorker: owners[index + 1]?.agent || null,
+                projectName: projectName || null,
+                workspacePath: workspacePath || null,
+                effectivePolicy: effectivePolicy || data.getEffectiveOrchestrationPolicy(projectId),
+            }),
+            successCriteria: this.defaultSuccessCriteriaForRole(item.role),
+        }));
+    }
+    inferWorkflowRoleOrder(prompt, assignments, intent) {
+        const explicitResearch = /\b(research|brainstorm|plan|planning|analyze|investigate|design|architect)\b/i.test(prompt);
+        const explicitCoding = /\b(code|codes|coded|coding|build|builds|building|implement|implements|implementing|create|creates|creating|fix|fixes|fixing|update|updates|updating|edit|editing|change|changes|changing)\b/i.test(prompt);
+        const explicitQa = /\b(qa|review|test|verify|verification|audit)\b/i.test(prompt);
+        const requestedRoles = [];
+        if (explicitResearch && assignments.research)
+            requestedRoles.push('research');
+        if (explicitCoding && assignments.coding)
+            requestedRoles.push('coding');
+        if (explicitQa && assignments.qa)
+            requestedRoles.push('qa');
+        if (requestedRoles.length > 0)
+            return requestedRoles;
+        if (intent.intent === 'review' && assignments.qa)
+            return ['qa'];
+        if (intent.intent === 'brainstorm' && assignments.research)
+            return ['research'];
+        const fallback = [];
+        if (assignments.research && /\b(research|brainstorm|plan|planning)\b/i.test(prompt))
+            fallback.push('research');
+        if (assignments.coding)
+            fallback.push('coding');
+        if (assignments.qa)
+            fallback.push('qa');
+        if (fallback.length > 0)
+            return Array.from(new Set(fallback));
+        return [];
+    }
+    normalizeTaskTypeForWorker(owner, fallback) {
+        const roleClass = String(owner.role_class || owner.role_label || '').trim().toLowerCase();
+        if (roleClass === 'qa' || roleClass === 'review')
+            return 'qa';
+        if (roleClass === 'research' || roleClass === 'brainstorm' || roleClass === 'planning' || roleClass === 'plan')
+            return 'research';
+        if (roleClass === 'verify' || roleClass === 'verification')
+            return 'verify';
+        if (roleClass === 'deploy' || roleClass === 'deployment')
+            return 'deploy';
+        if (roleClass === 'coding' || roleClass === 'code' || roleClass === 'builder' || roleClass === 'developer' || roleClass === 'engineer')
+            return 'coding';
+        return (fallback || 'coding');
+    }
+    buildWorkerTaskPrompt(input) {
+        const workerRole = String(input.owner.role_label || input.owner.role_class || 'general').trim() || 'general';
+        const composedTask = [
+            `Step instruction: ${input.stepInstruction}`,
+            '',
+            'Original user request:',
+            input.originalPrompt,
+        ].join('\n');
+        return (0, worker_operating_prompt_1.buildWorkerOperatingPrompt)({
+            workerName: input.owner.name,
+            workerRole,
+            taskType: this.normalizeTaskTypeForWorker(input.owner, null),
+            taskTitle: input.stepInstruction,
+            taskPrompt: composedTask,
+            projectName: input.projectName,
+            workspacePath: input.workspacePath,
+            effectivePolicy: (0, policy_prompt_1.buildEffectivePolicyPromptSection)(input.effectivePolicy, {
+                heading: '',
+                defaultLine: 'No confirmed special policy is set.',
+            }),
+            nextWorkerName: input.nextWorker?.name || null,
+            nextWorkerRole: input.nextWorker ? String(input.nextWorker.role_label || input.nextWorker.role_class || 'general') : null,
+        });
+    }
+    defaultTodoTitleForRole(role, prompt) {
+        if (role === 'research')
+            return `Research and plan: ${this.summarizeTodoTitle(prompt)}`;
+        if (role === 'qa')
+            return `QA and verify: ${this.summarizeTodoTitle(prompt)}`;
+        return `Build and implement: ${this.summarizeTodoTitle(prompt)}`;
+    }
+    defaultStepInstructionForRole(role, prompt) {
+        if (role === 'research') {
+            return 'Research, brainstorm, or plan the work so the implementation handoff is specific and actionable.';
+        }
+        if (role === 'qa') {
+            return 'Review and QA the completed work against the original request. If issues remain, prepare a fix handoff for the previous worker.';
+        }
+        return `Implement the requested work directly. Keep the original request in scope: ${prompt}`;
+    }
+    defaultSuccessCriteriaForRole(role) {
+        if (role === 'research')
+            return 'Produce a clear handoff that gives the next worker enough detail to execute without guessing.';
+        if (role === 'qa')
+            return 'Verify the work against the request and prepare the next handoff if fixes are needed.';
+        return 'Complete the requested implementation and prepare the next worker handoff.';
+    }
+    summarizeTodoTitle(text) {
+        const normalized = String(text || '').replace(/\s+/g, ' ').trim();
+        if (!normalized)
+            return 'Assigned task';
+        return normalized.length <= 72 ? normalized : `${normalized.slice(0, 69).trimEnd()}...`;
+    }
+    markConversationOrchestrated(conversationId) {
+        try {
+            const db = data.getDb();
+            db.prepare("UPDATE conversation SET routing_mode = 'orchestrated' WHERE id = ?").run(conversationId);
+        }
+        catch { /* best effort */ }
+    }
+    findAgentByName(name, projectId) {
+        const normalized = String(name || '').trim().toLowerCase();
+        if (!normalized)
+            return undefined;
+        const project = projectId ? data.getProject(projectId) : undefined;
+        const scopedIds = new Set(project?.bot_ids || []);
+        const allAgents = data.listAgentProfiles();
+        const scopedMatch = allAgents.find((agent) => scopedIds.has(agent.id) && agent.name.trim().toLowerCase() === normalized);
+        if (scopedMatch)
+            return scopedMatch;
+        return allAgents.find((agent) => agent.name.trim().toLowerCase() === normalized);
+    }
     async executeOrchestratorOwnedWork(prompt, conversationId, orchestratorBot, roleAssignments, project, opts, state, options) {
         this.recordOrchestrationAudit(state, 'execute_direct', 'executed', `Selected orchestrator bot ${orchestratorBot.name} kept the work.`, { orchestratorBotId: orchestratorBot.id, orchestratorBotName: orchestratorBot.name });
         this.reportHiddenRoleProgress(opts, 'orchestrator', `${orchestratorBot.name} is working on the request`);
@@ -1710,17 +2256,14 @@ class OrchestratorAgent {
             isOrchestrated: false,
             projectId: project?.id || state.projectId || null,
             workspacePath: project?.folder?.trim() || undefined,
-            persistConversationMessages: true,
+            // The orchestrator owns the visible reply and persists the final
+            // assistant message after post-processing. Letting the worker path
+            // also persist would create duplicate assistant messages.
+            persistConversationMessages: false,
             workerMode: false,
             onWorkerChunk: opts.onWorkerChunk,
             onProgress: (progress) => {
-                if (progress.event === 'step-started') {
-                    this.reportHiddenRoleProgress(opts, 'orchestrator', `${progress.step.agentName} is working on the kept task`);
-                }
-                else if (progress.event === 'step-completed') {
-                    this.reportHiddenRoleProgress(opts, 'orchestrator', `${progress.step.agentName} completed the kept task`);
-                }
-                else if (progress.event === 'step-failed') {
+                if (progress.event === 'step-failed') {
                     this.reportHiddenRoleProgress(opts, 'orchestrator', `${progress.step.agentName} hit an issue while working on the kept task`);
                 }
             },
@@ -2696,8 +3239,6 @@ class OrchestratorAgent {
             const conn = data.findProviderConnection(provider);
             if (conn?.api_key_enc)
                 return conn.api_key_enc;
-            if (conn?.oauth_token)
-                return conn.oauth_token;
         }
         catch { /* fall through */ }
         switch (provider) {
@@ -2754,11 +3295,11 @@ class OrchestratorAgent {
     }
     parseRoleAssignments(prompt) {
         const assignments = {};
-        const agents = (0, orchestrator_profile_1.filterOutOrchestratorProfiles)(data.listAgentProfiles());
+        const agents = data.listAgentProfiles();
         const rolePatterns = [
             { role: 'coding', patterns: [/\bcodes?\b/i, /\bcoding\b/i, /\bimplement(s|ing)?\b/i, /\bbuild(s|ing)?\b/i, /\bcreate(s|d|ing)?\b/i, /\bwrite(s|n)?\b/i, /\bdeveloper\b/i] },
             { role: 'qa', patterns: [/\bqa\b/i, /\btest(s|ing)?\b/i, /\breview(s|ing)?\b/i, /\bverify\b|\bverification\b/i, /\bpass\/fail\b/i] },
-            { role: 'research', patterns: [/\bresearch(es|ing)?\b/i, /\banaly(s|z)e(s|d|ing)?\b/i, /\binvestigate(s|d|ing)?\b/i, /\bbrainstorm\b/i, /\bidea is sound\b/i, /\bsound\b/i, /\bpressure[- ]?test\b/i, /\brecommend(?:s|ed|ing)?\b/i] },
+            { role: 'research', patterns: [/\bresearch(es|ing)?\b/i, /\banaly(s|z)e(s|d|ing)?\b/i, /\binvestigate(s|d|ing)?\b/i, /\bbrainstorm\b/i, /\bdesign(s|ed|ing)?\b/i, /\bplan(?:s|ned|ning)?\b/i, /\barchitect(?:s|ed|ing)?\b/i, /\bidea is sound\b/i, /\bsound\b/i, /\bpressure[- ]?test\b/i, /\brecommend(?:s|ed|ing)?\b/i] },
         ];
         const clauses = prompt
             .split(/[\n,;\.]+|\band\b|\bwhile\b|\bthen\b|->/gi)
@@ -3078,18 +3619,19 @@ class OrchestratorAgent {
             currentPolicy,
             projectName: overview?.project.name,
         }).catch(() => null);
-        const sanitizedInterpretedPatch = this.sanitizeInterpretedPolicyPatch(prompt, interpreted?.patch || {});
+        const agentNames = data.listAgentProfiles().map((agent) => agent.name);
+        const sanitizedInterpretedPatch = (0, policy_detection_1.sanitizePolicyPatch)(prompt, interpreted?.patch || {}, currentPolicy);
         const patch = {
-            ...this.extractPolicyPatch(prompt, assignments, currentPolicy),
+            ...(0, policy_detection_1.extractPolicyPatchFromPrompt)(prompt, currentPolicy, { agentNames }),
             ...sanitizedInterpretedPatch,
         };
         const changes = interpreted?.summaryLines?.length
             ? interpreted.summaryLines
-            : this.summarizePolicyPatch(patch);
+            : (0, policy_detection_1.summarizePolicyPatch)(patch);
         if (changes.length === 0) {
             return this.formatPolicyUpdateResponse(prompt, intent, assignments, overview);
         }
-        const scope = interpreted?.scope || this.determinePolicyScope(prompt, projectId);
+        const scope = interpreted?.scope || (0, policy_detection_1.determinePolicyScope)(prompt, overview?.project.name || undefined);
         data.setPendingOrchestrationPolicy({
             conversationId,
             projectId: scope === 'project' ? projectId || null : null,
@@ -3142,6 +3684,24 @@ class OrchestratorAgent {
             return data.getWorkflowTemplate(templates[0].id);
         return undefined;
     }
+    resolveWorkflowTemplateByPrompt(projectId, prompt) {
+        if (!projectId)
+            return undefined;
+        const normalizedPrompt = String(prompt || '').trim().toLowerCase();
+        if (!/\b(todo|workflow)\b/i.test(normalizedPrompt))
+            return undefined;
+        const templates = data.listWorkflowTemplates(projectId).filter((template) => template.enabled === 1);
+        for (const template of templates) {
+            const name = String(template.name || '').trim().toLowerCase();
+            if (!name)
+                continue;
+            const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            if (new RegExp(`(^|[^a-z0-9])${escaped}([^a-z0-9]|$)`, 'i').test(normalizedPrompt)) {
+                return data.getWorkflowTemplate(template.id);
+            }
+        }
+        return undefined;
+    }
     persistRoleAssignments(projectId, conversationId, agentId, assignments) {
         const merged = this.mergeRoleAssignments({}, this.loadRoleAssignments(projectId), this.deriveRoleAssignmentsFromProject(projectId), assignments);
         data.setProjectSetting(projectId, ORCHESTRATOR_ROLE_SETTING_KEY, JSON.stringify(merged));