funolio-agent 1.0.53 → 1.0.75

package/dist/orchestrator.js

@@ -47,7 +47,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrchestratorAgent = void 0;
+exports.buildLocalDesktopOrchestratorRuntime = buildLocalDesktopOrchestratorRuntime;
+const index_1 = require("./providers/index");
 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");
@@ -61,6 +64,7 @@ const state_1 = require("./orchestration/state");
 const orchestrator_profile_1 = require("./orchestrator-profile");
 const context_window_1 = require("./context-window");
 const data = __importStar(require("./local-data"));
+const cli_session_epoch_1 = require("./cli-session-epoch");
 const storage_mode_1 = require("./storage-mode");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -81,12 +85,130 @@ const ORCHESTRATION_NODE_RETRY_LIMITS = {
     require_confirmation: 0,
 };
 // ─── Orchestrator Agent ──────────────────────────────────────────
+function resolveLocalProviderCredentials(providerName, profile) {
+    if (index_1.CLI_PROVIDERS.has(providerName)) {
+        return { apiKey: 'cli-auth' };
+    }
+    const directConnection = profile?.provider_connection_id
+        ? data.getProviderConnection(profile.provider_connection_id)
+        : undefined;
+    if (directConnection?.oauth_token) {
+        return { apiKey: directConnection.oauth_token, authMode: 'oauth-bearer' };
+    }
+    if (directConnection?.api_key_enc) {
+        return { apiKey: directConnection.api_key_enc };
+    }
+    const providerConnection = data.findProviderConnection(providerName);
+    if (providerConnection?.oauth_token) {
+        return { apiKey: providerConnection.oauth_token, authMode: 'oauth-bearer' };
+    }
+    if (providerConnection?.api_key_enc) {
+        return { apiKey: providerConnection.api_key_enc };
+    }
+    if (profile?.api_key_enc) {
+        return { apiKey: profile.api_key_enc };
+    }
+    switch (providerName) {
+        case 'anthropic':
+            if (process.env.ANTHROPIC_API_KEY)
+                return { apiKey: process.env.ANTHROPIC_API_KEY };
+            break;
+        case 'openai':
+            if (process.env.OPENAI_API_KEY)
+                return { apiKey: process.env.OPENAI_API_KEY };
+            break;
+        case 'google':
+            if (process.env.GOOGLE_API_KEY)
+                return { apiKey: process.env.GOOGLE_API_KEY };
+            break;
+    }
+    throw new Error(`No credentials configured for provider ${providerName}.`);
+}
+function buildLocalDesktopOrchestratorRuntime(selectedBot) {
+    if (data.isClerkOrchestratorEnabled()) {
+        const providerName = (data.getSetting('clerk_provider') || '').trim();
+        const model = (data.getSetting('clerk_model') || '').trim() || 'default';
+        if (!providerName) {
+            throw new Error('Clerk is selected as orchestrator, but no clerk provider is configured.');
+        }
+        const credentials = resolveLocalProviderCredentials(providerName);
+        const llm = (0, index_1.createProvider)(providerName, {
+            apiKey: credentials.apiKey,
+            model,
+            runtimeMode: 'local_desktop',
+            ...(credentials.authMode ? { authMode: credentials.authMode } : {}),
+        });
+        return {
+            kind: 'clerk',
+            llm,
+            providerName,
+            model,
+            agentName: 'Clerk',
+            botId: null,
+            modelLabel: model ? `${model} | Clerk` : 'Clerk',
+        };
+    }
+    const profile = selectedBot || data.getOrchestratorBot() || data.getDefaultAgentProfile();
+    if (!profile) {
+        throw new Error('No orchestrator or default bot is configured.');
+    }
+    const credentials = resolveLocalProviderCredentials(profile.provider, profile);
+    const llm = (0, index_1.createProvider)(profile.provider, {
+        apiKey: credentials.apiKey,
+        model: (profile.model || '').trim() || 'default',
+        runtimeMode: 'local_desktop',
+        ...(credentials.authMode ? { authMode: credentials.authMode } : {}),
+    });
+    return {
+        kind: 'bot',
+        llm,
+        providerName: profile.provider,
+        model: profile.model || null,
+        agentName: profile.name,
+        botId: profile.id,
+        modelLabel: profile.model || profile.name,
+    };
+}
 class OrchestratorAgent {
-    clerk;
+    orchestratorRuntime;
     workflowEngine;
     lastResponseMeta = null;
-    constructor(clerk, workflowEngine) {
-        this.clerk = clerk;
+    constructor(orchestratorRuntime, workflowEngine) {
+        const runtimeCandidate = orchestratorRuntime;
+        if (runtimeCandidate && typeof runtimeCandidate.kind === 'string') {
+            this.orchestratorRuntime = orchestratorRuntime;
+        }
+        else if (runtimeCandidate && typeof runtimeCandidate.respond === 'function') {
+            const runtimeInfo = typeof runtimeCandidate.getRuntimeInfo === 'function'
+                ? runtimeCandidate.getRuntimeInfo()
+                : {};
+            this.orchestratorRuntime = {
+                kind: 'clerk',
+                llm: {
+                    chat: async (options) => ({
+                        content: await runtimeCandidate.respond(String(options.messages?.[0]?.content || ''), String(options.system || '')),
+                    }),
+                },
+                providerName: runtimeInfo?.provider || 'openai',
+                model: runtimeInfo?.model || null,
+                agentName: 'Clerk',
+                botId: null,
+                modelLabel: runtimeInfo?.model ? `${runtimeInfo.model} | Clerk` : 'Clerk',
+            };
+        }
+        else {
+            this.orchestratorRuntime = {
+                kind: 'clerk',
+                llm: {
+                    chat: async () => ({ content: '' }),
+                },
+                providerName: 'openai',
+                model: null,
+                agentName: 'Orchestrator',
+                botId: null,
+                modelLabel: null,
+            };
+        }
         this.workflowEngine = workflowEngine;
     }
     isLocalDesktopRuntime() {
@@ -264,41 +386,14 @@ class OrchestratorAgent {
             if (frontDoorResult !== null)
                 return frontDoorResult;
         }
-        let intent;
-        let routedPlan;
-        if (selectedOrchestrator) {
-            this.reportHiddenRoleProgress(opts, 'intent_classifier', 'Recovering routing from code fallback');
-            intent = this.fallbackClassifyUserMessage(prompt, routingMode);
-            orchestrationState.fallbackUsed = true;
-            if (this.applyClassificationGuards(prompt, intent, routingMode)) {
-                (0, state_1.markMisrouteCorrected)(orchestrationState);
-            }
-            this.reportHiddenRoleProgress(opts, 'intent_classifier', `Classified request as ${this.describeIntentForActivity(intent)}`);
-        }
-        else {
-            this.reportHiddenRoleProgress(opts, 'intent_classifier', 'Classifying request');
-            (0, state_1.addHelperRoleUsage)(orchestrationState, 'intent_classifier');
-            routedPlan = await this.decomposeAndRouteUserMessage(prompt, conversationId, opts.projectId, routingMode);
-            const routedIntent = routedPlan?.intents.length === 1
-                ? this.buildIntentAnalysisFromRoutedIntent(routedPlan.intents[0])
-                : undefined;
-            if (routedIntent) {
-                intent = routedIntent;
-                if (this.applyClassificationGuards(prompt, intent, routingMode)) {
-                    (0, state_1.markMisrouteCorrected)(orchestrationState);
-                }
-                this.reportHiddenRoleProgress(opts, 'intent_classifier', `Routed single intent as ${this.describeIntentForActivity(intent)}`);
-            }
-            else {
-                this.reportHiddenRoleProgress(opts, 'intent_classifier', 'Classifying request');
-                intent = await this.classifyUserMessage(prompt, opts.projectId, routingMode);
-                orchestrationState.fallbackUsed = true;
-                if (this.applyClassificationGuards(prompt, intent, routingMode)) {
-                    (0, state_1.markMisrouteCorrected)(orchestrationState);
-                }
-                this.reportHiddenRoleProgress(opts, 'intent_classifier', `Classified request as ${this.describeIntentForActivity(intent)}`);
-            }
+        this.reportHiddenRoleProgress(opts, 'intent_classifier', selectedOrchestrator ? 'Recovering routing from code fallback' : 'Classifying request');
+        (0, state_1.addHelperRoleUsage)(orchestrationState, 'intent_classifier');
+        const intent = this.fallbackClassifyUserMessage(prompt, routingMode);
+        orchestrationState.fallbackUsed = true;
+        if (this.applyClassificationGuards(prompt, intent, routingMode)) {
+            (0, state_1.markMisrouteCorrected)(orchestrationState);
         }
+        this.reportHiddenRoleProgress(opts, 'intent_classifier', `Classified request as ${this.describeIntentForActivity(intent)}`);
         orchestrationState.intent = intent.intent;
         orchestrationState.taskType = intent.primaryMode;
         this.recordOrchestrationAudit(orchestrationState, 'understand_request', 'classified', intent.reasoning || `Classified as ${intent.primaryMode}.`, {
@@ -331,11 +426,6 @@ class OrchestratorAgent {
         if (this.isOrchestratorControlMessage(prompt)) {
             return this.formatOrchestratorControlResponse(prompt, effectiveAssignments, projectOverview);
         }
-        if (routedPlan && routedPlan.intents.length > 1) {
-            (0, state_1.setOrchestrationPath)(orchestrationState, 'workflow', 'workflow');
-            this.recordOrchestrationAudit(orchestrationState, 'choose_path', 'path_selected', 'Selected ordered multi-intent workflow path.', { intentCount: routedPlan.intents.length });
-            return this.handleOrderedIntentSequence(routedPlan, prompt, conversationId, opts, promptAssignments, effectiveProjectId, effectiveProject, effectivePolicy, effectiveAssignments, projectOverview);
-        }
         if (this.hasMode(intent, 'POLICY_UPDATE')) {
             (0, state_1.addHelperRoleUsage)(orchestrationState, 'policy_interpreter');
             this.reportHiddenRoleProgress(opts, 'policy_interpreter', 'Reviewing requested orchestration policy changes');
@@ -498,437 +588,6 @@ class OrchestratorAgent {
         }
         return next;
     }
-    async decomposeAndRouteUserMessage(prompt, conversationId, projectId, routingMode) {
-        try {
-            const agents = (0, orchestrator_profile_1.filterOutOrchestratorProfiles)(data.listAgentProfiles());
-            const firstPass = await this.clerk.decomposeUserIntents({
-                prompt,
-                agents,
-            });
-            if (!firstPass?.intents?.length)
-                return null;
-            let plan = firstPass;
-            if (firstPass.intents.some((intent) => intent.needsContext)) {
-                const recentTurnsText = this.buildIntentVerifierRecentTurns(conversationId);
-                const verified = await this.clerk.verifyDecomposedUserIntents({
-                    prompt,
-                    priorPlan: firstPass,
-                    recentTurnsText,
-                });
-                if (verified?.intents?.length) {
-                    plan = verified;
-                }
-            }
-            const clarificationIntents = plan.intents.filter((intent) => intent.needsClarification);
-            if (clarificationIntents.length > 0) {
-                return {
-                    intents: clarificationIntents.map((intent) => ({
-                        id: intent.id,
-                        request: intent.request,
-                        category: 'CLARIFICATION_NEEDED',
-                        targetAgent: undefined,
-                        dependsOn: [...intent.dependsOn],
-                        requirements: [...intent.requirements],
-                        confidence: intent.confidence || 'MEDIUM',
-                        needsClarification: true,
-                        clarificationQuestions: [...(intent.clarificationQuestions || [])],
-                        reasoning: plan.reasoning || 'Intent verification requires clarification before routing.',
-                    })),
-                    reasoning: plan.reasoning,
-                };
-            }
-            const routed = [];
-            for (const atom of plan.intents) {
-                const routedAtom = await this.clerk.routeIntentAtom({
-                    atom,
-                    agents,
-                    routingMode,
-                });
-                if (!routedAtom)
-                    return null;
-                routed.push(routedAtom);
-            }
-            const collapsed = this.collapseSingleWorkerPlan(prompt, routed);
-            return {
-                intents: collapsed,
-                reasoning: plan.reasoning,
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    buildIntentVerifierRecentTurns(conversationId) {
-        try {
-            const context = (0, context_window_1.getPromptContextWindow)(conversationId, 3);
-            return (0, context_window_1.formatTurnsForPrompt)(context.turns);
-        }
-        catch {
-            return '(no recent messages)';
-        }
-    }
-    collapseSingleWorkerPlan(prompt, intents) {
-        if (intents.length <= 1)
-            return intents;
-        if (this.hasExplicitOrderingLanguage(prompt))
-            return intents;
-        if (!this.hasConcreteArtifactDetails(prompt))
-            return intents;
-        if (this.countMentionedAgents(prompt) > 1)
-            return intents;
-        if (!intents.every((intent) => intent.category === 'ASK_WORKER' || intent.category === 'FULL_WORKFLOW'))
-            return intents;
-        const resolvedTargets = Array.from(new Set(intents
-            .map((intent) => (intent.targetAgent || '').trim().toLowerCase())
-            .filter(Boolean)));
-        if (resolvedTargets.length > 1 && this.countMentionedAgents(prompt) > 0)
-            return intents;
-        const mergedRequirements = Array.from(new Set(intents
-            .flatMap((intent) => [intent.request, ...intent.requirements])
-            .map((item) => item.trim())
-            .filter(Boolean)));
-        const collapsedConfidence = intents.some((intent) => (intent.confidence || 'MEDIUM') === 'LOW')
-            ? 'LOW'
-            : intents.some((intent) => (intent.confidence || 'MEDIUM') === 'MEDIUM')
-                ? 'MEDIUM'
-                : 'HIGH';
-        return [{
-                ...intents[0],
-                category: 'ASK_WORKER',
-                request: prompt.trim(),
-                targetAgent: this.countMentionedAgents(prompt) > 0
-                    ? intents.find((intent) => intent.targetAgent)?.targetAgent
-                    : undefined,
-                dependsOn: [],
-                requirements: mergedRequirements,
-                confidence: collapsedConfidence,
-                needsClarification: intents.some((intent) => intent.needsClarification),
-                clarificationQuestions: Array.from(new Set(intents.flatMap((intent) => intent.clarificationQuestions || []))),
-                reasoning: 'Collapsed multiple single-worker fragments into one deliverable for one worker.',
-            }];
-    }
-    hasExplicitOrderingLanguage(prompt) {
-        return /\b(before|after|then|first|last|next|once that is done|once done|if that succeeds|after that|follow the workflow|workflow|todo|handoff)\b/i.test(prompt);
-    }
-    buildIntentAnalysisFromRoutedIntent(routed) {
-        let primaryMode = 'DIRECT_CONVERSATION';
-        let userFacingMode = 'DIRECT_RESPONSE';
-        let targetScope = 'SELF';
-        let isMultiStep = false;
-        switch (routed.category) {
-            case 'ASK_WORKER':
-                primaryMode = 'PROXY_MODE';
-                userFacingMode = 'ASK_WORKER';
-                targetScope = 'ONE_WORKER';
-                break;
-            case 'STATUS_CHECK':
-                primaryMode = 'STATUS_INQUIRY';
-                userFacingMode = 'STATUS_CHECK';
-                break;
-            case 'POLICY_CONFIGURATION':
-                primaryMode = 'POLICY_UPDATE';
-                userFacingMode = 'POLICY_CONFIGURATION';
-                break;
-            case 'FULL_WORKFLOW':
-                primaryMode = 'WORKFLOW_MODE';
-                userFacingMode = 'FULL_WORKFLOW';
-                targetScope = 'MULTI_WORKER';
-                isMultiStep = true;
-                break;
-            case 'MEMORY_CAPTURE':
-                primaryMode = 'MEMORY_CAPTURE';
-                userFacingMode = 'DIRECT_RESPONSE';
-                break;
-            default:
-                primaryMode = 'DIRECT_CONVERSATION';
-                userFacingMode = 'DIRECT_RESPONSE';
-                break;
-        }
-        const intent = this.inferIntentFromRequest(routed.request, routed.category);
-        const targetAgent = routed.targetAgent;
-        return {
-            primaryMode,
-            secondaryModes: [],
-            executionOrder: [primaryMode],
-            userFacingMode,
-            targetScope,
-            confidence: routed.confidence,
-            intent,
-            projectMatch: undefined,
-            topicMatch: undefined,
-            targetAgent,
-            isMultiStep,
-            reasoning: routed.reasoning,
-            needsClarification: routed.category === 'CLARIFICATION_NEEDED' || routed.needsClarification,
-            clarificationQuestions: routed.clarificationQuestions,
-        };
-    }
-    inferIntentFromRequest(request, category) {
-        const normalized = request.toLowerCase();
-        if (category === 'POLICY_CONFIGURATION')
-            return 'plan';
-        if (category === 'STATUS_CHECK')
-            return 'question';
-        if (/\b(brainstorm|research|pressure-test|feasibility|is this a good idea|is this sound|evaluate this idea)\b/i.test(normalized)) {
-            return 'brainstorm';
-        }
-        if (/\b(review|qa|test|audit|verify)\b/i.test(normalized))
-            return 'review';
-        if (/\b(plan|outline|roadmap|approach)\b/i.test(normalized))
-            return 'plan';
-        if (/\b(build|code|implement|create|fix|write|update)\b/i.test(normalized))
-            return 'build';
-        if (/\b(what|how|why|when|where|show|list|find|check)\b/i.test(normalized))
-            return 'question';
-        return category === 'ASK_WORKER' ? 'discuss' : 'simple';
-    }
-    async handleOrderedIntentSequence(routedPlan, originalPrompt, conversationId, opts, promptAssignments, effectiveProjectId, effectiveProject, effectivePolicy, effectiveAssignments, projectOverview) {
-        const normalizedIntents = this.normalizeOrderedIntentSequence(originalPrompt, routedPlan.intents, effectiveAssignments);
-        this.reportHiddenRoleProgress(opts, 'intent_classifier', `Decomposed request into ${normalizedIntents.length} ordered intents`);
-        if (normalizedIntents.length > 1) {
-            opts.onProgress(this.formatOrderedIntentPlanPreview(normalizedIntents));
-        }
-        const persistedPlan = data.createIntentExecutionPlan({
-            conversationId,
-            sourcePrompt: originalPrompt,
-            reasoning: routedPlan.reasoning,
-            intents: normalizedIntents.map((intent, index) => ({
-                atomId: intent.id,
-                orderIndex: index + 1,
-                request: intent.request,
-                category: intent.category,
-                targetAgent: intent.targetAgent,
-                requirements: intent.requirements,
-                dependsOn: intent.dependsOn,
-                confidence: intent.confidence,
-                needsClarification: intent.needsClarification,
-                clarificationQuestions: intent.clarificationQuestions,
-                reasoning: intent.reasoning,
-            })),
-        });
-        data.updateIntentExecutionPlan(persistedPlan.id, { status: 'running' });
-        const lines = [];
-        let completedIntents = 0;
-        for (let index = 0; index < normalizedIntents.length; index += 1) {
-            const routed = normalizedIntents[index];
-            const persistedAtom = persistedPlan.atoms[index];
-            if (routed.category === 'CLARIFICATION_NEEDED' || routed.needsClarification) {
-                if (persistedAtom) {
-                    data.updateIntentExecutionAtom(persistedAtom.id, {
-                        status: 'blocked',
-                        error: 'Clarification required before execution.',
-                    });
-                }
-                data.updateIntentExecutionPlan(persistedPlan.id, {
-                    status: 'blocked',
-                    completedIntents,
-                });
-                const clarificationIntent = this.buildIntentAnalysisFromRoutedIntent(routed);
-                return this.formatClarificationResponse(clarificationIntent, projectOverview);
-            }
-            const intent = this.buildIntentAnalysisFromRoutedIntent(routed);
-            if (persistedAtom) {
-                data.updateIntentExecutionAtom(persistedAtom.id, {
-                    status: 'running',
-                    startedAt: new Date().toISOString().replace('T', ' ').replace('Z', ''),
-                    error: null,
-                });
-            }
-            const executionValidation = this.validateIntentExecution(routed.request, intent, effectivePolicy);
-            if (!executionValidation.ok) {
-                if (persistedAtom) {
-                    data.updateIntentExecutionAtom(persistedAtom.id, {
-                        status: 'failed',
-                        error: executionValidation.reason,
-                    });
-                }
-                data.updateIntentExecutionPlan(persistedPlan.id, {
-                    status: 'failed',
-                    completedIntents,
-                });
-                if (executionValidation.clarificationQuestions?.length) {
-                    return this.formatClarificationResponse({ ...intent, clarificationQuestions: executionValidation.clarificationQuestions }, projectOverview);
-                }
-                return `I couldn't execute step ${index + 1} safely: ${executionValidation.reason}`;
-            }
-            const executionSpec = executionValidation.executionSpec;
-            const stepHeader = `**Step ${index + 1}:** ${routed.request}`;
-            if (this.hasMode(intent, 'POLICY_UPDATE')) {
-                const policyResponse = await this.handlePolicyUpdate(routed.request, conversationId, intent, this.parseRoleAssignments(routed.request), effectiveProjectId, projectOverview, effectivePolicy);
-                if (persistedAtom) {
-                    data.updateIntentExecutionAtom(persistedAtom.id, {
-                        status: 'completed',
-                        resultSummary: this.summarizeResultForIntentPlan(policyResponse),
-                        completedAt: new Date().toISOString().replace('T', ' ').replace('Z', ''),
-                    });
-                }
-                completedIntents += 1;
-                if (index < routedPlan.intents.length - 1) {
-                    data.updateIntentExecutionPlan(persistedPlan.id, {
-                        status: 'blocked',
-                        completedIntents,
-                    });
-                    return `${policyResponse}\n\nI paused the remaining ordered steps until the policy change is confirmed.`;
-                }
-                data.updateIntentExecutionPlan(persistedPlan.id, {
-                    status: 'completed',
-                    completedIntents,
-                    finishedAt: new Date().toISOString().replace('T', ' ').replace('Z', ''),
-                });
-                return policyResponse;
-            }
-            if (this.hasMode(intent, 'STATUS_INQUIRY')) {
-                const statusResponse = this.formatStatusInquiryResponse(conversationId, effectiveProjectId);
-                if (persistedAtom) {
-                    data.updateIntentExecutionAtom(persistedAtom.id, {
-                        status: 'completed',
-                        resultSummary: this.summarizeResultForIntentPlan(statusResponse),
-                        completedAt: new Date().toISOString().replace('T', ' ').replace('Z', ''),
-                    });
-                }
-                completedIntents += 1;
-                lines.push(stepHeader);
-                lines.push(statusResponse);
-                continue;
-            }
-            if (this.hasMode(intent, 'MEMORY_CAPTURE')) {
-                const memoryResponse = this.formatMemoryCaptureResponse(routed.request);
-                if (persistedAtom) {
-                    data.updateIntentExecutionAtom(persistedAtom.id, {
-                        status: 'completed',
-                        resultSummary: this.summarizeResultForIntentPlan(memoryResponse),
-                        completedAt: new Date().toISOString().replace('T', ' ').replace('Z', ''),
-                    });
-                }
-                completedIntents += 1;
-                lines.push(stepHeader);
-                lines.push(memoryResponse);
-                continue;
-            }
-            if (executionSpec.executionMode === 'direct') {
-                const directResponse = this.handleDirectConversation(routed.request, projectOverview, effectiveAssignments);
-                if (persistedAtom) {
-                    data.updateIntentExecutionAtom(persistedAtom.id, {
-                        status: 'completed',
-                        resultSummary: this.summarizeResultForIntentPlan(directResponse),
-                        completedAt: new Date().toISOString().replace('T', ' ').replace('Z', ''),
-                    });
-                }
-                completedIntents += 1;
-                lines.push(stepHeader);
-                lines.push(directResponse);
-                continue;
-            }
-            if (executionSpec.executionMode === 'proxy') {
-                const proxyPrompt = this.buildSimpleWorkerPrompt(routed.request, executionSpec.targetAgents[0] || intent.targetAgent || 'the worker');
-                const proxyResult = await this.executeProxyRequest(proxyPrompt, conversationId, intent, opts, executionSpec, effectiveAssignments);
-                const proxyResponse = proxyResult.response;
-                if (!proxyResult.ok) {
-                    if (persistedAtom) {
-                        data.updateIntentExecutionAtom(persistedAtom.id, {
-                            status: 'failed',
-                            error: proxyResult.error || proxyResponse,
-                            completedAt: new Date().toISOString().replace('T', ' ').replace('Z', ''),
-                        });
-                    }
-                    data.updateIntentExecutionPlan(persistedPlan.id, {
-                        status: 'failed',
-                        completedIntents,
-                        finishedAt: new Date().toISOString().replace('T', ' ').replace('Z', ''),
-                    });
-                    lines.push(stepHeader);
-                    lines.push(proxyResponse);
-                    return lines.join('\n\n');
-                }
-                if (persistedAtom) {
-                    data.updateIntentExecutionAtom(persistedAtom.id, {
-                        status: 'completed',
-                        resultSummary: this.summarizeResultForIntentPlan(proxyResponse),
-                        completedAt: new Date().toISOString().replace('T', ' ').replace('Z', ''),
-                    });
-                }
-                completedIntents += 1;
-                lines.push(stepHeader);
-                lines.push(proxyResponse);
-                continue;
-            }
-            if (executionSpec.executionMode === 'workflow') {
-                const workflowResponse = await this.handleOrchestratedRequest(routed.request, conversationId, intent, executionSpec, opts, effectiveAssignments, effectiveProject);
-                if (persistedAtom) {
-                    data.updateIntentExecutionAtom(persistedAtom.id, {
-                        status: 'completed',
-                        resultSummary: this.summarizeResultForIntentPlan(workflowResponse),
-                        completedAt: new Date().toISOString().replace('T', ' ').replace('Z', ''),
-                    });
-                }
-                completedIntents += 1;
-                lines.push(stepHeader);
-                lines.push(workflowResponse);
-            }
-        }
-        data.updateIntentExecutionPlan(persistedPlan.id, {
-            status: 'completed',
-            completedIntents,
-            finishedAt: new Date().toISOString().replace('T', ' ').replace('Z', ''),
-        });
-        return lines.join('\n\n');
-    }
-    normalizeOrderedIntentSequence(prompt, intents, assignments) {
-        const collapsed = this.collapseSingleWorkerPlan(prompt, intents);
-        const normalized = collapsed.map((intent) => this.applyImplicitWorkerTarget(intent, assignments));
-        return this.dropRedundantSequentialWorkerHandoffs(normalized);
-    }
-    applyImplicitWorkerTarget(intent, assignments) {
-        if (intent.category !== 'ASK_WORKER' || intent.targetAgent || intent.needsClarification) {
-            return intent;
-        }
-        const targetAgent = this.resolveImplicitWorkerTarget(intent.request, intent.requirements, assignments);
-        return targetAgent ? { ...intent, targetAgent } : intent;
-    }
-    resolveImplicitWorkerTarget(request, requirements, assignments) {
-        const text = `${request}\n${requirements.join('\n')}`.toLowerCase();
-        if (/\b(research|brainstorm|feasibility|evaluate|pressure-test|is this sound|idea)\b/i.test(text)) {
-            return assignments.research || assignments.coding || assignments.qa;
-        }
-        if (/\b(qa|review|verify|test|audit|check)\b/i.test(text)) {
-            return assignments.qa || assignments.coding || assignments.research;
-        }
-        if (/\b(build|code|implement|create|fix|write|update|design)\b/i.test(text)) {
-            return assignments.coding || assignments.qa || assignments.research;
-        }
-        return assignments.coding || assignments.research || assignments.qa;
-    }
-    dropRedundantSequentialWorkerHandoffs(intents) {
-        if (intents.length <= 1)
-            return intents;
-        const filtered = [];
-        for (let index = 0; index < intents.length; index += 1) {
-            const current = intents[index];
-            const next = intents[index + 1];
-            const currentText = current.request.toLowerCase();
-            const nextText = next?.request.toLowerCase() || '';
-            const redundantFeedbackStep = Boolean(next &&
-                current.category === 'ASK_WORKER' &&
-                next.category === 'ASK_WORKER' &&
-                current.targetAgent &&
-                next.targetAgent &&
-                current.targetAgent.toLowerCase() === next.targetAgent.toLowerCase() &&
-                /\b(give|send|provide|pass along)\b.*\b(feedback|qa)\b/.test(currentText) &&
-                /\b(fix|implement|apply|address)\b/.test(nextText));
-            if (!redundantFeedbackStep) {
-                filtered.push(current);
-            }
-        }
-        return filtered;
-    }
-    formatOrderedIntentPlanPreview(intents) {
-        const lines = [`**Here's my plan (${intents.length} steps):**`];
-        intents.forEach((intent, index) => {
-            const agentLabel = intent.targetAgent ? ` (${intent.targetAgent})` : '';
-            lines.push(`${index + 1}. ${intent.request}${agentLabel}`);
-        });
-        return lines.join('\n');
-    }
     shouldForceProxy(prompt, intent) {
         if (intent.primaryMode === 'PROXY_MODE')
             return true;
@@ -1055,82 +714,6 @@ class OrchestratorAgent {
         // Aliases like "claude" → "Ben" cause false matches on every prompt.
         return [agent.name.trim()].filter(Boolean);
     }
-    /**
-     * Interpret user intent using the clerk.
-     * This is the structured hidden-role classifier for Phase 1.
-     */
-    async classifyUserMessage(prompt, projectId, routingMode) {
-        try {
-            const agents = (0, orchestrator_profile_1.filterOutOrchestratorProfiles)(data.listAgentProfiles());
-            const projects = data.listProjects();
-            const topics = data.listTopics({ limit: 20 });
-            const parsed = await this.clerk.classifyOrchestratorIntent({
-                prompt,
-                agents,
-                projects,
-                topics,
-                projectId,
-                routingMode,
-            });
-            if (parsed) {
-                const primaryMode = this.normalizeMode(parsed.primaryMode);
-                const secondaryModes = this.normalizeModeList(parsed.secondaryModes);
-                const executionOrder = this.normalizeModeList(parsed.executionOrder);
-                return {
-                    primaryMode,
-                    secondaryModes,
-                    executionOrder: executionOrder.length > 0
-                        ? executionOrder
-                        : [primaryMode, ...secondaryModes.filter((mode) => mode !== primaryMode)],
-                    userFacingMode: parsed.userFacingMode,
-                    targetScope: parsed.targetScope,
-                    confidence: parsed.confidence,
-                    intent: parsed.intent || 'simple',
-                    projectMatch: undefined,
-                    topicMatch: undefined,
-                    targetAgent: parsed.targetAgent || undefined,
-                    isMultiStep: Boolean(parsed.isMultiStep),
-                    reasoning: parsed.reasoning || '',
-                    needsClarification: Boolean(parsed.needsClarification),
-                    clarificationQuestions: Array.isArray(parsed.clarificationQuestions) ? parsed.clarificationQuestions.map(String) : undefined,
-                };
-            }
-        }
-        catch { /* fall through */ }
-        return this.fallbackClassifyUserMessage(prompt, routingMode);
-        // Default: treat as simple single-step
-        return {
-            primaryMode: 'DIRECT_CONVERSATION',
-            secondaryModes: [],
-            executionOrder: ['DIRECT_CONVERSATION'],
-            userFacingMode: 'DIRECT_RESPONSE',
-            targetScope: 'SELF',
-            confidence: 'LOW',
-            intent: 'simple',
-            isMultiStep: false,
-            reasoning: 'Intent analysis failed - defaulting to direct conversation',
-        };
-    }
-    normalizeMode(raw) {
-        const value = String(raw || '').trim().toUpperCase();
-        switch (value) {
-            case 'POLICY_UPDATE':
-            case 'MEMORY_CAPTURE':
-            case 'STATUS_INQUIRY':
-            case 'PROXY_MODE':
-            case 'WORKFLOW_MODE':
-                return value;
-            default:
-                return 'DIRECT_CONVERSATION';
-        }
-    }
-    normalizeModeList(raw) {
-        if (!Array.isArray(raw))
-            return [];
-        return raw
-            .map((item) => this.normalizeMode(item))
-            .filter((mode, index, list) => list.indexOf(mode) === index);
-    }
     fallbackClassifyUserMessage(prompt, routingMode) {
         const normalized = prompt.toLowerCase();
         const targetAgent = this.extractTargetAgentName(prompt);
@@ -1543,9 +1126,20 @@ class OrchestratorAgent {
         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)';
-        // Build specialists list from non-orchestrator agent profiles
+        // Build specialists list — include all bots except pure orchestrators.
+        // A bot that is_orchestrator but also has a worker role_class (code, qa, research, etc.)
+        // should still appear as an available worker.
         const allProfiles = data.listAgentProfiles();
-        const specialists = (0, orchestrator_profile_1.filterOutOrchestratorProfiles)(allProfiles)
+        const PURE_ORCHESTRATOR_ROLES = new Set(['orchestrator', 'project manager']);
+        const specialists = allProfiles
+            .filter((agent) => {
+            const rc = String(agent.role_class || '').trim().toLowerCase();
+            if (agent.is_orchestrator === 1 && PURE_ORCHESTRATOR_ROLES.has(rc))
+                return false;
+            if (!agent.is_orchestrator && (0, orchestrator_profile_1.isOrchestratorProfile)(agent))
+                return false;
+            return true;
+        })
             .map((agent) => ({
             name: agent.name,
             roleLabel: agent.role_label || agent.role_class || 'general',
@@ -1586,12 +1180,20 @@ class OrchestratorAgent {
                 fastPath: false,
             });
         }
-        const useSinglePassOrchestrator = this.isLocalDesktopRuntime();
+        const useSinglePassOrchestrator = this.isLocalDesktopRuntime() && this.orchestratorRuntime.kind === 'bot';
+        const localPromptContract = useSinglePassOrchestrator
+            ? (index_1.CLI_PROVIDERS.has(orchestratorBot.provider)
+                && conversationId
+                && !!(0, cli_session_epoch_1.selectCliSessionEpoch)(conversationId, orchestratorBot.id, orchestratorBot.provider).resumeSessionId
+                ? 'cli_recurring'
+                : 'api_or_fresh_cli')
+            : 'legacy';
         const operatingPrompt = (0, orchestrator_operating_prompt_1.buildOrchestratorOperatingPrompt)({
             orchestratorName: orchestratorBot.name,
             primaryRole: orchestratorBot.role_label || orchestratorBot.role_class || null,
             specialists,
             workflowNames,
+            localPromptContract,
             entryMode: frontDoorSignals.explicitOrchestrationRequested ? 'orchestration_bias' : 'normal',
             signalSummary: {
                 matchedBots: frontDoorSignals.matchedBots,
@@ -1622,7 +1224,6 @@ class OrchestratorAgent {
         ].join('\n');
         let decision = null;
         this.reportHiddenRoleProgress(opts, 'orchestrator', 'Understanding request');
-        opts.onProgress('Understanding request...');
         let understandingHeartbeat = setInterval(() => {
             this.reportHiddenRoleProgress(opts, 'orchestrator', 'Still understanding the request');
         }, 8_000);
@@ -1656,14 +1257,14 @@ class OrchestratorAgent {
                 }
             }
             else {
-                const result = await this.runNodeWithRetry('understand_request', state, async () => this.workflowEngine.execute(decisionPrompt, null, orchestratorBot.id, {
-                    disableDecomposition: true,
-                    disableTools: true,
+                const rawDecision = await this.runNodeWithRetry('understand_request', state, async () => this.runOrchestratorPrompt(decisionPrompt, operatingPrompt, {
+                    conversationId: null,
+                    orchestratorBot,
                     projectId: projectId || null,
                     workspacePath: project?.folder?.trim() || undefined,
-                    systemPromptOverride: operatingPrompt,
+                    disableTools: true,
                 }));
-                decision = (0, orchestrator_operating_prompt_1.parseOrchestratorFrontDoorDecision)(result.mergedResult);
+                decision = (0, orchestrator_operating_prompt_1.parseOrchestratorFrontDoorDecision)(rawDecision);
             }
         }
         catch {
@@ -1831,6 +1432,37 @@ 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');
@@ -2177,7 +1809,13 @@ class OrchestratorAgent {
         });
         let rawResponse = '';
         try {
-            rawResponse = await this.runNodeWithRetry('finalize_response', state, async () => this.respondAsClerk(blockedPrompt, 'You are Clerk. Write the user-facing blocker message after work has already started. Be concise, outcome-first, and do not restate the full original request.'));
+            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,
+                projectId: project?.id || opts.projectId || state.projectId || null,
+                workspacePath: project?.folder?.trim() || undefined,
+                disableTools: true,
+            }));
         }
         catch (error) {
             this.recordOrchestrationAudit(state, 'finalize_response', 'blocked', `Blocked final response generation failed: ${error?.message || error}`);
@@ -2208,7 +1846,13 @@ class OrchestratorAgent {
         });
         let response = '';
         try {
-            response = await this.runNodeWithRetry('finalize_response', state, async () => this.respondAsClerk(finalPrompt, 'You are Clerk. 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.'));
+            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,
+                projectId: project?.id || opts.projectId || state.projectId || null,
+                workspacePath: project?.folder?.trim() || undefined,
+                disableTools: true,
+            }));
         }
         catch (error) {
             this.recordOrchestrationAudit(state, 'finalize_response', 'blocked', `Final response generation failed: ${error?.message || error}`);
@@ -2551,6 +2195,38 @@ class OrchestratorAgent {
             return 'research';
         return 'discuss';
     }
+    async runOrchestratorPrompt(userPrompt, systemPrompt, opts) {
+        if (this.orchestratorRuntime.kind === 'bot' && opts.orchestratorBot) {
+            const result = await this.workflowEngine.execute(userPrompt, opts.conversationId, opts.orchestratorBot.id, {
+                disableDecomposition: true,
+                disableTools: opts.disableTools === true,
+                isOrchestrated: false,
+                projectId: opts.projectId ?? null,
+                workspacePath: opts.workspacePath,
+                persistConversationMessages: false,
+                workerMode: false,
+                systemPromptOverride: systemPrompt,
+            });
+            this.setLastResponseMeta({
+                agentName: opts.orchestratorBot.name,
+                botId: opts.orchestratorBot.id,
+                modelLabel: this.orchestratorRuntime.modelLabel,
+            });
+            return this.stripWorkerProtocol(result.mergedResult || '');
+        }
+        const response = await this.orchestratorRuntime.llm.chat({
+            messages: [{ role: 'user', content: userPrompt }],
+            system: systemPrompt,
+            stream: false,
+            runtimeMode: 'local_desktop',
+        });
+        this.setLastResponseMeta({
+            agentName: 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)
@@ -2879,31 +2555,6 @@ class OrchestratorAgent {
         }
         return currentProjectId || intentProjectId;
     }
-    /**
-     * Handle simple requests — route to best agent, return response.
-     */
-    async handleSimpleRequest(prompt, conversationId, intent, opts) {
-        const agents = (0, orchestrator_profile_1.filterOutOrchestratorProfiles)(data.listAgentProfiles());
-        if (agents.length === 0)
-            return 'No worker agents configured. Please add an agent in Settings.';
-        const route = await this.clerk.routeTask(prompt, agents);
-        this.reportHiddenRoleProgress(opts, 'dispatch_controller', `Routing request to ${route.agentName}`);
-        this.publishOrchestratorStatus(opts, {
-            phase: 'delegating',
-            steps: [{ index: 0, description: prompt.slice(0, 80), agentName: route.agentName, status: 'running' }],
-            currentStep: 0,
-            totalSteps: 1,
-        });
-        // Execute via workflow engine — disable decomposition for simple mode
-        const result = await this.workflowEngine.execute(prompt, conversationId, route.agentId, {
-            apiKey: this.resolveApiKey(route.provider),
-            disableDecomposition: true,
-            onWorkerChunk: opts.onWorkerChunk,
-        });
-        this.publishOrchestratorStatus(opts, { phase: 'complete', totalSteps: 1, currentStep: 1 });
-        // Strip worker protocol before returning to user
-        return this.stripWorkerProtocol(result.mergedResult);
-    }
     /**
      * Handle proxy/discussion requests — forward to specific agent.
      */
@@ -3129,15 +2780,25 @@ class OrchestratorAgent {
             if (state && workflowTemplate) {
                 state.preferredWorkflowUsed = true;
             }
-            // TODO: planWorkflow uses the cheap clerk (GPT-4o-mini). Per architecture doc,
-            // workflow planning should be done by the orchestrator LLM, not the clerk.
-            // The clerk should only do summaries, extraction, and compression.
+            const inferredWorkflowRoles = this.inferRequestedWorkflowRoles(prompt, roleAssignments);
             const plannedSteps = !workflowTemplate
-                ? await this.clerk.planWorkflow({
-                    prompt,
-                    agents,
-                    roleAssignments,
-                }).catch(() => null)
+                ? inferredWorkflowRoles.map((role, index) => {
+                    const ownerName = roleAssignments[role] || defaultAgent.name;
+                    return {
+                        description: role === 'research'
+                            ? 'Research and pressure-test the request'
+                            : role === 'qa'
+                                ? 'Review and QA the completed work'
+                                : 'Implement the requested work',
+                        agentName: ownerName,
+                        expectedOutput: role === 'qa'
+                            ? 'PASS if the work meets the request, otherwise FAIL with actionable defects'
+                            : role === 'research'
+                                ? 'Clear research findings and implementation guidance'
+                                : 'Completed implementation that satisfies the request',
+                        dependsOn: index > 0 ? [index - 1] : [],
+                    };
+                })
                 : null;
             let todoTaskId;
             if (executionSpec.allowTodoCreation) {
@@ -3307,6 +2968,36 @@ class OrchestratorAgent {
         }
         return lines.join('\n');
     }
+    /**
+     * Run completion validation on a synthesized response and append warnings
+     * if the validation finds error-severity issues. Non-blocking — always
+     * returns a response, possibly with a validation warning appended.
+     */
+    applyCompletionValidation(synthesized, result, conversationId, executionMode) {
+        try {
+            const auditMessages = conversationId
+                ? data.getMessages(conversationId, { limit: 200 }).map((m) => ({
+                    role: m.role,
+                    content: m.content,
+                    tool_calls_json: m.tool_calls_json,
+                }))
+                : [];
+            const validation = (0, validation_1.validateCompletion)(result, synthesized, auditMessages, executionMode);
+            if (!validation.valid) {
+                console.warn(`[orchestrator] Completion validation failed (confidence=${validation.confidence}):`, JSON.stringify(validation.issues));
+                return synthesized + (0, validation_1.formatValidationWarning)(validation);
+            }
+            if (validation.issues.length > 0) {
+                console.info(`[orchestrator] Completion validation passed with warnings (confidence=${validation.confidence}):`, JSON.stringify(validation.issues));
+            }
+            return synthesized;
+        }
+        catch (err) {
+            // Validation must never block the response
+            console.warn('[orchestrator] Completion validation error (non-blocking):', err);
+            return synthesized;
+        }
+    }
     /**
      * Publish orchestrator status via MQTT for UI rendering.
      */
@@ -3474,21 +3165,6 @@ class OrchestratorAgent {
         }
         return assignments;
     }
-    clerkModelLabel() {
-        const runtime = this.clerk.getRuntimeInfo();
-        if (!runtime.model)
-            return 'Clerk';
-        return `${runtime.model} | Clerk`;
-    }
-    async respondAsClerk(userPrompt, systemPrompt) {
-        const response = await this.clerk.respond(userPrompt, systemPrompt);
-        this.setLastResponseMeta({
-            agentName: 'Clerk',
-            botId: null,
-            modelLabel: this.clerkModelLabel(),
-        });
-        return response;
-    }
     hasRoleAssignments(assignments) {
         return Boolean(assignments.coding || assignments.qa || assignments.research);
     }
@@ -3670,128 +3346,14 @@ class OrchestratorAgent {
     isPolicyConfirmation(prompt) {
         return /\b(yes|yes save it|save it|save this policy|apply it|apply this|confirm|confirmed|do that|sounds right)\b/i.test(prompt.trim());
     }
-    determinePolicyScope(prompt, projectId) {
-        if (!projectId)
-            return 'user';
-        if (/\b(for|in|on|within)\s+(this|the)\s+project\b/i.test(prompt))
-            return 'project';
-        const project = data.getProject(projectId);
-        if (project && new RegExp(`\\b${project.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i').test(prompt)) {
-            return 'project';
-        }
-        return 'user';
-    }
-    extractPolicyPatch(prompt, assignments, currentPolicy) {
-        const patch = {};
-        if (/\b(?:you|o|orchestrator|project manager)\s+never\s+code(?:s)?\b|\bnot code\b/i.test(prompt))
-            patch.allowOrchestratorCode = false;
-        if (/\b(?:you|o|orchestrator|project manager)\s+never\s+qa\b|\bnot qa\b/i.test(prompt))
-            patch.allowOrchestratorQa = false;
-        if (/\b(?:you|o|orchestrator|project manager)\s+never\s+deploy(?:s)?\b|\bnot deploy\b/i.test(prompt))
-            patch.allowOrchestratorDeploy = false;
-        if (/\b(?:you|o|orchestrator|project manager)\s+never\s+simulate(?:s)?\b|\bdo not simulate\b|\bnot simulate\b/i.test(prompt))
-            patch.allowOrchestratorSimulation = false;
-        if (/\bcasual\b/i.test(prompt) && /\bdirect\b/i.test(prompt))
-            patch.tone = 'casual_direct';
-        else if (/\bcasual\b/i.test(prompt))
-            patch.tone = 'casual';
-        else if (/\bdirect\b/i.test(prompt))
-            patch.tone = 'direct';
-        if (/\bstrict\b/i.test(prompt))
-            patch.policyEnforcementLevel = 'strict';
-        if (/\bno more than (\d+)\s+times\b/i.test(prompt)) {
-            patch.coderRetryLimit = Number(prompt.match(/\bno more than (\d+)\s+times\b/i)?.[1] || currentPolicy.coderRetryLimit || 2);
-        }
-        if (/\b30\s*seconds\b/i.test(prompt))
-            patch.statusReportingMode = 'event_plus_heartbeat';
-        if (assignments.research)
-            patch.defaultIdeaReviewer = assignments.research;
-        if (assignments.coding)
-            patch.defaultCoder = assignments.coding;
-        if (assignments.qa)
-            patch.defaultQa = assignments.qa;
-        return patch;
-    }
-    sanitizeInterpretedPolicyPatch(prompt, patch) {
-        const sanitized = {};
-        const normalized = prompt.toLowerCase();
-        const mentionsCodePolicy = /\b(?:you|o|orchestrator|project manager)\b[\s\S]{0,30}\b(code|codes|coding)\b/.test(normalized);
-        const mentionsQaPolicy = /\b(?:you|o|orchestrator|project manager)\b[\s\S]{0,30}\b(qa|review|test|testing)\b/.test(normalized);
-        const mentionsDeployPolicy = /\b(?:you|o|orchestrator|project manager)\b[\s\S]{0,30}\bdeploy(?:s|ing)?\b/.test(normalized);
-        const mentionsSimulationPolicy = /\b(?:you|o|orchestrator|project manager)\b[\s\S]{0,30}\bsimulat(?:e|es|ing|ion)\b/.test(normalized);
-        if (patch.allowOrchestratorCode !== undefined && mentionsCodePolicy)
-            sanitized.allowOrchestratorCode = patch.allowOrchestratorCode;
-        if (patch.allowOrchestratorQa !== undefined && mentionsQaPolicy)
-            sanitized.allowOrchestratorQa = patch.allowOrchestratorQa;
-        if (patch.allowOrchestratorDeploy !== undefined && mentionsDeployPolicy)
-            sanitized.allowOrchestratorDeploy = patch.allowOrchestratorDeploy;
-        if (patch.allowOrchestratorSimulation !== undefined && mentionsSimulationPolicy)
-            sanitized.allowOrchestratorSimulation = patch.allowOrchestratorSimulation;
-        if (patch.defaultIdeaReviewer)
-            sanitized.defaultIdeaReviewer = patch.defaultIdeaReviewer;
-        if (patch.defaultCoder)
-            sanitized.defaultCoder = patch.defaultCoder;
-        if (patch.defaultBackendCoder)
-            sanitized.defaultBackendCoder = patch.defaultBackendCoder;
-        if (patch.defaultQa)
-            sanitized.defaultQa = patch.defaultQa;
-        if (patch.coderRetryLimit !== undefined)
-            sanitized.coderRetryLimit = patch.coderRetryLimit;
-        if (patch.statusReportingMode)
-            sanitized.statusReportingMode = patch.statusReportingMode;
-        if (patch.tone)
-            sanitized.tone = patch.tone;
-        if (patch.policyEnforcementLevel)
-            sanitized.policyEnforcementLevel = patch.policyEnforcementLevel;
-        return sanitized;
-    }
-    summarizePolicyPatch(patch) {
-        const lines = [];
-        if (patch.allowOrchestratorCode === false)
-            lines.push('O should not code');
-        if (patch.allowOrchestratorQa === false)
-            lines.push('O should not QA');
-        if (patch.allowOrchestratorDeploy === false)
-            lines.push('O should not deploy');
-        if (patch.allowOrchestratorSimulation === false)
-            lines.push('O should not simulate work');
-        if (patch.defaultIdeaReviewer)
-            lines.push(`${patch.defaultIdeaReviewer} should review ideas by default`);
-        if (patch.defaultCoder)
-            lines.push(`${patch.defaultCoder} should code by default`);
-        if (patch.defaultBackendCoder)
-            lines.push(`${patch.defaultBackendCoder} should handle backend coding by default`);
-        if (patch.defaultQa)
-            lines.push(`${patch.defaultQa} should QA by default`);
-        if (patch.coderRetryLimit !== undefined)
-            lines.push(`Coder retry limit should be ${patch.coderRetryLimit}`);
-        if (patch.statusReportingMode)
-            lines.push(`Status reporting mode should be ${patch.statusReportingMode}`);
-        if (patch.tone)
-            lines.push(`Tone should be ${patch.tone.replace(/_/g, ' ')}`);
-        if (patch.policyEnforcementLevel)
-            lines.push(`Enforcement should be ${patch.policyEnforcementLevel}`);
-        return lines;
-    }
     async handlePolicyUpdate(prompt, conversationId, intent, assignments, projectId, overview, currentPolicy) {
-        const interpreted = await this.clerk.interpretPolicyUpdate({
-            prompt,
-            currentPolicy,
-            projectName: overview?.project.name,
-        }).catch(() => null);
         const agentNames = data.listAgentProfiles().map((agent) => agent.name);
-        const sanitizedInterpretedPatch = (0, policy_detection_1.sanitizePolicyPatch)(prompt, interpreted?.patch || {}, currentPolicy);
-        const patch = {
-            ...(0, policy_detection_1.extractPolicyPatchFromPrompt)(prompt, currentPolicy, { agentNames }),
-            ...sanitizedInterpretedPatch,
-        };
-        const changes = interpreted?.summaryLines?.length
-            ? interpreted.summaryLines
-            : (0, policy_detection_1.summarizePolicyPatch)(patch);
+        const patch = (0, policy_detection_1.extractPolicyPatchFromPrompt)(prompt, currentPolicy, { agentNames });
+        const changes = (0, policy_detection_1.summarizePolicyPatch)(patch);
         if (changes.length === 0) {
             return this.formatPolicyUpdateResponse(prompt, intent, assignments, overview);
         }
-        const scope = interpreted?.scope || (0, policy_detection_1.determinePolicyScope)(prompt, overview?.project.name || undefined);
+        const scope = (0, policy_detection_1.determinePolicyScope)(prompt, overview?.project.name || undefined);
         data.setPendingOrchestrationPolicy({
             conversationId,
             projectId: scope === 'project' ? projectId || null : null,