@girardmedia/bootspring 1.2.0 → 2.0.3

package/intelligence/orchestrator.js

@@ -278,6 +278,36 @@ const WORKFLOWS = {
       { name: 'Experiment Build', agents: ['frontend-expert', 'backend-expert'], duration: '2-3 days' },
       { name: 'Analysis & Decision', agents: ['code-review-expert', 'architecture-expert'], duration: '1 day' }
     ]
+  },
+  'full-stack-parallel': {
+    name: 'Full Stack Parallel Development',
+    description: 'Concurrent frontend and backend development with parallel testing',
+    tier: 'free',
+    pack: null,
+    outcomes: ['Full stack feature delivered with parallel development streams'],
+    completionSignals: ['API contract finalized', 'Frontend and backend complete', 'Integration tests passing'],
+    phases: [
+      { name: 'Design & Contract', agents: ['api-expert', 'ui-ux-expert', 'architecture-expert'], duration: '1-2 days' },
+      { name: 'Backend Development', agents: ['backend-expert', 'database-expert'], duration: '2-4 days', parallel: true },
+      { name: 'Frontend Development', agents: ['frontend-expert', 'ui-ux-expert'], duration: '2-4 days', parallel: true },
+      { name: 'Integration & Testing', agents: ['testing-expert', 'security-expert'], duration: '1-2 days' },
+      { name: 'Review & Deploy', agents: ['code-review-expert', 'devops-expert'], duration: '1 day' }
+    ]
+  },
+  'comprehensive-audit': {
+    name: 'Comprehensive Audit',
+    description: 'Parallel security, performance, and code quality audits',
+    tier: 'free',
+    pack: null,
+    outcomes: ['Complete audit report with prioritized findings'],
+    completionSignals: ['All audits complete', 'Findings documented', 'Remediation plan created'],
+    phases: [
+      { name: 'Preparation', agents: ['architecture-expert'], duration: '0.5 days' },
+      { name: 'Security Audit', agents: ['security-expert'], duration: '1-2 days', parallel: true },
+      { name: 'Performance Audit', agents: ['performance-expert'], duration: '1-2 days', parallel: true },
+      { name: 'Code Quality Audit', agents: ['code-review-expert'], duration: '1-2 days', parallel: true },
+      { name: 'Report & Plan', agents: ['architecture-expert', 'code-review-expert'], duration: '1 day' }
+    ]
   }
 };
 
