workflow-execute

# Workflow Execute Orchestrates autonomous workflow execution through systematic task discovery, agent coordination, and progress tracking. **Executes entire workflow without user interruption** (except initial session selection if multiple active sessions exist), providing complete context to agents and ensuring proper flow control execution with comprehensive TodoWrite tracking. **Resume Mode**: When called with `--resume-session` flag, skips discovery phase and directly enters TodoWrite generation and agent execution for the specified session. ## Usage ```bash # Interactive mode (with confirmations) /workflow-execute /workflow-execute --resume-session="WFS-auth" # Auto mode (skip confirmations, use defaults) /workflow-execute --yes /workflow-execute -y /workflow-execute -y --resume-session="WFS-auth" # With auto-commit (commit after each task completion) /workflow-execute --with-commit /workflow-execute -y --with-commit /workflow-execute -y --with-commit --resume-session="WFS-auth" ``` ## Auto Mode Defaults When `--yes` or `-y` flag is used: - **Session Selection**: Automatically selects the first (most recent) active session - **Completion Choice**: Automatically completes session (runs `/workflow:session:complete --yes`) When `--with-commit` flag is used: - **Auto-Commit**: After each agent task completes, commit changes based on summary document - **Commit Principle**: Minimal commits - only commit files modified by the completed task - **Commit Message**: Generated from task summary with format: "feat/fix/refactor: {task-title} - {summary}" **Flag Parsing**: ```javascript // ★ 统一 auto mode 检测：-y/--yes 从 $ARGUMENTS 或 ccw 传播 const autoYes = /\b(-y|--yes)\b/.test($ARGUMENTS) const withCommit = $ARGUMENTS.includes('--with-commit') ``` ## Performance Optimization Strategy **Lazy Loading**: Task JSONs read **on-demand** during execution, not upfront. TODO_LIST.md + IMPL_PLAN.md provide metadata for planning. **Loading Strategy**: - **TODO_LIST.md**: Read in Phase 3 (task metadata, status, dependencies for TodoWrite generation) - **IMPL_PLAN.md**: Check existence in Phase 2 (normal mode), parse execution strategy in Phase 4A - **Task JSONs**: Lazy loading - read only when task is about to execute (Phase 4B) ## 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.** **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 - **Session Discovery**: Identify and select active workflow sessions - **Execution Strategy Parsing**: Extract execution model from IMPL_PLAN.md - **TodoWrite Progress Tracking**: Maintain real-time execution status throughout entire workflow - **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 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 - **Autonomous completion**: Execute all tasks without user interruption until workflow complete ## Execution Process ``` Normal Mode: Phase 1: Discovery ├─ Count active sessions └─ Decision: ├─ count=0 → ERROR: No active sessions ├─ count=1 → Auto-select session → Phase 2 └─ count>1 → AskUserQuestion (max 4 options) → Phase 2 Phase 2: Planning Document Validation ├─ Check IMPL_PLAN.md exists ├─ Check TODO_LIST.md exists └─ Validate .task/ contains IMPL-*.json files Phase 3: TodoWrite Generation ├─ Update session status to "active" (Step 0) ├─ Parse TODO_LIST.md for task statuses ├─ Generate TodoWrite for entire workflow └─ Prepare session context paths Phase 4: Execution Strategy & Task Execution ├─ Step 4A: Parse execution strategy from IMPL_PLAN.md └─ Step 4B: Execute tasks with lazy loading └─ Loop: ├─ Get next in_progress task from TodoWrite ├─ Lazy load task JSON ├─ Launch agent with task context ├─ Mark task completed (update IMPL-*.json status) │ # Quick fix: Update task status for ccw dashboard │ # TS=$(date -Iseconds) && jq --arg ts "$TS" '.status="completed" | .status_history=(.status_history // [])+[{"from":"in_progress","to":"completed","changed_at":$ts}]' IMPL-X.json > tmp.json && mv tmp.json IMPL-X.json ├─ [with-commit] Commit changes based on summary (minimal principle) │ # Read summary from .summaries/IMPL-X-summary.md │ # Extract changed files from summary's "Files Modified" section │ # Generate commit message: "feat/fix/refactor: {task-title} - {summary}" │ # git add <changed-files> && git commit -m "<commit-message>" └─ Advance to next task Phase 5: Completion ├─ Update task statuses in JSON files ├─ Generate summaries └─ AskUserQuestion: Choose next step ├─ "Enter Review" → Phase 6 └─ "Complete Session" → /workflow:session:complete Phase 6: Post-Implementation Review (Optional) └─ Ref: phases/06-review.md ├─ Select review type (quality/security/architecture/action-items) ├─ CLI-assisted analysis (Gemini/Qwen) ├─ Generate REVIEW-{type}.md report └─ Post-review: another review or complete session Resume Mode (--resume-session): ├─ Skip Phase 1 & Phase 2 └─ Entry Point: Phase 3 (TodoWrite Generation) ├─ Update session status to "active" (if not already) └─ Continue: Phase 4 → Phase 5 → [Phase 6] ``` ## Execution Lifecycle ### Phase 1: Discovery **Applies to**: Normal mode only (skipped in resume mode) **Purpose**: Find and select active workflow session with user confirmation when multiple sessions exist **Process**: #### Step 1.1: Count Active Sessions ```bash bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null | wc -l) ``` #### Step 1.2: Handle Session Selection **Case A: No Sessions** (count = 0) ``` ERROR: No active workflow sessions found Run /workflow-plan "task description" to create a session ``` **Case B: Single Session** (count = 1) ```bash bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null | head -1 | xargs basename) ``` Auto-select and continue to Phase 2. **Case C: Multiple Sessions** (count > 1) List sessions with metadata and prompt user selection: ```bash 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) ``` **Parse --yes flag**: ```javascript // ★ 统一 auto mode 检测：-y/--yes 从 $ARGUMENTS 或 ccw 传播 const autoYes = /\b(-y|--yes)\b/.test($ARGUMENTS) ``` **Conditional Selection**: ```javascript if (autoYes) { // Auto mode: Select first session (most recent) const firstSession = sessions[0] console.log(`[--yes] Auto-selecting session: ${firstSession.id}`) selectedSessionId = firstSession.id // Continue to Phase 2 } else { // Interactive mode: Use AskUserQuestion to present formatted options (max 4 options shown) // If more than 4 sessions, show most recent 4 with "Other" option for manual input const sessions = getActiveSessions() // sorted by last modified const displaySessions = sessions.slice(0, 4) AskUserQuestion({ questions: [{ question: "Multiple active sessions detected. Select one:", header: "Session", multiSelect: false, options: displaySessions.map(s => ({ label: s.id, description: `${s.project} | ${s.progress}` })) // Note: User can select "Other" to manually enter session ID }] }) } ``` **Input Validation**: - If user selects from options: Use selected session ID - If user selects "Other" and provides input: Validate session exists - If validation fails: Show error and re-prompt or suggest available sessions Parse user input (supports: number "1", full ID "WFS-auth-system", or partial "auth"), validate selection, and continue to Phase 2. #### Step 1.3: Load Session Metadata ```bash bash(cat .workflow/active/${sessionId}/workflow-session.json) ``` **Output**: Store session metadata in memory **DO NOT read task JSONs yet** - defer until execution phase (lazy loading) **Resume Mode**: This entire phase is skipped when `--resume-session="session-id"` flag is provided. ### Phase 2: Planning Document Validation **Applies to**: Normal mode only (skipped in resume mode) **Purpose**: Validate planning artifacts exist before execution **Process**: 1. **Check IMPL_PLAN.md**: Verify file exists (defer detailed parsing to Phase 4A) 2. **Check plan.json**: Verify file exists (structured plan overview, used in Phase 4A) 3. **Check TODO_LIST.md**: Verify file exists (defer reading to Phase 3) 4. **Validate Task Directory**: Ensure `.task/` contains at least one IMPL-*.json file **Key Optimization**: Only existence checks here. Actual file reading happens in later phases. **Resume Mode**: This phase is skipped when `--resume-session` flag is provided. Resume mode entry point is Phase 3. ### Phase 3: TodoWrite Generation **Applies to**: Both normal and resume modes (resume mode entry point) **Step 0: Update Session Status to Active** Before generating TodoWrite, update session status from "planning" to "active": ```bash # Update session status (idempotent - safe to run if already active) jq '.status = "active" | .execution_started_at = (.execution_started_at // now | todate)' \ .workflow/active/${sessionId}/workflow-session.json > tmp.json && \ mv tmp.json .workflow/active/${sessionId}/workflow-session.json ``` This ensures the dashboard shows the session as "ACTIVE" during execution. **Process**: 1. **Create TodoWrite List**: Generate task list from TODO_LIST.md (not from task JSONs) - Parse TODO_LIST.md to extract all tasks with current statuses - Identify first pending task with met dependencies - Generate comprehensive TodoWrite covering entire workflow 2. **Prepare Session Context**: Inject workflow paths for agent use (using provided session-id) 3. **Validate Prerequisites**: Ensure IMPL_PLAN.md and TODO_LIST.md exist and are valid **Resume Mode Behavior**: - Load existing TODO_LIST.md directly from `.workflow/active/{session-id}/` - Extract current progress from TODO_LIST.md - Generate TodoWrite from TODO_LIST.md state - Proceed immediately to agent execution (Phase 4) ### Phase 4: Execution Strategy Selection & Task Execution **Applies to**: Both normal and resume modes **Step 4A: Parse Execution Strategy (plan.json preferred, IMPL_PLAN.md fallback)** Prefer `plan.json` (structured) over `IMPL_PLAN.md` (human-readable) for execution strategy: 1. **If plan.json exists**: Read `recommended_execution`, `complexity`, `task_ids[]`, `shared_context` 2. **Fallback to IMPL_PLAN.md**: Read Section 4 to extract execution model Extract: - **Execution Model**: Sequential | Parallel | Phased | TDD Cycles - **Parallelization Opportunities**: Which tasks can run in parallel - **Serialization Requirements**: Which tasks must run sequentially - **Critical Path**: Priority execution order If neither has execution strategy, use intelligent fallback (analyze task structure). **Step 4B: Execute Tasks with Lazy Loading** **Key Optimization**: Read task JSON **only when needed** for execution **Execution Loop Pattern**: ``` while (TODO_LIST.md has pending tasks) { next_task_id = getTodoWriteInProgressTask() task_json = Read(.workflow/active/{session}/.task/{next_task_id}.json) // Lazy load executeTaskWithAgent(task_json) updateTodoListMarkCompleted(next_task_id) advanceTodoWriteToNextTask() } ``` **Execution Process per Task**: 1. **Identify Next Task**: From TodoWrite, get the next `in_progress` task ID 2. **Load Task JSON on Demand**: Read `.task/{task-id}.json` for current task ONLY 3. **Validate Task Structure**: Ensure required fields exist (id, title, description, depends_on, convergence) 4. **Launch Agent**: Invoke specialized agent with complete context including flow control steps 5. **Monitor Progress**: Track agent execution and handle errors without user interruption 6. **Collect Results**: Gather implementation results and outputs 7. **[with-commit] Auto-Commit**: If `--with-commit` flag enabled, commit changes based on summary - Read summary from `.summaries/{task-id}-summary.md` - Extract changed files from summary's "Files Modified" section - Determine commit type from `meta.type` (feature→feat, bugfix→fix, refactor→refactor) - Generate commit message: "{type}: {task-title} - {summary-first-line}" - Commit only modified files (minimal principle): `git add <files> && git commit -m "<message>"` 8. **Continue Workflow**: Identify next pending task from TODO_LIST.md and repeat **Note**: TODO_LIST.md updates are handled by agents (e.g., code-developer.md), not by the orchestrator. ### Phase 5: Completion **Applies to**: Both normal and resume modes **Process**: 1. **Update Task Status**: Mark completed tasks in JSON files 2. **Generate Summary**: Create task summary in `.summaries/` 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. **User Choice**: When all tasks finished, ask user to choose next step: ```javascript // Parse --yes flag // ★ 统一 auto mode 检测：-y/--yes 从 $ARGUMENTS 或 ccw 传播