Claude-Code-Workflow/.claude/commands/workflow/lite-lite-lite.md

name, description, argument-hint, allowed-tools

name	description	argument-hint	allowed-tools
workflow:lite-lite-lite	Ultra-lightweight multi-tool analysis and direct execution. No artifacts, auto tool selection based on task analysis, user-driven iteration via AskUser.	<task description>	TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), mcp__ace-tool__search_context(*)

Ultra-Lite Multi-Tool Workflow

Quick Start

# Basic usage
/workflow:lite-lite-lite "Fix the login bug"

# Complex task
/workflow:lite-lite-lite "Refactor payment module for multi-gateway support"

Core Philosophy: Minimal friction, maximum velocity. No files, no artifacts - just analyze and execute.

What & Why

Core Concept

Zero-artifact workflow: Clarify requirements → Auto-select tools → Mixed tool analysis → User decision → Direct execution. All state in memory, all decisions via AskUser.

vs multi-cli-plan:

• multi-cli-plan: Full artifacts (IMPL_PLAN.md, plan.json, synthesis.json)
• lite-lite-lite: No files, direct in-memory flow, immediate execution

Value Proposition

1. Ultra-Fast: No file I/O overhead, no session management
2. Smart Selection: Auto-select optimal tool combination based on task
3. Interactive: Key decisions validated via AskUser
4. Direct: Analysis → Execution without intermediate artifacts

Execution Flow

Phase 1: Clarify Requirements
   └─ Parse input → AskUser for missing details (if needed)

Phase 2: Auto-Select Tools
   └─ Analyze task → Match to tool strengths → Confirm selection

Phase 3: Mixed Tool Analysis
   └─ Execute selected tools in parallel → Aggregate results

Phase 4: User Decision
   ├─ Present analysis summary
   ├─ AskUser: Execute / Refine / Change tools / Cancel
   └─ Loop to Phase 3 if refinement needed

Phase 5: Direct Execution
   └─ Execute solution directly (no plan files)

Phase Details

Phase 1: Clarify Requirements

Parse Task Description:

// Extract intent from user input
const taskDescription = $ARGUMENTS

// Check if clarification needed
if (taskDescription.length < 20 || isAmbiguous(taskDescription)) {
  AskUserQuestion({
    questions: [{
      question: "Please provide more details: target files/modules, expected behavior, constraints?",
      header: "Details",
      options: [
        { label: "I'll provide more", description: "Add more context" },
        { label: "Continue analysis", description: "Let tools explore autonomously" }
      ],
      multiSelect: false
    }]
  })
}

Quick ACE Context (optional, for complex tasks):

// Only if task seems to need codebase context
mcp__ace-tool__search_context({
  project_root_path: process.cwd(),
  query: `${taskDescription} implementation patterns`
})

Phase 2: Auto-Select Analysis Tools

Tool Categories:

Category	Source	Execution
CLI Tools	cli-tools.json	ccw cli -p "..." --tool <name>
Sub Agents	Task tool	Task({ subagent_type: "...", prompt: "..." })

Task Analysis Dimensions:

function analyzeTask(taskDescription) {
  return {
    complexity: detectComplexity(taskDescription),  // simple, medium, complex
    taskType: detectTaskType(taskDescription),      // bugfix, feature, refactor, analysis, etc.
    domain: detectDomain(taskDescription),          // frontend, backend, fullstack
    needsExecution: detectExecutionNeed(taskDescription)  // analysis-only vs needs-write
  }
}

CLI Tools (dynamically loaded from cli-tools.json):

// Load CLI tools from config file
const cliConfig = JSON.parse(Read("~/.claude/cli-tools.json"))
const cliTools = Object.entries(cliConfig.tools)
  .filter(([_, config]) => config.enabled)
  .map(([name, config]) => ({
    name,
    type: 'cli',
    tags: config.tags || [],
    model: config.primaryModel,
    toolType: config.type  // builtin, cli-wrapper, api-endpoint
  }))

Tags (user-defined in cli-tools.json, no fixed specification):

Tags are completely user-defined. Users can create any tags that match their workflow needs.

Config Example (cli-tools.json):

{
  "tools": {
    "gemini": {
      "enabled": true,
      "tags": ["architecture", "reasoning", "performance"],
      "primaryModel": "gemini-2.5-pro"
    },
    "codex": {
      "enabled": true,
      "tags": ["implementation", "fast"],
      "primaryModel": "gpt-5.2"
    },
    "qwen": {
      "enabled": true,
      "tags": ["implementation", "chinese", "documentation"],
      "primaryModel": "coder-model"
    }
  }
}

