/execute-plans — plans → code → PRs

You are a thin orchestrator: your role is to loop, delegate, pass data, and report. The heavy lifting happens inside skills and fresh-context agents.

Two standing rules, because sub-skill output buries the parent sequence and compaction silently drops instructions:

• After EVERY skill returns, restate position: "→ Returning to /execute-plans (plan X, step N done): next is step N+1 (<name>)."
• After any auto-compaction, re-invoke the skill governing the current step before continuing.

Input: $ARGUMENTS — PRD name, Initiative name, or explicit folder path(s). Resolve brainstorm-folders from the PRD's frontmatter, or from each Initiative's frontmatter when the PRD has Initiatives; a single Initiative (or folder path) scopes the run to that unit alone — check its depends-on and warn Luc if an upstream initiative hasn't merged yet. Build the plan inventory in DAG order (initiative depends-on, then plan number). Before executing the first plan, create 03-Product/PRDs/Index.md if missing and flip this PRD's row to In-Progress.

Goal: set a session goal now (SlashCommand /goal if available, otherwise state it and treat it as binding): "Every plan executed (or FAILED-with-diagnosis after one re-plan retry), one PR per plan, EXECUTION-REPORT.md written per folder, Index.md row → In-Progress."

Per plan file (strict loop, fresh context each)

Run each plan in a dedicated git worktree (git worktree add) so Luc's checkout is never touched. Plans within an initiative stack: plan 02's branch is cut from plan 01's branch (stacked PRs; /ship-it merges bottom-up).

1. Skill: `learn-existing` — focus plans:<folder>: direct read of THIS plan file + plan/INDEX.md + design.md; codebase sweep via subagent.
2. Skill: `frontend-craft` — only if the plan involves UI work; otherwise skip silently.
3. Execute — author a dynamic Workflow that implements the plan inside the worktree: decompose into the plan's own sections, parallelize only what the plan marks independent, agents report diffs back. (Fallback for small plans: one fresh subagent — or a context: fork skill invocation — executing the plan end-to-end.)
4. Skill: `adversarial-review` — focus: the produced diff.
5. Skill: `simplify` (built-in) — scoped to changed files only.
6. Skill: `frontend-test` — only if the diff touched frontend code.
7. Skill: `backend-test` — only if the diff touched backend code.
8. Skill: `design-test` — only if the plan touched the UI.
9. Skill: `verify` — full stack-detected verification (3-strike fix loop lives inside it).
10. Skill: `pr-preflight` — read-only hygiene gates; hard blockers stop this plan (the on-main finding is remediable — the pr skill branches).
11. Skill: `e2e-smoke-test` — regression gate; never PR on red E2E.
12. Skill: `pr` — branch already exists from the worktree; commit, push, open the PR (base = previous plan's branch when stacked, else main). Record plan → PR# in plan/INDEX.md.

Failure policy — if a step fails beyond its skill's 3-strike loop, or the plan proves wrong against reality: re-plan THIS file against what you learned (mini design pass; mark the file header REPLANNED: <date> — <why>), retry the loop once. Second failure → mark the plan FAILED in INDEX + report, skip plans that depend on it, continue independent ones.

Wrap-up (per brainstorm folder)

Write EXECUTION-REPORT.md at the folder root — lean and fixed: TL;DR (≤5 lines: shipped / failed / deviations) → per-plan table (Plan | PR | Status | Checks) → Deviations from plan (each with why + a Mermaid diagram when structural) → Failures & diagnosis (root cause + diagram) → Follow-ups. Busy-engineer tone: facts, no padding.

Print a phase summary line after every plan ("plan 2/6 done → PR #123, starting plan 3"). Finish with: PRs opened, failures, report paths, and the next command: /ship-it "<PRD name>".