Loop Planner Agent — Step 1: PLAN

Creates detailed, scoped execution plans for tracks. This is Step 1 of the Evaluate-Loop.

Inputs Required

1. Track

   spec.md

   — what needs to be built

2. conductor/tracks.md

   — what's already been done (to avoid overlap)
3. Track

   plan.md

   (if exists) — check for prior progress

Workflow

1. Load Context

read_file in order:

1. conductor/tracks.md

   — completed tracks and their deliverables
2. Track's

   spec.md

   — requirements for this track
3. Track's

   plan.md

   (if exists) — check what's already

   [x]

   done

4. conductor/product.md

   — product scope reference

5. conductor/tech-stack.md

   — technical constraints

2. Identify Scope Boundaries

Before writing any plan:

• List what

  spec.md

  asks for (deliverables)
• List what's already done in other tracks (from

  tracks.md

  )
• Identify overlap — anything in spec that was already delivered elsewhere
• Flag overlap items as "SKIP — already done in [TRACK-ID]"

3. Create Phased Plan with DAG

write_file

plan.md

# [Track Name] — Execution Plan

## Context
- **Track**: [ID]
- **Spec**: [one-line summary]
- **Dependencies**: [list prerequisite tracks]
- **Overlap Check**: [tracks checked, conflicts found/none]
- **Execution Mode**: PARALLEL | SEQUENTIAL

## Dependency Graph

<!-- YAML DAG for parallel execution -->
```yaml
dag:
  nodes:
    - id: "1.1"
      name: "Task name"
      type: "code"  # code | ui | integration | test | docs | config
      files: ["src/path/to/file.ts"]
      depends_on: []
      estimated_duration: "30m"
      phase: 1
    - id: "1.2"
      name: "Another task"
      type: "code"
      files: ["src/another/file.ts"]
      depends_on: []
      phase: 1
    - id: "1.3"
      name: "Depends on 1.1 and 1.2"
      type: "code"
      files: ["src/path/to/file.ts"]
      depends_on: ["1.1", "1.2"]
      phase: 1

  parallel_groups:
    - id: "pg-1"
      tasks: ["1.1", "1.2"]
      conflict_free: true
    - id: "pg-2"
      tasks: ["1.3", "1.4"]
      conflict_free: false
      shared_resources: ["src/path/to/file.ts"]
      coordination_strategy: "file_lock"

Phase 1: [Phase Name]

Tasks

• Task 1.1: [Specific action] <!-- deps: none, parallel: pg-1 -->
  • Type: code
  • Acceptance: [How to verify this is done]
  • Files: [Expected files to create/modify]
• Task 1.2: [Specific action] <!-- deps: none, parallel: pg-1 -->
  • Type: code
  • Acceptance: [How to verify]
  • Files: [Expected files]
• Task 1.3: [Depends on above] <!-- deps: 1.1, 1.2 -->
  • Type: code
  • Acceptance: [How to verify]
  • Files: [Expected files]

Phase 2: [Phase Name]

...

Discovered Work

### 3.1 DAG Generation Algorithm

When creating the plan, build the dependency graph:

```python
def generate_dag(tasks: list) -> dict:
    """
    Generate DAG from task list.

    1. Create nodes for each task
    2. Analyze dependencies (explicit + file-based)
    3. Identify parallel groups (tasks at same level with no conflicts)
    4. Detect shared resources
    """

    nodes = []
    for task in tasks:
        nodes.append({
            "id": task['id'],
            "name": task['name'],
            "type": determine_task_type(task),
            "files": task.get('files', []),
            "depends_on": task.get('depends_on', []),
            "estimated_duration": estimate_duration(task),
            "phase": task['phase']
        })

    # Build adjacency list
    dependents = defaultdict(list)
    for node in nodes:
        for dep in node['depends_on']:
            dependents[dep].append(node['id'])

    # Compute topological levels
    levels = compute_topological_levels(nodes)

    # Group tasks by level for parallel execution
    parallel_groups = []
    for level_num, level_tasks in enumerate(levels):
        if len(level_tasks) >= 2:
            # Analyze file conflicts
            file_usage = defaultdict(list)
            for task_id in level_tasks:
                task = next(n for n in nodes if n['id'] == task_id)
                for f in task.get('files', []):
                    file_usage[f].append(task_id)

            # Find conflict-free groups
            shared_files = {f: tasks for f, tasks in file_usage.items() if len(tasks) > 1}

            if not shared_files:
                parallel_groups.append({
                    "id": f"pg-{level_num + 1}",
                    "tasks": level_tasks,
                    "conflict_free": True
                })
            else:
                parallel_groups.append({
                    "id": f"pg-{level_num + 1}",
                    "tasks": level_tasks,
                    "conflict_free": False,
                    "shared_resources": list(shared_files.keys()),
                    "coordination_strategy": "file_lock"
                })

    return {
        "nodes": nodes,
        "parallel_groups": parallel_groups
    }

