claude-code-workflow 6.3.18 → 6.3.20

package/.claude/commands/workflow/brainstorm/auto-parallel.md

@@ -9,11 +9,11 @@ allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*
 
 ## Coordinator Role
 
-**This command is a pure orchestrator**: Dispatches 3 phases in sequence (interactive framework → parallel role analysis → synthesis), coordinating specialized commands/agents through task attachment model.
+**This command is a pure orchestrator**: Executes 3 phases in sequence (interactive framework → parallel role analysis → synthesis), coordinating specialized commands/agents through task attachment model.
 
 **Task Attachment Model**:
-- SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
-- Task agent dispatch **attaches analysis tasks** to orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- Task agent execute **attaches analysis tasks** to orchestrator's TodoWrite
 - Phase 1: artifacts command attaches its internal tasks (Phase 1-5)
 - Phase 2: N conceptual-planning-agent tasks attached in parallel
 - Phase 3: synthesis command attaches its internal tasks
@@ -26,9 +26,9 @@ allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*
 This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) handles user interaction, Phase 2 (role agents) runs in parallel.
 
 1. **User triggers**: `/workflow:brainstorm:auto-parallel "topic" [--count N]`
-2. **Dispatch Phase 1** → artifacts command (tasks ATTACHED) → Auto-continues
-3. **Dispatch Phase 2** → Parallel role agents (N tasks ATTACHED concurrently) → Auto-continues
-4. **Dispatch Phase 3** → Synthesis command (tasks ATTACHED) → Reports final summary
+2. **Execute Phase 1** → artifacts command (tasks ATTACHED) → Auto-continues
+3. **Execute Phase 2** → Parallel role agents (N tasks ATTACHED concurrently) → Auto-continues
+4. **Execute Phase 3** → Synthesis command (tasks ATTACHED) → Reports final summary
 
 **Auto-Continue Mechanism**:
 - TodoList tracks current phase status and dynamically manages task attachment/collapse
@@ -38,13 +38,13 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 
 ## Core Rules
 
-1. **Start Immediately**: First action is TodoWrite initialization, second action is dispatch Phase 1 command
+1. **Start Immediately**: First action is TodoWrite initialization, second action is execute Phase 1 command
 2. **No Preliminary Analysis**: Do not analyze topic before Phase 1 - artifacts handles all analysis
 3. **Parse Every Output**: Extract selected_roles from workflow-session.json after Phase 1
-4. **Auto-Continue via TodoList**: Check TodoList status to dispatch next pending phase automatically
+4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
 5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
-6. **Task Attachment Model**: SlashCommand and Task dispatches **attach** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
-7. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and dispatch next phase
+6. **Task Attachment Model**: SlashCommand and Task executes **attach** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+7. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
 8. **Parallel Execution**: Phase 2 attaches multiple agent tasks simultaneously for concurrent execution
 
 ## Usage
@@ -67,7 +67,7 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 
 ### Phase 1: Interactive Framework Generation
 
-**Step 1: Dispatch** - Interactive framework generation via artifacts command
+**Step 1: Execute** - Interactive framework generation via artifacts command
 
 ```javascript
 SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")
@@ -91,7 +91,7 @@ SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")
 - workflow-session.json contains selected_roles[] (metadata only, no content duplication)
 - Session directory `.workflow/active/WFS-{topic}/.brainstorming/` exists
 
-**TodoWrite Update (Phase 1 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 1 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
@@ -106,7 +106,7 @@ SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** artifacts' 5 internal tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** artifacts' 5 internal tasks. Orchestrator **executes** these tasks sequentially.
 
 **Next Action**: Tasks attached → **Execute Phase 1.1-1.5** sequentially
 
@@ -167,7 +167,7 @@ TOPIC: {user-provided-topic}
 "
 ```
 
-**Parallel Dispatch**:
+**Parallel Execute**:
 - Launch N agents simultaneously (one message with multiple Task calls)
 - Each agent task **attached** to orchestrator's TodoWrite
 - All agents execute concurrently, each attaching their own analysis sub-tasks
