Workflow Lite Plan

<task-description>         Task description or path to .md file (required)

if (typeof workflowPreferences === 'undefined' || workflowPreferences === null) {
  workflowPreferences = {
    autoYes: false,      // false: show LP-Phase 2/4 prompts | true (-y): skip all prompts
    forceExplore: false
  }
}

const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
const priorHeader = task_description.match(/^## Prior (?:Analysis|Brainstorm) \((.+?)\)/m)
const taskSlug = (priorHeader ? priorHeader[1] : task_description).toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 40).replace(/^-+|-+$/g, '')
const dateStr = getUtc8ISOString().substring(0, 10)
const sessionId = `${taskSlug}-${dateStr}`
const sessionFolder = `.workflow/.lite-plan/${sessionId}`
bash(`mkdir -p ${sessionFolder} && test -d ${sessionFolder} && echo "SUCCESS: ${sessionFolder}" || echo "FAILED: ${sessionFolder}"`)

// Pattern: set phases[0..N-1].status="completed", phases[N].status="in_progress"
// Only full block shown here; subsequent updates follow same structure with status changes
TodoWrite({ todos: [
  { content: `LP-Phase 1: Exploration [${complexity}] ${selectedAngles.length} angles`, status: "in_progress", activeForm: `Exploring: ${selectedAngles.join(', ')}` },
  { content: "LP-Phase 2: Clarification", status: "pending" },
  { content: "LP-Phase 3: Planning [cli-lite-planning-agent]", status: "pending" },
  { content: "LP-Phase 4: Confirmation", status: "pending" },
  { content: "LP-Phase 5: Execution", status: "pending" }
]})