Sub Agents (predefined, canExecute marks execution capability):

const agents = [
  { name: 'code-developer', type: 'agent', strength: 'Code implementation, test writing', canExecute: true },
  { name: 'Explore', type: 'agent', strength: 'Fast code exploration', canExecute: false },
  { name: 'cli-explore-agent', type: 'agent', strength: 'Dual-source deep analysis', canExecute: false },
  { name: 'cli-discuss-agent', type: 'agent', strength: 'Multi-CLI collaborative verification', canExecute: false },
  { name: 'debug-explore-agent', type: 'agent', strength: 'Hypothesis-driven debugging', canExecute: false },
  { name: 'context-search-agent', type: 'agent', strength: 'Context collection', canExecute: false },
  { name: 'test-fix-agent', type: 'agent', strength: 'Test execution and fixing', canExecute: true },
  { name: 'universal-executor', type: 'agent', strength: 'General multi-step execution', canExecute: true }
]

Agent	Strengths	canExecute
code-developer	Code implementation, test writing, incremental development	✅
Explore	Fast code exploration, file search, pattern discovery	❌
cli-explore-agent	Dual-source analysis (Bash+CLI), read-only exploration	❌
cli-discuss-agent	Multi-CLI collaboration, cross-verification, solution synthesis	❌
debug-explore-agent	Hypothesis-driven debugging, NDJSON logging, iterative verification	❌
context-search-agent	Multi-layer file discovery, dependency analysis, conflict assessment	❌
test-fix-agent	Test execution, failure diagnosis, code fixing	✅
universal-executor	General execution, multi-domain adaptation	✅

Three-Step Selection Flow (CLI → Mode → Agent):

// Step 1: Present CLI options from config (multiSelect for multi-CLI modes)
function getCliDescription(cli) {
  return cli.tags.length > 0 ? cli.tags.join(', ') : cli.model || 'general'
}

const cliOptions = cliTools.map(cli => ({
  label: cli.name,
  description: getCliDescription(cli)
}))

AskUserQuestion({
  questions: [{
    question: "Select CLI tools for analysis (select 1-3 for collaboration modes)",
    header: "CLI Tools",
    options: cliOptions,
    multiSelect: true  // Allow multiple selection for collaboration modes
  }]
})

// Step 2: Select Analysis Mode
const analysisModes = [
  {
    name: 'parallel',
    label: 'Parallel',
    description: 'All CLIs analyze simultaneously, aggregate results',
    minCLIs: 1,
    pattern: 'A || B || C → Aggregate'
  },
  {
    name: 'sequential',
    label: 'Sequential',
    description: 'Chain analysis: each CLI builds on previous via --resume',
    minCLIs: 2,
    pattern: 'A → B(resume A) → C(resume B)'
  },
  {
    name: 'collaborative',
    label: 'Collaborative',
    description: 'Multi-round synthesis: CLIs take turns refining analysis',
    minCLIs: 2,
    pattern: 'A → B(resume A) → A(resume B) → Synthesize'
  },
  {
    name: 'debate',
    label: 'Debate',
    description: 'Adversarial: CLI B challenges CLI A findings, A responds',
    minCLIs: 2,
    pattern: 'A(propose) → B(challenge, resume A) → A(defend, resume B)'
  },
  {
    name: 'challenge',
    label: 'Challenge',
    description: 'Stress test: CLI B finds flaws/alternatives in CLI A analysis',
    minCLIs: 2,
    pattern: 'A(analyze) → B(challenge, resume A) → Evaluate'
  }
]

// Filter modes based on selected CLI count
const availableModes = analysisModes.filter(m => selectedCLIs.length >= m.minCLIs)

AskUserQuestion({
  questions: [{
    question: "Select analysis mode",
    header: "Mode",
    options: availableModes.map(m => ({
      label: m.label,
      description: `${m.description} [${m.pattern}]`
    })),
    multiSelect: false
  }]
})

// Step 3: Present Agent options for execution
const agentOptions = agents.map(agent => ({
  label: agent.name,
  description: agent.strength
}))

AskUserQuestion({
  questions: [{
    question: "Select Sub Agent for execution",
    header: "Agent",
    options: agentOptions,
    multiSelect: false
  }]
})

Selection Summary:

