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

This reverts commit cdbc2d0. The bump was a judgment call without
evidence, and the planner design intent argues the other way: the plan
Iron Law is "EVERY STEP THAT CHANGES CODE INCLUDES THE CODE" and tasks
are sized so a subagent executes one "without judgement calls outside
its remit" (planner/SKILL.md) — the planner exists precisely to remove
design latitude from the implementer, which points at sonnet, not opus.
opus is only justified to the degree real plans leave slack (RED-step
invention, tree reconciliation, review repair), and that slack is
measurable, not felt. Restore sonnet/high; a future bump should be
grounded in the loop metrics (spec re-loop count, quality
changes_requested rate, end-verify BLOCKED rate) via postmortem, not a
gut call. The four fable gates (b591e75) are untouched.

docs/agent-template.md

@@ -137,18 +137,9 @@ 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** — recon, extraction, compliance-diffing
+3. **Mechanical scope** — tightly-scoped execution of a pre-made
-   run `sonnet` (near-opus quality on tightly-scoped work at
+   plan, recon, extraction, compliance-diffing run `sonnet`
-   lower latency and cost). Plan execution itself — the
+   (near-opus coding quality at lower latency and cost).
-   `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
@@ -165,9 +156,9 @@ Assignment rule, in priority order:
 
 Current distribution: `fable` — architect, debugger,
 grounding-check, tdd-author. `opus` — bencher, fieldtester,
-implementer (at `high`), plan-recon, quality-reviewer,
+plan-recon, quality-reviewer, spec-skeptic. `sonnet` — docwriter,
-spec-skeptic. `sonnet` — docwriter, glossary-extractor,
+glossary-extractor, implementer, spec-reviewer, synthetic-user,
-spec-reviewer, synthetic-user, tester.
+tester.
 
 The same rule binds Workflow scripts: every `agent()` call passes an
 explicit `model:` option, and `fable` is never a valid value there —
@@ -183,16 +174,14 @@ 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` judgment agent.** The
+- **`xhigh` on every `fable` and `opus` agent.** The judgement
-  judgement roles are the pipeline's quality floor; their thinking
+  roles are the pipeline's quality floor; their thinking budget
-  budget must not silently degrade because the session runs lower.
+  must not silently degrade because the session runs lower. The
-  The fable gates deliberately stay at `xhigh`, not `max` — the
+  fable gates deliberately stay at `xhigh`, not `max` — the
   marginal thinking is not worth the extra latency and
