@gravirei/reis 2.3.3 → 2.4.0

package/CHANGELOG.md

@@ -5,6 +5,81 @@ All notable changes to REIS will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.4.0] - 2026-01-22
+
+### Added - Kanban Board & Real Execution 🚀
+
+**Major Feature: Persistent Kanban Board**
+
+A visual kanban board that displays automatically on workflow commands showing real-time cycle progress.
+
+#### Kanban Board Features
+
+- **Persistent Display** - Shows automatically on workflow commands (plan, execute, verify, debug, cycle, progress, resume, checkpoint)
+- **4-Column Layout**:
+  - ALL PHASES - Shows all project phases (P1 P2 P3 P4...)
+  - IN PROGRESS - Current phase with wave/task breakdown
+  - CYCLE - Planning → Execute → Verify → Debug stages with progress bars
+  - COMPLETED - List of completed cycles
+- **Wave Execution Visualization**:
+  - Wave list with tree structure (Wave 1/3 ✓, Wave 2/3 ◉, Wave 3/3 ○)
+  - Task status under current wave (├ 2.1 ✓, └ 2.4 ○)
+  - Parallel execution indicator (⫴2 of 4 tasks)
+  - Running/Waiting task breakdown
+- **Subagent Status** - Shows active subagent (planner, executor, verifier, debugger)
+- **Centered Progress Bars** - `[■■■■■45% ░░░░░]` format
+- **3 Display Styles**: full, compact, minimal
+- **Idle States**:
+  - "No active phase" + "Run: reis cycle" prompt
+  - "No cycles completed" for fresh projects
+  - "✓ All phases done!" when complete
+
+#### Kanban Command
+
+- `reis kanban` - Show current settings
+- `reis kanban enable/disable/toggle` - Control display
+- `reis kanban style <full|compact|minimal>` - Change display style
+- `--no-kanban` flag to hide for single command
+
+**Major Feature: Real Subagent Execution (Priority 1)**
+
+Transformed REIS from a "prompt printer" to an actual "execution system".
+
+#### Subagent Invocation API
+
+- **New Module** (`lib/utils/subagent-invoker.js`) - Core API for programmatic subagent invocation
+- Classes: `SubagentDefinition`, `ExecutionContext`, `InvocationResult`, `SubagentInvoker`
+- Functions: `loadSubagentDefinition()`, `listSubagents()`, `buildExecutionContext()`, `invoke()`, `invokeParallel()`
+- Event-based execution with progress tracking
+- Timeout and error handling
+
+#### Cycle Orchestrator Completion
+
+- Implemented 5 TODOs that were previously stubbed:
+  - Actually execute plans via `invokeSubagent('reis_executor', ...)`
+  - Actually run verification via `invokeSubagent('reis_verifier', ...)`
+  - Actually run debug analysis via `invokeSubagent('reis_debugger', ...)`
+  - Actually execute fix plans
+  - Append completion records to STATE.md
+
+#### Command Updates
+
+- `reis execute <phase>` - Now invokes reis_executor subagent (with `--dry-run` fallback)
+- `reis verify` - Now invokes reis_verifier subagent
+- `reis debug` - Now invokes reis_debugger subagent
+- New options: `--dry-run`, `--verbose`, `--timeout <ms>`
+
+### Fixed
+
+- `reis whats-new` - Was showing "Command coming soon", now properly wired to implementation
+- `reis docs` - Was showing "Command coming soon", now properly wired to implementation
+
+### Changed
+
+- Help modal updated with new command options and compact format
+- Added hidden commands to help: `reis add`, `reis insert`, `reis remove`
+- Updated column widths in kanban board for better readability
+
 ## [2.3.0] - 2026-01-22
 
 ### Added - Decision Trees Support 🌳

package/bin/reis.js

@@ -78,6 +78,7 @@ const configCmd = require('../lib/commands/config.js');
 const cycleCmd = require('../lib/commands/cycle.js');
 const decisionsCmd = require('../lib/commands/decisions.js');
 const treeCmd = require('../lib/commands/tree.js');