console.log(`
## Selected Configuration

**CLI Tools**: ${selectedCLIs.map(c => c.name).join(' → ')}
**Analysis Mode**: ${selectedMode.label} - ${selectedMode.pattern}
**Execution Agent**: ${selectedAgent.name} - ${selectedAgent.strength}

> Mode determines how CLIs collaborate, Agent handles final execution
`)

AskUserQuestion({
  questions: [{
    question: "Confirm selection?",
    header: "Confirm",
    options: [
      { label: "Confirm and continue", description: `${selectedMode.label} mode with ${selectedCLIs.length} CLIs` },
      { label: "Re-select CLIs", description: "Choose different CLI tools" },
      { label: "Re-select Mode", description: "Choose different analysis mode" },
      { label: "Re-select Agent", description: "Choose different Sub Agent" }
    ],
    multiSelect: false
  }]
})

Phase 3: Multi-Mode Analysis

Mode-Specific Execution Patterns:

Mode 1: Parallel (并行)

// All CLIs run simultaneously, no resume dependency
async function executeParallel(clis, taskDescription) {
  const promises = clis.map(cli => Bash({
    command: `ccw cli -p "
PURPOSE: Analyze and provide solution for: ${taskDescription}
TASK: • Identify affected files • Analyze implementation approach • List specific changes needed
MODE: analysis
CONTEXT: @**/*
EXPECTED: Concise analysis with: 1) Root cause/approach 2) Files to modify 3) Key changes 4) Risks
RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Focus on actionable insights
" --tool ${cli.name} --mode analysis`,
    run_in_background: true
  }))

  return await Promise.all(promises)
}

Mode 2: Sequential (串联)

// Chain analysis: each CLI builds on previous via --resume
async function executeSequential(clis, taskDescription) {
  const results = []
  let previousSessionId = null

  for (const cli of clis) {
    const resumeFlag = previousSessionId ? `--resume ${previousSessionId}` : ''

    const result = await Bash({
      command: `ccw cli -p "
PURPOSE: ${previousSessionId ? 'Build on previous analysis and deepen' : 'Initial analysis'}: ${taskDescription}
TASK: • ${previousSessionId ? 'Review previous findings • Extend analysis • Add new insights' : 'Identify affected files • Analyze implementation approach'}
MODE: analysis
CONTEXT: @**/*
EXPECTED: ${previousSessionId ? 'Extended analysis building on previous findings' : 'Initial analysis with root cause and approach'}
RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | ${previousSessionId ? 'Build incrementally, avoid repetition' : 'Focus on actionable insights'}
" --tool ${cli.name} --mode analysis ${resumeFlag}`,
      run_in_background: false
    })

    results.push(result)
    previousSessionId = extractSessionId(result)  // Extract session ID for next iteration
  }

  return results
}

Mode 3: Collaborative (协同)

// Multi-round synthesis: CLIs take turns refining analysis
async function executeCollaborative(clis, taskDescription, rounds = 2) {
  const results = []
  let previousSessionId = null

  for (let round = 0; round < rounds; round++) {
    for (const cli of clis) {
      const resumeFlag = previousSessionId ? `--resume ${previousSessionId}` : ''
      const roundContext = round === 0 ? 'Initial analysis' : `Round ${round + 1}: Refine and synthesize`

      const result = await Bash({
        command: `ccw cli -p "
PURPOSE: ${roundContext} for: ${taskDescription}
TASK: • ${round === 0 ? 'Initial analysis of the problem' : 'Review previous analysis • Identify gaps • Add complementary insights • Synthesize findings'}
MODE: analysis
CONTEXT: @**/*
EXPECTED: ${round === 0 ? 'Foundational analysis' : 'Refined synthesis with new perspectives'}
RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | ${round === 0 ? 'Be thorough' : 'Build collaboratively, add value not repetition'}
" --tool ${cli.name} --mode analysis ${resumeFlag}`,
        run_in_background: false
      })

      results.push({ cli: cli.name, round, result })
      previousSessionId = extractSessionId(result)
    }
  }

  return results
}

Mode 4: Debate (辩论)

