@haoyiyin/workflow 0.2.10 → 0.3.0

package/src/skills/execute-plan/index.ts

@@ -1,18 +1,22 @@
 /**
- * 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 type { SkillContext } from '../types.js'
-import type { Plan, Wave, TaskResult, VerificationResult, DimensionResult } from '../../persistence/types.js'
+import type { Plan, Wave, Task, TaskResult, VerificationResult, DimensionResult } from '../../persistence/types.js'
 import type { HookType } from '../../types.js'
+import { implementerContract, verifierContract, reviewerContract } from '../../agents/contracts.js'
+
 // HookType constants (avoiding enum import issues)
 const HookType = {
   PRE_EXECUTE: 'pre-execute',
@@ -27,13 +31,11 @@ const HookType = {
   WAVE_START: 'wave-start',
   WAVE_COMPLETE: 'wave-complete',
 } as const
-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({
@@ -41,93 +43,110 @@ const ExecuteOutputSchema = z.object({
   results: z.array(z.any()),
   verification: z.any(),
   wavesCompleted: z.number(),
-  totalWaves: z.number()
+  totalWaves: z.number(),
 })
 
 type ExecuteInput = z.infer<typeof ExecuteInputSchema>
 type ExecuteOutput = z.infer<typeof ExecuteOutputSchema>
 
+interface WaveExecutionResult {
+  waveId: string
+  results: TaskResult[]
+  success: boolean
+  error?: string
+}
+
 export class ExecutePlanSkill extends Skill<ExecuteInput, ExecuteOutput> {
   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: ExecuteInput, context: SkillContext): Promise<ExecuteOutput> {
-    const { plan, waves } = input
     const results: TaskResult[] = []
     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.')
+    }
 
-    try {
-      // 3. Execute waves sequentially
-      for (const wave of waves) {
-        console.log(`\n[ExecutePlanSkill] Wave ${wave.id}: ${wave.tasks.length} tasks`)
+    // 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}`)
 
-        // Trigger wave start hooks
-        await this.triggerHook(context, HookType.WAVE_START, { wave, plan })
+    // Update state to executing phase
+    await context.persistence.state.updatePhase('executing')
 
-        // Execute wave using TDD skill for each task
-        const waveResults = await this.executeWaveWithTDD(wave, plan, input.model, context)
-        results.push(...waveResults)
+    // 3. Trigger pre-execute hooks
+    await this.triggerHook(context, HookType.PRE_EXECUTE, { plan, state: currentState })
 
-        // Update state with completed tasks
-        if (context.persistence) {
-          for (const result of waveResults) {
-            await context.persistence.state.recordTaskComplete(result.taskId, result)
-          }
-        }
+    try {
+      // 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}`)
+      }
 
-        // Merge task worktrees back to main branch
-        const successfulResults = waveResults.filter(r => r.success && r.branchName)
-        let mergeResult: { merged: string[]; conflicts: string[]; manualResolution: string[] } = { merged: [], conflicts: [], manualResolution: [] }
-        if (successfulResults.length > 0) {
-          mergeResult = await this.mergeTaskWorktrees(successfulResults, context)
+      // 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`)
 
-          // Report merge status
-          if (mergeResult.conflicts.length > 0) {
-            console.warn(`  [Merge] Auto-resolved conflicts in: ${mergeResult.conflicts.join(', ')}`)
-          }
-          if (mergeResult.manualResolution.length > 0) {
-            console.error(`  [Merge] Needs manual resolution: ${mergeResult.manualResolution.join(', ')}`)
+        // Trigger wave start hooks
+        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')
+          } 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: VerificationResult
-      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 = {
           success: false,
@@ -137,19 +156,17 @@ export class ExecutePlanSkill extends Skill<ExecuteInput, ExecuteOutput> {
         }
       }
 
-      // 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)
-      }
+      // 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)
 
-      // 6. Trigger post-execute hooks
+      // 8. Trigger post-execute hooks
       await this.triggerHook(context, HookType.POST_EXECUTE, {
         results,
         verification,
         wavesCompleted,
-        totalWaves: waves.length
+        totalWaves: plan.waves.length
       })
 
       return {
@@ -157,186 +174,259 @@ export class ExecutePlanSkill extends Skill<ExecuteInput, ExecuteOutput> {
         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 as 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
+   */
+  private findNextWaveIndex(plan: Plan, completedTasks: string[]): number {
+    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
+      }
+    }
+
+    return plan.waves.length
+  }
+
+  /**
+   * Execute a wave - tasks within wave run in parallel
+   * Each task dispatches an implementer subagent with fresh context
    */