@@ -185,7 +185,7 @@ TOPIC: {user-provided-topic}
 - **FORBIDDEN**: `recommendations.md` or any non-`analysis` prefixed files
 - All N role analyses completed
 
-**TodoWrite Update (Phase 2 agents dispatched - tasks attached in parallel)**:
+**TodoWrite Update (Phase 2 agents executed - tasks attached in parallel)**:
 ```json
 [
   {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
@@ -198,7 +198,7 @@ TOPIC: {user-provided-topic}
 ]
 ```
 
-**Note**: Multiple Task dispatches **attach** N role analysis tasks simultaneously. Orchestrator **executes** these tasks in parallel.
+**Note**: Multiple Task executes **attach** N role analysis tasks simultaneously. Orchestrator **executes** these tasks in parallel.
 
 **Next Action**: Tasks attached → **Execute Phase 2.1-2.N** concurrently
 
@@ -220,7 +220,7 @@ TOPIC: {user-provided-topic}
 
 ### Phase 3: Synthesis Generation
 
-**Step 3: Dispatch** - Synthesis integration via synthesis command
+**Step 3: Execute** - Synthesis integration via synthesis command
 
 ```javascript
 SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")
@@ -238,7 +238,7 @@ SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")
 - `.workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.md` exists
 - Synthesis references all role analyses
 
-**TodoWrite Update (Phase 3 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
@@ -251,7 +251,7 @@ SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** synthesis' internal tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** synthesis' internal tasks. Orchestrator **executes** these tasks sequentially.
 
 **Next Action**: Tasks attached → **Execute Phase 3.1-3.3** sequentially
 
@@ -284,7 +284,7 @@ Synthesis: .workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.m
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand/Task dispatched):
+1. **Task Attachment** (when SlashCommand/Task executed):
    - Sub-command's or agent's internal tasks are **attached** to orchestrator's TodoWrite
    - Phase 1: `/workflow:brainstorm:artifacts` attaches 5 internal tasks (Phase 1.1-1.5)
    - Phase 2: Multiple `Task(conceptual-planning-agent)` calls attach N role analysis tasks simultaneously
@@ -305,7 +305,7 @@ Synthesis: .workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.m
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase 1 dispatched (artifacts tasks ATTACHED) → Artifacts sub-tasks executed → Phase 1 completed (tasks COLLAPSED) → Phase 2 dispatched (N role tasks ATTACHED in parallel) → Role analyses executed concurrently → Phase 2 completed (tasks COLLAPSED) → Phase 3 dispatched (synthesis tasks ATTACHED) → Synthesis sub-tasks executed → Phase 3 completed (tasks COLLAPSED) → Workflow complete.
+**Lifecycle Summary**: Initial pending tasks → Phase 1 executed (artifacts tasks ATTACHED) → Artifacts sub-tasks executed → Phase 1 completed (tasks COLLAPSED) → Phase 2 executed (N role tasks ATTACHED in parallel) → Role analyses executed concurrently → Phase 2 completed (tasks COLLAPSED) → Phase 3 executed (synthesis tasks ATTACHED) → Synthesis sub-tasks executed → Phase 3 completed (tasks COLLAPSED) → Workflow complete.
 
 ### Brainstorming Workflow Specific Features
 

package/.claude/commands/workflow/execute.md

@@ -23,7 +23,7 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 ## Core Rules
 **Complete entire workflow autonomously without user interruption, using TodoWrite for comprehensive progress tracking.**
 **Execute all discovered pending tasks until workflow completion or blocking dependency.**
-**Auto-complete session when all tasks finished: Call `/workflow:session:complete` upon workflow completion.**
+**User-choice completion: When all tasks finished, ask user to choose review or complete.**
 **ONE AGENT = ONE TASK JSON: Each agent instance executes exactly one task JSON file - never batch multiple tasks into single agent execution.**
 
 ## Core Responsibilities
@@ -33,7 +33,7 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 - **Agent Orchestration**: Coordinate specialized agents with complete context
 - **Status Synchronization**: Update task JSON files and workflow state
 - **Autonomous Completion**: Continue execution until all tasks complete or reach blocking state
-- **Session Auto-Complete**: Call `/workflow:session:complete` when all workflow tasks finished
+- **Session User-Choice Completion**: Ask user to choose review or complete when all tasks finished
 
 ## Execution Philosophy
 - **Progress tracking**: Continuous TodoWrite updates throughout entire workflow execution
@@ -76,7 +76,9 @@ Phase 4: Execution Strategy & Task Execution
 Phase 5: Completion
    ├─ Update task statuses in JSON files
    ├─ Generate summaries
-   └─ Auto-call /workflow:session:complete
+   └─ AskUserQuestion: Choose next step
+      ├─ "Enter Review" → /workflow:review
+      └─ "Complete Session" → /workflow:session:complete
 
 Resume Mode (--resume-session):
    ├─ Skip Phase 1 & Phase 2
@@ -117,14 +119,7 @@ Auto-select and continue to Phase 2.
 
 List sessions with metadata and prompt user selection:
 ```bash
