chore: update context

Entire-Checkpoint: 2a6de2e59858

Author: JanDeDobbeleer

.agents/skills/code-changes/SKILL.md

@@ -1,67 +1,70 @@
 ---
 name: code-changes
 description: >
-  Orchestration workflow for any task that ends in code changes: issue analysis, pull request
-  review, feature implementation, bug fixes, refactors, or fleshing out an idea. MUST be invoked
-  at the start of such a task, before reading or writing any code. Defines how to analyze first,
-  gate on user approval, plan, pick the right executor model, delegate and supervise subagents,
-  verify, and deliver.
+  Orchestration workflow for any task that ends in code changes: issue analysis, pull request review, feature
+  implementation, bug fixes, refactors, or fleshing out an idea. MUST be invoked at the start of such a task, before
+  reading or writing any code. Defines how to analyze first, gate on user approval, plan, pick the right executor model,
+  delegate and supervise subagents, verify, and deliver.
 ---
 
 # Code Changes
 
-The workflow for going from an issue, pull request, idea, or feature request to shipped code.
-Follow the phases in order. Analysis always comes first; code comes last.
+The workflow for going from an issue, pull request, idea, or feature request to shipped code. Follow the phases in
+order. Analysis always comes first; code comes last.
 
-Each phase has a reference file with the full instructions. **Read the reference file when you
-enter the phase** — not before, and never skip it because the phase "looks obvious".
+Each phase has a reference file with the full instructions. **Read the reference file when you enter the phase** — not
+before, and never skip it because the phase "looks obvious".
 
 ## Roles
 
-Assign work based on model capability. The coordinator is not the strongest model — it's the one
-that stays resident, owns every phase by default, and knows when it's out of its depth.
+Assign work based on model capability. The coordinator is not the strongest model — it's the one that stays resident,
+owns every phase by default, and knows when it's out of its depth.
 
-| Role        | Capability tier                                               | Owns                                                                          |
-| ----------- | -------------------------------------------------------------- | ------------------------------------------------------------------------------ |
-| Coordinator | Capable mid-tier, resident for the whole task                | Analysis, plan, delegation, supervision, verification, delivery — by default |
-| Escalation  | Strongest reasoning model available; invoked only on trigger | The specific judgment call the coordinator flagged, then control returns     |
-| Implementer | Same tier as coordinator, or smaller for trivial edits        | Executing one pinned, self-contained task                                    |
+- **Role:** Coordinator
+  - **Capability tier:** Capable mid-tier, resident for the whole task
+  - **Owns:** Analysis, plan, delegation, supervision, verification, delivery — by default
 
-Concrete model names per vendor (Anthropic, OpenAI, Google) and how to run the split in Claude
-Code, GitHub Copilot, Codex, or IDE agents: [references/model-tiers.md](references/model-tiers.md).
+- **Role:** Escalation
+  - **Capability tier:** Strongest reasoning model available; invoked only on trigger
+  - **Owns:** The specific judgment call the coordinator flagged, then control returns
 
-When the current agent already runs at implementer tier, there's no separate delegation step for
-standard work: plan and execute directly, still following every phase. Escalate to the strongest
-model only when a trigger fires — see [references/escalate.md](references/escalate.md) — never by
-default and never for a routine judgment call the coordinator is equipped to make itself.
+- **Role:** Implementer
+  - **Capability tier:** Same tier as coordinator, or smaller for trivial edits
+  - **Owns:** Executing one pinned, self-contained task
+
+Concrete model names per vendor (Anthropic, OpenAI, Google) and how to run the split in Claude Code, GitHub Copilot,
+Codex, or IDE agents: [references/model-tiers.md](references/model-tiers.md).
+
+When the current agent already runs at implementer tier, there's no separate delegation step for standard work: plan and
+execute directly, still following every phase. Escalate to the strongest model only when a trigger fires — see
+[references/escalate.md](references/escalate.md) — never by default and never for a routine judgment call the
+coordinator is equipped to make itself.
 
 ## The flow
 
