1.1 Read all tasks first

Read the ENTIRE user message before doing anything
Do NOT start implementing
Do NOT ask clarifying questions yet (unless a task is completely ambiguous)

1.2 Categorize each task

For each task, identify:

Domain — which page, module, or feature area
Type — bug fix / new feature / refactor / config
Size — small (< 1 hour) / medium / large (cross-cutting)
Dependency — does it depend on another task?

Phase 2 — Decompose

2.1 Group by isolation boundary

Rule: Tasks that touch the same files → same agent
Rule: Tasks that are cross-cutting (e.g. alias migration) → separate agent
Rule: Tasks with no file overlap → separate agents (parallel)

2.2 Agent assignment

Name agents alphabetically:

AGENT A — [Domain or Theme]
AGENT B — [Domain or Theme]
AGENT C — [Domain or Theme]
...

Each agent gets:

A clear responsibility label
A list of tasks (numbered A.1, A.2, ...)
A list of files it owns (no overlap with other agents)

2.3 Isolation rule (HARD)

⚠️ ISOLATION — Non-negotiable

- Each agent owns its files. No other agent touches them.
- If two tasks need the same file → assign both to the same agent.
- If a file conflict is unavoidable → flag it to the user before starting.
- Agents NEVER read or modify each other's output mid-session.

Phase 3 — Prioritize

Priority	When	Examples
HIGH	Broken functionality, blocking others	Auth bug, crash, core feature
MEDIUM	Important but not blocking	New page, filter, export
LOW	Polish, cleanup, migration	Alias refactor, rename, docs

Execution order:

HIGH agents first (run in parallel if isolated)
MEDIUM after HIGH is verified
LOW last

Phase 4 — Write tasks.md

Create tasks.md in project root with this format:

# Task List — [Project Name]
Generated: [date]

---

## 🤖 AGENT A — [Theme]
**Files owned:** `src/x/`, `src/y/file.ts`
**Priority:** HIGH

### Task A.1 — [Title]
- **What:** Clear description of what to do
- **Why:** Reason / user complaint / bug
- **Acceptance:** Specific condition that proves it's done
- **Files:** Exact file paths

### Task A.2 — [Title]
- **What:** ...
- **Why:** ...
- **Acceptance:** ...
- **Files:** ...

---

## 🤖 AGENT B — [Theme]
**Files owned:** `src/z/`
**Priority:** MEDIUM

### Task B.1 — [Title]
...

---

## ⚠️ ISOLATION CONTRACT

| Agent | Files | Must NOT touch |
|-------|-------|---------------|
| Agent A | src/x/, src/y/ | src/z/ |
| Agent B | src/z/ | src/x/, src/y/ |

---

## 📋 SUMMARY

| # | Agent | Tasks | Priority | Can start? |
|---|-------|-------|----------|------------|
| A | [Theme] | 2 | HIGH | Yes |
| B | [Theme] | 3 | MEDIUM | After A verified |

**Total agents:** N
**Total tasks:** M
**Parallel groups:** [A, C] then [B] then [D]

---

## ✅ VERIFICATION (each agent runs after finishing)

\`\`\`bash
pnpm typecheck
pnpm lint
pnpm test  # if available
\`\`\`

Phase 5 — Dispatch

After tasks.md is written, dispatch agents:

Parallel dispatch (no dependencies):

Agent A, B, C — parallel start.
Each reads only its section in tasks.md.
Each runs typecheck + lint after finishing.

Sequential dispatch (dependencies exist):

1. Start Agent A (HIGH priority)
2. After Agent A: pnpm typecheck && pnpm lint
3. Start Agent B only after A is VERIFIED

Dispatch message format per agent:

## Agent [X] — START

Your tasks are in tasks.md under "AGENT [X]" section.
Files you own: [list]
Files you must NOT touch: [list]

After completing ALL your tasks:
1. pnpm typecheck
2. pnpm lint
3. Report: which tasks done, any blockers

Phase 6 — Track

After all agents complete:

Agent	Status	Typecheck	Lint	Blockers
A	✅ Done	✅ Pass	✅ Pass	None
B	🟡 WIP	—	—	Waiting for A
C	❌ Blocked	—	—	Unclear requirement

For blocked agents → ask user before resuming.

Rules

NEVER:

Start implementing before writing tasks.md
Mix tasks from different domains into one agent
Let two agents own the same file
Mark a task complete if typecheck/lint fails
Guess on ambiguous tasks — ask the user

ALWAYS:

Write tasks.md before any agent starts
Assign priority to every task
State the isolation contract explicitly
Run typecheck + lint after each agent
Report blockers immediately

Quick Reference

User sends tasks
     ↓
Phase 1: Read all. Categorize.
     ↓
Phase 2: Group by isolation. Assign agents.
     ↓
Phase 3: Set priorities.
     ↓
Phase 4: Write tasks.md
     ↓
Phase 5: Dispatch agents (parallel or sequential)
     ↓
Phase 6: Track. Verify. Report.

task-manager

Task Manager

When to Use

Phase 1 — Intake