+const kanbanCmd = require('../lib/commands/kanban.js');
 
 // Check for --help or -h flag before Commander parses
 if (process.argv.includes('--help') || process.argv.includes('-h')) {
@@ -95,6 +96,9 @@ program
   .description('REIS - Roadmap Execution & Implementation System')
   .usage('<command> [options]');
 
+// Global option for kanban
+program.option('--no-kanban', 'Hide kanban board for this command');
+
 // Getting Started Commands
 program
   .command('help')
@@ -130,7 +134,10 @@ program
 program
   .command('plan [phase]')
   .description('Create detailed plan for a phase')
-  .action((phase) => planCmd({phase}));
+  .action((phase, options, command) => {
+    const globalOpts = command.parent?.opts() || {};
+    planCmd({ phase }, { noKanban: globalOpts.kanban === false });
+  });
 
 program
   .command('discuss [phase]')
@@ -150,7 +157,15 @@ program
 program
   .command('execute [phase]')
   .description('Execute a phase')
-  .action((phase) => executeCmd({phase}));
+  .option('--dry-run', 'Show prompt without executing')
+  .option('-v, --verbose', 'Show detailed output')
+  .option('--no-commit', 'Skip auto-commit')
+  .option('--timeout <ms>', 'Execution timeout in milliseconds')
+  .action(async (phase, options, command) => {
+    const globalOpts = command.parent?.opts() || {};
+    const exitCode = await executeCmd({ phase }, { ...options, noKanban: globalOpts.kanban === false });
+    process.exit(exitCode);
+  });
 
 program
   .command('execute-plan <path>')
@@ -158,29 +173,37 @@ program
   .option('--wave', 'Enable wave-based execution (v2.0 feature)')
   .option('--dry-run', 'Show plan structure without executing')
   .option('--interactive', 'Step-by-step execution with prompts between waves')
-  .action(async (path, options) => {
+  .action(async (planPath, options, command) => {
+    const globalOpts = command.parent?.opts() || {};
     await executePlanCmd({
-      path,
+      path: planPath,
       wave: options.wave,
       dryRun: options.dryRun,
-      interactive: options.interactive
+      interactive: options.interactive,
+      noKanban: globalOpts.kanban === false
     });
   });
 
 program
   .command('verify <target>')
   .description('Verify execution results against success criteria (uses reis_verifier subagent)')
+  .option('--dry-run', 'Show prompt without executing')
   .option('-v, --verbose', 'Show detailed verification output')
   .option('-s, --strict', 'Fail on warnings')
-  .action(async (target, options) => {
-    await verifyCmd(target, options);
+  .option('--timeout <ms>', 'Verification timeout in milliseconds')
+  .action(async (target, options, command) => {
+    const globalOpts = command.parent?.opts() || {};
+    await verifyCmd(target, { ...options, noKanban: globalOpts.kanban === false });
   });
 
 // Progress Commands
 program
   .command('progress')
   .description('Show current project progress')
-  .action(() => progressCmd({}));
+  .action((options, command) => {
+    const globalOpts = command.parent?.opts() || {};
+    progressCmd({}, { noKanban: globalOpts.kanban === false });
+  });
 
 program
   .command('pause')
@@ -190,7 +213,10 @@ program
 program
   .command('resume')
   .description('Resume paused work')
-  .action(() => resumeCmd({}));
+  .action((options, command) => {
+    const globalOpts = command.parent?.opts() || {};
+    resumeCmd({}, { noKanban: globalOpts.kanban === false });
+  });
 
 // Checkpoint Management Commands
 program
@@ -199,8 +225,9 @@ program
   .option('-c, --commit', 'Force git commit')
   .option('--no-commit', 'Skip git commit')
   .option('-m, --message <message>', 'Custom commit message')
-  .action((subcommand, name, options) => {
-    checkpointCmd({ subcommand, name, ...options });
+  .action((subcommand, name, options, command) => {
+    const globalOpts = command.parent?.opts() || {};
+    checkpointCmd({ subcommand, name, ...options, noKanban: globalOpts.kanban === false });
   });
 
 // Roadmap Management Commands
@@ -241,11 +268,14 @@ program
 program
   .command('debug [target]')
   .description('Analyze failures and generate fix plans (uses reis_debugger subagent)')
+  .option('--dry-run', 'Show prompt without executing')
   .option('-i, --input <path>', 'Path to DEBUG_INPUT.md or plan file')
   .option('-f, --focus <area>', 'Focus analysis on specific area')
   .option('-v, --verbose', 'Show detailed debug output')
-  .action(async (target, options) => {
-    await debugCmd(target, options);
+  .option('--timeout <ms>', 'Debug timeout in milliseconds')
+  .action(async (target, options, command) => {
+    const globalOpts = command.parent?.opts() || {};
+    await debugCmd(target, { ...options, noKanban: globalOpts.kanban === false });
   });
 
 program
@@ -256,8 +286,9 @@ program
   .option('--resume', 'Resume interrupted cycle')
   .option('--continue-on-fail', 'Continue even if verification fails')
   .option('-v, --verbose', 'Detailed output')
-  .action(async (phaseOrPlan, options) => {
-    await cycleCmd(phaseOrPlan, options);
+  .action(async (phaseOrPlan, options, command) => {
+    const globalOpts = command.parent?.opts() || {};
+    await cycleCmd(phaseOrPlan, { ...options, noKanban: globalOpts.kanban === false });
   });
 
 program
@@ -310,7 +341,17 @@ program
     await treeCmd(subcommand, args, options);
   });
 
+program
+  .command('kanban [subcommand] [value]')
+  .description('Manage kanban board settings')
+  .action((subcommand, value) => {
+    const args = [subcommand, value].filter(Boolean);
+    kanbanCmd(args, {});
+  });
+
 const updateCmd = require('../lib/commands/update.js');
+const whatsNewCmd = require('../lib/commands/whats-new.js');
+const docsCmd = require('../lib/commands/docs.js');
 
 program
   .command('update')
@@ -323,14 +364,14 @@ program
   .command('whats-new')
   .description('Show what\'s new in latest version')
   .action(() => {
-    console.log('Command coming soon in Phase 5-8');
+    whatsNewCmd({});
   });
 
 program
   .command('docs')
   .description('Open REIS documentation')
   .action(() => {
-    console.log('Command coming soon in Phase 5-8');
+    docsCmd({});
   });
 
 program

package/lib/commands/checkpoint.js

@@ -6,6 +6,7 @@
 const StateManager = require('../utils/state-manager');
 const GitIntegration = require('../utils/git-integration');
 const { loadConfig } = require('../utils/config');
+const { showKanbanBoard } = require('../utils/kanban-renderer');
 const fs = require('fs');
 const path = require('path');
 
@@ -301,6 +302,9 @@ async function deleteCheckpoint(name, options = {}) {
  * Main checkpoint command handler
  */
 async function checkpoint(options = {}) {
+  // Show kanban board (unless disabled)
+  showKanbanBoard({ noKanban: options?.noKanban });
+  
   const subcommand = options.subcommand || 'list';
   const name = options.name;
 

package/lib/commands/cycle.js

@@ -2,6 +2,7 @@ const chalk = require('chalk');
 const { runCycle } = require('../utils/cycle-orchestrator');
 const stateManager = require('../utils/cycle-state-manager');
 const { showError, checkPlanningDir } = require('../utils/command-helpers');
+const { showKanbanBoard } = require('../utils/kanban-renderer');
 
 /**
  * Cycle Command
@@ -14,6 +15,8 @@ const { showError, checkPlanningDir } = require('../utils/command-helpers');
  * @param {Object} options - Command options
  */
 async function cycle(phaseOrPlan, options = {}) {
+  // Show kanban board (unless disabled)
+  showKanbanBoard({ noKanban: options?.noKanban });
   try {
     // Show welcome banner
     showBanner(phaseOrPlan, options);

package/lib/commands/debug.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
 const { showError, showSuccess, showInfo, checkPlanningDir } = require('../utils/command-helpers.js');
+const { showKanbanBoard } = require('../utils/kanban-renderer');
 
 /**
  * Debug command - Analyze verification failures and generate fix plans
@@ -9,6 +10,8 @@ const { showError, showSuccess, showInfo, checkPlanningDir } = require('../utils
  * @param {Object} options - Command options
  */
 async function debugCommand(target, options = {}) {
+  // Show kanban board (unless disabled)
+  showKanbanBoard({ noKanban: options?.noKanban });
   console.log(chalk.blue('\n🔍 REIS Debugger\n'));
 
   // Validate REIS project
@@ -58,6 +61,13 @@ async function debugCommand(target, options = {}) {
       process.exit(1);
     }
 
+    // Handle dry-run case
+    if (result.dryRun) {
+      console.log(chalk.yellow('\n⚠️  Dry run complete - no actual debugging performed'));
+      console.log(chalk.gray('Run without --dry-run to perform actual analysis'));
+      process.exit(0);
+    }
+
     // 7. Display results
     console.log(chalk.green('\n✅ Analysis complete!\n'));
     
@@ -215,39 +225,92 @@ function buildDebuggerPrompt(debugInput, context, issueType, options) {
 
 /**
  * Invoke debugger subagent via Rovo Dev
+ * @param {string} prompt - Debug prompt
+ * @param {object} options - Command options
+ * @returns {Promise<object>} Debug results
  */
 async function invokeDebugger(prompt, options) {
-  // TODO: Integrate with Rovo Dev API or CLI
-  // For now, output the prompt that would be sent to the subagent
-  
-  console.log(chalk.yellow('⚠️  Note: Subagent invocation pending Rovo Dev integration'));
-  console.log(chalk.gray('The debugger prompt has been generated and would be sent to reis_debugger.'));
-  console.log();
-  console.log(chalk.cyan('Prompt Preview:'));
-  console.log(chalk.gray('─'.repeat(80)));
-  console.log(prompt.substring(0, 500) + '...');
-  console.log(chalk.gray('─'.repeat(80)));
-  console.log();
-  
-  // Create debug output directory
   const debugDir = path.join(process.cwd(), '.planning', 'debug');
+  
+  // Ensure debug directory exists
   if (!fs.existsSync(debugDir)) {
     fs.mkdirSync(debugDir, { recursive: true });
   }
-
-  // Save prompt for manual invocation
-  const promptPath = path.join(debugDir, 'DEBUGGER_PROMPT.txt');
-  fs.writeFileSync(promptPath, prompt, 'utf-8');
-  console.log(chalk.gray(`Prompt saved to: ${promptPath}`));
-  console.log();
   
-  return {
-    success: true,
-    outputs: {
-      report: path.join(debugDir, 'DEBUG_REPORT.md'),
-      fixPlan: path.join(debugDir, 'FIX_PLAN.md')
+  // Dry run mode - show prompt only
+  if (options.dryRun) {
+    console.log(chalk.yellow('--dry-run mode: Showing prompt that would be sent\n'));
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(prompt.substring(0, 2000) + '...');
+    console.log(chalk.gray('─'.repeat(60)));
+    
+    // Save prompt for reference
+    const promptPath = path.join(debugDir, 'DEBUGGER_PROMPT.txt');
+    fs.writeFileSync(promptPath, prompt, 'utf-8');
+    console.log(chalk.gray(`\nPrompt saved to: ${promptPath}`));
+    
+    return {
+      success: true,
+      dryRun: true,
+      outputs: {
+        report: path.join(debugDir, 'DEBUG_REPORT.md'),
+        fixPlan: path.join(debugDir, 'FIX_PLAN.md')
+      }
+    };
+  }
+  
+  // Real execution mode
+  const { invokeSubagent, SubagentInvoker } = require('../utils/subagent-invoker');
+  
+  const invoker = new SubagentInvoker({ verbose: options.verbose });
+  
+  invoker.on('progress', (data) => {
+    console.log(chalk.gray(`  ${data.message}`));
+  });
+  
+  invoker.on('artifact', (data) => {
+    console.log(chalk.green(`  ✓ Generated: ${data.path}`));
+  });
+  
+  try {
+    const result = await invokeSubagent('reis_debugger', {
+      verbose: options.verbose,
+      timeout: options.timeout || 300000,
+      additionalContext: {
+        debugPrompt: prompt,
+        focusArea: options.focus || null
+      }
+    });
+    
+    // Determine output paths
+    let reportPath = path.join(debugDir, 'DEBUG_REPORT.md');
+    let fixPlanPath = path.join(debugDir, 'FIX_PLAN.md');
+    
+    if (result.metadata) {
+      reportPath = result.metadata.reportPath || reportPath;
+      fixPlanPath = result.metadata.fixPlanPath || fixPlanPath;
     }
-  };
+    
+    return {
+      success: result.success,
+      outputs: {
+        report: reportPath,
+        fixPlan: fixPlanPath
+      },
+      output: result.output,
+      error: result.error
+    };
+    
+  } catch (error) {
+    return {
+      success: false,
+      error: error,
+      outputs: {
+        report: path.join(debugDir, 'DEBUG_REPORT.md'),
+        fixPlan: path.join(debugDir, 'FIX_PLAN.md')
+      }
+    };
+  }
 }
 
 /**

package/lib/commands/execute-plan.js

@@ -7,6 +7,7 @@ const { loadConfig } = require('../utils/config');
 const { getGitStatus, commitWaveCompletion } = require('../utils/git-integration');
 const { parseDecisionTrees } = require('../utils/decision-tree-parser');
 const { renderDecisionTree } = require('../utils/visualizer');
+const { showKanbanBoard } = require('../utils/kanban-renderer');
 const chalk = require('chalk');
 
 /**
@@ -16,9 +17,12 @@ const chalk = require('chalk');
  * @param {boolean} args.wave - Enable wave-based execution
  * @param {boolean} args.dryRun - Show plan without executing
  * @param {boolean} args.interactive - Step-by-step execution with prompts
+ * @param {boolean} args.noKanban - Hide kanban board
  * @returns {Promise<number>} Exit code
  */
 async function executePlan(args) {
+  // Show kanban board (unless disabled)
+  showKanbanBoard({ noKanban: args?.noKanban });
   // Check if .planning/ exists
   if (!checkPlanningDir()) {
     showError('Not a REIS project. Run "reis new" or "reis map" first.');

package/lib/commands/execute.js

@@ -1,6 +1,18 @@
-const { showPrompt, showError, checkPlanningDir, validatePhaseNumber } = require('../utils/command-helpers');
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { showError, checkPlanningDir, validatePhaseNumber } = require('../utils/command-helpers');
+const { invokeSubagent, SubagentInvoker, buildExecutionContext } = require('../utils/subagent-invoker');
+const { showKanbanBoard } = require('../utils/kanban-renderer');
 
-module.exports = function execute(args) {
+/**
+ * Execute command - Runs reis_executor subagent
+ * @param {Object} args - Command arguments
+ * @param {Object} options - Command options
+ */
+async function execute(args, options = {}) {
+  // Show kanban board (unless disabled)
+  showKanbanBoard({ noKanban: options?.noKanban });
   // Check if .planning/ exists
   if (!checkPlanningDir()) {
     showError('Not a REIS project. Run "reis new" or "reis map" first.');
@@ -14,15 +26,145 @@ module.exports = function execute(args) {
     process.exit(1);
   }
   
-  // Validate phase is a valid positive number
   const validatedPhase = validatePhaseNumber(phase);
   if (validatedPhase === null) {
     process.exit(1);
   }
   
-  const prompt = `Execute phase ${validatedPhase} using REIS methodology. Use the reis_executor subagent to execute all plans for this phase in parallel where possible (up to 4 simultaneous tasks). Each task gets fresh 200k context. Update .planning/STATE.md with progress.`;
+  // Find plan file(s) for this phase
+  const planPath = findPlanPath(validatedPhase);
+  if (!planPath) {
+    showError(`No plan found for phase ${validatedPhase}. Run "reis plan ${validatedPhase}" first.`);
+    process.exit(1);
+  }
+  
+  console.log(chalk.blue(`\n⚙️  REIS Executor - Phase ${validatedPhase}\n`));
+  console.log(chalk.gray(`Plan: ${planPath}`));
+  
+  // Dry run mode - just show what would happen
+  if (options.dryRun) {
+    console.log(chalk.yellow('\n--dry-run mode: Showing prompt that would be sent\n'));
+    const ctx = buildExecutionContext('reis_executor', { planPath });
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(ctx.buildPrompt().substring(0, 2000) + '...');
+    console.log(chalk.gray('─'.repeat(60)));
+    return 0;
+  }
+  
+  // Real execution mode
+  console.log(chalk.blue('\n🚀 Starting execution...\n'));
   
-  showPrompt(prompt);
+  const invoker = new SubagentInvoker({ verbose: options.verbose });
   
-  return 0;
-};
+  // Set up progress display
+  invoker.on('start', () => {
+    console.log(chalk.gray('  Initializing executor...'));
+  });
+  
+  invoker.on('progress', (data) => {
+    console.log(chalk.gray(`  ${data.message}`));
+  });
+  
+  invoker.on('artifact', (data) => {
+    console.log(chalk.green(`  ✓ Created: ${data.path}`));
+  });
+  
+  try {
+    const result = await invokeSubagent('reis_executor', {
+      planPath,
+      verbose: options.verbose,
+      timeout: options.timeout || 600000,
+      additionalContext: {
+        phase: validatedPhase,
+        autoCommit: options.commit !== false
+      }
+    });
+    
+    if (result.success) {
+      console.log(chalk.green('\n✅ Execution complete!\n'));
+      
+      if (result.metadata?.artifacts?.length > 0) {
+        console.log(chalk.cyan('Artifacts created:'));
+        result.metadata.artifacts.forEach(a => {
+          console.log(chalk.gray(`  - ${a}`));
+        });
+      }
+      
+      console.log(chalk.blue('\nNext step: ') + chalk.cyan(`reis verify ${validatedPhase}`));
+      return 0;
+    } else {
+      console.log(chalk.red('\n❌ Execution failed\n'));
+      if (result.error) {
+        console.log(chalk.red(`Error: ${result.error.message}`));
+      }
+      console.log(chalk.yellow('\nTry: reis debug to analyze the failure'));
+      return 1;
+    }
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Execution error: ${error.message}`));
+    if (options.verbose) {
+      console.error(error.stack);
+    }
+    return 1;
+  }
+}
+
+/**
+ * Find plan file for a phase
+ */
+function findPlanPath(phase) {
+  const planningDir = path.join(process.cwd(), '.planning');
+  
+  // Try phase-N.PLAN.md
+  const directPath = path.join(planningDir, `phase-${phase}.PLAN.md`);
+  if (fs.existsSync(directPath)) {
+    return directPath;
+  }
+  
+  // Try phases/N-*/PLAN.md
+  const phasesDir = path.join(planningDir, 'phases');
+  if (fs.existsSync(phasesDir)) {
+    const dirs = fs.readdirSync(phasesDir).filter(d => d.startsWith(`${phase}-`));
+    if (dirs.length > 0) {
+      const phaseDir = path.join(phasesDir, dirs[0]);
+      const plans = fs.readdirSync(phaseDir).filter(f => f.endsWith('.PLAN.md'));
+      if (plans.length > 0) {
+        return path.join(phaseDir, plans[0]);
+      }
+    }
+  }
+  
+  // Try N-*/PLAN.md directly in .planning
+  const dirs = fs.readdirSync(planningDir).filter(d => d.startsWith(`${phase}-`));
+  if (dirs.length > 0) {
+    const phaseDir = path.join(planningDir, dirs[0]);
+    if (fs.statSync(phaseDir).isDirectory()) {
+      const plans = fs.readdirSync(phaseDir).filter(f => f.endsWith('.PLAN.md'));
+      if (plans.length > 0) {
+        return path.join(phaseDir, plans[0]);
+      }
+    }
+  }
+  
+  // Try priority-*/phase-N-* pattern (for priority folders)
+  const priorityDirs = fs.readdirSync(planningDir).filter(d => d.startsWith('priority-'));
+  for (const priorityDir of priorityDirs) {
+    const priorityPath = path.join(planningDir, priorityDir);
+    if (fs.statSync(priorityPath).isDirectory()) {
+      const phaseDirs = fs.readdirSync(priorityPath).filter(d => 
+        d.startsWith(`phase-${phase}-`) || d.startsWith(`${phase}-`)
+      );
+      if (phaseDirs.length > 0) {
+        const phaseDir = path.join(priorityPath, phaseDirs[0]);
+        const plans = fs.readdirSync(phaseDir).filter(f => f.endsWith('.PLAN.md'));
+        if (plans.length > 0) {
+          return path.join(phaseDir, plans[0]);
+        }
+      }
+    }
+  }
+  
+  return null;
+}
+
+module.exports = execute;