// Adversarial: CLI B challenges CLI A findings, A responds
async function executeDebate(clis, taskDescription) {
  const [cliA, cliB] = clis
  const results = []

  // Step 1: CLI A proposes initial analysis
  const proposeResult = await Bash({
    command: `ccw cli -p "
PURPOSE: Propose comprehensive analysis for: ${taskDescription}
TASK: • Analyze problem thoroughly • Propose solution approach • Identify implementation details • State assumptions clearly
MODE: analysis
CONTEXT: @**/*
EXPECTED: Well-reasoned proposal with clear assumptions and trade-offs stated
RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Be clear about assumptions and trade-offs
" --tool ${cliA.name} --mode analysis`,
    run_in_background: false
  })
  results.push({ phase: 'propose', cli: cliA.name, result: proposeResult })
  const proposeSessionId = extractSessionId(proposeResult)

  // Step 2: CLI B challenges the proposal
  const challengeResult = await Bash({
    command: `ccw cli -p "
PURPOSE: Challenge and stress-test the previous analysis for: ${taskDescription}
TASK: • Identify weaknesses in proposed approach • Question assumptions • Suggest alternative approaches • Highlight potential risks overlooked
MODE: analysis
CONTEXT: @**/*
EXPECTED: Constructive critique with specific counter-arguments and alternatives
RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Be adversarial but constructive, focus on improving the solution
" --tool ${cliB.name} --mode analysis --resume ${proposeSessionId}`,
    run_in_background: false
  })
  results.push({ phase: 'challenge', cli: cliB.name, result: challengeResult })
  const challengeSessionId = extractSessionId(challengeResult)

  // Step 3: CLI A defends and refines
  const defendResult = await Bash({
    command: `ccw cli -p "
PURPOSE: Respond to challenges and refine analysis for: ${taskDescription}
TASK: • Address each challenge point • Defend valid aspects • Acknowledge valid criticisms • Propose refined solution incorporating feedback
MODE: analysis
CONTEXT: @**/*
EXPECTED: Refined proposal that addresses criticisms and incorporates valid alternatives
RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Be open to valid criticism, synthesize best ideas
" --tool ${cliA.name} --mode analysis --resume ${challengeSessionId}`,
    run_in_background: false
  })
  results.push({ phase: 'defend', cli: cliA.name, result: defendResult })

  return results
}

Mode 5: Challenge (挑战)

// Stress test: CLI B finds flaws/alternatives in CLI A analysis
async function executeChallenge(clis, taskDescription) {
  const [cliA, cliB] = clis
  const results = []

  // Step 1: CLI A provides initial analysis
  const analyzeResult = await Bash({
    command: `ccw cli -p "
PURPOSE: Provide comprehensive analysis for: ${taskDescription}
TASK: • Deep analysis of problem space • Propose implementation approach • List specific changes • Identify risks
MODE: analysis
CONTEXT: @**/*
EXPECTED: Thorough analysis with clear reasoning
RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Be thorough and explicit about reasoning
" --tool ${cliA.name} --mode analysis`,
    run_in_background: false
  })
  results.push({ phase: 'analyze', cli: cliA.name, result: analyzeResult })
  const analyzeSessionId = extractSessionId(analyzeResult)

  // Step 2: CLI B challenges with focus on finding flaws
  const challengeResult = await Bash({
    command: `ccw cli -p "
PURPOSE: Stress-test and find weaknesses in the analysis for: ${taskDescription}
TASK: • Find logical flaws in reasoning • Identify missed edge cases • Propose better alternatives • Rate confidence in each criticism (High/Medium/Low)
MODE: analysis
CONTEXT: @**/*
EXPECTED: Detailed critique with severity ratings: [CRITICAL] [HIGH] [MEDIUM] [LOW] for each issue found
RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Be ruthlessly critical, find every possible flaw
" --tool ${cliB.name} --mode analysis --resume ${analyzeSessionId}`,
    run_in_background: false
  })
  results.push({ phase: 'challenge', cli: cliB.name, result: challengeResult })

  return results
}

Mode Router:

async function executeAnalysis(mode, clis, taskDescription) {
  switch (mode.name) {
    case 'parallel':
      return await executeParallel(clis, taskDescription)
    case 'sequential':
      return await executeSequential(clis, taskDescription)
    case 'collaborative':
      return await executeCollaborative(clis, taskDescription)
    case 'debate':
      return await executeDebate(clis, taskDescription)
    case 'challenge':
      return await executeChallenge(clis, taskDescription)
    default:
      return await executeParallel(clis, taskDescription)
  }
}

// Execute based on selected mode
const analysisResults = await executeAnalysis(selectedMode, selectedCLIs, taskDescription)

Result Aggregation (mode-aware):

