funolio-agent 1.0.75 → 1.1.65

package/dist/orchestrator.js

@@ -48,28 +48,36 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrchestratorAgent = void 0;
 exports.buildLocalDesktopOrchestratorRuntime = buildLocalDesktopOrchestratorRuntime;
+exports.buildNarrationStreamGate = buildNarrationStreamGate;
 const index_1 = require("./providers/index");
+const approval_1 = require("./approval");
 const status_parser_1 = require("./orchestration/status-parser");
 const validation_1 = require("./orchestration/validation");
 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 safeguards_1 = require("./orchestration/safeguards");
 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 capabilities_1 = require("./orchestration/capabilities");
 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");
 const context_window_1 = require("./context-window");
+const cli_bootstrap_history_1 = require("./cli-bootstrap-history");
+const plan_import_1 = require("./orchestration/plan-import");
+const index_2 = require("./index");
 const data = __importStar(require("./local-data"));
 const cli_session_epoch_1 = require("./cli-session-epoch");
 const storage_mode_1 = require("./storage-mode");
+const local_cli_pty_manager_1 = require("./local-cli-pty-manager");
+const codex_app_server_manager_1 = require("./codex-app-server-manager");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
-const ORCHESTRATOR_ROLE_SETTING_KEY = 'orchestrator_role_assignments';
 const ORCHESTRATOR_WORKFLOW_SETTING_KEY = 'orchestrator_preferred_workflow';
 const ORCHESTRATOR_TEMPLATE_SETTING_KEY = 'orchestrator_default_workflow_template_id';
 const HEARTBEAT_MS = 30_000;
@@ -84,11 +92,22 @@ const ORCHESTRATION_NODE_RETRY_LIMITS = {
     finalize_response: 0,
     require_confirmation: 0,
 };
+function isAbortLikeError(err) {
+    return err?.name === 'AbortError'
+        || err?.code === 'ABORT_ERR'
+        || /\baborted\b/i.test(String(err?.message || err || ''));
+}
 // ─── Orchestrator Agent ──────────────────────────────────────────
