feat(models): move the implementer to opus/high

Owner-ratified 2026-07-20: authored code is the pipeline's primary
output, so plan execution takes the judgment model — but keeps the
in-loop effort tier (high, not xhigh): the implementer is the
most-dispatched per-task role and volume x wall-clock still governs
its thinking budget. Applies to the frontmatter pin and the three
implement-loop dispatches (impl, impl-fix-spec, impl-fix-qual).

The compiler-driven-edit arm deliberately keeps its implementer
dispatch at sonnet/high: compiler-enumerated propagation is
mechanical, and the arm's policy header pins its own tier.

docs/agent-template.md

@@ -137,9 +137,18 @@ Assignment rule, in priority order:
    evidence, the in-loop quality review) — run `opus`. Opus is
    the documented strength for code review, debugging, and deep
    reasoning.
-3. **Mechanical scope** — tightly-scoped execution of a pre-made
-   plan, recon, extraction, compliance-diffing run `sonnet`
-   (near-opus coding quality at lower latency and cost).
+3. **Mechanical scope** — recon, extraction, compliance-diffing
+   run `sonnet` (near-opus quality on tightly-scoped work at
+   lower latency and cost). Plan execution itself — the
+   `implementer` — is owner-ratified (2026-07-20) onto `opus`:
+   authored code is the pipeline's primary output, so it takes
+   the judgment model, but pairs it with `high` effort, not
+   `xhigh` — it is the most-dispatched in-loop role, and
+   volume × wall-clock (rule 4) still governs its thinking
+   budget. The compiler-driven-edit arm keeps dispatching the
+   implementer agentType at `sonnet`/`high`: compiler-enumerated
+   propagation is mechanical, and that arm's policy header pins
+   its own tier.
 4. **Volume × wall-clock** — agents dispatched per-task inside
    loops or fanned out in parallel swarms multiply their model's
    latency; they run `sonnet` unless rule 2 overrides (currently
@@ -156,9 +165,9 @@ Assignment rule, in priority order:
 
 Current distribution: `fable` — architect, debugger,
 grounding-check, tdd-author. `opus` — bencher, fieldtester,
-plan-recon, quality-reviewer, spec-skeptic. `sonnet` — docwriter,
-glossary-extractor, implementer, spec-reviewer, synthetic-user,
-tester.
+implementer (at `high`), plan-recon, quality-reviewer,
+spec-skeptic. `sonnet` — docwriter, glossary-extractor,
+spec-reviewer, synthetic-user, tester.
 
 The same rule binds Workflow scripts: every `agent()` call passes an
 explicit `model:` option, and `fable` is never a valid value there —
@@ -174,14 +183,16 @@ effort, coupling every dispatch's thinking budget to whatever the user
 happens to be chatting at — the same session-state coupling the `model`
 pin exists to remove. Effort follows the model split:
 
-- **`xhigh` on every `fable` and `opus` agent.** The judgement
-  roles are the pipeline's quality floor; their thinking budget
-  must not silently degrade because the session runs lower. The
-  fable gates deliberately stay at `xhigh`, not `max` — the
+- **`xhigh` on every `fable` and `opus` judgment agent.** The
+  judgement roles are the pipeline's quality floor; their thinking
+  budget must not silently degrade because the session runs lower.
+  The fable gates deliberately stay at `xhigh`, not `max` — the
   marginal thinking is not worth the extra latency and
-  scarce-budget burn.
-- **`high` on every `sonnet` agent.** Tightly-scoped execution of a
-  pre-made plan gains little from `xhigh` but pays its latency on
+  scarce-budget burn. One `opus` agent is exempt: the
+  `implementer` pairs `opus` with `high` (§ model rule 3 — the
+  most-dispatched in-loop role keeps the in-loop effort tier).
+- **`high` on every `sonnet` agent.** Tightly-scoped mechanical
+  work gains little from `xhigh` but pays its latency on
   every dispatch — and these are exactly the roles dispatched
   per-task inside loops (wall-clock is the pipeline's efficiency
   metric). Not lower than `high`: a sloppy in-loop step triggers