funolio-agent 1.0.7 → 1.0.48

package/dist/orchestrator.js

@@ -61,6 +61,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 storage_mode_1 = require("./storage-mode");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -83,10 +84,20 @@ const ORCHESTRATION_NODE_RETRY_LIMITS = {
 class OrchestratorAgent {
     clerk;
     workflowEngine;
+    lastResponseMeta = null;
     constructor(clerk, workflowEngine) {
         this.clerk = clerk;
         this.workflowEngine = workflowEngine;
     }
+    isLocalDesktopRuntime() {
+        return this.workflowEngine.getRuntimeMode() === 'local_desktop';
+    }
+    getLastResponseMeta() {
+        return this.lastResponseMeta;
+    }
+    setLastResponseMeta(meta) {
+        this.lastResponseMeta = meta;
+    }
     async runNodeWithRetry(node, state, work) {
         const maxRetries = ORCHESTRATION_NODE_RETRY_LIMITS[node] ?? 0;
         let attempt = 0;
@@ -104,11 +115,60 @@ class OrchestratorAgent {
             }
         }
     }
+    getAgentRoutingReferences(agent) {
+        const refs = new Set();
+        const add = (value) => {
+            const trimmed = String(value || '').trim();
+            if (trimmed)
+                refs.add(trimmed);
+        };
+        add(agent.name);
+        const modelProviderText = `${agent.provider || ''} ${agent.model || ''}`.toLowerCase();
+        if (modelProviderText.includes('claude'))
+            add('Claude');
+        if (modelProviderText.includes('codex'))
+            add('Codex');
+        if (/\bgpt\b|gpt-/.test(modelProviderText))
+            add('GPT');
+        return Array.from(refs);
+    }
+    describeAgentResponsibilities(agent) {
+        const candidates = [
+            agent.purpose_md,
+            agent.identity_summary,
+            agent.skills_md,
+            agent.role_label,
+            agent.role_class,
+        ].map((value) => String(value || '').replace(/\s+/g, ' ').trim()).filter(Boolean);
+        for (const candidate of candidates) {
+            const cleaned = candidate
+                .replace(/^#+\s*/g, '')
+                .replace(/^\-\s*/g, '')
+                .replace(/^you are\s+/i, '')
+                .replace(/^role:\s*/i, '')
+                .trim();
+            if (cleaned) {
+                return cleaned.length > 180 ? `${cleaned.slice(0, 177).trim()}...` : cleaned;
+            }
+        }
+        const normalizedRole = String(agent.role_class || agent.role_label || '').trim().toLowerCase();
+        if (normalizedRole === 'code' || normalizedRole === 'coding') {
+            return 'implementation, code changes, fixes, and app changes';
+        }
+        if (normalizedRole === 'qa') {
+            return 'QA, review, verification, and testing';
+        }
+        if (normalizedRole === 'research') {
+            return 'brainstorming, research, planning, and evaluation';
+        }
+        return 'general assistance';
+    }
     /**
      * Main entry point. User sends a message, O handles everything.
      * Returns O's response to display to the user.
      */
     async handleUserMessage(prompt, conversationId, opts) {
+        this.lastResponseMeta = null;
         const conversation = conversationId ? data.getConversation(conversationId) : undefined;
         const routingMode = conversation?.routing_mode;
         const conversationProjectId = conversation?.project_id || opts.projectId;
@@ -137,6 +197,13 @@ class OrchestratorAgent {
         }
         const promptAssignments = this.parseRoleAssignments(prompt);
         const selectedOrchestrator = this.resolveSelectedOrchestratorBot(conversation);
+        if (selectedOrchestrator) {
+            this.setLastResponseMeta({
+                agentName: 'Orchestrator',
+                botId: selectedOrchestrator.id,
+                modelLabel: null,
+            });
+        }
         if (selectedOrchestrator) {
             orchestrationState.orchestratorBotId = selectedOrchestrator.id;
         }
@@ -197,26 +264,40 @@ class OrchestratorAgent {
             if (frontDoorResult !== null)
                 return frontDoorResult;
         }
-        this.reportHiddenRoleProgress(opts, 'intent_classifier', 'Classifying request');
-        (0, state_1.addHelperRoleUsage)(orchestrationState, 'intent_classifier');
-        const routedPlan = await this.decomposeAndRouteUserMessage(prompt, conversationId, opts.projectId, routingMode);
-        let intent = routedPlan?.intents.length === 1
-            ? this.buildIntentAnalysisFromRoutedIntent(routedPlan.intents[0])
-            : undefined;
-        if (intent) {
+        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', `Routed single intent as ${this.describeIntentForActivity(intent)}`);
+            this.reportHiddenRoleProgress(opts, 'intent_classifier', `Classified request 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);
+            (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', `Classified request as ${this.describeIntentForActivity(intent)}`);
         }
         orchestrationState.intent = intent.intent;
         orchestrationState.taskType = intent.primaryMode;
@@ -400,6 +481,7 @@ class OrchestratorAgent {
         const orchestratorOwnsCoding = orchestratorName.length > 0
             && (orchestratorName === codingOwner
                 || roleClass === 'code'
+                || roleClass === 'coding'
                 || roleClass === 'coder'
                 || roleClass === 'builder'
                 || roleClass === 'developer');
@@ -1276,9 +1358,12 @@ class OrchestratorAgent {
             return finalize(this.formatProjectKnowledgeResponse(overview, []), 'Handled project knowledge request directly.');
         }
         if (/\b(hello|hi|hey|are you there|good morning|good afternoon|good evening)\b/i.test(normalized)) {
-            return 'I’m here and ready. Tell me what you want me to coordinate.';
+            return "I'm here and ready. Tell me what you want me to coordinate.";
+        }
+        if (/\b(thanks|thank you|great work|good work|nice work|well done|awesome|perfect|just complementing you|just complimenting you|complimenting you|nothing else)\b/i.test(normalized)) {
+            return "Thanks. I'm here when you need me.";
         }
-        return 'I’m with you. Tell me whether this is a policy change, a status check, a single-worker request, or a full team workflow, and I’ll take the right path.';
+        return "I'm here. Tell me what you want to do next.";
     }
     formatPolicyUpdateResponse(prompt, intent, assignments, overview) {
         const lines = ['I’m reading that as an orchestration policy update, not as immediate work.'];
@@ -1464,11 +1549,15 @@ class OrchestratorAgent {
             .map((agent) => ({
             name: agent.name,
             roleLabel: agent.role_label || agent.role_class || 'general',
+            references: this.getAgentRoutingReferences(agent),
+            responsibilities: this.describeAgentResponsibilities(agent),
         }));
         const signalSpecialists = allProfiles
             .map((agent) => ({
             name: agent.name,
             roleLabel: agent.role_label || agent.role_class || 'general',
+            references: this.getAgentRoutingReferences(agent),
+            responsibilities: this.describeAgentResponsibilities(agent),
         }));
         // Build workflow names list from enabled templates
         const workflowNames = [];
@@ -1487,6 +1576,17 @@ class OrchestratorAgent {
             roleAssignments,
         });
         const normalizeName = (value) => String(value || '').trim().toLowerCase();
+        const systemSuggestion = this.buildFrontDoorSystemSuggestion(prompt, frontDoorSignals, promptAssignments, roleAssignments);
+        if (systemSuggestion) {
+            this.recordOrchestrationAudit(state, 'understand_request', 'path_selected', systemSuggestion.reason, {
+                decisionMode: systemSuggestion.mode,
+                delegateTarget: systemSuggestion.delegateTarget || null,
+                delegateRole: systemSuggestion.delegateRole || null,
+                suggestionConfidence: systemSuggestion.confidence || null,
+                fastPath: false,
+            });
+        }
+        const useSinglePassOrchestrator = this.isLocalDesktopRuntime();
         const operatingPrompt = (0, orchestrator_operating_prompt_1.buildOrchestratorOperatingPrompt)({
             orchestratorName: orchestratorBot.name,
             primaryRole: orchestratorBot.role_label || orchestratorBot.role_class || null,
@@ -1501,6 +1601,7 @@ class OrchestratorAgent {
                 explicitWorkflowKeyword: frontDoorSignals.explicitWorkflowKeyword,
                 explicitDelegationKeyword: frontDoorSignals.explicitDelegationKeyword,
             },
+            systemSuggestion,
             projectName: overview?.project.name || project?.name || null,
             projectFolder: project?.folder || overview?.project.folder || null,
             effectivePolicy: (0, policy_prompt_1.buildEffectivePolicyPromptSection)(policy, {
@@ -1509,6 +1610,7 @@ class OrchestratorAgent {
             }),
             recentSummary: recentSummaryText,
             lastFiveTurns: recentTurnsText,
+            decisionOnly: !useSinglePassOrchestrator,
         });
         const decisionPrompt = [
             'This is a routing decision only. Do not perform the task.',
@@ -1525,14 +1627,44 @@ class OrchestratorAgent {
             this.reportHiddenRoleProgress(opts, 'orchestrator', 'Still understanding the request');
         }, 8_000);
         try {
-            const result = await this.runNodeWithRetry('understand_request', state, async () => this.workflowEngine.execute(decisionPrompt, null, orchestratorBot.id, {
-                disableDecomposition: true,
-                disableTools: true,
-                projectId: projectId || null,
-                workspacePath: project?.folder?.trim() || undefined,
-                systemPromptOverride: operatingPrompt,
-            }));
-            decision = (0, orchestrator_operating_prompt_1.parseOrchestratorFrontDoorDecision)(result.mergedResult);
+            if (useSinglePassOrchestrator) {
+                const result = await this.runNodeWithRetry('understand_request', state, async () => this.workflowEngine.execute(prompt, conversationId, orchestratorBot.id, {
+                    disableDecomposition: true,
+                    isOrchestrated: false,
+                    projectId: projectId || null,
+                    workspacePath: project?.folder?.trim() || undefined,
+                    persistConversationMessages: false,
+                    workerMode: false,
+                    systemPromptOverride: operatingPrompt,
+                    onWorkerChunk: opts.onWorkerChunk,
+                    onProgress: (progress) => {
+                        if (progress.event === 'step-failed') {
+                            this.reportHiddenRoleProgress(opts, 'orchestrator', `${progress.step.agentName} hit an issue while working on the request`);
+                        }
+                    },
+                }));
+                const parsed = (0, orchestrator_operating_prompt_1.parseOrchestratorFrontDoorDecision)(result.mergedResult);
+                if (parsed && ['delegate', 'workflow', 'clarify', 'respond'].includes(parsed.mode)) {
+                    decision = parsed;
+                }
+                else if (parsed?.mode === 'execute_self') {
+                    decision = parsed;
+                }
+                else {
+                    clearInterval(understandingHeartbeat);
+                    return (await this.finalizeOwnedExecutionResult(result, prompt, conversationId, orchestratorBot, roleAssignments, project, opts, state)).response;
+                }
+            }
+            else {
+                const result = await this.runNodeWithRetry('understand_request', state, async () => this.workflowEngine.execute(decisionPrompt, null, orchestratorBot.id, {
+                    disableDecomposition: true,
+                    disableTools: true,
+                    projectId: projectId || null,
+                    workspacePath: project?.folder?.trim() || undefined,
+                    systemPromptOverride: operatingPrompt,
+                }));
+                decision = (0, orchestrator_operating_prompt_1.parseOrchestratorFrontDoorDecision)(result.mergedResult);
+            }
         }
         catch {
             decision = null;
@@ -1540,9 +1672,19 @@ class OrchestratorAgent {
         finally {
             clearInterval(understandingHeartbeat);
         }
+        if (!decision && systemSuggestion) {
+            decision = {
+                mode: systemSuggestion.mode,
+                reason: systemSuggestion.reason,
+                delegate_target: systemSuggestion.delegateTarget || undefined,
+                delegate_role: systemSuggestion.delegateRole || undefined,
+                delegate_request: systemSuggestion.mode === 'delegate' ? prompt : undefined,
+                workflow_request: systemSuggestion.mode === 'workflow' ? prompt : undefined,
+            };
+        }
         if (!decision) {
-            const fallbackTaskType = (0, front_door_policy_1.inferFrontDoorTaskType)(prompt);
             const promptAssignedRoles = [promptAssignments.coding, promptAssignments.qa, promptAssignments.research].filter(Boolean).length;
+            const fallbackTaskType = (0, front_door_policy_1.inferFrontDoorTaskType)(prompt);
             if (frontDoorSignals.preferredMode === 'workflow') {
                 decision = {
                     mode: 'workflow',
@@ -1572,34 +1714,59 @@ class OrchestratorAgent {
                     delegate_request: prompt,
                 };
             }
-            else if (fallbackTaskType === 'coding' && roleAssignments.coding) {
-                decision = {
-                    mode: 'delegate',
-                    reason: 'Code-based front door recovered routing for a coding task owned by the coding worker.',
-                    delegate_target: roleAssignments.coding,
-                    delegate_role: 'coding',
-                    delegate_request: prompt,
-                };
-            }
-            else if (fallbackTaskType === 'qa' && roleAssignments.qa) {
-                decision = {
-                    mode: 'delegate',
-                    reason: 'Code-based front door recovered routing for a QA task owned by the QA worker.',
-                    delegate_target: roleAssignments.qa,
-                    delegate_role: 'qa',
-                    delegate_request: prompt,
-                };
-            }
-            else if (fallbackTaskType === 'research' && roleAssignments.research) {
+            else {
                 decision = {
-                    mode: 'delegate',
-                    reason: 'Code-based front door recovered routing for a research task owned by the research worker.',
-                    delegate_target: roleAssignments.research,
-                    delegate_role: 'research',
-                    delegate_request: prompt,
+                    mode: 'execute_self',
+                    reason: 'No strong routing evidence was found. Handle the request directly.',
                 };
             }
         }
+        return this.handleFrontDoorDecision(decision, prompt, conversationId, opts, orchestratorBot, projectId, project, policy, promptAssignments, roleAssignments, overview, state, signalSpecialists, workflowNames);
+    }
+    buildFrontDoorSystemSuggestion(prompt, frontDoorSignals, promptAssignments, roleAssignments) {
+        const normalizeName = (value) => String(value || '').trim().toLowerCase();
+        const taskType = (0, front_door_policy_1.inferFrontDoorTaskType)(prompt);
+        if (taskType === 'policy' || taskType === 'status' || taskType === 'conversation')
+            return null;
+        if (/\bwhat do you think|can we|should we|do you agree|need to discuss|discuss more|is this a good idea|thoughts\??|recommend(?:ation)?\b/i.test(prompt)) {
+            return null;
+        }
+        if ((0, front_door_policy_1.isContextualWorkerReferencePrompt)(prompt))
+            return null;
+        const promptAssignedRoles = [promptAssignments.coding, promptAssignments.qa, promptAssignments.research].filter(Boolean).length;
+        const multiWorkerRequested = frontDoorSignals.matchedWorkflowNames.length > 0
+            || frontDoorSignals.preferredMode === 'workflow'
+            || taskType === 'mixed'
+            || promptAssignedRoles >= 2
+            || frontDoorSignals.matchedBots.length >= 2
+            || frontDoorSignals.matchedRoles.length >= 2;
+        if (multiWorkerRequested) {
+            return {
+                mode: 'workflow',
+                reason: frontDoorSignals.matchedWorkflowNames.length > 0
+                    ? 'Code-based front door suggests workflow because the prompt names an available workflow.'
+                    : 'Code-based front door suggests workflow because the prompt clearly points to multi-worker or staged work.',
+                confidence: frontDoorSignals.matchedWorkflowNames.length > 0 || frontDoorSignals.explicitOrchestrationRequested ? 'high' : 'medium',
+            };
+        }
+        const preferredTarget = frontDoorSignals.preferredTarget;
+        if (!preferredTarget)
+            return null;
+        const delegateRole = frontDoorSignals.matchedRoles[0]
+            || (normalizeName(preferredTarget) === normalizeName(roleAssignments.qa) ? 'qa'
+                : normalizeName(preferredTarget) === normalizeName(roleAssignments.research) ? 'research'
+                    : 'coding');
+        return {
+            mode: 'delegate',
+            reason: frontDoorSignals.explicitOrchestrationRequested
+                ? 'Code-based front door suggests delegate because the prompt explicitly requests worker assignment or TODO handling.'
+                : 'Code-based front door suggests delegate because the prompt clearly assigns one available worker or role.',
+            confidence: frontDoorSignals.explicitOrchestrationRequested ? 'high' : 'medium',
+            delegateTarget: preferredTarget,
+            delegateRole,
+        };
+    }
+    async handleFrontDoorDecision(decision, prompt, conversationId, opts, orchestratorBot, projectId, project, policy, promptAssignments, roleAssignments, overview, state, signalSpecialists, workflowNames) {
         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;
@@ -1949,6 +2116,7 @@ class OrchestratorAgent {
             const result = await this.runNodeWithRetry('run_workflow', state, async () => this.workflowEngine.execute(taskPrompt, conversationId, owner.id, {
                 apiKey: this.resolveApiKey(owner.provider),
                 taskId: task.id,
+                stepDescription: task.title,
                 disableDecomposition: true,
                 isOrchestrated: true,
                 projectId: project?.id || opts.projectId || state.projectId || null,
@@ -1989,6 +2157,7 @@ class OrchestratorAgent {
     async handleBlockedTodoTask(task, opts, state, orchestratorBot, project) {
         const policy = data.getEffectiveOrchestrationPolicy(project?.id || opts.projectId || state.projectId || undefined);
         const artifacts = data.listTodoArtifactsForTask(task.id, 'active').map((item) => item.path_or_ref);
+        const completedTasks = data.listCompletedTodoTasksForConversation(task.conversation_id || state.conversationId || '');
         const workerRole = task.task_type || task.next_worker_role || 'general';
         const blockedPrompt = (0, orchestrator_blocked_prompt_1.buildBlockedWorkerOrchestratorPrompt)({
             orchestratorName: orchestratorBot.name,
@@ -2001,33 +2170,33 @@ class OrchestratorAgent {
             workspacePath: project?.folder || null,
             effectivePolicy: policy,
             artifactRefs: artifacts,
+            completedTasks,
             blockerSummary: task.blocker_summary || 'Worker is blocked.',
             checkedContext: task.blocker_checked || 'No checked context was recorded.',
             userQuestion: task.blocker_question || 'What should happen next?',
         });
-        const response = await this.runNodeWithRetry('finalize_response', state, async () => {
-            const result = await this.workflowEngine.execute(blockedPrompt, task.conversation_id || state.conversationId || '', orchestratorBot.id, {
-                apiKey: this.resolveApiKey(orchestratorBot.provider),
-                disableDecomposition: true,
-                disableTools: true,
-                workerMode: false,
-                persistConversationMessages: false,
-                onWorkerChunk: opts.onWorkerChunk,
-                workspacePath: project?.folder?.trim() || undefined,
-            });
-            return this.stripWorkerProtocol(result.mergedResult || '');
-        });
+        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.'));
+        }
+        catch (error) {
+            this.recordOrchestrationAudit(state, 'finalize_response', 'blocked', `Blocked final response generation failed: ${error?.message || error}`);
+            rawResponse = '';
+        }
+        const response = (!rawResponse.trim() || /no steps completed\.?/i.test(rawResponse))
+            ? ''
+            : rawResponse;
         state.finalResponseDraft = response;
         return response;
     }
     async finalizeQueuedTodoChain(conversationId, opts, state, orchestratorBot, project, workflowName) {
-        const completedTasks = data.listCompletedTodoTasksForConversation(conversationId);
+        const completedTasks = data.listCompletedTodoTasksForConversation(conversationId).map((task) => ({
+            ...task,
+            artifactRefs: data.listTodoArtifactsForTask(task.id, 'completed').map((item) => item.path_or_ref),
+        }));
         if (completedTasks.length === 0) {
-            const fallback = workflowName
-                ? `The "${workflowName}" workflow finished without any completed worker output.`
-                : 'The queued workflow finished without any completed worker output.';
-            state.finalResponseDraft = fallback;
-            return fallback;
+            state.finalResponseDraft = '';
+            return '';
         }
         const policy = data.getEffectiveOrchestrationPolicy(project?.id || opts.projectId || state.projectId || undefined);
         const finalPrompt = (0, orchestrator_final_response_prompt_1.buildOrchestratorFinalResponsePrompt)({
@@ -2037,18 +2206,17 @@ class OrchestratorAgent {
             effectivePolicy: policy,
             completedTasks,
         });
-        const response = await this.runNodeWithRetry('finalize_response', state, async () => {
-            const result = await this.workflowEngine.execute(finalPrompt, conversationId, orchestratorBot.id, {
-                apiKey: this.resolveApiKey(orchestratorBot.provider),
-                disableDecomposition: true,
-                disableTools: true,
-                workerMode: false,
-                persistConversationMessages: false,
-                onWorkerChunk: opts.onWorkerChunk,
-                workspacePath: project?.folder?.trim() || undefined,
-            });
-            return this.stripWorkerProtocol(result.mergedResult || '');
-        });
+        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.'));
+        }
+        catch (error) {
+            this.recordOrchestrationAudit(state, 'finalize_response', 'blocked', `Final response generation failed: ${error?.message || error}`);
+            response = '';
+        }
+        if (!response.trim() || /no steps completed\.?/i.test(response)) {
+            response = '';
+        }
         state.finalResponseDraft = response;
         this.recordOrchestrationAudit(state, 'finalize_response', 'completed', workflowName
             ? `Completed automatic TODO dispatch for workflow "${workflowName}".`
@@ -2066,6 +2234,7 @@ class OrchestratorAgent {
                 originalPrompt: prompt,
                 stepInstruction: 'Handle this delegated request directly.',
                 owner,
+                previousWorker: null,
                 nextWorker: null,
                 projectName,
                 workspacePath,
@@ -2098,6 +2267,7 @@ class OrchestratorAgent {
                 originalPrompt: prompt,
                 stepInstruction: step.instruction,
                 owner: step.owner,
+                previousWorker: steps[index - 1]?.owner || null,
                 nextWorker: steps[index + 1]?.owner || null,
                 projectName,
                 workspacePath,
@@ -2126,6 +2296,7 @@ class OrchestratorAgent {
                 originalPrompt: prompt,
                 stepInstruction: this.defaultStepInstructionForRole(item.role, prompt),
                 owner: item.agent,
+                previousWorker: owners[index - 1]?.agent || null,
                 nextWorker: owners[index + 1]?.agent || null,
                 projectName: projectName || null,
                 workspacePath: workspacePath || null,
@@ -2178,16 +2349,34 @@ class OrchestratorAgent {
     }
     buildWorkerTaskPrompt(input) {
         const workerRole = String(input.owner.role_label || input.owner.role_class || 'general').trim() || 'general';
+        const taskType = this.normalizeTaskTypeForWorker(input.owner, null);
         const composedTask = [
             `Step instruction: ${input.stepInstruction}`,
-            '',
-            'Original user request:',
-            input.originalPrompt,
+            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.'
+                : 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.'
+                : '',
+            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
+                : '',
+            taskType === 'qa'
+                ? null
+                : 'Original user request (reference only):',
+            taskType === 'qa'
+                ? null
+                : input.originalPrompt,
         ].join('\n');
         return (0, worker_operating_prompt_1.buildWorkerOperatingPrompt)({
             workerName: input.owner.name,
             workerRole,
-            taskType: this.normalizeTaskTypeForWorker(input.owner, null),
+            taskType,
             taskTitle: input.stepInstruction,
             taskPrompt: composedTask,
             projectName: input.projectName,
@@ -2196,6 +2385,8 @@ class OrchestratorAgent {
                 heading: '',
                 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,
             nextWorkerName: input.nextWorker?.name || null,
             nextWorkerRole: input.nextWorker ? String(input.nextWorker.role_label || input.nextWorker.role_class || 'general') : null,
         });
@@ -2204,7 +2395,7 @@ class OrchestratorAgent {
         if (role === 'research')
             return `Research and plan: ${this.summarizeTodoTitle(prompt)}`;
         if (role === 'qa')
-            return `QA and verify: ${this.summarizeTodoTitle(prompt)}`;
+            return `QA and review: ${this.summarizeTodoTitle(prompt)}`;
         return `Build and implement: ${this.summarizeTodoTitle(prompt)}`;
     }
     defaultStepInstructionForRole(role, prompt) {
@@ -2212,7 +2403,7 @@ class OrchestratorAgent {
             return 'Research, brainstorm, or plan the work so the implementation handoff is specific and actionable.';
         }
         if (role === 'qa') {
-            return 'Review and QA the completed work against the original request. If issues remain, prepare a fix handoff for the previous worker.';
+            return '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 `Implement the requested work directly. Keep the original request in scope: ${prompt}`;
     }
@@ -2220,7 +2411,7 @@ class OrchestratorAgent {
         if (role === 'research')
             return 'Produce a clear handoff that gives the next worker enough detail to execute without guessing.';
         if (role === 'qa')
-            return 'Verify the work against the request and prepare the next handoff if fixes are needed.';
+            return 'Verify the delivered work against the handoff and explicit success criteria, and prepare a fix handoff if issues remain.';
         return 'Complete the requested implementation and prepare the next worker handoff.';
     }
     summarizeTodoTitle(text) {
@@ -2268,6 +2459,9 @@ class OrchestratorAgent {
                 }
             },
         }));
+        return this.finalizeOwnedExecutionResult(result, prompt, conversationId, orchestratorBot, roleAssignments, project, opts, state, options);
+    }
+    async finalizeOwnedExecutionResult(result, prompt, conversationId, orchestratorBot, roleAssignments, project, opts, state, options) {
         const response = this.stripWorkerProtocol(result.mergedResult);
         const footer = (0, status_parser_1.parseStructuredFooter)(result.mergedResult);
         const failureStep = result.steps.find((step) => step.status === 'failed');
@@ -2318,7 +2512,7 @@ class OrchestratorAgent {
             '',
             `Your task: Perform ${roleLabel} on the completed work above.`,
             role === 'qa'
-                ? 'Review the work against the original request. Report what passes and what fails. Be specific about any issues found.'
+                ? 'QA the completed work against the delivered artifact and the explicit requirements that are already present. Use the original request only to fill in missing expectations. Report what passes and what fails, and be specific about any issues found.'
                 : role === 'research'
                     ? 'Analyze the work and provide insights, suggestions, or additional research as requested.'
                     : 'Review and provide your feedback on the completed work.',
@@ -2393,7 +2587,7 @@ class OrchestratorAgent {
             return assignedName === orchestratorName;
         const roleClass = String(orchestratorBot.role_class || '').trim().toLowerCase();
         if (role === 'coding')
-            return ['code', 'coder', 'builder', 'developer', 'engineer', 'orchestrator', 'manager'].includes(roleClass);
+            return ['code', 'coding', 'coder', 'builder', 'developer', 'engineer', 'orchestrator', 'manager'].includes(roleClass);
         if (role === 'qa')
             return ['qa', 'review', 'reviewer'].includes(roleClass);
         if (role === 'research')
@@ -2667,61 +2861,8 @@ class OrchestratorAgent {
         return response;
     }
     async maybeRunFinalCriticPass(input) {
-        if (input.skip)
-            return input.candidateResponse;
-        if (input.state?.riskLevel !== 'high')
-            return input.candidateResponse;
-        const qaName = input.roleAssignments.qa;
-        if (!qaName)
-            return input.candidateResponse;
-        const agent = (0, orchestrator_profile_1.filterOutOrchestratorProfiles)(data.listAgentProfiles())
-            .find((candidate) => candidate.name.toLowerCase() === qaName.toLowerCase());
-        if (!agent)
-            return input.candidateResponse;
-        input.state && (0, state_1.addHelperRoleUsage)(input.state, 'verifier');
-        input.state && (0, state_1.addDelegateTarget)(input.state, agent.name);
-        input.state && this.recordOrchestrationAudit(input.state, 'verify_result', 'delegated', `Running final high-risk review with ${agent.name}.`, { qaAgent: agent.name });
-        const reviewPrompt = [
-            'You are performing a final high-risk review for an already-completed response.',
-            'Check for safety, consistency with the user request, and whether the response appears complete enough to show as finished.',
-            '',
-            `Original user request:\n${input.prompt}`,
-            '',
-            `Candidate final response:\n${input.candidateResponse}`,
-            '',
-            'Return this exact footer structure:',
-            'RESULT: PASS or FAIL, followed by one short sentence.',
-            'SUMMARY: one short sentence.',
-            'STATUS: PASS or FAIL',
-        ].join('\n');
-        try {
-            const result = await this.runNodeWithRetry('verify_result', input.state, async () => this.workflowEngine.execute(reviewPrompt, input.conversationId, agent.id, {
-                disableDecomposition: true,
-                disableTools: true,
-                projectId: input.project?.id || input.state?.projectId || null,
-                workspacePath: input.project?.folder?.trim() || undefined,
-            }));
-            const cleaned = this.stripWorkerProtocol(result.mergedResult);
-            const footer = (0, status_parser_1.parseStructuredFooter)(result.mergedResult);
-            if (input.state) {
-                (0, state_1.appendArtifact)(input.state, 'qaFindings', cleaned || footer.summary || footer.result || 'High-risk review completed.');
-            }
-            const status = String(footer.status || '').trim().toUpperCase();
-            if (status === 'FAIL' || status === 'BLOCKED') {
-                input.state && this.recordOrchestrationAudit(input.state, 'verify_result', 'blocked', `${agent.name} flagged the final response for revision.`, { qaStatus: status, qaSummary: footer.summary || cleaned || null });
-                return [
-                    'I paused after final review found issues that still need attention.',
-                    '',
-                    `QA review (${agent.name}): ${cleaned || footer.summary || 'The final response was not approved.'}`,
-                ].join('\n');
-            }
-            input.state && this.recordOrchestrationAudit(input.state, 'verify_result', 'verified', `${agent.name} approved the final high-risk response.`, { qaStatus: status || 'PASS' });
-            return input.candidateResponse;
-        }
-        catch (error) {
-            input.state && this.recordOrchestrationAudit(input.state, 'verify_result', 'blocked', `Final review failed to run cleanly: ${error?.message || error}`);
-            return input.candidateResponse;
-        }
+        void input;
+        return input.candidateResponse;
     }
     isHighRiskPrompt(prompt) {
         return /\b(delete|remove|destroy|drop|wipe|erase|purge|archive|unarchive|deploy|ship|publish|release|migrate|migration|schema change|database change|permission|permissions|access|oauth|token|secret|credential|auth|security|api key|provider|settings?)\b/i.test(prompt);
@@ -3215,6 +3356,14 @@ class OrchestratorAgent {
     reportHiddenRoleProgress(opts, roleName, detail) {
         opts.onProgress(`${roleName}::${detail}`);
     }
+    formatConfirmationRequest(prompt) {
+        const singleLine = String(prompt || '').replace(/\s+/g, ' ').trim();
+        if (!singleLine)
+            return 'Requested action';
+        if (singleLine.length <= 180)
+            return singleLine;
+        return `${singleLine.slice(0, 177)}...`;
+    }
     describeIntentForActivity(intent) {
         switch (intent.primaryMode) {
             case 'PROXY_MODE':
@@ -3325,6 +3474,21 @@ 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);
     }
@@ -3356,7 +3520,7 @@ class OrchestratorAgent {
         const result = {};
         const roleClass = String(orchestratorBot?.role_class || '').trim().toLowerCase();
         if (orchestratorBot?.name) {
-            if (['code', 'coder', 'builder', 'developer', 'engineer'].includes(roleClass)) {
+            if (['code', 'coding', 'coder', 'builder', 'developer', 'engineer'].includes(roleClass)) {
                 result.coding = orchestratorBot.name;
             }
             else if (['qa', 'review', 'reviewer'].includes(roleClass)) {
@@ -3367,7 +3531,7 @@ class OrchestratorAgent {
             }
         }
         const findByRole = (roles) => bots.find((bot) => roles.includes(String(bot.role_class || '').trim().toLowerCase()));
-        result.coding = result.coding || findByRole(['code', 'coder', 'builder', 'developer', 'engineer'])?.name;
+        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;
         return result;
@@ -3437,17 +3601,10 @@ class OrchestratorAgent {
             },
         });
         return [
-            'I want to pause before I do that because it looks like a higher-risk action.',
-            '',
-            `Why I paused: ${executionSpec.riskReasons.join(', ') || 'sensitive change'}.`,
-            ...(deterministicPlan.enabled
-                ? [
-                    '',
-                    'Deterministic guardrail path:',
-                    ...deterministicPlan.steps.map((step, index) => `${index + 1}. ${step}`),
-                ]
-                : []),
-            'Reply with "yes, continue" to proceed or "no, cancel" to stop here.',
+            'Are you sure you want to continue with this request?',
+            `Request: ${this.formatConfirmationRequest(prompt)}`,
+            `Reason: ${executionSpec.riskReasons.join(', ') || 'sensitive change'}.`,
+            'Reply with "yes, continue" or "no, cancel".',
         ].join('\n');
     }
     async handlePendingCheckpoint(prompt, checkpoint, opts, fallbackState) {
@@ -3457,11 +3614,14 @@ class OrchestratorAgent {
             return 'Understood. I cancelled that pending action.';
         }
         if (!this.isCheckpointConfirmation(prompt)) {
+            const pausedPrompt = typeof checkpoint.payload?.prompt === 'string'
+                ? checkpoint.payload.prompt
+                : fallbackState.userPromptRaw || '';
             return [
-                'I still have a paused high-risk action waiting for confirmation.',
-                '',
+                'I still have a paused action waiting for confirmation.',
+                `Request: ${this.formatConfirmationRequest(pausedPrompt)}`,
                 `Reason: ${checkpoint.reason}.`,
-                'Reply with "yes, continue" to resume it or "no, cancel" to discard it.',
+                'Reply with "yes, continue" or "no, cancel".',
             ].join('\n');
         }
         const payload = checkpoint.payload || {};
@@ -3710,7 +3870,7 @@ class OrchestratorAgent {
             merged.qa ? `${merged.qa} handles QA` : null,
             merged.research ? `${merged.research} handles research` : null,
         ].filter(Boolean);
-        if (parts.length > 0) {
+        if (parts.length > 0 && (0, storage_mode_1.isServerStorageMode)()) {
             data.upsertMemoryFact({
                 agentId,
                 conversationId,
@@ -3922,13 +4082,15 @@ class OrchestratorAgent {
         if (!workflow)
             return;
         data.setProjectSetting(projectId, ORCHESTRATOR_WORKFLOW_SETTING_KEY, JSON.stringify(workflow));
-        data.upsertMemoryFact({
-            agentId,
-            conversationId,
-            factType: 'operating_instruction',
-            content: `Preferred workflow for this project: ${workflow.steps.join('; ')}.`,
-            extractionMethod: 'orchestrator',
-        });
+        if ((0, storage_mode_1.isServerStorageMode)()) {
+            data.upsertMemoryFact({
+                agentId,
+                conversationId,
+                factType: 'operating_instruction',
+                content: `Preferred workflow for this project: ${workflow.steps.join('; ')}.`,
+                extractionMethod: 'orchestrator',
+            });
+        }
         data.logAdminAudit({
             actorType: 'orchestrator',
             actorId: 'Project Manager',