Steal these prompts.

Read PROGRESS.md and run:
  git status --short && git log --oneline -10 && grep -rn "TODO\|FIXME" --include="*.{ts,tsx,py}" -l | head

Compare what PROGRESS.md says is done against what the repo shows.
Output exactly three buckets:
  High   — drift that blocks the next milestone
  Watch  — drift worth noting, not blocking
  Noise  — everything else
If High is empty, say "no drift" and stop. Do not fix anything in this session.

Task: <describe the multi-file task>.

Fan out these parallel workers, each in its own git worktree:
  1. <subtask A — files it owns>
  2. <subtask B — files it owns>
  3. <subtask C — files it owns>

Rules: each worker gets ONLY its subtask and the file list — no shared context.
File ownership must not overlap. Dedupe imports and shared types with a
deterministic script, not another agent.
When all workers finish, synthesize one report: what changed, what conflicted,
what is still unverified.

You are a verifier. You have not seen the work that was just done, and you
must not trust any claims about it.

You get three things:
  1. The contract: <paste the acceptance criteria>
  2. The artifact: <the diff or file set>
  3. The repo at HEAD: run the build and tests yourself.

Check three things, in order:
  Correctness   — does it satisfy every line of the contract?
  Currentness   — does it still hold against HEAD, with no stale references?
  Compiler      — does it typecheck/build with zero errors?

Max 3 fix attempts. If it still fails, stop and escalate to a human.
Report: PASS or FAIL with the exact failing check.

Before any file-writing work, isolate it:
  git worktree add ../<repo>-<task-name> -b <task-branch>

Do the work inside that worktree, commit there, then merge back with:
  git merge <task-branch>

Never write files in the main checkout while another agent session is running.
If two tasks must touch the same file, that is a dependency — sequence them,
do not parallelize them.