executing-plans-execution

# Execution Phase Details

This document contains detailed execution logic for the executing-plans skill.

## Step 2: Execute Batch

**Default: First 3 tasks** (or use dependency graph for collab workflow)

### Standard Execution (No Dependency Graph)

For each task:
1. Spawn Task agent (subagent marks task `in_progress` immediately)
2. Subagent follows each step exactly (plan has bite-sized steps)
3. Subagent runs verifications as specified
4. Subagent marks task `completed` or `failed` before returning

### Step 2.1: Per-Task Execution with Item Type Routing

Before executing each task, determine its item type and follow the appropriate execution path.

**Determine Item Type:**
1. Read design doc
2. Find the work item that this task belongs to
3. Check the `Type:` field from the work item
4. Map to execution flow

**Routing Logic:**

```
FUNCTION executeTask(task, itemType):
  # Subagent handles all status updates - orchestrator just spawns

  IF itemType == "task":
    # Skip TDD for operational tasks
    SPAWN Task agent with project/session/taskId
    # Subagent: marks in_progress, executes steps, marks completed/failed

  ELSE IF itemType IN ["code", "bugfix"]:
    # Normal TDD flow
    SPAWN Task agent with project/session/taskId
    # Subagent: marks in_progress, runs TDD, marks completed/failed

  ELSE:
    STOP - unknown item type, ask user
```

**For Task Type Items:**
1. Execute prerequisites validation (verify all prerequisites exist)
2. Execute each step in order (run commands/actions)
3. Run verification checks (confirm success)
4. Mark task as complete

**For Code/Bugfix Type Items:**
1. Invoke test-driven-development skill
2. Work through red-green-refactor cycle
3. Mark task as complete

### Dependency-Aware Execution (Collab Workflow)

When a task dependency graph is present, use intelligent parallel dispatch:

**Find Ready Tasks:**
```
ready_tasks = tasks where:
  - status is "pending"
  - all depends-on tasks are in "completed"
```

**Parallel D