-1. **Analyze** ([references/analyze.md](references/analyze.md)) — root cause and scope,
-   validated against the code, never against the report alone.
-2. **Plan** ([references/plan.md](references/plan.md)) — pinned spec, task split, parallel vs
-   sequential, workspace per task.
-3. **Delegate** ([references/delegate.md](references/delegate.md)) — match each task to the
-   right executor, coordinator-tier by default.
-4. **Supervise** ([references/supervise.md](references/supervise.md)) — monitor, unblock, and
-   critically review implementer output.
-5. **Verify** ([references/verify.md](references/verify.md)) — quality gates plus functional
-   proof, never delegated downward.
-6. **Deliver** ([references/deliver.md](references/deliver.md)) — conventional commits and an
-   outcome-first report.
+1. **Analyze** ([references/analyze.md](references/analyze.md)) — root cause and scope, validated against the code,
+   never against the report alone.
+2. **Plan** ([references/plan.md](references/plan.md)) — pinned spec, task split, parallel vs sequential, workspace per
+   task.
+3. **Delegate** ([references/delegate.md](references/delegate.md)) — match each task to the right executor,
+   coordinator-tier by default.
+4. **Supervise** ([references/supervise.md](references/supervise.md)) — monitor, unblock, and critically review
+   implementer output.
+5. **Verify** ([references/verify.md](references/verify.md)) — quality gates plus functional proof, never delegated
+   downward.
+6. **Deliver** ([references/deliver.md](references/deliver.md)) — conventional commits and an outcome-first report.
 
 Analyze, Supervise, and Verify each carry an escalation checkpoint — see
-[references/escalate.md](references/escalate.md) — for handing one specific judgment call to the
-strongest available model without giving up ownership of the phase.
+[references/escalate.md](references/escalate.md) — for handing one specific judgment call to the strongest available
+model without giving up ownership of the phase.
 
