claude-flow-novice 2.0.0 → 2.0.1

package/.claude-flow-novice/dist/src/cli/commands/cfn-loop-parallel.js

@@ -0,0 +1,436 @@
+/**
+ * CFN Loop Parallel Execution CLI Command
+ * Sprint 5 - Phase 5.1: CLI Integration
+ *
+ * Enables parallel execution of multiple CFN Loop sprints with resource management,
+ * dependency analysis, and real-time monitoring.
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { Command } from "commander";
+import { EventEmitter } from "events";
+import Redis from "ioredis";
+/**
+ * Dependency Graph Analyzer
+ * Builds topological ordering of sprints for parallel execution
+ */ let DependencyAnalyzer = class DependencyAnalyzer {
+    buildGraph(sprints) {
+        // Initialize nodes
+        for (const sprint of sprints){
+            this.graph.set(sprint.sprintId, {
+                sprintId: sprint.sprintId,
+                dependencies: sprint.dependencies,
+                dependents: [],
+                depth: 0
+            });
+        }
+        // Build dependency edges
+        for (const sprint of sprints){
+            for (const depId of sprint.dependencies){
+                const depNode = this.graph.get(depId);
+                if (depNode) {
+                    depNode.dependents.push(sprint.sprintId);
+                }
+            }
+        }
+        // Calculate depth (for wave assignment)
+        this.calculateDepths();
+    }
+    calculateDepths() {
+        const visited = new Set();
+        const calculateDepth = (sprintId)=>{
+            if (visited.has(sprintId)) {
+                const node = this.graph.get(sprintId);
+                return node?.depth || 0;
+            }
+            visited.add(sprintId);
+            const node = this.graph.get(sprintId);
+            if (!node || node.dependencies.length === 0) {
+                if (node) node.depth = 0;
+                return 0;
+            }
+            const maxDepDepth = Math.max(...node.dependencies.map((depId)=>calculateDepth(depId)));
+            node.depth = maxDepDepth + 1;
+            return node.depth;
+        };
+        for (const sprintId of this.graph.keys()){
+            calculateDepth(sprintId);
+        }
+    }
+    /**
+   * Generate execution waves for parallel execution
+   * Sprints in same wave can run in parallel (no dependencies between them)
+   */ getExecutionWaves(sprints, maxParallelSprints) {
+        const waves = [];
+        const sprintsByDepth = new Map();
+        // Group sprints by depth
+        for (const sprint of sprints){
+            const node = this.graph.get(sprint.sprintId);
+            const depth = node?.depth || 0;
+            if (!sprintsByDepth.has(depth)) {
+                sprintsByDepth.set(depth, []);
+            }
+            sprintsByDepth.get(depth).push(sprint);
+        }
+        // Create waves respecting maxParallelSprints limit
+        const sortedDepths = Array.from(sprintsByDepth.keys()).sort((a, b)=>a - b);
+        for (const depth of sortedDepths){
+            const sprintsAtDepth = sprintsByDepth.get(depth);
+            // Split into multiple waves if exceeds limit
+            for(let i = 0; i < sprintsAtDepth.length; i += maxParallelSprints){
+                const waveSprints = sprintsAtDepth.slice(i, i + maxParallelSprints);
+                waves.push({
+                    wave: waves.length + 1,
+                    sprints: waveSprints.map((s)=>s.sprintId),
+                    estimatedAgents: waveSprints.reduce((sum, s)=>sum + s.estimatedAgents, 0),
+                    estimatedMemoryMb: waveSprints.reduce((sum, s)=>sum + s.estimatedAgents * 150, 0) // ~150MB per agent
+                });
+            }
+        }
+        return waves;
+    }
+    /**
+   * Detect circular dependencies
+   */ detectCircularDependencies() {
+        const cycles = [];
+        const visited = new Set();
+        const recStack = new Set();
+        const detectCycle = (sprintId, path)=>{
+            visited.add(sprintId);
+            recStack.add(sprintId);
+            path.push(sprintId);
+            const node = this.graph.get(sprintId);
+            if (node) {
+                for (const depId of node.dependencies){
+                    if (!visited.has(depId)) {
+                        detectCycle(depId, [
+                            ...path
+                        ]);
+                    } else if (recStack.has(depId)) {
+                        // Cycle detected
+                        const cycleStart = path.indexOf(depId);
+                        cycles.push([
+                            ...path.slice(cycleStart),
+                            depId
+                        ]);
+                    }
+                }
+            }
+            recStack.delete(sprintId);
+        };
+        for (const sprintId of this.graph.keys()){
+            if (!visited.has(sprintId)) {
+                detectCycle(sprintId, []);
+            }
+        }
+        return cycles;
+    }
+    constructor(sprints){
+        _define_property(this, "graph", new Map());
+        this.buildGraph(sprints);
+    }
+};
+/**
+ * Parallel CFN Loop Coordinator
+ * Manages resource allocation, test slot queuing, and execution monitoring
+ */ let ParallelCFNLoopCoordinator = class ParallelCFNLoopCoordinator extends EventEmitter {
+    /**
+   * Execute sprints in parallel waves
+   */ async executeWaves(waves, sprints) {
+        const startTime = Date.now();
+        for (const wave of waves){
+            this.activeWave = wave.wave;
+            console.log(`\n🌊 Wave ${wave.wave}/${waves.length}: ${wave.sprints.length} sprints`);
+            console.log(`   Estimated: ${wave.estimatedAgents} agents, ${wave.estimatedMemoryMb}MB memory`);
+            // Check resource availability
+            if (wave.estimatedMemoryMb > this.resourcePool.availableMemoryMb) {
+                console.warn(`⚠️  Wave ${wave.wave} exceeds memory limit. Proceeding with caution...`);
+            }
+            // Execute sprints in wave concurrently
+            const wavePromises = wave.sprints.map((sprintId)=>{
+                const sprint = sprints.find((s)=>s.sprintId === sprintId);
+                if (!sprint) return Promise.resolve({
+                    success: false,
+                    sprintId
+                });
+                return this.executeSprint(sprint);
+            });
+            const results = await Promise.allSettled(wavePromises);
+            // Process results
+            for(let i = 0; i < results.length; i++){
+                const result = results[i];
+                const sprintId = wave.sprints[i];
+                if (result.status === 'fulfilled' && result.value.success) {
+                    this.completedSprints.add(sprintId);
+                    console.log(`   ✅ ${sprintId} completed`);
+                } else {
+                    this.failedSprints.add(sprintId);
+                    console.error(`   ❌ ${sprintId} failed`);
+                }
+            }
+            // Store wave completion in Redis
+            await this.redis.setex(`cfn:parallel:wave:${wave.wave}:status`, 3600, JSON.stringify({
+                wave: wave.wave,
+                completed: Array.from(this.completedSprints),
+                failed: Array.from(this.failedSprints),
+                timestamp: Date.now()
+            }));
+        }
+        const totalTime = Date.now() - startTime;
+        return {
+            completed: Array.from(this.completedSprints),
+            failed: Array.from(this.failedSprints),
+            totalTime
+        };
+    }
+    /**
+   * Execute single sprint with resource management
+   */ async executeSprint(sprint) {
+        // Allocate test slot
+        const testSlot = await this.acquireTestSlot(sprint.sprintId);
+        if (!testSlot) {
+            console.warn(`⚠️  ${sprint.sprintId}: Waiting for test slot...`);
+            await this.waitForTestSlot();
+        }
+        try {
+            // Store sprint state in Redis
+            await this.redis.setex(`cfn:parallel:sprint:${sprint.sprintId}:state`, 3600, JSON.stringify({
+                status: 'in-progress',
+                wave: this.activeWave,
+                startTime: Date.now(),
+                estimatedAgents: sprint.estimatedAgents
+            }));
+            // Emit start event
+            this.emit('sprint:start', {
+                sprintId: sprint.sprintId,
+                wave: this.activeWave
+            });
+            // Execute CFN Loop for sprint
+            // This would call the actual CFN Loop execution logic
+            const result = await this.executeCFNLoop(sprint);
+            // Update resource pool
+            this.resourcePool.activeAgents -= sprint.estimatedAgents;
+            // Emit completion event
+            this.emit('sprint:complete', {
+                sprintId: sprint.sprintId,
+                confidence: result.confidence,
+                wave: this.activeWave
+            });
+            return {
+                success: result.confidence >= 0.75,
+                sprintId: sprint.sprintId,
+                confidence: result.confidence
+            };
+        } catch (error) {
+            this.emit('sprint:error', {
+                sprintId: sprint.sprintId,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            });
+            return {
+                success: false,
+                sprintId: sprint.sprintId
+            };
+        } finally{
+            // Release test slot
+            await this.releaseTestSlot(sprint.sprintId);
+        }
+    }
+    /**
+   * Acquire test slot with queuing
+   */ async acquireTestSlot(sprintId) {
+        const slot = await this.redis.lpush('cfn:parallel:test-slot-queue', sprintId);
+        // Check if we're within limit
+        const queueLength = await this.redis.llen('cfn:parallel:test-slot-queue');
+        return queueLength <= (this.options.testSlots || 4);
+    }
+    /**
+   * Release test slot
+   */ async releaseTestSlot(sprintId) {
+        await this.redis.lrem('cfn:parallel:test-slot-queue', 1, sprintId);
+    }
+    /**
+   * Wait for available test slot
+   */ async waitForTestSlot() {
+        return new Promise((resolve)=>{
+            const checkInterval = setInterval(async ()=>{
+                const queueLength = await this.redis.llen('cfn:parallel:test-slot-queue');
+                if (queueLength < (this.options.testSlots || 4)) {
+                    clearInterval(checkInterval);
+                    resolve();
+                }
+            }, 1000);
+        });
+    }
+    /**
+   * Execute CFN Loop for sprint (stub - integrate with actual CFN Loop)
+   */ async executeCFNLoop(sprint) {
+        // This would integrate with the actual CFN Loop execution
+        // For now, return mock result
+        await new Promise((resolve)=>setTimeout(resolve, 2000));
+        return {
+            confidence: 0.85
+        };
+    }
+    async close() {
+        await this.redis.quit();
+    }
+    constructor(options, redisUrl = 'redis://localhost:6379'){
+        super(), _define_property(this, "options", void 0), _define_property(this, "redisUrl", void 0), _define_property(this, "redis", void 0), _define_property(this, "activeWave", void 0), _define_property(this, "completedSprints", void 0), _define_property(this, "failedSprints", void 0), _define_property(this, "resourcePool", void 0), this.options = options, this.redisUrl = redisUrl, this.activeWave = 0, this.completedSprints = new Set(), this.failedSprints = new Set();
+        this.redis = new Redis(redisUrl);
+        this.resourcePool = {
+            availableTestSlots: options.testSlots || 4,
+            availableMemoryMb: options.memoryLimitMb || 8192,
+            activeAgents: 0
+        };
+    }
+};
+/**
+ * CLI Command: cfn-loop-parallel
+ */ export function createParallelCFNLoopCommand() {
+    const command = new Command('cfn-loop-parallel');
+    command.description('Execute CFN Loop sprints in parallel with dependency management').argument('<epic-config>', 'Path to epic configuration JSON file').option('--parallel', 'Enable parallel execution (default: sequential)', false).option('--analyze-only', 'Only analyze dependencies without execution', false).option('--max-parallel-sprints <n>', 'Maximum concurrent sprints', '3').option('--max-agents-per-sprint <n>', 'Maximum agents per sprint', '10').option('--test-slots <n>', 'Number of concurrent test slots', '4').option('--memory-limit-mb <n>', 'Memory limit in MB', '8192').action(async (epicConfigPath, options)=>{
+        try {
+            // Load epic configuration
+            const fs = await import("node:fs/promises");
+            const epicConfig = JSON.parse(await fs.readFile(epicConfigPath, 'utf-8'));
+            const sprints = epicConfig.sprints || [];
+            console.log(`\n🚀 CFN Loop Parallel Execution`);
+            console.log(`   Epic: ${epicConfig.name || 'Unnamed Epic'}`);
+            console.log(`   Sprints: ${sprints.length}`);
+            console.log(`   Mode: ${options.parallel ? 'Parallel' : 'Sequential'}`);
+            // Analyze dependencies
+            const analyzer = new DependencyAnalyzer(sprints);
+            const cycles = analyzer.detectCircularDependencies();
+            if (cycles.length > 0) {
+                console.error('\n❌ Circular dependencies detected:');
+                cycles.forEach((cycle, i)=>{
+                    console.error(`   ${i + 1}. ${cycle.join(' → ')}`);
+                });
+                process.exit(1);
+            }
+            // Generate execution waves
+            const maxParallelSprints = parseInt(options.maxParallelSprints || '3');
+            const waves = analyzer.getExecutionWaves(sprints, maxParallelSprints);
+            console.log(`\n📊 Execution Plan:`);
+            console.log(`   Waves: ${waves.length}`);
+            waves.forEach((wave)=>{
+                console.log(`   Wave ${wave.wave}: ${wave.sprints.join(', ')}`);
+                console.log(`      → ${wave.estimatedAgents} agents, ~${wave.estimatedMemoryMb}MB`);
+            });
+            if (options.analyzeOnly) {
+                console.log('\n✅ Analysis complete (--analyze-only mode)');
+                return;
+            }
+            // Execute parallel coordination
+            if (options.parallel) {
+                const coordinator = new ParallelCFNLoopCoordinator(options);
+                // Monitor events
+                coordinator.on('sprint:start', (data)=>{
+                    console.log(`   🔄 Starting: ${data.sprintId} (Wave ${data.wave})`);
+                });
+                coordinator.on('sprint:complete', (data)=>{
+                    console.log(`   ✅ Completed: ${data.sprintId} (confidence: ${data.confidence})`);
+                });
+                coordinator.on('sprint:error', (data)=>{
+                    console.error(`   ❌ Error: ${data.sprintId} - ${data.error}`);
+                });
+                const result = await coordinator.executeWaves(waves, sprints);
+                console.log(`\n📊 Execution Summary:`);
+                console.log(`   Total Time: ${(result.totalTime / 1000).toFixed(2)}s`);
+                console.log(`   Completed: ${result.completed.length}/${sprints.length}`);
+                console.log(`   Failed: ${result.failed.length}`);
+                await coordinator.close();
+                if (result.failed.length > 0) {
+                    process.exit(1);
+                }
+            } else {
+                console.log('\n⚠️  Sequential mode not yet implemented');
+            }
+        } catch (error) {
+            console.error('❌ Error:', error instanceof Error ? error.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    return command;
+}
+/**
+ * CLI Command: cfn-loop-parallel-status
+ */ export function createParallelStatusCommand() {
+    const command = new Command('cfn-loop-parallel-status');
+    command.description('Monitor parallel CFN Loop execution status').option('--wave <n>', 'Show specific wave status').option('--sprint <id>', 'Show specific sprint status').option('--watch', 'Watch mode (auto-refresh)', false).action(async (options)=>{
+        const redis = new Redis('redis://localhost:6379');
+        const displayStatus = async ()=>{
+            console.clear();
+            console.log('🔍 CFN Loop Parallel Execution Status\n');
+            if (options.sprint) {
+                // Show specific sprint
+                const state = await redis.get(`cfn:parallel:sprint:${options.sprint}:state`);
+                if (state) {
+                    const data = JSON.parse(state);
+                    console.log(`Sprint: ${options.sprint}`);
+                    console.log(`Status: ${data.status}`);
+                    console.log(`Wave: ${data.wave}`);
+                    console.log(`Agents: ${data.estimatedAgents}`);
+                    console.log(`Started: ${new Date(data.startTime).toISOString()}`);
+                } else {
+                    console.log(`Sprint ${options.sprint} not found`);
+                }
+            } else if (options.wave) {
+                // Show specific wave
+                const state = await redis.get(`cfn:parallel:wave:${options.wave}:status`);
+                if (state) {
+                    const data = JSON.parse(state);
+                    console.log(`Wave: ${data.wave}`);
+                    console.log(`Completed: ${data.completed.join(', ')}`);
+                    console.log(`Failed: ${data.failed.join(', ')}`);
+                } else {
+                    console.log(`Wave ${options.wave} not found`);
+                }
+            } else {
+                // Show all active sprints
+                const keys = await redis.keys('cfn:parallel:sprint:*:state');
+                console.log(`Active Sprints: ${keys.length}\n`);
+                for (const key of keys){
+                    const state = await redis.get(key);
+                    if (state) {
+                        const data = JSON.parse(state);
+                        const sprintId = key.split(':')[3];
+                        console.log(`  ${sprintId}: ${data.status} (Wave ${data.wave})`);
+                    }
+                }
+                // Show test slot queue
+                const queueLength = await redis.llen('cfn:parallel:test-slot-queue');
+                console.log(`\nTest Slot Queue: ${queueLength} waiting`);
+            }
+            console.log(`\nLast Update: ${new Date().toISOString()}`);
+        };
+        if (options.watch) {
+            // Watch mode
+            const interval = setInterval(displayStatus, 2000);
+            displayStatus();
+            process.on('SIGINT', ()=>{
+                clearInterval(interval);
+                redis.quit();
+                process.exit(0);
+            });
+        } else {
+            await displayStatus();
+            await redis.quit();
+        }
+    });
+    return command;
+}
+export default {
+    createParallelCFNLoopCommand,
+    createParallelStatusCommand
+};

package/.claude-flow-novice/dist/src/cli/commands/index.js

@@ -14,6 +14,10 @@ import { sparcAction } from "./sparc.js";
 import { createMigrateCommand } from "./migrate.js";
 import { enterpriseCommands } from "./enterprise.js";
 import { createEnhancedClaudeMd } from "../simple-commands/init/templates/enhanced-templates.js";
+// Import CFN Loop recovery commands
+import { handleRecoveryStatus, handleRecoveryInspect, handleRecoveryResume, handleRecoveryRestart, handleRecoveryAbandon } from "./recovery-status.js";
+// Import agent lifecycle commands
+import { agentLifecycleCommand } from "./agent-lifecycle.js";
 let orchestrator = null;
 let configManager = null;
 let persistence = null;
@@ -2674,6 +2678,88 @@ Now, please proceed with the task: ${task}`;
     for (const command of enterpriseCommands){
         cli.command(command);
     }
+    // Add agent lifecycle command
+    cli.command(agentLifecycleCommand);
+    // Add CFN Loop recovery commands
+    cli.command({
+        name: "recovery",
+        description: "CFN Loop crash recovery management",
+        subcommands: [
+            {
+                name: "status",
+                description: "Show recovery dashboard for interrupted executions",
+                options: [
+                    {
+                        name: "detailed",
+                        short: "d",
+                        description: "Show detailed information",
+                        type: "boolean"
+                    }
+                ],
+                action: async (ctx)=>{
+                    await handleRecoveryStatus({
+                        detailed: ctx.flags.detailed
+                    });
+                }
+            },
+            {
+                name: "inspect",
+                description: "Detailed inspection of interrupted epic",
+                args: [
+                    {
+                        name: "epicId",
+                        description: "Epic ID to inspect",
+                        required: true
+                    }
+                ],
+                action: async (ctx)=>{
+                    await handleRecoveryInspect(ctx.args[0]);
+                }
+            },
+            {
+                name: "resume",
+                description: "Resume execution from latest checkpoint",
+                args: [
+                    {
+                        name: "epicId",
+                        description: "Epic ID to resume",
+                        required: true
+                    }
+                ],
+                action: async (ctx)=>{
+                    await handleRecoveryResume(ctx.args[0]);
+                }
+            },
+            {
+                name: "restart",
+                description: "Restart execution from beginning",
+                args: [
+                    {
+                        name: "epicId",
+                        description: "Epic ID to restart",
+                        required: true
+                    }
+                ],
+                action: async (ctx)=>{
+                    await handleRecoveryRestart(ctx.args[0]);
+                }
+            },
+            {
+                name: "abandon",
+                description: "Abandon execution and cleanup",
+                args: [
+                    {
+                        name: "epicId",
+                        description: "Epic ID to abandon",
+                        required: true
+                    }
+                ],
+                action: async (ctx)=>{
+                    await handleRecoveryAbandon(ctx.args[0]);
+                }
+            }
+        ]
+    });
 }
 function getCapabilitiesForType(type) {
     const capabilities = {

package/.claude-flow-novice/dist/src/cli/commands/parse-epic.js

@@ -4,7 +4,7 @@ import path from "path";
 import { Command } from "commander";
 import chalk from "chalk";
 import { EpicParser } from "../../parsers/epic-parser.js";
-export const parseEpicCommand = new Command().name('parse-epic').description('Parse epic markdown files into structured JSON configuration').argument('<epic-directory>', 'Path to epic directory containing EPIC_OVERVIEW.md and phase files').option('-o, --output <file>', 'Output file path (default: <epic-name>-config.json)').option('-v, --validate', 'Run validation and report errors without generating output').action(async (epicDirectory, options)=>{
+export const parseEpicCommand = new Command().name('parse-epic').description('Parse epic markdown files into structured JSON configuration').argument('<epic-directory>', 'Path to epic directory containing EPIC_OVERVIEW.md and phase files').option('-o, --output <file>', 'Output file path (default: <epic-name>-config.json)').option('-v, --validate', 'Run validation and report errors without generating output').option('--cfn-mode <mode>', 'CFN Loop mode: mvp, enterprise, standard, or auto (default: auto)', 'auto').action(async (epicDirectory, options)=>{
     await executeParseEpic(epicDirectory, options);
 });
 async function executeParseEpic(epicDirectory, options) {
@@ -44,6 +44,8 @@ async function executeParseEpic(epicDirectory, options) {
             console.error(chalk.red(error.message));
             process.exit(1);
         }
+        // Detect CFN Loop mode
+        const cfnMode = detectCFNMode(options.cfnMode, defaultOutputName, epicConfig);
         // Get validation result with stats
         const validation = parser.getValidationResult();
         // Display parsing results
@@ -52,6 +54,7 @@ async function executeParseEpic(epicDirectory, options) {
             console.log(chalk.white('   - Epic:'), chalk.cyan(epicConfig.epicId));
             console.log(chalk.white('   - Phases:'), chalk.cyan(validation.stats?.totalPhases || 0));
             console.log(chalk.white('   - Total Sprints:'), chalk.cyan(validation.stats?.totalSprints || 0));
+            console.log(chalk.white('   - CFN Mode:'), chalk.cyan(cfnMode.toUpperCase()));
             console.log(chalk.white('   - Scope boundaries:'), chalk.green('✓'));
             console.log(chalk.white('   - Dependencies:'), chalk.green('✓'));
             if (validation.stats?.completedSprints) {
@@ -89,11 +92,20 @@ async function executeParseEpic(epicDirectory, options) {
         // Generate output file path
         const defaultOutputName = `${epicConfig.epicId}-config.json`;
         const outputPath = options.output ? path.resolve(process.cwd(), options.output) : path.join(absoluteEpicDir, defaultOutputName);
+        // Add CFN mode metadata to epic config
+        const epicConfigWithMode = {
+            ...epicConfig,
+            metadata: {
+                ...epicConfig.metadata,
+                cfnMode: cfnMode
+            }
+        };
         // Write JSON to output file
         try {
-            await fs.writeFile(outputPath, JSON.stringify(epicConfig, null, 2), 'utf-8');
+            await fs.writeFile(outputPath, JSON.stringify(epicConfigWithMode, null, 2), 'utf-8');
             const relativeOutput = path.relative(process.cwd(), outputPath);
             console.log(chalk.white('📄 Output:'), chalk.cyan(relativeOutput));
+            console.log(chalk.white('📦 CFN Mode:'), chalk.cyan(cfnMode.toUpperCase()));
         } catch (error) {
             console.error(chalk.red('✗ Failed to write output file:'), error.message);
             process.exit(1);
@@ -120,6 +132,56 @@ async function executeParseEpic(epicDirectory, options) {
         process.exit(1);
     }
 }
+/**
+ * Detect CFN Loop mode from options, filename, or metadata
+ *
+ * Priority:
+ * 1. Explicit --cfn-mode flag (if not 'auto')
+ * 2. Filename pattern (e.g., "project-mvp.json")
+ * 3. Epic metadata
+ * 4. Default to standard
+ */ function detectCFNMode(optionMode, filename, epicConfig) {
+    // 1. Explicit mode (if not 'auto')
+    if (optionMode && optionMode !== 'auto' && [
+        'mvp',
+        'enterprise',
+        'standard'
+    ].includes(optionMode)) {
+        return optionMode;
+    }
+    // 2. Filename pattern detection
+    const lowerFilename = filename.toLowerCase();
+    if (lowerFilename.includes('-mvp') || lowerFilename.includes('_mvp') || lowerFilename.includes('.mvp')) {
+        return 'mvp';
+    }
+    if (lowerFilename.includes('-enterprise') || lowerFilename.includes('_enterprise') || lowerFilename.includes('.enterprise')) {
+        return 'enterprise';
+    }
+    // 3. Epic metadata detection
+    if (epicConfig.metadata) {
+        const metadata = epicConfig.metadata;
+        if (metadata.cfnMode && [
+            'mvp',
+            'enterprise',
+            'standard'
+        ].includes(metadata.cfnMode)) {
+            return metadata.cfnMode;
+        }
+        if (metadata.mode && [
+            'mvp',
+            'enterprise',
+            'standard'
+        ].includes(metadata.mode)) {
+            return metadata.mode;
+        }
+        if (metadata.quality) {
+            if (metadata.quality === 'mvp') return 'mvp';
+            if (metadata.quality === 'enterprise') return 'enterprise';
+        }
+    }
+    // 4. Default to standard
+    return 'standard';
+}
 // CLI execution when run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
     parseEpicCommand.parse(process.argv);