-function resolveLocalProviderCredentials(providerName, profile) {
+function resolveLocalProviderCredentials(providerName, profile, explicitConnection) {
     if (index_1.CLI_PROVIDERS.has(providerName)) {
         return { apiKey: 'cli-auth' };
     }
+    if (explicitConnection?.oauth_token) {
+        return { apiKey: explicitConnection.oauth_token, authMode: 'oauth-bearer' };
+    }
+    if (explicitConnection?.api_key_enc) {
+        return { apiKey: explicitConnection.api_key_enc };
+    }
     const directConnection = profile?.provider_connection_id
         ? data.getProviderConnection(profile.provider_connection_id)
         : undefined;
@@ -126,12 +145,16 @@ function resolveLocalProviderCredentials(providerName, profile) {
 }
 function buildLocalDesktopOrchestratorRuntime(selectedBot) {
     if (data.isClerkOrchestratorEnabled()) {
-        const providerName = (data.getSetting('clerk_provider') || '').trim();
-        const model = (data.getSetting('clerk_model') || '').trim() || 'default';
+        const clerkConfig = data.getResolvedClerkConfigInfo();
+        const clerkConnection = clerkConfig.providerConnectionId
+            ? data.getProviderConnection(clerkConfig.providerConnectionId)
+            : undefined;
+        const providerName = (clerkConfig.provider || '').trim();
+        const model = (clerkConfig.model || '').trim() || 'default';
         if (!providerName) {
             throw new Error('Clerk is selected as orchestrator, but no clerk provider is configured.');
         }
-        const credentials = resolveLocalProviderCredentials(providerName);
+        const credentials = resolveLocalProviderCredentials(providerName, null, clerkConnection);
         const llm = (0, index_1.createProvider)(providerName, {
             apiKey: credentials.apiKey,
             model,
@@ -143,15 +166,23 @@ function buildLocalDesktopOrchestratorRuntime(selectedBot) {
             llm,
             providerName,
             model,
-            agentName: 'Clerk',
+            agentName: 'Orchestrator',
             botId: null,
-            modelLabel: model ? `${model} | Clerk` : 'Clerk',
+            modelLabel: model || null,
         };
     }
-    const profile = selectedBot || data.getOrchestratorBot() || data.getDefaultAgentProfile();
+    // Orchestrator must be designated explicitly (is_orchestrator=1 or selectedBot).
+    // No fallback to the default worker bot — that's what created the "Ben is both
+    // orchestrator and worker" bug. If neither Clerk nor an orchestrator bot is
+    // configured, the runtime should refuse to start rather than silently reuse
+    // whichever bot happens to be is_default=1.
+    const profile = selectedBot || data.getOrchestratorBot();
     if (!profile) {
-        throw new Error('No orchestrator or default bot is configured.');
+        throw new Error('No orchestrator bot is configured. Mark a bot with is_orchestrator=1 or enable Clerk orchestration.');
     }
+    return buildLocalDesktopRuntimeFromProfile(profile);
+}
+function buildLocalDesktopRuntimeFromProfile(profile) {
     const credentials = resolveLocalProviderCredentials(profile.provider, profile);
     const llm = (0, index_1.createProvider)(profile.provider, {
         apiKey: credentials.apiKey,
@@ -169,6 +200,135 @@ function buildLocalDesktopOrchestratorRuntime(selectedBot) {
         modelLabel: profile.model || profile.name,
     };
 }
+function scorePlannerModel(profile) {
+    const model = String(profile.model || '').trim().toLowerCase();
+    const provider = String(profile.provider || '').trim().toLowerCase();
+    let score = 50;
+    if (/gpt-5\.4/.test(model))
+        score += 60;
+    else if (/\bopus\b/.test(model))
+        score += 58;
+    else if (/gpt-5\.2/.test(model))
+        score += 54;
+    else if (/\bsonnet\b/.test(model))
+        score += 48;
+    else if (/gpt-5/.test(model))
+        score += 46;
+    else if (/\bpro\b/.test(model))
+        score += 44;
+    else if (/\bcodex\b/.test(model))
+        score += 38;
+    else if (/\bflash\b/.test(model))
+        score += 28;
+    else if (/\bmini\b/.test(model))
+        score += 24;
+    else if (/\bhaiku\b/.test(model))
+        score += 22;
+    else if (model)
+        score += 30;
+    if (provider === 'openai')
+        score += 8;
+    else if (provider === 'anthropic' || provider === 'claude-cli')
+        score += 7;
+    else if (provider === 'google')
+        score += 6;
+    else if (provider === 'codex-cli')
+        score += 5;
+    return score;
+}
+function selectStrongestPlannerBot(bots) {
+    if (bots.length === 0)
+        return null;
+    return [...bots]
+        .sort((a, b) => {
+        const scoreDiff = scorePlannerModel(b) - scorePlannerModel(a);
+        if (scoreDiff !== 0)
+            return scoreDiff;
+        return a.name.localeCompare(b.name);
+    })[0] || null;
+}
+/**
+ * Builds a chunk-forwarding gate used to stream orchestrator narration to
+ * the user while preserving the structured-decision contract:
+ *
+ *   - Forwards pre-sentinel text to onNarrationChunk
+ *   - Stops as soon as ===DECISION=== sentinel is seen (the rest is JSON)
+ *   - Detects "looks like raw JSON, no sentinel coming" early and suppresses
+ *     forwarding entirely so JSON does not leak to the user
+ *   - Holds the first 16 chars to make the narration-vs-JSON decision
+ *   - Handles sentinel arriving before the sniff length is reached
+ *
+ * Exported separately so unit tests can exercise the gate logic without
+ * standing up a full orchestrator instance.
+ */
+function buildNarrationStreamGate(onNarrationChunk) {
+    const SNIFF_LEN = 16;
+    let buffer = '';
+    let suppressed = false;
+    let decided = false;
+    let forwardedLen = 0;
+    const isLikelyRawJsonPrefix = (text) => {
+        const trimmed = text.replace(/^\s+/, '');
+        if (!trimmed)
+            return false;
+        if (trimmed.startsWith('{') || trimmed.startsWith('```json') || trimmed.startsWith('```'))
+            return true;
+        return false;
+    };
+    return async (chunk) => {
+        if (!chunk || suppressed)
+            return;
+        buffer += chunk;
+        const sentinelIdx = buffer.indexOf(orchestrator_operating_prompt_1.ORCHESTRATOR_DECISION_SENTINEL);
+        if (sentinelIdx >= 0) {
+            const preSentinel = buffer.slice(0, sentinelIdx);
+            if (!decided) {
+                if (preSentinel.length > 0 && !isLikelyRawJsonPrefix(preSentinel)) {
+                    try {
+                        await onNarrationChunk(preSentinel);
+                    }
+                    catch { /* swallow */ }
+                }
+                decided = true;
+            }
+            else if (sentinelIdx > forwardedLen) {
+                const tail = buffer.slice(forwardedLen, sentinelIdx);
+                if (tail) {
+                    try {
+                        await onNarrationChunk(tail);
+                    }
+                    catch { /* swallow */ }
+                }
+            }
+            forwardedLen = sentinelIdx;
+            suppressed = true;
+            return;
+        }
+        if (!decided) {
+            if (buffer.length < SNIFF_LEN)
+                return;
+            if (isLikelyRawJsonPrefix(buffer)) {
+                suppressed = true;
+                return;
+            }
+            decided = true;
+            forwardedLen = buffer.length;
+            try {
+                await onNarrationChunk(buffer);
+            }
+            catch { /* swallow */ }
+            return;
+        }
+        const tail = buffer.slice(forwardedLen);
+        if (tail) {
+            forwardedLen = buffer.length;
+            try {
+                await onNarrationChunk(tail);
+            }
+            catch { /* swallow */ }
+        }
+    };
+}
 class OrchestratorAgent {
     orchestratorRuntime;
     workflowEngine;
@@ -191,9 +351,9 @@ class OrchestratorAgent {
                 },
                 providerName: runtimeInfo?.provider || 'openai',
                 model: runtimeInfo?.model || null,
-                agentName: 'Clerk',
+                agentName: 'Orchestrator',
                 botId: null,
-                modelLabel: runtimeInfo?.model ? `${runtimeInfo.model} | Clerk` : 'Clerk',
+                modelLabel: runtimeInfo?.model || null,
             };
         }
         else {
@@ -228,6 +388,8 @@ class OrchestratorAgent {
                 return await work(attempt);
             }
             catch (error) {
+                if (isAbortLikeError(error))
+                    throw error;
                 if (attempt >= maxRetries)
                     throw error;
                 attempt += 1;
@@ -254,11 +416,52 @@ class OrchestratorAgent {
             add('GPT');
         return Array.from(refs);
     }
+    getOrchestrationRoleLabel(agent) {
+        return data.getAgentOrchestrationRoleLabel(agent) || 'general';
+    }
+    getOrchestrationRoleClass(agent) {
+        return String(data.getAgentOrchestrationRoleClass(agent) || '').trim().toLowerCase();
+    }
+    getOrchestrationRolePriorities(agent) {
+        if (!agent)
+            return [];
+        return data.getAgentRolePriorities(agent).map((role) => role.trim().toLowerCase()).filter(Boolean);
+    }
+    agentHasAnyRole(agent, roles) {
+        if (!agent)
+            return false;
+        const wanted = new Set(roles.map((role) => role.trim().toLowerCase()).filter(Boolean));
+        if (wanted.size === 0)
+            return false;
+        return this.getOrchestrationRolePriorities(agent).some((role) => wanted.has(role))
+            || wanted.has(this.getOrchestrationRoleClass(agent));
+    }
+    /**
+     * The worker's `orchestration_include_user_prompt` setting controls
+     * whether their task prompt is appended with the original user
+     * request as a reference block. Position-aware (2026-04-19): the
+     * FIRST worker in a chain ALWAYS gets the user prompt, regardless
+     * of the flag — they have no predecessor handoff to stand in for
+     * it, and without the prompt they'd have no concrete context at
+     * all. Downstream workers honor the explicit flag. This matches
+     * Steven's intent: "turn it off for Ben/John so they just read
+     * Brain's handoff, but Brain (the first bot) always gets it."
+     * If the user configures a different chain where Ben is first,
+     * Ben gets the prompt automatically without the user needing to
+     * remember to toggle the flag.
+     */
+    shouldIncludeOriginalPromptForWorker(agent, isFirstInChain) {
+        if (isFirstInChain)
+            return true;
+        return agent.orchestration_include_user_prompt === 1;
+    }
     describeAgentResponsibilities(agent) {
         const candidates = [
             agent.purpose_md,
             agent.identity_summary,
             agent.skills_md,
+            agent.orchestration_role_label,
+            agent.orchestration_role_class,
             agent.role_label,
             agent.role_class,
         ].map((value) => String(value || '').replace(/\s+/g, ' ').trim()).filter(Boolean);
@@ -273,7 +476,7 @@ class OrchestratorAgent {
                 return cleaned.length > 180 ? `${cleaned.slice(0, 177).trim()}...` : cleaned;
             }
         }
-        const normalizedRole = String(agent.role_class || agent.role_label || '').trim().toLowerCase();
+        const normalizedRole = this.getOrchestrationRoleClass(agent);
         if (normalizedRole === 'code' || normalizedRole === 'coding') {
             return 'implementation, code changes, fixes, and app changes';
         }
@@ -299,7 +502,7 @@ class OrchestratorAgent {
         const orchestrationState = (0, state_1.createOrchestrationState)({
             conversationId: conversationId || null,
             projectId: conversationProjectId || null,
-            orchestratorBotId: conversation?.agent_id || null,
+            orchestratorBotId: opts.orchestratorBotIdHint || null,
             userPromptRaw: prompt,
         });
         orchestrationState.requestedArtifactTargets = this.extractRequestedArtifactTargets(prompt);
@@ -318,24 +521,36 @@ class OrchestratorAgent {
             return this.applyPendingPolicy(conversationId, pendingPolicy);
         }
         const promptAssignments = this.parseRoleAssignments(prompt);
-        const selectedOrchestrator = this.resolveSelectedOrchestratorBot(conversation);
-        if (selectedOrchestrator) {
+        const selectedOrchestrator = this.resolveOrchestratorRuntimeBot(opts.orchestratorBotIdHint);
+        const dispatchOrchestratorBot = this.orchestratorRuntime.kind === 'clerk'
+            ? null
+            : selectedOrchestrator || null;
+        const hasConfiguredOrchestratorRuntime = this.orchestratorRuntime.kind === 'clerk' || !!selectedOrchestrator;
+        const selectedOrchestratorActor = this.getOrchestratorDispatchActor(dispatchOrchestratorBot);
+        if (this.orchestratorRuntime.kind === 'clerk') {
+            this.setLastResponseMeta({
+                agentName: 'Orchestrator',
+                botId: null,
+                modelLabel: this.orchestratorRuntime.modelLabel,
+            });
+        }
+        else if (selectedOrchestrator) {
             this.setLastResponseMeta({
                 agentName: 'Orchestrator',
                 botId: selectedOrchestrator.id,
                 modelLabel: null,
             });
         }
-        if (selectedOrchestrator) {
-            orchestrationState.orchestratorBotId = selectedOrchestrator.id;
+        if (dispatchOrchestratorBot) {
+            orchestrationState.orchestratorBotId = dispatchOrchestratorBot.id;
         }
         const initialProject = conversationProjectId ? data.getProject(conversationProjectId) : undefined;
         const initialPolicy = data.getEffectiveOrchestrationPolicy(conversationProjectId || undefined);
-        const initialAssignments = this.mergeRoleAssignments(this.policyRoleAssignments(initialPolicy), conversationProjectId ? this.loadRoleAssignments(conversationProjectId) : {}, this.deriveRoleAssignmentsFromProject(conversationProjectId, selectedOrchestrator), promptAssignments);
+        const initialAssignments = this.mergeRoleAssignments(this.policyRoleAssignments(initialPolicy), this.deriveRoleAssignmentsFromProject(conversationProjectId, dispatchOrchestratorBot), promptAssignments);
         const initialOverview = conversationProjectId ? data.getProjectOverview(conversationProjectId) : undefined;
         // If a specific workflow template was selected by the user, skip front-door classification
         // and go straight to workflow execution.
-        if (opts.workflowTemplateId && selectedOrchestrator) {
+        if (opts.workflowTemplateId && hasConfiguredOrchestratorRuntime) {
             const template = data.getWorkflowTemplate(opts.workflowTemplateId);
             if (template) {
                 orchestrationState.intent = 'workflow';
@@ -354,14 +569,21 @@ class OrchestratorAgent {
                 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, template);
+                    if (this.isLocalDesktopRuntime()) {
+                        const toolDispatchResult = await this.handleUserMessageViaToolDispatch(prompt, conversationId, opts, conversation, conversationProjectId, dispatchOrchestratorBot, orchestrationState, initialProject, template, 'selected_workflow_template');
+                        if (toolDispatchResult !== null) {
+                            return toolDispatchResult;
+                        }
+                        return 'Orchestration could not run the selected workflow: no LLM runtime is attached to the configured orchestrator.';
+                    }
+                    return await this.queueWorkflowTodoPlan(prompt, conversationId, workflowIntent, validation.executionSpec, opts, initialAssignments, initialProject, orchestrationState, selectedOrchestratorActor, template);
                 }
             }
         }
-        const namedWorkflowTemplate = selectedOrchestrator
+        const namedWorkflowTemplate = hasConfiguredOrchestratorRuntime
             ? this.resolveWorkflowTemplateByPrompt(conversationProjectId, prompt)
             : undefined;
-        if (namedWorkflowTemplate && selectedOrchestrator) {
+        if (namedWorkflowTemplate && hasConfiguredOrchestratorRuntime) {
             orchestrationState.intent = 'workflow';
             this.recordOrchestrationAudit(orchestrationState, 'choose_path', 'path_selected', `User explicitly named workflow template: ${namedWorkflowTemplate.name}`, { workflowTemplateId: namedWorkflowTemplate.id });
             const workflowIntent = {
@@ -378,8 +600,34 @@ class OrchestratorAgent {
             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);
+                if (this.isLocalDesktopRuntime()) {
+                    const toolDispatchResult = await this.handleUserMessageViaToolDispatch(prompt, conversationId, opts, conversation, conversationProjectId, dispatchOrchestratorBot, orchestrationState, initialProject, namedWorkflowTemplate, 'named_workflow_template');
+                    if (toolDispatchResult !== null) {
+                        return toolDispatchResult;
+                    }
+                    return 'Orchestration could not run the named workflow: no LLM runtime is attached to the configured orchestrator.';
+                }
+                return await this.queueWorkflowTodoPlan(prompt, conversationId, workflowIntent, validation.executionSpec, opts, initialAssignments, initialProject, orchestrationState, selectedOrchestratorActor, namedWorkflowTemplate);
+            }
+        }
+        if (this.isLocalDesktopRuntime() && hasConfiguredOrchestratorRuntime) {
+            // Phase B of orchestration-plan.txt. For the local_desktop runtime, the
+            // LLM-tool-dispatch path replaces the regex-based front door. All
+            // preflight flows (pendingCheckpoint, pendingPolicy, workflowTemplateId,
+            // namedWorkflowTemplate) have already been handled above — by this
+            // point we are choosing between reply_directly / delegate_single /
+            // create_workflow via the orchestrator LLM. Other runtimes
+            // (connected/server) still use the legacy front door.
+            const toolDispatchResult = await this.handleUserMessageViaToolDispatch(prompt, conversationId, opts, conversation, conversationProjectId, dispatchOrchestratorBot, orchestrationState, initialProject);
+            if (toolDispatchResult !== null) {
+                return toolDispatchResult;
             }
+            // Preconditions unmet in local_desktop. Surface a clear error rather
+            // than fall through to the deprecated regex front door.
+            return 'Orchestration could not run: no LLM runtime is attached to the configured orchestrator. Check Settings -> Orchestration or Settings -> Bots.';
+        }
+        if (this.isLocalDesktopRuntime()) {
+            return 'Orchestration could not run: no orchestrator runtime is configured. Check Settings -> Orchestration or mark a bot as orchestrator in Settings -> Bots.';
         }
         if (selectedOrchestrator) {
             const frontDoorResult = await this.handleOrchestratorFrontDoor(prompt, conversationId, opts, selectedOrchestrator, conversationProjectId, initialProject, initialPolicy, promptAssignments, initialAssignments, initialOverview, orchestrationState);
@@ -414,13 +662,14 @@ class OrchestratorAgent {
         const effectiveProjectId = refreshedConversation?.project_id || resolvedProjectId;
         const effectiveProject = effectiveProjectId ? data.getProject(effectiveProjectId) : undefined;
         const effectivePolicy = data.getEffectiveOrchestrationPolicy(effectiveProjectId || conversationProjectId || undefined);
-        const effectiveOrchestrator = refreshedConversation ? this.resolveSelectedOrchestratorBot(refreshedConversation) : selectedOrchestrator;
-        const effectiveAssignments = this.mergeRoleAssignments(this.policyRoleAssignments(effectivePolicy), effectiveProjectId ? this.loadRoleAssignments(effectiveProjectId) : {}, this.deriveRoleAssignmentsFromProject(effectiveProjectId, effectiveOrchestrator), promptAssignments);
+        const effectiveOrchestrator = this.resolveOrchestratorRuntimeBot(opts.orchestratorBotIdHint) || selectedOrchestrator;
+        const effectiveAssignments = this.mergeRoleAssignments(this.policyRoleAssignments(effectivePolicy), this.deriveRoleAssignmentsFromProject(effectiveProjectId, effectiveOrchestrator), promptAssignments);
         if (effectiveProjectId &&
             this.hasRoleAssignments(promptAssignments) &&
             !this.hasMode(intent, 'POLICY_UPDATE')) {
-            this.persistRoleAssignments(effectiveProjectId, conversationId, refreshedConversation?.agent_id || 'orchestrator', promptAssignments);
-            this.persistPreferredWorkflow(effectiveProjectId, conversationId, refreshedConversation?.agent_id || 'orchestrator', effectiveAssignments);
+            this.persistPreferredWorkflow(effectiveProjectId, conversationId, this.orchestratorRuntime.kind === 'clerk'
+                ? 'clerk-orchestrator'
+                : (effectiveOrchestrator?.id || opts.orchestratorBotIdHint || 'orchestrator'), effectiveAssignments);
         }
         const projectOverview = effectiveProjectId ? data.getProjectOverview(effectiveProjectId) : undefined;
         if (this.isOrchestratorControlMessage(prompt)) {
@@ -564,22 +813,15 @@ class OrchestratorAgent {
     buildFrontDoorEffectivePolicy(policy, orchestratorBot, roleAssignments, taskType) {
         const normalize = (value) => String(value || '').trim().toLowerCase();
         const orchestratorName = normalize(orchestratorBot.name);
-        const roleClass = normalize(orchestratorBot.role_class);
         const codingOwner = normalize(roleAssignments.coding);
         const qaOwner = normalize(roleAssignments.qa);
         const next = { ...policy };
         const orchestratorOwnsCoding = orchestratorName.length > 0
             && (orchestratorName === codingOwner
-                || roleClass === 'code'
-                || roleClass === 'coding'
-                || roleClass === 'coder'
-                || roleClass === 'builder'
-                || roleClass === 'developer');
+                || this.agentHasAnyRole(orchestratorBot, ['code', 'coding', 'coder', 'builder', 'developer']));
         const orchestratorOwnsQa = orchestratorName.length > 0
             && (orchestratorName === qaOwner
-                || roleClass === 'qa'
-                || roleClass === 'review'
-                || roleClass === 'reviewer');
+                || this.agentHasAnyRole(orchestratorBot, ['qa', 'review', 'reviewer']));
         if (taskType === 'coding' && orchestratorOwnsCoding) {
             next.allowOrchestratorCode = true;
         }
@@ -601,67 +843,16 @@ class OrchestratorAgent {
         const mentionedAgents = this.countMentionedAgents(prompt);
         return mentionedAgents === 1 && /\b(ask|let|have|talk to|discuss with|check with)\b/i.test(prompt);
     }
-    applyClassificationGuards(prompt, intent, routingMode) {
-        const before = JSON.stringify({
-            primaryMode: intent.primaryMode,
-            targetAgent: intent.targetAgent || null,
-            needsClarification: !!intent.needsClarification,
-            clarificationQuestions: intent.clarificationQuestions || [],
-        });
-        const targetAgent = this.extractTargetAgentName(prompt) || intent.targetAgent;
-        const needsConcreteArtifact = /\b(this idea|review this idea|code it|qa it|review it|build it|fix it)\b/i.test(prompt)
-            && !this.hasConcreteArtifactDetails(prompt);
-        const explicitWorkflowRoles = this.inferRequestedWorkflowRoles(prompt, {});
-        const explicitWorkflowRequest = explicitWorkflowRoles.length >= 2 && this.hasConcreteArtifactDetails(prompt);
-        if (targetAgent && !intent.targetAgent) {
-            intent.targetAgent = targetAgent;
-        }
-        if (explicitWorkflowRequest) {
-            intent.primaryMode = 'WORKFLOW_MODE';
-            intent.userFacingMode = 'FULL_WORKFLOW';
-            intent.targetScope = 'MULTI_WORKER';
-            intent.isMultiStep = true;
-            intent.intent = 'build';
-            intent.targetAgent = undefined;
-            intent.needsClarification = false;
-            intent.clarificationQuestions = undefined;
-            intent.secondaryModes = intent.secondaryModes.filter((mode) => mode !== 'PROXY_MODE');
-            intent.executionOrder = ['WORKFLOW_MODE'];
-        }
-        if (intent.primaryMode === 'PROXY_MODE' && !intent.targetAgent) {
-            intent.needsClarification = true;
-            intent.clarificationQuestions = Array.from(new Set([
-                ...(intent.clarificationQuestions || []),
-                'Which worker should handle this request?',
-            ]));
-        }
-        if (needsConcreteArtifact &&
-            (intent.primaryMode === 'WORKFLOW_MODE' || intent.primaryMode === 'PROXY_MODE')) {
-            intent.needsClarification = true;
-            intent.clarificationQuestions = Array.from(new Set([
-                ...(intent.clarificationQuestions || []),
-                'What specific idea, artifact, or content should the team work on?',
-            ]));
-        }
-        if (intent.primaryMode === 'WORKFLOW_MODE' && !intent.isMultiStep && intent.targetScope !== 'MULTI_WORKER') {
-            intent.needsClarification = true;
-            intent.clarificationQuestions = Array.from(new Set([
-                ...(intent.clarificationQuestions || []),
-                'What multi-step workflow do you want me to coordinate?',
-            ]));
-        }
-        if (intent.needsClarification && this.hasConcreteArtifactDetails(prompt)) {
-            const remaining = (intent.clarificationQuestions || []).filter((question) => !/specific idea, artifact, or content/i.test(question));
-            intent.clarificationQuestions = remaining.length > 0 ? remaining : undefined;
-            intent.needsClarification = Boolean(intent.clarificationQuestions?.length);
-        }
-        const after = JSON.stringify({
-            primaryMode: intent.primaryMode,
-            targetAgent: intent.targetAgent || null,
-            needsClarification: !!intent.needsClarification,
-            clarificationQuestions: intent.clarificationQuestions || [],
-        });
-        return before !== after;
+    /**
+     * DEPRECATED — returns false. Previously 70+ lines of regex that
+     * post-mutated an IntentAnalysis based on prose signals (bot names,
+     * role keywords, workflow language, concrete-artifact heuristics).
+     * Codex audit HIGH #5 (2026-04-19): runtime must not override mode/
+     * route via regex. The orchestrator LLM decides via structured tool
+     * calls (delegate_single / create_workflow / reply_directly).
+     */
+    applyClassificationGuards(_prompt, _intent, _routingMode) {
+        return false;
     }
     formatOrchestratorControlResponse(prompt, assignments, overview) {
         const lines = [];
@@ -714,82 +905,33 @@ class OrchestratorAgent {
         // Aliases like "claude" → "Ben" cause false matches on every prompt.
         return [agent.name.trim()].filter(Boolean);
     }
-    fallbackClassifyUserMessage(prompt, routingMode) {
-        const normalized = prompt.toLowerCase();
-        const targetAgent = this.extractTargetAgentName(prompt);
-        const hasPolicyLanguage = this.isExplicitPolicyMessage(prompt);
-        const hasMemoryLanguage = /\b(i am going to give you|things to remember|remember this|save this as a rule|project rules)\b/i.test(prompt);
-        const isStatus = /\b(what is happening|status|what is going on|what's going on|where are we|progress update|keep me updated)\b/i.test(prompt);
-        const isGreeting = /\b(hello|hi|hey|are you there|good morning|good afternoon|good evening)\b/i.test(prompt);
-        const needsWorkflow = /\b(todo|workflow|handoff|qa\b|review after|send .* then|first .* then|team workflow|multiple llms)\b/i.test(normalized)
-            || (/\bbrain\b/i.test(prompt) && /\bben\b/i.test(prompt))
-            || (/\bben\b/i.test(prompt) && /\bjohn\b/i.test(prompt));
-        const isProxy = Boolean(targetAgent) || (routingMode === 'proxy' && !hasPolicyLanguage && !isStatus);
-        let primaryMode = 'DIRECT_CONVERSATION';
-        const secondaryModes = [];
-        let intent = 'simple';
-        let isMultiStep = false;
-        if (hasPolicyLanguage) {
-            primaryMode = 'POLICY_UPDATE';
-            intent = 'plan';
-            secondaryModes.push('DIRECT_CONVERSATION');
-        }
-        else if (hasMemoryLanguage) {
-            primaryMode = 'MEMORY_CAPTURE';
-        }
-        else if (isStatus) {
-            primaryMode = 'STATUS_INQUIRY';
-            intent = 'question';
-        }
-        else if (needsWorkflow) {
-            primaryMode = 'WORKFLOW_MODE';
-            intent = 'build';
-            isMultiStep = true;
-        }
-        else if (isProxy) {
-            primaryMode = 'PROXY_MODE';
-            intent = 'discuss';
-        }
-        else if (isGreeting || this.isProjectKnowledgeRequest(prompt) || this.isOrchestratorControlMessage(prompt)) {
-            primaryMode = 'DIRECT_CONVERSATION';
-            intent = 'question';
-        }
-        const executionOrder = [primaryMode];
-        if (hasPolicyLanguage && needsWorkflow && !secondaryModes.includes('WORKFLOW_MODE')) {
-            secondaryModes.push('WORKFLOW_MODE');
-            executionOrder.push('WORKFLOW_MODE');
-        }
+    /**
+     * DEPRECATED — returns a neutral DIRECT_CONVERSATION intent. Previously
+     * 80+ lines of regex on the user prompt classifying into
+     * POLICY_UPDATE / MEMORY_CAPTURE / STATUS_INQUIRY / WORKFLOW_MODE /
+     * PROXY_MODE / DIRECT_CONVERSATION based on bot names and role
+     * keywords. Codex audit HIGH #5 (2026-04-19): runtime must not
+     * infer mode/route from prose. This fallback only runs when the
+     * primary LLM classifier is unavailable (non-local_desktop paths);
+     * returning a neutral default routes to the orchestrator's direct
+     * handling rather than miscategorizing via regex.
+     */
+    fallbackClassifyUserMessage(_prompt, _routingMode) {
         return {
-            primaryMode,
-            secondaryModes,
-            executionOrder,
-            userFacingMode: primaryMode === 'POLICY_UPDATE'
-                ? 'POLICY_CONFIGURATION'
-                : primaryMode === 'STATUS_INQUIRY'
-                    ? 'STATUS_CHECK'
-                    : primaryMode === 'PROXY_MODE'
-                        ? 'ASK_WORKER'
-                        : primaryMode === 'WORKFLOW_MODE'
-                            ? 'FULL_WORKFLOW'
-                            : intent === 'plan'
-                                ? 'PLANNING'
-                                : 'DIRECT_RESPONSE',
-            targetScope: primaryMode === 'PROXY_MODE'
-                ? 'ONE_WORKER'
-                : primaryMode === 'WORKFLOW_MODE'
-                    ? 'MULTI_WORKER'
-                    : 'SELF',
-            confidence: hasPolicyLanguage || isStatus || needsWorkflow || isProxy ? 'MEDIUM' : 'LOW',
-            intent,
+            primaryMode: 'DIRECT_CONVERSATION',
+            secondaryModes: [],
+            executionOrder: ['DIRECT_CONVERSATION'],
+            userFacingMode: 'DIRECT_RESPONSE',
+            targetScope: 'SELF',
+            confidence: 'LOW',
+            intent: 'simple',
             projectMatch: undefined,
             topicMatch: undefined,
-            targetAgent,
-            isMultiStep,
-            reasoning: 'Fallback intent classification',
-            needsClarification: primaryMode === 'PROXY_MODE' && this.isVagueProxyPrompt(prompt),
-            clarificationQuestions: primaryMode === 'PROXY_MODE' && this.isVagueProxyPrompt(prompt)
-                ? [`What specific idea, artifact, or content should ${targetAgent || 'the specialist'} review?`]
-                : undefined,
+            targetAgent: undefined,
+            isMultiStep: false,
+            reasoning: 'Fallback classifier deprecated — neutral direct-conversation default (Codex audit HIGH #5).',
+            needsClarification: false,
+            clarificationQuestions: undefined,
         };
     }
     isExplicitPolicyMessage(prompt) {
@@ -895,6 +1037,7 @@ class OrchestratorAgent {
             this.reportHiddenRoleProgress(opts, 'dispatch_controller', `Routing readiness ping to ${agent.name}`);
             const result = await this.workflowEngine.execute(readinessPrompt, conversationId, agent.id, {
                 apiKey: this.resolveApiKey(agent.provider),
+                abortSignal: opts.abortSignal,
                 disableDecomposition: true,
             });
             if (result.status === 'completed' || result.status === 'partial') {
@@ -1108,14 +1251,686 @@ class OrchestratorAgent {
             .replace(/\n?STATUS:\s*(PASS|FAIL|COMPLETE|BLOCKED|UNKNOWN)\s*$/i, '')
             .trim() || rawText.trim();
     }
-    resolveSelectedOrchestratorBot(conversation) {
-        const conversationBotId = conversation?.agent_id;
-        if (conversationBotId) {
-            const bot = data.getAgentProfile(conversationBotId);
+    /** Summarize a TodoTaskRow.status map ({participant: completed}) into a single label. */
+    // NOTE: module-level helper hoisted below the class; declared here as a forward reference only.
+    summarizeTodoStatus(status) {
+        if (!status || typeof status !== 'object')
+            return 'queued';
+        const values = Object.values(status);
+        if (values.length === 0)
+            return 'queued';
+        if (values.every((v) => v === true))
+            return 'completed';
+        if (values.some((v) => v === true))
+            return 'in_progress';
+        return 'queued';
+    }
+    resolveOrchestratorRuntimeBot(orchestratorBotIdHint) {
+        const hintedBotId = String(orchestratorBotIdHint || '').trim();
+        if (hintedBotId) {
+            const bot = data.getAgentProfile(hintedBotId);
             if (bot)
                 return bot;
         }
-        return data.getOrchestratorBot() || data.getDefaultAgentProfile();
+        // Orchestrator must be explicitly designated via is_orchestrator=1.
+        // No fallback to getDefaultAgentProfile() — that's the hardcoded-Ben trap that
+        // made the default bot double as orchestrator and worker simultaneously.
+        return data.getOrchestratorBot() || undefined;
+    }
+    getOrchestratorDispatchActor(orchestratorBot) {
+        if (orchestratorBot) {
+            return { name: orchestratorBot.name, actorId: orchestratorBot.id, bot: orchestratorBot };
+        }
+        return {
+            name: this.orchestratorRuntime.agentName || 'Orchestrator',
+            actorId: this.orchestratorRuntime.botId || 'clerk-orchestrator',
+        };
+    }
+    /**
+     * Phase A wire-up for orchestration-plan.txt.
+     * Called when `orchestration.tool_dispatch_enabled` flag is ON.
+     * Builds the hint, calls the orchestrator LLM with the three dispatch
+     * tools exposed, validates the tool call, and executes it via the
+     * pure dispatch-executor (creates TODOs or returns a direct reply).
+     *
+     * Returns the user-facing reply string on success. Returns `null` if
+     * preconditions are not met (no orchestrator bot configured, no LLM
+     * runtime available) so the caller can fall back to the legacy path.
+     */
+    async handleUserMessageViaToolDispatch(prompt, conversationId, opts, conversation, conversationProjectId, orchestratorBot, orchestrationState, initialProject, selectedWorkflowTemplate, selectedWorkflowSource = 'selected_workflow_template') {
+        // Dynamic imports — keep dispatch modules isolated.
+        const { runDispatchTurn } = await Promise.resolve().then(() => __importStar(require('./orchestration/dispatch-runner')));
+        const { executeCreateWorkflow } = await Promise.resolve().then(() => __importStar(require('./orchestration/dispatch-executor')));
+        const { computePlanExecutionIntent } = await Promise.resolve().then(() => __importStar(require('./orchestration/dispatch-hint')));
+        // Get an LLM interface to call. For the local_desktop runtime, the
+        // orchestratorRuntime's llm is what we need; for clerk runtime, same.
+        const llm = this.orchestratorRuntime?.llm;
+        if (!llm || typeof llm.chat !== 'function') {
+            return null;
+        }
+        const project = conversationProjectId ? data.getProject(conversationProjectId) : undefined;
+        const effectivePolicy = data.getEffectiveOrchestrationPolicy(conversationProjectId || undefined);
+        const effectivePolicyText = (0, policy_prompt_1.buildEffectivePolicyPromptSection)(effectivePolicy, {
+            heading: '',
+            defaultLine: 'No confirmed special policy is set.',
+        });
+        // Candidate worker bots for dispatch: project-scoped and orchestrator-
+        // profiles excluded (Codex QA 2026-04-18, finding #2). Using
+        // listProjectScopedBots ensures role resolution cannot assign work to
+        // a bot that isn't in the current project roster, and cannot pick
+        // the orchestrator itself as a worker.
+        const activeBots = this.listProjectScopedBots(conversationProjectId || undefined, { includeOrchestratorProfiles: !orchestratorBot })
+            .filter((b) => b.is_active === 1 && (!orchestratorBot || b.id !== orchestratorBot.id));
+        if (selectedWorkflowTemplate) {
+            const existingIds = new Set(activeBots.map((bot) => bot.id));
+            for (const step of selectedWorkflowTemplate.steps) {
+                const bot = data.getAgentProfile(step.agent_id);
+                if (bot && bot.is_active === 1 && !existingIds.has(bot.id)) {
+                    activeBots.push(bot);
+                    existingIds.add(bot.id);
+                }
+            }
+        }
+        const dispatchHintBots = activeBots
+            .filter((bot) => bot.is_active === 1)
+            .map((bot) => ({
+            name: bot.name,
+            provider: bot.provider,
+            model: bot.model || null,
+            role_priorities: data.getAgentRolePriorities(bot),
+            is_active: bot.is_active === 1,
+        }));
+        const planExecutionIntent = computePlanExecutionIntent(prompt, dispatchHintBots);
+        const selectedWorkflowTemplateHint = selectedWorkflowTemplate
+            ? this.buildSelectedWorkflowTemplateHint(selectedWorkflowTemplate)
+            : null;
+        const explicitCandidatePlan = selectedWorkflowTemplateHint || planExecutionIntent.mode !== 'none'
+            ? null
+            : this.buildExplicitBotSequenceCandidatePlan(prompt, activeBots);
+        const candidateWorkflowPlan = planExecutionIntent.mode !== 'none'
+            ? null
+            : selectedWorkflowTemplateHint
+                ? {
+                    source: selectedWorkflowSource,
+                    reason: selectedWorkflowSource === 'named_workflow_template'
+                        ? `User named workflow "${selectedWorkflowTemplate.name}".`
+                        : `User selected workflow "${selectedWorkflowTemplate.name}".`,
+                    steps: selectedWorkflowTemplateHint.steps.map((step) => ({
+                        index: step.index,
+                        bot_name: step.bot_name,
+                        role_priorities: step.role_priorities,
+                        suggested_role: step.role_priorities[0] || null,
+                        confidence: 'high',
+                        reason: `Step comes from selected workflow "${selectedWorkflowTemplate.name}".`,
+                    })),
+                }
+                : explicitCandidatePlan;
+        if (candidateWorkflowPlan) {
+            this.reportCandidateWorkflowProgress(opts, candidateWorkflowPlan);
+        }
+        const orchestratorActor = this.getOrchestratorDispatchActor(orchestratorBot);
+        const contextWindow = conversationId
+            ? (0, context_window_1.getPromptContextWindow)(conversationId, 5)
+            : { summary: null, turns: [], carriedForward: false };
+        const recentTurnsText = contextWindow.turns.length > 0
+            ? (0, context_window_1.formatTurnsForPrompt)(contextWindow.turns)
+            : '';
+        const recentContext = conversationId
+            ? this.buildRecentConversationContextForWorker(conversationId)
+            : '';
+        const isCliDispatchOrchestrator = !!(orchestratorBot && index_1.CLI_PROVIDERS.has(orchestratorBot.provider));
+        const orchestratorCliSessionPlan = isCliDispatchOrchestrator
+            ? (0, cli_session_epoch_1.selectCliSessionEpoch)(conversationId, orchestratorBot.id, orchestratorBot.provider)
+            : null;
+        const orchestratorBootstrapHistoryFilePath = isCliDispatchOrchestrator
+            && !orchestratorCliSessionPlan?.resumeSessionId
+            ? this.prepareBootstrapHistoryFile(conversationId)
+            : null;
+        const recentSummary = contextWindow.summary?.summary_text?.trim() || null;
+        const shouldSendFreshCliFallbackContext = isCliDispatchOrchestrator
+            && !orchestratorCliSessionPlan?.resumeSessionId
+            && !orchestratorBootstrapHistoryFilePath;
+        const dispatchRecentSummary = !isCliDispatchOrchestrator || shouldSendFreshCliFallbackContext
+            ? recentSummary
+            : null;
+        const dispatchRecentTurns = !isCliDispatchOrchestrator || shouldSendFreshCliFallbackContext
+            ? (recentTurnsText || null)
+            : null;
+        if (isCliDispatchOrchestrator && orchestratorBot) {
+            const sessionLaunchReason = orchestratorCliSessionPlan?.resumeSessionId
+                ? 'resumed'
+                : ('mode' in contextWindow && contextWindow.mode === 'new_topic')
+                    ? 'new_topic/no_context'
+                    : 'fresh_with_bootstrap';
+            console.info(`[orchestrator] session_launch_reason=${sessionLaunchReason} botId=${orchestratorBot.id} provider=${orchestratorBot.provider} bootstrap=${!!orchestratorBootstrapHistoryFilePath}`);
+            console.info(`[orchestrator] cli_session_selected conversationId=${conversationId} botId=${orchestratorBot.id} provider=${orchestratorBot.provider} selectedSessionId=${orchestratorCliSessionPlan?.resumeSessionId || '(none)'} resetReason=${orchestratorCliSessionPlan?.resetReason || '(none)'}`);
+            if (orchestratorCliSessionPlan?.resumeSessionId) {
+                console.info(`[orchestrator] cli_session_resuming conversationId=${conversationId} botId=${orchestratorBot.id} provider=${orchestratorBot.provider} sessionId=${orchestratorCliSessionPlan.resumeSessionId}`);
+            }
+            else if ('mode' in contextWindow && contextWindow.mode === 'new_topic') {
+                console.info(`[orchestrator] cli_session_fresh_without_bootstrap_new_topic conversationId=${conversationId} botId=${orchestratorBot.id} provider=${orchestratorBot.provider}`);
+            }
+            else if (orchestratorBootstrapHistoryFilePath) {
+                console.info(`[orchestrator] cli_session_fresh_bootstrap_applied conversationId=${conversationId} botId=${orchestratorBot.id} provider=${orchestratorBot.provider}`);
+            }
+            else {
+                console.warn(`[orchestrator] cli_session_fresh_without_bootstrap_unexpected conversationId=${conversationId} botId=${orchestratorBot.id} provider=${orchestratorBot.provider} mode=${'mode' in contextWindow ? contextWindow.mode : 'unknown'}`);
+            }
+        }
+        const precreatedCandidateTaskIds = candidateWorkflowPlan
+            ? this.createPendingWorkflowProposal({
+                prompt,
+                conversationId,
+                projectId: conversationProjectId || null,
+                orchestratorActor,
+                activeBots,
+                selectedWorkflowTemplateHint,
+                candidateWorkflowPlan,
+                executeCreateWorkflow,
+                recentContext,
+            })
+            : [];
+        const existingTodoRows = data.listActiveTodoTasksForConversation(conversationId);
+        const existingTodos = existingTodoRows.map((t) => ({
+            id: t.id,
+            owner_name: t.owner_name,
+            title: t.title,
+            // TodoTaskRow.status is a participant→boolean map ({"Ben":true,"John":false}).
+            // Derive a human-readable status label for the hint block.
+            status: this.summarizeTodoStatus(t.status),
+        }));
+        const turnCount = conversation?.turn_count || 0;
+        // Read-side tools for the orchestrator. Steven's rule (april19fixes.txt
+        // item 8): the orchestrator handles activities directly when no role-
+        // specific bot applies. These tools let it read files, search the
+        // codebase, look up TODOs, and fetch web content without delegating
+        // trivial reads to worker bots. Write-side tools (write_file,
+        // edit_file, run_command) are deliberately excluded — role
+        // separation still sends those to workers via delegate_single.
+        const { readFileTool } = await Promise.resolve().then(() => __importStar(require('./tools/read-file')));
+        const { listDirectoryTool } = await Promise.resolve().then(() => __importStar(require('./tools/list-directory')));
+        const { searchCodebaseTool } = await Promise.resolve().then(() => __importStar(require('./tools/search-codebase')));
+        const { searchLocalMemoryTool } = await Promise.resolve().then(() => __importStar(require('./tools/search-local-memory')));
+        const { webSearchTool } = await Promise.resolve().then(() => __importStar(require('./tools/web-search')));
+        const { webFetchTool } = await Promise.resolve().then(() => __importStar(require('./tools/web-fetch')));
+        const { listTasksTool } = await Promise.resolve().then(() => __importStar(require('./tools/todo-tasks')));
+        const orchestratorTools = [
+            readFileTool,
+            listDirectoryTool,
+            searchCodebaseTool,
+            searchLocalMemoryTool,
+            webSearchTool,
+            webFetchTool,
+            listTasksTool,
+        ];
+        const workspacePath = project?.folder?.trim() || opts.projectDir;
+        const orchestratorToolContext = (0, index_2.createToolContext)(workspacePath, {
+            runtimeMode: 'local_desktop',
+            projectId: conversationProjectId || null,
+            actorType: 'orchestrator',
+            actorId: orchestratorBot?.id || orchestratorActor.actorId,
+            botName: orchestratorActor.name,
+            llmProvider: this.orchestratorRuntime.providerName,
+            llmModel: this.orchestratorRuntime.model || undefined,
+        });
+        const result = await runDispatchTurn({
+            userPrompt: prompt,
+            orchestratorBot,
+            orchestratorActor,
+            llm,
+            conversationId,
+            projectId: conversationProjectId || null,
+            conversationTitle: conversation?.title || null,
+            topicId: null, // topic_id is not directly on conversation; callers that need it can extend later
+            projectName: project?.name || null,
+            projectFolder: project?.folder || null,
+            turnCount,
+            recentSummary: dispatchRecentSummary,
+            recentTurnsForHint: dispatchRecentTurns,
+            bootstrapHistoryFilePath: orchestratorBootstrapHistoryFilePath,
+            recentContext,
+            activeBots,
+            selectedWorkflowTemplate: selectedWorkflowTemplateHint,
+            candidateWorkflowPlan,
+            precreatedCandidateTaskIds,
+            existingTodos,
+            effectivePolicyText,
+            additionalGuidance: orchestratorBot?.soul_md || null,
+            orchestratorTools,
+            toolContext: orchestratorToolContext,
+        });
+        // Record dispatch outcome in the orchestration audit trail.
+        try {
+            orchestrationState.orchestratorBotId = orchestratorBot?.id || null;
+            this.recordOrchestrationAudit(orchestrationState, 'choose_path', result.outcome.kind === 'error' ? 'blocked' : 'completed', `Tool-dispatch decision: ${result.outcome.kind}`, { outcomeKind: result.outcome.kind });
+        }
+        catch {
+            // audit best-effort
+        }
+        this.setLastResponseMeta({
+            agentName: 'Orchestrator',
+            botId: orchestratorBot?.id || null,
+            modelLabel: this.orchestratorRuntime.modelLabel || orchestratorBot?.model || null,
+        });
+        // reply_directly and error cases have no worker chain to run — return
+        // immediately with the LLM's (or error) text.
+        if (result.outcome.kind === 'reply_directly' || result.outcome.kind === 'error') {
+            return result.userReplyText;
+        }
+        // delegate_single / create_workflow created TODOs. Fix for Codex QA
+        // 2026-04-18 finding #1: the new path must EXECUTE the queued chain,
+        // not just return a "queued" summary. Reuse the existing
+        // dispatchQueuedTodoChain which walks active TODOs for this conversation
+        // and runs each through workflowEngine.execute(). Without this, TODOs
+        // would be orphaned in the queue with no worker ever picking them up.
+        const createdTaskIds = [];
+        if (result.outcome.kind === 'delegate_single') {
+            const id = Number(result.outcome.taskId);
+            if (Number.isFinite(id))
+                createdTaskIds.push(id);
+        }
+        else if (result.outcome.kind === 'create_workflow') {
+            for (const tid of result.outcome.taskIds) {
+                const id = Number(tid);
+                if (Number.isFinite(id))
+                    createdTaskIds.push(id);
+            }
+        }
+        if (createdTaskIds.length > 0) {
+            this.markConversationOrchestrated(conversationId);
+        }
+        if (opts.autoDispatchTodos === false) {
+            const replyText = selectedWorkflowTemplate && result.outcome.kind === 'create_workflow'
+                ? `Queued workflow from "${selectedWorkflowTemplate.name}".\n${result.userReplyText}`
+                : result.userReplyText;
+            orchestrationState.finalResponseDraft = replyText;
+            return replyText;
+        }
+        return await this.dispatchQueuedTodoChain(conversationId, opts, orchestrationState, orchestratorActor, initialProject, {
+            taskIds: createdTaskIds,
+            workflowName: result.outcome.kind === 'create_workflow' ? (selectedWorkflowTemplate?.name || 'tool_dispatch_workflow') : null,
+        });
+    }
+    async importPlanAsTodos(input) {
+        const { executeCreateWorkflow } = await Promise.resolve().then(() => __importStar(require('./orchestration/dispatch-executor')));
+        const { buildDispatchValidationContext, validateCreateWorkflow } = await Promise.resolve().then(() => __importStar(require('./orchestration/dispatch-tools')));
+        const project = data.getProject(input.projectId);
+        const activeBots = this.listProjectScopedBots(input.projectId || undefined, {
+            includeOrchestratorProfiles: true,
+        }).filter((bot) => bot.is_active === 1);
+        if (activeBots.length === 0) {
+            throw new Error('No active bots are assigned to this project.');
+        }
+        const selectedStages = (input.stages || [])
+            .map((stage) => ({
+            role: String(stage?.role || '').trim(),
+            botId: String(stage?.botId || '').trim(),
+        }))
+            .filter((stage) => stage.role && stage.botId);
+        if (selectedStages.length === 0) {
+            throw new Error('Choose at least one stage and bot for the imported workflow.');
+        }
+        const plannerBot = this.resolvePlanImportBot(input.plannerBotId, input.projectId, input.orchestratorBot || null);
+        const plannerRuntime = plannerBot && input.orchestratorBot && plannerBot.id === input.orchestratorBot.id
+            ? this.orchestratorRuntime
+            : buildLocalDesktopRuntimeFromProfile(plannerBot);
+        const effectiveExecutionOrder = input.executionOrder === 'batch_by_stage' || input.executionOrder === 'per_item_pipeline'
+            ? input.executionOrder
+            : (0, plan_import_1.detectExecutionOrder)(input.plannerInstructions || null);
+        const stageHints = selectedStages.map((stage) => {
+            const stageBot = activeBots.find((bot) => bot.id === stage.botId);
+            if (!stageBot) {
+                throw new Error(`Plan import stage bot is not active in this project: ${stage.botId}`);
+            }
+            return {
+                role: stage.role,
+                botName: stageBot.name,
+            };
+        });
+        const promptInput = {
+            filePath: input.filePath,
+            fileContent: input.fileContent,
+            mode: input.mode,
+            stages: stageHints,
+            plannerInstructions: input.plannerInstructions || null,
+            executionOrder: effectiveExecutionOrder,
+            availableBots: activeBots.map((bot) => ({
+                name: bot.name,
+                provider: bot.provider,
+                model: bot.model || null,
+                rolePriorities: data.getAgentRolePriorities(bot),
+            })),
+            projectName: project?.name || null,
+            projectFolder: project?.folder || input.opts.projectDir,
+        };
+        const systemPrompt = (0, plan_import_1.buildPlanImportSystemPrompt)(promptInput);
+        const messages = [
+            { role: 'user', content: (0, plan_import_1.buildPlanImportUserPrompt)(promptInput) },
+        ];
+        const validationContext = buildDispatchValidationContext(activeBots);
+        let workflowArgs = null;
+        let lastError = '';
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            const rawContent = await this.runPlanImportPlannerTurn({
+                plannerRuntime,
+                plannerBot,
+                conversationId: input.conversationId,
+                projectId: input.projectId,
+                workspacePath: project?.folder || input.opts.projectDir,
+                systemPrompt,
+                messages,
+                abortSignal: input.opts.abortSignal,
+            });
+            const parsed = (0, plan_import_1.extractPlanImportResponse)(rawContent);
+            if (parsed.error) {
+                if (parsed.error === 'Planner authentication failed.') {
+                    lastError = `${plannerRuntime.agentName} could not authenticate. Check ${plannerRuntime.agentName}'s connection in Settings and retry.`;
+                }
+                else {
+                    lastError = parsed.error;
+                }
+            }
+            else if (parsed.workflow) {
+                const validation = validateCreateWorkflow(parsed.workflow, validationContext);
+                if (validation.ok) {
+                    const detailValidation = (0, plan_import_1.validatePlanImportWorkflow)(parsed.workflow);
+                    if (!detailValidation.ok) {
+                        lastError = detailValidation.error || 'Imported workflow steps were too sparse.';
+                    }
+                    else if (effectiveExecutionOrder === 'batch_by_stage') {
+                        const orderValidation = (0, plan_import_1.validateBatchByStageOrdering)(parsed.workflow, stageHints);
+                        if (!orderValidation.ok) {
+                            lastError = orderValidation.error || 'Planner output interleaves stages instead of batching them.';
+                        }
+                        else {
+                            workflowArgs = parsed.workflow;
+                            break;
+                        }
+                    }
+                    else {
+                        workflowArgs = parsed.workflow;
+                        break;
+                    }
+                }
+                else {
+                    lastError = validation.error;
+                }
+            }
+            else {
+                lastError = 'Planner did not return a workflow.';
+            }
+            const plannerSnippet = rawContent
+                .replace(/\s+/g, ' ')
+                .slice(0, 300);
+            console.warn(`[plan-import] invalid planner response attempt=${attempt + 1}/2 planner=${plannerRuntime.agentName} mode=${input.mode} error=${lastError} snippet="${plannerSnippet}"`);
+            if (parsed.error === 'Planner authentication failed.') {
+                break;
+            }
+            messages.push({ role: 'assistant', content: rawContent });
+            messages.push({
+                role: 'user',
+                content: `The previous output was invalid: ${lastError}\nReturn corrected workflow step blocks only. Do not add prose before or after the workflow. Fully materialize every task with Files:, Do:/Verify:, and success criteria.`,
+            });
+        }
+        if (!workflowArgs) {
+            throw new Error(lastError || 'Planner could not produce a valid workflow import.');
+        }
+        const orchestratorActor = this.getOrchestratorDispatchActor(input.orchestratorBot || null);
+        const existingTodoRows = data.listActiveTodoTasksForConversation(input.conversationId);
+        const executionContext = {
+            conversationId: input.conversationId,
+            projectId: input.projectId,
+            orchestratorActor,
+            resolution: {
+                activeBots,
+                botsWithActiveTodos: new Set(existingTodoRows.map((row) => row.owner_name).filter(Boolean)),
+            },
+            userPrompt: `Imported plan from ${path.basename(input.filePath)} using ${plannerRuntime.agentName}.`,
+            recentContext: null,
+            workflowSourceLabel: `Imported plan ${path.basename(input.filePath)}`,
+        };
+        const result = executeCreateWorkflow(workflowArgs, executionContext);
+        if (result.kind === 'error') {
+            throw new Error(result.error);
+        }
+        const taskIds = result.tasks.map((task) => Number(task.id)).filter((id) => Number.isFinite(id));
+        const ownerNames = Array.from(new Set(result.tasks.map((task) => task.owner_name).filter(Boolean)));
+        const planRun = data.createImportedPlanRun({
+            conversationId: input.conversationId,
+            projectId: input.projectId,
+            sourceFilePath: input.filePath,
+            sourceFileName: path.basename(input.filePath),
+            plannerBotId: plannerBot.id,
+            plannerAgentName: plannerRuntime.agentName,
+            plannerProvider: plannerRuntime.providerName,
+            plannerModel: plannerRuntime.model,
+            requestedStages: selectedStages,
+            requestedOptions: {
+                plannerInstructions: input.plannerInstructions || null,
+                executionOrder: effectiveExecutionOrder,
+            },
+            taskIds,
+            status: input.autoDispatchTodos ? 'running' : 'paused',
+        });
+        if (input.autoDispatchTodos) {
+            const state = (0, state_1.createOrchestrationState)({
+                conversationId: input.conversationId,
+                projectId: input.projectId,
+                orchestratorBotId: input.orchestratorBot?.id || this.orchestratorRuntime.botId || null,
+                userPromptRaw: `Imported plan ${path.basename(input.filePath)}`,
+            });
+            state.selectedPath = 'delegate';
+            await this.dispatchQueuedTodoChain(input.conversationId, input.opts, state, orchestratorActor, project, {
+                taskIds,
+                workflowName: path.basename(input.filePath),
+            });
+        }
+        const fileLabel = path.basename(input.filePath);
+        const pausedText = input.autoDispatchTodos ? 'and started the workflow' : 'and left the workflow paused for review';
+        return {
+            planRunId: planRun.id,
+            replyText: `Imported ${fileLabel} into ${result.tasks.length} TODOs ${pausedText}. Planner: ${plannerRuntime.agentName}${plannerRuntime.model ? ` (${plannerRuntime.model})` : ''}.`,
+            taskIds,
+            ownerNames,
+            planner: {
+                botId: plannerBot.id,
+                provider: plannerRuntime.providerName,
+                model: plannerRuntime.model,
+                agentName: plannerRuntime.agentName,
+            },
+        };
+    }
+    async startImportedPlanRun(input) {
+        const run = data.getImportedPlanRun(input.runId);
+        if (!run) {
+            throw new Error(`Imported plan run not found: ${input.runId}`);
+        }
+        if (run.status === 'discarded') {
+            throw new Error('This imported plan was discarded and cannot be started.');
+        }
+        const project = run.project_id ? data.getProject(run.project_id) : undefined;
+        const remainingTaskIds = data.getImportedPlanRunRemainingTaskIds(run.id);
+        if (remainingTaskIds.length === 0) {
+            const completedRun = data.updateImportedPlanRun(run.id, {
+                status: 'completed',
+                completedAt: run.completed_at || new Date().toISOString(),
+                lastError: null,
+            }) || run;
+            return {
+                run: completedRun,
+                replyText: `Imported plan ${run.source_file_name} is already complete.`,
+                remainingTaskIds: [],
+                completed: true,
+            };
+        }
+        const orchestratorActor = this.getOrchestratorDispatchActor(input.orchestratorBot || null);
+        const state = (0, state_1.createOrchestrationState)({
+            conversationId: run.conversation_id,
+            projectId: run.project_id || null,
+            orchestratorBotId: input.orchestratorBot?.id || this.orchestratorRuntime.botId || null,
+            userPromptRaw: `Resume imported plan ${run.source_file_name}`,
+        });
+        state.selectedPath = 'delegate';
+        data.updateImportedPlanRun(run.id, {
+            status: 'running',
+            startedAt: run.started_at || new Date().toISOString(),
+            completedAt: null,
+            discardedAt: null,
+            lastError: null,
+        });
+        let replyText = '';
+        try {
+            replyText = await this.dispatchQueuedTodoChain(run.conversation_id, input.opts, state, orchestratorActor, project, {
+                taskIds: remainingTaskIds,
+                workflowName: run.source_file_name,
+            });
+        }
+        catch (err) {
+            const pausedRun = data.updateImportedPlanRun(run.id, {
+                status: 'paused',
+                lastError: err?.message || 'Imported plan execution failed.',
+            }) || run;
+            return {
+                run: pausedRun,
+                replyText: err?.message || 'Imported plan execution failed.',
+                remainingTaskIds: data.getImportedPlanRunRemainingTaskIds(run.id),
+                completed: false,
+            };
+        }
+        const remainingAfter = data.getImportedPlanRunRemainingTaskIds(run.id);
+        const completed = remainingAfter.length === 0;
+        const updatedRun = data.updateImportedPlanRun(run.id, {
+            status: completed ? 'completed' : 'paused',
+            completedAt: completed ? new Date().toISOString() : null,
+            lastError: completed ? null : (replyText || state.finalResponseDraft || null),
+        }) || run;
+        return {
+            run: updatedRun,
+            replyText,
+            remainingTaskIds: remainingAfter,
+            completed,
+        };
+    }
+    buildDirectExecutionSystemPrompt(prompt, conversationId, project) {
+        const contextWindow = conversationId
+            ? (0, context_window_1.getPromptContextWindow)(conversationId, 5)
+            : { summary: null, turns: [], carriedForward: false };
+        const recentTurnsText = (0, context_window_1.formatTurnsForPrompt)(contextWindow.turns) || '(none)';
+        const recentSummaryText = contextWindow.summary?.summary_text?.trim()
+            ? `${contextWindow.carriedForward ? '(carried forward from the previous conversation in this topic)\n' : ''}${contextWindow.summary.summary_text.trim()}`
+            : '(none)';
+        return [
+            'You are the user-facing Orchestrator in Funolio local desktop mode.',
+            'You are handling this request directly.',
+            'Use the available tools whenever they are helpful.',
+            'Do not delegate, do not create workflow TODOs, and do not claim another bot is doing the work.',
+            'If the user asked to read, inspect, summarize, or show a file, do that directly.',
+            'If the user asked to update plain-text notes, plans, summaries, or TODO-like content, do that directly.',
+            'If you cannot complete the request directly, explain the concrete blocker briefly.',
+            '',
+            '[Project Context]',
+            `Project: ${project?.name || '(none)'}`,
+            `Workspace: ${project?.folder || '(none)'}`,
+            '',
+            '[Rolling Summary]',
+            recentSummaryText,
+            '',
+            '[Recent Turns]',
+            recentTurnsText,
+            '',
+            '[Current Request]',
+            prompt,
+        ].join('\n');
+    }
+    async executeClerkOwnedWorkDirect(prompt, conversationId, orchestratorBot, project, opts) {
+        const systemPrompt = this.buildDirectExecutionSystemPrompt(prompt, conversationId, project);
+        const workspacePath = project?.folder?.trim() || opts.projectDir;
+        const toolContext = (0, index_2.createToolContext)(workspacePath, {
+            runtimeMode: 'local_desktop',
+            projectId: project?.id || opts.projectId || null,
+            actorType: 'orchestrator',
+            actorId: 'Orchestrator',
+            botName: 'Orchestrator',
+            llmProvider: this.orchestratorRuntime.providerName,
+            llmModel: this.orchestratorRuntime.model || undefined,
+        });
+        const toolDefinitions = (0, index_2.getAllToolDefinitions)('local_desktop');
+        const messages = [{ role: 'user', content: prompt }];
+        const permissionMode = (orchestratorBot.permission_mode || 'autopilot');
+        for (let iteration = 0; iteration < 8; iteration++) {
+            const response = await this.orchestratorRuntime.llm.chat({
+                messages,
+                system: systemPrompt,
+                stream: true,
+                tools: toolDefinitions,
+                toolChoice: 'auto',
+                runtimeMode: 'local_desktop',
+                onChunk: opts.onWorkerChunk
+                    ? async (chunk) => {
+                        if (!chunk)
+                            return;
+                        opts.onWorkerChunk?.({
+                            type: 'chunk',
+                            text: chunk,
+                            stepId: 'orchestrator-direct',
+                            agentName: 'Orchestrator',
+                            description: 'Direct orchestrator work',
+                            stepIndex: 0,
+                            totalSteps: 1,
+                        });
+                    }
+                    : undefined,
+            });
+            if (response.toolCalls?.length) {
+                messages.push({
+                    role: 'assistant',
+                    content: response.content || '',
+                    toolCalls: response.toolCalls,
+                });
+                for (const tc of response.toolCalls) {
+                    const approval = (0, approval_1.checkPermission)(tc.name, permissionMode);
+                    if (!approval.approved) {
+                        throw new Error(`APPROVAL_REQUIRED: ${approval.reason}`);
+                    }
+                    opts.onWorkerChunk?.({
+                        type: 'tool_call',
+                        text: '',
+                        stepId: 'orchestrator-direct',
+                        agentName: 'Orchestrator',
+                        description: 'Direct orchestrator work',
+                        stepIndex: 0,
+                        totalSteps: 1,
+                        toolCallId: tc.id,
+                        toolName: tc.name,
+                        toolArguments: tc.arguments,
+                    });
+                    const result = await (0, index_2.executeAndVerify)({ id: tc.id, name: tc.name, arguments: tc.arguments }, toolContext);
+                    const output = result.success ? result.output : `ERROR: ${result.error || 'Unknown'}`;
+                    messages.push({
+                        role: 'tool',
+                        content: output,
+                        toolCallId: tc.id,
+                        toolName: tc.name,
+                    });
+                    opts.onWorkerChunk?.({
+                        type: 'tool_result',
+                        text: '',
+                        stepId: 'orchestrator-direct',
+                        agentName: 'Orchestrator',
+                        description: 'Direct orchestrator work',
+                        stepIndex: 0,
+                        totalSteps: 1,
+                        toolCallId: tc.id,
+                        toolName: tc.name,
+                        toolOutput: output.length > 500 ? `${output.slice(0, 500)}...` : output,
+                        toolIsError: !result.success,
+                    });
+                }
+                continue;
+            }
+            return String(response.content || '').trim();
+        }
+        throw new Error('Orchestrator direct execution exceeded the maximum tool iterations.');
     }
     async handleOrchestratorFrontDoor(prompt, conversationId, opts, orchestratorBot, projectId, project, policy, promptAssignments, roleAssignments, overview, state) {
         (0, state_1.addHelperRoleUsage)(state, 'orchestrator_front_door');
@@ -1133,7 +1948,7 @@ class OrchestratorAgent {
         const PURE_ORCHESTRATOR_ROLES = new Set(['orchestrator', 'project manager']);
         const specialists = allProfiles
             .filter((agent) => {
-            const rc = String(agent.role_class || '').trim().toLowerCase();
+            const rc = this.getOrchestrationRoleClass(agent);
             if (agent.is_orchestrator === 1 && PURE_ORCHESTRATOR_ROLES.has(rc))
                 return false;
             if (!agent.is_orchestrator && (0, orchestrator_profile_1.isOrchestratorProfile)(agent))
@@ -1142,14 +1957,14 @@ class OrchestratorAgent {
         })
             .map((agent) => ({
             name: agent.name,
-            roleLabel: agent.role_label || agent.role_class || 'general',
+            roleLabel: this.getOrchestrationRoleLabel(agent),
             references: this.getAgentRoutingReferences(agent),
             responsibilities: this.describeAgentResponsibilities(agent),
         }));
         const signalSpecialists = allProfiles
             .map((agent) => ({
             name: agent.name,
-            roleLabel: agent.role_label || agent.role_class || 'general',
+            roleLabel: this.getOrchestrationRoleLabel(agent),
             references: this.getAgentRoutingReferences(agent),
             responsibilities: this.describeAgentResponsibilities(agent),
         }));
@@ -1181,16 +1996,52 @@ class OrchestratorAgent {
             });
         }
         const useSinglePassOrchestrator = this.isLocalDesktopRuntime() && this.orchestratorRuntime.kind === 'bot';
+        const orchestratorCliSessionPlan = useSinglePassOrchestrator
+            && conversationId
+            && index_1.CLI_PROVIDERS.has(orchestratorBot.provider)
+            ? (0, cli_session_epoch_1.selectCliSessionEpoch)(conversationId, orchestratorBot.id, orchestratorBot.provider)
+            : null;
+        const orchestratorBootstrapHistoryFilePath = this.isLocalDesktopRuntime()
+            && conversationId
+            && index_1.CLI_PROVIDERS.has(orchestratorBot.provider)
+            && !orchestratorCliSessionPlan?.resumeSessionId
+            ? this.prepareBootstrapHistoryFile(conversationId)
+            : null;
         const localPromptContract = useSinglePassOrchestrator
             ? (index_1.CLI_PROVIDERS.has(orchestratorBot.provider)
                 && conversationId
-                && !!(0, cli_session_epoch_1.selectCliSessionEpoch)(conversationId, orchestratorBot.id, orchestratorBot.provider).resumeSessionId
+                && !!orchestratorCliSessionPlan?.resumeSessionId
                 ? 'cli_recurring'
                 : 'api_or_fresh_cli')
             : 'legacy';
+        if (useSinglePassOrchestrator && index_1.CLI_PROVIDERS.has(orchestratorBot.provider)) {
+            const sessionLaunchReason = orchestratorCliSessionPlan?.resumeSessionId
+                ? 'resumed'
+                : ('mode' in contextWindow && contextWindow.mode === 'new_topic')
+                    ? 'new_topic/no_context'
+                    : 'fresh_with_bootstrap';
+            console.info(`[orchestrator-front-door] session_launch_reason=${sessionLaunchReason} botId=${orchestratorBot.id} provider=${orchestratorBot.provider} bootstrap=${!!orchestratorBootstrapHistoryFilePath}`);
+            console.info(`[orchestrator-front-door] cli_session_selected conversationId=${conversationId} botId=${orchestratorBot.id} provider=${orchestratorBot.provider} selectedSessionId=${orchestratorCliSessionPlan?.resumeSessionId || '(none)'} resetReason=${orchestratorCliSessionPlan?.resetReason || '(none)'}`);
+            if (orchestratorCliSessionPlan?.resumeSessionId) {
+                console.info(`[orchestrator-front-door] cli_session_resuming conversationId=${conversationId} botId=${orchestratorBot.id} provider=${orchestratorBot.provider} sessionId=${orchestratorCliSessionPlan.resumeSessionId}`);
+            }
+            else if ('mode' in contextWindow && contextWindow.mode === 'new_topic') {
+                console.info(`[orchestrator-front-door] cli_session_fresh_without_bootstrap_new_topic conversationId=${conversationId} botId=${orchestratorBot.id} provider=${orchestratorBot.provider}`);
+            }
+            else if (orchestratorBootstrapHistoryFilePath) {
+                console.info(`[orchestrator-front-door] cli_session_fresh_bootstrap_applied conversationId=${conversationId} botId=${orchestratorBot.id} provider=${orchestratorBot.provider}`);
+            }
+            else {
+                console.warn(`[orchestrator-front-door] cli_session_fresh_without_bootstrap_unexpected conversationId=${conversationId} botId=${orchestratorBot.id} provider=${orchestratorBot.provider} mode=${'mode' in contextWindow ? contextWindow.mode : 'unknown'}`);
+            }
+        }
+        const isClerkRuntime = this.orchestratorRuntime.kind === 'clerk';
+        const orchestratorDisplayName = isClerkRuntime && !orchestratorBot.is_orchestrator
+            ? 'Orchestrator'
+            : orchestratorBot.name;
         const operatingPrompt = (0, orchestrator_operating_prompt_1.buildOrchestratorOperatingPrompt)({
-            orchestratorName: orchestratorBot.name,
-            primaryRole: orchestratorBot.role_label || orchestratorBot.role_class || null,
+            orchestratorName: orchestratorDisplayName,
+            primaryRole: isClerkRuntime ? 'project manager' : data.getAgentOrchestrationRoleLabel(orchestratorBot),
             specialists,
             workflowNames,
             localPromptContract,
@@ -1212,7 +2063,9 @@ class OrchestratorAgent {
             }),
             recentSummary: recentSummaryText,
             lastFiveTurns: recentTurnsText,
+            bootstrapHistoryFilePath: orchestratorBootstrapHistoryFilePath,
             decisionOnly: !useSinglePassOrchestrator,
+            defaultBotName: data.getDefaultAgentProfile()?.name || roleAssignments.coding || null,
         });
         const decisionPrompt = [
             'This is a routing decision only. Do not perform the task.',
@@ -1223,19 +2076,21 @@ class OrchestratorAgent {
             'Return strict JSON only.',
         ].join('\n');
         let decision = null;
-        this.reportHiddenRoleProgress(opts, 'orchestrator', 'Understanding request');
-        let understandingHeartbeat = setInterval(() => {
-            this.reportHiddenRoleProgress(opts, 'orchestrator', 'Still understanding the request');
-        }, 8_000);
+        // No robotic 'Understanding request' progress message — the streamed
+        // narration from the LLM front-door call is what the user sees instead.
+        // Heartbeat removed for the same reason.
+        let understandingHeartbeat = setInterval(() => { }, 1_000_000);
         try {
             if (useSinglePassOrchestrator) {
                 const result = await this.runNodeWithRetry('understand_request', state, async () => this.workflowEngine.execute(prompt, conversationId, orchestratorBot.id, {
+                    abortSignal: opts.abortSignal,
                     disableDecomposition: true,
                     isOrchestrated: false,
                     projectId: projectId || null,
                     workspacePath: project?.folder?.trim() || undefined,
                     persistConversationMessages: false,
                     workerMode: false,
+                    storedAttachments: opts.storedAttachments,
                     systemPromptOverride: operatingPrompt,
                     onWorkerChunk: opts.onWorkerChunk,
                     onProgress: (progress) => {
@@ -1263,6 +2118,8 @@ class OrchestratorAgent {
                     projectId: projectId || null,
                     workspacePath: project?.folder?.trim() || undefined,
                     disableTools: true,
+                    abortSignal: opts.abortSignal,
+                    onNarrationChunk: this.makeOrchestratorNarrationForwarder(opts, orchestratorBot),
                 }));
                 decision = (0, orchestrator_operating_prompt_1.parseOrchestratorFrontDoorDecision)(rawDecision);
             }
@@ -1322,7 +2179,20 @@ class OrchestratorAgent {
                 };
             }
         }
-        return this.handleFrontDoorDecision(decision, prompt, conversationId, opts, orchestratorBot, projectId, project, policy, promptAssignments, roleAssignments, overview, state, signalSpecialists, workflowNames);
+        // Fallback narration: if the decision has no narration (LLM call failed
+        // or returned a code-fallback decision), synthesize a short factual one
+        // and emit it so the user sees something natural in the orchestrator card.
+        // Pass roleAssignments so workflow fallbacks can use real worker names.
+        if (decision && !decision.narration?.trim()) {
+            const fallbackText = this.synthesizeFallbackNarration(decision, roleAssignments);
+            if (fallbackText) {
+                decision.narration = fallbackText;
+                const forwarder = this.makeOrchestratorNarrationForwarder(opts, orchestratorBot);
+                if (forwarder)
+                    forwarder(fallbackText);
+            }
+        }
+        return this.handleFrontDoorDecision(decision, prompt, conversationId, opts, orchestratorBot, projectId, project, policy, promptAssignments, roleAssignments, overview, state, frontDoorSignals, signalSpecialists, workflowNames);
     }
     buildFrontDoorSystemSuggestion(prompt, frontDoorSignals, promptAssignments, roleAssignments) {
         const normalizeName = (value) => String(value || '').trim().toLowerCase();
@@ -1367,7 +2237,7 @@ class OrchestratorAgent {
             delegateRole,
         };
     }
-    async handleFrontDoorDecision(decision, prompt, conversationId, opts, orchestratorBot, projectId, project, policy, promptAssignments, roleAssignments, overview, state, signalSpecialists, workflowNames) {
+    async handleFrontDoorDecision(decision, prompt, conversationId, opts, orchestratorBot, projectId, project, policy, promptAssignments, roleAssignments, overview, state, frontDoorSignals, signalSpecialists, workflowNames) {
         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;
@@ -1375,21 +2245,16 @@ class OrchestratorAgent {
         const highRiskPrompt = this.isHighRiskPrompt(prompt);
         state.riskLevel = highRiskPrompt ? 'high' : state.riskLevel;
         this.recordOrchestrationAudit(state, 'risk_gate', 'risk_assessed', highRiskPrompt ? 'Prompt matched high-risk action patterns.' : 'No high-risk action patterns matched before execution.', { highRiskPrompt });
-        const normalizedDecision = (0, front_door_policy_1.applyFrontDoorPolicy)({
-            prompt,
-            initialDecision: decision,
-            orchestratorName: orchestratorBot.name,
-            orchestratorRoleClass: orchestratorBot.role_class,
-            promptAssignments,
-            roleAssignments,
-            specialists: signalSpecialists,
-            workflowNames,
-            highRisk: highRiskPrompt,
-        });
-        if (normalizedDecision.corrected) {
-            (0, state_1.markMisrouteCorrected)(state);
-        }
-        decision = normalizedDecision.decision;
+        const normalizedDecision = {
+            decision,
+            corrected: false,
+            correctionReason: undefined,
+            taskType: (0, front_door_policy_1.inferFrontDoorTaskType)(prompt),
+            qaMode: 'none',
+            preferredWorkflowRequested: frontDoorSignals.matchedWorkflowNames.length > 0,
+            explicitWorkflowRequested: frontDoorSignals.explicitOrchestrationRequested,
+            signals: frontDoorSignals,
+        };
         state.intent = decision.mode;
         state.taskType = normalizedDecision.taskType;
         this.recordOrchestrationAudit(state, 'choose_path', 'path_selected', normalizedDecision.correctionReason || decision.reason || `Orchestrator selected ${decision.mode}.`, {
@@ -1432,42 +2297,39 @@ class OrchestratorAgent {
             return response;
         }
         if (decision.mode === 'execute_self') {
-            if (this.orchestratorRuntime.kind === 'clerk') {
-                const fallbackDelegateTarget = roleAssignments.coding
-                    || data.getDefaultAgentProfile()?.name
-                    || data.listAgentProfiles().find((agent) => !(0, orchestrator_profile_1.isOrchestratorProfile)(agent))?.name;
-                if (fallbackDelegateTarget) {
-                    const delegateIntent = {
-                        primaryMode: 'PROXY_MODE',
-                        secondaryModes: [],
-                        executionOrder: ['PROXY_MODE'],
-                        userFacingMode: 'ASK_WORKER',
-                        targetScope: 'ONE_WORKER',
-                        confidence: 'MEDIUM',
-                        intent: normalizedDecision.taskType === 'qa'
-                            ? 'review'
-                            : normalizedDecision.taskType === 'research'
-                                ? 'brainstorm'
-                                : 'build',
-                        targetAgent: fallbackDelegateTarget,
-                        isMultiStep: false,
-                        reasoning: 'Clerk orchestrator cannot own implementation work directly, so the task falls back to the default worker.',
-                    };
-                    const delegatePrompt = prompt;
-                    const executionSpec = this.buildFrontDoorDelegateExecutionSpec(delegatePrompt, delegateIntent, fallbackDelegateTarget);
-                    const guardrailQuestions = this.buildDeterministicGuardrailQuestions(executionSpec, roleAssignments, delegateIntent);
-                    if (guardrailQuestions.length > 0) {
-                        return this.formatClarificationResponse({ ...delegateIntent, clarificationQuestions: guardrailQuestions }, overview);
-                    }
-                    this.applyExecutionSpecToState(state, executionSpec);
-                    return this.handleProxyRequest(delegatePrompt, conversationId, delegateIntent, opts, executionSpec, 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);
-            return directResult.response;
+            if (directResult.ok) {
+                return directResult.response;
+            }
+            const fallbackAgent = this.resolveDefaultFallbackAgent(project?.id || state.projectId || undefined, orchestratorBot, roleAssignments);
+            if (!fallbackAgent) {
+                return directResult.response;
+            }
+            const fallbackIntent = {
+                primaryMode: 'PROXY_MODE',
+                secondaryModes: [],
+                executionOrder: ['PROXY_MODE'],
+                userFacingMode: 'ASK_WORKER',
+                targetScope: 'ONE_WORKER',
+                confidence: 'MEDIUM',
+                intent: normalizedDecision.taskType === 'qa'
+                    ? 'review'
+                    : normalizedDecision.taskType === 'research'
+                        ? 'brainstorm'
+                        : 'build',
+                targetAgent: fallbackAgent.name,
+                isMultiStep: false,
+                reasoning: `${orchestratorBot.name} could not complete the kept task, so it is falling back to default bot ${fallbackAgent.name}.`,
+            };
+            const fallbackExecutionSpec = this.buildFrontDoorDelegateExecutionSpec(prompt, fallbackIntent, fallbackAgent.name);
+            this.applyExecutionSpecToState(state, fallbackExecutionSpec);
+            this.recordOrchestrationAudit(state, 'delegate_specialist', 'delegated', `${orchestratorBot.name} could not finish the kept task, so it is falling back to default bot ${fallbackAgent.name}.`, {
+                targetAgentId: fallbackAgent.id,
+                targetAgentName: fallbackAgent.name,
+                fallbackReason: directResult.error || null,
+            });
+            return this.handleProxyRequest(prompt, conversationId, fallbackIntent, opts, fallbackExecutionSpec, roleAssignments, state);
         }
         if (decision.mode === 'delegate') {
             const delegateTarget = this.resolveDelegatedAgentName(decision, roleAssignments);
@@ -1509,7 +2371,7 @@ class OrchestratorAgent {
             if (executionSpec.requiresConfirmation) {
                 return this.createConfirmationCheckpoint(delegatePrompt, conversationId, delegateIntent, executionSpec, projectId, roleAssignments, state);
             }
-            return await this.queueDelegateTodo(delegatePrompt, conversationId, delegateIntent, opts, executionSpec, roleAssignments, state, orchestratorBot, delegateTarget);
+            return await this.queueDelegateTodo(delegatePrompt, conversationId, delegateIntent, opts, executionSpec, roleAssignments, state, this.getOrchestratorDispatchActor(orchestratorBot), delegateTarget);
         }
         if (decision.mode === 'workflow') {
             const workflowObjective = decision.workflow_request?.trim() || prompt;
@@ -1539,19 +2401,32 @@ 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 await this.queueWorkflowTodoPlan(prompt, conversationId, workflowIntent, validation.executionSpec, opts, roleAssignments, project, state, orchestratorBot);
+            return await this.queueWorkflowTodoPlan(prompt, conversationId, workflowIntent, validation.executionSpec, opts, roleAssignments, project, state, this.getOrchestratorDispatchActor(orchestratorBot));
         }
         return null;
     }
     resolveDelegatedAgentName(decision, roleAssignments) {
         const target = decision.delegate_target?.trim();
+        // Validate delegate_target matches delegate_role — if the LLM says role=qa
+        // but target=Ben (the default/coding bot), override with the correct role assignment.
+        // This prevents the LLM from always defaulting to the "default bot" for every role.
+        const role = decision.delegate_role;
+        if (role && target && target.toLowerCase() !== 'none') {
+            const roleBot = role === 'qa' ? roleAssignments.qa
+                : role === 'research' ? roleAssignments.research
+                    : role === 'coding' ? roleAssignments.coding
+                        : undefined;
+            if (roleBot && roleBot.toLowerCase() !== target.toLowerCase()) {
+                return roleBot;
+            }
+        }
         if (target && target.toLowerCase() !== 'none')
             return target;
-        if (decision.delegate_role === 'coding')
+        if (role === 'coding')
             return roleAssignments.coding;
-        if (decision.delegate_role === 'qa')
+        if (role === 'qa')
             return roleAssignments.qa;
-        if (decision.delegate_role === 'research')
+        if (role === 'research')
             return roleAssignments.research;
         return undefined;
     }
@@ -1615,7 +2490,7 @@ class OrchestratorAgent {
             locked: true,
         };
     }
-    async queueDelegateTodo(prompt, conversationId, intent, opts, executionSpec, roleAssignments, state, orchestratorBot, delegateTarget) {
+    async queueDelegateTodo(prompt, conversationId, intent, opts, executionSpec, roleAssignments, state, orchestratorActor, delegateTarget) {
         const projectId = opts.projectId || state.projectId || null;
         const project = projectId ? data.getProject(projectId) : undefined;
         const targetAgent = this.findAgentByName(delegateTarget, project?.id || undefined);
@@ -1626,7 +2501,7 @@ class OrchestratorAgent {
                 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 step = this.buildSingleDelegateTodoStep(prompt, conversationId, targetAgent, orchestratorActor, project?.name || null, project?.folder || null, data.getEffectiveOrchestrationPolicy(projectId || undefined));
         const task = data.addTodoTask({
             projectId,
             conversationId,
@@ -1639,7 +2514,7 @@ class OrchestratorAgent {
             taskType: step.taskType,
             profileName: 'Programming',
             taskPrompt: step.taskPrompt,
-            actor: { actorType: 'orchestrator', actorId: orchestratorBot.id },
+            actor: { actorType: 'orchestrator', actorId: orchestratorActor.actorId },
         });
         this.markConversationOrchestrated(conversationId);
         this.recordOrchestrationAudit(state, 'delegate_specialist', 'delegated', `Queued delegated TODO for ${targetAgent.name}.`, {
@@ -1659,14 +2534,14 @@ class OrchestratorAgent {
             ].join('\n');
             return state.finalResponseDraft;
         }
-        return await this.dispatchQueuedTodoChain(conversationId, opts, state, orchestratorBot, project, { taskIds: [task.id], workflowName: null });
+        return await this.dispatchQueuedTodoChain(conversationId, opts, state, orchestratorActor, project, { taskIds: [task.id], workflowName: null });
     }
-    async queueWorkflowTodoPlan(prompt, conversationId, intent, executionSpec, opts, roleAssignments, project, state, orchestratorBot, workflowTemplate) {
+    async queueWorkflowTodoPlan(prompt, conversationId, intent, executionSpec, opts, roleAssignments, project, state, orchestratorActor, 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);
+            ? this.buildTodoStepsFromTemplate(prompt, conversationId, workflowTemplate, orchestratorActor, project?.name || null, project?.folder || null, effectivePolicy)
+            : this.buildTodoStepsFromAssignments(prompt, conversationId, roleAssignments, intent, orchestratorActor, projectId || undefined, project?.name || null, project?.folder || null, effectivePolicy);
         if (plannedSteps.length === 0) {
             const overview = projectId ? data.getProjectOverview(projectId) : undefined;
             return this.formatClarificationResponse({
@@ -1692,9 +2567,9 @@ class OrchestratorAgent {
                 profileName: 'Programming',
                 nextWorkerBotId: next?.owner.id || null,
                 nextWorkerName: next?.owner.name || null,
-                nextWorkerRole: next ? (next.owner.role_label || next.owner.role_class || null) : null,
+                nextWorkerRole: next ? data.getAgentOrchestrationRoleLabel(next.owner) : null,
                 taskPrompt: step.taskPrompt,
-                actor: { actorType: 'orchestrator', actorId: orchestratorBot.id },
+                actor: { actorType: 'orchestrator', actorId: orchestratorActor.actorId },
             });
             createdTasks.push(task);
             (0, state_1.addDelegateTarget)(state, step.owner.name);
@@ -1723,18 +2598,72 @@ class OrchestratorAgent {
             state.finalResponseDraft = lines.join('\n');
             return state.finalResponseDraft;
         }
-        return await this.dispatchQueuedTodoChain(conversationId, opts, state, orchestratorBot, project, {
+        return await this.dispatchQueuedTodoChain(conversationId, opts, state, orchestratorActor, 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);
+    async dispatchQueuedTodoChain(conversationId, opts, state, orchestratorActor, project, context) {
+        // Pending queue seeded from the orchestrator's delegation. These IDs are
+        // the source of truth for the dispatch chain; we run them in the exact
+        // order the orchestrator returned them. If a completion produces a new
+        // TODO (qa_result='fail' auto-fix, insert_task, or re-QA companion),
+        // the new TODO is appended to the front of pending so the inline fix
+        // cycle runs before anything sitting later in the original sequence.
+        // (Codex QA 2026-04-19 #16 / april19fixes.txt item 5.)
+        const pending = context.taskIds.filter((id) => Number.isFinite(id)).map((id) => Number(id));
+        const seen = new Set(pending);
+        // Legacy fallback: if the caller didn't provide taskIds (older code
+        // paths that haven't been migrated yet), seed from the oldest active
+        // TODO. The new local_desktop dispatch path always supplies taskIds.
+        const completedTaskIds = [];
+        const initialTaskCount = pending.length;
+        // Explicit/imported workflows must be allowed to run to completion even
+        // when they legitimately contain dozens of ordered TODOs. Keep the
+        // safety brake, but make it an emergency guard against runaway re-queue
+        // loops rather than a low fixed workflow-length cap.
+        const maxIterations = Math.max(500, (initialTaskCount * 10) + 100);
+        const maxDynamicallyInsertedTasks = Math.max(200, (initialTaskCount * 4) + 50);
+        let dynamicallyInsertedCount = 0;
+        if (pending.length === 0) {
+            const first = data.getNextActiveTodoForConversation(conversationId);
+            if (first) {
+                pending.push(first.id);
+                seen.add(first.id);
+            }
+        }
+        for (let iteration = 0;; iteration += 1) {
+            if (iteration >= maxIterations) {
+                const message = 'The workflow created too many follow-up executions and was stopped to prevent an infinite loop.';
+                state.finalResponseDraft = message;
+                this.recordOrchestrationAudit(state, 'run_workflow', 'blocked', message, { maxIterations, initialTaskCount, dynamicallyInsertedCount });
+                return message;
+            }
+            if (opts.abortSignal?.aborted) {
+                state.finalResponseDraft = '';
+                return '';
+            }
+            let task;
+            while (pending.length > 0 && !task) {
+                const candidateId = pending.shift();
+                const active = data.getTodoTask(candidateId, 'active');
+                if (active) {
+                    task = active;
+                }
+                else if (data.getTodoTask(candidateId, 'completed')) {
+                    this.recordOrchestrationAudit(state, 'run_workflow', 'completed', `resume_skipped_completed_task:${candidateId}`, { taskId: candidateId });
+                }
+            }
             if (!task) {
-                return await this.finalizeQueuedTodoChain(conversationId, opts, state, orchestratorBot, project, context.workflowName);
+                return await this.finalizeQueuedTodoChain(conversationId, opts, state, orchestratorActor, project, context.workflowName, completedTaskIds);
             }
+            // Snapshot active IDs BEFORE this iteration so the post-iteration
+            // "new TODOs" scan only picks up tasks that were actually created
+            // during this execute() call (fix cycles, insert_task, re-QA
+            // companions). Stale/pre-existing active TODOs from prior turns
+            // are NOT swept in — the dispatcher only executes what the
+            // orchestrator delegated plus inline insertions.
+            const beforeActiveIds = new Set(data.listActiveTodoTasksForConversation(conversationId).map((t) => t.id));
             const owner = task.owner_bot_id
                 ? data.getAgentProfile(task.owner_bot_id)
                 : this.findAgentByName(task.owner_name || undefined, project?.id || undefined);
@@ -1745,8 +2674,12 @@ class OrchestratorAgent {
                 return message;
             }
             const taskPrompt = task.task_prompt?.trim() || task.details || task.title;
+            if (opts.importedPlanRunId) {
+                data.touchImportedPlanRun(opts.importedPlanRunId);
+            }
             const result = await this.runNodeWithRetry('run_workflow', state, async () => this.workflowEngine.execute(taskPrompt, conversationId, owner.id, {
                 apiKey: this.resolveApiKey(owner.provider),
+                abortSignal: opts.abortSignal,
                 taskId: task.id,
                 stepDescription: task.title,
                 disableDecomposition: true,
@@ -1754,6 +2687,10 @@ class OrchestratorAgent {
                 projectId: project?.id || opts.projectId || state.projectId || null,
                 workspacePath: project?.folder?.trim() || undefined,
                 persistConversationMessages: false,
+                storedAttachments: opts.storedAttachments,
+                workerImageDeliveryMode: opts.storedAttachments?.length ? 'reference' : undefined,
+                importedPlanRunId: opts.importedPlanRunId,
+                cliSessionScopeKey: opts.cliSessionScopeKey,
                 onWorkerChunk: opts.onWorkerChunk,
                 onProgress: (progress) => {
                     if (progress.event === 'step-started') {
@@ -1767,11 +2704,19 @@ class OrchestratorAgent {
                     }
                 },
             }));
+            if (opts.abortSignal?.aborted || isAbortLikeError(result?.error)) {
+                state.finalResponseDraft = '';
+                return '';
+            }
             const stillActive = data.getTodoTask(task.id, 'active');
             const completed = data.getTodoTask(task.id, 'completed');
+            if (opts.abortSignal?.aborted) {
+                state.finalResponseDraft = '';
+                return '';
+            }
             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);
+                return await this.handleBlockedTodoTask(stillActive, opts, state, orchestratorActor, project);
             }
             if (!completed) {
                 const error = result.steps.find((step) => step.error)?.error || this.stripWorkerProtocol(result.mergedResult || '') || 'Worker did not complete the queued task.';
@@ -1780,19 +2725,46 @@ class OrchestratorAgent {
                 this.recordOrchestrationAudit(state, 'run_workflow', 'blocked', message, { taskId: task.id });
                 return message;
             }
+            completedTaskIds.push(completed.id);
+            // Pick up any TODOs that were newly inserted during THIS iteration
+            // (fix cycles, re-QA companions, worker-directed insert_task) —
+            // i.e. active now but not active before the iteration began. They
+            // go to the front of pending so the inline cycle completes before
+            // the original chain continues. Stale/older active TODOs from
+            // prior turns are NOT swept in (they were in beforeActiveIds).
+            const activeAfter = data.listActiveTodoTasksForConversation(conversationId);
+            const newlyInserted = [];
+            for (const t of activeAfter) {
+                if (!beforeActiveIds.has(t.id) && !seen.has(t.id)) {
+                    newlyInserted.push(t.id);
+                    seen.add(t.id);
+                }
+            }
+            if (newlyInserted.length > 0) {
+                dynamicallyInsertedCount += newlyInserted.length;
+                if (dynamicallyInsertedCount > maxDynamicallyInsertedTasks) {
+                    const message = 'The workflow created too many follow-up TODOs and was stopped to prevent an infinite loop.';
+                    state.finalResponseDraft = message;
+                    this.recordOrchestrationAudit(state, 'run_workflow', 'blocked', message, { maxDynamicallyInsertedTasks, dynamicallyInsertedCount, initialTaskCount });
+                    return message;
+                }
+                pending.unshift(...newlyInserted);
+            }
         }
-        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) {
+    async handleBlockedTodoTask(task, opts, state, orchestratorActor, 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 completedTasks = data.listCompletedTodoTasksForConversation(task.conversation_id || state.conversationId || '');
         const workerRole = task.task_type || task.next_worker_role || 'general';
+        if (/provider returned a quota\/rate-limit error/i.test(task.blocker_checked || '')) {
+            const exact = task.blocker_summary || 'Provider limit reached.';
+            const response = `Provider returned:\n\n${exact}\n\nFix the provider account limit or wait for the retry window, then resume the plan.`;
+            state.finalResponseDraft = response;
+            return response;
+        }
         const blockedPrompt = (0, orchestrator_blocked_prompt_1.buildBlockedWorkerOrchestratorPrompt)({
-            orchestratorName: orchestratorBot.name,
+            orchestratorName: orchestratorActor.name,
             workerName: task.owner_name || 'Worker',
             workerRole,
             taskTitle: task.title,
@@ -1811,10 +2783,11 @@ class OrchestratorAgent {
         try {
             rawResponse = await this.runNodeWithRetry('finalize_response', state, async () => this.runOrchestratorPrompt(blockedPrompt, `You are ${this.orchestratorRuntime.agentName}. Write the user-facing blocker message after work has already started. Be concise, outcome-first, and do not restate the full original request.`, {
                 conversationId: task.conversation_id || state.conversationId || null,
-                orchestratorBot,
+                orchestratorBot: orchestratorActor.bot || undefined,
                 projectId: project?.id || opts.projectId || state.projectId || null,
                 workspacePath: project?.folder?.trim() || undefined,
                 disableTools: true,
+                abortSignal: opts.abortSignal,
             }));
         }
         catch (error) {
@@ -1827,8 +2800,14 @@ class OrchestratorAgent {
         state.finalResponseDraft = response;
         return response;
     }
-    async finalizeQueuedTodoChain(conversationId, opts, state, orchestratorBot, project, workflowName) {
-        const completedTasks = data.listCompletedTodoTasksForConversation(conversationId).map((task) => ({
+    async finalizeQueuedTodoChain(conversationId, opts, state, orchestratorActor, project, workflowName, completedTaskIds = []) {
+        const ids = completedTaskIds
+            .map((id) => Number(id))
+            .filter((id, index, arr) => Number.isFinite(id) && id > 0 && arr.indexOf(id) === index);
+        const sourceTasks = ids
+            .map((id) => data.getTodoTask(id, 'completed'))
+            .filter((task) => Boolean(task));
+        const completedTasks = sourceTasks.map((task) => ({
             ...task,
             artifactRefs: data.listTodoArtifactsForTask(task.id, 'completed').map((item) => item.path_or_ref),
         }));
@@ -1838,7 +2817,7 @@ class OrchestratorAgent {
         }
         const policy = data.getEffectiveOrchestrationPolicy(project?.id || opts.projectId || state.projectId || undefined);
         const finalPrompt = (0, orchestrator_final_response_prompt_1.buildOrchestratorFinalResponsePrompt)({
-            orchestratorName: orchestratorBot.name,
+            orchestratorName: orchestratorActor.name,
             projectName: project?.name || null,
             workspacePath: project?.folder || null,
             effectivePolicy: policy,
@@ -1848,10 +2827,11 @@ class OrchestratorAgent {
         try {
             response = await this.runNodeWithRetry('finalize_response', state, async () => this.runOrchestratorPrompt(finalPrompt, `You are ${this.orchestratorRuntime.agentName}. Write the final user-facing answer after the workflow is complete. Do not restate the full request. Say what was created, where it is, the concise result, and only any important caveat. Do not claim everything was verified, defect-free, or ready for use unless a completed verification step explicitly established that.`, {
                 conversationId,
-                orchestratorBot,
+                orchestratorBot: orchestratorActor.bot || undefined,
                 projectId: project?.id || opts.projectId || state.projectId || null,
                 workspacePath: project?.folder?.trim() || undefined,
                 disableTools: true,
+                abortSignal: opts.abortSignal,
             }));
         }
         catch (error) {
@@ -1867,27 +2847,31 @@ class OrchestratorAgent {
             : 'Completed automatic TODO dispatch.', { completedTaskCount: completedTasks.length });
         return response;
     }
-    buildSingleDelegateTodoStep(prompt, owner, orchestratorBot, projectName, workspacePath, effectivePolicy) {
+    buildSingleDelegateTodoStep(prompt, conversationId, owner, orchestratorActor, projectName, workspacePath, effectivePolicy) {
         const taskType = this.normalizeTaskTypeForWorker(owner, 'coding');
+        const recentContext = this.buildRecentConversationContextForWorker(conversationId);
         return {
-            title: `${owner.name}: ${this.summarizeTodoTitle(prompt)}`,
-            details: `Delegated by ${orchestratorBot.name}. Complete this single-worker request directly.`,
+            title: `${owner.name}: handle the delegated request`,
+            details: `Delegated by ${orchestratorActor.name}. Complete this single-worker request directly.`,
             owner,
             taskType,
             taskPrompt: this.buildWorkerTaskPrompt({
                 originalPrompt: prompt,
-                stepInstruction: 'Handle this delegated request directly.',
+                stepInstruction: 'Handle the user request from this conversation.',
                 owner,
                 previousWorker: null,
                 nextWorker: null,
+                conversationId,
                 projectName,
                 workspacePath,
                 effectivePolicy,
+                recentContext,
             }),
             successCriteria: `Complete the delegated ${taskType} task and return a concise result summary.`,
         };
     }
-    buildTodoStepsFromTemplate(prompt, workflowTemplate, orchestratorBot, projectName, workspacePath, effectivePolicy) {
+    buildTodoStepsFromTemplate(prompt, conversationId, workflowTemplate, orchestratorActor, projectName, workspacePath, effectivePolicy) {
+        const recentContext = this.buildRecentConversationContextForWorker(conversationId);
         const steps = workflowTemplate.steps
             .sort((a, b) => a.order_index - b.order_index)
             .map((step) => {
@@ -1913,14 +2897,315 @@ class OrchestratorAgent {
                 owner: step.owner,
                 previousWorker: steps[index - 1]?.owner || null,
                 nextWorker: steps[index + 1]?.owner || null,
+                conversationId,
                 projectName,
                 workspacePath,
                 effectivePolicy,
+                recentContext,
             }),
             successCriteria: `Complete step ${index + 1} of "${workflowTemplate.name}" and hand off the necessary output.`,
         }));
     }
-    buildTodoStepsFromAssignments(prompt, roleAssignments, intent, orchestratorBot, projectId, projectName, workspacePath, effectivePolicy) {
+    buildSelectedWorkflowTemplateHint(workflowTemplate) {
+        return {
+            id: workflowTemplate.id,
+            name: workflowTemplate.name,
+            description: workflowTemplate.description || null,
+            steps: workflowTemplate.steps
+                .slice()
+                .sort((a, b) => a.order_index - b.order_index)
+                .map((step, index) => {
+                const bot = data.getAgentProfile(step.agent_id);
+                return {
+                    index,
+                    bot_name: bot?.name || step.agent_id,
+                    role_priorities: bot ? data.getAgentRolePriorities(bot) : [],
+                    saved_instruction: step.instruction?.trim() || null,
+                    is_checkpoint: step.is_checkpoint === 1,
+                };
+            }),
+        };
+    }
+    createPendingWorkflowProposal(input) {
+        this.deleteStalePendingWorkflowProposals(input.conversationId, input.orchestratorActor);
+        const workflowArgs = this.buildPendingWorkflowProposalArgs(input.prompt, input.candidateWorkflowPlan, input.selectedWorkflowTemplateHint);
+        if (workflowArgs.steps.length === 0)
+            return [];
+        const existingActive = data.listActiveTodoTasksForConversation(input.conversationId);
+        const result = input.executeCreateWorkflow(workflowArgs, {
+            conversationId: input.conversationId,
+            projectId: input.projectId,
+            orchestratorActor: input.orchestratorActor,
+            resolution: {
+                activeBots: input.activeBots,
+                botsWithActiveTodos: new Set(existingActive.map((task) => task.owner_name).filter(Boolean)),
+            },
+            userPrompt: input.prompt,
+            recentContext: input.recentContext || null,
+        });
+        if (!result || result.kind === 'error' || !Array.isArray(result.tasks))
+            return [];
+        const confidence = this.summarizeCandidateConfidence(input.candidateWorkflowPlan.steps);
+        const stepReasons = input.candidateWorkflowPlan.steps
+            .map((step) => {
+            const role = step.suggested_role ? ` as ${step.suggested_role}` : '';
+            const confidenceLabel = step.confidence || 'low';
+            const reason = step.reason || 'No specific role signal; using configured priority.';
+            return `- ${step.bot_name}${role}: ${confidenceLabel} - ${reason}`;
+        })
+            .join('\n');
+        const details = [
+            'System-proposed workflow. Awaiting orchestrator approval; workers have not started.',
+            `Source: ${input.candidateWorkflowPlan.source}.`,
+            `Confidence: ${confidence}.`,
+            `Reason: ${input.candidateWorkflowPlan.reason}`,
+            stepReasons ? `Step confidence:\n${stepReasons}` : '',
+        ].join('\n');
+        for (const task of result.tasks) {
+            try {
+                data.editTodoTask(task.id, {
+                    details,
+                    actor: { actorType: 'orchestrator', actorId: input.orchestratorActor.actorId },
+                });
+            }
+            catch {
+                // Best effort. The task remains visible even if details were not updated.
+            }
+        }
+        return result.tasks.map((task) => task.id);
+    }
+    deleteStalePendingWorkflowProposals(conversationId, orchestratorActor) {
+        const marker = 'System-proposed workflow. Awaiting orchestrator approval; workers have not started.';
+        for (const task of data.listActiveTodoTasksForConversation(conversationId)) {
+            if (!String(task.details || '').includes(marker))
+                continue;
+            try {
+                data.deleteTodoTask(task.id, {
+                    actor: { actorType: 'orchestrator', actorId: orchestratorActor.actorId },
+                });
+            }
+            catch {
+                // Leave concurrently touched tasks alone.
+            }
+        }
+    }
+    summarizeCandidateConfidence(steps) {
+        if (steps.length === 0)
+            return 'low';
+        const values = steps.map((step) => step.confidence || 'low');
+        if (values.every((value) => value === 'high'))
+            return 'high';
+        if (values.every((value) => value === 'low'))
+            return 'low';
+        if (values.some((value) => value === 'low'))
+            return 'medium';
+        return 'medium';
+    }
+    buildPendingWorkflowProposalArgs(prompt, candidate, selectedWorkflowTemplateHint) {
+        const target = this.inferWorkflowTargetForTitle(prompt);
+        const templateStepsByIndex = new Map((selectedWorkflowTemplateHint?.steps || []).map((step) => [step.index, step]));
+        return {
+            steps: candidate.steps.map((step, index) => {
+                const role = step.suggested_role || step.role_priorities[0] || '';
+                const action = this.workflowActionForRole(role, prompt);
+                const templateInstruction = templateStepsByIndex.get(step.index)?.saved_instruction || '';
+                const nextStep = candidate.steps[index + 1] || null;
+                const title = this.buildCandidateWorkflowTitle({
+                    action,
+                    role,
+                    target,
+                    nextBotName: nextStep?.bot_name || null,
+                });
+                return {
+                    bot_name: step.bot_name,
+                    role: role || undefined,
+                    title,
+                    task_instructions: templateInstruction || this.buildCandidateWorkflowInstructions({
+                        action,
+                        role,
+                        target,
+                        nextBotName: nextStep?.bot_name || null,
+                        nextRole: nextStep?.suggested_role || nextStep?.role_priorities?.[0] || null,
+                    }),
+                };
+            }),
+        };
+    }
+    workflowActionForRole(role, prompt) {
+        const normalized = String(role || '').trim().toLowerCase();
+        if (this.roleHasCapability(role, 'prompt_building'))
+            return 'Generate prompt';
+        if (this.roleHasCapability(role, 'qa'))
+            return 'QA';
+        if (this.roleHasCapability(role, 'verify'))
+            return 'Verify';
+        if (this.roleHasCapability(role, 'deployment'))
+            return 'Deploy';
+        if (this.roleHasCapability(role, 'research') || this.roleHasCapability(role, 'design'))
+            return 'Plan';
+        if (this.roleHasCapability(role, 'coding')) {
+            const promptText = String(prompt || '').toLowerCase();
+            if (/\b(clean\s+up|improve|redesign|ui\/?ux|make .*better|polish)\b/.test(promptText))
+                return 'Improve';
+            if (/\b(fix|repair|correct)\b/.test(promptText))
+                return 'Fix';
+            if (/\b(update|modify|edit|change)\b/.test(promptText))
+                return 'Update';
+            return 'Build';
+        }
+        if (/\b(qa|quality assurance|review|test)\b/.test(normalized))
+            return 'QA';
+        if (/\b(verify|verification|validate)\b/.test(normalized))
+            return 'Verify';
+        if (/\b(research|brainstorm|plan|planning|design)\b/.test(normalized))
+            return 'Plan';
+        if (/\b(deploy|deployment|release|ship)\b/.test(normalized))
+            return 'Deploy';
+        if (/\b(code|coding|build|implement|create|write|develop)\b/.test(normalized)) {
+            const promptText = String(prompt || '').toLowerCase();
+            if (/\b(clean\s+up|improve|redesign|ui\/?ux|make .*better|polish)\b/.test(promptText))
+                return 'Improve';
+            if (/\b(fix|repair|correct)\b/.test(promptText))
+                return 'Fix';
+            if (/\b(update|modify|edit|change)\b/.test(promptText))
+                return 'Update';
+            return 'Build';
+        }
+        return 'Handle';
+    }
+    buildCandidateWorkflowTitle(input) {
+        if (this.roleHasCapability(input.role, 'prompt_building')) {
+            return input.nextBotName
+                ? `Generate ${input.nextBotName} handoff for ${input.target}`
+                : `Generate prompt for ${input.target}`;
+        }
+        return `${input.action} ${input.target}`;
+    }
+    buildCandidateWorkflowInstructions(input) {
+        if (this.roleHasCapability(input.role, 'prompt_building')) {
+            const next = input.nextBotName
+                ? `${input.nextBotName}${input.nextRole ? ` (${input.nextRole})` : ''}`
+                : 'the next worker';
+            return [
+                `Create a professional, detailed worker prompt for ${next} to handle ${input.target}.`,
+                `Include the target artifact/path, the current issue or requested change, exact expected behavior, scope limits, constraints, and acceptance checks.`,
+                'Put the finished prompt in complete_worker_task.handoff_prompt so the next worker can act without guessing.',
+            ].join(' ');
+        }
+        const nextLine = input.nextBotName
+            ? ` When done, hand off enough detail for ${input.nextBotName}${input.nextRole ? ` (${input.nextRole})` : ''} to continue without guessing.`
+            : '';
+        return `${input.action} ${input.target} for the current user request.${nextLine}`;
+    }
+    roleHasCapability(role, capabilityId) {
+        return (0, capabilities_1.matchCapabilityIds)([String(role || '')]).includes(capabilityId);
+    }
+    inferWorkflowTargetForTitle(prompt) {
+        const text = String(prompt || '');
+        const fileMatch = text.match(/\b([A-Za-z0-9_-]+\.(?:html|tsx?|jsx?|css|md|txt|json))\b/);
+        if (fileMatch?.[1])
+            return fileMatch[1];
+        if (/\boutfitter\b/i.test(text) || /\belk hunting\b/i.test(text))
+            return 'outfitter page';
+        if (/\b(web\s?page|website|html|landing page|page)\b/i.test(text))
+            return 'requested page';
+        if (/\binstall(?:er)?\b/i.test(text))
+            return 'installer';
+        if (/\brelease|deploy|download\b/i.test(text))
+            return 'release';
+        return 'request';
+    }
+    buildExplicitBotSequenceCandidatePlan(prompt, activeBots) {
+        const text = String(prompt || '');
+        if (!text.trim())
+            return null;
+        const matches = [];
+        for (const bot of activeBots) {
+            const escaped = bot.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const match = new RegExp(`\\b${escaped}\\b`, 'i').exec(text);
+            if (match && Number.isFinite(match.index)) {
+                matches.push({ bot, index: match.index });
+            }
+        }
+        const ordered = matches
+            .sort((a, b) => a.index - b.index)
+            .filter((match, index, arr) => arr.findIndex((other) => other.bot.id === match.bot.id) === index);
+        if (ordered.length < 2)
+            return null;
+        if (!this.hasExplicitBotWorkflowSignal(text))
+            return null;
+        return {
+            source: 'explicit_bot_sequence',
+            reason: `User explicitly mentioned multiple bots in order: ${ordered.map((item) => item.bot.name).join(' -> ')}.`,
+            steps: ordered.map((item, index) => {
+                const inference = this.inferSuggestedRoleNearBot(text, item.index, ordered[index + 1]?.index, item.bot);
+                return {
+                    index,
+                    bot_name: item.bot.name,
+                    role_priorities: data.getAgentRolePriorities(item.bot),
+                    suggested_role: inference.role,
+                    confidence: inference.confidence,
+                    reason: inference.reason,
+                };
+            }),
+        };
+    }
+    hasExplicitBotWorkflowSignal(prompt) {
+        const text = prompt.toLowerCase();
+        if (/\b(have|use|ask|tell|delegate|assign|workflow)\b/.test(text))
+            return true;
+        if (/\bthen\b|\bafter that\b|\bfollowed by\b/.test(text))
+            return true;
+        return /\b(code|coding|build|implement|create|write|develop|edit|update|modify|fix|prompt|qa|quality assurance|review|test|testing|verify|verification|validate|research|plan|brainstorm)\b/.test(text);
+    }
+    inferSuggestedRoleNearBot(prompt, startIndex, nextStartIndex, bot) {
+        const roles = data.getAgentRolePriorities(bot);
+        const segmentEnd = nextStartIndex === undefined ? prompt.length : nextStartIndex;
+        const segment = prompt.slice(startIndex, segmentEnd).toLowerCase();
+        const roleKeywordGroups = [
+            {
+                keywords: /\b(?:create|write|generate|draft|prepare|build|make)\s+(?:a\s+|the\s+)?(?:better\s+|professional\s+|detailed\s+)?(?:user\s+|worker\s+|handoff\s+)?prompt\b|\bhandoff\s+prompt\b|\bprompt\s+for\b/i,
+                capabilityId: 'prompt_building',
+                reason: 'User asked this worker to create or prepare a prompt/handoff.',
+            },
+            { keywords: /\b(qa|quality assurance|review|test|testing|audit)\b/i, capabilityId: 'qa', reason: 'User asked this worker to review, test, or QA.' },
+            { keywords: /\b(verify|verification|validate|validation)\b/i, capabilityId: 'verify', reason: 'User asked this worker to verify or validate.' },
+            { keywords: /\b(deploy|deployment|release|ship|publish)\b/i, capabilityId: 'deployment', reason: 'User asked this worker to deploy, release, or publish.' },
+            { keywords: /\b(code|coding|build|implement|create|write|develop|edit|update|modify|fix|clean\s+up|improve|redesign)\b/i, capabilityId: 'coding', reason: 'User asked this worker to create, modify, or fix an artifact.' },
+            { keywords: /\b(design|ui\/?ux|ux|visual|layout)\b/i, capabilityId: 'design', reason: 'User asked this worker to handle design or UI/UX planning.' },
+            { keywords: /\b(research|investigate|analy[sz]e|analysis|brainstorm|plan|planning)\b/i, capabilityId: 'research', reason: 'User asked this worker to research or plan.' },
+        ];
+        for (const group of roleKeywordGroups) {
+            if (!group.keywords.test(segment))
+                continue;
+            const matchedRole = (0, capabilities_1.findRoleLabelForCapability)(roles, group.capabilityId);
+            const botHasCapability = roles.some((role) => (0, capabilities_1.matchCapabilityIds)([role]).includes(group.capabilityId));
+            return {
+                role: matchedRole,
+                confidence: botHasCapability ? 'high' : 'medium',
+                reason: botHasCapability
+                    ? group.reason
+                    : `${group.reason} The worker was named explicitly; role is informational because it is not in that worker's configured priorities.`,
+            };
+        }
+        return {
+            role: roles[0] || null,
+            confidence: 'low',
+            reason: 'No specific capability keyword was found near this bot name; using the worker priority list.',
+        };
+    }
+    reportCandidateWorkflowProgress(opts, candidate) {
+        const names = candidate.steps
+            .map((step) => step.suggested_role ? `${step.bot_name} (${step.suggested_role})` : step.bot_name)
+            .filter(Boolean);
+        const prefix = candidate.source === 'explicit_bot_sequence'
+            ? 'Detected requested bot sequence'
+            : 'Detected requested workflow';
+        const summary = names.length > 0 ? `${prefix}: ${names.join(' -> ')}.` : prefix + '.';
+        opts.onProgress(`Orchestrator:: ${summary} Awaiting orchestrator approval before starting workers.`);
+    }
+    buildTodoStepsFromAssignments(prompt, conversationId, roleAssignments, intent, orchestratorActor, projectId, projectName, workspacePath, effectivePolicy) {
+        const recentContext = this.buildRecentConversationContextForWorker(conversationId);
         const roleOrder = this.inferWorkflowRoleOrder(prompt, roleAssignments, intent);
         const owners = roleOrder
             .map((role) => {
@@ -1933,7 +3218,7 @@ class OrchestratorAgent {
             .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}.`,
+            details: `Workflow step assigned by ${orchestratorActor.name}.`,
             owner: item.agent,
             taskType: this.normalizeTaskTypeForWorker(item.agent, item.role === 'research' ? 'research' : item.role === 'qa' ? 'qa' : 'coding'),
             taskPrompt: this.buildWorkerTaskPrompt({
@@ -1942,80 +3227,75 @@ class OrchestratorAgent {
                 owner: item.agent,
                 previousWorker: owners[index - 1]?.agent || null,
                 nextWorker: owners[index + 1]?.agent || null,
+                conversationId,
                 projectName: projectName || null,
                 workspacePath: workspacePath || null,
                 effectivePolicy: effectivePolicy || data.getEffectiveOrchestrationPolicy(projectId),
+                recentContext,
             }),
             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));
+    /**
+     * @deprecated Phase B of orchestration-plan.txt.
+     * Kept only to avoid breaking the non-local_desktop (connected) code paths
+     * that still call it. In local_desktop mode the LLM-tool-dispatch path
+     * makes this regex unreachable. Remove after connected-mode orchestration
+     * is migrated to tool dispatch.
+     */
+    /**
+     * DEPRECATED — returns []. Previously inferred workflow step order from
+     * prompt prose via regex. Codex audit HIGH #6: runtime must not scan
+     * English to decide workflow shape. The tool-dispatch path's
+     * create_workflow is the structured replacement — the orchestrator LLM
+     * decides the ordered role list from the prompt and bot priorities and
+     * emits structured steps. Kept as a stub so any remaining legacy caller
+     * produces an empty role order (which downstream callers handle by
+     * falling through to their no-role-inferred branch).
+     */
+    inferWorkflowRoleOrder(_prompt, _assignments, _intent) {
         return [];
     }
     normalizeTaskTypeForWorker(owner, fallback) {
-        const roleClass = String(owner.role_class || owner.role_label || '').trim().toLowerCase();
-        if (roleClass === 'qa' || roleClass === 'review')
+        const inferred = (0, capabilities_1.inferTaskTypeFromCapabilities)(null, data.getAgentRolePriorities(owner), fallback || 'coding');
+        if (['qa', 'research', 'verify', 'coding', 'deploy'].includes(inferred)) {
+            return inferred;
+        }
+        if (this.agentHasAnyRole(owner, ['qa', 'review', 'reviewer']))
             return 'qa';
-        if (roleClass === 'research' || roleClass === 'brainstorm' || roleClass === 'planning' || roleClass === 'plan')
+        if (this.agentHasAnyRole(owner, ['research', 'researcher', 'analyst', 'advisor', 'brainstorm', 'brainstorming', 'planning', 'plan', 'design']))
             return 'research';
-        if (roleClass === 'verify' || roleClass === 'verification')
+        if (this.agentHasAnyRole(owner, ['verify', 'verification']))
             return 'verify';
-        if (roleClass === 'deploy' || roleClass === 'deployment')
-            return 'deploy';
-        if (roleClass === 'coding' || roleClass === 'code' || roleClass === 'builder' || roleClass === 'developer' || roleClass === 'engineer')
+        if (this.agentHasAnyRole(owner, ['coding', 'code', 'builder', 'developer', 'engineer']))
             return 'coding';
+        if (this.agentHasAnyRole(owner, ['deploy', 'deployment']))
+            return 'deploy';
         return (fallback || 'coding');
     }
     buildWorkerTaskPrompt(input) {
-        const workerRole = String(input.owner.role_label || input.owner.role_class || 'general').trim() || 'general';
+        const workerRole = this.getOrchestrationRoleLabel(input.owner);
         const taskType = this.normalizeTaskTypeForWorker(input.owner, null);
+        const bootstrapHistoryFilePath = this.prepareBootstrapHistoryFile(input.conversationId);
+        const isFirstInChain = !input.previousWorker;
+        const includeOriginalPrompt = this.shouldIncludeOriginalPromptForWorker(input.owner, isFirstInChain);
         const composedTask = [
             `Step instruction: ${input.stepInstruction}`,
             taskType === 'qa'
-                ? 'QA scope: Use PREVIOUS WORKER HANDOFF, queued task details, and explicit success criteria as the source of truth for this QA pass. Only search for broader context if those inputs are incomplete.'
+                ? 'QA scope: Verify the delivered work against the assigned task, previous handoff, explicit success criteria, and original user request when provided. Use the tools and checks needed for that assignment.'
                 : taskType === 'verify'
                     ? 'Verification scope: Compare the delivered work against the original user request and the explicit success criteria.'
                     : '',
-            String(input.nextWorker?.role_label || input.nextWorker?.role_class || '').trim().toLowerCase() === 'qa'
-                ? 'QA handoff rule: Scope the handoff to static artifact/code review, concrete implementation claims, and explicit pass/fail checks. Do not ask the next QA worker to open a browser, capture screenshots, test desktop/mobile breakpoints, check animations or hover effects, or re-compare against the full original request unless the user explicitly asked for runtime verification.'
+            this.agentHasAnyRole(input.nextWorker, ['qa', 'review', 'reviewer'])
+                ? 'QA handoff rule: Include concrete implementation claims, artifact paths, known caveats, and recommended checks. Do not narrow the next QA worker beyond the user request, workflow instruction, or explicit success criteria.'
                 : '',
-            String(input.nextWorker?.role_label || input.nextWorker?.role_class || '').trim().toLowerCase() === 'qa'
-                ? 'QA handoff rule: Do not ask the next QA worker to use memory search, image analysis, or broad codebase discovery unless a specific missing expectation cannot be checked from the artifact and nearby implementation.'
-                : '',
-            taskType === 'qa'
-                ? null
+            this.agentHasAnyRole(input.nextWorker, ['qa', 'review', 'reviewer'])
+                ? 'QA handoff rule: Let QA decide which available tools or runtime checks are needed for the assigned verification.'
                 : '',
-            taskType === 'qa'
-                ? null
-                : 'Original user request (reference only):',
-            taskType === 'qa'
-                ? null
-                : input.originalPrompt,
+            isFirstInChain && input.recentContext?.trim() ? 'Recent conversation context:' : null,
+            isFirstInChain && input.recentContext?.trim() ? input.recentContext.trim() : null,
+            includeOriginalPrompt ? 'Original user request:' : null,
+            includeOriginalPrompt ? input.originalPrompt : null,
         ].join('\n');
         return (0, worker_operating_prompt_1.buildWorkerOperatingPrompt)({
             workerName: input.owner.name,
@@ -2030,26 +3310,60 @@ class OrchestratorAgent {
                 defaultLine: 'No confirmed special policy is set.',
             }),
             previousWorkerName: input.previousWorker?.name || null,
-            previousWorkerRole: input.previousWorker ? String(input.previousWorker.role_label || input.previousWorker.role_class || 'general') : null,
+            previousWorkerRole: input.previousWorker ? this.getOrchestrationRoleLabel(input.previousWorker) : null,
             nextWorkerName: input.nextWorker?.name || null,
-            nextWorkerRole: input.nextWorker ? String(input.nextWorker.role_label || input.nextWorker.role_class || 'general') : null,
+            nextWorkerRole: input.nextWorker ? this.getOrchestrationRoleLabel(input.nextWorker) : null,
+            bootstrapHistoryFilePath,
+            capabilityInstructions: (0, capabilities_1.buildCapabilityInstructionBlock)(data.getAgentRolePriorities(input.owner)),
+        });
+    }
+    buildRecentConversationContextForWorker(conversationId) {
+        const contextWindow = (0, context_window_1.getPromptContextWindow)(conversationId, safeguards_1.SAFEGUARDS.CONTEXT_WINDOW_TURNS);
+        const lines = [];
+        const summary = contextWindow.summary?.summary_text?.trim();
+        if (summary) {
+            lines.push('[Rolling Summary]');
+            lines.push(contextWindow.carriedForward ? '(carried forward from the previous conversation in this topic)' : '');
+            lines.push(summary);
+        }
+        if (contextWindow.turns.length > 0) {
+            lines.push('[Recent Turns]');
+            lines.push((0, context_window_1.formatTurnsForPrompt)(contextWindow.turns));
+        }
+        if (lines.length === 0) {
+            const currentTurns = (0, context_window_1.getRecentTurns)(conversationId, safeguards_1.SAFEGUARDS.CONTEXT_WINDOW_TURNS);
+            if (currentTurns.length > 0) {
+                lines.push('[Recent Turns]');
+                lines.push((0, context_window_1.formatTurnsForPrompt)(currentTurns));
+            }
+        }
+        return lines.filter((line) => line !== '').join('\n').slice(0, 10000);
+    }
+    prepareBootstrapHistoryFile(conversationId) {
+        const normalizedConversationId = String(conversationId || '').trim();
+        if (!normalizedConversationId)
+            return null;
+        const topicId = data.getPrimaryTopicIdForConversation(normalizedConversationId) || undefined;
+        return (0, cli_bootstrap_history_1.writeConversationBootstrapHistoryFile)({
+            conversationId: normalizedConversationId,
+            topicId,
         });
     }
-    defaultTodoTitleForRole(role, prompt) {
+    defaultTodoTitleForRole(role, _prompt) {
         if (role === 'research')
-            return `Research and plan: ${this.summarizeTodoTitle(prompt)}`;
+            return 'Research and plan the user request';
         if (role === 'qa')
-            return `QA and review: ${this.summarizeTodoTitle(prompt)}`;
-        return `Build and implement: ${this.summarizeTodoTitle(prompt)}`;
+            return 'QA and review the delivered work';
+        return 'Build and implement the requested work';
     }
-    defaultStepInstructionForRole(role, prompt) {
+    defaultStepInstructionForRole(role, _prompt) {
         if (role === 'research') {
-            return 'Research, brainstorm, or plan the work so the implementation handoff is specific and actionable.';
+            return 'Research, brainstorm, or plan the user request. Hand off whatever context the next worker needs to continue.';
         }
         if (role === 'qa') {
-            return 'QA the completed work against the previous worker handoff, delivered artifact, and explicit success criteria. Focus on artifact/code review only. Do not do browser checks, image analysis, memory search, or broad codebase discovery unless runtime verification was explicitly requested or the handoff is missing a specific fact you cannot otherwise inspect. If issues remain, prepare a precise fix handoff for the previous worker.';
+            return 'QA the completed work against the assigned task, previous worker handoff, delivered artifact, explicit success criteria, and original user request when provided. Use the available tools and checks needed for the assignment. If issues remain, prepare a precise fix handoff for the previous worker.';
         }
-        return `Implement the requested work directly. Keep the original request in scope: ${prompt}`;
+        return 'Implement the assigned work using the current task and previous worker handoff as context.';
     }
     defaultSuccessCriteriaForRole(role) {
         if (role === 'research')
@@ -2083,10 +3397,65 @@ class OrchestratorAgent {
             return scopedMatch;
         return allAgents.find((agent) => agent.name.trim().toLowerCase() === normalized);
     }
+    resolveDefaultFallbackAgent(projectId, orchestratorBot, roleAssignments) {
+        const candidates = [];
+        const defaultAgent = data.getDefaultAgentProfile();
+        if (defaultAgent)
+            candidates.push(defaultAgent);
+        if (roleAssignments.coding)
+            candidates.push(this.findAgentByName(roleAssignments.coding, projectId));
+        const project = projectId ? data.getProject(projectId) : undefined;
+        const projectScoped = project?.bot_ids?.length
+            ? data.listAgentProfiles().filter((agent) => project.bot_ids.includes(agent.id))
+            : data.listAgentProfiles();
+        candidates.push(...projectScoped.filter((agent) => !(0, orchestrator_profile_1.isOrchestratorProfile)(agent)));
+        return candidates.find((agent) => !!agent
+            && agent.id !== orchestratorBot.id
+            && !(0, orchestrator_profile_1.isOrchestratorProfile)(agent));
+    }
     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`);
+        const executionLabel = this.orchestratorRuntime.kind === 'clerk'
+            ? 'Clerk kept the work.'
+            : `Selected orchestrator bot ${orchestratorBot.name} kept the work.`;
+        this.recordOrchestrationAudit(state, 'execute_direct', 'executed', executionLabel, {
+            orchestratorBotId: orchestratorBot.id,
+            orchestratorBotName: orchestratorBot.name,
+            runtimeKind: this.orchestratorRuntime.kind,
+        });
+        this.reportHiddenRoleProgress(opts, 'orchestrator', this.orchestratorRuntime.kind === 'clerk'
+            ? 'Orchestrator is working on the request'
+            : `${orchestratorBot.name} is working on the request`);
+        if (this.orchestratorRuntime.kind === 'clerk') {
+            try {
+                const response = await this.executeClerkOwnedWorkDirect(prompt, conversationId, orchestratorBot, project, opts);
+                if (!response.trim()) {
+                    return {
+                        ok: false,
+                        response: 'Orchestrator returned an empty response.',
+                        error: 'Worker returned an empty response.',
+                    };
+                }
+                return this.finalizeOwnedExecutionResult({
+                    id: `orchestrator-direct-${Date.now()}`,
+                    conversationId,
+                    status: 'completed',
+                    steps: [],
+                    mergedResult: response,
+                    startedAt: Date.now(),
+                    completedAt: Date.now(),
+                }, prompt, conversationId, orchestratorBot, roleAssignments, project, opts, state, options);
+            }
+            catch (err) {
+                const failureReason = err?.message || 'Unknown error';
+                return {
+                    ok: false,
+                    response: `Orchestrator encountered an issue: ${failureReason}`,
+                    error: failureReason,
+                };
+            }
+        }
         const result = await this.runNodeWithRetry('execute_direct', state, async () => this.workflowEngine.execute(prompt, conversationId, orchestratorBot.id, {
+            abortSignal: opts.abortSignal,
             disableDecomposition: true,
             isOrchestrated: false,
             projectId: project?.id || state.projectId || null,
@@ -2096,6 +3465,7 @@ class OrchestratorAgent {
             // also persist would create duplicate assistant messages.
             persistConversationMessages: false,
             workerMode: false,
+            storedAttachments: opts.storedAttachments,
             onWorkerChunk: opts.onWorkerChunk,
             onProgress: (progress) => {
                 if (progress.event === 'step-failed') {
@@ -2165,12 +3535,15 @@ class OrchestratorAgent {
         (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, {
+            abortSignal: opts.abortSignal,
             disableDecomposition: true,
             isOrchestrated: false,
             workerMode: false,
             projectId: project?.id || state.projectId || null,
             workspacePath: project?.folder?.trim() || undefined,
             persistConversationMessages: true,
+            storedAttachments: opts.storedAttachments,
+            workerImageDeliveryMode: opts.storedAttachments?.length ? 'reference' : undefined,
             onWorkerChunk: opts.onWorkerChunk,
             onProgress: (progress) => {
                 if (progress.event === 'step-started') {
@@ -2195,9 +3568,25 @@ class OrchestratorAgent {
             return 'research';
         return 'discuss';
     }
+    /**
+     * Builds the chunk-forwarding callback used by both the bot path and the
+     * non-bot path of runOrchestratorPrompt. Wraps the exported helper.
+     */
+    buildNarrationStreamGate(onNarrationChunk) {
+        return buildNarrationStreamGate(onNarrationChunk);
+    }
     async runOrchestratorPrompt(userPrompt, systemPrompt, opts) {
         if (this.orchestratorRuntime.kind === 'bot' && opts.orchestratorBot) {
+            // Bot-backed orchestrator: stream chunks via the workflow engine.
+            // The workflow engine receives onWorkerChunk events of type 'chunk'
+            // for normal streaming text from the bot. We wrap onNarrationChunk
+            // in the same gate that the non-bot path uses, so the sentinel/JSON
+            // protection logic is consistent.
+            const narrationGate = opts.onNarrationChunk
+                ? this.buildNarrationStreamGate(opts.onNarrationChunk)
+                : null;
             const result = await this.workflowEngine.execute(userPrompt, opts.conversationId, opts.orchestratorBot.id, {
+                abortSignal: opts.abortSignal,
                 disableDecomposition: true,
                 disableTools: opts.disableTools === true,
                 isOrchestrated: false,
@@ -2205,7 +3594,18 @@ class OrchestratorAgent {
                 workspacePath: opts.workspacePath,
                 persistConversationMessages: false,
                 workerMode: false,
+                storedAttachments: opts.storedAttachments,
                 systemPromptOverride: systemPrompt,
+                ...(narrationGate ? {
+                    onWorkerChunk: async (event) => {
+                        // Only forward 'chunk' events (the bot's streaming text) into
+                        // the narration gate. Other events (step_start, tool_call, etc.)
+                        // are not narration content.
+                        if (event.type === 'chunk' && event.text) {
+                            await narrationGate(event.text);
+                        }
+                    },
+                } : {}),
             });
             this.setLastResponseMeta({
                 agentName: opts.orchestratorBot.name,
@@ -2214,60 +3614,57 @@ class OrchestratorAgent {
             });
             return this.stripWorkerProtocol(result.mergedResult || '');
         }
+        // Pattern C: stream the front-door LLM response through the narration gate.
+        const onChunk = opts.onNarrationChunk
+            ? this.buildNarrationStreamGate(opts.onNarrationChunk)
+            : undefined;
         const response = await this.orchestratorRuntime.llm.chat({
             messages: [{ role: 'user', content: userPrompt }],
             system: systemPrompt,
-            stream: false,
+            stream: !!onChunk,
             runtimeMode: 'local_desktop',
+            abortSignal: opts.abortSignal,
+            ...(onChunk ? { onChunk } : {}),
         });
         this.setLastResponseMeta({
-            agentName: this.orchestratorRuntime.agentName,
+            agentName: this.isLocalDesktopRuntime() ? 'Orchestrator' : this.orchestratorRuntime.agentName,
             botId: this.orchestratorRuntime.botId,
             modelLabel: this.orchestratorRuntime.modelLabel,
         });
         return String(response.content || '').trim();
     }
-    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)
-            || /\b(best idea|best approach|not sure what to do)\b/.test(normalized);
-        const explicitQa = /\b(john|codex|qa(?:['’/-]?d|['’/-]?ed|['’/-]?ing)?\b|quality assurance|test(?:ing)?|verify|review after|review it after|qa it|then qa|pass\/fail)\b/.test(normalized);
-        const explicitCoding = /\b(ben|claude|code|build|implement|create|write|fix|edit|html|page|ui|ux|frontend|backend|file)\b/.test(normalized);
-        const onlyCodingAndQa = /\bonly\s+coding\s+and\s+qa\b/.test(normalized) || /\bno\s+research\b/.test(normalized);
-        const mentionsWorkflow = /\b(workflow|team|todo|handoff|hand off|first\b.*\bthen\b|send .* then|after qa|after john|use my team)\b/.test(normalized);
-        const explicitCoderQaPair = explicitCoding && explicitQa;
-        const explicitResearchChain = explicitResearch && (explicitCoding || explicitQa);
-        if (!mentionsWorkflow && !explicitCoderQaPair && !explicitResearchChain) {
-            return [];
-        }
-        const roles = [];
-        if (explicitResearch && !onlyCodingAndQa)
-            roles.push('research');
-        if (explicitCoding || explicitCoderQaPair || explicitResearchChain)
-            roles.push('coding');
-        if (explicitQa || explicitCoderQaPair || explicitResearchChain)
-            roles.push('qa');
-        if (roles.length >= 2)
-            return roles;
-        if (mentionsWorkflow && roleAssignments.coding && roleAssignments.qa) {
-            return roleAssignments.research && !onlyCodingAndQa
-                ? ['research', 'coding', 'qa']
-                : ['coding', 'qa'];
-        }
-        return roles;
+    /**
+     * @deprecated Phase B of orchestration-plan.txt.
+     * Unreachable from local_desktop — that path always uses the LLM-tool
+     * dispatch in orchestration/dispatch-runner. Retained only for the
+     * non-local_desktop (connected/server) code paths that have not yet
+     * been migrated. Remove after connected-mode migration.
+     */
+    /**
+     * DEPRECATED — returns []. Previously scanned the user prompt via regex
+     * for role keywords (research/code/fix/qa/review/verify/after qa/use my
+     * team/bot names). Its output drove legacy workflow step construction.
+     * Codex audit HIGH #6: remove as an execution source. The orchestrator
+     * LLM decides the ordered role list via create_workflow now; code
+     * shouldn't infer "Ben -> John -> Ver" from English. Kept as a stub
+     * until all legacy callers are removed; downstream paths already
+     * handle an empty return by falling through to structured dispatch
+     * or user-prompted clarification.
+     */
+    inferRequestedWorkflowRoles(_prompt, _roleAssignments) {
+        return [];
     }
     orchestratorOwnsWorkflowRole(role, orchestratorBot, roleAssignments) {
         const orchestratorName = orchestratorBot.name.toLowerCase();
         const assignedName = roleAssignments[role]?.toLowerCase();
         if (assignedName)
             return assignedName === orchestratorName;
-        const roleClass = String(orchestratorBot.role_class || '').trim().toLowerCase();
         if (role === 'coding')
-            return ['code', 'coding', 'coder', 'builder', 'developer', 'engineer', 'orchestrator', 'manager'].includes(roleClass);
+            return this.agentHasAnyRole(orchestratorBot, ['code', 'coding', 'coder', 'builder', 'developer', 'engineer', 'orchestrator', 'manager']);
         if (role === 'qa')
-            return ['qa', 'review', 'reviewer'].includes(roleClass);
+            return this.agentHasAnyRole(orchestratorBot, ['qa', 'review', 'reviewer']);
         if (role === 'research')
-            return ['research', 'researcher', 'analyst', 'advisor'].includes(roleClass);
+            return this.agentHasAnyRole(orchestratorBot, ['research', 'researcher', 'analyst', 'advisor', 'brainstorming', 'planning', 'design']);
         return false;
     }
     resolveWorkflowRoleTarget(role, orchestratorBot, roleAssignments) {
@@ -2363,7 +3760,7 @@ class OrchestratorAgent {
                     'Do not build the final artifact in this step.',
                     'Your deliverable is a concrete implementation direction document that the coding step can use immediately.',
                     '',
-                    `Original user request (reference only):\n${originalPrompt}`,
+                    `Original user request:\n${originalPrompt}`,
                     artifactContext,
                     '',
                     'Your job: research the request, pressure-test the approach, and recommend the best implementation direction.',
@@ -2377,7 +3774,7 @@ class OrchestratorAgent {
                     'Do not perform QA in this step.',
                     'Your deliverable is the actual file or code change requested by the user.',
                     '',
-                    `Original user request (reference only):\n${originalPrompt}`,
+                    `Original user request:\n${originalPrompt}`,
                     artifactContext,
                     researchContext,
                     qaContext,
@@ -2395,7 +3792,7 @@ class OrchestratorAgent {
                     'You are the QA/review step in a multi-step workflow.',
                     'Do not redo the coding or research work in this step unless the file is missing and you must report that blocker.',
                     '',
-                    `Original user request (reference only):\n${originalPrompt}`,
+                    `Original user request:\n${originalPrompt}`,
                     artifactContext,
                     researchContext,
                     implementationContext,
@@ -2604,6 +4001,23 @@ class OrchestratorAgent {
             });
         }
         this.reportHiddenRoleProgress(opts, 'dispatch_controller', `Connecting request to ${agent.name}`);
+        const forwardProxyWorkerChunk = (event) => {
+            if (!opts.onWorkerChunk)
+                return;
+            if (event.type === 'chunk') {
+                opts.onWorkerChunk({ ...event, type: 'worker_chunk' });
+                return;
+            }
+            if (event.type === 'tool_call') {
+                opts.onWorkerChunk({ ...event, type: 'worker_tool_call' });
+                return;
+            }
+            if (event.type === 'tool_result') {
+                opts.onWorkerChunk({ ...event, type: 'worker_tool_result' });
+                return;
+            }
+            opts.onWorkerChunk(event);
+        };
         // Update conversation routing mode to 'proxy'
         try {
             const db = data.getDb();
@@ -2613,14 +4027,17 @@ class OrchestratorAgent {
         // Execute single step — disable decomposition for proxy mode
         const runProxyStep = (stepPrompt) => this.runNodeWithRetry('delegate_specialist', state, async () => this.workflowEngine.execute(stepPrompt, conversationId, agent.id, {
             apiKey: this.resolveApiKey(agent.provider),
+            abortSignal: opts.abortSignal,
             disableDecomposition: true,
-            isOrchestrated: true,
+            isOrchestrated: false,
             projectId: state?.projectId ?? null,
             workspacePath: state?.projectId
                 ? data.getProject(state.projectId)?.folder?.trim() || undefined
                 : undefined,
             persistConversationMessages: false,
-            onWorkerChunk: opts.onWorkerChunk,
+            storedAttachments: opts.storedAttachments,
+            workerImageDeliveryMode: opts.storedAttachments?.length ? 'reference' : undefined,
+            onWorkerChunk: forwardProxyWorkerChunk,
             onProgress: (progress) => {
                 if (progress.event === 'step-started') {
                     this.reportHiddenRoleProgress(opts, 'orchestrator', `${progress.step.agentName} is working on the delegated step`);
@@ -2888,17 +4305,22 @@ class OrchestratorAgent {
                     coderRetryLimit: effectivePolicy.coderRetryLimit,
                     workspacePath: effectiveWorkspacePath,
                     projectId: project?.id || opts.projectId || null,
+                    storedAttachments: opts.storedAttachments,
+                    workerImageDeliveryMode: opts.storedAttachments?.length ? 'reference' : undefined,
                     onProgress: progressHandler,
                     onWorkerChunk: opts.onWorkerChunk,
                 })
                 : this.workflowEngine.execute(prompt, conversationId, defaultAgent.id, {
                     apiKey: this.resolveApiKey(defaultAgent.provider),
+                    abortSignal: opts.abortSignal,
                     taskId: todoTaskId,
                     isOrchestrated: true,
                     roleAssignments,
                     coderRetryLimit: effectivePolicy.coderRetryLimit,
                     workspacePath: effectiveWorkspacePath,
                     projectId: project?.id || opts.projectId || null,
+                    storedAttachments: opts.storedAttachments,
+                    workerImageDeliveryMode: opts.storedAttachments?.length ? 'reference' : undefined,
                     onProgress: progressHandler,
                     onWorkerChunk: opts.onWorkerChunk,
                 }));
@@ -3047,6 +4469,83 @@ class OrchestratorAgent {
     reportHiddenRoleProgress(opts, roleName, detail) {
         opts.onProgress(`${roleName}::${detail}`);
     }
+    /**
+     * Returns a callback that forwards orchestrator narration chunks to the
+     * desktop as 'chunk' WorkerChunkEvents tagged with the orchestrator bot's identity.
+     * This is how the front-door narration appears live in the orchestrator card.
+     */
+    makeOrchestratorNarrationForwarder(opts, orchestratorBot) {
+        if (!opts.onWorkerChunk)
+            return undefined;
+        const stepId = `orchestrator-narration-${orchestratorBot.id}`;
+        return (text) => {
+            if (!text)
+                return;
+            try {
+                opts.onWorkerChunk?.({
+                    type: 'chunk',
+                    stepId,
+                    agentName: 'Orchestrator',
+                    description: 'Orchestrator narration',
+                    stepIndex: -1,
+                    totalSteps: 0,
+                    text,
+                });
+            }
+            catch {
+                // best-effort streaming
+            }
+        };
+    }
+    /**
+     * Synthesizes a short factual narration sentence when the LLM front-door call
+     * failed entirely and Funolio fell back to a system suggestion. Never returns
+     * robotic boilerplate — uses real bot/role names whenever available.
+     */
+    synthesizeFallbackNarration(decision, roleAssignments) {
+        const mode = decision?.mode;
+        if (!mode)
+            return null;
+        if (mode === 'delegate') {
+            const target = decision.delegate_target?.trim();
+            if (target && target.toUpperCase() !== 'NONE') {
+                return `Routing this to ${target}.`;
+            }
+            return 'Routing this to the appropriate worker.';
+        }
+        if (mode === 'workflow') {
+            // Use real worker names from assignments if available.
+            const workerNames = [];
+            if (roleAssignments) {
+                if (roleAssignments.research)
+                    workerNames.push(roleAssignments.research);
+                if (roleAssignments.coding)
+                    workerNames.push(roleAssignments.coding);
+                if (roleAssignments.qa)
+                    workerNames.push(roleAssignments.qa);
+            }
+            const uniqueNames = Array.from(new Set(workerNames.map((n) => String(n || '').trim()).filter(Boolean)));
+            if (uniqueNames.length === 0) {
+                return 'Setting up a multi-step workflow for this.';
+            }
+            if (uniqueNames.length === 1) {
+                return `Handing this to ${uniqueNames[0]} as a workflow.`;
+            }
+            if (uniqueNames.length === 2) {
+                return `Setting up a workflow with ${uniqueNames[0]} and ${uniqueNames[1]}.`;
+            }
+            const last = uniqueNames[uniqueNames.length - 1];
+            const front = uniqueNames.slice(0, -1).join(', ');
+            return `Setting up a workflow with ${front}, and ${last}.`;
+        }
+        if (mode === 'clarify') {
+            return 'I need a quick clarification before I can route this.';
+        }
+        if (mode === 'execute_self') {
+            return 'Working on this now.';
+        }
+        return null;
+    }
     formatConfirmationRequest(prompt) {
         const singleLine = String(prompt || '').replace(/\s+/g, ' ').trim();
         if (!singleLine)
@@ -3168,58 +4667,126 @@ class OrchestratorAgent {
     hasRoleAssignments(assignments) {
         return Boolean(assignments.coding || assignments.qa || assignments.research);
     }
-    loadRoleAssignments(projectId) {
-        const raw = data.getProjectSetting(projectId, ORCHESTRATOR_ROLE_SETTING_KEY);
-        if (!raw)
-            return {};
-        try {
-            const parsed = JSON.parse(raw);
-            return {
-                coding: parsed.coding || undefined,
-                qa: parsed.qa || undefined,
-                research: parsed.research || undefined,
-            };
-        }
-        catch {
-            return {};
-        }
-    }
-    mergeRoleAssignments(base, saved, inferred, incoming) {
+    mergeRoleAssignments(base, inferred, incoming) {
         return {
-            coding: incoming.coding || saved.coding || base.coding || inferred.coding,
-            qa: incoming.qa || saved.qa || base.qa || inferred.qa,
-            research: incoming.research || saved.research || base.research || inferred.research,
+            coding: incoming.coding || base.coding || inferred.coding,
+            qa: incoming.qa || base.qa || inferred.qa,
+            research: incoming.research || base.research || inferred.research,
         };
     }
     deriveRoleAssignmentsFromProject(projectId, orchestratorBot) {
         const bots = this.listProjectScopedBots(projectId);
         const result = {};
-        const roleClass = String(orchestratorBot?.role_class || '').trim().toLowerCase();
         if (orchestratorBot?.name) {
-            if (['code', 'coding', 'coder', 'builder', 'developer', 'engineer'].includes(roleClass)) {
+            if (this.agentHasAnyRole(orchestratorBot, ['code', 'coding', 'coder', 'builder', 'developer', 'engineer'])) {
                 result.coding = orchestratorBot.name;
             }
-            else if (['qa', 'review', 'reviewer'].includes(roleClass)) {
+            else if (this.agentHasAnyRole(orchestratorBot, ['qa', 'review', 'reviewer'])) {
                 result.qa = orchestratorBot.name;
             }
-            else if (['research', 'researcher', 'analyst', 'advisor'].includes(roleClass)) {
+            else if (this.agentHasAnyRole(orchestratorBot, ['research', 'researcher', 'analyst', 'advisor', 'brainstorming', 'planning', 'design'])) {
                 result.research = orchestratorBot.name;
             }
         }
-        const findByRole = (roles) => bots.find((bot) => roles.includes(String(bot.role_class || '').trim().toLowerCase()));
+        const findByRole = (roles) => bots.find((bot) => this.agentHasAnyRole(bot, roles));
         result.coding = result.coding || findByRole(['code', 'coding', 'coder', 'builder', 'developer', 'engineer'])?.name;
         result.qa = result.qa || findByRole(['qa', 'review', 'reviewer'])?.name;
-        result.research = result.research || findByRole(['research', 'researcher', 'analyst', 'advisor'])?.name;
+        result.research = result.research || findByRole(['research', 'researcher', 'analyst', 'advisor', 'brainstorming', 'planning', 'design'])?.name;
         return result;
     }
-    listProjectScopedBots(projectId) {
+    listProjectScopedBots(projectId, opts) {
+        const maybeFilterOrchestrators = (bots) => opts?.includeOrchestratorProfiles ? bots : (0, orchestrator_profile_1.filterOutOrchestratorProfiles)(bots);
         if (!projectId)
-            return (0, orchestrator_profile_1.filterOutOrchestratorProfiles)(data.listAgentProfiles());
+            return maybeFilterOrchestrators(data.listAgentProfiles());
         const project = data.getProject(projectId);
         const botIds = new Set(project?.bot_ids || []);
         const allBots = data.listAgentProfiles();
         const scoped = allBots.filter((bot) => botIds.has(bot.id));
-        return (0, orchestrator_profile_1.filterOutOrchestratorProfiles)(scoped.length > 0 ? scoped : allBots);
+        return maybeFilterOrchestrators(scoped.length > 0 ? scoped : allBots);
+    }
+    resolvePlanImportBot(plannerBotId, projectId, orchestratorBot) {
+        const candidates = this.listProjectScopedBots(projectId, { includeOrchestratorProfiles: true })
+            .filter((bot) => bot.is_active === 1);
+        const orchestratorCandidate = orchestratorBot && orchestratorBot.is_active === 1
+            ? orchestratorBot
+            : null;
+        const pool = orchestratorCandidate && !candidates.some((bot) => bot.id === orchestratorCandidate.id)
+            ? [...candidates, orchestratorCandidate]
+            : candidates;
+        const selected = pool.find((bot) => bot.id === plannerBotId);
+        if (!selected) {
+            throw new Error('Choose an active planner bot for this project.');
+        }
+        return selected;
+    }
+    async runPlanImportPlannerTurn(input) {
+        const syntheticConversationId = `${input.conversationId}::plan-import`;
+        if (input.plannerBot.provider === 'claude-cli') {
+            const manager = (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)();
+            try {
+                const result = await manager.runTurn({
+                    conversationId: syntheticConversationId,
+                    botId: input.plannerBot.id,
+                    provider: 'claude-cli',
+                    botSettings: {
+                        claude: {
+                            model: input.plannerBot.model,
+                            effortLevel: input.plannerBot.claude_effort_level,
+                            outputStyle: input.plannerBot.claude_output_style,
+                            fastMode: input.plannerBot.claude_fast_mode === 1,
+                            permissionsJson: input.plannerBot.claude_permissions_json,
+                        },
+                    },
+                    cwd: input.workspacePath,
+                    systemPrompt: input.systemPrompt,
+                    messages: input.messages,
+                    forceFreshSession: true,
+                    newSessionId: data.generateNextSessionId(),
+                    abortSignal: input.abortSignal,
+                });
+                return String(result.content || '').trim();
+            }
+            finally {
+                manager.closeSessionByConversation(syntheticConversationId, input.plannerBot.id);
+            }
+        }
+        if (input.plannerBot.provider === 'codex-cli' && !(0, storage_mode_1.isServerStorageMode)()) {
+            const manager = (0, codex_app_server_manager_1.getCodexAppServerManager)();
+            try {
+                const result = await manager.runTurn({
+                    runtimeMode: 'local_desktop',
+                    conversationId: syntheticConversationId,
+                    botId: input.plannerBot.id,
+                    botName: input.plannerBot.name,
+                    cwd: input.workspacePath,
+                    systemPrompt: input.systemPrompt,
+                    messages: input.messages,
+                    forceFreshSession: true,
+                    model: input.plannerBot.model || null,
+                    projectId: input.projectId,
+                    codexSettings: {
+                        reasoningEffort: input.plannerBot.codex_reasoning_effort,
+                        reasoningSummary: input.plannerBot.codex_reasoning_summary,
+                        personality: input.plannerBot.codex_personality,
+                        serviceTier: input.plannerBot.codex_service_tier,
+                        sandboxPolicy: input.plannerBot.codex_sandbox_policy,
+                        approvalPolicy: input.plannerBot.codex_approval_policy,
+                    },
+                    abortSignal: input.abortSignal,
+                });
+                return String(result.content || '').trim();
+            }
+            finally {
+                manager.closeSessionByConversation(syntheticConversationId, input.plannerBot.id);
+            }
+        }
+        const response = await input.plannerRuntime.llm.chat({
+            system: input.systemPrompt,
+            messages: input.messages,
+            maxOutputTokens: 20_000,
+            abortSignal: input.abortSignal,
+        });
+        return String(response?.content || '').trim();
     }
     policyRoleAssignments(policy) {
         return {
@@ -3424,35 +4991,6 @@ class OrchestratorAgent {
         }
         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));
-        const parts = [
-            merged.coding ? `${merged.coding} handles coding` : null,
-            merged.qa ? `${merged.qa} handles QA` : null,
-            merged.research ? `${merged.research} handles research` : null,
-        ].filter(Boolean);
-        if (parts.length > 0 && (0, storage_mode_1.isServerStorageMode)()) {
-            data.upsertMemoryFact({
-                agentId,
-                conversationId,
-                factType: 'operating_instruction',
-                content: `Default orchestrator assignments: ${parts.join('; ')}.`,
-                extractionMethod: 'orchestrator',
-            });
-        }
-        data.logAdminAudit({
-            actorType: 'orchestrator',
-            actorId: 'Project Manager',
-            projectId,
-            resourceType: 'project_setting',
-            resourceId: `${projectId}:${ORCHESTRATOR_ROLE_SETTING_KEY}`,
-            action: 'set_orchestrator_role_assignments',
-            request: assignments,
-            after: merged,
-            result: 'ok',
-        });
-    }
     roleAssignmentParticipants(assignments, agents) {
         return Array.from(new Set([assignments.coding, assignments.qa, assignments.research]
             .filter((name) => Boolean(name))