-  private async executeWaveWithTDD(
+  private async executeWave(
     wave: Wave,
     plan: Plan,
     model: string | undefined,
     context: SkillContext
-  ): Promise<TaskResult[]> {
-    // Get TDD skill from registry
-    const tddSkill = context.skills.get('tdd')
-    if (!tddSkill) {
-      throw new Error('TDD skill not found in registry')
-    }
+  ): Promise<WaveExecutionResult> {
+    const taskResults: TaskResult[] = []
 
-    // 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 })
+    // Filter out already completed tasks
+    const pendingTasks = wave.tasks.filter(t => t.status !== 'completed')
 
-        // Execute task with TDD
-        const tddResult = await this.executeTaskWithTDD(task, model, context, tddSkill)
+    if (pendingTasks.length === 0) {
+      console.log(`  [Wave ${wave.id}] All tasks already completed`)
+      return { waveId: wave.id, results: [], success: true }
+    }
 
-        // Trigger task complete hooks
-        await this.triggerHook(context, HookType.TASK_COMPLETE, { task, result: tddResult })
+    // Update task statuses to in_progress
+    for (const task of pendingTasks) {
+      await context.persistence?.plan.updateTaskStatus(task.id, 'in_progress')
+    }
 
-        return {
-          taskId,
-          success: tddResult.status === 'success',
-          filesModified: tddResult.filesModified || [],
-          testsAdded: tddResult.testFile ? [tddResult.testFile] : [],
-          duration: tddResult.duration || 0,
-          notes: tddResult.summary || '',
-          phases: tddResult.phases
-        }
-      } catch (error) {
-        // Task failed
-        await this.triggerHook(context, HookType.ON_ERROR, { task, error })
-        return {
-          taskId,
-          success: false,
-          filesModified: [],
-          testsAdded: [],
-          duration: 0,
-          notes: '',
-          error: (error as Error).message
-        }
-      }
-    })
+    // Execute all tasks in parallel using Promise.allSettled
+    const promises = pendingTasks.map(task =>
+      this.executeTask(task, wave, plan, model, context)
+    )
 
-    // Wait for all tasks to complete (fail-fast disabled for wave)
     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
    */
-  private async executeTaskWithTDD(
-    task: { id: string; description: string; relatedFiles?: string[] },
+  private async executeTask(
+    task: Task,
+    wave: Wave,
+    plan: Plan,
     model: string | undefined,
-    context: SkillContext,
-    tddSkill: any
-  ): Promise<any> {
-    // 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: {
-      status: string
-      output: string
-      errors?: string[]
-    } = await context.dispatcher.dispatch(
-      { role: 'general', model },
-      worktreeContract({
-        branchName: taskBranchName,
-        baseBranch: 'main',
-        isolation: true
+    context: SkillContext
+  ): Promise<TaskResult> {
+    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 as { output?: string }).output || '{}'
+      const parsed = this.parseImplementerOutput(output)
+
+      const taskResult: 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 as Error).message
       })
-    )
 