@@ -591,6 +621,7 @@ function startWorkflow(workflowName) {
 
 /**
  * Advance workflow to next step
+ * Automatically detects and handles parallel phases
  */
 function advanceWorkflow() {
   const state = loadState();
@@ -599,6 +630,25 @@ function advanceWorkflow() {
     return { success: false, error: 'No active workflow' };
   }
 
+  // Check if workflow is paused
+  if (state.workflowPaused) {
+    return {
+      success: false,
+      error: 'Workflow is paused. Use resumeWorkflow() before advancing.',
+      pausedAt: state.workflowPausedAt,
+      reason: state.workflowPauseReason
+    };
+  }
+
+  // Check if we're in parallel execution mode
+  if (state.parallelExecution) {
+    return {
+      success: false,
+      error: 'Parallel phases in progress. Use completeParallelPhase() to mark phases complete.',
+      parallelStatus: getParallelExecutionStatus()
+    };
+  }
+
   const workflow = WORKFLOWS[state.activeWorkflow];
   const activeWorkflowName = state.activeWorkflow;
   state.workflowStep += 1;
@@ -626,6 +676,59 @@ function advanceWorkflow() {
     return { success: true, complete: true };
   }
 
+  // Check if next phase(s) are parallel
+  const nextPhase = workflow.phases[state.workflowStep];
+  if (nextPhase.parallel) {
+    // Find all consecutive parallel phases
+    const parallelPhases = [];
+    let i = state.workflowStep;
+    while (i < workflow.phases.length && workflow.phases[i].parallel) {
+      parallelPhases.push({
+        index: i,
+        phase: workflow.phases[i],
+        status: 'in_progress',
+        startedAt: new Date().toISOString()
+      });
+      i++;
+    }
+
+    // Initialize parallel execution state
+    state.parallelExecution = {
+      workflow: activeWorkflowName,
+      phases: parallelPhases,
+      startedAt: new Date().toISOString(),
+      completedPhases: []
+    };
+
+    state.history.push({
+      action: 'parallel_phases_started',
+      workflow: activeWorkflowName,
+      phases: parallelPhases.map(p => p.phase.name),
+      timestamp: new Date().toISOString()
+    });
+
+    saveState(state);
+
+    emitWorkflowTelemetry('parallel_phases_started', {
+      workflow: activeWorkflowName,
+      phaseCount: parallelPhases.length,
+      phases: parallelPhases.map(p => p.phase.name)
+    });
+
+    return {
+      success: true,
+      complete: false,
+      parallelExecution: true,
+      parallelPhases: parallelPhases.map(p => ({
+        index: p.index,
+        name: p.phase.name,
+        agents: p.phase.agents,
+        duration: p.phase.duration
+      })),
+      message: `Started ${parallelPhases.length} parallel phases. Complete each with completeParallelPhase(index).`
+    };
+  }
+
   saveState(state);
   emitWorkflowTelemetry('workflow_step_advanced', {
     workflow: activeWorkflowName,
@@ -812,6 +915,18 @@ function displayStatus() {
   if (state.activeWorkflow) {
     const workflow = WORKFLOWS[state.activeWorkflow];
     console.log(`${c.bold}Workflow Step:${c.reset} ${state.workflowStep + 1}/${workflow.phases.length}`);
+
+    // Show pause status
+    if (state.workflowPaused) {
+      const pausedAt = state.workflowPausedAt ? new Date(state.workflowPausedAt) : null;
+      const pauseDuration = pausedAt ? Math.round((new Date() - pausedAt) / 1000) : 0;
+      console.log(`${c.yellow}${c.bold}Workflow Status:${c.reset}${c.yellow} PAUSED${c.reset}`);
+      console.log(`${c.bold}Paused At:${c.reset} ${state.workflowPausedAt}`);
+      console.log(`${c.bold}Pause Duration:${c.reset} ${formatDuration(pauseDuration)}`);
+      if (state.workflowPauseReason) {
+        console.log(`${c.bold}Pause Reason:${c.reset} ${state.workflowPauseReason}`);
+      }
+    }
   }
 
   if (state.suggestions.length > 0) {
@@ -842,6 +957,8 @@ ${c.cyan}Commands:${c.reset}
   workflows             List available workflows
   start <workflow>      Start a workflow
   next                  Advance to next workflow step
+  pause [reason]        Pause the active workflow
+  resume                Resume a paused workflow
   status                Show orchestrator status
   agents                List available agents
   help                  Show this help
@@ -850,6 +967,8 @@ ${c.cyan}Examples:${c.reset}
   node orchestrator.js analyze "building authentication api"
   node orchestrator.js workflow feature-development
   node orchestrator.js start feature-development
+  node orchestrator.js pause "waiting for external review"
+  node orchestrator.js resume
   node orchestrator.js status
 `);
 }
@@ -924,6 +1043,41 @@ if (require.main === module) {
       break;
     }
 
+    case 'pause': {
+      const pauseReason = args.slice(1).join(' ') || null;
+      const pauseResult = pauseWorkflow(pauseReason);
+      if (pauseResult.success) {
+        console.log(`${c.yellow}Workflow paused${c.reset}`);
+        console.log(`${c.bold}Workflow:${c.reset} ${pauseResult.workflow}`);
+        console.log(`${c.bold}Step:${c.reset} ${pauseResult.step}/${pauseResult.totalSteps}`);
+        console.log(`${c.bold}Phase:${c.reset} ${pauseResult.currentPhase.name}`);
+        if (pauseResult.reason) {
+          console.log(`${c.bold}Reason:${c.reset} ${pauseResult.reason}`);
+        }
+        console.log(`${c.dim}Use 'resume' to continue the workflow${c.reset}`);
+      } else {
+        console.log(`${c.red}Error: ${pauseResult.error}${c.reset}`);
+      }
+      break;
+    }
+
+    case 'resume': {
+      const resumeResult = resumeWorkflow();
+      if (resumeResult.success) {
+        console.log(`${c.green}Workflow resumed${c.reset}`);
+        console.log(`${c.bold}Workflow:${c.reset} ${resumeResult.workflow}`);
+        console.log(`${c.bold}Step:${c.reset} ${resumeResult.step}/${resumeResult.totalSteps}`);
+        console.log(`${c.bold}Phase:${c.reset} ${resumeResult.currentPhase.name}`);
+        console.log(`${c.bold}Pause Duration:${c.reset} ${formatDuration(resumeResult.pauseDuration)}`);
+        if (resumeResult.previousPauseReason) {
+          console.log(`${c.dim}Previous pause reason: ${resumeResult.previousPauseReason}${c.reset}`);
+        }
+      } else {
+        console.log(`${c.red}Error: ${resumeResult.error}${c.reset}`);
+      }
+      break;
+    }
+
     case 'status':
       displayStatus();
       break;
@@ -945,12 +1099,2713 @@ if (require.main === module) {
 }
 
 // Export for use as module
+/**
+ * Remediation workflows for common failure scenarios
+ * Enhanced with severity levels, auto-trigger options, fallback phases, and preventive actions
+ */
+const REMEDIATION_PATHS = {
+  'testing-failure': {
+    description: 'Tests failed during workflow',
+    severity: 'high',
+    autoTrigger: true,
+    maxRetries: 3,
+    steps: [
+      { action: 'analyze_failures', agent: 'testing-expert', description: 'Analyze test failures', timeout: 300 },
+      { action: 'fix_issues', agent: 'code-review-expert', description: 'Review and fix failing code', timeout: 600 },
+      { action: 'rerun_tests', agent: 'testing-expert', description: 'Re-run tests', timeout: 300 }
+    ],
+    preventiveActions: [
+      'Run tests locally before committing',
+      'Check for flaky tests in CI history',
+      'Verify test environment configuration'
+    ],
+    fallbackPhase: { name: 'Manual Review', agents: ['code-review-expert'], duration: '1-2 days' }
+  },
+  'security-failure': {
+    description: 'Security issues found during workflow',
+    severity: 'critical',
+    autoTrigger: true,
+    maxRetries: 2,
+    steps: [
+      { action: 'security_audit', agent: 'security-expert', description: 'Full security audit', timeout: 600 },
+      { action: 'remediate', agent: 'security-expert', description: 'Fix security vulnerabilities', timeout: 900 },
+      { action: 'verify', agent: 'security-expert', description: 'Verify fixes', timeout: 300 }
+    ],
+    preventiveActions: [
+      'Run security scans in pre-commit hooks',
+      'Keep dependencies updated',
+      'Review auth/authz changes carefully'
+    ],
+    fallbackPhase: { name: 'Security Escalation', agents: ['security-expert', 'architecture-expert'], duration: '2-3 days' }
+  },
+  'performance-failure': {
+    description: 'Performance issues detected',
+    severity: 'medium',
+    autoTrigger: false,
+    maxRetries: 2,
+    steps: [
+      { action: 'profile', agent: 'performance-expert', description: 'Profile application', timeout: 600 },
+      { action: 'optimize', agent: 'performance-expert', description: 'Implement optimizations', timeout: 900 },
+      { action: 'benchmark', agent: 'performance-expert', description: 'Benchmark improvements', timeout: 300 }
+    ],
+    preventiveActions: [
+      'Set performance budgets',
+      'Monitor bundle sizes',
+      'Profile database queries'
+    ],
+    fallbackPhase: { name: 'Performance Review', agents: ['performance-expert', 'database-expert'], duration: '2-3 days' }
+  },
+  'deployment-failure': {
+    description: 'Deployment failed',
+    severity: 'high',
+    autoTrigger: true,
+    maxRetries: 2,
+    steps: [
+      { action: 'diagnose', agent: 'devops-expert', description: 'Diagnose deployment failure', timeout: 300 },
+      { action: 'fix_config', agent: 'devops-expert', description: 'Fix configuration issues', timeout: 600 },
+      { action: 'retry_deploy', agent: 'devops-expert', description: 'Retry deployment', timeout: 300 }
+    ],
+    preventiveActions: [
+      'Deploy to staging first',
+      'Verify environment variables',
+      'Check resource limits and quotas'
+    ],
+    fallbackPhase: { name: 'Deployment Rollback', agents: ['devops-expert'], duration: '0.5 days' }
+  },
+  'database-failure': {
+    description: 'Database issues detected',
+    severity: 'high',
+    autoTrigger: true,
+    maxRetries: 1,
+    steps: [
+      { action: 'analyze_schema', agent: 'database-expert', description: 'Analyze database issues', timeout: 300 },
+      { action: 'fix_migration', agent: 'database-expert', description: 'Fix migration issues', timeout: 600 },
+      { action: 'verify_data', agent: 'database-expert', description: 'Verify data integrity', timeout: 300 }
+    ],
+    preventiveActions: [
+      'Test migrations on copy of production data',
+      'Have rollback plan ready',
+      'Check for breaking schema changes'
+    ],
+    fallbackPhase: { name: 'Database Recovery', agents: ['database-expert', 'devops-expert'], duration: '1-2 days' }
+  },
+  'build-failure': {
+    description: 'Build process failed',
+    severity: 'high',
+    autoTrigger: true,
+    maxRetries: 3,
+    steps: [
+      { action: 'analyze_build', agent: 'devops-expert', description: 'Analyze build errors', timeout: 300 },
+      { action: 'fix_dependencies', agent: 'backend-expert', description: 'Fix dependency issues', timeout: 600 },
+      { action: 'rebuild', agent: 'devops-expert', description: 'Rebuild application', timeout: 300 }
+    ],
+    preventiveActions: [
+      'Lock dependency versions',
+      'Verify build environment matches CI',
+      'Check for circular dependencies'
+    ],
+    fallbackPhase: { name: 'Build Investigation', agents: ['devops-expert', 'backend-expert'], duration: '1 day' }
+  },
+  'integration-failure': {
+    description: 'Integration issues with external services',
+    severity: 'medium',
+    autoTrigger: false,
+    maxRetries: 2,
+    steps: [
+      { action: 'diagnose_integration', agent: 'api-expert', description: 'Diagnose integration issues', timeout: 300 },
+      { action: 'fix_api', agent: 'api-expert', description: 'Fix API integration', timeout: 600 },
+      { action: 'verify_integration', agent: 'testing-expert', description: 'Verify integration works', timeout: 300 }
+    ],
+    preventiveActions: [
+      'Mock external services in tests',
+      'Check API version compatibility',
+      'Verify credentials and permissions'
+    ],
+    fallbackPhase: { name: 'Integration Workaround', agents: ['api-expert', 'backend-expert'], duration: '1-2 days' }
+  },
+  'timeout-failure': {
+    description: 'Operation timed out',
+    severity: 'medium',
+    autoTrigger: false,
+    maxRetries: 2,
+    steps: [
+      { action: 'profile_operation', agent: 'performance-expert', description: 'Profile slow operation', timeout: 600 },
+      { action: 'optimize_critical_path', agent: 'performance-expert', description: 'Optimize critical path', timeout: 600 },
+      { action: 'adjust_timeout', agent: 'devops-expert', description: 'Adjust timeout settings', timeout: 300 }
+    ],
+    preventiveActions: [
+      'Set appropriate timeout values',
+      'Add progress indicators',
+      'Consider async processing'
+    ],
+    fallbackPhase: { name: 'Async Processing', agents: ['backend-expert', 'performance-expert'], duration: '1-2 days' }
+  }
+};
+
+/**
+ * Failure pattern signatures for auto-detection
+ * Maps keywords to failure types for intelligent failure classification
+ */
+const FAILURE_SIGNATURES = {
+  'testing': ['test', 'spec', 'jest', 'vitest', 'assertion', 'expect', 'failing', 'failed test'],
+  'security': ['vulnerability', 'auth', 'permission', 'unauthorized', 'csrf', 'xss', 'injection', 'security'],
+  'performance': ['slow', 'timeout', 'memory', 'cpu', 'latency', 'bottleneck', 'performance'],
+  'deployment': ['deploy', 'release', 'ci/cd', 'pipeline', 'staging', 'production', 'build failed'],
+  'database': ['migration', 'schema', 'query', 'prisma', 'sql', 'database', 'connection', 'deadlock'],
+  'build': ['build', 'compile', 'bundle', 'webpack', 'typescript', 'syntax error', 'module not found'],
+  'integration': ['api', 'endpoint', 'external', 'service', 'http', 'request failed', '500', '503'],
+  'timeout': ['timeout', 'deadline', 'exceeded', 'timed out', 'ETIMEDOUT']
+};
+
+/**
+ * Severity weights for adaptive response calculation
+ */
+const SEVERITY_WEIGHTS = {
+  'critical': 4,
+  'high': 3,
+  'medium': 2,
+  'low': 1
+};
+/**
+ * Report a phase failure and get remediation options
+ * @param {string} failureType - Type of failure (testing, security, performance, deployment, database)
+ * @param {object} details - Failure details
+ */
+function reportPhaseFailure(failureType, details = {}) {
+  const state = loadState();
+
+  if (!state.activeWorkflow) {
+    return { success: false, error: 'No active workflow' };
+  }
+
+  const workflow = WORKFLOWS[state.activeWorkflow];
+  const currentPhase = workflow.phases[state.workflowStep];
+
+  // Record the failure
+  state.workflowFailures = state.workflowFailures || [];
+  const failure = {
+    id: `failure-${Date.now()}`,
+    workflow: state.activeWorkflow,
+    phase: currentPhase.name,
+    phaseIndex: state.workflowStep,
+    type: failureType,
+    details,
+    timestamp: new Date().toISOString(),
+    resolved: false
+  };
+  state.workflowFailures.push(failure);
+
+  // Get remediation path
+  const remediationKey = `${failureType}-failure`;
+  const remediation = REMEDIATION_PATHS[remediationKey];
+
+  state.history.push({
+    action: 'phase_failure_reported',
+    workflow: state.activeWorkflow,
+    phase: currentPhase.name,
+    failureType,
+    timestamp: new Date().toISOString()
+  });
+
+  saveState(state);
+
+  emitWorkflowTelemetry('workflow_phase_failed', {
+    workflow: state.activeWorkflow,
+    phase: currentPhase.name,
+    failureType,
+    tier: workflow.tier || 'free'
+  });
+
+  return {
+    success: true,
+    failureId: failure.id,
+    workflow: state.activeWorkflow,
+    phase: currentPhase.name,
+    failureType,
+    remediation: remediation || null,
+    message: remediation
+      ? `Remediation path available: ${remediation.description}`
+      : 'No specific remediation path found. Consider manual review.'
+  };
+}
+
+/**
+ * Start remediation for a failure
+ * @param {string} failureId - Failure ID
+ */
+function startRemediation(failureId) {
+  const state = loadState();
+
+  const failure = state.workflowFailures?.find(f => f.id === failureId);
+  if (!failure) {
+    return { success: false, error: 'Failure not found' };
+  }
+
+  if (failure.resolved) {
+    return { success: false, error: 'Failure already resolved' };
+  }
+
+  const remediationKey = `${failure.type}-failure`;
+  const remediation = REMEDIATION_PATHS[remediationKey];
+
+  if (!remediation) {
+    return { success: false, error: 'No remediation path for this failure type' };
+  }
+
+  // Set up remediation state
+  state.activeRemediation = {
+    failureId,
+    type: failure.type,
+    currentStep: 0,
+    steps: remediation.steps,
+    startedAt: new Date().toISOString()
+  };
+
+  state.history.push({
+    action: 'remediation_started',
+    failureId,
+    type: failure.type,
+    timestamp: new Date().toISOString()
+  });
+
+  saveState(state);
+
+  return {
+    success: true,
+    failureId,
+    remediation: {
+      description: remediation.description,
+      currentStep: remediation.steps[0],
+      totalSteps: remediation.steps.length
+    },
+    message: `Remediation started. First step: ${remediation.steps[0].description}`
+  };
+}
+
+/**
+ * Advance remediation to next step
+ */
+function advanceRemediation() {
+  const state = loadState();
+
+  if (!state.activeRemediation) {
+    return { success: false, error: 'No active remediation' };
+  }
+
+  const rem = state.activeRemediation;
+  rem.currentStep += 1;
+
+  if (rem.currentStep >= rem.steps.length) {
+    // Remediation complete - mark failure as resolved
+    const failure = state.workflowFailures?.find(f => f.id === rem.failureId);
+    if (failure) {
+      failure.resolved = true;
+      failure.resolvedAt = new Date().toISOString();
+    }
+
+    state.history.push({
+      action: 'remediation_completed',
+      failureId: rem.failureId,
+      timestamp: new Date().toISOString()
+    });
+
+    state.activeRemediation = null;
+    saveState(state);
+
+    return {
+      success: true,
+      complete: true,
+      message: 'Remediation complete. You can resume the workflow.'
+    };
+  }
+
+  saveState(state);
+
+  return {
+    success: true,
+    complete: false,
+    currentStep: rem.steps[rem.currentStep],
+    stepNumber: rem.currentStep + 1,
+    totalSteps: rem.steps.length,
+    message: `Step ${rem.currentStep + 1}/${rem.steps.length}: ${rem.steps[rem.currentStep].description}`
+  };
+}
+
+/**
+ * Get workflow failure history
+ */
+function getWorkflowFailures() {
+  const state = loadState();
+  return state.workflowFailures || [];
+}
+
+/**
+ * Pause active workflow
+ * @param {string} reason - Optional reason for pausing the workflow
+ */
+function pauseWorkflow(reason = null) {
+  const state = loadState();
+
+  if (!state.activeWorkflow) {
+    return { success: false, error: 'No active workflow to pause' };
+  }
+
+  if (state.workflowPaused) {
+    return { success: false, error: 'Workflow is already paused' };
+  }
+
+  const workflow = WORKFLOWS[state.activeWorkflow];
+  if (!workflow) {
+    return { success: false, error: 'Active workflow not found' };
+  }
+
+  const pauseTimestamp = new Date().toISOString();
+
+  // Capture complete pause context for exact resume
+  state.workflowPaused = true;
+  state.workflowPausedAt = pauseTimestamp;
+  state.workflowPauseReason = reason;
+  state.workflowPauseContext = {
+    workflow: state.activeWorkflow,
+    step: state.workflowStep,
+    phase: workflow.phases[state.workflowStep],
+    parallelExecution: state.parallelExecution ? { ...state.parallelExecution } : null,
+    activeRemediation: state.activeRemediation ? { ...state.activeRemediation } : null,
+    workflowSignals: state.workflowSignals?.[state.activeWorkflow] || [],
+    timestamp: pauseTimestamp
+  };
+
+  state.history.push({
+    action: 'workflow_paused',
+    workflow: state.activeWorkflow,
+    step: state.workflowStep,
+    reason: reason,
+    timestamp: pauseTimestamp
+  });
+
+  saveState(state);
+
+  emitWorkflowTelemetry('workflow_paused', {
+    workflow: state.activeWorkflow,
+    tier: workflow.tier || 'free',
+    pack: workflow.pack || null,
+    step: state.workflowStep,
+    reason: reason
+  });
+
+  return {
+    success: true,
+    workflow: state.activeWorkflow,
+    step: state.workflowStep + 1,
+    totalSteps: workflow.phases.length,
+    currentPhase: workflow.phases[state.workflowStep],
+    pausedAt: pauseTimestamp,
+    reason: reason,
+    context: state.workflowPauseContext,
+    message: `Workflow "${state.activeWorkflow}" paused at step ${state.workflowStep + 1}${reason ? ` (reason: ${reason})` : ''}`
+  };
+}
+
+/**
+ * Resume paused workflow
+ * Continues from the exact point where the workflow was paused
+ */
+function resumeWorkflow() {
+  const state = loadState();
+
+  if (!state.activeWorkflow) {
+    return { success: false, error: 'No active workflow to resume' };
+  }
+
+  if (!state.workflowPaused) {
+    return { success: false, error: 'Workflow is not paused' };
+  }
+
+  const workflow = WORKFLOWS[state.activeWorkflow];
+  if (!workflow) {
+    return { success: false, error: 'Active workflow not found' };
+  }
+
+  // Calculate pause duration
+  const pausedAt = new Date(state.workflowPausedAt);
+  const resumedAt = new Date();
+  const pauseDuration = Math.round((resumedAt - pausedAt) / 1000); // seconds
+
+  // Capture pause context before clearing
+  const pauseContext = state.workflowPauseContext || {};
+  const pauseReason = state.workflowPauseReason;
+
+  // Verify and restore workflow state from pause context if needed
+  // This ensures we resume from the exact point even after process restart
+  if (pauseContext.step !== undefined && pauseContext.step !== state.workflowStep) {
+    state.workflowStep = pauseContext.step;
+  }
+
+  // Restore parallel execution state if it was active during pause
+  if (pauseContext.parallelExecution && !state.parallelExecution) {
+    state.parallelExecution = pauseContext.parallelExecution;
+  }
+
+  // Restore active remediation if it was in progress
+  if (pauseContext.activeRemediation && !state.activeRemediation) {
+    state.activeRemediation = pauseContext.activeRemediation;
+  }
+
+  // Clear pause state
+  state.workflowPaused = false;
+  state.workflowPausedAt = null;
+  state.workflowPauseReason = null;
+  state.workflowPauseContext = null;
+
+  state.history.push({
+    action: 'workflow_resumed',
+    workflow: state.activeWorkflow,
+    step: state.workflowStep,
+    pauseDurationSeconds: pauseDuration,
+    previousPauseReason: pauseReason,
+    timestamp: resumedAt.toISOString()
+  });
+
+  saveState(state);
+
+  emitWorkflowTelemetry('workflow_resumed', {
+    workflow: state.activeWorkflow,
+    tier: workflow.tier || 'free',
+    pack: workflow.pack || null,
+    step: state.workflowStep,
+    pauseDurationSeconds: pauseDuration,
+    previousPauseReason: pauseReason
+  });
+
+  // Build resume context with all relevant state
+  const resumeContext = {
+    step: state.workflowStep + 1,
+    totalSteps: workflow.phases.length,
+    currentPhase: workflow.phases[state.workflowStep],
+    parallelExecutionActive: !!state.parallelExecution,
+    remediationActive: !!state.activeRemediation
+  };
+
+  if (state.parallelExecution) {
+    resumeContext.parallelExecution = getParallelExecutionStatus();
+  }
+
+  return {
+    success: true,
+    workflow: state.activeWorkflow,
+    step: state.workflowStep + 1,
+    totalSteps: workflow.phases.length,
+    currentPhase: workflow.phases[state.workflowStep],
+    pauseDuration: pauseDuration,
+    previousPauseReason: pauseReason,
+    resumeContext: resumeContext,
+    message: `Workflow "${state.activeWorkflow}" resumed at step ${state.workflowStep + 1} (was paused for ${formatDuration(pauseDuration)}${pauseReason ? `, reason: ${pauseReason}` : ''})`
+  };
+}
+
+/**
+ * Format duration in seconds to human-readable string
+ * @param {number} seconds - Duration in seconds
+ */
+function formatDuration(seconds) {
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  if (seconds < 3600) {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+  }
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.floor((seconds % 3600) / 60);
+  return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+}
+
+/**
+ * Check if workflow is paused and get pause details
+ */
+function isWorkflowPaused() {
+  const state = loadState();
+
+  if (!state.workflowPaused) {
+    return {
+      paused: false,
+      workflow: state.activeWorkflow
+    };
+  }
+
+  const workflow = state.activeWorkflow ? WORKFLOWS[state.activeWorkflow] : null;
+  const pausedAt = state.workflowPausedAt ? new Date(state.workflowPausedAt) : null;
+  const pauseDuration = pausedAt ? Math.round((new Date() - pausedAt) / 1000) : 0;
+
+  return {
+    paused: true,
+    workflow: state.activeWorkflow,
+    workflowName: workflow?.name,
+    pausedAt: state.workflowPausedAt,
+    reason: state.workflowPauseReason,
+    pauseDurationSeconds: pauseDuration,
+    pauseDurationFormatted: formatDuration(pauseDuration),
+    pauseContext: state.workflowPauseContext || null,
+    canResume: !!state.activeWorkflow && !!workflow
+  };
+}
+
+/**
+ * Get detailed pause state for persistence verification
+ * Useful for debugging or verifying state after process restart
+ */
+function getPauseState() {
+  const state = loadState();
+
+  if (!state.workflowPaused) {
+    return { paused: false };
+  }
+
+  return {
+    paused: true,
+    workflow: state.activeWorkflow,
+    step: state.workflowStep,
+    pausedAt: state.workflowPausedAt,
+    reason: state.workflowPauseReason,
+    context: state.workflowPauseContext,
+    statePath: getPaths().statePath
+  };
+}
+
+/**
+ * PRD-Workflow Integration
+ * Links PRD stories to workflow phases for automatic progress tracking
+ */
+
+/**
+ * Analyze story content to determine best workflow phase match
+ * Uses keywords and patterns to intelligently map stories to phases
+ * @param {object} story - The story object
+ * @param {object} workflow - The workflow definition
+ * @returns {object} - { phaseIndex, confidence, score }
+ */
+function analyzeStoryForPhase(story, workflow) {
+  const titleLower = (story.title || '').toLowerCase();
+  const descLower = (story.description || '').toLowerCase();
+  const acceptanceLower = (story.acceptance || []).join(' ').toLowerCase();
+  const combined = `${titleLower} ${descLower} ${acceptanceLower}`;
+
+  // Phase detection patterns
+  const phasePatterns = {
+    'Design': ['design', 'wireframe', 'mockup', 'layout', 'ui design', 'ux', 'prototype', 'spec', 'figma'],
+    'Design & Contract': ['contract', 'api design', 'interface', 'specification'],
+    'Implementation': ['implement', 'build', 'create', 'develop', 'add', 'integrate', 'code', 'feature'],
+    'Backend Development': ['api', 'endpoint', 'server', 'backend', 'route', 'handler', 'service'],
+    'Frontend Development': ['component', 'page', 'frontend', 'react', 'ui component', 'view', 'form'],
+    'Testing': ['test', 'spec', 'coverage', 'qa', 'quality', 'verify', 'validate', 'unit test', 'e2e'],
+    'Integration & Testing': ['integration', 'e2e', 'end-to-end'],
+    'Review': ['review', 'audit', 'check', 'code review', 'pr review'],
+    'Security': ['security', 'auth', 'permission', 'sanitize', 'vulnerability', 'encryption', 'oauth'],
+    'Deployment': ['deploy', 'release', 'ci/cd', 'pipeline', 'production', 'staging'],
+    'Review & Deploy': ['ship', 'merge', 'release'],
+    'Schema Design': ['schema', 'model', 'database design', 'migration', 'table', 'entity'],
+    'Database': ['database', 'query', 'prisma', 'sql', 'orm'],
+    'Analysis': ['analyze', 'profile', 'benchmark', 'metrics', 'audit'],
+    'Preparation': ['setup', 'init', 'configure', 'prepare', 'scaffold'],
+    'Infrastructure': ['infrastructure', 'devops', 'docker', 'kubernetes', 'aws', 'vercel'],
+    'Monitoring': ['monitor', 'logging', 'observability', 'alerts', 'metrics']
+  };
+
+  let bestMatch = null;
+  let bestScore = 0;
+
+  for (let phaseIdx = 0; phaseIdx < workflow.phases.length; phaseIdx++) {
+    const phase = workflow.phases[phaseIdx];
+    const phaseName = phase.name;
+    const patterns = phasePatterns[phaseName] || [];
+
+    let score = 0;
+
+    // Check direct phase name match (highest weight)
+    if (combined.includes(phaseName.toLowerCase())) {
+      score += 5;
+    }
+
+    // Check pattern matches
+    for (const pattern of patterns) {
+      if (combined.includes(pattern)) {
+        score += 2;
+      }
+    }
+
+    // Check agent-related keywords
+    for (const agent of phase.agents) {
+      const agentKeywords = agent.replace('-expert', '').split('-');
+      for (const keyword of agentKeywords) {
+        if (keyword.length > 2 && combined.includes(keyword)) {
+          score += 1;
+        }
+      }
+    }
+
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = phaseIdx;
+    }
+  }
+
+  if (bestMatch !== null && bestScore > 0) {
+    const confidence = bestScore >= 5 ? 'high' : bestScore >= 2 ? 'medium' : 'low';
+    return { phaseIndex: bestMatch, confidence, score: bestScore };
+  }
+
+  return { phaseIndex: null, confidence: 'none', score: 0 };
+}
+
+/**
+ * Link a PRD to a workflow
+ * Maps PRD stories to workflow phases based on story content analysis
+ * @param {object} prd - The PRD object
+ * @param {string} workflowName - Name of the workflow to link
+ * @param {object} options - Optional configuration
+ * @param {object} options.manualMapping - Manual story->phase mapping { storyId: phaseIndex }
+ * @param {boolean} options.autoAdvance - Auto-advance workflow on phase completion (default: true)
+ */
+function linkPrdToWorkflow(prd, workflowName, options = {}) {
+  const workflow = WORKFLOWS[workflowName];
+  if (!workflow) {
+    return { success: false, error: `Unknown workflow: ${workflowName}` };
+  }
+
+  if (!prd || !prd.stories) {
+    return { success: false, error: 'Invalid PRD' };
+  }
+
+  const state = loadState();
+  state.prdWorkflowLinks = state.prdWorkflowLinks || {};
+
+  const storyPhaseMap = {};
+  const phaseCount = workflow.phases.length;
+  const mappingDetails = { manual: [], analyzed: [], fallback: [] };
+
+  prd.stories.forEach((story, index) => {
+    // Check for manual mapping override
+    if (options.manualMapping && options.manualMapping[story.id] !== undefined) {
+      const manualPhase = options.manualMapping[story.id];
+      if (manualPhase >= 0 && manualPhase < phaseCount) {
+        storyPhaseMap[story.id] = {
+          phase: manualPhase,
+          phaseName: workflow.phases[manualPhase].name,
+          storyTitle: story.title,
+          status: story.status || 'pending',
+          confidence: 'manual'
+        };
+        mappingDetails.manual.push(story.id);
+        return;
+      }
+    }
+
+    // Try intelligent mapping based on story content
+    const analysis = analyzeStoryForPhase(story, workflow);
+
+    if (analysis.phaseIndex !== null && analysis.confidence !== 'none') {
+      storyPhaseMap[story.id] = {
+        phase: analysis.phaseIndex,
+        phaseName: workflow.phases[analysis.phaseIndex].name,
+        storyTitle: story.title,
+        status: story.status || 'pending',
+        confidence: analysis.confidence,
+        analysisScore: analysis.score
+      };
+      mappingDetails.analyzed.push(story.id);
+    } else {
+      // Fallback: distribute evenly across phases
+      const phaseIndex = Math.floor((index / prd.stories.length) * phaseCount);
+      storyPhaseMap[story.id] = {
+        phase: phaseIndex,
+        phaseName: workflow.phases[phaseIndex].name,
+        storyTitle: story.title,
+        status: story.status || 'pending',
+        confidence: 'fallback'
+      };
+      mappingDetails.fallback.push(story.id);
+    }
+  });
+
+  // Build phase progress tracking
+  const phaseProgress = {};
+  workflow.phases.forEach((phase, idx) => {
+    const storiesInPhase = Object.entries(storyPhaseMap)
+      .filter(([, mapping]) => mapping.phase === idx);
+    const completedInPhase = storiesInPhase
+      .filter(([, mapping]) => mapping.status === 'complete');
+
+    phaseProgress[idx] = {
+      phaseName: phase.name,
+      total: storiesInPhase.length,
+      completed: completedInPhase.length,
+      percent: storiesInPhase.length > 0
+        ? Math.round((completedInPhase.length / storiesInPhase.length) * 100)
+        : 0,
+      stories: storiesInPhase.map(([id, mapping]) => ({
+        id,
+        title: mapping.storyTitle,
+        status: mapping.status,
+        confidence: mapping.confidence
+      }))
+    };
+  });
+
+  // Track completed story IDs
+  const completedStoryIds = prd.stories
+    .filter(s => s.status === 'complete')
+    .map(s => s.id);
+
+  state.prdWorkflowLinks[prd.name] = {
+    workflow: workflowName,
+    linkedAt: new Date().toISOString(),
+    storyPhaseMap,
+    phaseProgress,
+    totalStories: prd.stories.length,
+    completedStories: completedStoryIds.length,
+    completedStoryIds,
+    autoAdvance: options.autoAdvance !== false,
+    mappingDetails
+  };
+
+  state.history.push({
+    action: 'prd_linked_to_workflow',
+    prd: prd.name,
+    workflow: workflowName,
+    storyCount: prd.stories.length,
+    mappingBreakdown: {
+      manual: mappingDetails.manual.length,
+      analyzed: mappingDetails.analyzed.length,
+      fallback: mappingDetails.fallback.length
+    },
+    timestamp: new Date().toISOString()
+  });
+
+  saveState(state);
+
+  emitWorkflowTelemetry('prd_workflow_linked', {
+    prd: prd.name,
+    workflow: workflowName,
+    storyCount: prd.stories.length,
+    analyzedMappings: mappingDetails.analyzed.length,
+    fallbackMappings: mappingDetails.fallback.length
+  });
+
+  return {
+    success: true,
+    workflow: workflowName,
+    workflowName: workflow.name,
+    prd: prd.name,
+    mapping: storyPhaseMap,
+    phaseProgress,
+    mappingDetails,
+    message: `Linked ${prd.stories.length} stories to ${phaseCount} workflow phases`
+  };
+}
+
+/**
+ * Notify workflow when a PRD story is completed
+ * Advances workflow if all stories in current phase are done
+ * @param {string} prdName - Name of the PRD
+ * @param {string} storyId - ID of the completed story
+ */
+function onPrdStoryComplete(prdName, storyId) {
+  const state = loadState();
+  const link = state.prdWorkflowLinks?.[prdName];
+
+  if (!link) {
+    return { success: false, error: 'PRD not linked to a workflow' };
+  }
+
+  const workflow = WORKFLOWS[link.workflow];
+  if (!workflow) {
+    return { success: false, error: 'Linked workflow not found' };
+  }
+
+  const storyMapping = link.storyPhaseMap[storyId];
+  if (!storyMapping) {
+    return { success: true, advanced: false, message: 'Story not mapped to workflow phase' };
+  }
+
+  // Check if already marked complete
+  if (link.completedStoryIds?.includes(storyId)) {
+    return {
+      success: true,
+      advanced: false,
+      message: 'Story already marked complete',
+      progress: {
+        completed: link.completedStories,
+        total: link.totalStories,
+        percent: Math.round((link.completedStories / link.totalStories) * 100)
+      }
+    };
+  }
+
+  // Update story status in mapping
+  storyMapping.status = 'complete';
+  storyMapping.completedAt = new Date().toISOString();
+
+  // Update completed tracking
+  link.completedStoryIds = link.completedStoryIds || [];
+  link.completedStoryIds.push(storyId);
+  link.completedStories = link.completedStoryIds.length;
+
+  // Update phase progress
+  const storyPhase = storyMapping.phase;
+  if (link.phaseProgress && link.phaseProgress[storyPhase]) {
+    const phaseStories = Object.entries(link.storyPhaseMap)
+      .filter(([, m]) => m.phase === storyPhase);
+    const completedInPhase = phaseStories.filter(([, m]) => m.status === 'complete');
+
+    link.phaseProgress[storyPhase].completed = completedInPhase.length;
+    link.phaseProgress[storyPhase].percent = Math.round(
+      (completedInPhase.length / phaseStories.length) * 100
+    );
+
+    link.phaseProgress[storyPhase].stories = phaseStories.map(([id, mapping]) => ({
+      id,
+      title: mapping.storyTitle,
+      status: mapping.status,
+      confidence: mapping.confidence
+    }));
+  }
+
+  state.prdWorkflowLinks[prdName] = link;
+
+  state.history.push({
+    action: 'prd_story_completed',
+    prd: prdName,
+    storyId,
+    phase: storyMapping.phaseName,
+    timestamp: new Date().toISOString()
+  });
+
+  // Check if current workflow phase is complete
+  const currentPhase = state.workflowStep || 0;
+  const phaseProgress = link.phaseProgress?.[currentPhase];
+  const phaseComplete = phaseProgress &&
+    phaseProgress.total > 0 &&
+    phaseProgress.completed >= phaseProgress.total;
+
+  // Auto-advance if enabled and phase is complete
+  if (link.autoAdvance !== false &&
+      phaseComplete &&
+      storyMapping.phase === currentPhase &&
+      state.activeWorkflow === link.workflow) {
+
+    saveState(state);
+    const advanceResult = advanceWorkflow();
+
+    emitWorkflowTelemetry('prd_triggered_phase_advance', {
+      prd: prdName,
+      workflow: link.workflow,
+      fromPhase: currentPhase,
+      triggeredBy: storyId
+    });
+
+    return {
+      success: true,
+      advanced: true,
+      advanceResult,
+      phaseCompleted: storyMapping.phaseName,
+      message: `Story completed. Phase "${storyMapping.phaseName}" complete - workflow advanced.`,
+      progress: {
+        completed: link.completedStories,
+        total: link.totalStories,
+        percent: Math.round((link.completedStories / link.totalStories) * 100),
+        phaseProgress: link.phaseProgress
+      }
+    };
+  }
+
+  saveState(state);
+
+  emitWorkflowTelemetry('prd_story_completed', {
+    prd: prdName,
+    workflow: link.workflow,
+    storyId,
+    phase: storyMapping.phase,
+    phaseName: storyMapping.phaseName,
+    phaseComplete
+  });
+
+  return {
+    success: true,
+    advanced: false,
+    storyPhase: storyMapping.phaseName,
+    phaseComplete,
+    message: phaseComplete
+      ? `Story completed. Phase "${storyMapping.phaseName}" is now complete.`
+      : 'Story completed.',
+    progress: {
+      completed: link.completedStories,
+      total: link.totalStories,
+      percent: Math.round((link.completedStories / link.totalStories) * 100),
+      phaseProgress: link.phaseProgress
+    }
+  };
+}
+
+/**
+ * Get PRD-Workflow link status with detailed progress
+ * @param {string} prdName - Name of the PRD
+ * @returns {object|null} - Link status or null if not linked
+ */
+function getPrdWorkflowStatus(prdName) {
+  const state = loadState();
+  const link = state.prdWorkflowLinks?.[prdName];
+
+  if (!link) {
+    return null;
+  }
+
+  const workflow = WORKFLOWS[link.workflow];
+  const currentPhase = state.workflowStep || 0;
+
+  return {
+    prd: prdName,
+    workflow: link.workflow,
+    workflowName: workflow?.name,
+    linkedAt: link.linkedAt,
+    autoAdvance: link.autoAdvance !== false,
+    currentWorkflowPhase: currentPhase,
+    currentPhaseName: workflow?.phases[currentPhase]?.name,
+    progress: {
+      completed: link.completedStories || 0,
+      total: link.totalStories || 0,
+      percent: link.totalStories > 0
+        ? Math.round(((link.completedStories || 0) / link.totalStories) * 100)
+        : 0
+    },
+    phaseProgress: link.phaseProgress,
+    storyPhaseMap: link.storyPhaseMap,
+    completedStoryIds: link.completedStoryIds || [],
+    mappingDetails: link.mappingDetails
+  };
+}
+
+/**
+ * Get stories for a specific workflow phase
+ * @param {string} prdName - Name of the PRD
+ * @param {number} phaseIndex - Index of the workflow phase
+ * @returns {object|null} - Phase stories info or null
+ */
+function getPhaseStories(prdName, phaseIndex) {
+  const state = loadState();
+  const link = state.prdWorkflowLinks?.[prdName];
+
+  if (!link) {
+    return null;
+  }
+
+  const workflow = WORKFLOWS[link.workflow];
+  if (!workflow || phaseIndex >= workflow.phases.length) {
+    return null;
+  }
+
+  const phase = workflow.phases[phaseIndex];
+  const phaseProgress = link.phaseProgress?.[phaseIndex];
+
+  if (!phaseProgress) {
+    return {
+      phase: phaseIndex,
+      phaseName: phase.name,
+      agents: phase.agents,
+      stories: [],
+      progress: { total: 0, completed: 0, percent: 0 }
+    };
+  }
+
+  return {
+    phase: phaseIndex,
+    phaseName: phase.name,
+    agents: phase.agents,
+    duration: phase.duration,
+    stories: phaseProgress.stories || [],
+    progress: {
+      total: phaseProgress.total,
+      completed: phaseProgress.completed,
+      percent: phaseProgress.percent
+    }
+  };
+}
+
+/**
+ * Manually reassign a story to a different workflow phase
+ * @param {string} prdName - Name of the PRD
+ * @param {string} storyId - ID of the story
+ * @param {number} newPhaseIndex - New phase index to assign
+ */
+function reassignStoryToPhase(prdName, storyId, newPhaseIndex) {
+  const state = loadState();
+  const link = state.prdWorkflowLinks?.[prdName];
+
+  if (!link) {
+    return { success: false, error: 'PRD not linked to a workflow' };
+  }
+
+  const workflow = WORKFLOWS[link.workflow];
+  if (!workflow) {
+    return { success: false, error: 'Linked workflow not found' };
+  }
+
+  if (newPhaseIndex < 0 || newPhaseIndex >= workflow.phases.length) {
+    return { success: false, error: 'Invalid phase index' };
+  }
+
+  const storyMapping = link.storyPhaseMap[storyId];
+  if (!storyMapping) {
+    return { success: false, error: 'Story not found in PRD' };
+  }
+
+  const oldPhase = storyMapping.phase;
+  const oldPhaseName = storyMapping.phaseName;
+
+  // Update mapping
+  storyMapping.phase = newPhaseIndex;
+  storyMapping.phaseName = workflow.phases[newPhaseIndex].name;
+  storyMapping.confidence = 'manual';
+  storyMapping.reassignedAt = new Date().toISOString();
+
+  // Rebuild phase progress
+  workflow.phases.forEach((phase, idx) => {
+    const storiesInPhase = Object.entries(link.storyPhaseMap)
+      .filter(([, m]) => m.phase === idx);
+    const completedInPhase = storiesInPhase.filter(([, m]) => m.status === 'complete');
+
+    link.phaseProgress[idx] = {
+      phaseName: phase.name,
+      total: storiesInPhase.length,
+      completed: completedInPhase.length,
+      percent: storiesInPhase.length > 0
+        ? Math.round((completedInPhase.length / storiesInPhase.length) * 100)
+        : 0,
+      stories: storiesInPhase.map(([id, mapping]) => ({
+        id,
+        title: mapping.storyTitle,
+        status: mapping.status,
+        confidence: mapping.confidence
+      }))
+    };
+  });
+
+  state.history.push({
+    action: 'prd_story_reassigned',
+    prd: prdName,
+    storyId,
+    fromPhase: oldPhaseName,
+    toPhase: storyMapping.phaseName,
+    timestamp: new Date().toISOString()
+  });
+
+  saveState(state);
+
+  return {
+    success: true,
+    storyId,
+    fromPhase: { index: oldPhase, name: oldPhaseName },
+    toPhase: { index: newPhaseIndex, name: storyMapping.phaseName },
+    message: `Story reassigned from "${oldPhaseName}" to "${storyMapping.phaseName}"`
+  };
+}
+
+/**
+ * Unlink a PRD from its workflow
+ * @param {string} prdName - Name of the PRD
+ */
+function unlinkPrdFromWorkflow(prdName) {
+  const state = loadState();
+
+  if (!state.prdWorkflowLinks?.[prdName]) {
+    return { success: false, error: 'PRD not linked to a workflow' };
+  }
+
+  const link = state.prdWorkflowLinks[prdName];
+  delete state.prdWorkflowLinks[prdName];
+
+  state.history.push({
+    action: 'prd_unlinked_from_workflow',
+    prd: prdName,
+    workflow: link.workflow,
+    timestamp: new Date().toISOString()
+  });
+
+  saveState(state);
+
+  return {
+    success: true,
+    prd: prdName,
+    workflow: link.workflow,
+    message: `PRD "${prdName}" unlinked from workflow "${link.workflow}"`
+  };
+}
+
+/**
+ * Get all PRDs linked to workflows
+ */
+function getLinkedPrds() {
+  const state = loadState();
+  const links = state.prdWorkflowLinks || {};
+
+  return Object.entries(links).map(([prdName, link]) => ({
+    prd: prdName,
+    workflow: link.workflow,
+    linkedAt: link.linkedAt,
+    progress: {
+      completed: link.completedStories || 0,
+      total: link.totalStories || 0,
+      percent: link.totalStories > 0
+        ? Math.round(((link.completedStories || 0) / link.totalStories) * 100)
+        : 0
+    }
+  }));
+}
+
+/**
+ * Parallel Phase Execution
+ * Enables concurrent execution of workflow phases marked with `parallel: true`
+ *
+ * Features:
+ * - Concurrent execution of parallel phases
+ * - Partial failure handling with configurable strategies
+ * - Individual phase progress tracking within parallel groups
+ * - Failure recovery and retry support
+ */
+
+/**
+ * Failure strategy options for parallel execution
+ * - 'fail-fast': Stop all phases on first failure (default)
+ * - 'continue': Continue other phases, collect failures at end
+ * - 'retry': Allow retry of failed phases while others continue
+ */
+const PARALLEL_FAILURE_STRATEGIES = {
+  'fail-fast': 'Stop all phases when one fails',
+  'continue': 'Continue other phases, handle failures at completion',
+  'retry': 'Allow retry of failed phases'
+};
+
+/**
+ * Start parallel phase execution
+ * Identifies consecutive parallel phases and starts them together
+ * @param {string} workflowName - Workflow to execute
+ * @param {number} startIndex - Starting phase index
+ * @param {object} options - Execution options
+ * @param {string} options.failureStrategy - How to handle failures ('fail-fast', 'continue', 'retry')
+ * @param {number} options.maxRetries - Maximum retry attempts for 'retry' strategy (default: 2)
+ */
+function startParallelPhases(workflowName, startIndex = 0, options = {}) {
+  const workflow = WORKFLOWS[workflowName];
+  if (!workflow) {
+    return { success: false, error: `Unknown workflow: ${workflowName}` };
+  }
+
+  const state = loadState();
+  const failureStrategy = options.failureStrategy || 'continue';
+  const maxRetries = options.maxRetries || 2;
+
+  // Validate failure strategy
+  if (!PARALLEL_FAILURE_STRATEGIES[failureStrategy]) {
+    return {
+      success: false,
+      error: `Invalid failure strategy: ${failureStrategy}. Valid options: ${Object.keys(PARALLEL_FAILURE_STRATEGIES).join(', ')}`
+    };
+  }
+
+  // Find consecutive parallel phases starting from startIndex
+  const parallelPhases = [];
+  let i = startIndex;
+
+  while (i < workflow.phases.length && workflow.phases[i].parallel) {
+    parallelPhases.push({
+      index: i,
+      phase: workflow.phases[i],
+      status: 'in_progress',
+      progress: {
+        percent: 0,
+        currentTask: null,
+        tasksCompleted: 0,
+        tasksTotal: 0,
+        lastUpdate: new Date().toISOString()
+      },
+      startedAt: new Date().toISOString(),
+      retryCount: 0
+    });
+    i++;
+  }
+
+  // If no parallel phases, also check if current phase should be included alone
+  if (parallelPhases.length === 0 && startIndex < workflow.phases.length) {
+    return { success: false, isSequential: true, message: 'Phase is sequential, not parallel' };
+  }
+
+  // Initialize parallel execution state
+  state.parallelExecution = {
+    workflow: workflowName,
+    phases: parallelPhases,
+    startedAt: new Date().toISOString(),
+    completedPhases: [],
+    failedPhases: [],
+    failureStrategy,
+    maxRetries,
+    halted: false,
+    haltReason: null
+  };
+
+  state.history.push({
+    action: 'parallel_phases_started',
+    workflow: workflowName,
+    phases: parallelPhases.map(p => p.phase.name),
+    failureStrategy,
+    timestamp: new Date().toISOString()
+  });
+
+  saveState(state);
+
+  emitWorkflowTelemetry('parallel_phases_started', {
+    workflow: workflowName,
+    phaseCount: parallelPhases.length,
+    phases: parallelPhases.map(p => p.phase.name),
+    failureStrategy
+  });
+
+  return {
+    success: true,
+    workflow: workflowName,
+    failureStrategy,
+    parallelPhases: parallelPhases.map(p => ({
+      index: p.index,
+      name: p.phase.name,
+      agents: p.phase.agents,
+      duration: p.phase.duration,
+      progress: p.progress
+    })),
+    message: `Started ${parallelPhases.length} parallel phases with '${failureStrategy}' failure strategy`
+  };
+}
+
+/**
+ * Mark a parallel phase as complete
+ * @param {number} phaseIndex - Index of the completed phase
+ * @param {object} result - Optional result/output from the phase
+ */
+function completeParallelPhase(phaseIndex, result = null) {
+  const state = loadState();
+
+  if (!state.parallelExecution) {
+    return { success: false, error: 'No parallel execution in progress' };
+  }
+
+  const pe = state.parallelExecution;
+  const workflow = WORKFLOWS[pe.workflow];
+  if (!workflow) {
+    return { success: false, error: 'Workflow not found' };
+  }
+
+  // Check if execution is halted
+  if (pe.halted) {
+    return {
+      success: false,
+      error: 'Parallel execution is halted due to failure',
+      haltReason: pe.haltReason
+    };
+  }
+
+  // Find the phase in parallel execution
+  const phaseEntry = pe.phases.find(p => p.index === phaseIndex);
+  if (!phaseEntry) {
+    return { success: false, error: 'Phase not in parallel execution' };
+  }
+
+  if (phaseEntry.status === 'completed') {
+    return { success: false, error: 'Phase already completed' };
+  }
+
+  if (phaseEntry.status === 'failed' && pe.failureStrategy !== 'retry') {
+    return { success: false, error: 'Phase has failed. Use retryParallelPhase() to retry.' };
+  }
+
+  // Mark phase as complete
+  phaseEntry.status = 'completed';
+  phaseEntry.completedAt = new Date().toISOString();
+  phaseEntry.result = result;
+  phaseEntry.progress = {
+    percent: 100,
+    currentTask: null,
+    tasksCompleted: phaseEntry.progress?.tasksTotal || 0,
+    tasksTotal: phaseEntry.progress?.tasksTotal || 0,
+    lastUpdate: new Date().toISOString()
+  };
+
+  // Remove from failed if it was retried
+  pe.failedPhases = pe.failedPhases.filter(idx => idx !== phaseIndex);
+  pe.completedPhases.push(phaseIndex);
+
+  state.history.push({
+    action: 'parallel_phase_completed',
+    workflow: pe.workflow,
+    phase: phaseEntry.phase.name,
+    phaseIndex,
+    timestamp: new Date().toISOString()
+  });
+
+  // Check if all parallel phases are complete or resolved
+  const activePhases = pe.phases.filter(p => p.status === 'in_progress');
+  const failedPhases = pe.phases.filter(p => p.status === 'failed');
+  const allResolved = activePhases.length === 0;
+
+  if (allResolved) {
+    return finalizeParallelExecution(state, pe, workflow, failedPhases);
+  }
+
+  saveState(state);
+
+  const remaining = activePhases.length;
+  return {
+    success: true,
+    phaseComplete: true,
+    allParallelComplete: false,
+    remaining,
+    failedCount: failedPhases.length,
+    completedPhases: pe.completedPhases.length,
+    totalPhases: pe.phases.length,
+    message: `Phase completed. ${remaining} parallel phases remaining${failedPhases.length > 0 ? `, ${failedPhases.length} failed` : ''}.`
+  };
+}
+
+/**
+ * Mark a parallel phase as failed
+ * @param {number} phaseIndex - Index of the failed phase
+ * @param {object} error - Error details
+ * @param {string} error.message - Error message
+ * @param {string} error.type - Error type (e.g., 'testing', 'security', 'timeout')
+ * @param {object} error.details - Additional error details
+ */
+function failParallelPhase(phaseIndex, error = {}) {
+  const state = loadState();
+
+  if (!state.parallelExecution) {
+    return { success: false, error: 'No parallel execution in progress' };
+  }
+
+  const pe = state.parallelExecution;
+  const workflow = WORKFLOWS[pe.workflow];
+  if (!workflow) {
+    return { success: false, error: 'Workflow not found' };
+  }
+
+  // Find the phase in parallel execution
+  const phaseEntry = pe.phases.find(p => p.index === phaseIndex);
+  if (!phaseEntry) {
+    return { success: false, error: 'Phase not in parallel execution' };
+  }
+
+  if (phaseEntry.status === 'completed') {
+    return { success: false, error: 'Cannot fail a completed phase' };
+  }
+
+  if (phaseEntry.status === 'failed') {
+    return { success: false, error: 'Phase already marked as failed' };
+  }
+
+  // Mark phase as failed
+  phaseEntry.status = 'failed';
+  phaseEntry.failedAt = new Date().toISOString();
+  phaseEntry.error = {
+    message: error.message || 'Phase failed',
+    type: error.type || 'unknown',
+    details: error.details || {}
+  };
+
+  pe.failedPhases.push(phaseIndex);
+
+  state.history.push({
+    action: 'parallel_phase_failed',
+    workflow: pe.workflow,
+    phase: phaseEntry.phase.name,
+    phaseIndex,
+    error: phaseEntry.error,
+    timestamp: new Date().toISOString()
+  });
+
+  emitWorkflowTelemetry('parallel_phase_failed', {
+    workflow: pe.workflow,
+    phase: phaseEntry.phase.name,
+    phaseIndex,
+    errorType: phaseEntry.error.type,
+    failureStrategy: pe.failureStrategy
+  });
+
+  // Handle based on failure strategy
+  if (pe.failureStrategy === 'fail-fast') {
+    // Halt all phases
+    pe.halted = true;
+    pe.haltReason = `Phase "${phaseEntry.phase.name}" failed: ${phaseEntry.error.message}`;
+
+    state.history.push({
+      action: 'parallel_execution_halted',
+      workflow: pe.workflow,
+      reason: pe.haltReason,
+      failedPhase: phaseEntry.phase.name,
+      timestamp: new Date().toISOString()
+    });
+
+    saveState(state);
+
+    return {
+      success: true,
+      phaseFailed: true,
+      halted: true,
+      haltReason: pe.haltReason,
+      failedPhases: pe.failedPhases.map(idx => {
+        const p = pe.phases.find(ph => ph.index === idx);
+        return { index: idx, name: p?.phase.name, error: p?.error };
+      }),
+      message: `Parallel execution halted: ${pe.haltReason}`
+    };
+  }
+
+  // For 'continue' and 'retry' strategies
+  const activePhases = pe.phases.filter(p => p.status === 'in_progress');
+  const allResolved = activePhases.length === 0;
+
+  if (allResolved) {
+    return finalizeParallelExecution(state, pe, workflow, pe.phases.filter(p => p.status === 'failed'));
+  }
+
+  saveState(state);
+
+  const canRetry = pe.failureStrategy === 'retry' && phaseEntry.retryCount < pe.maxRetries;
+
+  return {
+    success: true,
+    phaseFailed: true,
+    halted: false,
+    canRetry,
+    retriesRemaining: canRetry ? pe.maxRetries - phaseEntry.retryCount : 0,
+    activePhases: activePhases.length,
+    failedPhases: pe.failedPhases.length,
+    message: canRetry
+      ? `Phase failed but can be retried (${pe.maxRetries - phaseEntry.retryCount} retries remaining). Other phases continue.`
+      : 'Phase failed. Other phases continue.'
+  };
+}
+
+/**
+ * Retry a failed parallel phase
+ * @param {number} phaseIndex - Index of the phase to retry
+ */
+function retryParallelPhase(phaseIndex) {
+  const state = loadState();
+
+  if (!state.parallelExecution) {
+    return { success: false, error: 'No parallel execution in progress' };
+  }
+
+  const pe = state.parallelExecution;
+  const workflow = WORKFLOWS[pe.workflow];
+  if (!workflow) {
+    return { success: false, error: 'Workflow not found' };
+  }
+
+  if (pe.failureStrategy !== 'retry') {
+    return { success: false, error: 'Retry not enabled. Use "retry" failure strategy.' };
+  }
+
+  const phaseEntry = pe.phases.find(p => p.index === phaseIndex);
+  if (!phaseEntry) {
+    return { success: false, error: 'Phase not in parallel execution' };
+  }
+
+  if (phaseEntry.status !== 'failed') {
+    return { success: false, error: 'Phase is not in failed state' };
+  }
+
+  if (phaseEntry.retryCount >= pe.maxRetries) {
+    return {
+      success: false,
+      error: `Maximum retries (${pe.maxRetries}) exceeded for this phase`,
+      retryCount: phaseEntry.retryCount
+    };
+  }
+
+  // Reset phase for retry
+  phaseEntry.status = 'in_progress';
+  phaseEntry.retryCount += 1;
+  phaseEntry.lastRetryAt = new Date().toISOString();
+  phaseEntry.progress = {
+    percent: 0,
+    currentTask: null,
+    tasksCompleted: 0,
+    tasksTotal: phaseEntry.progress?.tasksTotal || 0,
+    lastUpdate: new Date().toISOString()
+  };
+
+  // Remove from failed phases list
+  pe.failedPhases = pe.failedPhases.filter(idx => idx !== phaseIndex);
+
+  // Clear halt if it was halted
+  if (pe.halted) {
+    pe.halted = false;
+    pe.haltReason = null;
+  }
+
+  state.history.push({
+    action: 'parallel_phase_retried',
+    workflow: pe.workflow,
+    phase: phaseEntry.phase.name,
+    phaseIndex,
+    retryCount: phaseEntry.retryCount,
+    timestamp: new Date().toISOString()
+  });
+
+  saveState(state);
+
+  emitWorkflowTelemetry('parallel_phase_retried', {
+    workflow: pe.workflow,
+    phase: phaseEntry.phase.name,
+    phaseIndex,
+    retryCount: phaseEntry.retryCount
+  });
+
+  return {
+    success: true,
+    phase: phaseEntry.phase.name,
+    retryCount: phaseEntry.retryCount,
+    retriesRemaining: pe.maxRetries - phaseEntry.retryCount,
+    message: `Phase "${phaseEntry.phase.name}" restarted (retry ${phaseEntry.retryCount}/${pe.maxRetries})`
+  };
+}
+
+/**
+ * Update progress for a parallel phase
+ * @param {number} phaseIndex - Index of the phase
+ * @param {object} progress - Progress update
+ * @param {number} progress.percent - Completion percentage (0-100)
+ * @param {string} progress.currentTask - Current task description
+ * @param {number} progress.tasksCompleted - Number of tasks completed
+ * @param {number} progress.tasksTotal - Total number of tasks
+ */
+function updateParallelPhaseProgress(phaseIndex, progress = {}) {
+  const state = loadState();
+
+  if (!state.parallelExecution) {
+    return { success: false, error: 'No parallel execution in progress' };
+  }
+
+  const pe = state.parallelExecution;
+  const phaseEntry = pe.phases.find(p => p.index === phaseIndex);
+
+  if (!phaseEntry) {
+    return { success: false, error: 'Phase not in parallel execution' };
+  }
+
+  if (phaseEntry.status !== 'in_progress') {
+    return { success: false, error: `Cannot update progress for phase in ${phaseEntry.status} state` };
+  }
+
+  // Update progress
+  phaseEntry.progress = {
+    percent: Math.min(100, Math.max(0, progress.percent ?? phaseEntry.progress?.percent ?? 0)),
+    currentTask: progress.currentTask ?? phaseEntry.progress?.currentTask,
+    tasksCompleted: progress.tasksCompleted ?? phaseEntry.progress?.tasksCompleted ?? 0,
+    tasksTotal: progress.tasksTotal ?? phaseEntry.progress?.tasksTotal ?? 0,
+    lastUpdate: new Date().toISOString()
+  };
+
+  saveState(state);
+
+  return {
+    success: true,
+    phaseIndex,
+    phaseName: phaseEntry.phase.name,
+    progress: phaseEntry.progress
+  };
+}
+
+/**
+ * Finalize parallel execution when all phases are resolved
+ * @private
+ */
+function finalizeParallelExecution(state, pe, workflow, failedPhases) {
+  const hasFailures = failedPhases.length > 0;
+  const completedPhases = pe.phases.filter(p => p.status === 'completed');
+
+  if (hasFailures) {
+    // Parallel execution completed with failures
+    state.history.push({
+      action: 'parallel_execution_completed_with_failures',
+      workflow: pe.workflow,
+      completedPhases: completedPhases.map(p => p.phase.name),
+      failedPhases: failedPhases.map(p => p.phase.name),
+      timestamp: new Date().toISOString()
+    });
+
+    emitWorkflowTelemetry('parallel_phases_completed_with_failures', {
+      workflow: pe.workflow,
+      completedCount: completedPhases.length,
+      failedCount: failedPhases.length,
+      phases: pe.phases.map(p => ({ name: p.phase.name, status: p.status }))
+    });
+
+    // Keep parallel execution state for potential recovery
+    pe.resolved = true;
+    pe.resolvedAt = new Date().toISOString();
+    saveState(state);
+
+    return {
+      success: true,
+      allParallelComplete: true,
+      hasFailures: true,
+      completedPhases: completedPhases.map(p => ({
+        index: p.index,
+        name: p.phase.name,
+        result: p.result
+      })),
+      failedPhases: failedPhases.map(p => ({
+        index: p.index,
+        name: p.phase.name,
+        error: p.error
+      })),
+      message: `Parallel execution completed with ${failedPhases.length} failure(s). Review failures before proceeding.`,
+      canProceed: false,
+      recoveryOptions: ['retryFailed', 'skipFailed', 'cancelWorkflow']
+    };
+  }
+
+  // All phases completed successfully
+  const maxPhaseIndex = Math.max(...pe.phases.map(p => p.index));
+  state.workflowStep = maxPhaseIndex + 1;
+
+  state.history.push({
+    action: 'parallel_execution_complete',
+    workflow: pe.workflow,
+    phases: pe.phases.map(p => p.phase.name),
+    timestamp: new Date().toISOString()
+  });
+
+  emitWorkflowTelemetry('parallel_phases_completed', {
+    workflow: pe.workflow,
+    phaseCount: pe.phases.length,
+    phases: pe.phases.map(p => p.phase.name)
+  });
+
+  // Check if workflow is now complete
+  if (state.workflowStep >= workflow.phases.length) {
+    state.activeWorkflow = null;
+    state.parallelExecution = null;
+    saveState(state);
+
+    return {
+      success: true,
+      phaseComplete: true,
+      allParallelComplete: true,
+      hasFailures: false,
+      workflowComplete: true,
+      message: 'All parallel phases complete. Workflow finished.'
+    };
+  }
+
+  // Clear parallel execution state
+  state.parallelExecution = null;
+  saveState(state);
+
+  return {
+    success: true,
+    phaseComplete: true,
+    allParallelComplete: true,
+    hasFailures: false,
+    workflowComplete: false,
+    nextPhase: workflow.phases[state.workflowStep],
+    message: 'All parallel phases complete. Continuing to next phase.'
+  };
+}
+
+/**
+ * Skip failed phases and proceed with workflow
+ * Use after parallel execution completes with failures
+ */
+function skipFailedParallelPhases() {
+  const state = loadState();
+
+  if (!state.parallelExecution) {
+    return { success: false, error: 'No parallel execution in progress' };
+  }
+
+  const pe = state.parallelExecution;
+  if (!pe.resolved) {
+    return { success: false, error: 'Parallel execution not yet resolved' };
+  }
+
+  const workflow = WORKFLOWS[pe.workflow];
+  if (!workflow) {
+    return { success: false, error: 'Workflow not found' };
+  }
+
+  const failedPhases = pe.phases.filter(p => p.status === 'failed');
+  const skippedNames = failedPhases.map(p => p.phase.name);
+
+  // Move past all parallel phases
+  const maxPhaseIndex = Math.max(...pe.phases.map(p => p.index));
+  state.workflowStep = maxPhaseIndex + 1;
+
+  state.history.push({
+    action: 'parallel_failed_phases_skipped',
+    workflow: pe.workflow,
+    skippedPhases: skippedNames,
+    timestamp: new Date().toISOString()
+  });
+
+  // Check if workflow is now complete
+  if (state.workflowStep >= workflow.phases.length) {
+    state.activeWorkflow = null;
+    state.parallelExecution = null;
+    saveState(state);
+
+    return {
+      success: true,
+      skippedPhases: skippedNames,
+      workflowComplete: true,
+      message: `Skipped ${skippedNames.length} failed phases. Workflow finished.`
+    };
+  }
+
+  state.parallelExecution = null;
+  saveState(state);
+
+  return {
+    success: true,
+    skippedPhases: skippedNames,
+    workflowComplete: false,
+    nextPhase: workflow.phases[state.workflowStep],
+    message: `Skipped ${skippedNames.length} failed phases. Continuing to next phase.`
+  };
+}
+
+/**
+ * Retry all failed phases in parallel execution
+ */
+function retryAllFailedPhases() {
+  const state = loadState();
+
+  if (!state.parallelExecution) {
+    return { success: false, error: 'No parallel execution in progress' };
+  }
+
+  const pe = state.parallelExecution;
+  const failedPhases = pe.phases.filter(p => p.status === 'failed');
+
+  if (failedPhases.length === 0) {
+    return { success: false, error: 'No failed phases to retry' };
+  }
+
+  // Check if retries are allowed
+  const canRetryAll = failedPhases.every(p => p.retryCount < pe.maxRetries);
+  if (!canRetryAll && pe.failureStrategy === 'retry') {
+    const exhausted = failedPhases.filter(p => p.retryCount >= pe.maxRetries);
+    return {
+      success: false,
+      error: 'Some phases have exhausted retries',
+      exhaustedPhases: exhausted.map(p => ({ name: p.phase.name, retryCount: p.retryCount }))
+    };
+  }
+
+  const retriedPhases = [];
+
+  for (const phaseEntry of failedPhases) {
+    phaseEntry.status = 'in_progress';
+    phaseEntry.retryCount += 1;
+    phaseEntry.lastRetryAt = new Date().toISOString();
+    phaseEntry.progress = {
+      percent: 0,
+      currentTask: null,
+      tasksCompleted: 0,
+      tasksTotal: phaseEntry.progress?.tasksTotal || 0,
+      lastUpdate: new Date().toISOString()
+    };
+    retriedPhases.push(phaseEntry.phase.name);
+  }
+
+  pe.failedPhases = [];
+  pe.resolved = false;
+  pe.halted = false;
+  pe.haltReason = null;
+
+  state.history.push({
+    action: 'parallel_all_failed_retried',
+    workflow: pe.workflow,
+    retriedPhases,
+    timestamp: new Date().toISOString()
+  });
+
+  saveState(state);
+
+  return {
+    success: true,
+    retriedPhases,
+    message: `Retrying ${retriedPhases.length} failed phases`
+  };
+}
+
+/**
+ * Get parallel execution status with detailed progress tracking
+ */
+function getParallelExecutionStatus() {
+  const state = loadState();
+
+  if (!state.parallelExecution) {
+    return { active: false };
+  }
+
+  const pe = state.parallelExecution;
+  const workflow = WORKFLOWS[pe.workflow];
+
+  // Calculate aggregate progress
+  const inProgressPhases = pe.phases.filter(p => p.status === 'in_progress');
+  const completedPhases = pe.phases.filter(p => p.status === 'completed');
+  const failedPhases = pe.phases.filter(p => p.status === 'failed');
+
+  // Calculate overall progress percentage
+  const totalProgress = pe.phases.reduce((sum, p) => {
+    if (p.status === 'completed') return sum + 100;
+    if (p.status === 'failed') return sum + 0;
+    return sum + (p.progress?.percent || 0);
+  }, 0);
+  const overallPercent = Math.round(totalProgress / pe.phases.length);
+
+  return {
+    active: true,
+    workflow: pe.workflow,
+    workflowName: workflow?.name,
+    startedAt: pe.startedAt,
+    failureStrategy: pe.failureStrategy,
+    maxRetries: pe.maxRetries,
+    halted: pe.halted || false,
+    haltReason: pe.haltReason,
+    resolved: pe.resolved || false,
+    phases: pe.phases.map(p => ({
+      index: p.index,
+      name: p.phase.name,
+      agents: p.phase.agents,
+      status: p.status,
+      progress: p.progress || { percent: 0 },
+      startedAt: p.startedAt,
+      completedAt: p.completedAt,
+      failedAt: p.failedAt,
+      error: p.error,
+      retryCount: p.retryCount || 0,
+      result: p.result
+    })),
+    summary: {
+      total: pe.phases.length,
+      inProgress: inProgressPhases.length,
+      completed: completedPhases.length,
+      failed: failedPhases.length
+    },
+    progress: {
+      completed: completedPhases.length,
+      total: pe.phases.length,
+      percent: overallPercent,
+      byPhase: pe.phases.map(p => ({
+        name: p.phase.name,
+        status: p.status,
+        percent: p.status === 'completed' ? 100 : p.status === 'failed' ? 0 : (p.progress?.percent || 0)
+      }))
+    }
+  };
+}
+
+/**
+ * Cancel parallel execution
+ */
+function cancelParallelExecution() {
+  const state = loadState();
+
+  if (!state.parallelExecution) {
+    return { success: false, error: 'No parallel execution to cancel' };
+  }
+
+  const pe = state.parallelExecution;
+
+  state.history.push({
+    action: 'parallel_execution_cancelled',
+    workflow: pe.workflow,
+    phases: pe.phases.map(p => p.phase.name),
+    completedPhases: pe.completedPhases.length,
+    timestamp: new Date().toISOString()
+  });
+
+  state.parallelExecution = null;
+  saveState(state);
+
+  return {
+    success: true,
+    message: 'Parallel execution cancelled'
+  };
+}
+
+/**
+ * Check if a workflow phase supports parallel execution
+ * @param {string} workflowName - Workflow name
+ * @param {number} phaseIndex - Phase index
+ */
+function isParallelPhase(workflowName, phaseIndex) {
+  const workflow = WORKFLOWS[workflowName];
+  if (!workflow || phaseIndex >= workflow.phases.length) {
+    return false;
+  }
+  return !!workflow.phases[phaseIndex].parallel;
+}
+
+/**
+ * Define a custom workflow with parallel phases
+ * @param {string} name - Workflow name
+ * @param {object} definition - Workflow definition
+ */
+function defineWorkflowWithParallel(name, definition) {
+  if (!definition.name || !definition.phases) {
+    return { success: false, error: 'Invalid workflow definition' };
+  }
+
+  // Validate parallel phases
+  for (const phase of definition.phases) {
+    if (phase.parallel && (!phase.agents || phase.agents.length === 0)) {
+      return { success: false, error: `Parallel phase "${phase.name}" must have agents` };
+    }
+  }
+
+  WORKFLOWS[name] = {
+    ...definition,
+    tier: definition.tier || 'free',
+    pack: definition.pack || null
+  };
+
+  return {
+    success: true,
+    workflow: name,
+    phases: definition.phases.length,
+    parallelPhases: definition.phases.filter(p => p.parallel).length
+  };
+}
+
+
+/**
+ * =============================================================================
+ * ADAPTIVE WORKFLOW SYSTEM
+ * =============================================================================
+ *
+ * Provides intelligent failure handling with:
+ * - Automatic failure type detection from error messages
+ * - Adaptive remediation path selection
+ * - Failure pattern tracking and learning
+ * - Preventive action suggestions based on history
+ * - Fallback phase support for workflows
+ */
+
+/**
+ * Auto-detect failure type from error message or details
+ * Uses FAILURE_SIGNATURES to classify the failure
+ * @param {string} errorMessage - Error message or description
+ * @param {object} details - Additional details about the failure
+ * @returns {object} - { type, confidence, matchedKeywords }
+ */
+function detectFailureType(errorMessage, details = {}) {
+  const combined = (errorMessage + ' ' + JSON.stringify(details)).toLowerCase();
+  const scores = {};
+  const matches = {};
+
+  // Score each failure type based on keyword matches
+  for (const [type, keywords] of Object.entries(FAILURE_SIGNATURES)) {
+    scores[type] = 0;
+    matches[type] = [];
+
+    for (const keyword of keywords) {
+      if (combined.includes(keyword.toLowerCase())) {
+        scores[type]++;
+        matches[type].push(keyword);
+      }
+    }
+  }
+
+  // Find the best match
+  let bestType = null;
+  let bestScore = 0;
+
+  for (const [type, score] of Object.entries(scores)) {
+    if (score > bestScore) {
+      bestScore = score;
+      bestType = type;
+    }
+  }
+
+  // Calculate confidence (0-1)
+  const confidence = bestScore > 0 ? Math.min(bestScore / 3, 1) : 0; // 3+ matches = high confidence
+
+  return {
+    type: bestType,
+    confidence,
+    matchedKeywords: bestType ? matches[bestType] : [],
+    allScores: scores
+  };
+}
+
+/**
+ * Trigger adaptive remediation for a workflow phase failure
+ * Automatically detects failure type and starts appropriate remediation
+ * @param {string} errorMessage - Error message
+ * @param {object} details - Failure details
+ * @param {object} options - Options { autoStart: boolean, notifyAgents: boolean }
+ * @returns {object} - Remediation plan and status
+ */
+function triggerAdaptiveRemediation(errorMessage, details = {}, options = {}) {
+  const state = loadState();
+
+  if (!state.activeWorkflow) {
+    return { success: false, error: 'No active workflow' };
+  }
+
+  // Detect failure type
+  const detection = detectFailureType(errorMessage, details);
+
+  if (!detection.type || detection.confidence < 0.3) {
+    return {
+      success: false,
+      error: 'Could not determine failure type with sufficient confidence',
+      detection,
+      suggestion: 'Use reportPhaseFailure() with an explicit failure type'
+    };
+  }
+
+  const failureType = detection.type;
+  const remediationKey = failureType + '-failure';
+  const remediation = REMEDIATION_PATHS[remediationKey];
+
+  if (!remediation) {
+    return {
+      success: false,
+      error: 'No remediation path for detected failure type: ' + failureType,
+      detection
+    };
+  }
+
+  // Check if auto-trigger is enabled for this failure type
+  if (!remediation.autoTrigger && !options.forceStart) {
+    return {
+      success: true,
+      autoTriggered: false,
+      detection,
+      remediation: {
+        description: remediation.description,
+        severity: remediation.severity,
+        steps: remediation.steps.length,
+        preventiveActions: remediation.preventiveActions
+      },
+      message: 'Remediation available but auto-trigger disabled for ' + failureType + '. Use forceStart: true to override.'
+    };
+  }
+
+  // Report the failure
+  const failureReport = reportPhaseFailure(failureType, {
+    ...details,
+    errorMessage,
+    detectedKeywords: detection.matchedKeywords,
+    confidence: detection.confidence
+  });
+
+  // Track this failure pattern
+  trackFailurePattern(failureType, state.activeWorkflow, details);
+
+  // Auto-start remediation if requested
+  let remediationResult = null;
+  if (options.autoStart !== false) {
+    remediationResult = startRemediation(failureReport.failureId);
+  }
+
+  return {
+    success: true,
+    autoTriggered: true,
+    detection,
+    failure: failureReport,
+    remediation: remediationResult,
+    preventiveActions: remediation.preventiveActions,
+    fallbackPhase: remediation.fallbackPhase,
+    message: 'Adaptive remediation ' + (options.autoStart !== false ? 'started' : 'prepared') + ' for ' + failureType + ' failure'
+  };
+}
+
+/**
+ * Track failure patterns for learning
+ * Stores failure history for preventive suggestions
+ * @param {string} failureType - Type of failure
+ * @param {string} workflow - Workflow name
+ * @param {object} details - Failure details
+ */
+function trackFailurePattern(failureType, workflow, details = {}) {
+  const state = loadState();
+
+  // Initialize failure patterns tracking
+  state.failurePatterns = state.failurePatterns || {
+    byType: {},
+    byWorkflow: {},
+    byPhase: {},
+    timeline: []
+  };
+
+  const timestamp = new Date().toISOString();
+  const workflowObj = WORKFLOWS[workflow];
+  const currentPhase = workflowObj && workflowObj.phases[state.workflowStep] ?
+    workflowObj.phases[state.workflowStep].name : 'unknown';
+
+  // Track by type
+  state.failurePatterns.byType[failureType] = state.failurePatterns.byType[failureType] || {
+    count: 0,
+    lastOccurrence: null,
+    workflows: []
+  };
+  state.failurePatterns.byType[failureType].count++;
+  state.failurePatterns.byType[failureType].lastOccurrence = timestamp;
+  if (!state.failurePatterns.byType[failureType].workflows.includes(workflow)) {
+    state.failurePatterns.byType[failureType].workflows.push(workflow);
+  }
+
+  // Track by workflow
+  state.failurePatterns.byWorkflow[workflow] = state.failurePatterns.byWorkflow[workflow] || {
+    count: 0,
+    failureTypes: {},
+    phases: {}
+  };
+  state.failurePatterns.byWorkflow[workflow].count++;
+  state.failurePatterns.byWorkflow[workflow].failureTypes[failureType] =
+    (state.failurePatterns.byWorkflow[workflow].failureTypes[failureType] || 0) + 1;
+  state.failurePatterns.byWorkflow[workflow].phases[currentPhase] =
+    (state.failurePatterns.byWorkflow[workflow].phases[currentPhase] || 0) + 1;
+
+  // Track by phase
+  state.failurePatterns.byPhase[currentPhase] = state.failurePatterns.byPhase[currentPhase] || {
+    count: 0,
+    failureTypes: {}
+  };
+  state.failurePatterns.byPhase[currentPhase].count++;
+  state.failurePatterns.byPhase[currentPhase].failureTypes[failureType] =
+    (state.failurePatterns.byPhase[currentPhase].failureTypes[failureType] || 0) + 1;
+
+  // Add to timeline (keep last 100 entries)
+  state.failurePatterns.timeline.push({
+    type: failureType,
+    workflow,
+    phase: currentPhase,
+    timestamp,
+    details: {
+      errorSummary: details.errorMessage ? details.errorMessage.substring(0, 200) : null
+    }
+  });
+  if (state.failurePatterns.timeline.length > 100) {
+    state.failurePatterns.timeline = state.failurePatterns.timeline.slice(-100);
+  }
+
+  saveState(state);
+}
+
+/**
+ * Get preventive actions based on failure history
+ * Analyzes patterns and suggests actions to prevent future failures
+ * @param {string} workflow - Optional workflow name to focus on
+ * @param {string} phase - Optional phase name to focus on
+ * @returns {object} - Preventive action suggestions
+ */
+function getPreventiveActions(workflow, phase) {
+  workflow = workflow || null;
+  phase = phase || null;
+
+  const state = loadState();
+  const patterns = state.failurePatterns || { byType: {}, byWorkflow: {}, byPhase: {} };
+
+  const suggestions = {
+    high: [],
+    medium: [],
+    low: [],
+    patterns: []
+  };
+
+  // Analyze by failure type
+  const sortedTypes = Object.entries(patterns.byType)
+    .sort(function(a, b) { return b[1].count - a[1].count; });
+
+  for (let i = 0; i < sortedTypes.length; i++) {
+    const type = sortedTypes[i][0];
+    const data = sortedTypes[i][1];
+    const remediationKey = type + '-failure';
+    const remediation = REMEDIATION_PATHS[remediationKey];
+
+    if (remediation && data.count >= 2) {
+      const severity = remediation.severity || 'medium';
+      const priority = data.count >= 5 ? 'high' : data.count >= 3 ? 'medium' : 'low';
+
+      suggestions.patterns.push({
+        type: type,
+        occurrences: data.count,
+        severity: severity,
+        lastSeen: data.lastOccurrence
+      });
+
+      if (remediation.preventiveActions) {
+        for (let j = 0; j < remediation.preventiveActions.length; j++) {
+          const action = remediation.preventiveActions[j];
+          if (suggestions[priority].indexOf(action) === -1) {
+            suggestions[priority].push(action);
+          }
+        }
+      }
+    }
+  }
+
+  // Add workflow-specific suggestions
+  if (workflow && patterns.byWorkflow[workflow]) {
+    const wfPatterns = patterns.byWorkflow[workflow];
+    const dominantType = Object.entries(wfPatterns.failureTypes)
+      .sort(function(a, b) { return b[1] - a[1]; })[0];
+
+    if (dominantType) {
+      suggestions.workflowSpecific = {
+        workflow: workflow,
+        dominantFailureType: dominantType[0],
+        occurrences: dominantType[1],
+        suggestion: 'This workflow frequently fails due to ' + dominantType[0] + ' issues. Consider adding extra validation steps.'
+      };
+    }
+  }
+
+  // Add phase-specific suggestions
+  if (phase && patterns.byPhase[phase]) {
+    const phasePatterns = patterns.byPhase[phase];
+    if (phasePatterns.count >= 3) {
+      suggestions.phaseSpecific = {
+        phase: phase,
+        totalFailures: phasePatterns.count,
+        suggestion: 'Phase "' + phase + '" has ' + phasePatterns.count + ' recorded failures. Consider extending duration or adding checkpoints.'
+      };
+    }
+  }
+
+  return suggestions;
+}
+
+/**
+ * Get failure pattern analytics
+ * Returns detailed analysis of failure history
+ * @returns {object} - Failure pattern analysis
+ */
+function getFailureAnalytics() {
+  const state = loadState();
+  const patterns = state.failurePatterns || { byType: {}, byWorkflow: {}, byPhase: {}, timeline: [] };
+
+  // Calculate totals
+  let totalFailures = 0;
+  const typeValues = Object.values(patterns.byType);
+  for (let i = 0; i < typeValues.length; i++) {
+    totalFailures += typeValues[i].count;
+  }
+
+  // Find most common failure types
+  const topFailureTypes = Object.entries(patterns.byType)
+    .map(function(entry) {
+      const type = entry[0];
+      const data = entry[1];
+      const remKey = type + '-failure';
+      return {
+        type: type,
+        count: data.count,
+        percentage: totalFailures > 0 ? Math.round((data.count / totalFailures) * 100) : 0,
+        lastOccurrence: data.lastOccurrence,
+        severity: REMEDIATION_PATHS[remKey] ? REMEDIATION_PATHS[remKey].severity : 'unknown'
+      };
+    })
+    .sort(function(a, b) { return b.count - a.count; });
+
+  // Find most problematic workflows
+  const problematicWorkflows = Object.entries(patterns.byWorkflow)
+    .map(function(entry) {
+      const workflow = entry[0];
+      const data = entry[1];
+      const dominant = Object.entries(data.failureTypes)
+        .sort(function(a, b) { return b[1] - a[1]; })[0];
+      return {
+        workflow: workflow,
+        failureCount: data.count,
+        dominantIssue: dominant ? dominant[0] : 'unknown',
+        affectedPhases: Object.keys(data.phases)
+      };
+    })
+    .sort(function(a, b) { return b.failureCount - a.failureCount; });
+
+  // Find most problematic phases
+  const problematicPhases = Object.entries(patterns.byPhase)
+    .map(function(entry) {
+      const phase = entry[0];
+      const data = entry[1];
+      return {
+        phase: phase,
+        failureCount: data.count,
+        failureTypes: Object.keys(data.failureTypes)
+      };
+    })
+    .sort(function(a, b) { return b.failureCount - a.failureCount; });
+
+  // Recent trend (last 7 days)
+  const oneWeekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+  const recentFailures = patterns.timeline.filter(function(f) { return f.timestamp >= oneWeekAgo; });
+
+  const recentByType = {};
+  for (let j = 0; j < recentFailures.length; j++) {
+    const f = recentFailures[j];
+    recentByType[f.type] = (recentByType[f.type] || 0) + 1;
+  }
+
+  return {
+    summary: {
+      totalFailures: totalFailures,
+      failureTypes: Object.keys(patterns.byType).length,
+      affectedWorkflows: Object.keys(patterns.byWorkflow).length,
+      affectedPhases: Object.keys(patterns.byPhase).length
+    },
+    topFailureTypes: topFailureTypes.slice(0, 5),
+    problematicWorkflows: problematicWorkflows.slice(0, 5),
+    problematicPhases: problematicPhases.slice(0, 5),
+    recentTrend: {
+      period: '7 days',
+      failures: recentFailures.length,
+      byType: recentByType
+    },
+    timeline: patterns.timeline.slice(-10) // Last 10 failures
+  };
+}
+
+/**
+ * Apply fallback phase for a failed workflow phase
+ * Inserts a fallback phase from the remediation path
+ * @param {string} failureId - The failure ID
+ * @returns {object} - Result of applying fallback
+ */
+function applyFallbackPhase(failureId) {
+  const state = loadState();
+
+  const failure = state.workflowFailures ? state.workflowFailures.find(function(f) { return f.id === failureId; }) : null;
+  if (!failure) {
+    return { success: false, error: 'Failure not found' };
+  }
+
+  const remediationKey = failure.type + '-failure';
+  const remediation = REMEDIATION_PATHS[remediationKey];
+
+  if (!remediation || !remediation.fallbackPhase) {
+    return { success: false, error: 'No fallback phase defined for this failure type' };
+  }
+
+  const workflow = WORKFLOWS[failure.workflow];
+  if (!workflow) {
+    return { success: false, error: 'Workflow not found' };
+  }
+
+  // Insert fallback phase after current phase
+  const fallbackPhase = {
+    name: remediation.fallbackPhase.name,
+    agents: remediation.fallbackPhase.agents,
+    duration: remediation.fallbackPhase.duration,
+    isFallback: true,
+    triggeredByFailure: failureId
+  };
+
+  // Track fallback phase insertion
+  state.fallbackPhases = state.fallbackPhases || [];
+  state.fallbackPhases.push({
+    workflow: failure.workflow,
+    originalPhase: failure.phase,
+    fallbackPhase: fallbackPhase.name,
+    insertedAt: new Date().toISOString(),
+    failureId: failureId
+  });
+
+  state.history.push({
+    action: 'fallback_phase_applied',
+    workflow: failure.workflow,
+    originalPhase: failure.phase,
+    fallbackPhase: fallbackPhase.name,
+    timestamp: new Date().toISOString()
+  });
+
+  saveState(state);
+
+  emitWorkflowTelemetry('fallback_phase_applied', {
+    workflow: failure.workflow,
+    originalPhase: failure.phase,
+    fallbackPhase: fallbackPhase.name,
+    failureType: failure.type
+  });
+
+  return {
+    success: true,
+    workflow: failure.workflow,
+    originalPhase: failure.phase,
+    fallbackPhase: fallbackPhase,
+    message: 'Fallback phase "' + fallbackPhase.name + '" applied after "' + failure.phase + '"'
+  };
+}
+
+/**
+ * Check if remediation retries are exhausted
+ * @param {string} failureId - The failure ID
+ * @returns {object} - Retry status
+ */
+function checkRemediationRetries(failureId) {
+  const state = loadState();
+
+  const failure = state.workflowFailures ? state.workflowFailures.find(function(f) { return f.id === failureId; }) : null;
+  if (!failure) {
+    return { success: false, error: 'Failure not found' };
+  }
+
+  const remediationKey = failure.type + '-failure';
+  const remediation = REMEDIATION_PATHS[remediationKey];
+  const maxRetries = remediation ? (remediation.maxRetries || 2) : 2;
+
+  // Count retry attempts
+  const retryAttempts = (state.remediationAttempts && state.remediationAttempts[failureId]) || 0;
+  const retriesRemaining = maxRetries - retryAttempts;
+  const exhausted = retriesRemaining <= 0;
+
+  return {
+    success: true,
+    failureId: failureId,
+    failureType: failure.type,
+    maxRetries: maxRetries,
+    attempts: retryAttempts,
+    retriesRemaining: retriesRemaining,
+    exhausted: exhausted,
+    recommendation: exhausted
+      ? 'Consider applying fallback phase or escalating'
+      : retriesRemaining + ' retry attempt(s) remaining'
+  };
+}
+
+/**
+ * Record a remediation attempt
+ * @param {string} failureId - The failure ID
+ * @param {object} result - Result of the attempt { success, details }
+ */
+function recordRemediationAttempt(failureId, result) {
+  result = result || {};
+  const state = loadState();
+
+  state.remediationAttempts = state.remediationAttempts || {};
+  state.remediationAttempts[failureId] = (state.remediationAttempts[failureId] || 0) + 1;
+
+  state.remediationHistory = state.remediationHistory || [];
+  state.remediationHistory.push({
+    failureId: failureId,
+    attemptNumber: state.remediationAttempts[failureId],
+    success: result.success || false,
+    details: result.details,
+    timestamp: new Date().toISOString()
+  });
+
+  // Keep history manageable
+  if (state.remediationHistory.length > 200) {
+    state.remediationHistory = state.remediationHistory.slice(-200);
+  }
+
+  saveState(state);
+
+  return {
+    success: true,
+    failureId: failureId,
+    attemptNumber: state.remediationAttempts[failureId],
+    retryStatus: checkRemediationRetries(failureId)
+  };
+}
+
+/**
+ * Get adaptive workflow recommendations
+ * Based on failure patterns and current context
+ * @param {string} workflow - Optional specific workflow
+ * @returns {object} - Adaptive recommendations
+ */
+function getAdaptiveRecommendations(workflow) {
+  workflow = workflow || null;
+  const preventive = getPreventiveActions(workflow);
+  const analytics = getFailureAnalytics();
+
+  const recommendations = {
+    immediate: [],
+    shortTerm: [],
+    longTerm: []
+  };
+
+  // Immediate: Based on recent failures
+  if (analytics.recentTrend.failures > 5) {
+    recommendations.immediate.push({
+      priority: 'high',
+      action: 'Review recent failure patterns',
+      reason: analytics.recentTrend.failures + ' failures in the last 7 days',
+      details: analytics.recentTrend.byType
+    });
+  }
+
+  // Immediate: Critical severity failures
+  const criticalTypes = analytics.topFailureTypes.filter(function(t) { return t.severity === 'critical'; });
+  for (let i = 0; i < criticalTypes.length; i++) {
+    const critical = criticalTypes[i];
+    const remKey = critical.type + '-failure';
+    recommendations.immediate.push({
+      priority: 'critical',
+      action: 'Address ' + critical.type + ' failures',
+      reason: critical.count + ' critical failures recorded',
+      preventiveActions: REMEDIATION_PATHS[remKey] ? REMEDIATION_PATHS[remKey].preventiveActions : []
+    });
+  }
+
+  // Short-term: Frequent failure types
+  const topTypes = analytics.topFailureTypes.slice(0, 3);
+  for (let j = 0; j < topTypes.length; j++) {
+    const failureType = topTypes[j];
+    if (failureType.count >= 3) {
+      recommendations.shortTerm.push({
+        priority: failureType.severity === 'high' ? 'high' : 'medium',
+        action: 'Reduce ' + failureType.type + ' failures',
+        reason: failureType.percentage + '% of all failures',
+        preventiveActions: preventive.high.concat(preventive.medium).slice(0, 3)
+      });
+    }
+  }
+
+  // Long-term: Problematic phases
+  const topPhases = analytics.problematicPhases.slice(0, 2);
+  for (let k = 0; k < topPhases.length; k++) {
+    const phase = topPhases[k];
+    if (phase.failureCount >= 5) {
+      recommendations.longTerm.push({
+        priority: 'medium',
+        action: 'Review and strengthen "' + phase.phase + '" phase',
+        reason: phase.failureCount + ' total failures in this phase',
+        suggestion: 'Consider adding checkpoints, extending duration, or splitting into smaller phases'
+      });
+    }
+  }
+
+  // Add workflow-specific if provided
+  if (workflow) {
+    const wfData = analytics.problematicWorkflows.find(function(w) { return w.workflow === workflow; });
+    if (wfData) {
+      recommendations.workflowSpecific = {
+        workflow: workflow,
+        failureCount: wfData.failureCount,
+        dominantIssue: wfData.dominantIssue,
+        recommendation: 'Focus on ' + wfData.dominantIssue + ' issues which are the main cause of failures in this workflow'
+      };
+    }
+  }
+
+  return recommendations;
+}
+
+/**
+ * Define workflow with fallback phases
+ * Enhanced workflow definition with built-in fallbacks
+ * @param {string} name - Workflow name
+ * @param {object} definition - Workflow definition with fallback phases
+ */
+function defineWorkflowWithFallbacks(name, definition) {
+  if (!definition.name || !definition.phases) {
+    return { success: false, error: 'Invalid workflow definition' };
+  }
+
+  // Validate fallback phases reference valid remediation paths
+  for (let i = 0; i < definition.phases.length; i++) {
+    const phase = definition.phases[i];
+    if (phase.fallbackOnFailure) {
+      const remediationKey = phase.fallbackOnFailure + '-failure';
+      if (!REMEDIATION_PATHS[remediationKey]) {
+        return {
+          success: false,
+          error: 'Invalid fallback type "' + phase.fallbackOnFailure + '" for phase "' + phase.name + '"'
+        };
+      }
+    }
+  }
+
+  WORKFLOWS[name] = {
+    name: definition.name,
+    description: definition.description,
+    phases: definition.phases,
+    outcomes: definition.outcomes,
+    completionSignals: definition.completionSignals,
+    tier: definition.tier || 'free',
+    pack: definition.pack || null,
+    hasAdaptiveFallbacks: true
+  };
+
+  const phasesWithFallbacks = definition.phases.filter(function(p) { return p.fallbackOnFailure; }).length;
+
+  return {
+    success: true,
+    workflow: name,
+    phases: definition.phases.length,
+    phasesWithFallbacks: phasesWithFallbacks
+  };
+}
+
+/**
+ * Clear failure patterns (for testing or reset)
+ * @param {object} options - { keepRecent: number } Keep last N entries
+ */
+function clearFailurePatterns(options) {
+  options = options || {};
+  const state = loadState();
+
+  if (options.keepRecent) {
+    // Keep recent entries
+    state.failurePatterns = state.failurePatterns || { timeline: [] };
+    state.failurePatterns.timeline = state.failurePatterns.timeline.slice(-options.keepRecent);
+    // Rebuild stats from kept timeline
+    state.failurePatterns.byType = {};
+    state.failurePatterns.byWorkflow = {};
+    state.failurePatterns.byPhase = {};
+  } else {
+    // Clear everything
+    state.failurePatterns = {
+      byType: {},
+      byWorkflow: {},
+      byPhase: {},
+      timeline: []
+    };
+  }
+
+  state.history.push({
+    action: 'failure_patterns_cleared',
+    keepRecent: options.keepRecent || 0,
+    timestamp: new Date().toISOString()
+  });
+
+  saveState(state);
+
+  return { success: true, message: 'Failure patterns cleared' };
+}
+
 module.exports = {
   analyzeContext,
   getWorkflow,
   listWorkflows,
   startWorkflow,
   advanceWorkflow,
+  // Pause/Resume functionality
+  pauseWorkflow,
+  resumeWorkflow,
+  isWorkflowPaused,
+  getPauseState,
+  // Failure handling
+  reportPhaseFailure,
+  startRemediation,
+  advanceRemediation,
+  getWorkflowFailures,
   markWorkflowCheckpoint,
   getWorkflowSignalProgress,
   loadState,
@@ -958,7 +3813,47 @@ module.exports = {
   getCurrentPhase,
   agentExists,
   getAvailableAgents,
+  // PRD-Workflow Integration
+  linkPrdToWorkflow,
+  onPrdStoryComplete,
+  getPrdWorkflowStatus,
+  getPhaseStories,
+  reassignStoryToPhase,
+  unlinkPrdFromWorkflow,
+  getLinkedPrds,
+  analyzeStoryForPhase,
+  // Parallel execution
+  startParallelPhases,
+  completeParallelPhase,
+  getParallelExecutionStatus,
+  cancelParallelExecution,
+  isParallelPhase,
+  defineWorkflowWithParallel,
+  failParallelPhase,
+  retryParallelPhase,
+  updateParallelPhaseProgress,
+  skipFailedParallelPhases,
+  retryAllFailedPhases,
+  // Adaptive Workflows
+  detectFailureType,
+  triggerAdaptiveRemediation,
+  trackFailurePattern,
+  getPreventiveActions,
+  getFailureAnalytics,
+  applyFallbackPhase,
+  checkRemediationRetries,
+  recordRemediationAttempt,
+  getAdaptiveRecommendations,
+  defineWorkflowWithFallbacks,
+  clearFailurePatterns,
+  // Utilities
+  formatDuration,
+  // Constants
   PHASE_AGENTS,
   TECHNICAL_TRIGGERS,
-  WORKFLOWS
+  WORKFLOWS,
+  REMEDIATION_PATHS,
+  FAILURE_SIGNATURES,
+  SEVERITY_WEIGHTS,
+  PARALLEL_FAILURE_STRATEGIES
 };