-bash(for dir in .workflow/active/WFS-*/; do
-  session=$(basename "$dir")
-  project=$(jq -r '.project // "Unknown"' "$dir/workflow-session.json" 2>/dev/null)
-  total=$(grep -c "^- \[" "$dir/TODO_LIST.md" 2>/dev/null || echo "0")
-  completed=$(grep -c "^- \[x\]" "$dir/TODO_LIST.md" 2>/dev/null || echo "0")
-  [ "$total" -gt 0 ] && progress=$((completed * 100 / total)) || progress=0
-  echo "${session} | ${project} | ${completed}/${total} tasks (${progress}%)"
-done)
+bash(for dir in .workflow/active/WFS-*/; do [ -d "$dir" ] || continue; session=$(basename "$dir"); project=$(jq -r '.project // "Unknown"' "${dir}workflow-session.json" 2>/dev/null || echo "Unknown"); total=$(grep -c '^\- \[' "${dir}TODO_LIST.md" 2>/dev/null || echo 0); completed=$(grep -c '^\- \[x\]' "${dir}TODO_LIST.md" 2>/dev/null || echo 0); if [ "$total" -gt 0 ]; then progress=$((completed * 100 / total)); else progress=0; fi; echo "$session | $project | $completed/$total tasks ($progress%)"; done)
 ```
 
 Use AskUserQuestion to present formatted options (max 4 options shown):
@@ -254,7 +249,31 @@ while (TODO_LIST.md has pending tasks) {
 3. **Update TodoWrite**: Mark current task complete, advance to next
 4. **Synchronize State**: Update session state and workflow status
 5. **Check Workflow Complete**: Verify all tasks are completed
-6. **Auto-Complete Session**: Call `/workflow:session:complete` when all tasks finished
+6. **User Choice**: When all tasks finished, ask user to choose next step:
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "All tasks completed. What would you like to do next?",
+    header: "Next Step",
+    multiSelect: false,
+    options: [
+      {
+        label: "Enter Review",
+        description: "Run specialized review (security/architecture/quality/action-items)"
+      },
+      {
+        label: "Complete Session",
+        description: "Archive session and update manifest"
+      }
+    ]
+  }]
+})
+```
+
+**Based on user selection**:
+- **"Enter Review"**: Execute `/workflow:review`
+- **"Complete Session"**: Execute `/workflow:session:complete`
 
 ## Execution Strategy (IMPL_PLAN-Driven)
 
@@ -330,7 +349,7 @@ blocked → skip until dependencies clear
 - **Continuous Tracking**: Maintain TodoWrite throughout entire workflow execution until completion
 
 **Rule 4: Workflow Completion Check**
-- When all tasks marked `completed`, auto-call `/workflow:session:complete`
+- When all tasks marked `completed`, prompt user to choose review or complete session
 
 ### TodoWrite Tool Usage
 
