@haoyiyin/workflow 0.2.0

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

@@ -0,0 +1,784 @@
+/**
+ * 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';
+// 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',
+};
+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()
+});
+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']
+        });
+    }
+    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');
+        }
+        // 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: [], 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;
+            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.message,
+                results
+            });
+            throw error;
+        }
+    }
+    /**
+     * Execute a wave using TDD skill for each task
+     * Parallel execution with Promise.allSettled
+     */
+    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
+                };
+            }
+            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)
+        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
+     */
+    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'}`);
+        }
+        // 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
+     */
+    async runVerificationWithReviewDiff(plan, results, context) {
+        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 = {
+            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
+     */
+    async verifyGoalsWithReviewDiff(plan, context, reviewSkill) {
+        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) => i.severity === 'blocker' || i.severity === 'major').map((i) => i.description)
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                gaps: [`Goal verification failed: ${error.message}`]
+            };
+        }
+    }
+    /**
+     * Verify code quality using review-diff skill
+     */
+    async verifyQualityWithReviewDiff(results, context, reviewSkill) {
+        try {
+            const review = await reviewSkill.execute({
+                target: '.',
+                targetType: 'branch',
+                focus: ['security', 'performance', 'style']
+            }, context);
+            const hasBlockers = review.issues?.some((i) => 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.message}`]
+            };
+        }
+    }
+    /**
+     * Verify tests by checking TDD results
+     */
+    async verifyTests(results, context) {
+        // 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({
+                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
+     */
+    async handleWaveFailure(wave, failedTasks, context) {
+        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
+     */
+    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
+     */
+    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;
+    }
+    /**
+     * Parse conflict analysis from subagent output
+     */
+    parseConflictAnalysis(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'
+                };
+            }
+        }
+        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` };
+        }
+    }
+    /**
+     * 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
+     */
+    parseResolutionResult(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
+                };
+            }
+        }
+        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
+     */
+    parseWorktreeOutput(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
+                };
+            }
+        }
+        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
+     */
+    async triggerHook(context, type, data) {
+        if (context.hooks) {
+            try {
+                const hookContext = data;
+                await context.hooks.execute(type, hookContext);
+            }
+            catch (error) {
+                console.warn(`[ExecutePlanSkill] Hook ${type} failed:`, error);
+            }
+        }
+    }
+}
+export const executePlanSkill = new ExecutePlanSkill();
+//# sourceMappingURL=index.js.map