const hasPriorAnalysis = /##\s*Prior Analysis/i.test(task_description)
const hasHandoffSpec = /```json:handoff-spec/i.test(task_description)

// Parse structured handoff from analyze-with-file or brainstorm-with-file (if present)
let handoffSpec = null
if (hasHandoffSpec) {
  const specMatch = task_description.match(/```json:handoff-spec\s*\n([\s\S]*?)\n```/)
  if (specMatch) {
    handoffSpec = JSON.parse(specMatch[1])
    // handoffSpec contains: { source, session_id, session_folder, summary,
    //   implementation_scope[], code_anchors[], key_files[], key_findings[], decision_context[],
    //   exploration_artifacts: { exploration_codebase, explorations, perspectives, research, deep_dives[] } }
    // implementation_scope[]: { objective, rationale, priority, target_files[], acceptance_criteria[], change_summary }
    console.log(`[Handoff] From ${handoffSpec.source} session ${handoffSpec.session_id}`)
    console.log(`[Handoff] ${handoffSpec.implementation_scope.length} scoped items with acceptance criteria`)

    // Enrich task_description with handoff context for downstream planning agent
    // These fields were previously produced but unused — now injected into planning context
    if (handoffSpec.summary) {
      task_description += `\n\n## Analysis Summary\n${handoffSpec.summary}`
    }
    if (handoffSpec.key_findings?.length > 0) {
      task_description += `\n\n## Key Findings\n${handoffSpec.key_findings.map((f, i) =>
        `${i+1}. ${f.point || f} (${f.confidence || 'medium'})`).join('\n')}`
    }
    if (handoffSpec.decision_context?.length > 0) {
      task_description += `\n\n## Decision Context\n${handoffSpec.decision_context.map(d =>
        `- **${d.decision || d}**: ${d.reason || ''}`).join('\n')}`
    }
    if (handoffSpec.code_anchors?.length > 0) {
      task_description += `\n\n## Code Anchors\n${handoffSpec.code_anchors.slice(0, 10).map(a =>
        `- \`${a.file}:${a.lines}\`: ${a.significance}`).join('\n')}`
    }
  }
}

// Brainstorm handoff has no code_anchors/key_files — needs exploration for implementation context
const isBrainstormSource = handoffSpec?.source === 'brainstorm-with-file'
const isAnalysisSource = handoffSpec?.source === 'analyze-with-file'

needsExploration = workflowPreferences.forceExplore ? true
  : isBrainstormSource ? true  // brainstorm explore is lightweight, lite-plan needs deeper exploration
  : (hasPriorAnalysis || isAnalysisSource) ? false
  : (task.mentions_specific_files ||
     task.requires_codebase_context ||
     task.needs_architecture_understanding ||
     task.modifies_existing_code)

if (!needsExploration) {
  // Bridge: Build manifest from analyze session's exploration artifacts
  if (isAnalysisSource && handoffSpec?.exploration_artifacts) {
    const artifacts = handoffSpec.exploration_artifacts
    const explorationEntries = []
    let idx = 1
    const artifactMapping = [
      { key: 'exploration_codebase', angle: 'codebase-discovery' },
      { key: 'explorations', angle: 'analysis-findings' },
      { key: 'perspectives', angle: 'multi-perspective' },
      { key: 'research', angle: 'external-research' }
    ]
    artifactMapping.forEach(({ key, angle }) => {
      if (artifacts[key] && file_exists(artifacts[key])) {
        explorationEntries.push({
          angle, file: artifacts[key].split('/').pop(),
          path: artifacts[key], source_schema: 'analyze', index: idx++
        })
      }
    })
    if (artifacts.deep_dives?.length > 0) {
      artifacts.deep_dives.forEach(divePath => {
        if (file_exists(divePath)) {
          const name = divePath.match(/explorations\/(.+)\.json$/)?.[1] || `deep-dive-${idx}`
          explorationEntries.push({
            angle: name, file: `${name}.json`,
            path: divePath, source_schema: 'analyze', index: idx++
          })
        }
      })
    }
    if (explorationEntries.length > 0) {
      Write(`${sessionFolder}/explorations-manifest.json`, JSON.stringify({
        session_id: sessionId, task_description, timestamp: getUtc8ISOString(),
        complexity, exploration_count: explorationEntries.length,
        source: 'analyze-with-file', source_session: handoffSpec.session_id,
        explorations: explorationEntries
      }, null, 2))
      console.log(`[Analyze Bridge] ${explorationEntries.length} artifacts from ${handoffSpec.session_id}`)
    }
  }
  // If no manifest built; LP-Phase 3 loads with safe fallback
  proceed_to_next_phase()
}

const complexity = analyzeTaskComplexity(task_description)
// 'Low': single file, single function, zero cross-module impact (fix typo, rename var, adjust constant)
// 'Medium': multiple files OR integration point OR new pattern (add endpoint, implement feature, refactor)
// 'High': cross-module, architectural, systemic (new subsystem, migration, security overhaul)
// Default bias: uncertain between Low/Medium → choose Medium

const ANGLE_PRESETS = {
  architecture: ['architecture', 'dependencies', 'modularity', 'integration-points'],
  security: ['security', 'auth-patterns', 'dataflow', 'validation'],
  performance: ['performance', 'bottlenecks', 'caching', 'data-access'],
  bugfix: ['error-handling', 'dataflow', 'state-management', 'edge-cases'],
  feature: ['patterns', 'integration-points', 'testing', 'dependencies']
}

function selectAngles(taskDescription, count) {
  const text = taskDescription.toLowerCase()
  let preset = 'feature'
  if (/refactor|architect|restructure|modular/.test(text)) preset = 'architecture'
  else if (/security|auth|permission|access/.test(text)) preset = 'security'
  else if (/performance|slow|optimi|cache/.test(text)) preset = 'performance'
  else if (/fix|bug|error|issue|broken/.test(text)) preset = 'bugfix'
  return ANGLE_PRESETS[preset].slice(0, count)
}

const selectedAngles = selectAngles(task_description, complexity === 'High' ? 4 : (complexity === 'Medium' ? 3 : 1))

console.log(`Exploration Plan: ${complexity} | ${selectedAngles.join(', ')} | cli-lite-planning-agent`)

const explorationTasks = selectedAngles.map((angle, index) =>
  Task(
    subagent_type="cli-explore-agent",
    run_in_background=false,
    description=`Explore: ${angle}`,
    prompt=`
## Task Objective
Execute **${angle}** exploration for task planning context.

## Output Location
**Session Folder**: ${sessionFolder}
**Output File**: ${sessionFolder}/exploration-${angle}.json

## Assigned Context
- **Exploration Angle**: ${angle}
- **Task Description**: ${task_description}
- **Exploration Index**: ${index + 1} of ${selectedAngles.length}