@@ -388,38 +407,39 @@ TodoWrite({
 **Note**: Orchestrator does NOT execute flow control steps - Agent interprets and executes them autonomously.
 
 ### Agent Prompt Template
-**Dynamic Generation**: Before agent invocation, read task JSON and extract key requirements.
+**Path-Based Invocation**: Pass paths and trigger markers, let agent parse task JSON autonomously.
 
 ```bash
 Task(subagent_type="{meta.agent}",
      run_in_background=false,
-     prompt="Execute task: {task.title}
-
-     {[FLOW_CONTROL]}
+     prompt="Implement task {task.id}: {task.title}
 
-     **Task Objectives** (from task JSON):
-     {task.context.objective}
+     [FLOW_CONTROL]
 
-     **Expected Deliverables** (from task JSON):
-     {task.context.deliverables}
+     **Input**:
+     - Task JSON: {session.task_json_path}
+     - Context Package: {session.context_package_path}
 
-     **Quality Standards** (from task JSON):
-     {task.context.acceptance_criteria}
+     **Output Location**:
+     - Workflow: {session.workflow_dir}
+     - TODO List: {session.todo_list_path}
+     - Summaries: {session.summaries_dir}
 
-     **MANDATORY FIRST STEPS**:
-     1. Read complete task JSON: {session.task_json_path}
-     2. Load context package: {session.context_package_path}
+     **Execution**: Read task JSON → Parse flow_control → Execute implementation_approach → Update TODO_LIST.md → Generate summary",
+     description="Implement: {task.id}")
+```
 
+**Key Markers**:
+- `Implement` keyword: Triggers tech stack detection and guidelines loading
+- `[FLOW_CONTROL]`: Triggers flow_control.pre_analysis execution
 
-     **Session Paths**:
-     - Workflow Dir: {session.workflow_dir}
-     - TODO List: {session.todo_list_path}
-     - Summaries Dir: {session.summaries_dir}
-     - Context Package: {session.context_package_path}
+**Why Path-Based**: Agent (code-developer.md) autonomously:
+- Reads and parses task JSON (requirements, acceptance, flow_control)
+- Loads tech stack guidelines based on detected language
+- Executes pre_analysis steps and implementation_approach
+- Generates structured summary with integration points
 
-     **Success Criteria**: Complete all objectives, meet all quality standards, deliver all outputs as specified above.",
-     description="Executing: {task.title}")
-```
+Embedding task content in prompt creates duplication and conflicts with agent's parsing logic.
 
 ### Agent Assignment Rules
 ```

package/.claude/commands/workflow/lite-execute.md

@@ -307,120 +307,74 @@ for (const call of sequential) {
 }
 ```
 
-**Option A: Agent Execution**
+### Unified Task Prompt Builder
 
-When to use:
-- `getTaskExecutor(task) === "agent"`
-- 或 `executionMethod = "Agent"` (全局 fallback)
-- 或 `executionMethod = "Auto" AND complexity = "Low"` (全局 fallback)
+**Task Formatting Principle**: Each task is a self-contained checklist. The executor only needs to know what THIS task requires. Same template for Agent and CLI.
 
-**Task Formatting Principle**: Each task is a self-contained checklist. The agent only needs to know what THIS task requires, not its position or relation to other tasks.
-
-Agent call format:
 ```javascript
-// Format single task as self-contained checklist
-function formatTaskChecklist(task) {
-  return `
-## ${task.title}
+function buildExecutionPrompt(batch) {
+  // Task template (4 parts: Modification Points → How → Reference → Done)
+  const formatTask = (t) => `
+## ${t.title}
 
-**Target**: \`${task.file}\`
-**Action**: ${task.action}
+**Scope**: \`${t.scope}\`  |  **Action**: ${t.action}
 
-### What to do
-${task.description}
+### Modification Points
+${t.modification_points.map(p => `- **${p.file}** → \`${p.target}\`: ${p.change}`).join('\n')}
 
 ### How to do it
-${task.implementation.map(step => `- ${step}`).join('\n')}
+${t.description}
+
+${t.implementation.map(step => `- ${step}`).join('\n')}
 
 ### Reference
