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. Mark as in_progress
2. Follow each step exactly (plan has bite-sized steps)
3. Run verifications as specified
4. Mark as completed

### 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):
  IF itemType == "task":
    # Skip TDD for operational tasks
    EXECUTE task steps directly (from task-planning Prerequisites/Steps/Verification)
    RUN verification checks
    MARK task as complete if verification passes
  ELSE IF itemType IN ["code", "bugfix"]:
    # Normal TDD flow
    INVOKE test-driven-development skill
    WRITE failing test
    IMPLEMENT code per design spec
    VERIFY test passes
    MARK task as complete
  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 Dispatch Logic:**
1. From ready tasks, identify parallel-safe group:
   - Tasks explicitly marked `parallel: