@agentic-qe/v3 3.0.0-alpha.3

package/src/coordination/workflow-orchestrator.ts

@@ -0,0 +1,1917 @@
+/**
+ * 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);
+}