@haoyiyin/workflow 0.2.11 → 0.3.0

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

@@ -1,25 +1,24 @@
 /**
- * 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 type { SkillContext } from '../types.js'
-import { createDispatcher } from '../../agents/dispatcher.js'
-import type { SubagentContract, SubagentConfig } from '../../agents/types.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'
+import type { Plan, Task, Wave } from '../../persistence/types.js'
+import type { SubagentConfig, SubagentContract } from '../../agents/types.js'
 
 // ---------------------------------------------------------------------------
 // Schemas
@@ -28,335 +27,188 @@ import { join } from 'path'
 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<Wave>()),
+  taskCount: z.number(),
   summary: z.string(),
   tokensUsed: z.number(),
 })
 
 type ToPlanInput = z.infer<typeof ToPlanInputSchema>
 type ToPlanOutput = z.infer<typeof ToPlanOutputSchema>
-type TaskDef = z.infer<typeof TaskSchema>
 
 // ---------------------------------------------------------------------------
-// Pure helper types
+// Planner Subagent Prompt
 // ---------------------------------------------------------------------------
 
-interface Classification {
-  type: string
-  complexity: 'low' | 'medium' | 'high'
-  risk: 'low' | 'medium' | 'high'
-  explorationAreas: string[]
-}
+function buildPlannerPrompt(input: ToPlanInput): string {
+  return `# Planning Task
 
-interface SynthesizedPlan {
-  executionModel: 'single-agent' | 'ordered-non-parallel' | 'fan-out-fan-in'
-  tasks: TaskDef[]
-  summary: string
-}
+## Goal
+${input.goal}
 
-// ---------------------------------------------------------------------------
-// Step 1: Classify prompt builder
-// ---------------------------------------------------------------------------
+${input.context ? `## Context\n${input.context}\n` : ''}
+${input.constraints ? `## Constraints\n${input.constraints.map(c => `- ${c}`).join('\n')}\n` : ''}
 
-function buildClassifyPrompt(goal: string, context?: string, workType?: string, researchFindings?: string): string {
-  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')
-}
+## Instructions
 
-// ---------------------------------------------------------------------------
-// Step 2: Exploration prompt builder (one per area)
-// ---------------------------------------------------------------------------
+Create a detailed implementation plan. Break the work into small, concrete tasks.
 
-function buildExplorePrompt(area: string, goal: string, context?: string): string {
-  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')
-}
+### 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
 
-// ---------------------------------------------------------------------------
-// Step 3: Synthesize prompt builder
-// ---------------------------------------------------------------------------
+### Output Format
 
-function buildSynthesizePrompt(
-  goal: string,
-  context: string | undefined,
-  classification: Classification,
-  explorationOutputs: string[],
-): string {
-  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')
+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"
+}
+\`\`\`
+
+## 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 4: Write plan prompt builder
+// Parsing Helpers
 // ---------------------------------------------------------------------------
 
-function buildWritePlanPrompt(
-  goal: string,
-  context: string | undefined,
-  classification: Classification,
-  synthesis: SynthesizedPlan,
-  planPath: string,
-): string {
-  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')
+function parsePlanFromResponse(response: string): Plan {
+  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: Task[] = (parsed.tasks || []).map((t: Record<string, unknown>) => ({
+      id: String(t.id || ''),
+      description: String(t.description || ''),
+      status: 'pending',
+      dependencies: Array.isArray(t.dependencies) ? t.dependencies.map(String) : [],
+      estimatedComplexity: (t.estimatedComplexity as 'low' | 'medium' | 'high') || 'medium',
+    }))
+
+    const dependencies: Record<string, string[]> = 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 as Error).message}`)
+  }
 }
 
 // ---------------------------------------------------------------------------
-// Step 5: Plan check prompt builder
+// Topological Sort for Wave Grouping
 // ---------------------------------------------------------------------------
 
-function buildPlanCheckPrompt(planPath: string): string {
-  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 groupTasksIntoWaves(plan: Plan): Wave[] {
+  const waves: Wave[] = []
+  const completed = new Set<string>()
+  const remaining = new Set(plan.tasks.map(t => t.id))
+  const taskMap = new Map(plan.tasks.map(t => [t.id, t]))
+  let waveIndex = 0
 
-// ---------------------------------------------------------------------------
-// Parsing helpers (pure functions)
-// ---------------------------------------------------------------------------
+  // Kahn's algorithm for topological sort with wave grouping
+  while (remaining.size > 0) {
+    // Find all tasks whose dependencies are satisfied
+    const waveTaskIds: string[] = []
+
+    for (const taskId of remaining) {
+      const deps = plan.dependencies[taskId] || []
+      const allDepsCompleted = deps.every(dep => completed.has(dep))
 
-function parseClassification(output: string): Classification {
-  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/'],
+      if (allDepsCompleted) {
+        waveTaskIds.push(taskId)
       }
-    } catch {
-      // fall through to defaults
     }
-  }
-  return {
-    type: 'feature',
-    complexity: 'medium',
-    risk: 'medium',
-    explorationAreas: ['src/'],
-  }
-}
 
-function parseSynthesis(output: string): SynthesizedPlan {
-  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',
-      }
-    } catch {
-      // fall through to defaults
+    if (waveTaskIds.length === 0) {
+      // Circular dependency detected
+      const remainingIds = Array.from(remaining).join(', ')
+      throw new Error(`Circular dependency detected among tasks: ${remainingIds}`)
     }
-  }
-  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: string): boolean {
-  return !output.toLowerCase().includes('blocked')
-}
+    // Create wave with full task objects
+    const waveTasks = waveTaskIds
+      .map(id => taskMap.get(id))
+      .filter((t): t is Task => t !== undefined)
 
-// ---------------------------------------------------------------------------
-// Fallback plan writer (used when write subagent fails)
-// ---------------------------------------------------------------------------
+    waves.push({
+      id: `wave-${waveIndex}`,
+      tasks: waveTasks,
+    })
 
-function buildFallbackPlan(
-  goal: string,
-  context: string | undefined,
-  synthesis: SynthesizedPlan,
-): string {
-  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')
+    // Mark tasks as completed and remove from remaining
+    for (const taskId of waveTaskIds) {
+      completed.add(taskId)
+      remaining.delete(taskId)
+    }
+
+    waveIndex++
+  }
+
+  return waves
 }
 
 // ---------------------------------------------------------------------------
-// Skill class
+// Skill Class
 // ---------------------------------------------------------------------------
 
 export class ToPlanSkill extends Skill<ToPlanInput, ToPlanOutput> {
   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,
@@ -364,220 +216,97 @@ export class ToPlanSkill extends Skill<ToPlanInput, ToPlanOutput> {
   }
 
   async execute(input: ToPlanInput, context: SkillContext): Promise<ToPlanOutput> {
-    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.')
+    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: SubagentConfig = {
+      role: 'planner',
+      model,
+      timeout: 120000,
     }
 
-    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)}...`)
-      }
+    const plannerContract: SubagentContract = {
+      permissions: {
+        readFiles: true,
+        searchCode: true,
+        runCommands: false,
+        writeFiles: false,
+        gitOperations: false,
+      },
+      prompt: buildPlannerPrompt(input),
+      owns: [],
+      reads: [],
+    }
 
-      // ---- 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: SubagentConfig[] = areas.map(() => ({
-        role: 'explorer' as const,
-        model,
-        tokenBudget: 16000,
-      }))
-
-      const exploreContracts: SubagentContract[] = 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 plannerResult = await dispatcher.dispatch<{ output: string; tokensUsed: number }>(
+      plannerConfig,
+      plannerContract
+    )
 
-      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')
-      }
+    tokensUsed += plannerResult.tokensUsed || 0
+    logger.info(`[to-plan] Planner subagent completed, used ${plannerResult.tokensUsed} tokens`)
 
-      // ---- 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()
+    // 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,
     }
   }
 }