ai-sdlc 0.3.0 → 0.3.1-alpha.0-alpha.1

package/dist/cli/dependency-resolver.js

@@ -0,0 +1,133 @@
+/**
+ * Group stories into parallel execution phases based on dependencies.
+ * Uses iterative topological sort to identify stories that can run concurrently.
+ *
+ * @param stories - Array of stories to group
+ * @param preSatisfiedDeps - Optional set of dependency IDs that are already satisfied (e.g., done stories)
+ * @returns Array of phases, where each phase contains stories that can run in parallel
+ * @throws Error if circular dependencies detected
+ *
+ * @example
+ * // Stories: A -> B, A -> C, B -> D, C -> D
+ * // Returns: [[A], [B, C], [D]]
+ */
+export function groupStoriesByPhase(stories, preSatisfiedDeps) {
+    const phases = [];
+    const remaining = new Set(stories);
+    const completed = new Set(preSatisfiedDeps || []);
+    while (remaining.size > 0) {
+        // Find all stories whose dependencies are satisfied
+        const currentPhase = Array.from(remaining).filter(story => {
+            const deps = story.frontmatter.dependencies || [];
+            return deps.every(dep => completed.has(dep));
+        });
+        // If no stories can be processed, we have a circular dependency
+        if (currentPhase.length === 0) {
+            const cycle = detectCircularDependencies(Array.from(remaining));
+            throw new Error(`Circular dependency detected: ${cycle.join(' → ')}`);
+        }
+        phases.push(currentPhase);
+        // Mark current phase stories as completed
+        currentPhase.forEach(story => {
+            remaining.delete(story);
+            completed.add(story.frontmatter.id);
+        });
+    }
+    return phases;
+}
+/**
+ * Detect circular dependencies using depth-first search.
+ *
+ * @param stories - Array of stories to check
+ * @returns Array of story IDs forming the cycle, or empty array if no cycle
+ *
+ * @example
+ * // Stories: A -> B, B -> C, C -> A
+ * // Returns: ['S-001', 'S-002', 'S-003', 'S-001']
+ */
+export function detectCircularDependencies(stories) {
+    const storyMap = new Map();
+    stories.forEach(story => storyMap.set(story.frontmatter.id, story));
+    const visited = new Set();
+    const recursionStack = new Set();
+    const path = [];
+    function dfs(storyId) {
+        if (recursionStack.has(storyId)) {
+            // Found a cycle - return the path from cycle start to current
+            const cycleStart = path.indexOf(storyId);
+            return [...path.slice(cycleStart), storyId];
+        }
+        if (visited.has(storyId)) {
+            return null; // Already processed this branch
+        }
+        visited.add(storyId);
+        recursionStack.add(storyId);
+        path.push(storyId);
+        const story = storyMap.get(storyId);
+        if (story) {
+            const deps = story.frontmatter.dependencies || [];
+            for (const dep of deps) {
+                const cycle = dfs(dep);
+                if (cycle) {
+                    return cycle;
+                }
+            }
+        }
+        recursionStack.delete(storyId);
+        path.pop();
+        return null;
+    }
+    // Check all stories as starting points
+    for (const story of stories) {
+        const cycle = dfs(story.frontmatter.id);
+        if (cycle) {
+            return cycle;
+        }
+    }
+    return [];
+}
+/**
+ * Validate that all story dependencies are satisfied.
+ * Checks for missing dependencies and circular references.
+ *
+ * @param stories - Array of stories to validate
+ * @param preSatisfiedDeps - Optional set of dependency IDs that are already satisfied (e.g., done stories)
+ * @returns Validation result with errors if any
+ *
+ * @example
+ * const result = validateDependencies(stories);
+ * if (!result.valid) {
+ *   console.error(result.errors);
+ * }
+ */
+export function validateDependencies(stories, preSatisfiedDeps) {
+    const errors = [];
+    const storyIds = new Set(stories.map(s => s.frontmatter.id));
+    const satisfiedDeps = preSatisfiedDeps || new Set();
+    // Check for missing dependencies (excluding pre-satisfied ones like done stories)
+    for (const story of stories) {
+        const deps = story.frontmatter.dependencies || [];
+        for (const dep of deps) {
+            if (!storyIds.has(dep) && !satisfiedDeps.has(dep)) {
+                errors.push(`Story ${story.frontmatter.id} depends on ${dep}, but ${dep} is not in the epic`);
+            }
+        }
+    }
+    // Only check for circular dependencies if all dependencies exist
+    // (missing dependencies will cause groupStoriesByPhase to fail with misleading error)
+    if (errors.length === 0) {
+        try {
+            groupStoriesByPhase(stories, preSatisfiedDeps);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                errors.push(error.message);
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+//# sourceMappingURL=dependency-resolver.js.map

package/dist/cli/dependency-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-resolver.js","sourceRoot":"","sources":["../../src/cli/dependency-resolver.ts"],"names":[],"mappings":"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"}

package/dist/cli/epic-processor.d.ts

@@ -0,0 +1,16 @@
+import { Story, EpicProcessingOptions } from '../types/index.js';
+/**
+ * Normalize epic ID by stripping 'epic-' prefix if present
+ * Both 'epic-foo' and 'foo' become 'foo'
+ */
+export declare function normalizeEpicId(epicId: string): string;
+/**
+ * Discover stories for an epic with normalized ID
+ * Filters out stories that are already done
+ */
+export declare function discoverEpicStories(sdlcRoot: string, epicId: string): Story[];
+/**
+ * Main epic processing function
+ */
+export declare function processEpic(options: EpicProcessingOptions): Promise<number>;
+//# sourceMappingURL=epic-processor.d.ts.map

package/dist/cli/epic-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epic-processor.d.ts","sourceRoot":"","sources":["../../src/cli/epic-processor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,qBAAqB,EAA6C,MAAM,mBAAmB,CAAC;AAoB5G;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,EAAE,CAc7E;AAgXD;;GAEG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,CA0MjF"}

package/dist/cli/epic-processor.js

@@ -0,0 +1,489 @@
+import path from 'path';
+import { spawn } from 'child_process';
+import { getSdlcRoot, loadConfig, validateWorktreeBasePath, DEFAULT_MERGE_CONFIG } from '../core/config.js';
+import { findStoriesByEpic } from '../core/kanban.js';
+import { GitWorktreeService } from '../core/worktree.js';
+import { getThemedChalk } from '../core/theme.js';
+import { groupStoriesByPhase, validateDependencies } from './dependency-resolver.js';
+import { createDashboard, updateStoryStatus, markStorySkipped, markStoryFailed, advancePhase, startDashboardRenderer, } from './progress-dashboard.js';
+import { StoryLogger } from '../core/story-logger.js';
+import { parseStory, isPRMerged, markPRMerged } from '../core/story.js';
+import { waitForChecks, mergePullRequest } from '../agents/review.js';
+import fs from 'fs';
+/**
+ * Normalize epic ID by stripping 'epic-' prefix if present
+ * Both 'epic-foo' and 'foo' become 'foo'
+ */
+export function normalizeEpicId(epicId) {
+    return epicId.startsWith('epic-') ? epicId.slice(5) : epicId;
+}
+/**
+ * Discover stories for an epic with normalized ID
+ * Filters out stories that are already done
+ */
+export function discoverEpicStories(sdlcRoot, epicId) {
+    const normalized = normalizeEpicId(epicId);
+    const stories = findStoriesByEpic(sdlcRoot, normalized);
+    // Filter out stories that are already done
+    const activeStories = stories.filter(story => story.frontmatter.status !== 'done');
+    // Sort by priority (ascending) then created date (ascending)
+    return activeStories.sort((a, b) => {
+        if (a.frontmatter.priority !== b.frontmatter.priority) {
+            return a.frontmatter.priority - b.frontmatter.priority;
+        }
+        return a.frontmatter.created.localeCompare(b.frontmatter.created);
+    });
+}
+/**
+ * Format execution plan for display
+ */
+function formatExecutionPlan(epicId, phases) {
+    const lines = [];
+    const totalStories = phases.reduce((sum, phase) => sum + phase.length, 0);
+    lines.push(`\nFound ${totalStories} stories for epic: ${epicId}\n`);
+    phases.forEach((phase, index) => {
+        const phaseNum = index + 1;
+        const storyCount = phase.length;
+        const parallelNote = storyCount > 1 ? ', parallel' : '';
+        lines.push(`Phase ${phaseNum} (${storyCount} ${storyCount === 1 ? 'story' : 'stories'}${parallelNote}):`);
+        phase.forEach(story => {
+            const deps = story.frontmatter.dependencies || [];
+            const depsStr = deps.length > 0 ? ` (depends: ${deps.join(', ')})` : '';
+            lines.push(`  • ${story.frontmatter.id}: ${story.frontmatter.title}${depsStr}`);
+        });
+        lines.push('');
+    });
+    // Estimate time (rough: 15-30 min per story, parallelized)
+    const estimatedMinutes = phases.length * 15; // Very rough estimate
+    lines.push(`Estimated time: ${estimatedMinutes}-${estimatedMinutes * 2} minutes`);
+    return lines.join('\n');
+}
+/**
+ * Merge a story's PR after successful completion
+ * Waits for CI checks to pass before merging
+ */
+async function mergeStoryPR(storyId, worktreePath, config, logger) {
+    const mergeConfig = config.merge ?? DEFAULT_MERGE_CONFIG;
+    if (!mergeConfig.enabled) {
+        logger.log('DEBUG', 'PR merge is disabled in config');
+        return { success: true };
+    }
+    // Load the story from the worktree to get pr_url
+    const sdlcRoot = path.join(worktreePath, config.sdlcFolder);
+    const storyPath = path.join(sdlcRoot, 'stories', storyId, 'story.md');
+    if (!fs.existsSync(storyPath)) {
+        logger.log('WARN', `Story file not found in worktree: ${storyPath}`);
+        return { success: true }; // Not a failure - story might not have a PR
+    }
+    let story;
+    try {
+        story = parseStory(storyPath);
+    }
+    catch (error) {
+        logger.log('ERROR', `Failed to parse story: ${error}`);
+        return { success: false, error: `Failed to parse story: ${error}` };
+    }
+    // Check if story has a PR URL
+    const prUrl = story.frontmatter.pr_url;
+    if (!prUrl) {
+        logger.log('DEBUG', 'Story has no PR URL, skipping merge');
+        return { success: true };
+    }
+    // Check if already merged
+    if (isPRMerged(story)) {
+        logger.log('DEBUG', 'PR already merged');
+        return { success: true };
+    }
+    logger.log('INFO', `Waiting for CI checks on PR: ${prUrl}`);
+    // Wait for CI checks to pass
+    const checksResult = await waitForChecks(prUrl, worktreePath, {
+        timeout: mergeConfig.checksTimeout,
+        pollingInterval: mergeConfig.checksPollingInterval,
+        requireAllChecksPassing: mergeConfig.requireAllChecksPassing,
+    });
+    if (!checksResult.allPassed) {
+        if (checksResult.timedOut) {
+            logger.log('WARN', `CI checks timed out after ${mergeConfig.checksTimeout}ms`);
+            return { success: false, error: 'CI checks timed out - manual merge required' };
+        }
+        logger.log('ERROR', `CI checks failed: ${checksResult.error}`);
+        return { success: false, error: checksResult.error || 'CI checks failed' };
+    }
+    logger.log('INFO', 'CI checks passed, merging PR');
+    // Merge the PR
+    const mergeResult = await mergePullRequest(prUrl, worktreePath, {
+        strategy: mergeConfig.strategy,
+        deleteBranchAfterMerge: mergeConfig.deleteBranchAfterMerge,
+    });
+    if (!mergeResult.success) {
+        logger.log('ERROR', `PR merge failed: ${mergeResult.error}`);
+        return { success: false, error: mergeResult.error || 'PR merge failed' };
+    }
+    logger.log('INFO', `PR merged successfully${mergeResult.mergeSha ? ` (SHA: ${mergeResult.mergeSha})` : ''}`);
+    // Update story with merge metadata
+    try {
+        await markPRMerged(story, mergeResult.mergeSha);
+        logger.log('DEBUG', 'Updated story with merge metadata');
+    }
+    catch (error) {
+        // Log but don't fail - the merge succeeded
+        logger.log('WARN', `Failed to update story with merge metadata: ${error}`);
+    }
+    return { success: true };
+}
+/**
+ * Process a single story in an isolated worktree
+ */
+async function processStoryInWorktree(story, dashboard, worktreeService, keepWorktrees, config) {
+    const storyId = story.frontmatter.id;
+    const slug = story.frontmatter.slug;
+    updateStoryStatus(dashboard, storyId, 'in-progress');
+    try {
+        // Create worktree
+        const worktreePath = worktreeService.create({
+            storyId,
+            slug,
+        });
+        // Verify worktree was created
+        if (!fs.existsSync(worktreePath)) {
+            const error = `Worktree creation failed: ${worktreePath} does not exist`;
+            markStoryFailed(dashboard, storyId, error);
+            return { success: false, error };
+        }
+        // Log to story-specific epic run log
+        const sdlcRoot = getSdlcRoot();
+        const logger = new StoryLogger(storyId, sdlcRoot);
+        logger.log('INFO', `Starting story execution in worktree: ${worktreePath}`);
+        // Spawn ai-sdlc run process in worktree
+        // Use the same invocation method as the current process (handles global install, npx, or dev mode)
+        // Use --no-worktree since we're already in an isolated worktree
+        const result = await new Promise((resolve) => {
+            const proc = spawn(process.execPath, [process.argv[1], 'run', '--story', storyId, '--auto', '--no-worktree'], {
+                cwd: worktreePath,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: false,
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (code) => {
+                // Log subprocess output for debugging
+                if (stdout.trim()) {
+                    logger.log('DEBUG', `Subprocess stdout:\n${stdout}`);
+                }
+                if (stderr.trim()) {
+                    logger.log('DEBUG', `Subprocess stderr:\n${stderr}`);
+                }
+                if (code === 0) {
+                    logger.log('INFO', 'Story execution completed successfully');
+                    resolve({ success: true });
+                }
+                else {
+                    const error = `Process exited with code ${code}`;
+                    logger.log('ERROR', `Story execution failed: ${error}\n${stderr}`);
+                    resolve({ success: false, error });
+                }
+            });
+            proc.on('error', (err) => {
+                logger.log('ERROR', `Failed to spawn process: ${err.message}`);
+                resolve({ success: false, error: err.message });
+            });
+        });
+        // If execution succeeded, attempt PR merge (if enabled)
+        if (result.success && config.merge?.enabled) {
+            const mergeResult = await mergeStoryPR(storyId, worktreePath, config, logger);
+            if (!mergeResult.success) {
+                // Merge failure is a story failure
+                result.success = false;
+                result.error = mergeResult.error || 'PR merge failed';
+                logger.log('ERROR', `Story failed due to merge failure: ${result.error}`);
+            }
+        }
+        // Cleanup worktree if not keeping
+        if (!keepWorktrees) {
+            try {
+                // Use force cleanup after successful merge since branch may be deleted
+                const forceCleanup = result.success && config.merge?.enabled && config.merge?.deleteBranchAfterMerge;
+                worktreeService.remove(worktreePath, forceCleanup);
+            }
+            catch (cleanupError) {
+                // Log but don't fail the story
+                logger.log('WARN', `Failed to cleanup worktree: ${cleanupError}`);
+            }
+        }
+        if (result.success) {
+            updateStoryStatus(dashboard, storyId, 'completed');
+        }
+        else {
+            markStoryFailed(dashboard, storyId, result.error || 'Unknown error');
+        }
+        return result;
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        markStoryFailed(dashboard, storyId, errorMsg);
+        return { success: false, error: errorMsg };
+    }
+}
+/**
+ * Execute a single phase with concurrency limit
+ */
+async function executePhase(phase, phaseNumber, maxConcurrent, dashboard, worktreeService, keepWorktrees, config) {
+    const result = {
+        phase: phaseNumber,
+        succeeded: [],
+        failed: [],
+        skipped: [],
+    };
+    const queue = [...phase];
+    const active = new Set();
+    while (queue.length > 0 || active.size > 0) {
+        // Fill up to maxConcurrent
+        while (active.size < maxConcurrent && queue.length > 0) {
+            const story = queue.shift();
+            const promise = processStoryInWorktree(story, dashboard, worktreeService, keepWorktrees, config)
+                .then(result => ({
+                storyId: story.frontmatter.id,
+                ...result,
+            }));
+            active.add(promise);
+            // Remove from active when done
+            promise.finally(() => active.delete(promise));
+        }
+        if (active.size > 0) {
+            // Wait for at least one to complete
+            const completed = await Promise.race(active);
+            if (completed.success) {
+                result.succeeded.push(completed.storyId);
+            }
+            else {
+                result.failed.push(completed.storyId);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Generate final epic summary
+ */
+function generateEpicSummary(epicId, phases, phaseResults, failedStories, skippedStories, startTime) {
+    const totalStories = phases.reduce((sum, phase) => sum + phase.length, 0);
+    const completed = phaseResults.reduce((sum, r) => sum + r.succeeded.length, 0);
+    const failed = Array.from(failedStories.keys()).length;
+    const skipped = Array.from(skippedStories.keys()).length;
+    return {
+        epicId,
+        totalStories,
+        completed,
+        failed,
+        skipped,
+        duration: Date.now() - startTime,
+        failedStories: Array.from(failedStories.entries()).map(([storyId, error]) => ({
+            storyId,
+            error,
+        })),
+        skippedStories: Array.from(skippedStories.entries()).map(([storyId, reason]) => ({
+            storyId,
+            reason,
+        })),
+    };
+}
+/**
+ * Print epic summary to console
+ */
+function printEpicSummary(summary, chalk) {
+    console.log('\n' + chalk.bold('═══ Epic Summary ═══'));
+    console.log(`\nEpic: ${chalk.bold(summary.epicId)}`);
+    console.log('');
+    if (summary.completed > 0) {
+        console.log(chalk.success(`✓ Completed: ${summary.completed} ${summary.completed === 1 ? 'story' : 'stories'}`));
+    }
+    if (summary.failed > 0) {
+        console.log(chalk.error(`✗ Failed: ${summary.failed} ${summary.failed === 1 ? 'story' : 'stories'}`));
+        summary.failedStories.forEach(({ storyId, error }) => {
+            console.log(chalk.error(`  • ${storyId}: ${error}`));
+        });
+    }
+    if (summary.skipped > 0) {
+        console.log(chalk.warning(`⊘ Skipped: ${summary.skipped} ${summary.skipped === 1 ? 'story' : 'stories'} (dependencies failed)`));
+        summary.skippedStories.forEach(({ storyId, reason }) => {
+            console.log(chalk.dim(`  • ${storyId}: ${reason}`));
+        });
+    }
+    const durationSeconds = Math.floor(summary.duration / 1000);
+    const minutes = Math.floor(durationSeconds / 60);
+    const seconds = durationSeconds % 60;
+    console.log('');
+    console.log(`Duration: ${minutes}m ${seconds}s`);
+    console.log('');
+}
+/**
+ * Main epic processing function
+ */
+export async function processEpic(options) {
+    const config = loadConfig();
+    const c = getThemedChalk(config);
+    const sdlcRoot = getSdlcRoot();
+    const projectRoot = process.cwd();
+    // Validate worktrees enabled
+    if (!config.worktree?.enabled) {
+        console.log(c.error('Error: Epic processing requires worktrees to be enabled'));
+        console.log(c.dim('Set "worktree.enabled": true in .ai-sdlc.json'));
+        return 1;
+    }
+    // Get effective configuration
+    const maxConcurrent = options.maxConcurrent ?? config.epic?.maxConcurrent ?? 3;
+    const keepWorktrees = options.keepWorktrees ?? config.epic?.keepWorktrees ?? false;
+    const continueOnFailure = config.epic?.continueOnFailure ?? true;
+    // Apply CLI overrides for merge config
+    if (options.merge !== undefined) {
+        config.merge = config.merge ?? { ...DEFAULT_MERGE_CONFIG };
+        config.merge.enabled = options.merge;
+    }
+    if (options.mergeStrategy !== undefined) {
+        config.merge = config.merge ?? { ...DEFAULT_MERGE_CONFIG };
+        config.merge.strategy = options.mergeStrategy;
+    }
+    // Validate maxConcurrent
+    if (maxConcurrent < 1) {
+        console.log(c.error('Error: --max-concurrent must be >= 1'));
+        return 1;
+    }
+    // Discover stories (active only - done stories are filtered out)
+    console.log(c.info(`Discovering stories for epic: ${options.epicId}`));
+    const stories = discoverEpicStories(sdlcRoot, options.epicId);
+    // Also get done story IDs to treat as pre-satisfied dependencies
+    const normalized = normalizeEpicId(options.epicId);
+    const allEpicStories = findStoriesByEpic(sdlcRoot, normalized);
+    const doneStoryIds = new Set(allEpicStories
+        .filter(s => s.frontmatter.status === 'done')
+        .map(s => s.frontmatter.id));
+    if (stories.length === 0) {
+        if (doneStoryIds.size > 0) {
+            console.log(c.success(`All ${doneStoryIds.size} stories in epic are already done!`));
+        }
+        else {
+            console.log(c.warning(`No stories found for epic: ${options.epicId}`));
+        }
+        return 0; // Not an error
+    }
+    // Validate dependencies (done stories count as satisfied)
+    const validation = validateDependencies(stories, doneStoryIds);
+    if (!validation.valid) {
+        console.log(c.error('Error: Invalid dependencies detected:'));
+        validation.errors.forEach(error => console.log(c.error(`  • ${error}`)));
+        return 1;
+    }
+    // Group into phases (done stories count as already completed)
+    const phases = groupStoriesByPhase(stories, doneStoryIds);
+    // Display execution plan
+    console.log(formatExecutionPlan(options.epicId, phases));
+    // Dry run - stop here
+    if (options.dryRun) {
+        console.log(c.info('\nDry run complete - no stories executed'));
+        return 0;
+    }
+    // Confirm execution (unless --force)
+    if (!options.force) {
+        console.log(c.warning('\nContinue? [Y/n] '));
+        // For now, assume yes in automated context
+        // TODO: Add actual prompt in interactive mode
+    }
+    // Initialize worktree service with resolved basePath
+    let resolvedBasePath;
+    try {
+        resolvedBasePath = validateWorktreeBasePath(config.worktree.basePath, projectRoot);
+    }
+    catch (error) {
+        console.log(c.error(`Configuration Error: ${error instanceof Error ? error.message : String(error)}`));
+        return 1;
+    }
+    const worktreeService = new GitWorktreeService(projectRoot, resolvedBasePath);
+    // Create dashboard
+    const dashboard = createDashboard(options.epicId, phases);
+    const stopRenderer = startDashboardRenderer(dashboard);
+    const startTime = Date.now();
+    const failedStories = new Map();
+    const skippedStories = new Map();
+    const phaseResults = [];
+    try {
+        // Execute phases sequentially
+        for (let i = 0; i < phases.length; i++) {
+            const phase = phases[i];
+            // Check if any stories in this phase should be skipped due to failed or unmerged dependencies
+            const phaseToExecute = phase.filter(story => {
+                const deps = story.frontmatter.dependencies || [];
+                // Check for failed dependencies
+                const hasFailedDep = deps.some(dep => failedStories.has(dep));
+                if (hasFailedDep) {
+                    const failedDep = deps.find(dep => failedStories.has(dep));
+                    const reason = `Dependency failed: ${failedDep}`;
+                    markStorySkipped(dashboard, story.frontmatter.id, reason);
+                    skippedStories.set(story.frontmatter.id, reason);
+                    return false;
+                }
+                // If merge is enabled, check for unmerged dependencies
+                // A dependency is unmerged if it has a pr_url but pr_merged !== true
+                if (config.merge?.enabled) {
+                    for (const depId of deps) {
+                        // Skip done stories (already validated) and failed stories (handled above)
+                        if (doneStoryIds.has(depId) || failedStories.has(depId))
+                            continue;
+                        // Check if this dependency story has been completed in this run
+                        const depCompleted = phaseResults.some(pr => pr.succeeded.includes(depId));
+                        if (!depCompleted)
+                            continue;
+                        // Try to load the dependency story to check merge status
+                        try {
+                            const depStoryPath = path.join(sdlcRoot, 'stories', depId, 'story.md');
+                            if (fs.existsSync(depStoryPath)) {
+                                const depStory = parseStory(depStoryPath);
+                                if (depStory.frontmatter.pr_url && !isPRMerged(depStory)) {
+                                    const reason = `Waiting for dependency merge: ${depId}`;
+                                    markStorySkipped(dashboard, story.frontmatter.id, reason);
+                                    skippedStories.set(story.frontmatter.id, reason);
+                                    return false;
+                                }
+                            }
+                        }
+                        catch {
+                            // If we can't read the story, skip this check
+                        }
+                    }
+                }
+                return true;
+            });
+            // Skip phase if all stories are blocked
+            if (phaseToExecute.length === 0) {
+                continue;
+            }
+            // Execute phase
+            const result = await executePhase(phaseToExecute, i + 1, maxConcurrent, dashboard, worktreeService, keepWorktrees, config);
+            phaseResults.push(result);
+            // Track failed stories
+            result.failed.forEach(storyId => {
+                failedStories.set(storyId, 'Execution failed');
+            });
+            // Stop on failure if not continuing
+            if (!continueOnFailure && result.failed.length > 0) {
+                console.log(c.error('\nStopping due to failure (continueOnFailure = false)'));
+                break;
+            }
+            advancePhase(dashboard);
+        }
+    }
+    finally {
+        stopRenderer();
+    }
+    // Generate and print summary
+    const summary = generateEpicSummary(options.epicId, phases, phaseResults, failedStories, skippedStories, startTime);
+    printEpicSummary(summary, c);
+    // Return exit code
+    return summary.failed > 0 ? 1 : 0;
+}
+//# sourceMappingURL=epic-processor.js.map