@haoyiyin/workflow 0.2.10 → 0.3.0

package/dist/src/skills/execute-plan/index.js

@@ -1,15 +1,18 @@
 /**
- * Enhanced Execute Plan Skill - Orchestrates TDD and Review skills
+ * Execute Plan Skill - Orchestrates plan execution with persistence integration
  *
  * Architecture: Orchestrator pattern
- * - Executes waves sequentially
- * - Each task uses TDD skill (RED/GREEN/REFACTOR)
- * - Verification uses review-diff skill
- * - Lifecycle managed via hooks
- * - Task-level worktree isolation via worktreeContract subagent
+ * - Reads PLAN.md from PlanMdManager
+ * - Reads/updates STATE.md for progress tracking
+ * - Executes waves sequentially, tasks within wave in parallel
+ * - Each task dispatches implementer subagent with fresh context
+ * - After each wave: updates STATE.md with completed tasks
+ * - After all waves: runs verification subagents (goals, quality, tests)
+ * - Updates final state based on verification results
  */
 import { z } from 'zod';
 import { Skill } from '../skill.js';
+import { implementerContract, verifierContract, reviewerContract } from '../../agents/contracts.js';
 // HookType constants (avoiding enum import issues)
 const HookType = {
     PRE_EXECUTE: 'pre-execute',
@@ -24,87 +27,93 @@ const HookType = {
     WAVE_START: 'wave-start',
     WAVE_COMPLETE: 'wave-complete',
 };
-import { worktreeContract } from '../../agents/contracts.js';
 const ExecuteInputSchema = z.object({
-    plan: z.any(),
-    waves: z.array(z.any()),
+    model: z.string().optional(),
     skipVerify: z.boolean().optional(),
-    model: z.string().optional()
+    continueFromState: z.boolean().optional(),
 });
 const ExecuteOutputSchema = z.object({
     success: z.boolean(),
     results: z.array(z.any()),
     verification: z.any(),
     wavesCompleted: z.number(),
-    totalWaves: z.number()
+    totalWaves: z.number(),
 });
 export class ExecutePlanSkill extends Skill {
     constructor() {
         super({
             name: 'execute-plan',
-            description: 'Orchestrate plan execution with task-level worktree isolation using TDD skill and review-diff for verification',
-            requires: ['tdd', 'review-diff']
+            description: 'Execute plan from PLAN.md with STATE.md tracking, parallel task execution, and verification',
+            requires: []
         });
     }
     async execute(input, context) {
-        const { plan, waves } = input;
         const results = [];
         let wavesCompleted = 0;
-        // 1. Update state
-        if (context.persistence) {
-            await context.persistence.state.updatePhase('executing');
+        // 1. Read PLAN.md from PlanMdManager
+        if (!context.persistence) {
+            throw new Error('Persistence manager required for execute-plan skill');
         }
-        // 2. Trigger pre-execute hooks
-        await this.triggerHook(context, HookType.PRE_EXECUTE, { plan, waves });
+        const plan = await context.persistence.plan.readPlan();
+        if (!plan) {
+            throw new Error('No PLAN.md found. Run plan skill first.');
+        }
+        // 2. Read STATE.md for current progress
+        const currentState = await context.persistence.state.readCurrentState();
+        console.log(`\n[ExecutePlanSkill] Goal: ${plan.goal}`);
+        console.log(`[ExecutePlanSkill] Current phase: ${currentState.phase}`);
+        console.log(`[ExecutePlanSkill] Total waves: ${plan.waves.length}, Tasks: ${plan.tasks.length}`);
+        // Update state to executing phase
+        await context.persistence.state.updatePhase('executing');
+        // 3. Trigger pre-execute hooks
+        await this.triggerHook(context, HookType.PRE_EXECUTE, { plan, state: currentState });
         try {
-            // 3. Execute waves sequentially
-            for (const wave of waves) {
+            // Determine starting point if continuing from state
+            let startWaveIndex = 0;
+            if (input.continueFromState && currentState.completedTasks.length > 0) {
+                startWaveIndex = this.findNextWaveIndex(plan, currentState.completedTasks);
+                console.log(`[ExecutePlanSkill] Resuming from wave ${startWaveIndex + 1}`);
+            }
+            // 4. Execute waves sequentially
+            for (let i = startWaveIndex; i < plan.waves.length; i++) {
+                const wave = plan.waves[i];
                 console.log(`\n[ExecutePlanSkill] Wave ${wave.id}: ${wave.tasks.length} tasks`);
                 // Trigger wave start hooks
-                await this.triggerHook(context, HookType.WAVE_START, { wave, plan });
-                // Execute wave using TDD skill for each task
-                const waveResults = await this.executeWaveWithTDD(wave, plan, input.model, context);
-                results.push(...waveResults);
-                // Update state with completed tasks
-                if (context.persistence) {
-                    for (const result of waveResults) {
-                        await context.persistence.state.recordTaskComplete(result.taskId, result);
-                    }
-                }
-                // Merge task worktrees back to main branch
-                const successfulResults = waveResults.filter(r => r.success && r.branchName);
-                let mergeResult = { merged: [], conflicts: [], manualResolution: [] };
-                if (successfulResults.length > 0) {
-                    mergeResult = await this.mergeTaskWorktrees(successfulResults, context);
-                    // Report merge status
-                    if (mergeResult.conflicts.length > 0) {
-                        console.warn(`  [Merge] Auto-resolved conflicts in: ${mergeResult.conflicts.join(', ')}`);
+                await this.triggerHook(context, HookType.WAVE_START, { wave, plan, waveIndex: i });
+                // Execute wave with parallel tasks
+                const waveResult = await this.executeWave(wave, plan, input.model, context);
+                results.push(...waveResult.results);
+                // 5. After each wave: update STATE.md with completed tasks
+                for (const taskResult of waveResult.results) {
+                    if (taskResult.success) {
+                        await context.persistence.state.recordTaskComplete(taskResult.taskId, taskResult);
+                        await context.persistence.plan.updateTaskStatus(taskResult.taskId, 'complete');
                     }
-                    if (mergeResult.manualResolution.length > 0) {
-                        console.error(`  [Merge] Needs manual resolution: ${mergeResult.manualResolution.join(', ')}`);
+                    else {
+                        await context.persistence.state.recordTaskFailed(taskResult.taskId, taskResult.error);
+                        await context.persistence.plan.updateTaskStatus(taskResult.taskId, 'pending');
                     }
                 }
-                // Trigger wave complete hooks (with merge info)
+                // Trigger wave complete hooks
                 await this.triggerHook(context, HookType.WAVE_COMPLETE, {
                     wave,
-                    results: waveResults,
-                    plan,
-                    mergeResult
+                    results: waveResult.results,
+                    plan
                 });
                 wavesCompleted++;
-                // Check for failures - fail-fast
-                const failedTasks = waveResults.filter(r => !r.success);
-                if (failedTasks.length > 0) {
-                    console.error(`[ExecutePlanSkill] Wave ${wave.id} failed:`, failedTasks.map(t => t.taskId));
-                    await this.handleWaveFailure(wave, failedTasks, context);
+                // Error handling for wave failures
+                if (!waveResult.success) {
+                    await this.handleWaveFailure(wave, waveResult.results, context);
+                    // Fail-fast: stop execution on wave failure
+                    console.error(`[ExecutePlanSkill] Wave ${wave.id} failed, stopping execution`);
                     break;
                 }
                 console.log(`[ExecutePlanSkill] Wave ${wave.id} complete ✓`);
             }
-            // 4. Run verification using review-diff skill
+            // 6. After all waves: run verification subagents (goals, quality, tests)
             let verification;
-            if (!input.skipVerify && wavesCompleted === waves.length) {
-                verification = await this.runVerificationWithReviewDiff(plan, results, context);
+            if (!input.skipVerify && wavesCompleted === plan.waves.length) {
+                verification = await this.runVerification(plan, results, context);
             }
             else {
                 verification = {
@@ -114,166 +123,215 @@ export class ExecutePlanSkill extends Skill {
                     }
                 };
             }
-            // 5. Update final state
-            const finalPhase = verification.success ? 'complete' : 'verifying';
-            if (context.persistence) {
-                await context.persistence.state.updatePhase(finalPhase);
-                await context.persistence.state.recordVerification(verification);
-            }
-            // 6. Trigger post-execute hooks
+            // 7. Update final state based on verification results
+            const finalPhase = verification.success ? 'completed' : 'failed';
+            await context.persistence.state.updatePhase(finalPhase);
+            await context.persistence.state.recordVerification(verification);
+            // 8. Trigger post-execute hooks
             await this.triggerHook(context, HookType.POST_EXECUTE, {
                 results,
                 verification,
                 wavesCompleted,
-                totalWaves: waves.length
+                totalWaves: plan.waves.length
             });
             return {
                 success: results.every(r => r.success) && verification.success,
                 results,
                 verification,
                 wavesCompleted,
-                totalWaves: waves.length
+                totalWaves: plan.waves.length
             };
         }
         catch (error) {
-            // Trigger error hooks
+            // Trigger error hooks and update state
             await this.triggerHook(context, HookType.ON_ERROR, {
                 phase: 'execute',
                 error: error.message,
                 results
             });
+            // Update state to failed
+            await context.persistence.state.updatePhase('failed');
             throw error;
         }
     }
     /**
-     * Execute a wave using TDD skill for each task
-     * Parallel execution with Promise.allSettled
+     * Find the next wave index based on completed tasks
      */
-    async executeWaveWithTDD(wave, plan, model, context) {
-        // Get TDD skill from registry
-        const tddSkill = context.skills.get('tdd');
-        if (!tddSkill) {
-            throw new Error('TDD skill not found in registry');
-        }
-        // Prepare task contexts
-        const taskConfigs = wave.tasks.map(taskId => {
-            const task = plan.tasks.find(t => t.id === taskId);
-            if (!task)
-                throw new Error(`Task not found: ${taskId}`);
-            return { taskId, task };
-        });
-        // Execute all tasks in parallel using TDD skill
-        const promises = taskConfigs.map(async ({ taskId, task }) => {
-            try {
-                // Trigger task start hooks
-                await this.triggerHook(context, HookType.PRE_EXECUTE, { task, wave });
-                // Execute task with TDD
-                const tddResult = await this.executeTaskWithTDD(task, model, context, tddSkill);
-                // Trigger task complete hooks
-                await this.triggerHook(context, HookType.TASK_COMPLETE, { task, result: tddResult });
-                return {
-                    taskId,
-                    success: tddResult.status === 'success',
-                    filesModified: tddResult.filesModified || [],
-                    testsAdded: tddResult.testFile ? [tddResult.testFile] : [],
-                    duration: tddResult.duration || 0,
-                    notes: tddResult.summary || '',
-                    phases: tddResult.phases
-                };
+    findNextWaveIndex(plan, completedTasks) {
+        const completedSet = new Set(completedTasks);
+        for (let i = 0; i < plan.waves.length; i++) {
+            const wave = plan.waves[i];
+            const waveTaskIds = wave.tasks.map(t => t.id);
+            const allCompleted = waveTaskIds.every(id => completedSet.has(id));
+            if (!allCompleted) {
+                return i;
             }
-            catch (error) {
-                // Task failed
-                await this.triggerHook(context, HookType.ON_ERROR, { task, error });
-                return {
-                    taskId,
-                    success: false,
-                    filesModified: [],
-                    testsAdded: [],
-                    duration: 0,
-                    notes: '',
-                    error: error.message
-                };
-            }
-        });
-        // Wait for all tasks to complete (fail-fast disabled for wave)
+        }
+        return plan.waves.length;
+    }
+    /**
+     * Execute a wave - tasks within wave run in parallel
+     * Each task dispatches an implementer subagent with fresh context
+     */
+    async executeWave(wave, plan, model, context) {
+        const taskResults = [];
+        // Filter out already completed tasks
+        const pendingTasks = wave.tasks.filter(t => t.status !== 'completed');
+        if (pendingTasks.length === 0) {
+            console.log(`  [Wave ${wave.id}] All tasks already completed`);
+            return { waveId: wave.id, results: [], success: true };
+        }
+        // Update task statuses to in_progress
+        for (const task of pendingTasks) {
+            await context.persistence?.plan.updateTaskStatus(task.id, 'in_progress');
+        }
+        // Execute all tasks in parallel using Promise.allSettled
+        const promises = pendingTasks.map(task => this.executeTask(task, wave, plan, model, context));
         const settledResults = await Promise.allSettled(promises);
-        return settledResults.map((result, index) => {
+        // Process results
+        let hasFailures = false;
+        for (const result of settledResults) {
             if (result.status === 'fulfilled') {
-                return result.value;
+                taskResults.push(result.value);
+                if (!result.value.success) {
+                    hasFailures = true;
+                }
             }
             else {
-                return {
-                    taskId: taskConfigs[index].taskId,
+                hasFailures = true;
+                taskResults.push({
+                    taskId: 'unknown',
                     success: false,
-                    filesModified: [],
-                    testsAdded: [],
                     duration: 0,
                     notes: '',
                     error: result.reason?.message || 'Unknown error'
-                };
+                });
             }
-        });
+        }
+        return {
+            waveId: wave.id,
+            results: taskResults,
+            success: !hasFailures
+        };
     }
     /**
-     * Execute single task using TDD skill with task-level worktree isolation
-     * Each task gets its own worktree for true isolation
-     * Uses worktreeContract instead of worktree-start skill
+     * Execute a single task by dispatching implementer subagent
+     * Fresh context for each task with proper permissions
      */
-    async executeTaskWithTDD(task, model, context, tddSkill) {
-        // Step 1: Create isolated worktree using worktreeContract subagent
-        const taskBranchName = `agent/task-${task.id}-${Date.now().toString(36)}`;
-        console.log(`  [Worktree] Creating for ${task.id}: ${taskBranchName}`);
-        const worktreeResult = await context.dispatcher.dispatch({ role: 'general', model }, worktreeContract({
-            branchName: taskBranchName,
-            baseBranch: 'main',
-            isolation: true
-        }));
-        if (worktreeResult.status !== 'success') {
-            throw new Error(`Failed to create worktree for ${task.id}: ${worktreeResult.errors?.join(', ') || 'Unknown error'}`);
+    async executeTask(task, wave, plan, model, context) {
+        const startTime = Date.now();
+        try {
+            // Trigger pre-task hooks
+            await this.triggerHook(context, HookType.PRE_TASK, { task, wave, plan });
+            console.log(`  [Task ${task.id}] ${task.description}`);
+            // Determine files to own and read
+            const ownedFiles = task.relatedFiles || [];
+            const readFiles = this.getRelatedFilesForTask(task, plan);
+            // Dispatch implementer subagent with fresh context
+            const result = await context.dispatcher.dispatch({ role: 'implementer', model }, implementerContract({
+                task: task.description,
+                ownedFiles,
+                readFiles,
+                constraints: [
+                    'Follow immutability patterns - create new objects, never mutate',
+                    'Handle errors comprehensively with try/catch',
+                    'Validate inputs using zod schemas',
+                    'Keep functions small (<50 lines)',
+                    'Files should be focused (<800 lines)'
+                ]
+            }));
+            const duration = Date.now() - startTime;
+            // Parse result
+            const output = result.output || '{}';
+            const parsed = this.parseImplementerOutput(output);
+            const taskResult = {
+                taskId: task.id,
+                success: parsed.success,
+                duration,
+                notes: parsed.summary || '',
+                filesModified: parsed.filesChanged || []
+            };
+            // Trigger post-task hooks
+            await this.triggerHook(context, HookType.POST_TASK, { task, result: taskResult });
+            await this.triggerHook(context, HookType.TASK_COMPLETE, { task, result: taskResult });
+            return taskResult;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            // Trigger error hooks
+            await this.triggerHook(context, HookType.ON_ERROR, {
+                task,
+                error: error.message
+            });
+            return {
+                taskId: task.id,
+                success: false,
+                duration,
+                notes: '',
+                error: error.message
+            };
         }
-        // Parse worktree output
-        const worktreeData = this.parseWorktreeOutput(worktreeResult.output);
-        const worktreePath = worktreeData.worktreePath;
-        console.log(`  [Worktree] Created at: ${worktreePath}`);
-        // Step 2: Determine target file and test file from task
-        const targetFile = task.relatedFiles?.[0] || 'src/index.ts';
-        const testFile = targetFile.replace(/\.ts$/, '.test.ts');
-        console.log(`  [TDD] ${task.id}: ${task.description}`);
-        // Step 3: Execute TDD skill - it will use isolation: 'worktree' internally
-        // The TDD skill's implementer subagents will work within their own worktrees
-        // but the task-level worktree is already isolated
-        const tddResult = await tddSkill.execute({
-            behavior: task.description,
-            targetFile,
-            testFile,
-            testLevel: 'unit',
-            model
-        }, context);
-        // Step 4: Record worktree info in result for potential merge later
-        return {
-            ...tddResult,
-            worktreePath,
-            branchName: taskBranchName
-        };
     }
     /**
-     * Run verification using review-diff skill
-     * Returns structured verification result
+     * Get related files for a task based on dependencies
      */
-    async runVerificationWithReviewDiff(plan, results, context) {
-        console.log('\n[ExecutePlanSkill] Running verification...');
-        if (context.persistence) {
-            await context.persistence.state.updatePhase('verifying');
+    getRelatedFilesForTask(task, plan) {
+        const files = new Set();
+        // Add files from task's relatedFiles
+        if (task.relatedFiles) {
+            task.relatedFiles.forEach(f => files.add(f));
+        }
+        // Add files from dependency tasks
+        const depTaskIds = plan.dependencies[task.id] || [];
+        for (const depId of depTaskIds) {
+            const depTask = plan.tasks.find(t => t.id === depId);
+            if (depTask?.relatedFiles) {
+                depTask.relatedFiles.forEach(f => files.add(f));
+            }
+        }
+        return Array.from(files);
+    }
+    /**
+     * Parse implementer subagent output
+     */
+    parseImplementerOutput(output) {
+        try {
+            const jsonMatch = output.match(/```json\s*([\s\S]*?)\s*```/);
+            if (jsonMatch) {
+                const parsed = JSON.parse(jsonMatch[1]);
+                return {
+                    success: parsed.success ?? true,
+                    summary: parsed.summary,
+                    filesChanged: parsed.filesChanged || []
+                };
+            }
+            // Fallback: check for success indicators
+            if (output.includes('success') || output.includes('completed')) {
+                return { success: true };
+            }
+            return { success: false, error: 'Could not parse output' };
         }
-        const reviewSkill = context.skills.get('review-diff');
-        if (!reviewSkill) {
-            console.warn('[ExecutePlanSkill] review-diff skill not found, skipping verification');
-            return { success: true, dimensions: {} };
+        catch {
+            return { success: false, error: 'Failed to parse JSON output' };
         }
-        // Parallel verification dimensions
+    }
+    /**
+     * Run verification subagents after all waves complete
+     * - Goals verification: verifierContract
+     * - Quality verification: reviewerContract
+     * - Tests verification: dispatcher with test runner
+     */
+    async runVerification(plan, results, context) {
+        console.log('\n[ExecutePlanSkill] Running verification...');
+        await context.persistence?.state.updatePhase('executing');
+        // Get changed files from results
+        const changedFiles = results
+            .flatMap(r => r.filesModified || [])
+            .filter((f, i, arr) => arr.indexOf(f) === i); // unique
+        // Run verification dimensions in parallel
         const [goalsResult, qualityResult, testsResult] = await Promise.all([
-            this.verifyGoalsWithReviewDiff(plan, context, reviewSkill),
-            this.verifyQualityWithReviewDiff(results, context, reviewSkill),
+            this.verifyGoals(plan, changedFiles, context),
+            this.verifyQuality(changedFiles, context),
             this.verifyTests(results, context)
         ]);
         const verification = {
@@ -285,26 +343,31 @@ export class ExecutePlanSkill extends Skill {
             }
         };
         console.log(`[ExecutePlanSkill] Verification: ${verification.success ? 'PASSED' : 'FAILED'}`);
+        console.log(`  - Goals: ${goalsResult.success ? '✓' : '✗'}`);
+        console.log(`  - Quality: ${qualityResult.success ? '✓' : '✗'}`);
+        console.log(`  - Tests: ${testsResult.success ? '✓' : '✗'}`);
         return verification;
     }
     /**
-     * Verify goals using review-diff skill
+     * Verify goals using verifierContract subagent
      */
-    async verifyGoalsWithReviewDiff(plan, context, reviewSkill) {
+    async verifyGoals(plan, changedFiles, context) {
         try {
-            // Review current changes against plan
-            const review = await reviewSkill.execute({
-                target: '.',
-                targetType: 'branch',
-                focus: ['correctness'],
-                planPath: '.pi/state/PLAN.md'
-            }, context);
-            const passed = review.specCompliance === 'pass' || review.specCompliance === 'partial';
+            const result = await context.dispatcher.dispatch({ role: 'verifier' }, verifierContract({
+                goal: plan.goal,
+                plan: this.formatPlanSummary(plan),
+                changedFiles,
+                acceptanceCriteria: plan.verificationCriteria
+            }));
+            const output = result.output || '{}';
+            const parsed = this.parseVerifierOutput(output);
             return {
-                success: passed,
-                details: review,
-                evidence: review.strengths,
-                gaps: passed ? [] : review.issues?.filter((i) => i.severity === 'blocker' || i.severity === 'major').map((i) => i.description)
+                success: parsed.verdict === 'pass',
+                details: parsed,
+                evidence: parsed.criteriaResults
+                    ?.filter((c) => c.status === 'pass')
+                    .map((c) => c.criterion),
+                gaps: parsed.gaps || []
             };
         }
         catch (error) {
@@ -315,21 +378,30 @@ export class ExecutePlanSkill extends Skill {
         }
     }
     /**
-     * Verify code quality using review-diff skill
+     * Verify quality using reviewerContract subagent
      */
-    async verifyQualityWithReviewDiff(results, context, reviewSkill) {
+    async verifyQuality(changedFiles, context) {
         try {
-            const review = await reviewSkill.execute({
-                target: '.',
-                targetType: 'branch',
-                focus: ['security', 'performance', 'style']
-            }, context);
-            const hasBlockers = review.issues?.some((i) => i.severity === 'blocker');
+            const result = await context.dispatcher.dispatch({ role: 'reviewer' }, reviewerContract({
+                target: 'Implementation quality review',
+                reviewFiles: changedFiles,
+                focusAreas: ['correctness', 'security', 'performance', 'style'],
+                criteria: [
+                    'No hardcoded secrets',
+                    'Proper error handling',
+                    'Input validation',
+                    'Immutability patterns',
+                    'Test coverage >= 80%'
+                ]
+            }));
+            const output = result.output || '{}';
+            const parsed = this.parseReviewerOutput(output);
+            const hasCritical = parsed.findings?.some((f) => f.severity === 'critical');
             return {
-                success: !hasBlockers && review.decision !== 'blocked',
-                details: review,
-                evidence: review.strengths,
-                gaps: hasBlockers ? ['Critical issues found'] : []
+                success: !hasCritical && parsed.verdict !== 'request_changes',
+                details: parsed,
+                evidence: parsed.strengths,
+                gaps: hasCritical ? ['Critical issues found'] : []
             };
         }
         catch (error) {
@@ -340,7 +412,7 @@ export class ExecutePlanSkill extends Skill {
         }
     }
     /**
-     * Verify tests by checking TDD results
+     * Verify tests by running test suite
      */
     async verifyTests(results, context) {
         // Check if all tasks have tests
@@ -348,10 +420,7 @@ export class ExecutePlanSkill extends Skill {
         const allPassed = results.every(r => r.success);
         // Try to run full test suite
         try {
-            const testResult = await context.dispatcher.dispatch({
-                role: 'verifier',
-                timeout: 120000
-            }, {
+            const testResult = await context.dispatcher.dispatch({ role: 'verifier', timeout: 120000 }, {
                 permissions: {
                     readFiles: true,
                     searchCode: true,
@@ -359,16 +428,30 @@ export class ExecutePlanSkill extends Skill {
                     writeFiles: false,
                     gitOperations: false
                 },
-                prompt: `Run the full test suite and report coverage.\n\nReturn JSON: { "passed": boolean, "coverage": number }`,
+                prompt: `Run the full test suite and report coverage.
+
+Commands:
+1. npm test -- --coverage --watchAll=false 2>&1 || true
+2. cat coverage/lcov-report/index.html 2>/dev/null | grep -o '[^>]*%' | head -1 || echo "N/A"
+
+Return JSON:
+{
+  "passed": boolean,
+  "coverage": number,
+  "testCount": number,
+  "failedTests": number
+}`,
                 owns: [],
                 reads: []
             });
-            const coverageOk = testResult.coverage >= 80;
+            const output = testResult.output || '{}';
+            const parsed = this.parseTestOutput(output);
+            const coverageOk = parsed.coverage >= 80;
             return {
-                success: allHaveTests && allPassed && coverageOk,
-                details: { coverage: testResult.coverage, allHaveTests, allPassed },
-                evidence: coverageOk ? [`Coverage: ${testResult.coverage}%`] : [],
-                gaps: !coverageOk ? [`Coverage ${testResult.coverage}% < 80%`] : []
+                success: allHaveTests && allPassed && coverageOk && parsed.passed,
+                details: { coverage: parsed.coverage, allHaveTests, allPassed },
+                evidence: coverageOk ? [`Coverage: ${parsed.coverage}%`] : [],
+                gaps: !coverageOk ? [`Coverage ${parsed.coverage}% < 80%`] : []
             };
         }
         catch {
@@ -382,388 +465,79 @@ export class ExecutePlanSkill extends Skill {
         }
     }
     /**
-     * Handle wave failure
+     * Handle wave failure with proper error handling
      */
-    async handleWaveFailure(wave, failedTasks, context) {
-        console.error(`[ExecutePlanSkill] Wave failure handler`);
+    async handleWaveFailure(wave, failedResults, context) {
+        const failedTasks = failedResults.filter(r => !r.success);
+        console.error(`\n[ExecutePlanSkill] Wave ${wave.id} failure handler:`);
+        console.error(`  Failed tasks: ${failedTasks.map(t => t.taskId).join(', ')}`);
+        // Update state for failed tasks
+        for (const result of failedTasks) {
+            await context.persistence?.state.recordTaskFailed(result.taskId, result.error);
+        }
+        // Trigger error hooks
         await this.triggerHook(context, HookType.ON_ERROR, {
-            phase: 'execute',
+            phase: 'wave',
             wave,
             failedTasks
         });
     }
     /**
-     * Merge completed task worktrees back to main worktree with automatic conflict resolution
-     * Called after each successful wave
-     *
-     * Conflict Resolution Strategy:
-     * 1. Try merge --no-ff
-     * 2. If conflict, analyze with debugger subagent
-     * 3. Auto-resolve based on conflict type (imports, adjacent changes, etc.)
-     * 4. If cannot auto-resolve, try rebase-merging or manual merge
-     * 5. Last resort: mark for manual resolution
-     */
-    async mergeTaskWorktrees(waveResults, context) {
-        console.log('[ExecutePlanSkill] Merging task worktrees...');
-        const merged = [];
-        const conflicts = [];
-        const manualResolution = [];
-        for (const result of waveResults) {
-            if (!result.success || !result.branchName)
-                continue;
-            try {
-                const mergeResult = await this.mergeSingleBranch(result.taskId, result.branchName, context);
-                if (mergeResult.status === 'success') {
-                    merged.push(result.taskId);
-                    console.log(`  [Merge] ${result.taskId}: ✓ ${result.branchName}`);
-                }
-                else if (mergeResult.status === 'auto-resolved') {
-                    merged.push(result.taskId);
-                    conflicts.push(`${result.taskId} (auto-resolved: ${mergeResult.conflicts.join(', ')})`);
-                    console.log(`  [Merge] ${result.taskId}: ✓ (auto-resolved ${mergeResult.conflicts.length} conflicts)`);
-                }
-                else {
-                    manualResolution.push(result.taskId);
-                    console.error(`  [Merge] ${result.taskId}: ✗ needs manual resolution`);
-                }
-            }
-            catch (error) {
-                manualResolution.push(result.taskId);
-                console.error(`  [Merge] ${result.taskId}: ✗ ${error.message}`);
-            }
-        }
-        return { merged, conflicts, manualResolution };
-    }
-    /**
-     * Merge a single branch with conflict detection and auto-resolution
-     */
-    async mergeSingleBranch(taskId, branchName, context) {
-        // Step 1: Attempt merge
-        const mergeAttempt = await context.dispatcher.dispatch({
-            role: 'general',
-            timeout: 60000
-        }, {
-            permissions: {
-                readFiles: true,
-                searchCode: false,
-                runCommands: true,
-                writeFiles: false,
-                gitOperations: true
-            },
-            prompt: `Attempt to merge branch ${branchName} to current branch.
-
-Commands:
-1. git merge ${branchName} --no-ff -m "Merge ${branchName}" 2>&1
-2. Check exit code and output
-
-If successful: report status=success
-If conflicts: list conflicting files with git diff --name-only --diff-filter=U
-
-Return JSON:
-{
-  "status": "success|conflict",
-  "conflictingFiles": ["path/to/file"],
-  "mergeOutput": "..."
-}`,
-            owns: [],
-            reads: []
-        });
-        const mergeResult = this.parseMergeResult(mergeAttempt.output);
-        if (mergeResult.status === 'success') {
-            return { status: 'success', conflicts: [] };
-        }
-        // Step 2: Auto-resolve conflicts
-        console.log(`  [Merge] ${taskId}: Detected conflicts in ${mergeResult.conflictingFiles.length} files`);
-        const resolved = await this.autoResolveConflicts(mergeResult.conflictingFiles, branchName, context);
-        if (resolved.success) {
-            return { status: 'auto-resolved', conflicts: mergeResult.conflictingFiles };
-        }
-        // Step 3: Abort and mark for manual resolution
-        await context.dispatcher.dispatch({
-            role: 'general',
-            timeout: 30000
-        }, {
-            permissions: {
-                readFiles: false,
-                searchCode: false,
-                runCommands: true,
-                writeFiles: false,
-                gitOperations: true
-            },
-            prompt: `git merge --abort`,
-            owns: [],
-            reads: []
-        });
-        return { status: 'failed', conflicts: mergeResult.conflictingFiles };
-    }
-    /**
-     * Parse merge result from subagent output
-     */
-    parseMergeResult(output) {
-        try {
-            const jsonMatch = output.match(/```json\s*([\s\S]*?)\s*```/);
-            if (jsonMatch) {
-                const parsed = JSON.parse(jsonMatch[1]);
-                return {
-                    status: parsed.status || 'conflict',
-                    conflictingFiles: parsed.conflictingFiles || []
-                };
-            }
-        }
-        catch {
-            // Fallback to text parsing
-        }
-        // Text-based detection
-        if (output.includes('CONFLICT') || output.includes('Automatic merge failed')) {
-            const fileMatches = output.matchAll(/CONFLICT\s*\([^)]+\):\s*(.+)/g);
-            const files = [];
-            for (const match of fileMatches) {
-                files.push(match[1].trim());
-            }
-            return { status: 'conflict', conflictingFiles: files };
-        }
-        return { status: 'success', conflictingFiles: [] };
-    }
-    /**
-     * Auto-resolve merge conflicts using debugger subagent
-     */
-    async autoResolveConflicts(conflictingFiles, branchName, context) {
-        const resolved = [];
-        const failed = [];
-        for (const file of conflictingFiles) {
-            const resolution = await this.resolveSingleFile(file, branchName, context);
-            if (resolution.success) {
-                resolved.push(file);
-            }
-            else {
-                failed.push(file);
-            }
-        }
-        return {
-            success: resolved.length > 0 && failed.length === 0,
-            resolved,
-            failed
-        };
-    }
-    /**
-     * Resolve a single file conflict
+     * Format plan summary for verifier
      */
-    async resolveSingleFile(file, branchName, context) {
-        // Get both versions of the file
-        const fileAnalysis = await context.dispatcher.dispatch({
-            role: 'debugger',
-            timeout: 60000
-        }, {
-            permissions: {
-                readFiles: true,
-                searchCode: false,
-                runCommands: true,
-                writeFiles: false,
-                gitOperations: true
-            },
-            prompt: `Analyze conflict in file: ${file}
-
-Commands:
-1. git show :1:${file} > /tmp/base.txt    # common ancestor
-2. git show :2:${file} > /tmp/ours.txt   # current branch
-3. git show :3:${file} > /tmp/theirs.txt # merging branch
-4. cat ${file}                           # conflict markers
-
-Analyze:
-- Type of conflict (import additions, adjacent changes, overlapping edits)
-- Are changes logically compatible?
-- Can they be combined?
-
-Return JSON:
-{
-  "conflictType": "imports|adjacent|overlapping|unrelated",
-  "canAutoResolve": boolean,
-  "strategy": "accept-ours|accept-theirs|combine|manual"
-}`,
-            owns: [],
-            reads: [file]
-        });
-        const analysis = this.parseConflictAnalysis(fileAnalysis.output);
-        if (!analysis.canAutoResolve) {
-            return { success: false, method: 'manual-required' };
-        }
-        // Attempt resolution based on strategy
-        const resolution = await this.applyConflictStrategy(file, analysis.strategy, branchName, context);
-        return resolution;
+    formatPlanSummary(plan) {
+        return plan.waves.map(w => `- ${w.id}: ${w.tasks.map(t => t.id).join(', ')}`).join('\n');
     }
     /**
-     * Parse conflict analysis from subagent output
+     * Parse verifier output
      */
-    parseConflictAnalysis(output) {
+    parseVerifierOutput(output) {
         try {
             const jsonMatch = output.match(/```json\s*([\s\S]*?)\s*```/);
             if (jsonMatch) {
-                const parsed = JSON.parse(jsonMatch[1]);
-                return {
-                    conflictType: parsed.conflictType || 'unknown',
-                    canAutoResolve: parsed.canAutoResolve || false,
-                    strategy: parsed.strategy || 'manual'
-                };
+                return JSON.parse(jsonMatch[1]);
             }
         }
         catch {
-            // Default fallback
-        }
-        return { conflictType: 'unknown', canAutoResolve: false, strategy: 'manual' };
-    }
-    /**
-     * Apply conflict resolution strategy
-     */
-    async applyConflictStrategy(file, strategy, branchName, context) {
-        let commands;
-        switch (strategy) {
-            case 'accept-ours':
-                commands = `git checkout --ours "${file}" && git add "${file}"`;
-                break;
-            case 'accept-theirs':
-                commands = `git checkout --theirs "${file}" && git add "${file}"`;
-                break;
-            case 'combine':
-                // Use implementer to intelligently combine changes
-                return this.combineFileChanges(file, branchName, context);
-            default:
-                return { success: false, method: 'manual-required' };
-        }
-        try {
-            await context.dispatcher.dispatch({
-                role: 'general',
-                timeout: 30000
-            }, {
-                permissions: {
-                    readFiles: false,
-                    searchCode: false,
-                    runCommands: true,
-                    writeFiles: false,
-                    gitOperations: true
-                },
-                prompt: commands,
-                owns: [],
-                reads: []
-            });
-            return { success: true, method: strategy };
-        }
-        catch {
-            return { success: false, method: `${strategy}-failed` };
+            // Fallback
         }
+        return { verdict: 'fail' };
     }
     /**
-     * Intelligently combine changes from both branches
-     */
-    async combineFileChanges(file, branchName, context) {
-        // Use implementer subagent to merge changes intelligently
-        const combineResult = await context.dispatcher.dispatch({
-            role: 'implementer',
-            timeout: 60000
-        }, {
-            permissions: {
-                readFiles: true,
-                searchCode: false,
-                runCommands: true,
-                writeFiles: true,
-                gitOperations: true
-            },
-            prompt: `Resolve merge conflict in ${file} by combining both changes.
-
-Steps:
-1. git show :1:${file} > /tmp/base.ts
-2. git show :2:${file} > /tmp/ours.ts
-3. git show :3:${file} > /tmp/theirs.ts
-4. Read all three versions
-5. Create merged version that includes both sets of changes
-6. Resolve conflict markers and write to ${file}
-7. git add ${file}
-8. Verify file is valid (syntax check if applicable)
-
-Rules:
-- Keep changes from both branches where possible
-- For imports: combine import lists
-- For functions: merge non-overlapping additions
-- Preserve code style and formatting
-- Add comment if resolution is complex
-
-Return JSON:
-{
-  "success": boolean,
-  "resolution": "description of changes made"
-}`,
-            owns: [file],
-            reads: [file]
-        });
-        const result = this.parseResolutionResult(combineResult.output);
-        return {
-            success: result.success,
-            method: result.success ? 'combine-intelligent' : 'combine-failed'
-        };
-    }
-    /**
-     * Parse resolution result
+     * Parse reviewer output
      */
-    parseResolutionResult(output) {
+    parseReviewerOutput(output) {
         try {
             const jsonMatch = output.match(/```json\s*([\s\S]*?)\s*```/);
             if (jsonMatch) {
-                const parsed = JSON.parse(jsonMatch[1]);
-                return {
-                    success: parsed.success || false,
-                    resolution: parsed.resolution
-                };
+                return JSON.parse(jsonMatch[1]);
             }
         }
         catch {
-            // Check for success indicators in text
-            if (output.includes('success') || output.includes('resolved')) {
-                return { success: true };
-            }
+            // Fallback
         }
-        return { success: false };
+        return { verdict: 'request_changes' };
     }
     /**
-     * Parse worktree output from subagent
+     * Parse test output
      */
-    parseWorktreeOutput(output) {
+    parseTestOutput(output) {
         try {
             const jsonMatch = output.match(/```json\s*([\s\S]*?)\s*```/);
             if (jsonMatch) {
-                const parsed = JSON.parse(jsonMatch[1]);
-                return {
-                    worktreePath: parsed.worktreePath || '',
-                    branchName: parsed.branchName || '',
-                    baseBranch: parsed.baseBranch || 'main',
-                    repoRoot: parsed.repoRoot || '',
-                    status: parsed.status || 'unknown',
-                    error: parsed.error
-                };
+                return JSON.parse(jsonMatch[1]);
             }
+            // Fallback parsing
+            const coverageMatch = output.match(/(\d+(?:\.\d+)?)%/);
+            const passed = !output.includes('FAIL') && !output.includes('failed');
+            return {
+                passed,
+                coverage: coverageMatch ? parseFloat(coverageMatch[1]) : 0
+            };
         }
         catch {
-            // Fallback: try to extract from text
-            const pathMatch = output.match(/worktreePath["\']?\s*[:=]\s*["\']([^"\']+)["\']/i);
-            const branchMatch = output.match(/branchName["\']?\s*[:=]\s*["\']([^"\']+)["\']/i);
-            const statusMatch = output.match(/status["\']?\s*[:=]\s*["\'](created|reused|failed)["\']/i);
-            if (pathMatch) {
-                return {
-                    worktreePath: pathMatch[1],
-                    branchName: branchMatch?.[1] || '',
-                    baseBranch: 'main',
-                    repoRoot: '',
-                    status: statusMatch?.[1] || 'unknown'
-                };
-            }
+            return { passed: false, coverage: 0 };
         }
-        // Default fallback
-        return {
-            worktreePath: '',
-            branchName: '',
-            baseBranch: 'main',
-            repoRoot: '',
-            status: 'failed',
-            error: 'Could not parse worktree output'
-        };
     }
     /**
      * Helper to trigger hooks with error handling