agentic-qe 3.6.8 → 3.6.10

package/v3/dist/coordination/workflow-orchestrator.js

@@ -1,30 +1,23 @@
 /**
  * Agentic QE v3 - Workflow Orchestrator
  * Coordinates complete QE workflows across all 12 domains
+ *
+ * Module structure (extracted for maintainability):
+ * - workflow-types.ts: All types, interfaces, events, config
+ * - workflow-builtin.ts: Built-in workflow definitions
+ * - workflow-orchestrator.ts: WorkflowOrchestrator class (this file, facade)
  */
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err, ALL_DOMAINS, } from '../shared/types/index.js';
 import { createEvent } from '../shared/events/domain-events.js';
+import { toError, toErrorMessage } from '../shared/error-utils.js';
+export { WorkflowEvents, DEFAULT_WORKFLOW_CONFIG, } from './workflow-types.js';
+import { WorkflowEvents, DEFAULT_WORKFLOW_CONFIG } from './workflow-types.js';
+// Import built-in workflows
+import { getBuiltInWorkflows, BUILTIN_WORKFLOW_IDS } from './workflow-builtin.js';
 // ============================================================================
-// Workflow Events
+// Workflow Orchestrator Implementation
 // ============================================================================
-export const WorkflowEvents = {
-    WorkflowStarted: 'workflow.WorkflowStarted',
-    WorkflowCompleted: 'workflow.WorkflowCompleted',
-    WorkflowFailed: 'workflow.WorkflowFailed',
-    WorkflowCancelled: 'workflow.WorkflowCancelled',
-    StepStarted: 'workflow.StepStarted',
-    StepCompleted: 'workflow.StepCompleted',
-    StepFailed: 'workflow.StepFailed',
-    StepSkipped: 'workflow.StepSkipped',
-};
-const DEFAULT_CONFIG = {
-    maxConcurrentWorkflows: 10,
-    defaultStepTimeout: 60000,
-    defaultWorkflowTimeout: 600000,
-    enableEventTriggers: true,
-    persistExecutions: true,
-};
 export class WorkflowOrchestrator {
     eventBus;
     memory;
@@ -39,72 +32,49 @@ export class WorkflowOrchestrator {
         this.eventBus = eventBus;
         this.memory = memory;
         this.agentCoordinator = agentCoordinator;
-        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.config = { ...DEFAULT_WORKFLOW_CONFIG, ...config };
     }
-    /**
-     * Initialize the orchestrator
-     */
     async initialize() {
         if (this.initialized)
             return;
-        // Register built-in workflows
         this.registerBuiltInWorkflows();
-        // Set up event triggers if enabled
         if (this.config.enableEventTriggers) {
             this.setupEventTriggers();
         }
-        // Load persisted workflow definitions
         await this.loadPersistedWorkflows();
         this.initialized = true;
     }
-    /**
-     * Dispose resources
-     */
     async dispose() {
-        // Cancel all active executions
         for (const execution of this.executions.values()) {
             if (execution.status === 'running') {
                 await this.cancelWorkflow(execution.executionId);
             }
         }
-        // Unsubscribe from events
         for (const subscription of this.eventSubscriptions) {
             subscription.unsubscribe();
         }
-        // Persist workflow definitions
         await this.persistWorkflows();
         this.initialized = false;
     }
-    /**
-     * Register a workflow definition
-     */
     registerWorkflow(definition) {
         try {
-            // Validate workflow
             const validationResult = this.validateWorkflowDefinition(definition);
-            if (!validationResult.success) {
+            if (!validationResult.success)
                 return validationResult;
-            }
-            // Store workflow
             this.workflows.set(definition.id, definition);
-            // Set up triggers
             if (this.config.enableEventTriggers && definition.triggers) {
                 this.registerWorkflowTriggers(definition);
             }
             return ok(undefined);
         }
         catch (error) {
-            return err(error instanceof Error ? error : new Error(String(error)));
+            return err(toError(error));
         }
     }
-    /**
-     * Unregister a workflow
-     */
     unregisterWorkflow(workflowId) {
         if (!this.workflows.has(workflowId)) {
             return err(new Error(`Workflow not found: ${workflowId}`));
         }
-        // Check for active executions
         const activeExecutions = Array.from(this.executions.values()).filter((e) => e.workflowId === workflowId && e.status === 'running');
         if (activeExecutions.length > 0) {
             return err(new Error(`Cannot unregister workflow with ${activeExecutions.length} active execution(s)`));
@@ -112,51 +82,29 @@ export class WorkflowOrchestrator {
         this.workflows.delete(workflowId);
         return ok(undefined);
     }
-    /**
-     * Execute a workflow
-     */
     async executeWorkflow(workflowId, input = {}, correlationId) {
         const workflow = this.workflows.get(workflowId);
-        if (!workflow) {
+        if (!workflow)
             return err(new Error(`Workflow not found: ${workflowId}`));
-        }
-        // Check concurrent execution limit
         const activeCount = Array.from(this.executions.values()).filter((e) => e.status === 'running').length;
         if (activeCount >= this.config.maxConcurrentWorkflows) {
             return err(new Error(`Maximum concurrent workflows (${this.config.maxConcurrentWorkflows}) reached`));
         }
         const executionId = uuidv4();
         const startedAt = new Date();
-        // Initialize execution context
         const context = {
             input,
             results: {},
-            metadata: {
-                executionId,
-                workflowId,
-                correlationId: correlationId || executionId,
-                startedAt,
-            },
+            metadata: { executionId, workflowId, correlationId: correlationId || executionId, startedAt },
         };
-        // Initialize execution status
         const execution = {
-            executionId,
-            workflowId,
-            workflowName: workflow.name,
-            status: 'running',
-            startedAt,
-            progress: 0,
-            currentSteps: [],
-            completedSteps: [],
-            failedSteps: [],
-            skippedSteps: [],
-            context,
-            stepResults: new Map(),
+            executionId, workflowId, workflowName: workflow.name,
+            status: 'running', startedAt, progress: 0,
+            currentSteps: [], completedSteps: [], failedSteps: [], skippedSteps: [],
+            context, stepResults: new Map(),
         };
         this.executions.set(executionId, execution);
-        // Publish workflow started event
         await this.publishWorkflowStarted(execution, workflow);
-        // Execute workflow asynchronously
         this.runWorkflow(workflow, execution).catch(async (error) => {
             execution.status = 'failed';
             execution.error = String(error);
@@ -166,99 +114,102 @@ export class WorkflowOrchestrator {
         });
         return ok(executionId);
     }
-    /**
-     * Get workflow execution status
-     */
     getWorkflowStatus(executionId) {
         return this.executions.get(executionId);
     }
-    /**
-     * Cancel a running workflow
-     */
     async cancelWorkflow(executionId) {
         const execution = this.executions.get(executionId);
-        if (!execution) {
+        if (!execution)
             return err(new Error(`Execution not found: ${executionId}`));
-        }
         if (execution.status !== 'running' && execution.status !== 'paused') {
             return err(new Error(`Cannot cancel workflow in status: ${execution.status}`));
         }
         execution.status = 'cancelled';
         execution.completedAt = new Date();
-        execution.duration =
-            execution.completedAt.getTime() - execution.startedAt.getTime();
-        // Publish cancellation event
+        execution.duration = execution.completedAt.getTime() - execution.startedAt.getTime();
         await this.publishEvent(WorkflowEvents.WorkflowCancelled, {
-            executionId,
-            workflowId: execution.workflowId,
-            workflowName: execution.workflowName,
+            executionId, workflowId: execution.workflowId, workflowName: execution.workflowName,
         }, execution.context.metadata.correlationId);
         return ok(undefined);
     }
-    /**
-     * Pause a running workflow
-     */
     async pauseWorkflow(executionId) {
         const execution = this.executions.get(executionId);
-        if (!execution) {
+        if (!execution)
             return err(new Error(`Execution not found: ${executionId}`));
-        }
-        if (execution.status !== 'running') {
+        if (execution.status !== 'running')
             return err(new Error(`Cannot pause workflow in status: ${execution.status}`));
-        }
         execution.status = 'paused';
         return ok(undefined);
     }
-    /**
-     * Resume a paused workflow
-     */
     async resumeWorkflow(executionId) {
         const execution = this.executions.get(executionId);
-        if (!execution) {
+        if (!execution)
             return err(new Error(`Execution not found: ${executionId}`));
-        }
-        if (execution.status !== 'paused') {
+        if (execution.status !== 'paused')
             return err(new Error(`Cannot resume workflow in status: ${execution.status}`));
-        }
         const workflow = this.workflows.get(execution.workflowId);
-        if (!workflow) {
+        if (!workflow)
             return err(new Error(`Workflow definition not found: ${execution.workflowId}`));
-        }
         execution.status = 'running';
-        // Continue execution from where it was paused
         this.runWorkflow(workflow, execution).catch(async (error) => {
             execution.status = 'failed';
             execution.error = String(error);
         });
         return ok(undefined);
     }
-    /**
-     * List registered workflows
-     */
     listWorkflows() {
         return Array.from(this.workflows.values()).map((w) => ({
-            id: w.id,
-            name: w.name,
-            description: w.description,
-            version: w.version,
-            stepCount: w.steps.length,
-            tags: w.tags,
+            id: w.id, name: w.name, description: w.description, version: w.version,
+            stepCount: w.steps.length, tags: w.tags,
             triggers: w.triggers?.map((t) => t.eventType),
         }));
     }
-    /**
-     * Get active executions
-     */
     getActiveExecutions() {
         return Array.from(this.executions.values()).filter((e) => e.status === 'running' || e.status === 'paused');
     }
-    /**
-     * Get workflow definition
-     */
     getWorkflow(workflowId) {
         return this.workflows.get(workflowId);
     }
     // ============================================================================
+    // Public Utility Methods
+    // ============================================================================
+    isActionRegistered(domain, action) {
+        return !!this.actionRegistry[domain]?.[action];
+    }
+    getRegisteredActions(domain) {
+        return Object.keys(this.actionRegistry[domain] || {});
+    }
+    getDomainsWithActions() {
+        return Object.keys(this.actionRegistry);
+    }
+    async spawnWorkflowAgent(workflowId, stepId, domain) {
+        if (!this.agentCoordinator.canSpawn())
+            return err(new Error('Agent limit reached'));
+        return this.agentCoordinator.spawn({
+            name: `workflow-agent-${workflowId.slice(0, 8)}-${stepId}`,
+            domain, type: 'coordinator',
+            capabilities: ['workflow-execution', stepId],
+            config: { workflowId, stepId },
+        });
+    }
+    async stopWorkflowAgent(agentId) {
+        return this.agentCoordinator.stop(agentId);
+    }
+    getAvailableAgentCapacity() {
+        return this.agentCoordinator.canSpawn()
+            ? this.config.maxConcurrentWorkflows - this.getActiveExecutions().length
+            : 0;
+    }
+    registerAction(domain, action, handler) {
+        const dangerousKeys = ['__proto__', 'constructor', 'prototype'];
+        if (dangerousKeys.includes(domain) || dangerousKeys.includes(action)) {
+            throw new Error('Invalid domain or action name: contains dangerous prototype key');
+        }
+        if (!this.actionRegistry[domain])
+            this.actionRegistry[domain] = {};
+        this.actionRegistry[domain][action] = handler;
+    }
+    // ============================================================================
     // Private Methods - Workflow Execution
     // ============================================================================
     async runWorkflow(workflow, execution) {
@@ -267,15 +218,11 @@ export class WorkflowOrchestrator {
             setTimeout(() => reject(new Error(`Workflow timeout after ${timeout}ms`)), timeout);
         });
         try {
-            await Promise.race([
-                this.executeSteps(workflow, execution),
-                timeoutPromise,
-            ]);
+            await Promise.race([this.executeSteps(workflow, execution), timeoutPromise]);
             if (execution.status === 'running') {
                 execution.status = 'completed';
                 execution.completedAt = new Date();
-                execution.duration =
-                    execution.completedAt.getTime() - execution.startedAt.getTime();
+                execution.duration = execution.completedAt.getTime() - execution.startedAt.getTime();
                 execution.progress = 100;
                 await this.publishWorkflowCompleted(execution);
             }
@@ -285,40 +232,29 @@ export class WorkflowOrchestrator {
                 execution.status = 'failed';
                 execution.error = String(error);
                 execution.completedAt = new Date();
-                execution.duration =
-                    execution.completedAt.getTime() - execution.startedAt.getTime();
+                execution.duration = execution.completedAt.getTime() - execution.startedAt.getTime();
                 const failedStep = execution.currentSteps[0] || 'unknown';
                 await this.publishWorkflowFailed(execution, failedStep, String(error));
             }
         }
-        // Persist execution if configured
-        if (this.config.persistExecutions) {
+        if (this.config.persistExecutions)
             await this.persistExecution(execution);
-        }
     }
     async executeSteps(workflow, execution) {
         const steps = workflow.steps;
         const completedSteps = new Set(execution.completedSteps);
         const skippedSteps = new Set(execution.skippedSteps);
         const failedSteps = new Set(execution.failedSteps);
-        // Build dependency graph
-        const pendingSteps = steps.filter((s) => !completedSteps.has(s.id) &&
-            !skippedSteps.has(s.id) &&
-            !failedSteps.has(s.id));
+        const pendingSteps = steps.filter((s) => !completedSteps.has(s.id) && !skippedSteps.has(s.id) && !failedSteps.has(s.id));
         while (pendingSteps.length > 0 && execution.status === 'running') {
-            // Find steps that are ready to execute (all dependencies satisfied)
             const readySteps = pendingSteps.filter((step) => {
                 const deps = step.dependsOn || [];
                 return deps.every((depId) => completedSteps.has(depId) || skippedSteps.has(depId));
             });
-            if (readySteps.length === 0) {
-                // Deadlock or all remaining steps have failed dependencies
+            if (readySteps.length === 0)
                 break;
-            }
-            // Determine execution mode
             const parallelSteps = readySteps.filter((s) => !s.dependsOn?.length);
             const sequentialSteps = readySteps.filter((s) => s.dependsOn?.length);
-            // Execute parallel steps concurrently
             if (parallelSteps.length > 0) {
                 execution.currentSteps = parallelSteps.map((s) => s.id);
                 const results = await Promise.allSettled(parallelSteps.map((step) => this.executeStep(step, execution, workflow)));
@@ -354,14 +290,11 @@ export class WorkflowOrchestrator {
                             return;
                         }
                     }
-                    // Remove from pending
                     const pendingIndex = pendingSteps.indexOf(step);
-                    if (pendingIndex !== -1) {
+                    if (pendingIndex !== -1)
                         pendingSteps.splice(pendingIndex, 1);
-                    }
                 }
             }
-            // Execute sequential steps one at a time
             for (const step of sequentialSteps) {
                 if (execution.status !== 'running')
                     break;
@@ -384,13 +317,10 @@ export class WorkflowOrchestrator {
                         return;
                     }
                 }
-                // Remove from pending
                 const pendingIndex = pendingSteps.indexOf(step);
-                if (pendingIndex !== -1) {
+                if (pendingIndex !== -1)
                     pendingSteps.splice(pendingIndex, 1);
-                }
             }
-            // Update progress
             const totalSteps = steps.length;
             const processedSteps = completedSteps.size + skippedSteps.size + failedSteps.size;
             execution.progress = Math.round((processedSteps / totalSteps) * 100);
@@ -399,13 +329,8 @@ export class WorkflowOrchestrator {
     }
     async executeStep(step, execution, _workflow) {
         const startedAt = new Date();
-        const result = {
-            stepId: step.id,
-            status: 'pending',
-            startedAt,
-        };
+        const result = { stepId: step.id, status: 'pending', startedAt };
         try {
-            // Check skip condition
             if (step.skipCondition && this.evaluateCondition(step.skipCondition, execution.context)) {
                 result.status = 'skipped';
                 result.completedAt = new Date();
@@ -414,7 +339,6 @@ export class WorkflowOrchestrator {
                 await this.publishStepSkipped(execution, step);
                 return result;
             }
-            // Check execution condition
             if (step.condition && !this.evaluateCondition(step.condition, execution.context)) {
                 result.status = 'skipped';
                 result.completedAt = new Date();
@@ -425,9 +349,7 @@ export class WorkflowOrchestrator {
             }
             result.status = 'running';
             await this.publishStepStarted(execution, step);
-            // Build input from mapping
             const input = this.buildStepInput(step, execution.context);
-            // Execute with retry logic
             let lastError;
             const maxAttempts = step.retry?.maxAttempts || 1;
             let backoffMs = step.retry?.backoffMs || 1000;
@@ -437,7 +359,6 @@ export class WorkflowOrchestrator {
                 try {
                     const stepTimeout = step.timeout || this.config.defaultStepTimeout;
                     const output = await this.executeStepAction(step, input, execution.context, stepTimeout);
-                    // Map output to context
                     this.mapStepOutput(step, output, execution.context);
                     result.status = 'completed';
                     result.output = output;
@@ -448,29 +369,26 @@ export class WorkflowOrchestrator {
                     return result;
                 }
                 catch (error) {
-                    lastError = error instanceof Error ? error : new Error(String(error));
+                    lastError = toError(error);
                     if (attempt < maxAttempts) {
                         await this.delay(backoffMs);
                         backoffMs *= backoffMultiplier;
                     }
                 }
             }
-            // All retries failed
             result.status = 'failed';
             result.error = lastError?.message || 'Unknown error';
             result.completedAt = new Date();
             result.duration = result.completedAt.getTime() - startedAt.getTime();
             execution.stepResults.set(step.id, result);
-            // Execute rollback if defined
-            if (step.rollback) {
+            if (step.rollback)
                 await this.executeRollback(step.rollback, execution.context);
-            }
             await this.publishStepFailed(execution, step, result.error);
             return result;
         }
         catch (error) {
             result.status = 'failed';
-            result.error = error instanceof Error ? error.message : String(error);
+            result.error = toErrorMessage(error);
             result.completedAt = new Date();
             result.duration = result.completedAt.getTime() - startedAt.getTime();
             execution.stepResults.set(step.id, result);
@@ -479,92 +397,31 @@ export class WorkflowOrchestrator {
         }
     }
     async executeStepAction(step, input, context, timeout) {
-        // Check if action is registered
         const domainActions = this.actionRegistry[step.domain];
         if (domainActions?.[step.action]) {
             const timeoutPromise = new Promise((_, reject) => {
                 setTimeout(() => reject(new Error(`Step timeout after ${timeout}ms`)), timeout);
             });
-            const actionResult = await Promise.race([
-                domainActions[step.action](input, context),
-                timeoutPromise,
-            ]);
-            if (!actionResult.success) {
+            const actionResult = await Promise.race([domainActions[step.action](input, context), timeoutPromise]);
+            if (!actionResult.success)
                 throw actionResult.error;
-            }
             return actionResult.value;
         }
-        // No action registered - throw error rather than fake success
         throw new Error(`Action '${step.action}' not registered for domain '${step.domain}'. ` +
             `Register it using orchestrator.registerAction('${step.domain}', '${step.action}', handler)`);
     }
-    /**
-     * Check if an action is registered for a domain
-     */
-    isActionRegistered(domain, action) {
-        return !!this.actionRegistry[domain]?.[action];
-    }
-    /**
-     * Get all registered actions for a domain
-     */
-    getRegisteredActions(domain) {
-        return Object.keys(this.actionRegistry[domain] || {});
-    }
-    /**
-     * Get all domains with registered actions
-     */
-    getDomainsWithActions() {
-        return Object.keys(this.actionRegistry);
-    }
-    /**
-     * Spawn a workflow agent for complex step execution
-     * Used when steps require dedicated agent resources
-     */
-    async spawnWorkflowAgent(workflowId, stepId, domain) {
-        if (!this.agentCoordinator.canSpawn()) {
-            return err(new Error('Agent limit reached'));
-        }
-        return this.agentCoordinator.spawn({
-            name: `workflow-agent-${workflowId.slice(0, 8)}-${stepId}`,
-            domain,
-            type: 'coordinator',
-            capabilities: ['workflow-execution', stepId],
-            config: {
-                workflowId,
-                stepId,
-            },
-        });
-    }
-    /**
-     * Stop a workflow agent after step completion
-     */
-    async stopWorkflowAgent(agentId) {
-        return this.agentCoordinator.stop(agentId);
-    }
-    /**
-     * Get the number of agents available for workflow execution
-     */
-    getAvailableAgentCapacity() {
-        return this.agentCoordinator.canSpawn()
-            ? this.config.maxConcurrentWorkflows - this.getActiveExecutions().length
-            : 0;
-    }
     async executeRollback(rollback, context) {
         try {
-            // Check if rollback action is registered
             const domainActions = this.actionRegistry[rollback.domain];
             if (!domainActions?.[rollback.action]) {
                 console.warn(`Rollback action '${rollback.action}' not registered for domain '${rollback.domain}'. Skipping rollback.`);
                 return;
             }
-            // Execute rollback action
             const result = await domainActions[rollback.action](rollback.input || {}, context);
-            if (!result.success) {
+            if (!result.success)
                 console.error(`Rollback failed for ${rollback.domain}.${rollback.action}:`, result.error);
-            }
         }
         catch (error) {
-            // Log but don't throw - rollback failures shouldn't cascade
             console.error(`Rollback failed for ${rollback.domain}.${rollback.action}:`, error);
         }
     }
@@ -576,23 +433,19 @@ export class WorkflowOrchestrator {
         if (step.inputMapping) {
             for (const [targetKey, sourcePath] of Object.entries(step.inputMapping)) {
                 const value = this.getValueByPath(context, sourcePath);
-                if (value !== undefined) {
+                if (value !== undefined)
                     input[targetKey] = value;
-                }
             }
         }
         return input;
     }
     mapStepOutput(step, output, context) {
-        // Store raw output
         context.results[step.id] = output;
-        // Apply output mapping
         if (step.outputMapping && typeof output === 'object' && output !== null) {
             for (const [sourcePath, targetPath] of Object.entries(step.outputMapping)) {
                 const value = this.getValueByPath(output, sourcePath);
-                if (value !== undefined) {
+                if (value !== undefined)
                     this.setValueByPath(context.results, targetPath, value);
-                }
             }
         }
     }
@@ -600,60 +453,37 @@ export class WorkflowOrchestrator {
         const parts = path.split('.');
         let current = obj;
         for (const part of parts) {
-            if (current === null || current === undefined) {
+            if (current === null || current === undefined)
                 return undefined;
-            }
-            if (typeof current === 'object') {
+            if (typeof current === 'object')
                 current = current[part];
-            }
-            else {
+            else
                 return undefined;
-            }
         }
         return current;
     }
     setValueByPath(obj, path, value) {
         const parts = path.split('.');
-        // Guard against prototype pollution - check ALL parts before any assignment
         const dangerousKeys = new Set(['__proto__', 'constructor', 'prototype']);
         for (const part of parts) {
-            if (dangerousKeys.has(part)) {
+            if (dangerousKeys.has(part))
                 throw new Error(`Invalid path: contains dangerous prototype key`);
-            }
         }
         let current = obj;
         for (let i = 0; i < parts.length - 1; i++) {
             const part = parts[i];
-            // CodeQL fix: Immediate dangerous key check before property access
-            if (dangerousKeys.has(part)) {
+            if (dangerousKeys.has(part))
                 throw new Error(`Invalid path segment: '${part}' is a dangerous prototype key`);
-            }
-            // Use Object.hasOwn for safe property check
             if (!Object.hasOwn(current, part)) {
-                // Use Object.defineProperty for safe assignment
-                Object.defineProperty(current, part, {
-                    value: Object.create(null),
-                    writable: true,
-                    enumerable: true,
-                    configurable: true,
-                });
+                Object.defineProperty(current, part, { value: Object.create(null), writable: true, enumerable: true, configurable: true });
             }
             current = current[part];
         }
         const finalKey = parts[parts.length - 1];
-        // CodeQL fix: Immediate dangerous key check before Object.defineProperty
-        if (dangerousKeys.has(finalKey)) {
+        if (dangerousKeys.has(finalKey))
             throw new Error(`Invalid final key: '${finalKey}' is a dangerous prototype key`);
-        }
-        // Use Object.defineProperty for safe final assignment
-        // CodeQL: False positive - finalKey validated against dangerousKeys Set above
         // lgtm[js/prototype-pollution-utility]
-        Object.defineProperty(current, finalKey, {
-            value,
-            writable: true,
-            enumerable: true,
-            configurable: true,
-        });
+        Object.defineProperty(current, finalKey, { value, writable: true, enumerable: true, configurable: true });
     }
     // ============================================================================
     // Private Methods - Condition Evaluation
@@ -661,138 +491,95 @@ export class WorkflowOrchestrator {
     evaluateCondition(condition, context) {
         const value = this.getValueByPath(context, condition.path);
         switch (condition.operator) {
-            case 'eq':
-                return value === condition.value;
-            case 'neq':
-                return value !== condition.value;
-            case 'gt':
-                return typeof value === 'number' && value > condition.value;
-            case 'gte':
-                return typeof value === 'number' && value >= condition.value;
-            case 'lt':
-                return typeof value === 'number' && value < condition.value;
-            case 'lte':
-                return typeof value === 'number' && value <= condition.value;
+            case 'eq': return value === condition.value;
+            case 'neq': return value !== condition.value;
+            case 'gt': return typeof value === 'number' && value > condition.value;
+            case 'gte': return typeof value === 'number' && value >= condition.value;
+            case 'lt': return typeof value === 'number' && value < condition.value;
+            case 'lte': return typeof value === 'number' && value <= condition.value;
             case 'contains':
-                if (Array.isArray(value)) {
+                if (Array.isArray(value))
                     return value.includes(condition.value);
-                }
-                if (typeof value === 'string') {
+                if (typeof value === 'string')
                     return value.includes(String(condition.value));
-                }
-                return false;
-            case 'exists':
-                return value !== undefined && value !== null;
-            default:
                 return false;
+            case 'exists': return value !== undefined && value !== null;
+            default: return false;
         }
     }
     // ============================================================================
     // Private Methods - Event Publishing
     // ============================================================================
     async publishEvent(type, payload, correlationId) {
-        const event = createEvent(type, 'learning-optimization', // Workflow orchestrator publishes as coordination
-        payload, correlationId);
+        const event = createEvent(type, 'learning-optimization', payload, correlationId);
         await this.eventBus.publish(event);
     }
     async publishWorkflowStarted(execution, workflow) {
         await this.publishEvent(WorkflowEvents.WorkflowStarted, {
-            executionId: execution.executionId,
-            workflowId: execution.workflowId,
-            workflowName: execution.workflowName,
-            stepCount: workflow.steps.length,
+            executionId: execution.executionId, workflowId: execution.workflowId,
+            workflowName: execution.workflowName, stepCount: workflow.steps.length,
         }, execution.context.metadata.correlationId);
     }
     async publishWorkflowCompleted(execution) {
         await this.publishEvent(WorkflowEvents.WorkflowCompleted, {
-            executionId: execution.executionId,
-            workflowId: execution.workflowId,
-            workflowName: execution.workflowName,
-            duration: execution.duration || 0,
-            completedSteps: execution.completedSteps.length,
-            skippedSteps: execution.skippedSteps.length,
+            executionId: execution.executionId, workflowId: execution.workflowId,
+            workflowName: execution.workflowName, duration: execution.duration || 0,
+            completedSteps: execution.completedSteps.length, skippedSteps: execution.skippedSteps.length,
         }, execution.context.metadata.correlationId);
     }
     async publishWorkflowFailed(execution, failedStep, error) {
         await this.publishEvent(WorkflowEvents.WorkflowFailed, {
-            executionId: execution.executionId,
-            workflowId: execution.workflowId,
-            workflowName: execution.workflowName,
-            failedStep,
-            error,
+            executionId: execution.executionId, workflowId: execution.workflowId,
+            workflowName: execution.workflowName, failedStep, error,
         }, execution.context.metadata.correlationId);
     }
     async publishStepStarted(execution, step) {
         await this.publishEvent(WorkflowEvents.StepStarted, {
-            executionId: execution.executionId,
-            workflowId: execution.workflowId,
-            stepId: step.id,
-            stepName: step.name,
-            domain: step.domain,
+            executionId: execution.executionId, workflowId: execution.workflowId,
+            stepId: step.id, stepName: step.name, domain: step.domain,
         }, execution.context.metadata.correlationId);
     }
     async publishStepCompleted(execution, step, result) {
         await this.publishEvent(WorkflowEvents.StepCompleted, {
-            executionId: execution.executionId,
-            workflowId: execution.workflowId,
-            stepId: step.id,
-            stepName: step.name,
-            domain: step.domain,
-            duration: result.duration,
+            executionId: execution.executionId, workflowId: execution.workflowId,
+            stepId: step.id, stepName: step.name, domain: step.domain, duration: result.duration,
         }, execution.context.metadata.correlationId);
     }
     async publishStepFailed(execution, step, error) {
         await this.publishEvent(WorkflowEvents.StepFailed, {
-            executionId: execution.executionId,
-            workflowId: execution.workflowId,
-            stepId: step.id,
-            stepName: step.name,
-            domain: step.domain,
-            error,
+            executionId: execution.executionId, workflowId: execution.workflowId,
+            stepId: step.id, stepName: step.name, domain: step.domain, error,
         }, execution.context.metadata.correlationId);
     }
     async publishStepSkipped(execution, step) {
         await this.publishEvent(WorkflowEvents.StepSkipped, {
-            executionId: execution.executionId,
-            workflowId: execution.workflowId,
-            stepId: step.id,
-            stepName: step.name,
-            domain: step.domain,
+            executionId: execution.executionId, workflowId: execution.workflowId,
+            stepId: step.id, stepName: step.name, domain: step.domain,
         }, execution.context.metadata.correlationId);
     }
     // ============================================================================
     // Private Methods - Workflow Validation
     // ============================================================================
     validateWorkflowDefinition(definition) {
-        if (!definition.id) {
+        if (!definition.id)
             return err(new Error('Workflow ID is required'));
-        }
-        if (!definition.name) {
+        if (!definition.name)
             return err(new Error('Workflow name is required'));
-        }
-        if (!definition.steps || definition.steps.length === 0) {
+        if (!definition.steps || definition.steps.length === 0)
             return err(new Error('Workflow must have at least one step'));
-        }
-        // Validate steps
         const stepIds = new Set();
         for (const step of definition.steps) {
-            if (!step.id) {
+            if (!step.id)
                 return err(new Error('Step ID is required'));
-            }
-            if (stepIds.has(step.id)) {
+            if (stepIds.has(step.id))
                 return err(new Error(`Duplicate step ID: ${step.id}`));
-            }
             stepIds.add(step.id);
-            if (!step.domain) {
+            if (!step.domain)
                 return err(new Error(`Step ${step.id} must have a domain`));
-            }
-            if (!ALL_DOMAINS.includes(step.domain)) {
+            if (!ALL_DOMAINS.includes(step.domain))
                 return err(new Error(`Invalid domain for step ${step.id}: ${step.domain}`));
-            }
-            if (!step.action) {
+            if (!step.action)
                 return err(new Error(`Step ${step.id} must have an action`));
-            }
-            // Validate dependencies
             if (step.dependsOn) {
                 for (const dep of step.dependsOn) {
                     if (!definition.steps.some((s) => s.id === dep)) {
@@ -801,23 +588,19 @@ export class WorkflowOrchestrator {
                 }
             }
         }
-        // Check for circular dependencies
         const circularCheck = this.detectCircularDependencies(definition.steps);
-        if (circularCheck) {
+        if (circularCheck)
             return err(new Error(`Circular dependency detected: ${circularCheck}`));
-        }
         return ok(undefined);
     }
     detectCircularDependencies(steps) {
         const visited = new Set();
         const recursionStack = new Set();
         const visit = (stepId, path) => {
-            if (recursionStack.has(stepId)) {
+            if (recursionStack.has(stepId))
                 return [...path, stepId].join(' -> ');
-            }
-            if (visited.has(stepId)) {
+            if (visited.has(stepId))
                 return null;
-            }
             visited.add(stepId);
             recursionStack.add(stepId);
             const step = steps.find((s) => s.id === stepId);
@@ -842,7 +625,6 @@ export class WorkflowOrchestrator {
     // Private Methods - Event Triggers
     // ============================================================================
     setupEventTriggers() {
-        // Subscribe to all domain events for trigger matching
         const subscription = this.eventBus.subscribe('*', async (event) => {
             await this.handleEventForTriggers(event);
         });
@@ -850,49 +632,35 @@ export class WorkflowOrchestrator {
     }
     registerWorkflowTriggers(_workflow) {
         // Triggers are evaluated when events arrive via the * subscription
-        // No additional subscription needed, just store the workflow with triggers
     }
     async handleEventForTriggers(event) {
         for (const workflow of this.workflows.values()) {
             if (!workflow.triggers)
                 continue;
             for (const trigger of workflow.triggers) {
-                // Match event type
                 if (trigger.eventType !== event.type)
                     continue;
-                // Match source domain
                 if (trigger.sourceDomain && trigger.sourceDomain !== event.source)
                     continue;
-                // Evaluate condition if present
                 if (trigger.condition) {
                     const context = {
-                        input: { event: event.payload },
-                        results: {},
-                        metadata: {
-                            executionId: '',
-                            workflowId: workflow.id,
-                            startedAt: new Date(),
-                        },
+                        input: { event: event.payload }, results: {},
+                        metadata: { executionId: '', workflowId: workflow.id, startedAt: new Date() },
                     };
-                    if (!this.evaluateCondition(trigger.condition, context)) {
+                    if (!this.evaluateCondition(trigger.condition, context))
                         continue;
-                    }
                 }
-                // Build input from trigger mapping
                 const input = {};
                 if (trigger.inputMapping) {
                     for (const [targetKey, sourcePath] of Object.entries(trigger.inputMapping)) {
                         const value = this.getValueByPath({ event: event.payload }, sourcePath);
-                        if (value !== undefined) {
+                        if (value !== undefined)
                             input[targetKey] = value;
-                        }
                     }
                 }
                 else {
-                    // Default: pass entire payload as input
                     input.triggerEvent = event.payload;
                 }
-                // Execute workflow
                 await this.executeWorkflow(workflow.id, input, event.correlationId);
             }
         }
@@ -901,618 +669,10 @@ export class WorkflowOrchestrator {
     // Private Methods - Built-in Workflows
     // ============================================================================
     registerBuiltInWorkflows() {
-        // 1. Comprehensive Testing Workflow
-        this.registerWorkflow({
-            id: 'comprehensive-testing',
-            name: 'Comprehensive Testing Workflow',
-            description: 'test-generation -> test-execution -> coverage-analysis -> quality-assessment',
-            version: '1.0.0',
-            tags: ['testing', 'quality'],
-            steps: [
-                {
-                    id: 'generate-tests',
-                    name: 'Generate Tests',
-                    domain: 'test-generation',
-                    action: 'generateTests',
-                    inputMapping: {
-                        sourceFiles: 'input.sourceFiles',
-                        framework: 'input.framework',
-                    },
-                    outputMapping: {
-                        testFiles: 'generatedTests.files',
-                        testCount: 'generatedTests.count',
-                    },
-                    timeout: 120000,
-                    retry: { maxAttempts: 2, backoffMs: 1000 },
-                },
-                {
-                    id: 'execute-tests',
-                    name: 'Execute Tests',
-                    domain: 'test-execution',
-                    action: 'execute',
-                    dependsOn: ['generate-tests'],
-                    inputMapping: {
-                        testFiles: 'results.generatedTests.files',
-                    },
-                    outputMapping: {
-                        runId: 'execution.runId',
-                        passed: 'execution.passed',
-                        failed: 'execution.failed',
-                    },
-                    timeout: 300000,
-                },
-                {
-                    id: 'analyze-coverage',
-                    name: 'Analyze Coverage',
-                    domain: 'coverage-analysis',
-                    action: 'analyze',
-                    dependsOn: ['execute-tests'],
-                    inputMapping: {
-                        runId: 'results.execution.runId',
-                    },
-                    outputMapping: {
-                        line: 'coverage.line',
-                        branch: 'coverage.branch',
-                        overall: 'coverage.overall',
-                    },
-                },
-                {
-                    id: 'assess-quality',
-                    name: 'Assess Quality',
-                    domain: 'quality-assessment',
-                    action: 'evaluateGate',
-                    dependsOn: ['analyze-coverage'],
-                    inputMapping: {
-                        coverage: 'results.coverage',
-                        testResults: 'results.execution',
-                    },
-                    outputMapping: {
-                        passed: 'quality.gatePassed',
-                        score: 'quality.score',
-                    },
-                },
-                {
-                    id: 'generate-more-tests',
-                    name: 'Generate Additional Tests',
-                    domain: 'test-generation',
-                    action: 'generateTests',
-                    dependsOn: ['analyze-coverage'],
-                    condition: {
-                        path: 'results.coverage.overall',
-                        operator: 'lt',
-                        value: 80,
-                    },
-                    inputMapping: {
-                        sourceFiles: 'input.sourceFiles',
-                        targetCoverage: 'input.targetCoverage',
-                    },
-                    continueOnFailure: true,
-                },
-            ],
-        });
-        // 2. Defect Prevention Workflow
-        this.registerWorkflow({
-            id: 'defect-prevention',
-            name: 'Defect Prevention Workflow',
-            description: 'code-intelligence (impact) -> defect-intelligence (predict) -> test-generation (for risky areas)',
-            version: '1.0.0',
-            tags: ['defect', 'prevention', 'ai'],
-            steps: [
-                {
-                    id: 'analyze-impact',
-                    name: 'Analyze Code Impact',
-                    domain: 'code-intelligence',
-                    action: 'analyzeImpact',
-                    inputMapping: {
-                        changedFiles: 'input.changedFiles',
-                    },
-                    outputMapping: {
-                        impactedFiles: 'impact.files',
-                        impactedTests: 'impact.tests',
-                        riskLevel: 'impact.riskLevel',
-                    },
-                    timeout: 60000,
-                },
-                {
-                    id: 'predict-defects',
-                    name: 'Predict Defects',
-                    domain: 'defect-intelligence',
-                    action: 'predictDefects',
-                    dependsOn: ['analyze-impact'],
-                    inputMapping: {
-                        files: 'results.impact.files',
-                    },
-                    outputMapping: {
-                        predictions: 'defects.predictions',
-                        highRiskFiles: 'defects.highRiskFiles',
-                    },
-                },
-                {
-                    id: 'generate-targeted-tests',
-                    name: 'Generate Targeted Tests',
-                    domain: 'test-generation',
-                    action: 'generateTests',
-                    dependsOn: ['predict-defects'],
-                    condition: {
-                        path: 'results.defects.highRiskFiles',
-                        operator: 'exists',
-                        value: true,
-                    },
-                    inputMapping: {
-                        sourceFiles: 'results.defects.highRiskFiles',
-                        priority: 'input.priority',
-                    },
-                },
-            ],
-            triggers: [
-                {
-                    eventType: 'code-intelligence.ImpactAnalysisCompleted',
-                    inputMapping: {
-                        changedFiles: 'event.changedFiles',
-                    },
-                },
-            ],
-        });
-        // 3. Pre-Release Workflow
-        this.registerWorkflow({
-            id: 'pre-release',
-            name: 'Pre-Release Workflow',
-            description: 'security-audit -> quality-gate -> deployment-advisor',
-            version: '1.0.0',
-            tags: ['release', 'security', 'deployment'],
-            steps: [
-                {
-                    id: 'security-audit',
-                    name: 'Security Audit',
-                    domain: 'security-compliance',
-                    action: 'runAudit',
-                    inputMapping: {
-                        targetFiles: 'input.targetFiles',
-                        includeDependencies: 'input.includeDependencies',
-                    },
-                    outputMapping: {
-                        vulnerabilities: 'security.vulnerabilities',
-                        riskScore: 'security.riskScore',
-                        passed: 'security.passed',
-                    },
-                    timeout: 180000,
-                },
-                {
-                    id: 'quality-gate',
-                    name: 'Quality Gate Evaluation',
-                    domain: 'quality-assessment',
-                    action: 'evaluateGate',
-                    dependsOn: ['security-audit'],
-                    inputMapping: {
-                        securityResults: 'results.security',
-                        releaseCandidate: 'input.releaseCandidate',
-                    },
-                    outputMapping: {
-                        passed: 'quality.gatePassed',
-                        checks: 'quality.checks',
-                    },
-                },
-                {
-                    id: 'deployment-advice',
-                    name: 'Get Deployment Advice',
-                    domain: 'quality-assessment',
-                    action: 'getDeploymentAdvice',
-                    dependsOn: ['quality-gate'],
-                    inputMapping: {
-                        releaseCandidate: 'input.releaseCandidate',
-                        qualityResults: 'results.quality',
-                        securityResults: 'results.security',
-                    },
-                    outputMapping: {
-                        decision: 'deployment.decision',
-                        recommendations: 'deployment.recommendations',
-                        riskScore: 'deployment.riskScore',
-                    },
-                },
-            ],
-            triggers: [
-                {
-                    eventType: 'quality-assessment.QualityGateEvaluated',
-                    condition: {
-                        path: 'event.passed',
-                        operator: 'eq',
-                        value: true,
-                    },
-                },
-            ],
-        });
-        // 4. Continuous Learning Workflow
-        this.registerWorkflow({
-            id: 'continuous-learning',
-            name: 'Continuous Learning Workflow',
-            description: 'Collect patterns -> consolidate -> transfer -> optimize',
-            version: '1.0.0',
-            tags: ['learning', 'optimization', 'ai'],
-            steps: [
-                {
-                    id: 'collect-patterns',
-                    name: 'Collect Patterns',
-                    domain: 'learning-optimization',
-                    action: 'runLearningCycle',
-                    inputMapping: {
-                        domain: 'input.targetDomain',
-                    },
-                    outputMapping: {
-                        patternsLearned: 'learning.patterns',
-                        experiencesProcessed: 'learning.experiences',
-                    },
-                },
-                {
-                    id: 'consolidate-patterns',
-                    name: 'Consolidate Patterns',
-                    domain: 'learning-optimization',
-                    action: 'shareCrossDomainLearnings',
-                    dependsOn: ['collect-patterns'],
-                    condition: {
-                        path: 'results.learning.patterns',
-                        operator: 'gt',
-                        value: 0,
-                    },
-                    outputMapping: {
-                        knowledgeShared: 'consolidation.shared',
-                        domainsUpdated: 'consolidation.domains',
-                    },
-                },
-                {
-                    id: 'transfer-knowledge',
-                    name: 'Transfer Knowledge',
-                    domain: 'learning-optimization',
-                    action: 'shareCrossDomainLearnings',
-                    dependsOn: ['consolidate-patterns'],
-                    outputMapping: {
-                        transferSuccessRate: 'transfer.successRate',
-                        newPatternsCreated: 'transfer.newPatterns',
-                    },
-                },
-                {
-                    id: 'optimize-strategies',
-                    name: 'Optimize Strategies',
-                    domain: 'learning-optimization',
-                    action: 'optimizeAllStrategies',
-                    dependsOn: ['transfer-knowledge'],
-                    outputMapping: {
-                        domainsOptimized: 'optimization.domains',
-                        avgImprovement: 'optimization.improvement',
-                    },
-                },
-            ],
-        });
-        // 5. Morning Sync Protocol Workflow
-        this.registerWorkflow({
-            id: 'morning-sync',
-            name: 'Morning Sync Protocol',
-            description: 'Daily quality synchronization across all domains',
-            version: '1.0.0',
-            tags: ['protocol', 'daily', 'sync'],
-            steps: [
-                {
-                    id: 'collect-metrics',
-                    name: 'Collect Quality Metrics',
-                    domain: 'quality-assessment',
-                    action: 'analyzeQuality',
-                    inputMapping: {
-                        sourceFiles: 'input.sourceFiles',
-                    },
-                    outputMapping: {
-                        score: 'metrics.qualityScore',
-                    },
-                },
-                {
-                    id: 'analyze-trends',
-                    name: 'Analyze Coverage Trends',
-                    domain: 'coverage-analysis',
-                    action: 'getTrend',
-                    inputMapping: {
-                        timeRange: 'input.timeRange',
-                        granularity: 'input.granularity',
-                    },
-                    outputMapping: {
-                        trend: 'trends.coverage',
-                        forecast: 'trends.forecast',
-                    },
-                },
-                {
-                    id: 'check-security',
-                    name: 'Check Security Posture',
-                    domain: 'security-compliance',
-                    action: 'getSecurityPosture',
-                    outputMapping: {
-                        overallScore: 'security.score',
-                        criticalIssues: 'security.critical',
-                        recommendations: 'security.recommendations',
-                    },
-                },
-                {
-                    id: 'get-defect-predictions',
-                    name: 'Get Defect Predictions',
-                    domain: 'defect-intelligence',
-                    action: 'predictDefects',
-                    inputMapping: {
-                        files: 'input.changedFiles',
-                    },
-                    outputMapping: {
-                        predictions: 'defects.predictions',
-                    },
-                },
-                {
-                    id: 'generate-learning-report',
-                    name: 'Generate Learning Dashboard',
-                    domain: 'learning-optimization',
-                    action: 'getLearningDashboard',
-                    dependsOn: ['collect-metrics', 'analyze-trends', 'check-security', 'get-defect-predictions'],
-                    outputMapping: {
-                        learningRate: 'learning.rate',
-                        topDomains: 'learning.topDomains',
-                    },
-                },
-            ],
-        });
-        // 6. QCSD Ideation Swarm Workflow
-        // Per QCSD framework: Quality Criteria sessions during PI/Sprint Planning
-        // Primary: qe-quality-criteria-recommender (HTSM v6.3 analysis)
-        // Supporting: testability-scoring, qe-risk-assessor, qe-requirements-validator
-        // Enhanced: Supports live URL input - extracts website content for analysis
-        this.registerWorkflow({
-            id: 'qcsd-ideation-swarm',
-            name: 'QCSD Ideation Swarm',
-            description: 'Quality Conscious Software Delivery ideation phase: [url-extraction] -> [flag-detection] -> quality-criteria (HTSM) -> [testability, risk, requirements, security*, accessibility*, qx*] in parallel -> aggregated report. Supports live website URLs with conditional agent spawning based on HAS_UI, HAS_SECURITY, HAS_UX flags.',
-            version: '3.0.0',
-            tags: ['qcsd', 'ideation', 'quality-criteria', 'htsm', 'shift-left', 'url-analysis'],
-            steps: [
-                // Step 0: Optional - Website Content Extraction (for URL input)
-                {
-                    id: 'website-content-extraction',
-                    name: 'Website Content Extraction',
-                    domain: 'requirements-validation',
-                    action: 'extractWebsiteContent',
-                    inputMapping: {
-                        url: 'input.url',
-                    },
-                    outputMapping: {
-                        extractedDescription: 'extraction.description',
-                        extractedFeatures: 'extraction.features',
-                        extractedAcceptanceCriteria: 'extraction.acceptanceCriteria',
-                        detectedFlags: 'extraction.flags',
-                        isWebsite: 'extraction.isWebsite',
-                    },
-                    timeout: 60000, // 1 minute for URL fetch
-                    continueOnFailure: true, // Continue even if URL fetch fails
-                },
-                // Step 1: Primary - Quality Criteria Analysis (HTSM v6.3)
-                {
-                    id: 'quality-criteria-analysis',
-                    name: 'HTSM Quality Criteria Analysis',
-                    domain: 'requirements-validation',
-                    action: 'analyzeQualityCriteria',
-                    dependsOn: ['website-content-extraction'],
-                    inputMapping: {
-                        targetId: 'input.targetId',
-                        targetType: 'input.targetType',
-                        // Use extracted description if available, otherwise use input
-                        description: 'results.website-content-extraction.extractedDescription || input.description',
-                        acceptanceCriteria: 'results.website-content-extraction.extractedAcceptanceCriteria || input.acceptanceCriteria',
-                    },
-                    outputMapping: {
-                        qualityCriteria: 'qualityCriteria.criteria',
-                        qualityScore: 'qualityCriteria.score',
-                    },
-                    timeout: 180000, // 3 minutes for deep analysis
-                    retry: { maxAttempts: 2, backoffMs: 2000 },
-                },
-                // Step 2a: Parallel - Testability Scoring
-                {
-                    id: 'testability-assessment',
-                    name: 'Testability Scoring (10 Principles)',
-                    domain: 'requirements-validation',
-                    action: 'assessTestability',
-                    dependsOn: ['quality-criteria-analysis'],
-                    inputMapping: {
-                        targetId: 'input.targetId',
-                        description: 'results.website-content-extraction.extractedDescription || input.description',
-                        acceptanceCriteria: 'results.website-content-extraction.extractedAcceptanceCriteria || input.acceptanceCriteria',
-                    },
-                    outputMapping: {
-                        overallScore: 'testability.overallScore',
-                        principles: 'testability.principles',
-                        blockers: 'testability.blockers',
-                        recommendations: 'testability.recommendations',
-                    },
-                    timeout: 120000,
-                    continueOnFailure: true, // Don't block other assessments
-                },
-                // Step 2b: Parallel - Risk Assessment
-                {
-                    id: 'risk-assessment',
-                    name: 'Quality Risk Assessment',
-                    domain: 'requirements-validation',
-                    action: 'assessRisks',
-                    dependsOn: ['quality-criteria-analysis'],
-                    inputMapping: {
-                        targetId: 'input.targetId',
-                        targetType: 'input.targetType',
-                        description: 'results.website-content-extraction.extractedDescription || input.description',
-                    },
-                    outputMapping: {
-                        overallRisk: 'risks.overallRisk',
-                        riskScore: 'risks.riskScore',
-                        factors: 'risks.factors',
-                        mitigations: 'risks.mitigations',
-                    },
-                    timeout: 90000,
-                    continueOnFailure: true,
-                },
-                // Step 2c: Parallel - Requirements Validation
-                {
-                    id: 'requirements-validation',
-                    name: 'Requirements & Acceptance Criteria Validation',
-                    domain: 'requirements-validation',
-                    action: 'validateRequirements',
-                    dependsOn: ['quality-criteria-analysis'],
-                    inputMapping: {
-                        targetId: 'input.targetId',
-                        description: 'results.website-content-extraction.extractedDescription || input.description',
-                        acceptanceCriteria: 'results.website-content-extraction.extractedAcceptanceCriteria || input.acceptanceCriteria',
-                    },
-                    outputMapping: {
-                        valid: 'requirements.valid',
-                        issues: 'requirements.issues',
-                        suggestions: 'requirements.suggestions',
-                    },
-                    timeout: 90000,
-                    continueOnFailure: true,
-                },
-                // Step 3a: Optional - Security Threat Modeling (if HAS_SECURITY flag is true)
-                {
-                    id: 'security-threat-modeling',
-                    name: 'Early Security Threat Modeling (STRIDE)',
-                    domain: 'security-compliance',
-                    action: 'modelSecurityThreats',
-                    dependsOn: ['quality-criteria-analysis'],
-                    // Trigger if explicitly requested OR if website extraction detected security features
-                    condition: {
-                        path: 'results.website-content-extraction.detectedFlags.hasSecurity || input.securityCritical',
-                        operator: 'eq',
-                        value: true,
-                    },
-                    inputMapping: {
-                        targetId: 'input.targetId',
-                        description: 'results.website-content-extraction.extractedDescription || input.description',
-                        securityCritical: 'results.website-content-extraction.detectedFlags.hasSecurity || input.securityCritical',
-                    },
-                    outputMapping: {
-                        threats: 'security.threats',
-                        overallRisk: 'security.overallRisk',
-                        recommendations: 'security.recommendations',
-                    },
-                    timeout: 120000,
-                    continueOnFailure: true,
-                },
-                // Step 3b: Optional - Accessibility Audit (if HAS_UI flag is true)
-                {
-                    id: 'accessibility-audit',
-                    name: 'Accessibility Audit (WCAG 2.2)',
-                    domain: 'visual-accessibility',
-                    action: 'auditAccessibility',
-                    dependsOn: ['quality-criteria-analysis'],
-                    // Trigger if website has UI components
-                    condition: {
-                        path: 'results.website-content-extraction.detectedFlags.hasUI || input.hasUI',
-                        operator: 'eq',
-                        value: true,
-                    },
-                    inputMapping: {
-                        targetId: 'input.targetId',
-                        url: 'input.url',
-                        description: 'results.website-content-extraction.extractedDescription || input.description',
-                        features: 'results.website-content-extraction.extractedFeatures',
-                    },
-                    outputMapping: {
-                        wcagLevel: 'accessibility.wcagLevel',
-                        violations: 'accessibility.violations',
-                        recommendations: 'accessibility.recommendations',
-                    },
-                    timeout: 180000, // 3 minutes for comprehensive audit
-                    continueOnFailure: true,
-                },
-                // Step 3c: Optional - Quality Experience Analysis (if HAS_UX flag is true)
-                {
-                    id: 'quality-experience-analysis',
-                    name: 'Quality Experience Analysis (QX Partner)',
-                    domain: 'coordination',
-                    action: 'analyzeQualityExperience',
-                    dependsOn: ['quality-criteria-analysis'],
-                    // Trigger if website has UX concerns
-                    condition: {
-                        path: 'results.website-content-extraction.detectedFlags.hasUX || input.hasUX',
-                        operator: 'eq',
-                        value: true,
-                    },
-                    inputMapping: {
-                        targetId: 'input.targetId',
-                        url: 'input.url',
-                        description: 'results.website-content-extraction.extractedDescription || input.description',
-                        features: 'results.website-content-extraction.extractedFeatures',
-                    },
-                    outputMapping: {
-                        journeys: 'qx.journeys',
-                        frictionPoints: 'qx.frictionPoints',
-                        recommendations: 'qx.recommendations',
-                    },
-                    timeout: 150000,
-                    continueOnFailure: true,
-                },
-                // Step 4: Aggregate Ideation Report (waits for all parallel assessments)
-                {
-                    id: 'aggregate-ideation-report',
-                    name: 'Generate Ideation Report',
-                    domain: 'requirements-validation',
-                    action: 'generateIdeationReport',
-                    dependsOn: [
-                        'quality-criteria-analysis',
-                        'testability-assessment',
-                        'risk-assessment',
-                        'requirements-validation',
-                        'security-threat-modeling', // Optional - may be skipped
-                        'accessibility-audit', // Optional - may be skipped
-                        'quality-experience-analysis', // Optional - may be skipped
-                    ],
-                    inputMapping: {
-                        targetId: 'input.targetId',
-                        targetType: 'input.targetType',
-                    },
-                    outputMapping: {
-                        report: 'ideation.report',
-                        readyForDevelopment: 'ideation.readyForDevelopment',
-                        blockers: 'ideation.blockers',
-                        recommendations: 'ideation.recommendations',
-                        testStrategy: 'ideation.testStrategy',
-                    },
-                    timeout: 60000,
-                },
-                // Step 5: Store learnings for cross-phase feedback
-                {
-                    id: 'store-ideation-learnings',
-                    name: 'Store Ideation Learnings',
-                    domain: 'learning-optimization',
-                    action: 'storeIdeationLearnings',
-                    dependsOn: ['aggregate-ideation-report'],
-                    inputMapping: {
-                        targetId: 'input.targetId',
-                        report: 'results.ideation.report',
-                    },
-                    outputMapping: {
-                        stored: 'learning.stored',
-                        patternId: 'learning.patternId',
-                    },
-                    continueOnFailure: true,
-                },
-            ],
-            triggers: [
-                {
-                    eventType: 'requirements-validation.EpicCreated',
-                    inputMapping: {
-                        targetId: 'event.epicId',
-                        targetType: 'event.type',
-                        description: 'event.description',
-                        acceptanceCriteria: 'event.acceptanceCriteria',
-                    },
-                },
-                {
-                    eventType: 'requirements-validation.SprintPlanningStarted',
-                    inputMapping: {
-                        targetId: 'event.sprintId',
-                        targetType: 'event.type',
-                        description: 'event.description',
-                        acceptanceCriteria: 'event.acceptanceCriteria',
-                    },
-                },
-            ],
-        });
+        const builtInWorkflows = getBuiltInWorkflows();
+        for (const workflow of builtInWorkflows) {
+            this.registerWorkflow(workflow);
+        }
     }
     // ============================================================================
     // Private Methods - Persistence
@@ -1534,16 +694,8 @@ export class WorkflowOrchestrator {
     async persistWorkflows() {
         try {
             for (const workflow of this.workflows.values()) {
-                // Don't persist built-in workflows
-                if ([
-                    'comprehensive-testing',
-                    'defect-prevention',
-                    'pre-release',
-                    'continuous-learning',
-                    'morning-sync',
-                ].includes(workflow.id)) {
+                if (BUILTIN_WORKFLOW_IDS.includes(workflow.id))
                     continue;
-                }
                 await this.memory.set(`workflow:definition:${workflow.id}`, workflow, { namespace: 'coordination', persist: true });
             }
         }
@@ -1553,13 +705,8 @@ export class WorkflowOrchestrator {
     }
     async persistExecution(execution) {
         try {
-            // Convert Map to object for serialization
-            const serializable = {
-                ...execution,
-                stepResults: Object.fromEntries(execution.stepResults),
-            };
-            await this.memory.set(`workflow:execution:${execution.executionId}`, serializable, { namespace: 'coordination', ttl: 86400 * 7 } // 7 days
-            );
+            const serializable = { ...execution, stepResults: Object.fromEntries(execution.stepResults) };
+            await this.memory.set(`workflow:execution:${execution.executionId}`, serializable, { namespace: 'coordination', ttl: 86400 * 7 });
         }
         catch (error) {
             console.error('Failed to persist execution:', error);
@@ -1571,20 +718,6 @@ export class WorkflowOrchestrator {
     delay(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
-    /**
-     * Register a domain action handler
-     */
-    registerAction(domain, action, handler) {
-        // Guard against prototype pollution
-        const dangerousKeys = ['__proto__', 'constructor', 'prototype'];
-        if (dangerousKeys.includes(domain) || dangerousKeys.includes(action)) {
-            throw new Error('Invalid domain or action name: contains dangerous prototype key');
-        }
-        if (!this.actionRegistry[domain]) {
-            this.actionRegistry[domain] = {};
-        }
-        this.actionRegistry[domain][action] = handler;
-    }
 }
 // ============================================================================
 // Factory Function