-**Stop gate:** Phase 1 ends with reporting the analysis and proposed approach to the user and
-waiting for a go. Skip the gate only when the user already gave the go in the request itself
-("do it", "fix it and commit", "implement with Sonnet").
+**Stop gate:** Phase 1 ends with reporting the analysis and proposed approach to the user and waiting for a go. Skip the
+gate only when the user already gave the go in the request itself ("do it", "fix it and commit", "implement with
+Sonnet").
 
 ## Special cases
 
 These entry points replace or extend Phase 1; the rest of the flow applies unchanged.
 
-- Pull request review comments →
-  [references/pr-review-comments.md](references/pr-review-comments.md)
+- Pull request review comments → [references/pr-review-comments.md](references/pr-review-comments.md)
 - Issue triage → [references/issue-triage.md](references/issue-triage.md)

.agents/skills/code-changes/references/delegate.md

@@ -1,42 +1,41 @@
 # Phase 3 — Delegate
 
-Match the executor to the task, not the other way around. The point is cost and speed without
-losing quality — the coordinator stays accountable for the result.
+Match the executor to the task, not the other way around. The point is cost and speed without losing quality — the
+coordinator stays accountable for the result.
 
 ## Executor matrix
 
 Tier definitions and per-vendor model examples: [model-tiers.md](model-tiers.md).
 
-| Task profile                                             | Executor                                                       |
-| ---------------------------------------------------------- | ------------------------------------------------------------ |
-| Trivial: mechanical edit, config tweak, typo, doc update  | Do it directly, or batch on a trivial-tier model              |
-| Standard, well-specified implementation                   | Coordinator itself, or a same-tier subagent for parallelism   |
-| Hits an escalation trigger (see [escalate.md](escalate.md)) | Escalation-tier subagent, for that one specific question    |
+- **Task profile:** Trivial: mechanical edit, config tweak, typo, doc update
+  - **Executor:** Do it directly, or batch on a trivial-tier model
 
-- The coordinator typically runs at implementer tier itself, so standard tasks are usually
-  executed directly rather than delegated. Delegate anyway when there's real parallelism —
-  independent tasks, each in its own worktree — or to shed trivial mechanical work onto a
-  cheaper model.
-- Escalation is never the default path for "ambiguous" or "architectural" — it fires only on the
-  concrete triggers in [escalate.md](escalate.md), and only for the specific question, not the
-  whole task.
+- **Task profile:** Standard, well-specified implementation
+  - **Executor:** Coordinator itself, or a same-tier subagent for parallelism
+
+- **Task profile:** Hits an escalation trigger (see [escalate.md](escalate.md))
+  - **Executor:** Escalation-tier subagent, for that one specific question
+
+- The coordinator typically runs at implementer tier itself, so standard tasks are usually executed directly rather than
+  delegated. Delegate anyway when there's real parallelism — independent tasks, each in its own worktree — or to shed
+  trivial mechanical work onto a cheaper model.
+- Escalation is never the default path for "ambiguous" or "architectural" — it fires only on the concrete triggers in
+  [escalate.md](escalate.md), and only for the specific question, not the whole task.
 
 ## What a delegation carries
 
 Hand the subagent its full pinned spec from Phase 2, plus:
 
 - The verification commands it must run and pass before reporting done.
 - The instruction to report what it changed and what it verified — not just "done".
-- The instruction to stop and report when it hits something the spec does not cover, instead of
-  improvising scope.
+- The instruction to stop and report when it hits something the spec does not cover, instead of improvising scope.
 
 ## What is never delegated downward
 
-Analysis, final verification, and delivery never go to an implementer — they stay with the
-coordinator or go up to Escalation tier for a specific question:
+Analysis, final verification, and delivery never go to an implementer — they stay with the coordinator or go up to
+Escalation tier for a specific question:
 
 - Analysis and root-cause work (Phase 1).
 - Final verification (Phase 5) — an implementer's green run is a claim, not a result.
-- Commits, history rewrites, pushes, and user-facing reporting (Phase 6) — these stay with the
-  coordinator regardless of tier; they're about accountability, not capability, so they never go
-  to Escalation tier either.
+- Commits, history rewrites, pushes, and user-facing reporting (Phase 6) — these stay with the coordinator regardless of
+  tier; they're about accountability, not capability, so they never go to Escalation tier either.

.agents/skills/code-changes/references/model-tiers.md

@@ -1,55 +1,65 @@
 # Model tiers and agent tooling
 
-The workflow talks about capability tiers, not vendor names. Map whatever stack is in use onto
-these four tiers. The model names below are a mid-2026 snapshot — they go stale; when a name no
-longer exists, map its replacement by tier, not by nostalgia.
+The workflow talks about capability tiers, not vendor names. Map whatever stack is in use onto these four tiers. The
+model names below are a mid-2026 snapshot — they go stale; when a name no longer exists, map its replacement by tier,
+not by nostalgia.
 
 ## The four tiers
 
-| Tier        | Role                                       | Anthropic         | OpenAI            | Google            |
-| ----------- | ------------------------------------------- | ----------------- | ----------------- | ----------------- |
-| Escalation  | Judgment calls the coordinator flags        | Fable 5, Opus 4.8 | Sol, GPT-5 (high) | Gemini 2.5 Pro    |
-| Coordinator | Resident; owns every phase by default       | Sonnet 5          | GPT-5, GPT-4.1    | Gemini 2.5 Flash  |
-| Implementer | Pinned-spec work, often same tier as coordinator | Sonnet 5     | GPT-5, GPT-4.1    | Gemini 2.5 Flash  |
-| Trivial     | Mechanical edits                            | Haiku 4.5         | GPT-4.1 mini      | Gemini Flash-Lite |
-
-- **Escalation** — the strongest reasoning model available, called only when a trigger in
-  [escalate.md](escalate.md) fires: unclear root cause, architectural risk, security sensitivity,
-  an irreversible operation, repeated spec gaps, or low confidence in a review. Answers one
-  specific question, then hands control back to the coordinator.
-- **Coordinator** — a capable mid-tier model, resident for the whole task. Owns analysis,
-  planning, supervision, and verification by default. It's capable enough for the large majority
-  of work, and cheap enough relative to Escalation tier that most tasks never need to call up at
-  all — that's the point of the split.
-- **Implementer** — often literally the same model as the coordinator; the distinction is
-  parallelism and workspace isolation, not capability. Falls back to a smaller model for batches
-  of mechanical, unambiguous edits.
-- **Trivial** — small, very fast models for mechanical, unambiguous edits: renames, config
-  tweaks, typo fixes, doc touch-ups. Batch several to amortize the dispatch overhead. When in
-  doubt between trivial and implementer, pick implementer — a wrong cheap edit costs more than
-  the price difference.
+- **Tier:** Escalation
+  - **Role:** Judgment calls the coordinator flags
+  - **Anthropic:** Fable 5, Opus 4.8
+  - **OpenAI:** Sol, GPT-5 (high)
+  - **Google:** Gemini 2.5 Pro
+
+- **Tier:** Coordinator
+  - **Role:** Resident; owns every phase by default
+  - **Anthropic:** Sonnet 5
+  - **OpenAI:** GPT-5, GPT-4.1
+  - **Google:** Gemini 2.5 Flash
+
+- **Tier:** Implementer
+  - **Role:** Pinned-spec work, often same tier as coordinator
+  - **Anthropic:** Sonnet 5
+  - **OpenAI:** GPT-5, GPT-4.1
+  - **Google:** Gemini 2.5 Flash
+
+- **Tier:** Trivial
+  - **Role:** Mechanical edits
+  - **Anthropic:** Haiku 4.5
+  - **OpenAI:** GPT-4.1 mini
+  - **Google:** Gemini Flash-Lite
+
+- **Escalation** — the strongest reasoning model available, called only when a trigger in [escalate.md](escalate.md)
+  fires: unclear root cause, architectural risk, security sensitivity, an irreversible operation, repeated spec gaps, or
+  low confidence in a review. Answers one specific question, then hands control back to the coordinator.
+- **Coordinator** — a capable mid-tier model, resident for the whole task. Owns analysis, planning, supervision, and
+  verification by default. It's capable enough for the large majority of work, and cheap enough relative to Escalation
+  tier that most tasks never need to call up at all — that's the point of the split.
+- **Implementer** — often literally the same model as the coordinator; the distinction is parallelism and workspace
+  isolation, not capability. Falls back to a smaller model for batches of mechanical, unambiguous edits.
+- **Trivial** — small, very fast models for mechanical, unambiguous edits: renames, config tweaks, typo fixes, doc
+  touch-ups. Batch several to amortize the dispatch overhead. When in doubt between trivial and implementer, pick
+  implementer — a wrong cheap edit costs more than the price difference.
 
 ## Tooling mappings
 
 How to run the coordinator/escalation/implementer split in common agent tooling:
 
-- **Claude Code** — run the session itself on a coordinator-tier model (e.g. Sonnet 5). Call
-  `Agent` with `model: opus` (or `fable`) only at an escalation checkpoint, scoped to the one
-  question that triggered it. Use worktree isolation for parallel implementer-tier tasks, and
-  `model: haiku` for batched trivial edits.
-- **GitHub Copilot** — run Copilot Chat on a coordinator-tier model for the whole flow; switch the
-  model picker to the strongest reasoning model only for the specific question an escalation
-  trigger flagged, then switch back. Standalone, well-specified tasks can still be assigned to the
-  Copilot coding agent (assign the issue or PR to Copilot), which works on its own branch — the
-  pinned spec becomes the issue body.
-- **Codex** — orchestrate locally (CLI or chat) on a coordinator-tier model; dispatch each pinned
-  spec as a Codex cloud task, one task per independent unit, and review the resulting diffs
-  yourself, escalating to the frontier model only when a trigger fires.
-- **Cursor and similar IDE agents** — one composer/agent session per task on a coordinator-tier
-  model; background agents for the parallel implementer-tier ones; switch to the strongest model
-  in-session only for an escalation checkpoint, then switch back.
-
-**No subagent support at all?** Keep the phases, drop the parallelism: run the whole flow on a
-coordinator-tier model, and switch the session model up to the strongest one only for the specific
-question an escalation trigger flagged, then switch back down. The discipline transfers even when
-the delegation mechanism does not.
+- **Claude Code** — run the session itself on a coordinator-tier model (e.g. Sonnet 5). Call `Agent` with `model: opus`
+  (or `fable`) only at an escalation checkpoint, scoped to the one question that triggered it. Use worktree isolation
+  for parallel implementer-tier tasks, and `model: haiku` for batched trivial edits.
+- **GitHub Copilot** — run Copilot Chat on a coordinator-tier model for the whole flow; switch the model picker to the
+  strongest reasoning model only for the specific question an escalation trigger flagged, then switch back. Standalone,
+  well-specified tasks can still be assigned to the Copilot coding agent (assign the issue or PR to Copilot), which
+  works on its own branch — the pinned spec becomes the issue body.
+- **Codex** — orchestrate locally (CLI or chat) on a coordinator-tier model; dispatch each pinned spec as a Codex cloud
+  task, one task per independent unit, and review the resulting diffs yourself, escalating to the frontier model only
+  when a trigger fires.
+- **Cursor and similar IDE agents** — one composer/agent session per task on a coordinator-tier model; background agents
+  for the parallel implementer-tier ones; switch to the strongest model in-session only for an escalation checkpoint,
+  then switch back.
+
+**No subagent support at all?** Keep the phases, drop the parallelism: run the whole flow on a coordinator-tier model,
+and switch the session model up to the strongest one only for the specific question an escalation trigger flagged, then
+switch back down. The discipline transfers even when the delegation mechanism does not.