@haoyiyin/workflow 0.2.0 → 0.2.3

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

@@ -0,0 +1,970 @@
+/**
+ * Enhanced Execute Plan Skill - Orchestrates TDD and Review skills
+ *
+ * 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
+ */
+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 { HookType } from '../../types.js'
+// HookType constants (avoiding enum import issues)
+const HookType = {
+  PRE_EXECUTE: 'pre-execute',
+  POST_EXECUTE: 'post-execute',
+  PRE_WAVE: 'pre-wave',
+  POST_WAVE: 'post-wave',
+  PRE_TASK: 'pre-task',
+  POST_TASK: 'post-task',
+  ON_ERROR: 'on-error',
+  STATE_CHANGE: 'state-change',
+  TASK_COMPLETE: 'task-complete',
+  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()),
+  skipVerify: z.boolean().optional(),
+  model: z.string().optional()
+})
+
+const ExecuteOutputSchema = z.object({
+  success: z.boolean(),
+  results: z.array(z.any()),
+  verification: z.any(),
+  wavesCompleted: z.number(),
+  totalWaves: z.number()
+})
+
+type ExecuteInput = z.infer<typeof ExecuteInputSchema>
+type ExecuteOutput = z.infer<typeof ExecuteOutputSchema>
+
+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']
+    })
+  }
+
+  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')
+    }
+
+    // 2. Trigger pre-execute hooks
+    await this.triggerHook(context, HookType.PRE_EXECUTE, { plan, waves })
+
+    try {
+      // 3. Execute waves sequentially
+      for (const wave of waves) {
+        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: string[]; conflicts: string[]; manualResolution: string[] } = { 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(', ')}`)
+          }
+          if (mergeResult.manualResolution.length > 0) {
+            console.error(`  [Merge] Needs manual resolution: ${mergeResult.manualResolution.join(', ')}`)
+          }
+        }
+
+        // Trigger wave complete hooks (with merge info)
+        await this.triggerHook(context, HookType.WAVE_COMPLETE, {
+          wave,
+          results: waveResults,
+          plan,
+          mergeResult
+        })
+
+        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)
+          break
+        }
+
+        console.log(`[ExecutePlanSkill] Wave ${wave.id} complete ✓`)
+      }
+
+      // 4. Run verification using review-diff skill
+      let verification: VerificationResult
+      if (!input.skipVerify && wavesCompleted === waves.length) {
+        verification = await this.runVerificationWithReviewDiff(plan, results, context)
+      } else {
+        verification = {
+          success: false,
+          dimensions: {
+            goals: { success: false, gaps: ['Verification skipped or incomplete'] }
+          }
+        }
+      }
+
+      // 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
+      await this.triggerHook(context, HookType.POST_EXECUTE, {
+        results,
+        verification,
+        wavesCompleted,
+        totalWaves: waves.length
+      })
+
+      return {
+        success: results.every(r => r.success) && verification.success,
+        results,
+        verification,
+        wavesCompleted,
+        totalWaves: waves.length
+      }
+
+    } catch (error) {
+      // Trigger error hooks
+      await this.triggerHook(context, HookType.ON_ERROR, {
+        phase: 'execute',
+        error: (error as Error).message,
+        results
+      })
+      throw error
+    }
+  }
+
+  /**
+   * Execute a wave using TDD skill for each task
+   * Parallel execution with Promise.allSettled
+   */
+  private async executeWaveWithTDD(
+    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')
+    }
+
+    // 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
+        }
+      } 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
+        }
+      }
+    })
+
+    // Wait for all tasks to complete (fail-fast disabled for wave)
+    const settledResults = await Promise.allSettled(promises)
+
+    return settledResults.map((result, index) => {
+      if (result.status === 'fulfilled') {
+        return result.value
+      } else {
+        return {
+          taskId: taskConfigs[index].taskId,
+          success: false,
+          filesModified: [],
+          testsAdded: [],
+          duration: 0,
+          notes: '',
+          error: result.reason?.message || 'Unknown error'
+        }
+      }
+    })
+  }
+
+  /**
+   * 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
+   */
+  private async executeTaskWithTDD(
+    task: { id: string; description: string; relatedFiles?: string[] },
+    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
+      })
+    )
+
+    if (worktreeResult.status !== 'success') {
+      throw new Error(`Failed to create worktree for ${task.id}: ${worktreeResult.errors?.join(', ') || 'Unknown error'}`)
+    }
+
+    // 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
+   */
+  private async runVerificationWithReviewDiff(
+    plan: Plan,
+    results: TaskResult[],
+    context: SkillContext
+  ): Promise<VerificationResult> {
+    console.log('\n[ExecutePlanSkill] Running verification...')
+
+    if (context.persistence) {
+      await context.persistence.state.updatePhase('verifying')
+    }
+
+    const reviewSkill = context.skills.get('review-diff')
+    if (!reviewSkill) {
+      console.warn('[ExecutePlanSkill] review-diff skill not found, skipping verification')
+      return { success: true, dimensions: {} }
+    }
+
+    // Parallel verification dimensions
+    const [goalsResult, qualityResult, testsResult] = await Promise.all([
+      this.verifyGoalsWithReviewDiff(plan, context, reviewSkill),
+      this.verifyQualityWithReviewDiff(results, context, reviewSkill),
+      this.verifyTests(results, context)
+    ])
+
+    const verification: VerificationResult = {
+      success: goalsResult.success && qualityResult.success && testsResult.success,
+      dimensions: {
+        goals: goalsResult,
+        quality: qualityResult,
+        tests: testsResult
+      }
+    }
+
+    console.log(`[ExecutePlanSkill] Verification: ${verification.success ? 'PASSED' : 'FAILED'}`)
+
+    return verification
+  }
+
+  /**
+   * Verify goals using review-diff skill
+   */
+  private async verifyGoalsWithReviewDiff(
+    plan: Plan,
+    context: SkillContext,
+    reviewSkill: any
+  ): 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 passed = review.specCompliance === 'pass' || review.specCompliance === 'partial'
+
+      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)
+      }
+    } catch (error) {
+      return {
+        success: false,
+        gaps: [`Goal verification failed: ${(error as Error).message}`]
+      }
+    }
+  }
+
+  /**
+   * Verify code quality using review-diff skill
+   */
+  private async verifyQualityWithReviewDiff(
+    results: TaskResult[],
+    context: SkillContext,
+    reviewSkill: any
+  ): Promise<DimensionResult> {
+    try {
+      const review = await reviewSkill.execute({
+        target: '.',
+        targetType: 'branch',
+        focus: ['security', 'performance', 'style']
+      }, context)
+
+      const hasBlockers = review.issues?.some((i: any) => i.severity === 'blocker')
+
+      return {
+        success: !hasBlockers && review.decision !== 'blocked',
+        details: review,
+        evidence: review.strengths,
+        gaps: hasBlockers ? ['Critical issues found'] : []
+      }
+    } catch (error) {
+      return {
+        success: false,
+        gaps: [`Quality verification failed: ${(error as Error).message}`]
+      }
+    }
+  }
+
+  /**
+   * Verify tests by checking TDD results
+   */
+  private async verifyTests(
+    results: TaskResult[],
+    context: SkillContext
+  ): Promise<DimensionResult> {
+    // Check if all tasks have tests
+    const allHaveTests = results.every(r => r.testsAdded && r.testsAdded.length > 0)
+    const allPassed = results.every(r => r.success)
+
+    // 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 coverageOk = testResult.coverage >= 80
+
+      return {
+        success: allHaveTests && allPassed && coverageOk,
+        details: { coverage: testResult.coverage, allHaveTests, allPassed },
+        evidence: coverageOk ? [`Coverage: ${testResult.coverage}%`] : [],
+        gaps: !coverageOk ? [`Coverage ${testResult.coverage}% < 80%`] : []
+      }
+    } catch {
+      // Fallback to basic check
+      return {
+        success: allHaveTests && allPassed,
+        details: { allHaveTests, allPassed },
+        evidence: allHaveTests ? ['All tasks have tests'] : [],
+        gaps: !allHaveTests ? ['Some tasks missing tests'] : []
+      }
+    }
+  }
+
+  /**
+   * Handle wave failure
+   */
+  private async handleWaveFailure(
+    wave: Wave,
+    failedTasks: TaskResult[],
+    context: SkillContext
+  ): Promise<void> {
+    console.error(`[ExecutePlanSkill] Wave failure handler`)
+
+    await this.triggerHook(context, HookType.ON_ERROR, {
+      phase: 'execute',
+      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
+   */
+  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 }
+  }
+
+  /**
+   * Parse merge result from subagent output
+   */
+  private parseMergeResult(output: string): {
+    status: 'success' | 'conflict'
+    conflictingFiles: 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 || []
+        }
+      }
+    } 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' }
+    }
+
+    // Attempt resolution based on strategy
+    const resolution = await this.applyConflictStrategy(
+      file,
+      analysis.strategy,
+      branchName,
+      context
+    )
+
+    return resolution
+  }
+
+  /**
+   * Parse conflict analysis from subagent output
+   */
+  private parseConflictAnalysis(output: string): {
+    conflictType: string
+    canAutoResolve: boolean
+    strategy: 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'
+        }
+      }
+    } 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'
+    }
+  }
+
+  /**
+   * Parse resolution result
+   */
+  private parseResolutionResult(output: string): {
+    success: boolean
+    resolution?: string
+  } {
+    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
+        }
+      }
+    } catch {
+      // Check for success indicators in text
+      if (output.includes('success') || output.includes('resolved')) {
+        return { success: true }
+      }
+    }
+
+    return { success: false }
+  }
+
+  /**
+   * 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
+        }
+      }
+    } 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'
+    }
+  }
+
+  /**
+   * Helper to trigger hooks with error handling
+   */
+  private async triggerHook(
+    context: SkillContext,
+    type: typeof HookType[keyof typeof HookType],
+    data: Record<string, unknown>
+  ): Promise<void> {
+    if (context.hooks) {
+      try {
+        const hookContext = data as unknown as import('../../types.js').HookContext
+        await context.hooks.execute(type as HookType, hookContext)
+      } catch (error) {
+        console.warn(`[ExecutePlanSkill] Hook ${type} failed:`, error)
+      }
+    }
+  }
+}
+export const executePlanSkill = new ExecutePlanSkill()