@haoyiyin/workflow 0.2.11 → 0.3.0

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

@@ -1,458 +1,263 @@
 /**
- * To Plan Skill - Creates implementation plans via multi-step subagent dispatch
+ * To Plan Skill - Thin orchestrator that delegates all planning to subagent
  *
- * 5-Step Process:
- *   Step 1: Classify the request (type, complexity, risk, exploration areas)
- *   Step 2: Dispatch 1-3 read-only exploration subagents (in parallel)
- *   Step 3: Synthesize findings into a unified plan structure
- *   Step 4: Write the plan to disk
- *   Step 5: Dispatch plan-checker subagent to validate the plan
+ * Architecture:
+ * 1. Initialize STATE.md with goal
+ * 2. Dispatch planner subagent with FRESH context (no main agent state)
+ * 3. Parse planner output into Plan structure
+ * 4. Group tasks into waves via topological sort
+ * 5. Write PLAN.md
+ * 6. Update STATE.md with plan
  *
- * Main Agent NEVER reads source files directly — all exploration is delegated.
+ * The skill is THIN - all heavy lifting done by planner subagent.
  */
 import { z } from 'zod';
 import { Skill } from '../skill.js';
-import { createDispatcher } from '../../agents/dispatcher.js';
-import { researcherContract } from '../../agents/contracts.js';
-import { createMainAgentGuard } from '../../guard/main-agent.js';
-import { mkdir, writeFile } from 'fs/promises';
-import { join } from 'path';
+import { StateMdManager } from '../../persistence/state-md.js';
+import { PlanMdManager } from '../../persistence/plan-md.js';
 // ---------------------------------------------------------------------------
 // Schemas
 // ---------------------------------------------------------------------------
 const ToPlanInputSchema = z.object({
     goal: z.string().min(1, 'Goal is required'),
     context: z.string().optional(),
-    outputPath: z.string().optional(),
+    constraints: z.array(z.string()).optional(),
     model: z.string().optional(),
-    filesHint: z.array(z.string()).optional(),
-    workType: z.enum(['feature', 'bugfix', 'migration', 'cleanup', 'refactor']).optional(),
-});
-const TaskSchema = z.object({
-    id: z.string(),
-    title: z.string(),
-    description: z.string(),
-    owns: z.array(z.string()),
-    reads: z.array(z.string()),
-    dependencies: z.array(z.string()),
-    verification: z.string().optional(),
+    outputPath: z.string().optional(),
 });
 const ToPlanOutputSchema = z.object({
     planPath: z.string(),
-    executionModel: z.enum(['single-agent', 'ordered-non-parallel', 'fan-out-fan-in']),
-    classification: z.object({
-        type: z.string(),
-        complexity: z.enum(['low', 'medium', 'high']),
-        risk: z.enum(['low', 'medium', 'high']),
-    }),
-    planCheckerPassed: z.boolean(),
-    tasks: z.array(TaskSchema),
+    waves: z.array(z.custom()),
+    taskCount: z.number(),
     summary: z.string(),
     tokensUsed: z.number(),
 });
 // ---------------------------------------------------------------------------