-  scarce-budget burn. One `opus` agent is exempt: the
+  scarce-budget burn.
-  `implementer` pairs `opus` with `high` (§ model rule 3 — the
+- **`high` on every `sonnet` agent.** Tightly-scoped execution of a
-  most-dispatched in-loop role keeps the in-loop effort tier).
+  pre-made plan gains little from `xhigh` but pays its latency on
-- **`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

implement/agents/implementer.md

@@ -2,7 +2,7 @@
 name: implementer
 description: Carries out a tightly scoped implementation task. Reads the task extract handed by the controller, implements, builds, tests, reports a structured status with the diff. NOT for architecture decisions, NOT for self-curated scope; this agent executes a plan that has already been made.
 tools: Read, Edit, Write, Bash, Glob, Grep
-model: opus
+model: sonnet
 effort: high
 ---
 

implement/workflows/compiler-driven-edit.js

@@ -43,10 +43,7 @@
 // session-model inherit (which could route to an unintended tier, e.g. fable —
 // reserved for the four ratified frontmatter gates, never for workflow stages;
 // agent-template § model rule 1). Both phases here are mechanical
-// (compiler-enumerated propagation, build/suite re-run), so both run sonnet —
+// (compiler-enumerated propagation, build/suite re-run), so both run sonnet.
-// including the implementer agentType: its opus frontmatter tier is for plan
-// execution, not compiler-enumerated propagation (agent-template § model
-// rule 3), so this arm pins sonnet explicitly.
 // Effort policy mirrors it: every call pins an explicit effort — the edit
 // (real code work) runs high, the build/suite verify (schema-bound check)
 // runs medium. See docs/agent-template.md § effort.

implement/workflows/implement-loop.js

@@ -82,9 +82,7 @@
 //     session-model inherit (which could route to an unintended tier, e.g.
 //     fable — reserved for the four ratified frontmatter gates, never for
 //     workflow stages; agent-template § model rule 1). Mechanical and
-//     in-loop check steps run sonnet; the implementer runs opus/high
+//     in-loop steps run sonnet; the quality gate runs opus by default (last
-//     (owner-ratified 2026-07-20: judgment model for code authorship, kept at
-//     the in-loop effort tier); the quality gate runs opus by default (last
 //     correctness review before the end-verify), TIERED to sonnet/high for a
 //     small (<= 25 changed lines), non-contract diff as measured
 //     independently by the spec-reviewer (issue #30) — the end-verify /
@@ -794,7 +792,7 @@ async function runTask(task) {
       'inner-loop discipline — add the failing test inline even if the task text forgot to script it). ' +
       'Build and test must be green before you report DONE. Leave all edits UNSTAGED; never commit.\n\n' +
       `mode: ${mode}\niter_id: ${iter_id}\n\nTASK ${task.id} — ${task.title}\n${task.text}`,
-    { agentType: 'implementer', model: 'opus', effort: 'high', label: `impl:${task.id}`, phase: 'Per-task loop', schema: IMPL_SCHEMA },
+    { agentType: 'implementer', model: 'sonnet', effort: 'high', label: `impl:${task.id}`, phase: 'Per-task loop', schema: IMPL_SCHEMA },
   )
   if (!impl) return { id: task.id, title: task.title, outcome: 'BLOCKED', reason: 'implementer agent did not return' }
   if (impl.status === 'BLOCKED') return { id: task.id, title: task.title, outcome: 'BLOCKED', reason: impl.reason || 'worker-blocked' }
@@ -835,7 +833,7 @@ async function runTask(task) {
       `${STANDING}${ANCHOR}\n\nRepair task ${task.id} to satisfy the spec-compliance review. Address EACH finding; ` +
         'do not widen scope. Keep build + tests green; leave edits unstaged.\n\n' +
         `TASK ${task.id} — ${task.title}\n${task.text}\n\nFINDINGS:\n- ${(spec?.findings || ['(none reported)']).join('\n- ')}`,
-      { agentType: 'implementer', model: 'opus', effort: 'high', label: `impl-fix-spec:${task.id}`, phase: 'Per-task loop', schema: IMPL_SCHEMA },
+      { agentType: 'implementer', model: 'sonnet', effort: 'high', label: `impl-fix-spec:${task.id}`, phase: 'Per-task loop', schema: IMPL_SCHEMA },
     )
     if (specFix && specFix.applied_changes === true) wroteAnyFile = true
   }
@@ -953,7 +951,7 @@ async function runTask(task) {
         'into a deviation the next review flags.\n\n' +
         `TASK ${task.id} — ${task.title}\n${task.text}\n\nISSUES:\n- ` +
         (qual?.issues?.length ? qual.issues.map((i) => `[${i.severity}] ${i.text}`) : ['(none reported)']).join('\n- '),
-      { agentType: 'implementer', model: 'opus', effort: 'high', label: `impl-fix-qual:${task.id}`, phase: 'Per-task loop', schema: IMPL_SCHEMA },
+      { agentType: 'implementer', model: 'sonnet', effort: 'high', label: `impl-fix-qual:${task.id}`, phase: 'Per-task loop', schema: IMPL_SCHEMA },
     )
     if (fix && fix.applied_changes === true) wroteAnyFile = true
     if (fix && (fix.status === 'BLOCKED' || fix.status === 'NEEDS_CONTEXT')) {