@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/coordination/workflow-orchestrator.ts

@@ -1,1917 +0,0 @@
-/**
- * Agentic QE v3 - Workflow Orchestrator
- * Coordinates complete QE workflows across all 12 domains
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import {
-  Result,
-  ok,
-  err,
-  DomainName,
-  ALL_DOMAINS,
-  DomainEvent,
-} from '../shared/types/index.js';
-import {
-  EventBus,
-  MemoryBackend,
-  AgentCoordinator,
-  Subscription,
-} from '../kernel/interfaces.js';
-import { createEvent } from '../shared/events/domain-events.js';
-
-// ============================================================================
-// Workflow Types
-// ============================================================================
-
-/**
- * Step execution mode
- */
-export type StepExecutionMode = 'sequential' | 'parallel';
-
-/**
- * Step status
- */
-export type StepStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
-
-/**
- * Workflow status
- */
-export type WorkflowStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'paused';
-
-/**
- * Condition operator
- */
-export type ConditionOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'exists';
-
-/**
- * Step condition for conditional branching
- */
-export interface StepCondition {
-  /** Path to the value in context (e.g., 'results.coverage.line') */
-  path: string;
-  /** Comparison operator */
-  operator: ConditionOperator;
-  /** Value to compare against */
-  value: unknown;
-}
-
-/**
- * Workflow step definition
- */
-export interface WorkflowStepDefinition {
-  /** Unique step identifier */
-  id: string;
-  /** Human-readable name */
-  name: string;
-  /** Target domain for execution */
-  domain: DomainName;
-  /** Action to invoke on the domain */
-  action: string;
-  /** Input mapping from context */
-  inputMapping?: Record<string, string>;
-  /** Output mapping to context */
-  outputMapping?: Record<string, string>;
-  /** Step dependencies (step IDs that must complete first) */
-  dependsOn?: string[];
-  /** Condition to execute this step */
-  condition?: StepCondition;
-  /** Skip condition (if true, step is skipped) */
-  skipCondition?: StepCondition;
-  /** Timeout in milliseconds */
-  timeout?: number;
-  /** Retry configuration */
-  retry?: {
-    maxAttempts: number;
-    backoffMs: number;
-    backoffMultiplier?: number;
-  };
-  /** Rollback action if step fails */
-  rollback?: {
-    domain: DomainName;
-    action: string;
-    input?: Record<string, unknown>;
-  };
-  /** Continue workflow on failure */
-  continueOnFailure?: boolean;
-}
-
-/**
- * Workflow definition
- */
-export interface WorkflowDefinition {
-  /** Unique workflow identifier */
-  id: string;
-  /** Human-readable name */
-  name: string;
-  /** Description */
-  description: string;
-  /** Workflow version */
-  version: string;
-  /** Workflow steps */
-  steps: WorkflowStepDefinition[];
-  /** Default execution mode for steps without dependencies */
-  defaultMode?: StepExecutionMode;
-  /** Global timeout in milliseconds */
-  timeout?: number;
-  /** Event triggers */
-  triggers?: WorkflowTrigger[];
-  /** Tags for categorization */
-  tags?: string[];
-}
-
-/**
- * Workflow trigger definition
- */
-export interface WorkflowTrigger {
-  /** Event type to trigger on */
-  eventType: string;
-  /** Optional source domain filter */
-  sourceDomain?: DomainName;
-  /** Condition to evaluate on event payload */
-  condition?: StepCondition;
-  /** Input mapping from event payload to workflow context */
-  inputMapping?: Record<string, string>;
-}
-
-/**
- * Step execution result
- */
-export interface StepExecutionResult {
-  stepId: string;
-  status: StepStatus;
-  startedAt: Date;
-  completedAt?: Date;
-  duration?: number;
-  output?: unknown;
-  error?: string;
-  retryCount?: number;
-}
-
-/**
- * Workflow execution context
- */
-export interface WorkflowContext {
-  /** Input parameters */
-  input: Record<string, unknown>;
-  /** Accumulated results from steps */
-  results: Record<string, unknown>;
-  /** Metadata */
-  metadata: {
-    executionId: string;
-    workflowId: string;
-    correlationId?: string;
-    startedAt: Date;
-    triggeredBy?: string;
-  };
-}
-
-/**
- * Workflow execution status
- */
-export interface WorkflowExecutionStatus {
-  executionId: string;
-  workflowId: string;
-  workflowName: string;
-  status: WorkflowStatus;
-  startedAt: Date;
-  completedAt?: Date;
-  duration?: number;
-  progress: number;
-  currentSteps: string[];
-  completedSteps: string[];
-  failedSteps: string[];
-  skippedSteps: string[];
-  context: WorkflowContext;
-  stepResults: Map<string, StepExecutionResult>;
-  error?: string;
-}
-
-/**
- * Workflow list item
- */
-export interface WorkflowListItem {
-  id: string;
-  name: string;
-  description: string;
-  version: string;
-  stepCount: number;
-  tags?: string[];
-  triggers?: string[];
-}
-
-// ============================================================================
-// Workflow Events
-// ============================================================================
-
-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',
-} as const;
-
-export interface WorkflowStartedPayload {
-  executionId: string;
-  workflowId: string;
-  workflowName: string;
-  stepCount: number;
-}
-
-export interface WorkflowCompletedPayload {
-  executionId: string;
-  workflowId: string;
-  workflowName: string;
-  duration: number;
-  completedSteps: number;
-  skippedSteps: number;
-}
-
-export interface WorkflowFailedPayload {
-  executionId: string;
-  workflowId: string;
-  workflowName: string;
-  failedStep: string;
-  error: string;
-}
-
-export interface StepEventPayload {
-  executionId: string;
-  workflowId: string;
-  stepId: string;
-  stepName: string;
-  domain: DomainName;
-}
-
-// ============================================================================
-// Workflow Orchestrator Interface
-// ============================================================================
-
-export interface IWorkflowOrchestrator {
-  /** Initialize the orchestrator */
-  initialize(): Promise<void>;
-  /** Dispose resources */
-  dispose(): Promise<void>;
-  /** Register a workflow definition */
-  registerWorkflow(definition: WorkflowDefinition): Result<void, Error>;
-  /** Unregister a workflow */
-  unregisterWorkflow(workflowId: string): Result<void, Error>;
-  /** Execute a workflow */
-  executeWorkflow(
-    workflowId: string,
-    input?: Record<string, unknown>,
-    correlationId?: string
-  ): Promise<Result<string, Error>>;
-  /** Get workflow execution status */
-  getWorkflowStatus(executionId: string): WorkflowExecutionStatus | undefined;
-  /** Cancel a running workflow */
-  cancelWorkflow(executionId: string): Promise<Result<void, Error>>;
-  /** Pause a running workflow */
-  pauseWorkflow(executionId: string): Promise<Result<void, Error>>;
-  /** Resume a paused workflow */
-  resumeWorkflow(executionId: string): Promise<Result<void, Error>>;
-  /** List registered workflows */
-  listWorkflows(): WorkflowListItem[];
-  /** Get active executions */
-  getActiveExecutions(): WorkflowExecutionStatus[];
-  /** Get workflow definition */
-  getWorkflow(workflowId: string): WorkflowDefinition | undefined;
-}
-
-// ============================================================================
-// Domain Action Registry
-// ============================================================================
-
-type DomainAction = (
-  input: Record<string, unknown>,
-  context: WorkflowContext
-) => Promise<Result<unknown, Error>>;
-
-interface DomainActionRegistry {
-  [domain: string]: {
-    [action: string]: DomainAction;
-  };
-}
-
-// ============================================================================
-// Workflow Orchestrator Implementation
-// ============================================================================
-
-export interface WorkflowOrchestratorConfig {
-  maxConcurrentWorkflows: number;
-  defaultStepTimeout: number;
-  defaultWorkflowTimeout: number;
-  enableEventTriggers: boolean;
-  persistExecutions: boolean;
-}
-
-const DEFAULT_CONFIG: WorkflowOrchestratorConfig = {
-  maxConcurrentWorkflows: 10,
-  defaultStepTimeout: 60000,
-  defaultWorkflowTimeout: 600000,
-  enableEventTriggers: true,
-  persistExecutions: true,
-};
-
-export class WorkflowOrchestrator implements IWorkflowOrchestrator {
-  private readonly config: WorkflowOrchestratorConfig;
-  private readonly workflows: Map<string, WorkflowDefinition> = new Map();
-  private readonly executions: Map<string, WorkflowExecutionStatus> = new Map();
-  private readonly actionRegistry: DomainActionRegistry = {};
-  private readonly eventSubscriptions: Subscription[] = [];
-  private initialized = false;
-
-  constructor(
-    private readonly eventBus: EventBus,
-    private readonly memory: MemoryBackend,
-    private readonly agentCoordinator: AgentCoordinator,
-    config: Partial<WorkflowOrchestratorConfig> = {}
-  ) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-
-  /**
-   * Initialize the orchestrator
-   */
-  async initialize(): Promise<void> {
-    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(): Promise<void> {
-    // 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: WorkflowDefinition): Result<void, Error> {
-    try {
-      // Validate workflow
-      const validationResult = this.validateWorkflowDefinition(definition);
-      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)));
-    }
-  }
-
-  /**
-   * Unregister a workflow
-   */
-  unregisterWorkflow(workflowId: string): Result<void, Error> {
-    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)`
-        )
-      );
-    }
-
-    this.workflows.delete(workflowId);
-    return ok(undefined);
-  }
-
-  /**
-   * Execute a workflow
-   */
-  async executeWorkflow(
-    workflowId: string,
-    input: Record<string, unknown> = {},
-    correlationId?: string
-  ): Promise<Result<string, Error>> {
-    const workflow = this.workflows.get(workflowId);
-    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: WorkflowContext = {
-      input,
-      results: {},
-      metadata: {
-        executionId,
-        workflowId,
-        correlationId: correlationId || executionId,
-        startedAt,
-      },
-    };
-
-    // Initialize execution status
-    const execution: WorkflowExecutionStatus = {
-      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);
-      execution.completedAt = new Date();
-      execution.duration = execution.completedAt.getTime() - startedAt.getTime();
-
-      await this.publishWorkflowFailed(execution, 'unknown', String(error));
-    });
-
-    return ok(executionId);
-  }
-
-  /**
-   * Get workflow execution status
-   */
-  getWorkflowStatus(executionId: string): WorkflowExecutionStatus | undefined {
-    return this.executions.get(executionId);
-  }
-
-  /**
-   * Cancel a running workflow
-   */
-  async cancelWorkflow(executionId: string): Promise<Result<void, Error>> {
-    const execution = this.executions.get(executionId);
-    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
-    await this.publishEvent(
-      WorkflowEvents.WorkflowCancelled,
-      {
-        executionId,
-        workflowId: execution.workflowId,
-        workflowName: execution.workflowName,
-      },
-      execution.context.metadata.correlationId
-    );
-
-    return ok(undefined);
-  }
-
-  /**
-   * Pause a running workflow
-   */
-  async pauseWorkflow(executionId: string): Promise<Result<void, Error>> {
-    const execution = this.executions.get(executionId);
-    if (!execution) {
-      return err(new Error(`Execution not found: ${executionId}`));
-    }
-
-    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: string): Promise<Result<void, Error>> {
-    const execution = this.executions.get(executionId);
-    if (!execution) {
-      return err(new Error(`Execution not found: ${executionId}`));
-    }
-
-    if (execution.status !== 'paused') {
-      return err(new Error(`Cannot resume workflow in status: ${execution.status}`));
-    }
-
-    const workflow = this.workflows.get(execution.workflowId);
-    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(): WorkflowListItem[] {
-    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,
-      triggers: w.triggers?.map((t) => t.eventType),
-    }));
-  }
-
-  /**
-   * Get active executions
-   */
-  getActiveExecutions(): WorkflowExecutionStatus[] {
-    return Array.from(this.executions.values()).filter(
-      (e) => e.status === 'running' || e.status === 'paused'
-    );
-  }
-
-  /**
-   * Get workflow definition
-   */
-  getWorkflow(workflowId: string): WorkflowDefinition | undefined {
-    return this.workflows.get(workflowId);
-  }
-
-  // ============================================================================
-  // Private Methods - Workflow Execution
-  // ============================================================================
-
-  private async runWorkflow(
-    workflow: WorkflowDefinition,
-    execution: WorkflowExecutionStatus
-  ): Promise<void> {
-    const timeout = workflow.timeout || this.config.defaultWorkflowTimeout;
-    const timeoutPromise = new Promise<never>((_, reject) => {
-      setTimeout(
-        () => reject(new Error(`Workflow timeout after ${timeout}ms`)),
-        timeout
-      );
-    });
-
-    try {
-      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.progress = 100;
-
-        await this.publishWorkflowCompleted(execution);
-      }
-    } catch (error) {
-      if (execution.status === 'running') {
-        execution.status = 'failed';
-        execution.error = String(error);
-        execution.completedAt = new Date();
-        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) {
-      await this.persistExecution(execution);
-    }
-  }
-
-  private async executeSteps(
-    workflow: WorkflowDefinition,
-    execution: WorkflowExecutionStatus
-  ): Promise<void> {
-    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)
-    );
-
-    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
-        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)
-          )
-        );
-
-        for (let i = 0; i < parallelSteps.length; i++) {
-          const step = parallelSteps[i];
-          const result = results[i];
-
-          if (result.status === 'fulfilled') {
-            const stepResult = result.value;
-            if (stepResult.status === 'completed') {
-              completedSteps.add(step.id);
-              execution.completedSteps.push(step.id);
-            } else if (stepResult.status === 'skipped') {
-              skippedSteps.add(step.id);
-              execution.skippedSteps.push(step.id);
-            } else if (stepResult.status === 'failed') {
-              failedSteps.add(step.id);
-              execution.failedSteps.push(step.id);
-
-              if (!step.continueOnFailure) {
-                execution.status = 'failed';
-                execution.error = stepResult.error;
-                return;
-              }
-            }
-          } else {
-            failedSteps.add(step.id);
-            execution.failedSteps.push(step.id);
-
-            if (!step.continueOnFailure) {
-              execution.status = 'failed';
-              execution.error = result.reason?.message || 'Unknown error';
-              return;
-            }
-          }
-
-          // Remove from pending
-          const pendingIndex = pendingSteps.indexOf(step);
-          if (pendingIndex !== -1) {
-            pendingSteps.splice(pendingIndex, 1);
-          }
-        }
-      }
-
-      // Execute sequential steps one at a time
-      for (const step of sequentialSteps) {
-        if (execution.status !== 'running') break;
-
-        execution.currentSteps = [step.id];
-
-        const stepResult = await this.executeStep(step, execution, workflow);
-
-        if (stepResult.status === 'completed') {
-          completedSteps.add(step.id);
-          execution.completedSteps.push(step.id);
-        } else if (stepResult.status === 'skipped') {
-          skippedSteps.add(step.id);
-          execution.skippedSteps.push(step.id);
-        } else if (stepResult.status === 'failed') {
-          failedSteps.add(step.id);
-          execution.failedSteps.push(step.id);
-
-          if (!step.continueOnFailure) {
-            execution.status = 'failed';
-            execution.error = stepResult.error;
-            return;
-          }
-        }
-
-        // Remove from pending
-        const pendingIndex = pendingSteps.indexOf(step);
-        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);
-    }
-
-    execution.currentSteps = [];
-  }
-
-  private async executeStep(
-    step: WorkflowStepDefinition,
-    execution: WorkflowExecutionStatus,
-    _workflow: WorkflowDefinition
-  ): Promise<StepExecutionResult> {
-    const startedAt = new Date();
-    const result: StepExecutionResult = {
-      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();
-        result.duration = result.completedAt.getTime() - startedAt.getTime();
-        execution.stepResults.set(step.id, result);
-
-        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();
-        result.duration = result.completedAt.getTime() - startedAt.getTime();
-        execution.stepResults.set(step.id, result);
-
-        await this.publishStepSkipped(execution, step);
-        return result;
-      }
-
-      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: Error | undefined;
-      const maxAttempts = step.retry?.maxAttempts || 1;
-      let backoffMs = step.retry?.backoffMs || 1000;
-      const backoffMultiplier = step.retry?.backoffMultiplier || 2;
-
-      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        result.retryCount = attempt - 1;
-
-        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;
-          result.completedAt = new Date();
-          result.duration = result.completedAt.getTime() - startedAt.getTime();
-          execution.stepResults.set(step.id, result);
-
-          await this.publishStepCompleted(execution, step, result);
-          return result;
-        } catch (error) {
-          lastError = error instanceof Error ? error : new Error(String(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) {
-        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.completedAt = new Date();
-      result.duration = result.completedAt.getTime() - startedAt.getTime();
-      execution.stepResults.set(step.id, result);
-
-      await this.publishStepFailed(execution, step, result.error);
-      return result;
-    }
-  }
-
-  private async executeStepAction(
-    step: WorkflowStepDefinition,
-    input: Record<string, unknown>,
-    context: WorkflowContext,
-    timeout: number
-  ): Promise<unknown> {
-    // Check if action is registered
-    const domainActions = this.actionRegistry[step.domain];
-    if (domainActions?.[step.action]) {
-      const timeoutPromise = new Promise<never>((_, 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) {
-        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: DomainName, action: string): boolean {
-    return !!this.actionRegistry[domain]?.[action];
-  }
-
-  /**
-   * Get all registered actions for a domain
-   */
-  getRegisteredActions(domain: DomainName): string[] {
-    return Object.keys(this.actionRegistry[domain] || {});
-  }
-
-  /**
-   * Get all domains with registered actions
-   */
-  getDomainsWithActions(): DomainName[] {
-    return Object.keys(this.actionRegistry) as DomainName[];
-  }
-
-  /**
-   * Spawn a workflow agent for complex step execution
-   * Used when steps require dedicated agent resources
-   */
-  async spawnWorkflowAgent(
-    workflowId: string,
-    stepId: string,
-    domain: DomainName
-  ): Promise<Result<string, Error>> {
-    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: string): Promise<Result<void, Error>> {
-    return this.agentCoordinator.stop(agentId);
-  }
-
-  /**
-   * Get the number of agents available for workflow execution
-   */
-  getAvailableAgentCapacity(): number {
-    return this.agentCoordinator.canSpawn()
-      ? this.config.maxConcurrentWorkflows - this.getActiveExecutions().length
-      : 0;
-  }
-
-  private async executeRollback(
-    rollback: { domain: DomainName; action: string; input?: Record<string, unknown> },
-    context: WorkflowContext
-  ): Promise<void> {
-    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) {
-        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);
-    }
-  }
-
-  // ============================================================================
-  // Private Methods - Input/Output Mapping
-  // ============================================================================
-
-  private buildStepInput(
-    step: WorkflowStepDefinition,
-    context: WorkflowContext
-  ): Record<string, unknown> {
-    const input: Record<string, unknown> = {};
-
-    if (step.inputMapping) {
-      for (const [targetKey, sourcePath] of Object.entries(step.inputMapping)) {
-        const value = this.getValueByPath(context, sourcePath);
-        if (value !== undefined) {
-          input[targetKey] = value;
-        }
-      }
-    }
-
-    return input;
-  }
-
-  private mapStepOutput(
-    step: WorkflowStepDefinition,
-    output: unknown,
-    context: WorkflowContext
-  ): void {
-    // 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) {
-          this.setValueByPath(context.results, targetPath, value);
-        }
-      }
-    }
-  }
-
-  private getValueByPath(obj: unknown, path: string): unknown {
-    const parts = path.split('.');
-    let current: unknown = obj;
-
-    for (const part of parts) {
-      if (current === null || current === undefined) {
-        return undefined;
-      }
-      if (typeof current === 'object') {
-        current = (current as Record<string, unknown>)[part];
-      } else {
-        return undefined;
-      }
-    }
-
-    return current;
-  }
-
-  private setValueByPath(
-    obj: Record<string, unknown>,
-    path: string,
-    value: unknown
-  ): void {
-    const parts = path.split('.');
-    let current = obj;
-
-    for (let i = 0; i < parts.length - 1; i++) {
-      const part = parts[i];
-      if (!(part in current)) {
-        current[part] = {};
-      }
-      current = current[part] as Record<string, unknown>;
-    }
-
-    current[parts[parts.length - 1]] = value;
-  }
-
-  // ============================================================================
-  // Private Methods - Condition Evaluation
-  // ============================================================================
-
-  private evaluateCondition(
-    condition: StepCondition,
-    context: WorkflowContext
-  ): boolean {
-    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 as number);
-      case 'gte':
-        return typeof value === 'number' && value >= (condition.value as number);
-      case 'lt':
-        return typeof value === 'number' && value < (condition.value as number);
-      case 'lte':
-        return typeof value === 'number' && value <= (condition.value as number);
-      case 'contains':
-        if (Array.isArray(value)) {
-          return value.includes(condition.value);
-        }
-        if (typeof value === 'string') {
-          return value.includes(String(condition.value));
-        }
-        return false;
-      case 'exists':
-        return value !== undefined && value !== null;
-      default:
-        return false;
-    }
-  }
-
-  // ============================================================================
-  // Private Methods - Event Publishing
-  // ============================================================================
-
-  private async publishEvent<T>(
-    type: string,
-    payload: T,
-    correlationId?: string
-  ): Promise<void> {
-    const event = createEvent(
-      type,
-      'learning-optimization' as DomainName, // Workflow orchestrator publishes as coordination
-      payload,
-      correlationId
-    );
-    await this.eventBus.publish(event);
-  }
-
-  private async publishWorkflowStarted(
-    execution: WorkflowExecutionStatus,
-    workflow: WorkflowDefinition
-  ): Promise<void> {
-    await this.publishEvent<WorkflowStartedPayload>(
-      WorkflowEvents.WorkflowStarted,
-      {
-        executionId: execution.executionId,
-        workflowId: execution.workflowId,
-        workflowName: execution.workflowName,
-        stepCount: workflow.steps.length,
-      },
-      execution.context.metadata.correlationId
-    );
-  }
-
-  private async publishWorkflowCompleted(
-    execution: WorkflowExecutionStatus
-  ): Promise<void> {
-    await this.publishEvent<WorkflowCompletedPayload>(
-      WorkflowEvents.WorkflowCompleted,
-      {
-        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
-    );
-  }
-
-  private async publishWorkflowFailed(
-    execution: WorkflowExecutionStatus,
-    failedStep: string,
-    error: string
-  ): Promise<void> {
-    await this.publishEvent<WorkflowFailedPayload>(
-      WorkflowEvents.WorkflowFailed,
-      {
-        executionId: execution.executionId,
-        workflowId: execution.workflowId,
-        workflowName: execution.workflowName,
-        failedStep,
-        error,
-      },
-      execution.context.metadata.correlationId
-    );
-  }
-
-  private async publishStepStarted(
-    execution: WorkflowExecutionStatus,
-    step: WorkflowStepDefinition
-  ): Promise<void> {
-    await this.publishEvent<StepEventPayload>(
-      WorkflowEvents.StepStarted,
-      {
-        executionId: execution.executionId,
-        workflowId: execution.workflowId,
-        stepId: step.id,
-        stepName: step.name,
-        domain: step.domain,
-      },
-      execution.context.metadata.correlationId
-    );
-  }
-
-  private async publishStepCompleted(
-    execution: WorkflowExecutionStatus,
-    step: WorkflowStepDefinition,
-    result: StepExecutionResult
-  ): Promise<void> {
-    await this.publishEvent(
-      WorkflowEvents.StepCompleted,
-      {
-        executionId: execution.executionId,
-        workflowId: execution.workflowId,
-        stepId: step.id,
-        stepName: step.name,
-        domain: step.domain,
-        duration: result.duration,
-      },
-      execution.context.metadata.correlationId
-    );
-  }
-
-  private async publishStepFailed(
-    execution: WorkflowExecutionStatus,
-    step: WorkflowStepDefinition,
-    error: string
-  ): Promise<void> {
-    await this.publishEvent(
-      WorkflowEvents.StepFailed,
-      {
-        executionId: execution.executionId,
-        workflowId: execution.workflowId,
-        stepId: step.id,
-        stepName: step.name,
-        domain: step.domain,
-        error,
-      },
-      execution.context.metadata.correlationId
-    );
-  }
-
-  private async publishStepSkipped(
-    execution: WorkflowExecutionStatus,
-    step: WorkflowStepDefinition
-  ): Promise<void> {
-    await this.publishEvent<StepEventPayload>(
-      WorkflowEvents.StepSkipped,
-      {
-        executionId: execution.executionId,
-        workflowId: execution.workflowId,
-        stepId: step.id,
-        stepName: step.name,
-        domain: step.domain,
-      },
-      execution.context.metadata.correlationId
-    );
-  }
-
-  // ============================================================================
-  // Private Methods - Workflow Validation
-  // ============================================================================
-
-  private validateWorkflowDefinition(
-    definition: WorkflowDefinition
-  ): Result<void, Error> {
-    if (!definition.id) {
-      return err(new Error('Workflow ID is required'));
-    }
-
-    if (!definition.name) {
-      return err(new Error('Workflow name is required'));
-    }
-
-    if (!definition.steps || definition.steps.length === 0) {
-      return err(new Error('Workflow must have at least one step'));
-    }
-
-    // Validate steps
-    const stepIds = new Set<string>();
-    for (const step of definition.steps) {
-      if (!step.id) {
-        return err(new Error('Step ID is required'));
-      }
-
-      if (stepIds.has(step.id)) {
-        return err(new Error(`Duplicate step ID: ${step.id}`));
-      }
-      stepIds.add(step.id);
-
-      if (!step.domain) {
-        return err(new Error(`Step ${step.id} must have a domain`));
-      }
-
-      if (!ALL_DOMAINS.includes(step.domain)) {
-        return err(new Error(`Invalid domain for step ${step.id}: ${step.domain}`));
-      }
-
-      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)) {
-            return err(
-              new Error(`Step ${step.id} depends on unknown step: ${dep}`)
-            );
-          }
-        }
-      }
-    }
-
-    // Check for circular dependencies
-    const circularCheck = this.detectCircularDependencies(definition.steps);
-    if (circularCheck) {
-      return err(new Error(`Circular dependency detected: ${circularCheck}`));
-    }
-
-    return ok(undefined);
-  }
-
-  private detectCircularDependencies(
-    steps: WorkflowStepDefinition[]
-  ): string | null {
-    const visited = new Set<string>();
-    const recursionStack = new Set<string>();
-
-    const visit = (stepId: string, path: string[]): string | null => {
-      if (recursionStack.has(stepId)) {
-        return [...path, stepId].join(' -> ');
-      }
-
-      if (visited.has(stepId)) {
-        return null;
-      }
-
-      visited.add(stepId);
-      recursionStack.add(stepId);
-
-      const step = steps.find((s) => s.id === stepId);
-      if (step?.dependsOn) {
-        for (const dep of step.dependsOn) {
-          const result = visit(dep, [...path, stepId]);
-          if (result) return result;
-        }
-      }
-
-      recursionStack.delete(stepId);
-      return null;
-    };
-
-    for (const step of steps) {
-      const result = visit(step.id, []);
-      if (result) return result;
-    }
-
-    return null;
-  }
-
-  // ============================================================================
-  // Private Methods - Event Triggers
-  // ============================================================================
-
-  private setupEventTriggers(): void {
-    // Subscribe to all domain events for trigger matching
-    const subscription = this.eventBus.subscribe('*', async (event: DomainEvent) => {
-      await this.handleEventForTriggers(event);
-    });
-
-    this.eventSubscriptions.push(subscription);
-  }
-
-  private registerWorkflowTriggers(_workflow: WorkflowDefinition): void {
-    // Triggers are evaluated when events arrive via the * subscription
-    // No additional subscription needed, just store the workflow with triggers
-  }
-
-  private async handleEventForTriggers(event: DomainEvent): Promise<void> {
-    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: WorkflowContext = {
-            input: { event: event.payload },
-            results: {},
-            metadata: {
-              executionId: '',
-              workflowId: workflow.id,
-              startedAt: new Date(),
-            },
-          };
-
-          if (!this.evaluateCondition(trigger.condition, context)) {
-            continue;
-          }
-        }
-
-        // Build input from trigger mapping
-        const input: Record<string, unknown> = {};
-        if (trigger.inputMapping) {
-          for (const [targetKey, sourcePath] of Object.entries(trigger.inputMapping)) {
-            const value = this.getValueByPath({ event: event.payload }, sourcePath);
-            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);
-      }
-    }
-  }
-
-  // ============================================================================
-  // Private Methods - Built-in Workflows
-  // ============================================================================
-
-  private registerBuiltInWorkflows(): void {
-    // 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',
-          },
-        },
-      ],
-    });
-  }
-
-  // ============================================================================
-  // Private Methods - Persistence
-  // ============================================================================
-
-  private async loadPersistedWorkflows(): Promise<void> {
-    try {
-      const keys = await this.memory.search('workflow:definition:*', 100);
-
-      for (const key of keys) {
-        const definition = await this.memory.get<WorkflowDefinition>(key);
-        if (definition && !this.workflows.has(definition.id)) {
-          this.workflows.set(definition.id, definition);
-        }
-      }
-    } catch (error) {
-      console.error('Failed to load persisted workflows:', error);
-    }
-  }
-
-  private async persistWorkflows(): Promise<void> {
-    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)
-        ) {
-          continue;
-        }
-
-        await this.memory.set(
-          `workflow:definition:${workflow.id}`,
-          workflow,
-          { namespace: 'coordination', persist: true }
-        );
-      }
-    } catch (error) {
-      console.error('Failed to persist workflows:', error);
-    }
-  }
-
-  private async persistExecution(execution: WorkflowExecutionStatus): Promise<void> {
-    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
-      );
-    } catch (error) {
-      console.error('Failed to persist execution:', error);
-    }
-  }
-
-  // ============================================================================
-  // Private Methods - Utilities
-  // ============================================================================
-
-  private delay(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Register a domain action handler
-   */
-  registerAction(
-    domain: DomainName,
-    action: string,
-    handler: DomainAction
-  ): void {
-    if (!this.actionRegistry[domain]) {
-      this.actionRegistry[domain] = {};
-    }
-    this.actionRegistry[domain][action] = handler;
-  }
-}
-
-// ============================================================================
-// Factory Function
-// ============================================================================
-
-export function createWorkflowOrchestrator(
-  eventBus: EventBus,
-  memory: MemoryBackend,
-  agentCoordinator: AgentCoordinator,
-  config?: Partial<WorkflowOrchestratorConfig>
-): IWorkflowOrchestrator {
-  return new WorkflowOrchestrator(eventBus, memory, agentCoordinator, config);
-}