-// Step 1: Classify prompt builder
-// ---------------------------------------------------------------------------
-function buildClassifyPrompt(goal, context, workType, researchFindings) {
-    return [
-        '## Classify This Request',
-        '',
-        `**Goal**: ${goal}`,
-        context ? `**Context**: ${context}` : '',
-        workType ? `**Hinted Work Type**: ${workType}` : '',
-        researchFindings ? `## Research Findings\n\n${researchFindings.slice(0, 1000)}` : '',
-        '',
-        'Determine:',
-        '- **Type**: feature, bugfix, migration, cleanup, refactor, or other',
-        '- **Complexity**: low (1-3 files), medium (3-10 files), high (10+ files / architectural)',
-        '- **Risk**: low (isolated, well-tested), medium (shared code), high (core systems, low coverage)',
-        '- **Exploration Areas**: 1-3 key directories or file patterns to explore first',
-        '',
-        'Output as JSON:',
-        '```json',
-        '{ "type": "...", "complexity": "low|medium|high", "risk": "low|medium|high", "explorationAreas": ["path/area1", "path/area2"] }',
-        '```',
-    ].join('\n');
-}
-// ---------------------------------------------------------------------------
-// Step 2: Exploration prompt builder (one per area)
-// ---------------------------------------------------------------------------
-function buildExplorePrompt(area, goal, context) {
-    return [
-        '## Exploration Task',
-        '',
-        `**Goal**: ${goal}`,
-        context ? `**Context**: ${context}` : '',
-        `**Focus Area**: ${area}`,
-        '',
-        '## Instructions',
-        '',
-        '1. Search and read files within this area',
-        '2. Identify: existing patterns, relevant abstractions, dependencies, test coverage',
-        '3. Note any existing implementation that relates to the goal',
-        '4. Flag surprises, risks, or undocumented behavior',
-        '',
-        '## Constraints',
-        '- READ ONLY — do not modify any files',
-        '- Focus only on the assigned area',
-        '- Be thorough but concise',
-    ].join('\n');
-}
-// ---------------------------------------------------------------------------
-// Step 3: Synthesize prompt builder
+// Planner Subagent Prompt
 // ---------------------------------------------------------------------------
-function buildSynthesizePrompt(goal, context, classification, explorationOutputs) {
-    const explorationsBlock = explorationOutputs
-        .map((output, i) => `### Exploration ${i + 1}\n\n${output.slice(0, 2000)}`)
-        .join('\n\n');
-    return [
-        '## Synthesize Findings into an Implementation Plan',
-        '',
-        `**Goal**: ${goal}`,
-        context ? `**Context**: ${context}` : '',
-        '',
-        '## Classification',
-        `Type: ${classification.type}, Complexity: ${classification.complexity}, Risk: ${classification.risk}`,
-        '',
-        '## Exploration Results',
-        explorationsBlock,
-        '',
-        '## Instructions',
-        '',
-        '1. Cross-reference all exploration findings',
-        '2. Identify conflicts or gaps in understanding',
-        '3. Determine the execution model:',
-        '   - **single-agent**: one implementer can do everything',
-        '   - **ordered-non-parallel**: tasks must run in dependency order',
-        '   - **fan-out-fan-in**: independent tasks in parallel, then merge',
-        '4. Break work into concrete tasks (typically 3-8 tasks)',
-        '',
-        '## Task Rules',
-        '- Each task: id, title, description, owns[], reads[], dependencies[], verification',
-        '- **owns[]**: files the task CREATES or MODIFIES',
-        '- **reads[]**: files the task reads for context',
-        '- **dependencies[]**: task IDs that must finish first',
-        '- **verification**: how to confirm the task is done correctly',
-        '- Tasks sized for 1-5 minutes of subagent work',
-        '',
-        'Output as JSON:',
-        '```json',
-        '{ "executionModel": "...", "tasks": [...], "summary": "..." }',
-        '```',
-    ].join('\n');
+function buildPlannerPrompt(input) {
+    return `# Planning Task
+
+## Goal
+${input.goal}
+
+${input.context ? `## Context\n${input.context}\n` : ''}
+${input.constraints ? `## Constraints\n${input.constraints.map(c => `- ${c}`).join('\n')}\n` : ''}
+
+## Instructions
+
+Create a detailed implementation plan. Break the work into small, concrete tasks.
+
+### Task Requirements
+- Each task should be completable in 1-5 minutes by a subagent
+- Tasks should be independent where possible
+- Each task must have clear owns[] (files to modify) and reads[] (files to read)
+- Dependencies must be explicitly declared
+
+### Output Format
+
+Return ONLY a JSON object with this exact structure:
+
+\`\`\`json
+{
+  "goal": "restated goal",
+  "tasks": [
+    {
+      "id": "task-1",
+      "description": "Clear description of what to do",
+      "estimatedComplexity": "low|medium|high",
+      "owns": ["files/to/create/or/modify"],
+      "reads": ["files/to/read/for/context"],
+      "dependencies": ["task-ids-that-must-complete-first"],
+      "verificationCriteria": ["how to verify this task is done"]
+    }
+  ],
+  "dependencies": {
+    "task-2": ["task-1"]
+  },
+  "verificationCriteria": [
+    "Overall acceptance criteria for the plan"
+  ],
+  "estimatedDuration": 300000,
+  "rationale": "Brief explanation of the plan structure"
 }
-// ---------------------------------------------------------------------------
-// Step 4: Write plan prompt builder
-// ---------------------------------------------------------------------------
-function buildWritePlanPrompt(goal, context, classification, synthesis, planPath) {
-    const tasksBlock = synthesis.tasks
-        .map((t) => `- **Task ${t.id}**: ${t.title} — ${t.description} (owns: ${t.owns.join(', ') || 'none'}, reads: ${t.reads.join(', ') || 'none'}, deps: ${t.dependencies.join(', ') || 'none'})`)
-        .join('\n');
-    return [
-        `Write the implementation plan to: ${planPath}`,
-        '',
-        `**Goal**: ${goal}`,
-        context ? `**Context**: ${context}` : '',
-        `**Type**: ${classification.type}, **Complexity**: ${classification.complexity}, **Risk**: ${classification.risk}`,
-        `**Execution Model**: ${synthesis.executionModel}`,
-        '',
-        '## Tasks to Document',
-        tasksBlock,
-        '',
-        '## Plan Format',
-        '',
-        'Write a markdown file with these sections:',
-        '1. `# Goal` — restate the goal',
-        '2. `## Context` — background information',
-        '3. `## Execution Model` — how tasks should be executed',
-        '4. `## Tasks` — numbered sections per task with title, description, owns, reads, dependencies, verification',
-        '5. `## Risks` — identified risks and mitigation strategies',
-    ].join('\n');
+\`\`\`
+
+## Rules
+1. Use descriptive task IDs like "setup-config", "implement-core", "add-tests"
+2. Keep task descriptions under 100 characters
+3. owns[] and reads[] should be relative file paths
+4. No circular dependencies
+5. Include at least one verification criterion per task`;
 }
 // ---------------------------------------------------------------------------