-- Pattern: ${task.reference.pattern}
-- Examples: ${task.reference.files.join(', ')}
-- Notes: ${task.reference.examples}
+- Pattern: ${t.reference?.pattern || 'N/A'}
+- Files: ${t.reference?.files?.join(', ') || 'N/A'}
+${t.reference?.examples ? `- Notes: ${t.reference.examples}` : ''}
 
 ### Done when
-${task.acceptance.map(c => `- [ ] ${c}`).join('\n')}
-`
-}
-
-// For batch execution: aggregate tasks without numbering
-function formatBatchPrompt(batch) {
-  const tasksSection = batch.tasks.map(t => formatTaskChecklist(t)).join('\n---\n')
-
-  return `
-${originalUserInput ? `## Goal\n${originalUserInput}\n` : ''}
-
-## Tasks
-
-${tasksSection}
-
-${batch.context ? `## Context\n${batch.context}` : ''}
-
-Complete each task according to its "Done when" checklist.
-`
-}
-
-Task(
-  subagent_type="code-developer",
-  run_in_background=false,
-  description=batch.taskSummary,
-  prompt=formatBatchPrompt({
-    tasks: batch.tasks,
-    context: buildRelevantContext(batch.tasks)
-  })
-)
+${t.acceptance.map(c => `- [ ] ${c}`).join('\n')}`
 
