plan-to-dag

Plan To DAG

Core Rule

Turn the plan into an execution graph before implementation. Do not produce a flat task list for work that has dependencies, shared files, rollout gates, or multiple agents.

Workflow

1. Extract concrete tasks.
2. Mark blockers, dependencies, and shared write surfaces.
3. Classify tasks by type and risk.
4. Build a DAG.
5. Compress the DAG into execution waves.
6. Define validation gates for each wave.
7. Produce subagent prompts only for tasks that can run independently.
8. State what must stay local on the critical path.

Task Extraction

Convert prose into task nodes. Each node must have:

id:
title:
type: research | design | code | test | docs | migration | ops | review
owner: local | worker | explorer | human | external
write_scope:
inputs:
outputs:
depends_on:
parallel_with:
risk: low | medium | high
validation:
done_when:

Prefer small implementation nodes with clear write scopes. Avoid vague nodes such as “integrate platform” or “improve system”.

Dependency Rules

Use these dependency defaults unless the repo proves otherwise:

• Contracts before producers and consumers.
• Schemas before generated types.
• DB migrations before stores and APIs.
• Store methods before API handlers.
• API handlers before UI integration.
• Runtime registry before runtime execution.
• Feature flags before behavior changes.
• Dual-write before read-path switch.
• Read-path switch before deleting compatibility paths.
• Tests beside each behavior change, not only at the end.
• Docs/ADRs before irreversible architecture changes.

Parallelization Rules

Parallelize only when write scopes do not overlap and the tasks do not depend on each other.

Good parallel splits:

• schema/type work vs documentation
• platform API tests vs vehicle runtime tests
• UI handoff docs vs backend migration design
• independent app handlers with separate files

Bad parallel splits:

• two workers editing the same generated API file
• implementation before schema is settled
• tests for behavior not yet implemented
• cleanup that touches files active workers are editing