-// Step 5: Plan check prompt builder
+// Parsing Helpers
 // ---------------------------------------------------------------------------
-function buildPlanCheckPrompt(planPath) {
-    return [
-        '## Validate the Implementation Plan',
-        '',
-        `Read the plan file: ${planPath}`,
-        '',
-        '## Checklist',
-        '',
-        '1. Do tasks cover all requirements?',
-        '2. Does every task have clear owns[] and reads[]?',
-        '3. Are dependencies acyclic and valid (referenced IDs exist)?',
-        '4. Are tasks small enough for subagent execution (<5 min)?',
-        '5. Does each task have a verification step?',
-        '6. Are identified risks addressed?',
-        '7. Could tasks conflict by owning the same file?',
-        '',
-        'Return: PASS or BLOCKED with specific issues.',
-    ].join('\n');
+function parsePlanFromResponse(response) {
+    try {
+        // Extract JSON from markdown code block or use raw response
+        const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/);
+        const jsonStr = jsonMatch ? jsonMatch[1].trim() : response.trim();
+        const parsed = JSON.parse(jsonStr);
+        // Transform to Plan structure
+        const tasks = (parsed.tasks || []).map((t) => ({
+            id: String(t.id || ''),
+            description: String(t.description || ''),
+            status: 'pending',
+            dependencies: Array.isArray(t.dependencies) ? t.dependencies.map(String) : [],
+            estimatedComplexity: t.estimatedComplexity || 'medium',
+        }));
+        const dependencies = parsed.dependencies || {};
+        // Ensure all tasks have entry in dependencies
+        for (const task of tasks) {
+            if (!dependencies[task.id]) {
+                dependencies[task.id] = task.dependencies;
+            }
+        }
+        return {
+            goal: String(parsed.goal || ''),
+            tasks,
+            dependencies,
+            waves: [], // Will be computed via topological sort
+            verificationCriteria: Array.isArray(parsed.verificationCriteria)
+                ? parsed.verificationCriteria.map(String)
+                : [],
+            estimatedDuration: Number(parsed.estimatedDuration) || 0,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to parse planner output: ${error.message}`);
+    }
 }
 // ---------------------------------------------------------------------------
-// Parsing helpers (pure functions)
+// Topological Sort for Wave Grouping
 // ---------------------------------------------------------------------------
-function parseClassification(output) {
-    const jsonMatch = output.match(/```json\s*([\s\S]*?)\s*```/);
-    if (jsonMatch) {
-        try {
-            const parsed = JSON.parse(jsonMatch[1].trim());
-            return {
-                type: parsed.type || 'feature',
-                complexity: parsed.complexity || 'medium',
-                risk: parsed.risk || 'medium',
-                explorationAreas: Array.isArray(parsed.explorationAreas)
-                    ? parsed.explorationAreas.slice(0, 3)
-                    : ['src/'],
-            };
-        }
-        catch {
-            // fall through to defaults
+function groupTasksIntoWaves(plan) {
+    const waves = [];
+    const completed = new Set();
+    const remaining = new Set(plan.tasks.map(t => t.id));
+    const taskMap = new Map(plan.tasks.map(t => [t.id, t]));
+    let waveIndex = 0;
+    // Kahn's algorithm for topological sort with wave grouping
+    while (remaining.size > 0) {
+        // Find all tasks whose dependencies are satisfied
+        const waveTaskIds = [];
+        for (const taskId of remaining) {
+            const deps = plan.dependencies[taskId] || [];
+            const allDepsCompleted = deps.every(dep => completed.has(dep));
+            if (allDepsCompleted) {
+                waveTaskIds.push(taskId);
+            }
         }
-    }
-    return {
-        type: 'feature',
-        complexity: 'medium',
-        risk: 'medium',
-        explorationAreas: ['src/'],
-    };
-}
-function parseSynthesis(output) {
-    const jsonMatch = output.match(/```json\s*([\s\S]*?)\s*```/);
-    if (jsonMatch) {
-        try {
-            const parsed = JSON.parse(jsonMatch[1].trim());
-            return {
-                executionModel: parsed.executionModel || 'ordered-non-parallel',
-                tasks: Array.isArray(parsed.tasks) ? parsed.tasks : [],
-                summary: parsed.summary || 'Plan synthesized',
-            };
+        if (waveTaskIds.length === 0) {
+            // Circular dependency detected
+            const remainingIds = Array.from(remaining).join(', ');
+            throw new Error(`Circular dependency detected among tasks: ${remainingIds}`);
         }
-        catch {
-            // fall through to defaults
+        // Create wave with full task objects
+        const waveTasks = waveTaskIds
+            .map(id => taskMap.get(id))
+            .filter((t) => t !== undefined);
+        waves.push({
+            id: `wave-${waveIndex}`,
+            tasks: waveTasks,
+        });
+        // Mark tasks as completed and remove from remaining
+        for (const taskId of waveTaskIds) {
+            completed.add(taskId);
+            remaining.delete(taskId);
         }
+        waveIndex++;
     }
-    return {
-        executionModel: 'ordered-non-parallel',
-        tasks: [
-            {
-                id: '1',
-                title: 'Implementation',
-                description: 'Core implementation work',
-                owns: [],
-                reads: [],
-                dependencies: [],
-                verification: 'Run tests',
-            },
-        ],
-        summary: output.slice(0, 200),
-    };
-}
-function checkPlanPassed(output) {
-    return !output.toLowerCase().includes('blocked');
-}
-// ---------------------------------------------------------------------------
-// Fallback plan writer (used when write subagent fails)
-// ---------------------------------------------------------------------------
-function buildFallbackPlan(goal, context, synthesis) {
-    const tasksBlock = synthesis.tasks
-        .map((t) => [
-        `### Task ${t.id}: ${t.title}`,
-        '',
-        t.description,
-        '',
-        `- **Owns**: ${t.owns.join(', ') || 'none'}`,
-        `- **Reads**: ${t.reads.join(', ') || 'none'}`,
-        `- **Depends on**: ${t.dependencies.join(', ') || 'none'}`,
-        `- **Verification**: ${t.verification || 'Run tests'}`,
-    ].join('\n'))
-        .join('\n\n');
-    return [
-        `# ${goal}`,
-        '',
-        context ? `## Context\n\n${context}\n` : '',
-        `## Execution Model\n\n${synthesis.executionModel}`,
-        '',
-        '## Tasks',
-        '',
-        tasksBlock,
-    ].join('\n');
+    return waves;
 }
 // ---------------------------------------------------------------------------