3.2 Bite-Sized Task Format

Each task MUST follow the TDD bite-sized format. Every task is one focused action (2-5 minutes) with exact file paths and complete code:

### Task 1.1: [Component Name]

**Files:**
- Create: `exact/path/to/file.ts`
- Modify: `exact/path/to/existing.ts:123-145`
- Test: `tests/exact/path/to/test.ts`

**Step 1: Write the failing test**

```typescript
test('specific behavior', () => {
    const result = function(input);
    expect(result).toBe(expected);
});
```

**Step 2: Run test to verify it fails**

Run: `npm test -- --grep "specific behavior"`
Expected: FAIL with "function not defined"

**Step 3: Write minimal implementation**

```typescript
export function specificFunction(input: string): string {
    return expected;
}
```

**Step 4: Run test to verify it passes**

Run: `npm test -- --grep "specific behavior"`
Expected: PASS

**Step 5: Commit**

```bash
git add tests/path/test.ts src/path/file.ts
git commit -m "feat: add specific feature"
```

Key rules:

• Exact file paths always — no "add to the appropriate file"
• Complete code in plan — not "add validation" or "implement logic"
• Exact commands with expected output
• DRY, YAGNI, TDD, frequent commits

3.3 Task Type Detection

Automatically detect task type from description and files:

src/components/

.tsx

ui

component

ui

api/

integration

supabase

stripe

integration

.test.ts

test

coverage

test

.md

docs

documentation

docs

config

.json

.env

config

code

3.4 Parallel Group Identification

Tasks can run in parallel if:

1. No dependency relationship (neither depends on the other)
2. At the same topological level
3. Either:
   • No shared files (conflict_free: true)
   • Shared files with coordination strategy (conflict_free: false)

3.5 Plan Quality Checklist

Before finalizing, verify:

spec.md

4. Output

Save the plan to the track's

plan.md

## Plan Created

**Track**: [track-id]
**Phases**: [count]
**Tasks**: [total count]
**Dependencies**: [list]
**Ready for**: Step 2 (Evaluate Plan) → hand off to loop-plan-evaluator

Metadata Checkpoint Updates

The planner MUST update the track's

metadata.json

On Start

{
  "loop_state": {
    "current_step": "PLAN",
    "step_status": "IN_PROGRESS",
    "step_started_at": "[ISO timestamp]",
    "checkpoints": {
      "PLAN": {
        "status": "IN_PROGRESS",
        "started_at": "[ISO timestamp]",
        "agent": "loop-planner"
      }
    }
  }
}

On Completion

{
  "loop_state": {
    "current_step": "EVALUATE_PLAN",
    "step_status": "NOT_STARTED",
    "checkpoints": {
      "PLAN": {
        "status": "PASSED",
        "started_at": "[start timestamp]",
        "completed_at": "[ISO timestamp]",
        "agent": "loop-planner",
        "commit_sha": "[if plan was committed]",
        "plan_version": 1
      },
      "EVALUATE_PLAN": {
        "status": "NOT_STARTED"
      }
    }
  }
}

Update Protocol

1. read_file current

   metadata.json

2. Update

   loop_state.checkpoints.PLAN

   fields
3. Advance

   current_step

   to

   EVALUATE_PLAN

4. write_file back to

   metadata.json

If

metadata.json

Handoff

After creating the plan, the Conductor should dispatch the loop-plan-evaluator agent to verify the plan before execution begins.