## Exploration Strategy (${angle} focus)

**Step 1: Structural Scan** (Bash)
- get_modules_by_depth.sh → identify modules related to ${angle}
- find/rg → locate files relevant to ${angle} aspect
- Analyze imports/dependencies from ${angle} perspective

**Step 2: Semantic Analysis** (Gemini CLI)
- How does existing code handle ${angle} concerns?
- What patterns are used for ${angle}?
- Where would new code integrate from ${angle} viewpoint?

**Step 3: Write Output**
- Consolidate ${angle} findings into JSON
- Identify ${angle}-specific clarification needs

## Expected Output
**Schema**: explore-json-schema.json (auto-loaded by agent)
- All fields scoped to ${angle} perspective
- Ensure rationale is specific and >10 chars (not generic)
- Include file:line locations in integration_points
- _metadata.exploration_angle: "${angle}"

## Success Criteria
- [ ] get_modules_by_depth.sh executed
- [ ] At least 3 relevant files with specific rationale (>10 chars) + role classification
- [ ] Patterns are actionable (code examples, not generic advice)
- [ ] Integration points include file:line locations
- [ ] Constraints are project-specific to ${angle}
- [ ] JSON follows schema; clarification_needs includes options + recommended
- [ ] Files with relevance >= 0.7 have key_code array + topic_relation

## Execution
**Write**: \`${sessionFolder}/exploration-${angle}.json\`
**Return**: 2-3 sentence summary of ${angle} findings
`
  )
)
// Execute all exploration tasks in parallel

const explorationFiles = bash(`find ${sessionFolder} -name "exploration-*.json" -type f`)
  .split('\n').filter(f => f.trim())

const explorationManifest = {
  session_id: sessionId,
  task_description: task_description,
  timestamp: getUtc8ISOString(),
  complexity: complexity,
  exploration_count: explorationFiles.length,
  explorations: explorationFiles.map(file => {
    const data = JSON.parse(Read(file))
    return {
      angle: data._metadata.exploration_angle,
      file: path.basename(file),
      path: file,
      index: data._metadata.exploration_index
    }
  })
}

Write(`${sessionFolder}/explorations-manifest.json`, JSON.stringify(explorationManifest, null, 2))
console.log(`Exploration complete: ${explorationManifest.explorations.map(e => e.angle).join(', ')}`)

const manifest = file_exists(`${sessionFolder}/explorations-manifest.json`)
  ? JSON.parse(Read(`${sessionFolder}/explorations-manifest.json`))
  : { exploration_count: 0, explorations: [] }
const explorations = manifest.explorations.map(exp => ({
  angle: exp.angle,
  data: JSON.parse(Read(exp.path))
}))

// Aggregate from all explorations
const allClarifications = []
explorations.forEach(exp => {
  if (exp.data.clarification_needs?.length > 0) {
    exp.data.clarification_needs.forEach(need => {
      allClarifications.push({ ...need, source_angle: exp.angle })
    })
  }
})

// Intelligent dedup: merge similar intent across angles, combine options
const dedupedClarifications = intelligentMerge(allClarifications)

if (workflowPreferences.autoYes) {
  console.log(`[Auto] Skipping ${dedupedClarifications.length} clarification questions`)
} else if (dedupedClarifications.length > 0) {
  const BATCH_SIZE = 4
  const totalRounds = Math.ceil(dedupedClarifications.length / BATCH_SIZE)

  for (let i = 0; i < dedupedClarifications.length; i += BATCH_SIZE) {
    const batch = dedupedClarifications.slice(i, i + BATCH_SIZE)
    const currentRound = Math.floor(i / BATCH_SIZE) + 1
    console.log(`### Clarification Round ${currentRound}/${totalRounds}`)

    AskUserQuestion({
      questions: batch.map(need => ({
        question: `[${need.source_angle}] ${need.question}\n\nContext: ${need.context}`,
        header: need.source_angle.substring(0, 12),
        multiSelect: false,
        options: need.options.map((opt, index) => ({
          label: need.recommended === index ? `${opt} ★` : opt,
          description: need.recommended === index ? `Recommended` : `Use ${opt}`
        }))
      }))
    })
    // Store batch responses in clarificationContext before next round
  }
}

