@polymorphism-tech/morph-spec 2.2.0 → 2.4.0

package/src/lib/complexity-analyzer.js

@@ -1,292 +1,441 @@
-/**
- * MORPH-SPEC Complexity Analyzer Library
- *
- * Analyzes user requests and classifies them into workflows:
- * - fast-track: Trivial changes (bug fixes, small adjustments)
- * - standard: Medium features (simple additions, improvements)
- * - full-morph: Complex features (new subsystems, architecture)
- *
- * Used both by CLI commands and internal automation.
- */
-
-// ============================================================================
-// COMPLEXITY THRESHOLDS
-// ============================================================================
-
-export const COMPLEXITY_THRESHOLDS = {
-  'fast-track': {
-    maxFiles: 3,
-    maxLines: 50,
-    maxComponents: 0,
-    requiresInfrastructure: false,
-    requiresArchitecturalDecisions: false,
-    description: 'Bug fixes, small adjustments, edge cases, hotfixes'
-  },
-  'standard': {
-    maxFiles: 10,
-    maxLines: 500,
-    maxComponents: 2,
-    requiresInfrastructure: false,
-    requiresArchitecturalDecisions: false, // Only tactical decisions
-    description: 'Simple features, refactorings, incremental improvements'
-  },
-  'full-morph': {
-    maxFiles: Infinity,
-    maxLines: Infinity,
-    maxComponents: Infinity,
-    requiresInfrastructure: true, // Can have infrastructure
-    requiresArchitecturalDecisions: true, // Strategic decisions
-    description: 'Complex features, new subsystems, architectural changes'
-  }
-};
-
-// ============================================================================
-// KEYWORD DETECTION
-// ============================================================================
-
-/**
- * Keywords that indicate different complexity levels
- */
-const COMPLEXITY_KEYWORDS = {
-  trivial: [
-    'bug', 'fix', 'corrigir', 'ajustar', 'typo', 'correção',
-    'edge case', 'hotfix', 'urgente', 'rápido', 'quick',
-    'cor', 'color', 'texto', 'text', 'label', 'validação',
-    'mensagem', 'message', 'css', 'style', 'espaçamento'
-  ],
-
-  infrastructure: [
-    'azure', 'bicep', 'deploy', 'infra', 'infrastructure',
-    'container', 'kubernetes', 'k8s', 'database', 'sql',
-    'storage', 'queue', 'service bus', 'redis', 'cosmos'
-  ],
-
-  architectural: [
-    'sistema', 'system', 'arquitetura', 'architecture',
-    'pattern', 'cqrs', 'event sourcing', 'microservice',
-    'subsistema', 'subsystem', 'integração', 'integration',
-    'autenticação', 'authentication', 'autorização', 'authorization'
-  ],
-
-  newComponents: [
-    'novo', 'new', 'criar', 'create', 'adicionar', 'add',
-    'implementar', 'implement', 'desenvolver', 'develop',
-    'componente', 'component', 'serviço', 'service',
-    'tela', 'screen', 'página', 'page', 'formulário', 'form'
-  ]
-};
-
-// ============================================================================
-// ANALYSIS FUNCTIONS
-// ============================================================================
-
-/**
- * Detect keywords in user input
- * @param {string} userInput - User request
- * @param {Array<string>} keywords - Keywords to search for
- * @returns {number} Count of keyword matches
- */
-function detectKeywords(userInput, keywords) {
-  const lowerInput = userInput.toLowerCase();
-  return keywords.filter(keyword => lowerInput.includes(keyword)).length;
-}
-
-/**
- * Estimate code impact from user input
- * @param {string} userInput - User request
- * @returns {Object} Estimated impact
- */
-export function estimateCodeImpact(userInput) {
-  const lowerInput = userInput.toLowerCase();
-
-  // Trivial indicators
-  const trivialCount = detectKeywords(lowerInput, COMPLEXITY_KEYWORDS.trivial);
-  if (trivialCount > 0) {
-    return {
-      estimatedFiles: 1,
-      estimatedLines: 10,
-      estimatedComponents: 0,
-      confidence: 'high'
-    };
-  }
-
-  // Count indicators of new components
-  const newComponentCount = detectKeywords(lowerInput, COMPLEXITY_KEYWORDS.newComponents);
-
-  // Multiple components/features mentioned (separated by "e", "and", or commas)
-  const separators = [' e ', ' and ', ','];
-  const hasSeparator = separators.some(sep => lowerInput.includes(sep));
-
-  if (hasSeparator) {
-    // Split by any separator
-    let parts = [lowerInput];
-    for (const sep of separators) {
-      parts = parts.flatMap(part => part.split(sep));
-    }
-    parts = parts.filter(p => p.trim().length > 0);
-
-    // If we found multiple parts, estimate high complexity
-    if (parts.length > 1) {
-      return {
-        estimatedFiles: Math.min(parts.length * 3, 15),
-        estimatedLines: Math.min(parts.length * 200, 1000),
-        estimatedComponents: Math.min(parts.length, 5),
-        confidence: 'medium'
-      };
-    }
-  }
-
-  // New component indicators
-  if (newComponentCount > 0) {
-    return {
-      estimatedFiles: 5,
-      estimatedLines: 200,
-      estimatedComponents: 1,
-      confidence: 'medium'
-    };
-  }
-
-  // Default to standard complexity
-  return {
-    estimatedFiles: 5,
-    estimatedLines: 150,
-    estimatedComponents: 1,
-    confidence: 'low'
-  };
-}
-
-/**
- * Detect if request involves infrastructure
- * @param {string} userInput - User request
- * @returns {boolean} True if infrastructure is involved
- */
-export function detectInfrastructure(userInput) {
-  const infraCount = detectKeywords(userInput, COMPLEXITY_KEYWORDS.infrastructure);
-  return infraCount > 0;
-}
-
-/**
- * Detect if request involves architectural decisions
- * @param {string} userInput - User request
- * @returns {boolean} True if architectural decisions are involved
- */
-export function detectArchitecturalDecisions(userInput) {
-  const archCount = detectKeywords(userInput, COMPLEXITY_KEYWORDS.architectural);
-  return archCount > 0;
-}
-
-/**
- * Classify workflow based on analysis
- * @param {Object} impact - Code impact estimation
- * @param {boolean} hasInfrastructure - Has infrastructure
- * @param {boolean} hasArchitecturalDecisions - Has architectural decisions
- * @returns {string} Workflow type: "fast-track" | "standard" | "full-morph"
- */
-export function classifyWorkflow(impact, hasInfrastructure, hasArchitecturalDecisions) {
-  const { estimatedFiles, estimatedLines, estimatedComponents } = impact;
-
-  // Full MORPH: Infrastructure or architectural decisions
-  if (hasInfrastructure || hasArchitecturalDecisions) {
-    return 'full-morph';
-  }
-
-  // Full MORPH: Large code impact
-  if (estimatedFiles > COMPLEXITY_THRESHOLDS.standard.maxFiles ||
-      estimatedLines > COMPLEXITY_THRESHOLDS.standard.maxLines ||
-      estimatedComponents > COMPLEXITY_THRESHOLDS.standard.maxComponents) {
-    return 'full-morph';
-  }
-
-  // Fast Track: Trivial changes
-  if (estimatedFiles <= COMPLEXITY_THRESHOLDS['fast-track'].maxFiles &&
-      estimatedLines <= COMPLEXITY_THRESHOLDS['fast-track'].maxLines &&
-      estimatedComponents <= COMPLEXITY_THRESHOLDS['fast-track'].maxComponents) {
-    return 'fast-track';
-  }
-
-  // Default: Standard workflow
-  return 'standard';
-}
-
-/**
- * Analyze request complexity - Main entry point
- * @param {string} userInput - User request
- * @param {Object} options - Options
- * @param {string} options.forceWorkflow - Force specific workflow
- * @returns {Object} Complete analysis
- */
-export function analyzeRequestComplexity(userInput, options = {}) {
-  // Check for forced workflow
-  if (options.forceWorkflow) {
-    return {
-      workflow: options.forceWorkflow,
-      forced: true,
-      reason: 'Manually overridden by user'
-    };
-  }
-
-  // Analyze request
-  const impact = estimateCodeImpact(userInput);
-  const hasInfrastructure = detectInfrastructure(userInput);
-  const hasArchitecturalDecisions = detectArchitecturalDecisions(userInput);
-
-  const workflow = classifyWorkflow(impact, hasInfrastructure, hasArchitecturalDecisions);
-
-  // Build reason
-  let reason = `Estimated ${impact.estimatedFiles} files, ${impact.estimatedLines} lines, ${impact.estimatedComponents} components`;
-  if (hasInfrastructure) reason += ', requires infrastructure';
-  if (hasArchitecturalDecisions) reason += ', requires architectural decisions';
-
-  return {
-    workflow,
-    forced: false,
-    impact,
-    hasInfrastructure,
-    hasArchitecturalDecisions,
-    confidence: impact.confidence,
-    reason,
-    thresholds: COMPLEXITY_THRESHOLDS[workflow]
-  };
-}
-
-/**
- * Get workflow phases
- * @param {string} workflow - Workflow type
- * @returns {Array<string>} List of phases to execute
- */
-export function getWorkflowPhases(workflow) {
-  switch (workflow) {
-    case 'fast-track':
-      return ['quick-analysis', 'implement'];
-
-    case 'standard':
-      return ['proposal', 'design', 'tasks', 'implement'];
-
-    case 'full-morph':
-      return ['context', 'proposal', 'setup', 'uiux', 'design', 'clarify', 'tasks', 'implement', 'sync'];
-
-    default:
-      return ['context', 'proposal', 'setup', 'uiux', 'design', 'clarify', 'tasks', 'implement', 'sync'];
-  }
-}
-
-/**
- * Get workflow description
- * @param {string} workflow - Workflow type
- * @returns {string} Human-readable description
- */
-export function getWorkflowDescription(workflow) {
-  switch (workflow) {
-    case 'fast-track':
-      return 'Fast Track: Quick fixes without formal spec (1 pause, no outputs)';
-
-    case 'standard':
-      return 'Standard: Medium complexity with simplified workflow (2-3 pauses, minimal outputs)';
-
-    case 'full-morph':
-      return 'Full MORPH: Complete 8-phase workflow with all outputs';
-
-    default:
-      return 'Unknown workflow';
-  }
-}
+/**
+ * MORPH-SPEC Complexity Analyzer Library
+ *
+ * Analyzes user requests and classifies them into workflows:
+ * - fast-track: Trivial changes (bug fixes, small adjustments)
+ * - standard: Medium features (simple additions, improvements)
+ * - full-morph: Complex features (new subsystems, architecture)
+ *
+ * Used both by CLI commands and internal automation.
+ */
+
+// ============================================================================
+// COMPLEXITY THRESHOLDS
+// ============================================================================
+
+export const COMPLEXITY_THRESHOLDS = {
+  'fast-track': {
+    maxFiles: 3,
+    maxLines: 50,
+    maxComponents: 0,
+    requiresInfrastructure: false,
+    requiresArchitecturalDecisions: false,
+    description: 'Bug fixes, small adjustments, edge cases, hotfixes'
+  },
+  'standard': {
+    maxFiles: 10,
+    maxLines: 500,
+    maxComponents: 2,
+    requiresInfrastructure: false,
+    requiresArchitecturalDecisions: false, // Only tactical decisions
+    description: 'Simple features, refactorings, incremental improvements'
+  },
+  'full-morph': {
+    maxFiles: Infinity,
+    maxLines: Infinity,
+    maxComponents: Infinity,
+    requiresInfrastructure: true, // Can have infrastructure
+    requiresArchitecturalDecisions: true, // Strategic decisions
+    description: 'Complex features, new subsystems, architectural changes'
+  }
+};
+
+// ============================================================================
+// KEYWORD DETECTION
+// ============================================================================
+
+/**
+ * Keywords that indicate different complexity levels
+ */
+const COMPLEXITY_KEYWORDS = {
+  trivial: [
+    'bug', 'fix', 'corrigir', 'ajustar', 'typo', 'correção',
+    'edge case', 'hotfix', 'urgente', 'rápido', 'quick',
+    'cor', 'color', 'texto', 'text', 'label', 'validação',
+    'mensagem', 'message', 'css', 'style', 'espaçamento'
+  ],
+
+  infrastructure: [
+    'azure', 'bicep', 'deploy', 'infra', 'infrastructure',
+    'container', 'kubernetes', 'k8s', 'database', 'sql',
+    'storage', 'queue', 'service bus', 'redis', 'cosmos'
+  ],
+
+  architectural: [
+    'sistema', 'system', 'arquitetura', 'architecture',
+    'pattern', 'cqrs', 'event sourcing', 'microservice',
+    'subsistema', 'subsystem', 'integração', 'integration',
+    'autenticação', 'authentication', 'autorização', 'authorization'
+  ],
+
+  newComponents: [
+    'novo', 'new', 'criar', 'create', 'adicionar', 'add',
+    'implementar', 'implement', 'desenvolver', 'develop',
+    'componente', 'component', 'serviço', 'service',
+    'tela', 'screen', 'página', 'page', 'formulário', 'form'
+  ],
+
+  // UI Refresh workflow - visual only changes
+  uiRefresh: [
+    'redesign', 'redesenhar', 'bonito', 'bonitas', 'visual',
+    'estetica', 'aesthetics', 'modernizar', 'modernize',
+    'melhorar visual', 'mais bonito', 'prettier', 'beautiful',
+    'refresh', 'design system'
+  ],
+
+  // Design Implementation workflow - prototype to code
+  designImplementation: [
+    'prototipo', 'prototype', 'figma', 'html para',
+    'converter design', 'replicar', 'from design',
+    'based on mockup', 'mockup', 'wireframe', 'implementar tela'
+  ]
+};
+
+/**
+ * Hidden complexity indicators for Blazor Server
+ * These keyword combinations indicate complexity that isn't obvious at first glance.
+ * When detected together, they should force full-morph workflow.
+ *
+ * See: framework/standards/blazor-efcore.md, blazor-state.md
+ */
+const HIDDEN_COMPLEXITY_INDICATORS = {
+  // Session + Blazor = complex circuit/state management
+  session: {
+    primary: ['session', 'sessão', 'estado', 'state'],
+    context: ['blazor', 'persist', 'persistir', 'circuit', 'scoped']
+  },
+  // Background operations = DbContext concurrency issues
+  background: {
+    primary: ['task.run', 'background', 'segundo plano', 'job', 'hangfire'],
+    context: ['concurrent', 'concorrente', 'async', 'parallel', 'paralelo', 'dbcontext', 'ef core']
+  },
+  // Navigation = potential state loss
+  navigation: {
+    primary: ['redirect', 'navigate', 'navegar', 'navegação'],
+    context: ['circuit', 'signalr', 'forceload', 'refresh', 'reload']
+  }
+};
+
+// ============================================================================
+// ANALYSIS FUNCTIONS
+// ============================================================================
+
+/**
+ * Detect keywords in user input
+ * @param {string} userInput - User request
+ * @param {Array<string>} keywords - Keywords to search for
+ * @returns {number} Count of keyword matches
+ */
+function detectKeywords(userInput, keywords) {
+  const lowerInput = userInput.toLowerCase();
+  return keywords.filter(keyword => lowerInput.includes(keyword)).length;
+}
+
+/**
+ * Estimate code impact from user input
+ * @param {string} userInput - User request
+ * @returns {Object} Estimated impact
+ */
+export function estimateCodeImpact(userInput) {
+  const lowerInput = userInput.toLowerCase();
+
+  // Trivial indicators
+  const trivialCount = detectKeywords(lowerInput, COMPLEXITY_KEYWORDS.trivial);
+  if (trivialCount > 0) {
+    return {
+      estimatedFiles: 1,
+      estimatedLines: 10,
+      estimatedComponents: 0,
+      confidence: 'high'
+    };
+  }
+
+  // Count indicators of new components
+  const newComponentCount = detectKeywords(lowerInput, COMPLEXITY_KEYWORDS.newComponents);
+
+  // Multiple components/features mentioned (separated by "e", "and", or commas)
+  const separators = [' e ', ' and ', ','];
+  const hasSeparator = separators.some(sep => lowerInput.includes(sep));
+
+  if (hasSeparator) {
+    // Split by any separator
+    let parts = [lowerInput];
+    for (const sep of separators) {
+      parts = parts.flatMap(part => part.split(sep));
+    }
+    parts = parts.filter(p => p.trim().length > 0);
+
+    // If we found multiple parts, estimate high complexity
+    if (parts.length > 1) {
+      return {
+        estimatedFiles: Math.min(parts.length * 3, 15),
+        estimatedLines: Math.min(parts.length * 200, 1000),
+        estimatedComponents: Math.min(parts.length, 5),
+        confidence: 'medium'
+      };
+    }
+  }
+
+  // New component indicators
+  if (newComponentCount > 0) {
+    return {
+      estimatedFiles: 5,
+      estimatedLines: 200,
+      estimatedComponents: 1,
+      confidence: 'medium'
+    };
+  }
+
+  // Default to standard complexity
+  return {
+    estimatedFiles: 5,
+    estimatedLines: 150,
+    estimatedComponents: 1,
+    confidence: 'low'
+  };
+}
+
+/**
+ * Detect if request involves infrastructure
+ * @param {string} userInput - User request
+ * @returns {boolean} True if infrastructure is involved
+ */
+export function detectInfrastructure(userInput) {
+  const infraCount = detectKeywords(userInput, COMPLEXITY_KEYWORDS.infrastructure);
+  return infraCount > 0;
+}
+
+/**
+ * Detect if request involves architectural decisions
+ * @param {string} userInput - User request
+ * @returns {boolean} True if architectural decisions are involved
+ */
+export function detectArchitecturalDecisions(userInput) {
+  const archCount = detectKeywords(userInput, COMPLEXITY_KEYWORDS.architectural);
+  return archCount > 0;
+}
+
+/**
+ * Detect if request is a UI refresh (visual redesign only)
+ * @param {string} userInput - User request
+ * @returns {boolean} True if UI refresh is detected
+ */
+export function detectUiRefresh(userInput) {
+  const refreshCount = detectKeywords(userInput, COMPLEXITY_KEYWORDS.uiRefresh);
+  // Need at least one refresh keyword AND no infrastructure/architectural keywords
+  const hasInfra = detectKeywords(userInput, COMPLEXITY_KEYWORDS.infrastructure) > 0;
+  const hasArch = detectKeywords(userInput, COMPLEXITY_KEYWORDS.architectural) > 0;
+  return refreshCount > 0 && !hasInfra && !hasArch;
+}
+
+/**
+ * Detect if request is a design implementation (prototype to code)
+ * @param {string} userInput - User request
+ * @returns {boolean} True if design implementation is detected
+ */
+export function detectDesignImplementation(userInput) {
+  const designCount = detectKeywords(userInput, COMPLEXITY_KEYWORDS.designImplementation);
+  return designCount > 0;
+}
+
+/**
+ * Detect hidden complexity in Blazor Server requests
+ * These are keyword combinations that indicate non-obvious complexity.
+ * @param {string} userInput - User request
+ * @returns {Object} Detection result with matched indicators
+ */
+export function detectHiddenComplexity(userInput) {
+  const lowerInput = userInput.toLowerCase();
+  const matchedIndicators = [];
+
+  for (const [indicatorName, indicator] of Object.entries(HIDDEN_COMPLEXITY_INDICATORS)) {
+    const hasPrimary = indicator.primary.some(keyword => lowerInput.includes(keyword));
+    const hasContext = indicator.context.some(keyword => lowerInput.includes(keyword));
+
+    if (hasPrimary && hasContext) {
+      matchedIndicators.push({
+        name: indicatorName,
+        reason: `Detected ${indicatorName} complexity: primary keywords + context keywords found`
+      });
+    }
+  }
+
+  return {
+    hasHiddenComplexity: matchedIndicators.length > 0,
+    indicators: matchedIndicators
+  };
+}
+
+/**
+ * Classify workflow based on analysis
+ * @param {Object} impact - Code impact estimation
+ * @param {boolean} hasInfrastructure - Has infrastructure
+ * @param {boolean} hasArchitecturalDecisions - Has architectural decisions
+ * @returns {string} Workflow type: "fast-track" | "standard" | "full-morph"
+ */
+export function classifyWorkflow(impact, hasInfrastructure, hasArchitecturalDecisions) {
+  const { estimatedFiles, estimatedLines, estimatedComponents } = impact;
+
+  // Full MORPH: Infrastructure or architectural decisions
+  if (hasInfrastructure || hasArchitecturalDecisions) {
+    return 'full-morph';
+  }
+
+  // Full MORPH: Large code impact
+  if (estimatedFiles > COMPLEXITY_THRESHOLDS.standard.maxFiles ||
+      estimatedLines > COMPLEXITY_THRESHOLDS.standard.maxLines ||
+      estimatedComponents > COMPLEXITY_THRESHOLDS.standard.maxComponents) {
+    return 'full-morph';
+  }
+
+  // Fast Track: Trivial changes
+  if (estimatedFiles <= COMPLEXITY_THRESHOLDS['fast-track'].maxFiles &&
+      estimatedLines <= COMPLEXITY_THRESHOLDS['fast-track'].maxLines &&
+      estimatedComponents <= COMPLEXITY_THRESHOLDS['fast-track'].maxComponents) {
+    return 'fast-track';
+  }
+
+  // Default: Standard workflow
+  return 'standard';
+}
+
+/**
+ * Analyze request complexity - Main entry point
+ * @param {string} userInput - User request
+ * @param {Object} options - Options
+ * @param {string} options.forceWorkflow - Force specific workflow
+ * @returns {Object} Complete analysis
+ */
+export function analyzeRequestComplexity(userInput, options = {}) {
+  // Check for forced workflow
+  if (options.forceWorkflow) {
+    return {
+      workflow: options.forceWorkflow,
+      forced: true,
+      reason: 'Manually overridden by user'
+    };
+  }
+
+  // Check for special workflows first (UI Refresh, Design Implementation)
+  const isUiRefresh = detectUiRefresh(userInput);
+  const isDesignImplementation = detectDesignImplementation(userInput);
+
+  if (isUiRefresh) {
+    return {
+      workflow: 'ui-refresh',
+      forced: false,
+      impact: { estimatedFiles: 5, estimatedLines: 200, estimatedComponents: 0 },
+      hasInfrastructure: false,
+      hasArchitecturalDecisions: false,
+      hasHiddenComplexity: false,
+      hiddenComplexityIndicators: [],
+      confidence: 'high',
+      reason: 'UI refresh detected: visual-only changes, no infrastructure or architecture',
+      thresholds: COMPLEXITY_THRESHOLDS.standard // Uses standard thresholds
+    };
+  }
+
+  if (isDesignImplementation) {
+    return {
+      workflow: 'design-implementation',
+      forced: false,
+      impact: { estimatedFiles: 8, estimatedLines: 400, estimatedComponents: 2 },
+      hasInfrastructure: false,
+      hasArchitecturalDecisions: false,
+      hasHiddenComplexity: false,
+      hiddenComplexityIndicators: [],
+      confidence: 'high',
+      reason: 'Design implementation detected: prototype to code conversion',
+      thresholds: COMPLEXITY_THRESHOLDS.standard // Uses standard thresholds
+    };
+  }
+
+  // Analyze request
+  const impact = estimateCodeImpact(userInput);
+  const hasInfrastructure = detectInfrastructure(userInput);
+  const hasArchitecturalDecisions = detectArchitecturalDecisions(userInput);
+  const hiddenComplexity = detectHiddenComplexity(userInput);
+
+  // Hidden complexity forces full-morph (Blazor Server specific concerns)
+  let workflow;
+  if (hiddenComplexity.hasHiddenComplexity) {
+    workflow = 'full-morph';
+  } else {
+    workflow = classifyWorkflow(impact, hasInfrastructure, hasArchitecturalDecisions);
+  }
+
+  // Build reason
+  let reason = `Estimated ${impact.estimatedFiles} files, ${impact.estimatedLines} lines, ${impact.estimatedComponents} components`;
+  if (hasInfrastructure) reason += ', requires infrastructure';
+  if (hasArchitecturalDecisions) reason += ', requires architectural decisions';
+  if (hiddenComplexity.hasHiddenComplexity) {
+    reason += `, hidden complexity detected: ${hiddenComplexity.indicators.map(i => i.name).join(', ')}`;
+  }
+
+  return {
+    workflow,
+    forced: false,
+    impact,
+    hasInfrastructure,
+    hasArchitecturalDecisions,
+    hasHiddenComplexity: hiddenComplexity.hasHiddenComplexity,
+    hiddenComplexityIndicators: hiddenComplexity.indicators,
+    confidence: impact.confidence,
+    reason,
+    thresholds: COMPLEXITY_THRESHOLDS[workflow]
+  };
+}
+
+/**
+ * Get workflow phases
+ * @param {string} workflow - Workflow type
+ * @returns {Array<string>} List of phases to execute
+ */
+export function getWorkflowPhases(workflow) {
+  switch (workflow) {
+    case 'fast-track':
+      return ['quick-analysis', 'implement'];
+
+    case 'standard':
+      return ['proposal', 'design', 'tasks', 'implement'];
+
+    case 'full-morph':
+      return ['context', 'proposal', 'setup', 'uiux', 'design', 'clarify', 'tasks', 'implement', 'sync'];
+
+    case 'ui-refresh':
+      return ['visual-analysis', 'design-system', 'implement'];
+
+    case 'design-implementation':
+      return ['prototype-analysis', 'tasks', 'implement'];
+
+    default:
+      return ['context', 'proposal', 'setup', 'uiux', 'design', 'clarify', 'tasks', 'implement', 'sync'];
+  }
+}
+
+/**
+ * Get workflow description
+ * @param {string} workflow - Workflow type
+ * @returns {string} Human-readable description
+ */
+export function getWorkflowDescription(workflow) {
+  switch (workflow) {
+    case 'fast-track':
+      return 'Fast Track: Quick fixes without formal spec (1 pause, no outputs)';
+
+    case 'standard':
+      return 'Standard: Medium complexity with simplified workflow (2-3 pauses, minimal outputs)';
+
+    case 'full-morph':
+      return 'Full MORPH: Complete 8-phase workflow with all outputs';
+
+    case 'ui-refresh':
+      return 'UI Refresh: Visual redesign only (3 phases: Visual Analysis → Design System → Implement)';
+
+    case 'design-implementation':
+      return 'Design Implementation: Prototype to code conversion (3 phases: Prototype Analysis → Tasks → Implement)';
+
+    default:
+      return 'Unknown workflow';
+  }
+}