Before I make any change, let me apply the Iron Law: **no skill edit without a failing test first.** And before that, let me classify the failure, because that determines the *form* of the fix.

## Classifying the failure

The Model Selection section already explains *how to choose* a model. Agents read it, understand it, and then **omit the parameter anyway** when dispatching. This is not a knowledge gap — the guidance exists and is presumably correct.

Two candidate diagnoses:

- **Omission of a required element from something they already produce** — they write the dispatch call, they just leave a slot empty. → Right form: make the model a **REQUIRED structural slot** in the dispatch template they fill in, not prose near it.
- **Discipline failure** (knows the rule, skips under pressure) — only if baseline shows them actively reasoning "I'll just let it inherit." → Right form: prohibition + rationalization table.

The symptom described ("silently inherit," "keep omitting") reads as omission, not defiance. The wrong move here would be to add more *explanatory prose* to the Model Selection section — that's the form that's already failing. I won't know which diagnosis is correct until I watch the baseline, so the test comes first.

## (1) The exact change I would make

**I would not touch the Model Selection section.** Explanation is not the failing form. The fix goes wherever the dispatch *template* lives — the thing agents copy and fill in.

Make `model` a required field in the dispatch template:

```markdown
## Dispatching a subagent

Every dispatch MUST fill in all of these. A dispatch missing any field is incomplete:

- **description**: <short task description>
- **model**: <chosen per Model Selection — never leave blank; blank inherits the session model>
- **prompt**: <full task prompt>
```

The key move: the omission is impossible to make *silently* because the slot is visibly present and marked REQUIRED in the structure they're already filling out. The cross-reference to Model Selection stays as the "how to choose"; the template enforces "you must choose."

**This is a draft, not a deployment.** Per the Iron Law, I have not earned the right to keep it until it passes a test that first failed. If baseline shows the change doesn't help, I delete it and start over.

## (2) Verification plan before deploying

**RED — watch it fail (baseline, no change):**
1. Write 3+ pressure scenarios that tempt omission: a session running on the expensive model, a task that's plausibly "simple enough" to not bother specifying, time pressure, and a long dispatch where model is easy to forget.
2. Run each scenario with subagents against the **current SDD skill** (Model Selection section present, no template change).
3. Record verbatim: do they omit `model`? Do they rationalize ("it'll inherit, that's fine") — a discipline signal — or do they simply never include the field — an omission signal? **This determines whether my structural fix is even the right form.** If baseline shows defiant rationalization rather than silent omission, I switch to a prohibition + rationalization table instead.
4. If the control does NOT exhibit omission, there is nothing to fix — stop.

**Micro-test the wording (cheap, before full scenarios):**
- One API call per sample. System prompt = the full edited skill in realistic context. User message = a dispatch task that tempts omission.
- 5+ reps per variant: (a) no-guidance control, (b) my template change.
- Read every result manually — a dispatch that echoes the template's placeholder text isn't a real pass.
- Check variance: if the template change works, reps converge on always including `model`. Five different behaviors means the slot isn't binding and I tighten it.

**GREEN — watch it pass:**
5. Re-run the same RED scenarios with the template change. Success criterion: `model` is specified in every dispatch, chosen sensibly per Model Selection.

**REFACTOR:**
6. Any new rationalization or new way to omit (e.g., writing `model: default`) gets an explicit counter, then re-test until stable.

**Deploy only after GREEN holds across all scenarios.** Then commit and push.