// Priority: 1. User explicit ("用 gemini 分析..." → gemini) | 2. Default → agent
const executorAssignments = {}  // { taskId: { executor: 'gemini'|'codex'|'agent', reason } }
const taskFiles = Glob(`${sessionFolder}/.task/TASK-*.json`)
taskFiles.forEach(taskPath => {
  const task = JSON.parse(Read(taskPath))
  executorAssignments[task.id] = { executor: '...', reason: '...' }
})

Task(
  subagent_type="cli-lite-planning-agent",
  run_in_background=false,
  description="Generate detailed implementation plan",
  prompt=`
Generate implementation plan and write plan.json.

## Output Location
**Session Folder**: ${sessionFolder}
**Output Files**:
- ${sessionFolder}/planning-context.md (evidence + understanding)
- ${sessionFolder}/plan.json (plan overview — NO embedded tasks[])
- ${sessionFolder}/.task/TASK-*.json (independent task files, one per task)

## Project Context (MANDATORY)
Execute: ccw spec load --category planning
**CRITICAL**: All generated tasks MUST comply with constraints in specs/*.md

## Task Description
${task_description}

## Multi-Angle Exploration Context

${manifest.explorations.length > 0
  ? manifest.explorations.map(exp => `### Exploration: ${exp.angle} (${exp.file})
Path: ${exp.path}
Read this file for detailed ${exp.angle} analysis.`).join('\n\n') + `

Total: ${manifest.exploration_count} | Angles: ${manifest.explorations.map(e => e.angle).join(', ')}
Manifest: ${sessionFolder}/explorations-manifest.json`
  : `No exploration files. Task Description contains "## Prior Analysis" — use as primary planning context.`}

## Structured Handoff Spec (from ${handoffSpec?.source || 'upstream workflow'})
${handoffSpec ? `
**Source**: ${handoffSpec.source} session ${handoffSpec.session_id}
**CRITICAL**: Use implementation_scope as PRIMARY input for task generation.
${isBrainstormSource ? '**NOTE**: Brainstorm source — code_anchors/key_files are empty. Use exploration results as primary file context.' : ''}
Each scope item maps to one or more tasks. Acceptance criteria become convergence.criteria.

${JSON.stringify(handoffSpec.implementation_scope, null, 2)}

**Code Anchors** (implementation targets):
${JSON.stringify(handoffSpec.code_anchors?.slice(0, 8), null, 2)}

**Key Findings** (context):
${JSON.stringify(handoffSpec.key_findings?.slice(0, 5), null, 2)}

**Task Generation Rules when handoffSpec present**:
1. Each implementation_scope item → 1 task (group only if tightly coupled)
2. scope.acceptance_criteria[] → task.convergence.criteria[]
3. scope.target_files[] → task.files[] with change from scope.change_summary
4. scope.objective → task.title, scope.rationale → task.description context
5. scope.priority → task ordering (high first)
` : 'No structured handoff spec — use task description and explorations as input.'}

## User Clarifications
${JSON.stringify(clarificationContext) || "None"}

## Complexity Level
${complexity}

## Requirements
- _metadata.exploration_angles: ${JSON.stringify(manifest.explorations.map(e => e.angle))}
- Two-layer output: plan.json (task_ids[], NO tasks[]) + .task/TASK-*.json
- Field names: files[].change (not modification_points), convergence.criteria (not acceptance)

## Task Grouping Rules
1. **Group by feature**: All changes for one feature = one task (even if 3-5 files)
2. **Group by context**: Related functional changes can be grouped together
3. **Minimize agent count**: Group simple unrelated tasks to reduce overhead
4. **Avoid file-per-task**: Do NOT create separate tasks for each file
5. **Substantial tasks**: Each task = 15-60 minutes of work
6. **True dependencies only**: depends_on only when Task B needs Task A's output
7. **Prefer parallel**: Most tasks should be independent

## Execution
1. ccw spec load → 2. Read ALL exploration files → 3. Synthesize + generate
4. Write: planning-context.md, .task/TASK-*.json, plan.json (task_ids[], NO tasks[])
5. Return brief completion summary
`
)