function aggregateResults(mode, results) {
  const base = {
    mode: mode.name,
    pattern: mode.pattern,
    tools_used: results.map(r => r.cli || 'unknown')
  }

  switch (mode.name) {
    case 'parallel':
      return {
        ...base,
        findings: results.map(r => parseOutput(r)),
        consensus: findCommonPoints(results),
        divergences: findDifferences(results)
      }

    case 'sequential':
      return {
        ...base,
        evolution: results.map((r, i) => ({ step: i + 1, analysis: parseOutput(r) })),
        finalAnalysis: parseOutput(results[results.length - 1])
      }

    case 'collaborative':
      return {
        ...base,
        rounds: groupByRound(results),
        synthesis: extractSynthesis(results[results.length - 1])
      }

    case 'debate':
      return {
        ...base,
        proposal: parseOutput(results.find(r => r.phase === 'propose')?.result),
        challenges: parseOutput(results.find(r => r.phase === 'challenge')?.result),
        resolution: parseOutput(results.find(r => r.phase === 'defend')?.result),
        confidence: calculateDebateConfidence(results)
      }

    case 'challenge':
      return {
        ...base,
        originalAnalysis: parseOutput(results.find(r => r.phase === 'analyze')?.result),
        critiques: parseCritiques(results.find(r => r.phase === 'challenge')?.result),
        riskScore: calculateRiskScore(results)
      }
  }
}

const aggregatedAnalysis = aggregateResults(selectedMode, analysisResults)

Phase 4: User Decision

Present Mode-Specific Summary:

function presentSummary(aggregatedAnalysis) {
  const { mode, pattern } = aggregatedAnalysis

  console.log(`
## Analysis Result Summary

**Mode**: ${mode} (${pattern})
**Tools**: ${aggregatedAnalysis.tools_used.join(' → ')}
`)

  switch (mode) {
    case 'parallel':
      console.log(`
### Consensus Points
${aggregatedAnalysis.consensus.map(c => `- ${c}`).join('\n')}

### Divergence Points
${aggregatedAnalysis.divergences.map(d => `- ${d}`).join('\n')}
`)
      break

    case 'sequential':
      console.log(`
### Analysis Evolution
${aggregatedAnalysis.evolution.map(e => `**Step ${e.step}**: ${e.analysis.summary}`).join('\n')}

### Final Analysis
${aggregatedAnalysis.finalAnalysis.summary}
`)
      break

    case 'collaborative':
      console.log(`
### Collaboration Rounds
${Object.entries(aggregatedAnalysis.rounds).map(([round, analyses]) =>
  `**Round ${round}**: ${analyses.map(a => a.cli).join(' + ')}`
).join('\n')}

### Synthesized Result
${aggregatedAnalysis.synthesis}
`)
      break

    case 'debate':
      console.log(`
### Debate Summary
**Proposal**: ${aggregatedAnalysis.proposal.summary}
**Challenges**: ${aggregatedAnalysis.challenges.points?.length || 0} points raised
**Resolution**: ${aggregatedAnalysis.resolution.summary}
**Confidence**: ${aggregatedAnalysis.confidence}%
`)
      break

    case 'challenge':
      console.log(`
### Challenge Summary
**Original Analysis**: ${aggregatedAnalysis.originalAnalysis.summary}
**Critiques Found**: ${aggregatedAnalysis.critiques.length} issues
${aggregatedAnalysis.critiques.map(c => `- [${c.severity}] ${c.description}`).join('\n')}
**Risk Score**: ${aggregatedAnalysis.riskScore}/100
`)
      break
  }
}

presentSummary(aggregatedAnalysis)

Decision Options:

AskUserQuestion({
  questions: [{
    question: "How to proceed?",
    header: "Next Step",
    options: [
      { label: "Execute directly", description: "Implement immediately based on analysis" },
      { label: "Refine analysis", description: "Provide more constraints, re-analyze" },
      { label: "Change tools", description: "Select different tool combination" },
      { label: "Cancel", description: "End current workflow" }
    ],
    multiSelect: false
  }]
})

Routing Logic:

• Execute directly → Phase 5
• Refine analysis → Collect feedback, return to Phase 3
• Change tools → Return to Phase 2
• Cancel → End workflow

Phase 5: Direct Execution

No Artifacts - Direct Implementation:

// Use the aggregated analysis directly
// No IMPL_PLAN.md, no plan.json, no session files

console.log("Starting direct execution based on analysis...")

// Execution-capable agents (canExecute: true)
const executionAgents = agents.filter(a => a.canExecute)

