@girardmedia/bootspring 2.0.36 → 2.0.37

package/cli/plan.js

@@ -17,6 +17,11 @@ let ContinuousAnalyzer = null;
 let DocumentCoherenceEngine = null;
 let DynamicContextGenerator = null;
 let DecisionIntelligence = null;
+let FeatureDecomposer = null;
+let StagePlanner = null;
+let AdaptivePlanningEngine = null;
+let PlanningSimulator = null;
+let IntelligentAgentRouter = null;
 
 function getAnalyzer(root) {
   if (!ContinuousAnalyzer) {
@@ -46,6 +51,41 @@ function getDecisionEngine(root) {
   return new DecisionIntelligence(root);
 }
 
+function getFeatureDecomposer(root) {
+  if (!FeatureDecomposer) {
+    FeatureDecomposer = require('../core/planning').FeatureDecomposer;
+  }
+  return new FeatureDecomposer({ projectRoot: root });
+}
+
+function getStagePlanner(root) {
+  if (!StagePlanner) {
+    StagePlanner = require('../core/planning').StagePlanner;
+  }
+  return new StagePlanner({ projectRoot: root });
+}
+
+function getAdaptiveEngine(root) {
+  if (!AdaptivePlanningEngine) {
+    AdaptivePlanningEngine = require('../core/planning').AdaptivePlanningEngine;
+  }
+  return new AdaptivePlanningEngine({ projectRoot: root });
+}
+
+function getSimulator(root) {
+  if (!PlanningSimulator) {
+    PlanningSimulator = require('../core/planning').PlanningSimulator;
+  }
+  return new PlanningSimulator({ projectRoot: root });
+}
+
+function getAgentRouter(root) {
+  if (!IntelligentAgentRouter) {
+    IntelligentAgentRouter = require('../intelligence/agent-router').IntelligentAgentRouter;
+  }
+  return new IntelligentAgentRouter({ projectRoot: root });
+}
+
 // Get project root
 const projectRoot = process.cwd();
 
@@ -59,11 +99,16 @@ Intelligent planning and analysis for project development
 
 ${utils.COLORS.bold}Usage:${utils.COLORS.reset}
   bootspring plan                 Interactive planning overview
+  bootspring plan status          Current planning state and drift
+  bootspring plan stage           Detect and manage planning stage
+  bootspring plan refresh         Re-analyze and update plans
+  bootspring plan simulate        "What if" scenario planning
   bootspring plan analyze         Deep project analysis
   bootspring plan suggest         Get planning suggestions
   bootspring plan decompose       Break down a feature
   bootspring plan dependencies    Map feature dependencies
   bootspring plan risks           Analyze feature risks
+  bootspring plan route           Get agent routing recommendation
   bootspring plan coherence       Check document coherence
   bootspring plan drift           Detect documentation drift
   bootspring plan decisions       Get decision recommendations
@@ -72,14 +117,22 @@ ${utils.COLORS.bold}Options:${utils.COLORS.reset}
   --feature=<name>                Feature name (required for some commands)
   --context=<text>                Additional context
   --depth=<level>                 Analysis depth: quick, standard, deep
+  --type=<scenario>               Simulation type: feature, refactor, timeline, resource
+  --complexity=<level>            Complexity: trivial, simple, moderate, complex, very_complex
+  --all                           Refresh all documents
   --json                          Output as JSON
 
 ${utils.COLORS.bold}Examples:${utils.COLORS.reset}
   bootspring plan                           Overview
+  bootspring plan status                    Show planning drift
+  bootspring plan stage                     Detect current stage
+  bootspring plan stage --set=execution    Set planning stage
+  bootspring plan refresh                   Refresh drifted docs
+  bootspring plan simulate --type=feature --feature="Payment" --complexity=complex
   bootspring plan analyze --depth=deep      Deep analysis
   bootspring plan decompose --feature="User authentication"
+  bootspring plan route --feature="Add real-time chat"
   bootspring plan risks --feature="Payment integration"
-  bootspring plan suggest --context="adding real-time features"
 `);
 }
 
@@ -703,6 +756,536 @@ async function planDecisions(args) {
   }
 }
 
+/**
+ * Show planning status
+ */
+async function planStatus(args) {
+  utils.print.header('Planning Status');
+  console.log('');
+
+  const spinner = utils.createSpinner('Loading planning state...').start();
+
+  try {
+    const engine = getAdaptiveEngine(projectRoot);
+    await engine.initialize();
+    const status = await engine.getStatus();
+
+    spinner.succeed('Status loaded');
+    console.log('');
+
+    // Current stage
+    console.log(`${utils.COLORS.bold}Current Stage:${utils.COLORS.reset} ${status.stage}`);
+    console.log(`${utils.COLORS.bold}Last Refresh:${utils.COLORS.reset} ${status.lastRefresh || 'Never'}`);
+    console.log('');
+
+    // Drift indicator
+    const driftPercent = Math.round(status.drift.overall * 100);
+    const driftColor = driftPercent > 50 ? utils.COLORS.red :
+                       driftPercent > 25 ? utils.COLORS.yellow :
+                       utils.COLORS.green;
+    console.log(`${utils.COLORS.bold}Documentation Drift:${utils.COLORS.reset} ${driftColor}${driftPercent}%${utils.COLORS.reset} (${status.drift.severity.label})`);
+
+    if (status.pendingChanges > 0) {
+      console.log(`${utils.COLORS.bold}Pending Changes:${utils.COLORS.reset} ${status.pendingChanges}`);
+    }
+    console.log('');
+
+    // Planning layers
+    console.log(`${utils.COLORS.bold}Planning Layers:${utils.COLORS.reset}`);
+    for (const layer of status.layers) {
+      const layerDrift = Math.round(layer.drift * 100);
+      const icon = layerDrift > 40 ? utils.COLORS.red + '!' :
+                   layerDrift > 20 ? utils.COLORS.yellow + '●' :
+                   utils.COLORS.green + '✓';
+      console.log(`  ${icon}${utils.COLORS.reset} ${layer.name} (${layer.horizon}): ${layerDrift}% drift`);
+    }
+    console.log('');
+
+    // Recommendations
+    if (status.recommendations.length > 0) {
+      console.log(`${utils.COLORS.bold}Recommendations:${utils.COLORS.reset}`);
+      for (const rec of status.recommendations.slice(0, 3)) {
+        const icon = rec.priority === 'critical' ? utils.COLORS.red + '!' :
+                     rec.priority === 'high' ? utils.COLORS.yellow + '●' :
+                     utils.COLORS.dim + '○';
+        console.log(`  ${icon}${utils.COLORS.reset} ${rec.action}`);
+        if (rec.suggestedCommand) {
+          console.log(`    ${utils.COLORS.cyan}→${utils.COLORS.reset} ${rec.suggestedCommand}`);
+        }
+      }
+    }
+
+    if (args.json) {
+      console.log('');
+      console.log(JSON.stringify(status, null, 2));
+    }
+
+  } catch (error) {
+    spinner.fail(`Error: ${error.message}`);
+  }
+}
+
+/**
+ * Manage planning stage
+ */
+async function planStage(args) {
+  utils.print.header('Planning Stage');
+  console.log('');
+
+  const spinner = utils.createSpinner('Analyzing project stage...').start();
+
+  try {
+    const stagePlanner = getStagePlanner(projectRoot);
+    await stagePlanner.initialize();
+
+    if (args.set) {
+      // Transition to new stage
+      const transition = await stagePlanner.transitionTo(args.set, {
+        reason: args.reason || 'Manual transition via CLI'
+      });
+
+      spinner.succeed(`Transitioned to ${args.set} stage`);
+      console.log('');
+
+      console.log(`${utils.COLORS.bold}Stage Transition:${utils.COLORS.reset}`);
+      console.log(`  From: ${transition.previousStage}`);
+      console.log(`  To: ${transition.newStage}`);
+      console.log('');
+
+      // Show new stage context
+      const context = await stagePlanner.getStageContext();
+      console.log(`${utils.COLORS.bold}New Stage Documents:${utils.COLORS.reset}`);
+      for (const doc of context.documents) {
+        console.log(`  ${utils.COLORS.cyan}□${utils.COLORS.reset} ${doc.toUpperCase()}.md`);
+      }
+
+    } else {
+      // Detect current stage
+      const detection = await stagePlanner.detectStage();
+      spinner.succeed('Stage detected');
+      console.log('');
+
+      console.log(`${utils.COLORS.bold}Current Stage:${utils.COLORS.reset} ${detection.stage}`);
+      console.log(`${utils.COLORS.bold}Confidence:${utils.COLORS.reset} ${Math.round(detection.confidence * 100)}%`);
+      console.log('');
+
+      // Show signals
+      if (detection.signals) {
+        console.log(`${utils.COLORS.bold}Detection Signals:${utils.COLORS.reset}`);
+        for (const [signal, value] of Object.entries(detection.signals)) {
+          const icon = value ? utils.COLORS.green + '✓' : utils.COLORS.dim + '○';
+          console.log(`  ${icon}${utils.COLORS.reset} ${signal}`);
+        }
+        console.log('');
+      }
+
+      // Show stage context
+      const context = await stagePlanner.getStageContext();
+      console.log(`${utils.COLORS.bold}Stage Focus:${utils.COLORS.reset}`);
+      console.log(`  AI Prompt Style: ${context.aiPromptStyle}`);
+      console.log(`  Analysis Depth: ${context.analysisDepth}`);
+      console.log('');
+
+      console.log(`${utils.COLORS.bold}Key Questions:${utils.COLORS.reset}`);
+      for (const q of context.questions.slice(0, 4)) {
+        console.log(`  ${utils.COLORS.cyan}?${utils.COLORS.reset} ${q}`);
+      }
+      console.log('');
+
+      console.log(`${utils.COLORS.bold}Expected Documents:${utils.COLORS.reset}`);
+      for (const doc of context.documents) {
+        console.log(`  ${utils.COLORS.cyan}□${utils.COLORS.reset} ${doc.toUpperCase()}.md`);
+      }
+    }
+
+    if (args.json) {
+      const fullContext = await stagePlanner.getStageContext();
+      console.log('');
+      console.log(JSON.stringify(fullContext, null, 2));
+    }
+
+  } catch (error) {
+    spinner.fail(`Error: ${error.message}`);
+  }
+}
+
+/**
+ * Refresh planning documents
+ */
+async function planRefresh(args) {
+  utils.print.header('Planning Refresh');
+  console.log('');
+
+  const spinner = utils.createSpinner('Analyzing drift...').start();
+
+  try {
+    const engine = getAdaptiveEngine(projectRoot);
+    await engine.initialize();
+
+    // First show what would be refreshed
+    const drift = await engine.calculateDrift();
+
+    spinner.succeed('Drift analysis complete');
+    console.log('');
+
+    console.log(`${utils.COLORS.bold}Overall Drift:${utils.COLORS.reset} ${Math.round(drift.overall * 100)}%`);
+    console.log('');
+
+    if (Object.keys(drift.byDocument).length > 0) {
+      console.log(`${utils.COLORS.bold}Documents to Refresh:${utils.COLORS.reset}`);
+      for (const [doc, data] of Object.entries(drift.byDocument)) {
+        if (data.drift > 0.2 || args.all) {
+          const driftPercent = Math.round(data.drift * 100);
+          const icon = data.severity.level === 'critical' ? utils.COLORS.red + '!' :
+                       data.severity.level === 'significant' ? utils.COLORS.yellow + '●' :
+                       utils.COLORS.dim + '○';
+          console.log(`  ${icon}${utils.COLORS.reset} ${doc.toUpperCase()}.md (${driftPercent}% drift, ${data.changesAffecting} changes)`);
+        }
+      }
+      console.log('');
+    }
+
+    // Perform refresh
+    const refreshSpinner = utils.createSpinner('Refreshing documents...').start();
+
+    const result = await engine.refresh({
+      all: args.all,
+      documents: args.docs?.split(',')
+    });
+
+    if (result.documentsRefreshed.length > 0) {
+      refreshSpinner.succeed(`Refreshed ${result.documentsRefreshed.length} documents`);
+      console.log('');
+
+      console.log(`${utils.COLORS.bold}Refreshed:${utils.COLORS.reset}`);
+      for (const change of result.changes) {
+        console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} ${change.document.toUpperCase()}.md (v${change.newVersion}, ${change.changesIncorporated} changes)`);
+      }
+    } else {
+      refreshSpinner.info('No documents needed refresh');
+    }
+
+    if (result.errors.length > 0) {
+      console.log('');
+      console.log(`${utils.COLORS.bold}Errors:${utils.COLORS.reset}`);
+      for (const err of result.errors) {
+        console.log(`  ${utils.COLORS.red}✗${utils.COLORS.reset} ${err.document}: ${err.error}`);
+      }
+    }
+
+    if (args.json) {
+      console.log('');
+      console.log(JSON.stringify(result, null, 2));
+    }
+
+  } catch (error) {
+    spinner.fail(`Error: ${error.message}`);
+  }
+}
+
+/**
+ * Run planning simulation
+ */
+async function planSimulate(args) {
+  const type = args.type || 'feature';
+  const feature = args.feature || args.name;
+
+  utils.print.header('Planning Simulation');
+  console.log(`Type: ${type}`);
+  console.log('');
+
+  const spinner = utils.createSpinner('Running simulation...').start();
+
+  try {
+    const simulator = getSimulator(projectRoot);
+    await simulator.initialize();
+
+    // Build scenario based on type
+    const scenario = { type };
+
+    switch (type) {
+      case 'feature':
+        if (!feature) {
+          spinner.fail('Feature name required for feature simulation');
+          console.log('Usage: bootspring plan simulate --type=feature --feature="Feature name"');
+          return;
+        }
+        scenario.featureName = feature;
+        scenario.complexity = args.complexity || 'moderate';
+        scenario.dependencies = args.dependencies?.split(',') || [];
+        break;
+
+      case 'refactor':
+        scenario.scope = args.scope || 'module';
+        scenario.target = args.target || feature || 'unknown';
+        break;
+
+      case 'timeline':
+        scenario.change = args.change || 'compress';
+        scenario.amount = parseInt(args.amount) || 20;
+        break;
+
+      case 'resource':
+        scenario.action = args.action || 'add';
+        scenario.count = parseInt(args.count) || 1;
+        break;
+
+      default:
+        spinner.fail(`Unknown simulation type: ${type}`);
+        console.log('Valid types: feature, refactor, timeline, resource');
+        return;
+    }
+
+    const result = await simulator.simulate(scenario);
+
+    spinner.succeed('Simulation complete');
+    console.log('');
+
+    // Summary
+    console.log(`${utils.COLORS.bold}Summary:${utils.COLORS.reset}`);
+    console.log(`  ${result.summary.overallAssessment}`);
+    console.log('');
+
+    // Key points
+    if (result.summary.keyPoints.length > 0) {
+      console.log(`${utils.COLORS.bold}Key Points:${utils.COLORS.reset}`);
+      for (const point of result.summary.keyPoints) {
+        console.log(`  ${utils.COLORS.cyan}→${utils.COLORS.reset} ${point}`);
+      }
+      console.log('');
+    }
+
+    // Results by category
+    for (const [category, data] of Object.entries(result.results)) {
+      if (typeof data === 'object' && data !== null) {
+        console.log(`${utils.COLORS.bold}${category.charAt(0).toUpperCase() + category.slice(1)}:${utils.COLORS.reset}`);
+
+        if (data.estimatedDays) {
+          console.log(`  Estimated: ${data.estimatedDays} days (${data.range?.optimistic}-${data.range?.pessimistic} range)`);
+        }
+        if (data.overall) {
+          const icon = data.overall === 'high' ? utils.COLORS.red + '!' :
+                       data.overall === 'medium' ? utils.COLORS.yellow + '●' :
+                       utils.COLORS.green + '✓';
+          console.log(`  Level: ${icon}${utils.COLORS.reset} ${data.overall}`);
+        }
+        if (data.impact) {
+          console.log(`  Impact: ${data.impact}`);
+        }
+        if (Array.isArray(data.factors)) {
+          for (const factor of data.factors.slice(0, 3)) {
+            console.log(`    ${utils.COLORS.dim}•${utils.COLORS.reset} ${factor.description || factor}`);
+          }
+        }
+        console.log('');
+      }
+    }
+
+    // Recommendations
+    if (result.recommendations.length > 0) {
+      console.log(`${utils.COLORS.bold}Recommendations:${utils.COLORS.reset}`);
+      for (const rec of result.recommendations.slice(0, 5)) {
+        const icon = rec.priority === 'high' ? utils.COLORS.yellow + '!' :
+                     utils.COLORS.dim + '●';
+        console.log(`  ${icon}${utils.COLORS.reset} ${rec.action}`);
+        if (rec.command) {
+          console.log(`    ${utils.COLORS.cyan}→${utils.COLORS.reset} ${rec.command}`);
+        }
+      }
+    }
+
+    if (args.json) {
+      console.log('');
+      console.log(JSON.stringify(result, null, 2));
+    }
+
+  } catch (error) {
+    spinner.fail(`Error: ${error.message}`);
+  }
+}
+
+/**
+ * Get agent routing recommendation
+ */
+async function planRoute(args) {
+  const task = args.feature || args.task || args.context;
+
+  if (!task) {
+    utils.print.error('Task description required');
+    console.log('Usage: bootspring plan route --task="Implement user authentication"');
+    return;
+  }
+
+  utils.print.header('Agent Routing');
+  console.log(`Task: ${task}`);
+  console.log('');
+
+  const spinner = utils.createSpinner('Analyzing task...').start();
+
+  try {
+    const router = getAgentRouter(projectRoot);
+    await router.initialize();
+
+    const routing = await router.route(task, {
+      affectedFiles: args.files?.split(',') || []
+    });
+
+    spinner.succeed('Routing analysis complete');
+    console.log('');
+
+    // Mode
+    console.log(`${utils.COLORS.bold}Mode:${utils.COLORS.reset} ${routing.mode === 'single' ? 'Single Agent' : 'Multi-Agent Collaboration'}`);
+    console.log('');
+
+    // Complexity
+    console.log(`${utils.COLORS.bold}Complexity:${utils.COLORS.reset} ${routing.complexity.level}`);
+    console.log(`  Scope: ${routing.complexity.factors.scope}`);
+    console.log(`  Risk: ${routing.complexity.factors.risk}`);
+    console.log('');
+
+    if (routing.mode === 'single') {
+      // Single agent recommendation
+      console.log(`${utils.COLORS.bold}Recommended Agent:${utils.COLORS.reset} ${routing.primaryAgent}`);
+      if (routing.fallbackAgents?.length > 0) {
+        console.log(`${utils.COLORS.bold}Fallbacks:${utils.COLORS.reset} ${routing.fallbackAgents.join(', ')}`);
+      }
+      console.log('');
+
+      console.log(`${utils.COLORS.bold}Approach:${utils.COLORS.reset}`);
+      for (const step of routing.suggestedApproach.steps) {
+        console.log(`  ${utils.COLORS.cyan}→${utils.COLORS.reset} ${step}`);
+      }
+
+    } else {
+      // Multi-agent collaboration
+      console.log(`${utils.COLORS.bold}Collaboration Pattern:${utils.COLORS.reset} ${routing.pattern.name}`);
+      console.log(`  ${routing.pattern.description}`);
+      console.log('');
+
+      console.log(`${utils.COLORS.bold}Agent Sequence:${utils.COLORS.reset}`);
+      for (const agent of routing.agents) {
+        console.log(`  ${utils.COLORS.cyan}${agent.phase}.${utils.COLORS.reset} ${agent.agent}`);
+        console.log(`     Focus: ${agent.focus}`);
+        if (agent.input) console.log(`     Input: ${agent.input}`);
+        console.log(`     Output: ${agent.output}`);
+      }
+      console.log('');
+
+      if (routing.handoffPoints?.length > 0) {
+        console.log(`${utils.COLORS.bold}Handoff Points:${utils.COLORS.reset}`);
+        for (const handoff of routing.handoffPoints) {
+          console.log(`  ${utils.COLORS.yellow}→${utils.COLORS.reset} ${handoff.from} → ${handoff.to}: ${handoff.artifact}`);
+        }
+        console.log('');
+      }
+
+      console.log(`${utils.COLORS.bold}Coordinator:${utils.COLORS.reset} ${routing.coordinatorAgent}`);
+    }
+
+    // Estimated effort
+    console.log('');
+    console.log(`${utils.COLORS.bold}Estimated Effort:${utils.COLORS.reset} ${routing.estimatedEffort?.range || 'Unknown'}`);
+
+    if (args.json) {
+      console.log('');
+      console.log(JSON.stringify(routing, null, 2));
+    }
+
+  } catch (error) {
+    spinner.fail(`Error: ${error.message}`);
+  }
+}
+
+/**
+ * Enhanced feature decomposition using FeatureDecomposer
+ */
+async function planDecomposeEnhanced(args) {
+  const feature = args.feature;
+
+  if (!feature) {
+    utils.print.error('Feature name required');
+    console.log('Usage: bootspring plan decompose --feature="Feature name"');
+    return;
+  }
+
+  utils.print.header(`Feature Decomposition: ${feature}`);
+  console.log('');
+
+  const spinner = utils.createSpinner('Breaking down feature...').start();
+
+  try {
+    const decomposer = getFeatureDecomposer(projectRoot);
+
+    const decomposition = await decomposer.decompose(feature, {
+      depth: args.depth || 'standard',
+      includePatterns: !args.noPatterns
+    });
+
+    spinner.succeed('Decomposition complete');
+    console.log('');
+
+    // Classification
+    console.log(`${utils.COLORS.bold}Classification:${utils.COLORS.reset} ${decomposition.classification || 'Custom'}`);
+    console.log(`${utils.COLORS.bold}Complexity:${utils.COLORS.reset} ${decomposition.complexity || 'medium'}`);
+    console.log('');
+
+    // Metrics summary
+    if (decomposition.metrics) {
+      console.log(`${utils.COLORS.bold}Metrics:${utils.COLORS.reset}`);
+      console.log(`  Total Tasks: ${decomposition.metrics.totalTasks}`);
+      console.log(`  Estimated Points: ${decomposition.metrics.totalPoints}`);
+      console.log(`  Estimated Time: ${decomposition.metrics.estimatedTime}`);
+      console.log('');
+    }
+
+    // Layers
+    console.log(`${utils.COLORS.bold}Task Breakdown:${utils.COLORS.reset}`);
+    for (const [layer, tasks] of Object.entries(decomposition.layers)) {
+      if (tasks.length > 0) {
+        console.log(`\n  ${utils.COLORS.bold}${layer.charAt(0).toUpperCase() + layer.slice(1)}:${utils.COLORS.reset}`);
+        for (const task of tasks) {
+          const deps = task.deps?.length > 0 ? ` ${utils.COLORS.dim}(after: ${task.deps.join(', ')})${utils.COLORS.reset}` : '';
+          console.log(`    ${utils.COLORS.cyan}□${utils.COLORS.reset} ${task.task} [${task.effort}]${deps}`);
+        }
+      }
+    }
+    console.log('');
+
+    // Critical path
+    if (decomposition.criticalPath?.length > 0) {
+      console.log(`${utils.COLORS.bold}Critical Path:${utils.COLORS.reset}`);
+      console.log(`  ${decomposition.criticalPath.join(' → ')}`);
+      console.log('');
+    }
+
+    // Risks
+    if (decomposition.risks?.length > 0) {
+      console.log(`${utils.COLORS.bold}Risks:${utils.COLORS.reset}`);
+      for (const risk of decomposition.risks) {
+        console.log(`  ${utils.COLORS.yellow}⚠${utils.COLORS.reset} ${risk.risk}`);
+        console.log(`    Mitigation: ${risk.mitigation}`);
+      }
+      console.log('');
+    }
+
+    // Recommended patterns
+    if (decomposition.recommendedPatterns?.length > 0) {
+      console.log(`${utils.COLORS.bold}Recommended Patterns:${utils.COLORS.reset}`);
+      for (const pattern of decomposition.recommendedPatterns) {
+        console.log(`  ${utils.COLORS.green}●${utils.COLORS.reset} ${pattern}`);
+      }
+    }
+
+    if (args.json) {
+      console.log('');
+      console.log(JSON.stringify(decomposition, null, 2));
+    }
+
+  } catch (error) {
+    spinner.fail(`Error: ${error.message}`);
+  }
+}
+
 /**
  * Main entry point
  */
@@ -711,6 +1294,19 @@ async function run(args) {
   const subcommand = parsedArgs._[0];
 
   switch (subcommand) {
+    case 'status':
+      return planStatus(parsedArgs);
+
+    case 'stage':
+      return planStage(parsedArgs);
+
+    case 'refresh':
+      return planRefresh(parsedArgs);
+
+    case 'simulate':
+    case 'sim':
+      return planSimulate(parsedArgs);
+
     case 'analyze':
       return planAnalyze(parsedArgs);
 
@@ -720,7 +1316,7 @@ async function run(args) {
 
     case 'decompose':
     case 'breakdown':
-      return planDecompose(parsedArgs);
+      return planDecomposeEnhanced(parsedArgs);
 
     case 'dependencies':
     case 'deps':
@@ -730,6 +1326,10 @@ async function run(args) {
     case 'risk':
       return planRisks(parsedArgs);
 
+    case 'route':
+    case 'routing':
+      return planRoute(parsedArgs);
+
     case 'coherence':
       return planCoherence(parsedArgs);