-// Helper: Build relevant context for batch
-// Context serves as REFERENCE ONLY - helps agent understand existing state
-function buildRelevantContext(tasks) {
+  // Build prompt
   const sections = []
 
-  // 1. Previous work completion - what's already done (reference for continuity)
-  if (previousExecutionResults.length > 0) {
-    sections.push(`### Previous Work (Reference)
-Use this to understand what's already completed. Avoid duplicating work.
-
-${previousExecutionResults.map(r => `**${r.tasksSummary}**
-- Status: ${r.status}
-- Outputs: ${r.keyOutputs || 'See git diff'}
-${r.notes ? `- Notes: ${r.notes}` : ''}`
-    ).join('\n\n')}`)
-  }
+  if (originalUserInput) sections.push(`## Goal\n${originalUserInput}`)
 
-  // 2. Related files - files that may need to be read/referenced
-  const relatedFiles = extractRelatedFiles(tasks)
-  if (relatedFiles.length > 0) {
-    sections.push(`### Related Files (Reference)
-These files may contain patterns, types, or utilities relevant to your tasks:
+  sections.push(`## Tasks\n${batch.tasks.map(formatTask).join('\n\n---\n')}`)
 
-${relatedFiles.map(f => `- \`${f}\``).join('\n')}`)
+  // Context (reference only)
+  const context = []
+  if (previousExecutionResults.length > 0) {
+    context.push(`### Previous Work\n${previousExecutionResults.map(r => `- ${r.tasksSummary}: ${r.status}`).join('\n')}`)
   }
-
-  // 3. Clarifications from user
   if (clarificationContext) {
-    sections.push(`### User Clarifications
-${Object.entries(clarificationContext).map(([q, a]) => `- **${q}**: ${a}`).join('\n')}`)
+    context.push(`### Clarifications\n${Object.entries(clarificationContext).map(([q, a]) => `- ${q}: ${a}`).join('\n')}`)
   }
-
-  // 4. Artifact files (for deeper context if needed)
   if (executionContext?.session?.artifacts?.plan) {
-    sections.push(`### Artifacts
-For detailed planning context, read: ${executionContext.session.artifacts.plan}`)
+    context.push(`### Artifacts\nPlan: ${executionContext.session.artifacts.plan}`)
   }
+  if (context.length > 0) sections.push(`## Context\n${context.join('\n\n')}`)
+
+  sections.push(`Complete each task according to its "Done when" checklist.`)
 
   return sections.join('\n\n')
 }
+```
 
-// Extract related files from task references
-function extractRelatedFiles(tasks) {
-  const files = new Set()
-  tasks.forEach(task => {
-    // Add reference example files
-    if (task.reference?.files) {
-      task.reference.files.forEach(f => files.add(f))
-    }
-  })
-  return [...files]
-}
+**Option A: Agent Execution**
+
+When to use:
+- `getTaskExecutor(task) === "agent"`
+- 或 `executionMethod = "Agent"` (全局 fallback)
+- 或 `executionMethod = "Auto" AND complexity = "Low"` (全局 fallback)
+
+```javascript
+Task(
+  subagent_type="code-developer",
+  run_in_background=false,
+  description=batch.taskSummary,
+  prompt=buildExecutionPrompt(batch)
+)
 ```
 
 **Result Collection**: After completion, collect result following `executionResult` structure (see Data Structures section)
@@ -432,78 +386,8 @@ When to use:
 - 或 `executionMethod = "Codex"` (全局 fallback)
 - 或 `executionMethod = "Auto" AND complexity = "Medium/High"` (全局 fallback)
 
-**Task Formatting Principle**: Same as Agent - each task is a self-contained checklist. No task numbering or position awareness.
-
-Command format:
 ```bash
-// Format single task as compact checklist for CLI
-function formatTaskForCLI(task) {
-  return `
-## ${task.title}
-File: ${task.file}
-Action: ${task.action}
-
-What: ${task.description}
-
-How:
-${task.implementation.map(step => `- ${step}`).join('\n')}
-
-Reference: ${task.reference.pattern} (see ${task.reference.files.join(', ')})
-Notes: ${task.reference.examples}
-
-Done when:
-${task.acceptance.map(c => `- [ ] ${c}`).join('\n')}
-`
-}
-
-// Build CLI prompt for batch
-// Context provides REFERENCE information - not requirements to fulfill
-function buildCLIPrompt(batch) {
-  const tasksSection = batch.tasks.map(t => formatTaskForCLI(t)).join('\n---\n')
-
-  let prompt = `${originalUserInput ? `## Goal\n${originalUserInput}\n\n` : ''}`
-  prompt += `## Tasks\n\n${tasksSection}\n`
-
-  // Context section - reference information only
-  const contextSections = []
-
-  // 1. Previous work - what's already completed
-  if (previousExecutionResults.length > 0) {
-    contextSections.push(`### Previous Work (Reference)
-Already completed - avoid duplicating:
-${previousExecutionResults.map(r => `- ${r.tasksSummary}: ${r.status}${r.keyOutputs ? ` (${r.keyOutputs})` : ''}`).join('\n')}`)
-  }
-
-  // 2. Related files from task references
-  const relatedFiles = [...new Set(batch.tasks.flatMap(t => t.reference?.files || []))]
-  if (relatedFiles.length > 0) {
-    contextSections.push(`### Related Files (Reference)
-Patterns and examples to follow:
-${relatedFiles.map(f => `- ${f}`).join('\n')}`)
-  }
-
-  // 3. User clarifications
-  if (clarificationContext) {
-    contextSections.push(`### Clarifications
-${Object.entries(clarificationContext).map(([q, a]) => `- ${q}: ${a}`).join('\n')}`)
-  }
-
-  // 4. Plan artifact for deeper context
-  if (executionContext?.session?.artifacts?.plan) {
-    contextSections.push(`### Artifacts
-Detailed plan: ${executionContext.session.artifacts.plan}`)
-  }
-
-  if (contextSections.length > 0) {
-    prompt += `\n## Context\n${contextSections.join('\n\n')}\n`
-  }
-
-  prompt += `\nComplete each task according to its "Done when" checklist.`
-
-  return prompt
-}
-
-ccw cli -p "${buildCLIPrompt(batch)}" --tool codex --mode write
+ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write
 ```
 
 **Execution with fixed IDs** (predictable ID pattern):
@@ -526,8 +410,8 @@ const previousCliId = batch.resumeFromCliId || null
 
 // Build command with fixed ID (and optional resume for continuation)
 const cli_command = previousCliId
-  ? `ccw cli -p "${buildCLIPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId} --resume ${previousCliId}`
-  : `ccw cli -p "${buildCLIPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId}`
+  ? `ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId} --resume ${previousCliId}`
+  : `ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId}`
 
 bash_result = Bash(
   command=cli_command,
@@ -564,8 +448,8 @@ if (bash_result.status === 'failed' || bash_result.status === 'timeout') {
 When to use: `getTaskExecutor(task) === "gemini"` (分析类任务)
 
 ```bash
-# 使用与 Option B 相同的 formatBatchPrompt，切换 tool 和 mode
-ccw cli -p "${formatBatchPrompt(batch)}" --tool gemini --mode analysis --id ${sessionId}-${batch.groupId}
+# 使用统一的 buildExecutionPrompt，切换 tool 和 mode
+ccw cli -p "${buildExecutionPrompt(batch)}" --tool gemini --mode analysis --id ${sessionId}-${batch.groupId}
 ```
 
 ### Step 4: Progress Tracking

package/.claude/commands/workflow/lite-fix.md

@@ -17,7 +17,7 @@ Intelligent lightweight bug fixing command with dynamic workflow adaptation base
 - Interactive clarification after diagnosis to gather missing information
 - Adaptive fix planning strategy (direct Claude vs cli-lite-planning-agent) based on complexity
 - Two-step confirmation: fix-plan display -> multi-dimensional input collection
-- Execution dispatch with complete context handoff to lite-execute
+- Execution execute with complete context handoff to lite-execute
 
 ## Usage
 
@@ -62,7 +62,7 @@ Phase 4: Confirmation & Selection
       |- Execution: Agent / Codex / Auto
       +- Review: Gemini / Agent / Skip
 
-Phase 5: Dispatch
+Phase 5: Execute
    |- Build executionContext (fix-plan + diagnoses + clarifications + selections)
    +- SlashCommand("/workflow:lite-execute --in-memory --mode bugfix")
 ```
@@ -543,7 +543,7 @@ AskUserQuestion({
 
 ---
 
-### Phase 5: Dispatch to Execution
+### Phase 5: Execute to Execution
 
 **CRITICAL**: lite-fix NEVER executes code directly. ALL execution MUST go through lite-execute.
 
@@ -588,7 +588,7 @@ executionContext = {
 }
 ```
 
-**Step 5.2: Dispatch**
+**Step 5.2: Execute**
 
 ```javascript
 SlashCommand(command="/workflow:lite-execute --in-memory --mode bugfix")

package/.claude/commands/workflow/lite-plan.md

@@ -1,6 +1,6 @@
 ---
 name: lite-plan
-description: Lightweight interactive planning workflow with in-memory planning, code exploration, and execution dispatch to lite-execute after user confirmation
+description: Lightweight interactive planning workflow with in-memory planning, code exploration, and execution execute to lite-execute after user confirmation
 argument-hint: "[-e|--explore] \"task description\"|file.md"
 allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*)
 ---
@@ -17,7 +17,7 @@ Intelligent lightweight planning command with dynamic workflow adaptation based
 - Interactive clarification after exploration to gather missing information
 - Adaptive planning: Low complexity → Direct Claude; Medium/High → cli-lite-planning-agent
 - Two-step confirmation: plan display → multi-dimensional input collection
-- Execution dispatch with complete context handoff to lite-execute
+- Execution execute with complete context handoff to lite-execute
 
 ## Usage
 
@@ -62,7 +62,7 @@ Phase 4: Confirmation & Selection
       ├─ Execution: Agent / Codex / Auto
       └─ Review: Gemini / Agent / Skip
 
-Phase 5: Dispatch
+Phase 5: Execute
    ├─ Build executionContext (plan + explorations + clarifications + selections)
    └─ SlashCommand("/workflow:lite-execute --in-memory")
 ```
@@ -535,7 +535,7 @@ AskUserQuestion({
 
 ---
 
-### Phase 5: Dispatch to Execution
+### Phase 5: Execute to Execution
 
 **CRITICAL**: lite-plan NEVER executes code directly. ALL execution MUST go through lite-execute.
 
@@ -582,7 +582,7 @@ executionContext = {
 }
 ```
 
-**Step 5.2: Dispatch**
+**Step 5.2: Execute**
 
 ```javascript
 SlashCommand(command="/workflow:lite-execute --in-memory")