-    if (worktreeResult.status !== 'success') {
-      throw new Error(`Failed to create worktree for ${task.id}: ${worktreeResult.errors?.join(', ') || 'Unknown error'}`)
+      return {
+        taskId: task.id,
+        success: false,
+        duration,
+        notes: '',
+        error: (error as 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
+  /**
+   * Get related files for a task based on dependencies
+   */
+  private getRelatedFilesForTask(task: Task, plan: Plan): string[] {
+    const files = new Set<string>()
+
+    // 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
+   */
+  private parseImplementerOutput(output: string): {
+    success: boolean
+    summary?: string
+    filesChanged?: string[]
+    error?: string
+  } {
+    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' }
+    } catch {
+      return { success: false, error: 'Failed to parse JSON output' }
     }
   }
 
   /**
-   * Run verification using review-diff skill
-   * Returns structured verification result
+   * Run verification subagents after all waves complete
+   * - Goals verification: verifierContract
+   * - Quality verification: reviewerContract
+   * - Tests verification: dispatcher with test runner
    */
-  private async runVerificationWithReviewDiff(
+  private async runVerification(
     plan: Plan,
     results: TaskResult[],
     context: SkillContext
   ): Promise<VerificationResult> {
     console.log('\n[ExecutePlanSkill] Running verification...')
 
-    if (context.persistence) {
-      await context.persistence.state.updatePhase('verifying')
-    }
+    await context.persistence?.state.updatePhase('executing')
 
-    const reviewSkill = context.skills.get('review-diff')
-    if (!reviewSkill) {
-      console.warn('[ExecutePlanSkill] review-diff skill not found, skipping verification')
-      return { success: true, dimensions: {} }
-    }
+    // Get changed files from results
+    const changedFiles = results
+      .flatMap(r => r.filesModified || [])
+      .filter((f, i, arr) => arr.indexOf(f) === i) // unique
 
-    // Parallel verification dimensions
+    // 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)
     ])
 
@@ -350,34 +440,42 @@ export class ExecutePlanSkill extends Skill<ExecuteInput, ExecuteOutput> {
     }
 
     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
    */
-  private async verifyGoalsWithReviewDiff(
+  private async verifyGoals(
     plan: Plan,
-    context: SkillContext,
-    reviewSkill: any
+    changedFiles: string[],
+    context: SkillContext
   ): Promise<DimensionResult> {
     try {
-      // Review current changes against plan
-      const review = await reviewSkill.execute({
-        target: '.',
-        targetType: 'branch',
-        focus: ['correctness'],
-        planPath: '.pi/state/PLAN.md'
-      }, context)
+      const result = await context.dispatcher.dispatch(
+        { role: 'verifier' },
+        verifierContract({
+          goal: plan.goal,
+          plan: this.formatPlanSummary(plan),
+          changedFiles,
+          acceptanceCriteria: plan.verificationCriteria
+        })
+      )
 
-      const passed = review.specCompliance === 'pass' || review.specCompliance === 'partial'
+      const output = (result as { output?: string }).output || '{}'
+      const parsed = this.parseVerifierOutput(output)
 
       return {
-        success: passed,
-        details: review,
-        evidence: review.strengths,
-        gaps: passed ? [] : review.issues?.filter((i: any) => i.severity === 'blocker' || i.severity === 'major').map((i: any) => i.description)
+        success: parsed.verdict === 'pass',
+        details: parsed,
+        evidence: parsed.criteriaResults
+          ?.filter((c: { status: string }) => c.status === 'pass')
+          .map((c: { criterion: string }) => c.criterion),
+        gaps: parsed.gaps || []
       }
     } catch (error) {
       return {
@@ -388,27 +486,41 @@ export class ExecutePlanSkill extends Skill<ExecuteInput, ExecuteOutput> {
   }
 
   /**
-   * Verify code quality using review-diff skill
+   * Verify quality using reviewerContract subagent
    */
-  private async verifyQualityWithReviewDiff(
-    results: TaskResult[],
-    context: SkillContext,
-    reviewSkill: any
+  private async verifyQuality(
+    changedFiles: string[],
+    context: SkillContext
   ): Promise<DimensionResult> {
     try {
-      const review = await reviewSkill.execute({
-        target: '.',
-        targetType: 'branch',
-        focus: ['security', 'performance', 'style']
-      }, context)
+      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 as { output?: string }).output || '{}'
+      const parsed = this.parseReviewerOutput(output)
 
-      const hasBlockers = review.issues?.some((i: any) => i.severity === 'blocker')
+      const hasCritical = parsed.findings?.some(
+        (f: { severity: string }) => 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) {
       return {
@@ -419,7 +531,7 @@ export class ExecutePlanSkill extends Skill<ExecuteInput, ExecuteOutput> {
   }
 
   /**
-   * Verify tests by checking TDD results
+   * Verify tests by running test suite
    */
   private async verifyTests(
     results: TaskResult[],
@@ -431,32 +543,44 @@ export class ExecutePlanSkill extends Skill<ExecuteInput, ExecuteOutput> {
 
     // Try to run full test suite
     try {
-      const testResult = await context.dispatcher.dispatch<{
-        coverage: number
-        passed: boolean
-      }>({
-        role: 'verifier',
-        timeout: 120000
-      }, {
-        permissions: {
-          readFiles: true,
-          searchCode: true,
-          runCommands: true,
-          writeFiles: false,
-          gitOperations: false
-        },
-        prompt: `Run the full test suite and report coverage.\n\nReturn JSON: { "passed": boolean, "coverage": number }`,
-        owns: [],
-        reads: []
-      })
+      const testResult = await context.dispatcher.dispatch(
+        { role: 'verifier', timeout: 120000 },
+        {
+          permissions: {
+            readFiles: true,
+            searchCode: true,
+            runCommands: true,
+            writeFiles: false,
+            gitOperations: false
+          },
+          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 as { output?: string }).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 {
       // Fallback to basic check
@@ -470,482 +594,103 @@ export class ExecutePlanSkill extends Skill<ExecuteInput, ExecuteOutput> {
   }
 
   /**
-   * Handle wave failure
+   * Handle wave failure with proper error handling
    */
   private async handleWaveFailure(
     wave: Wave,
-    failedTasks: TaskResult[],
+    failedResults: TaskResult[],
     context: SkillContext
   ): Promise<void> {
-    console.error(`[ExecutePlanSkill] Wave failure handler`)
+    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
+   * Format plan summary for verifier
    */
-  private async mergeTaskWorktrees(
-    waveResults: TaskResult[],
-    context: SkillContext
-  ): Promise<{
-    merged: string[]
-    conflicts: string[]
-    manualResolution: string[]
-  }> {
-    console.log('[ExecutePlanSkill] Merging task worktrees...')
-
-    const merged: string[] = []
-    const conflicts: string[] = []
-    const manualResolution: string[] = []
-
-    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 as Error).message}`)
-      }
-    }
-
-    return { merged, conflicts, manualResolution }
-  }
-
-  /**
-   * Merge a single branch with conflict detection and auto-resolution
-   */
-  private async mergeSingleBranch(
-    taskId: string,
-    branchName: string,
-    context: SkillContext
-  ): Promise<{
-    status: 'success' | 'auto-resolved' | 'failed'
-    conflicts: string[]
-  }> {
-    // 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 as { output: string }).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 }
+  private formatPlanSummary(plan: Plan): string {
+    return plan.waves.map(w =>
+      `- ${w.id}: ${w.tasks.map(t => t.id).join(', ')}`
+    ).join('\n')
   }
 
   /**
-   * Parse merge result from subagent output
+   * Parse verifier output
    */
-  private parseMergeResult(output: string): {
-    status: 'success' | 'conflict'
-    conflictingFiles: string[]
+  private parseVerifierOutput(output: string): {
+    verdict: string
+    criteriaResults?: Array<{ criterion: string; status: string; evidence?: string }>
+    gaps?: string[]
   } {
     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 || []
-        }
+        return JSON.parse(jsonMatch[1])
       }
     } 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: string[] = []
-      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
-   */
-  private async autoResolveConflicts(
-    conflictingFiles: string[],
-    branchName: string,
-    context: SkillContext
-  ): Promise<{ success: boolean; resolved: string[]; failed: string[] }> {
-    const resolved: string[] = []
-    const failed: string[] = []
-
-    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
-   */
-  private async resolveSingleFile(
-    file: string,
-    branchName: string,
-    context: SkillContext
-  ): Promise<{ success: boolean; method: string }> {
-    // 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 as { output: string }).output)
-
-    if (!analysis.canAutoResolve) {
-      return { success: false, method: 'manual-required' }
+      // Fallback
     }
-
-    // Attempt resolution based on strategy
-    const resolution = await this.applyConflictStrategy(
-      file,
-      analysis.strategy,
-      branchName,
-      context
-    )
-
-    return resolution
+    return { verdict: 'fail' }
   }
 
   /**
-   * Parse conflict analysis from subagent output
+   * Parse reviewer output
    */
-  private parseConflictAnalysis(output: string): {
-    conflictType: string
-    canAutoResolve: boolean
-    strategy: string
+  private parseReviewerOutput(output: string): {
+    verdict: string
+    findings?: Array<{ severity: string; file: string; message: string }>
+    strengths?: string[]
   } {
     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
-   */
-  private async applyConflictStrategy(
-    file: string,
-    strategy: string,
-    branchName: string,
-    context: SkillContext
-  ): Promise<{ success: boolean; method: string }> {
-    let commands: string
-
-    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` }
-    }
-  }
-
-  /**
-   * Intelligently combine changes from both branches
-   */
-  private async combineFileChanges(
-    file: string,
-    branchName: string,
-    context: SkillContext
-  ): Promise<{ success: boolean; method: string }> {
-    // 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 as { output: string }).output)
-
-    return {
-      success: result.success,
-      method: result.success ? 'combine-intelligent' : 'combine-failed'
+      // Fallback
     }
+    return { verdict: 'request_changes' }
   }
 
   /**
-   * Parse resolution result
+   * Parse test output
    */
-  private parseResolutionResult(output: string): {
-    success: boolean
-    resolution?: string
+  private parseTestOutput(output: string): {
+    passed: boolean
+    coverage: number
+    testCount?: number
+    failedTests?: number
   } {
     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 }
-      }
-    }
 
-    return { success: false }
-  }
+      // Fallback parsing
+      const coverageMatch = output.match(/(\d+(?:\.\d+)?)%/)
+      const passed = !output.includes('FAIL') && !output.includes('failed')
 
-  /**
-   * Parse worktree output from subagent
-   */
-  private parseWorktreeOutput(output: string): {
-    worktreePath: string
-    branchName: string
-    baseBranch: string
-    repoRoot: string
-    status: string
-    error?: string
-  } {
-    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 {
+        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'
-        }
-      }
-    }
-
-    // Default fallback
-    return {
-      worktreePath: '',
-      branchName: '',
-      baseBranch: 'main',
-      repoRoot: '',
-      status: 'failed',
-      error: 'Could not parse worktree output'
+      return { passed: false, coverage: 0 }
     }
   }
 
@@ -967,4 +712,5 @@ Return JSON:
     }
   }
 }
+
 export const executePlanSkill = new ExecutePlanSkill()