Bash({
  command: `ccw cli -p "PURPOSE: Analyze requirement complexity and select 1-4 exploration angles for codebase discovery before implementation.

if (!AUTO_YES) {
  console.log(`\n## Exploration Plan (${angles.length} angles)\n`)
  angles.forEach(a => console.log(`  - [${a.id}] ${a.angle}: ${a.focus}`))

  const answer = AskUserQuestion({
    questions: [{
      question: "Approve exploration angles?",
      header: "Validation",
      multiSelect: false,
      options: [
        { label: "Approve", description: "Proceed with wave exploration" },
        { label: "Modify", description: `Edit ${sessionFolder}/explore.csv manually, then --continue` },
        { label: "Cancel", description: "Abort" }
      ]
    }]
  })

  if (answer.Validation === "Modify") {
    console.log(`Edit: ${sessionFolder}/explore.csv\nResume: $wave-plan-pipeline --continue`)
    return
  } else if (answer.Validation === "Cancel") {
    return
  }
}

const exploreCSV = parseCsv(Read(`${sessionFolder}/explore.csv`))
const maxExploreWave = Math.max(...exploreCSV.map(r => parseInt(r.wave)))

for (let wave = 1; wave <= maxExploreWave; wave++) {
  const waveTasks = exploreCSV.filter(r =>
    parseInt(r.wave) === wave && r.status === 'pending'
  )
  if (waveTasks.length === 0) continue

  // Skip rows with failed dependencies
  const executableTasks = []
  for (const task of waveTasks) {
    const deps = (task.deps || '').split(';').filter(Boolean)
    if (deps.some(d => {
      const dep = exploreCSV.find(r => r.id === d)
      return !dep || dep.status !== 'completed'
    })) {
      task.status = 'skipped'
      task.error = 'Dependency failed/skipped'
      continue
    }
    executableTasks.push(task)
  }

  if (executableTasks.length === 0) continue

  // Write explore wave CSV
  const waveHeader = 'id,angle,description,focus,deps,wave'
  const waveRows = executableTasks.map(t =>
    [t.id, t.angle, t.description, t.focus, t.deps, t.wave]
      .map(v => `"${String(v).replace(/"/g, '""')}"`)
      .join(',')
  )
  Write(`${sessionFolder}/explore-wave-${wave}.csv`, [waveHeader, ...waveRows].join('\n'))

  // Execute explore wave
  console.log(`  Exploring ${executableTasks.length} angles (wave ${wave})...`)

  spawn_agents_on_csv({
    csv_path: `${sessionFolder}/explore-wave-${wave}.csv`,
    id_column: "id",
    instruction: buildExploreInstruction(sessionFolder),
    max_concurrency: maxConcurrency,
    max_runtime_seconds: 300,
    output_csv_path: `${sessionFolder}/explore-wave-${wave}-results.csv`,
    output_schema: {
      type: "object",
      properties: {
        id: { type: "string" },
        status: { type: "string", enum: ["completed", "failed"] },
        findings: { type: "string" },
        key_files: { type: "array", items: { type: "string" } },
        error: { type: "string" }
      },
      required: ["id", "status", "findings"]
    }
  })

  // Merge results into explore.csv
  const waveResults = parseCsv(Read(`${sessionFolder}/explore-wave-${wave}-results.csv`))
  for (const result of waveResults) {
    updateMasterCsvRow(`${sessionFolder}/explore.csv`, result.id, {
      status: result.status,
      findings: result.findings || '',
      key_files: Array.isArray(result.key_files) ? result.key_files.join(';') : (result.key_files || ''),
      error: result.error || ''
    })
  }

  // Cleanup temporary wave CSV
  Bash(`rm -f "${sessionFolder}/explore-wave-${wave}.csv" "${sessionFolder}/explore-wave-${wave}-results.csv"`)
}

function buildExploreInstruction(sessionFolder) {
  return `

const exploreCSV = parseCsv(Read(`${sessionFolder}/explore.csv`))
const completed = exploreCSV.filter(r => r.status === 'completed')

// Cross-reference: find shared files across angles
const fileRefs = {}
completed.forEach(r => {
  (r.key_files || '').split(';').filter(Boolean).forEach(f => {
    if (!fileRefs[f]) fileRefs[f] = []
    fileRefs[f].push({ angle: r.angle, id: r.id })
  })
})
const sharedFiles = Object.entries(fileRefs).filter(([_, refs]) => refs.length > 1)

// Build synthesis context for task decomposition
const synthesisContext = completed.map(r =>
  `[${r.id}: ${r.angle}] ${r.findings}\n  Key files: ${r.key_files || 'none'}`
).join('\n\n')

const sharedFilesContext = sharedFiles.length > 0
  ? `\nShared files (referenced by multiple angles):\n${sharedFiles.map(([f, refs]) =>
      `  ${f} ← ${refs.map(r => r.id).join(', ')}`
    ).join('\n')}`
  : ''

Bash({
  command: `ccw cli -p "PURPOSE: Based on exploration findings, decompose requirement into 3-10 atomic execution tasks. Each task must include test cases, acceptance criteria, and link to relevant exploration findings.

if (!AUTO_YES) {
  console.log(`

const exploreCSV = parseCsv(Read(`${sessionFolder}/explore.csv`))
const failedIds = new Set()
const skippedIds = new Set()

for (let wave = 1; wave <= maxWave; wave++) {
  console.log(`\n## Wave ${wave}/${maxWave}\n`)

  // Re-read master CSV
  const masterCsv = parseCsv(Read(`${sessionFolder}/tasks.csv`))
  const waveTasks = masterCsv.filter(row => parseInt(row.wave) === wave)

  // Skip tasks whose deps failed
  const executableTasks = []
  for (const task of waveTasks) {
    const deps = (task.deps || '').split(';').filter(Boolean)
    if (deps.some(d => failedIds.has(d) || skippedIds.has(d))) {
      skippedIds.add(task.id)
      updateMasterCsvRow(`${sessionFolder}/tasks.csv`, task.id, {
        status: 'skipped',
        error: 'Dependency failed or skipped'
      })
      console.log(`  [${task.id}] ${task.title} → SKIPPED (dependency failed)`)
      continue
    }
    executableTasks.push(task)
  }

  if (executableTasks.length === 0) {
    console.log(`  No executable tasks in wave ${wave}`)
    continue
  }

  // Build prev_context for each task (cross-phase: E* + T*)
  for (const task of executableTasks) {
    task.prev_context = buildPrevContext(task.context_from, exploreCSV, masterCsv)
  }

  // Write wave CSV
  const waveHeader = 'id,title,description,test,acceptance_criteria,scope,hints,execution_directives,deps,context_from,wave,prev_context'
  const waveRows = executableTasks.map(t =>
    [t.id, t.title, t.description, t.test, t.acceptance_criteria, t.scope, t.hints, t.execution_directives, t.deps, t.context_from, t.wave, t.prev_context]
      .map(cell => `"${String(cell).replace(/"/g, '""')}"`)
      .join(',')
  )
  Write(`${sessionFolder}/task-wave-${wave}.csv`, [waveHeader, ...waveRows].join('\n'))

  // Execute wave
  console.log(`  Executing ${executableTasks.length} tasks (concurrency: ${maxConcurrency})...`)

  spawn_agents_on_csv({
    csv_path: `${sessionFolder}/task-wave-${wave}.csv`,
    id_column: "id",
    instruction: buildExecuteInstruction(sessionFolder, wave),
    max_concurrency: maxConcurrency,
    max_runtime_seconds: 600,
    output_csv_path: `${sessionFolder}/task-wave-${wave}-results.csv`,
    output_schema: {
      type: "object",
      properties: {
        id: { type: "string" },
        status: { type: "string", enum: ["completed", "failed"] },
        findings: { type: "string" },
        files_modified: { type: "array", items: { type: "string" } },
        tests_passed: { type: "boolean" },
        acceptance_met: { type: "string" },
        error: { type: "string" }
      },
      required: ["id", "status", "findings", "tests_passed"]
    }
  })

  // Merge results into master CSV
  const waveResults = parseCsv(Read(`${sessionFolder}/task-wave-${wave}-results.csv`))
  for (const result of waveResults) {
    updateMasterCsvRow(`${sessionFolder}/tasks.csv`, result.id, {
      status: result.status,
      findings: result.findings || '',
      files_modified: Array.isArray(result.files_modified) ? result.files_modified.join(';') : (result.files_modified || ''),
      tests_passed: String(result.tests_passed ?? ''),
      acceptance_met: result.acceptance_met || '',
      error: result.error || ''
    })

    if (result.status === 'failed') {
      failedIds.add(result.id)
      console.log(`  [${result.id}] → FAILED: ${result.error}`)
    } else {
      console.log(`  [${result.id}] → COMPLETED${result.tests_passed ? ' ✓tests' : ''}`)
    }
  }

  // Cleanup
  Bash(`rm -f "${sessionFolder}/task-wave-${wave}.csv" "${sessionFolder}/task-wave-${wave}-results.csv"`)

  console.log(`  Wave ${wave} done: ${waveResults.filter(r => r.status === 'completed').length} completed, ${waveResults.filter(r => r.status === 'failed').length} failed`)
}

function buildPrevContext(contextFrom, exploreCSV, tasksCSV) {
  if (!contextFrom) return 'No previous context available'

  const ids = contextFrom.split(';').filter(Boolean)
  const entries = []

  ids.forEach(id => {
    if (id.startsWith('E')) {
      // ← Look up in explore.csv (cross-phase link)
      const row = exploreCSV.find(r => r.id === id)
      if (row && row.status === 'completed' && row.findings) {
        entries.push(`[Explore ${row.angle}] ${row.findings}`)
        if (row.key_files) entries.push(`  Key files: ${row.key_files}`)
      }
    } else if (id.startsWith('T')) {
      // ← Look up in tasks.csv (same-phase link)
      const row = tasksCSV.find(r => r.id === id)
      if (row && row.status === 'completed' && row.findings) {
        entries.push(`[Task ${row.id}: ${row.title}] ${row.findings}`)
        if (row.files_modified) entries.push(`  Modified: ${row.files_modified}`)
      }
    }
  })

  return entries.length > 0 ? entries.join('\n') : 'No previous context available'
}

function buildExecuteInstruction(sessionFolder, wave) {
  return `