// Select execution tool: prefer execution-capable agent, fallback to CLI
const executionTool = selectedTools.find(t =>
  t.type === 'agent' && executionAgents.some(ea => ea.name === t.name)
) || selectedTools.find(t => t.type === 'cli')

if (executionTool.type === 'agent') {
  // Use Agent for execution (preferred if available)
  Task({
    subagent_type: executionTool.name,
    run_in_background: false,
    description: `Execute: ${taskDescription.slice(0, 30)}`,
    prompt: `
## Task
${taskDescription}

## Analysis Results (from previous tools)
${JSON.stringify(aggregatedAnalysis, null, 2)}

## Instructions
Based on the analysis above, implement the solution:
1. Apply changes to identified files
2. Follow the recommended approach
3. Handle identified risks
4. Verify changes work correctly
`
  })
} else {
  // Use CLI with write mode
  Bash({
    command: `ccw cli -p "
PURPOSE: Implement the solution based on analysis: ${taskDescription}
TASK: ${extractedTasks.join(' • ')}
MODE: write
CONTEXT: @${affectedFiles.join(' @')}
EXPECTED: Working implementation with all changes applied
RULES: $(cat ~/.claude/workflows/cli-templates/protocols/write-protocol.md) | Apply analysis findings directly
" --tool ${executionTool.name} --mode write`,
    run_in_background: false
  })
}

TodoWrite Structure

TodoWrite({ todos: [
  { content: "Phase 1: Clarify requirements", status: "in_progress", activeForm: "Clarifying requirements" },
  { content: "Phase 2: Auto-select tools", status: "pending", activeForm: "Analyzing task" },
  { content: "Phase 3: Mixed tool analysis", status: "pending", activeForm: "Running analysis" },
  { content: "Phase 4: User decision", status: "pending", activeForm: "Awaiting decision" },
  { content: "Phase 5: Direct execution", status: "pending", activeForm: "Executing implementation" }
]})

Iteration Patterns

Pattern A: Direct Path (Most Common)

Phase 1 → Phase 2 (auto) → Phase 3 → Phase 4 (execute) → Phase 5

Pattern B: Refinement Loop

Phase 3 → Phase 4 (refine) → Phase 3 → Phase 4 → Phase 5

Pattern C: Tool Adjustment

Phase 2 (adjust) → Phase 3 → Phase 4 → Phase 5

Error Handling

Error	Resolution
CLI timeout	Retry with secondary model
No enabled tools	Load cli-tools.json, ask user to enable tools
Task type unclear	Default to first available CLI + code-developer
Ambiguous task	Force clarification via AskUser
Execution fails	Present error, ask user for direction

Analysis Modes Reference

Mode	Pattern	Use Case	CLI Count
Parallel	A || B || C → Aggregate	Fast multi-perspective analysis	1+
Sequential	A → B(resume) → C(resume)	Deep incremental analysis	2+
Collaborative	A → B → A → B → Synthesize	Multi-round refinement	2+
Debate	A(propose) → B(challenge) → A(defend)	Stress-test solutions	2
Challenge	A(analyze) → B(challenge)	Find flaws and risks	2

Comparison

Aspect	lite-lite-lite	multi-cli-plan
Artifacts	None	IMPL_PLAN.md, plan.json, synthesis.json
Session	Stateless (uses --resume for chaining)	Persistent session folder
Tool Selection	Multi-CLI + Agent via 3-step selection	Config-driven with fixed tools
Analysis Modes	5 modes (parallel/sequential/collaborative/debate/challenge)	Fixed synthesis rounds
CLI Collaboration	Auto --resume chaining	Manual session management
Iteration	Via AskUser	Via rounds/synthesis
Execution	Direct	Via lite-execute
Best For	Quick analysis, adversarial validation, rapid iteration	Complex multi-step implementations

Best Practices

1. Be Specific: Clear task description improves auto-selection accuracy
2. Trust Auto-Selection: Algorithm matches task type to tool strengths
3. Adjust When Needed: Use "Adjust tools" if auto-selection doesn't fit
4. Trust Consensus: When tools agree, confidence is high
5. Iterate Fast: Use refinement loop for complex requirements
6. Direct is Fast: Skip artifacts when task is straightforward

Related Commands

# Full planning workflow
/workflow:multi-cli-plan "complex task"

# Single CLI planning
/workflow:lite-plan "task"

# Direct execution
/workflow:lite-execute --in-memory