-// Skill class
+// Skill Class
 // ---------------------------------------------------------------------------
 export class ToPlanSkill extends Skill {
     constructor() {
         super({
             name: 'to-plan',
-            description: 'Create implementation plans via 5-step subagent dispatch: classify, explore, synthesize, write, check',
+            description: 'Thin orchestrator that delegates planning to subagent with fresh context',
             requires: [],
             inputSchema: ToPlanInputSchema,
             outputSchema: ToPlanOutputSchema,
         });
     }
     async execute(input, context) {
-        const { config, logger } = context;
-        const dispatcher = createDispatcher(logger);
-        const guard = createMainAgentGuard({}, logger);
-        const model = input.model || config.defaultModel;
-        let totalTokens = 0;
-        if (!model) {
-            throw new Error('Model is required. Set defaultModel in config or pass model in input.');
-        }
-        guard.activateEmbargo();
-        try {
-            // ---- Step 0: Research external context (if needed) ----
-            let researchSummary = '';
-            const needsResearch = /api|library|framework|migrate|upgrade|version|best practice/i.test(input.goal);
-            if (needsResearch) {
-                logger.info(`[to-plan] Step 0: Researching "${input.goal.slice(0, 80)}"`);
-                const researchResult = await dispatcher.dispatch({ role: 'researcher', model, tokenBudget: 12000 }, researcherContract({
-                    topic: input.goal,
-                    scope: 'technical',
-                    questions: [
-                        'What are the latest best practices?',
-                        'Are there known issues or breaking changes?',
-                        'What are recommended approaches?'
-                    ],
-                    timeRange: '1y'
-                }));
-                totalTokens += researchResult.tokensUsed;
-                researchSummary = researchResult.output.slice(0, 1500);
-                logger.info(`[to-plan] Research complete: ${researchSummary.slice(0, 100)}...`);
-            }
-            // ---- Step 1: Classify the request ----
-            logger.info(`[to-plan] Step 1: Classifying "${input.goal.slice(0, 80)}"`);
-            const classifyResult = await dispatcher.dispatch({ role: 'explorer', model, tokenBudget: 8000 }, {
-                permissions: {
-                    readFiles: true,
-                    searchCode: false,
-                    runCommands: false,
-                    writeFiles: false,
-                    gitOperations: false,
-                },
-                prompt: buildClassifyPrompt(input.goal, input.context, input.workType, researchSummary),
-                owns: [],
-                reads: [],
-            });
-            totalTokens += classifyResult.tokensUsed;
-            const classification = parseClassification(classifyResult.output);
-            logger.info(`[to-plan] Classified: type=${classification.type}, complexity=${classification.complexity}, risk=${classification.risk}`);
-            // ---- Step 2: Dispatch 1-3 read-only exploration subagents (parallel) ----
-            const areas = classification.explorationAreas.slice(0, 3);
-            logger.info(`[to-plan] Step 2: Dispatching ${areas.length} exploration subagent(s) in parallel`);
-            const exploreConfigs = areas.map(() => ({
-                role: 'explorer',
-                model,
-                tokenBudget: 16000,
-            }));
-            const exploreContracts = areas.map((area) => ({
-                permissions: {
-                    readFiles: true,
-                    searchCode: true,
-                    runCommands: false,
-                    writeFiles: false,
-                    gitOperations: false,
-                },
-                prompt: buildExplorePrompt(area, input.goal, input.context),
-                owns: [],
-                reads: input.filesHint ?? [],
-            }));
-            const exploreResults = areas.length === 1
-                ? [await dispatcher.dispatch(exploreConfigs[0], exploreContracts[0])]
-                : await dispatcher.dispatchParallel(exploreConfigs, exploreContracts);
-            for (const result of exploreResults) {
-                totalTokens += result.tokensUsed;
-            }
-            const successfulExplorations = exploreResults.filter((r) => r.status === 'success');
-            logger.info(`[to-plan] ${successfulExplorations.length}/${areas.length} explorations succeeded`);
-            // ---- Step 3: Synthesize findings ----
-            logger.info('[to-plan] Step 3: Synthesizing findings');
-            const synthesizeResult = await dispatcher.dispatch({ role: 'planner', model }, {
-                permissions: {
-                    readFiles: true,
-                    searchCode: false,
-                    runCommands: false,
-                    writeFiles: false,
-                    gitOperations: false,
-                },
-                prompt: buildSynthesizePrompt(input.goal, input.context, classification, successfulExplorations.map((r) => r.output)),
-                owns: [],
-                reads: [],
-            });
-            totalTokens += synthesizeResult.tokensUsed;
-            const synthesis = parseSynthesis(synthesizeResult.output);
-            logger.info(`[to-plan] Synthesized: ${synthesis.tasks.length} tasks, model=${synthesis.executionModel}`);
-            // ---- Step 4: Write plan to disk ----
-            const date = new Date().toISOString().split('T')[0];
-            const sanitized = input.goal
-                .toLowerCase()
-                .replace(/[^a-z0-9]+/g, '-')
-                .slice(0, 50);
-            const planPath = input.outputPath ||
-                join(config.planPath, `${date}-${sanitized}-implementation-plan.md`);
-            await mkdir(config.planPath, { recursive: true });
-            logger.info(`[to-plan] Step 4: Writing plan to ${planPath}`);
-            const writeResult = await dispatcher.dispatch({ role: 'implementer', model }, {
-                permissions: {
-                    readFiles: false,
-                    searchCode: false,
-                    runCommands: false,
-                    writeFiles: true,
-                    gitOperations: false,
-                },
-                prompt: buildWritePlanPrompt(input.goal, input.context, classification, synthesis, planPath),
-                owns: [planPath],
-                reads: [],
-            });
-            totalTokens += writeResult.tokensUsed;
-            // If the write subagent failed, write a fallback plan
-            if (writeResult.status !== 'success') {
-                const fallback = buildFallbackPlan(input.goal, input.context, synthesis);
-                await writeFile(planPath, fallback, 'utf-8');
-                logger.warn('[to-plan] Write subagent failed; wrote fallback plan');
-            }
-            // ---- Step 5: Dispatch plan-checker subagent ----
-            logger.info('[to-plan] Step 5: Validating plan');
-            const checkerResult = await dispatcher.dispatch({ role: 'reviewer', model }, {
-                permissions: {
-                    readFiles: true,
-                    searchCode: false,
-                    runCommands: false,
-                    writeFiles: false,
-                    gitOperations: false,
-                },
-                prompt: buildPlanCheckPrompt(planPath),
-                owns: [],
-                reads: [planPath],
-            });
-            totalTokens += checkerResult.tokensUsed;
-            const planCheckerPassed = checkPlanPassed(checkerResult.output);
-            logger.info(`[to-plan] Plan checker: ${planCheckerPassed ? 'PASS' : 'BLOCKED'}`);
-            return {
-                planPath,
-                executionModel: synthesis.executionModel,
-                classification: {
-                    type: classification.type,
-                    complexity: classification.complexity,
-                    risk: classification.risk,
-                },
-                planCheckerPassed,
-                tasks: synthesis.tasks,
-                summary: [
-                    `Plan created with ${synthesis.tasks.length} tasks.`,
-                    `Execution model: ${synthesis.executionModel}.`,
-                    `Checker: ${planCheckerPassed ? 'PASS' : 'BLOCKED'}.`,
-                    `Used ${totalTokens} tokens.`,
-                ].join(' '),
-                tokensUsed: totalTokens,
-            };
-        }
-        finally {
-            guard.deactivateEmbargo();
+        const { config, logger, dispatcher } = context;
+        const model = input.model || config.defaultModel || 'claude-sonnet-4.5';
+        let tokensUsed = 0;
+        // Determine paths
+        const statePath = input.outputPath
+            ? input.outputPath.replace(/\.md$/, '-STATE.md')
+            : '.pi/state/STATE.md';
+        const planPath = input.outputPath || '.pi/state/PLAN.md';
+        // Initialize managers
+        const stateManager = new StateMdManager(statePath);
+        const planManager = new PlanMdManager(planPath);
+        // Step 1: Initialize STATE.md with goal
+        logger.info('[to-plan] Initializing STATE.md');
+        await stateManager.initialize(input.goal);
+        // Step 2: Dispatch planner subagent with FRESH context
+        logger.info('[to-plan] Dispatching planner subagent with fresh context');
+        const plannerConfig = {
+            role: 'planner',
+            model,
+            timeout: 120000,
+        };
+        const plannerContract = {
+            permissions: {
+                readFiles: true,
+                searchCode: true,
+                runCommands: false,
+                writeFiles: false,
+                gitOperations: false,
+            },
+            prompt: buildPlannerPrompt(input),
+            owns: [],
+            reads: [],
+        };
+        const plannerResult = await dispatcher.dispatch(plannerConfig, plannerContract);
+        tokensUsed += plannerResult.tokensUsed || 0;
+        logger.info(`[to-plan] Planner subagent completed, used ${plannerResult.tokensUsed} tokens`);
+        // Step 3: Parse plan from subagent output
+        logger.info('[to-plan] Parsing plan from subagent output');
+        const plan = parsePlanFromResponse(plannerResult.output);
+        logger.info(`[to-plan] Parsed ${plan.tasks.length} tasks`);
+        // Step 4: Group tasks into waves via topological sort
+        logger.info('[to-plan] Grouping tasks into waves');
+        const waves = groupTasksIntoWaves(plan);
+        plan.waves = waves;
+        logger.info(`[to-plan] Created ${waves.length} waves for parallel execution`);
+        // Log wave details
+        for (const wave of waves) {
+            const taskIds = wave.tasks.map(t => t.id).join(', ');
+            logger.info(`[to-plan]   ${wave.id}: ${taskIds}`);
         }
+        // Step 5: Write PLAN.md
+        logger.info(`[to-plan] Writing plan to ${planPath}`);
+        await planManager.writePlan(plan);
+        // Step 6: Update STATE.md with plan
+        logger.info('[to-plan] Recording plan in STATE.md');
+        await stateManager.recordPlan(plan);
+        await stateManager.updatePhase('planning');
+        await stateManager.updateTokenUsage(tokensUsed);
+        // Build summary
+        const summary = [
+            `Plan created with ${plan.tasks.length} tasks`,
+            `Organized into ${waves.length} parallel waves`,
+            `Estimated duration: ${plan.estimatedDuration}ms`,
+            `Used ${tokensUsed} tokens`,
+        ].join('. ');
+        logger.info(`[to-plan] ${summary}`);
+        return {
+            planPath,
+            waves,
+            taskCount: plan.tasks.length,
+            summary,
+            tokensUsed,
+        };
     }
 }
 export const toPlanSkill = new ToPlanSkill();