@hegemonart/get-design-done 1.41.5 → 1.43.0

package/skills/roi/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: gdd-roi
-description: "Shows whether GDD spend actually shipped anything. Joins per-cycle cost (.design/telemetry/costs.jsonl) with what each cycle shipped — commits that SURVIVED in main vs commits that were reverted — and reports cost-per-shipped-commit + a stick rate per cycle. 'Shipped' = a commit surviving >= the window (default 14 days), which catches revert-after-bug-discovery. Markdown table, not a GUI. Read-only — it reads git log + cost telemetry and reports. Use to see which cycles were worth their spend."
+description: "Shows whether GDD spend actually shipped anything. Joins per-cycle cost (.design/telemetry/costs.jsonl) with what each cycle shipped - commits that SURVIVED in main vs commits that were reverted - and reports cost-per-shipped-commit + a stick rate per cycle. 'Shipped' = a commit surviving >= the window (default 14 days), which catches revert-after-bug-discovery. Markdown table, not a GUI. Read-only - it reads git log + cost telemetry and reports. Use to see which cycles were worth their spend."
 argument-hint: "[--since <date>] [--window-days 14]"
 user-invocable: true
 tools: Read, Bash, Grep, Glob
@@ -10,7 +10,7 @@ tools: Read, Bash, Grep, Glob
 
 Closes the loop on cost: `/gdd:budget` forecasts *spend*, this shows the *return*. It joins per-cycle
 cost with the commits that actually stuck, so you can see cost-per-shipped-commit and which cycles
-were worth it. **Read-only** — it reads `git log` + cost telemetry and prints a table. Contract +
+were worth it. **Read-only** - it reads `git log` + cost telemetry and prints a table. Contract +
 the "shipped" definition: `../../reference/cost-governance.md`.
 
 ## Invocation
@@ -29,8 +29,8 @@ the "shipped" definition: `../../reference/cost-governance.md`.
 3. **Per-cycle shipped / reverted.** For each cycle, use `git log` to count, in that cycle's date
    range: commits still present in `main` and older than the window = **shipped**; commits that a
    later `revert` removed (or that were reverted within the window) = **reverted**. (A commit younger
-   than the window is "too new to score" — exclude it, don't count it as shipped.)
-4. **Join + compute** via the pure helper — never hand-compute:
+   than the window is "too new to score" - exclude it, don't count it as shipped.)
+4. **Join + compute** via the pure helper - never hand-compute:
 
    ```bash
    node -e '
@@ -43,7 +43,7 @@ the "shipped" definition: `../../reference/cost-governance.md`.
 5. **Render** the markdown table (cycle · cost · shipped · reverted · $/shipped · stick rate) plus the
    TOTAL row. A high `$/shipped` with a low stick rate is the signal that a cycle burned budget
    without lasting output.
-6. **Do not act.** Reporting only — never revert, re-run, or change budget.
+6. **Do not act.** Reporting only - never revert, re-run, or change budget.
 
 ## Output
 

package/skills/rollout-status/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: gdd-rollout-status
-description: "Shows where a finished design cycle actually is in production rollout — unrolled / staging-only / canary-N% / prod-100% — by reading the feature-flag service (LaunchDarkly/Statsig/GrowthBook) via the rollout-coordinator. Surfaces STUCK rollouts (a canary that hasn't advanced for N days) and the design_arms outcome weighting. Read-only — GDD never advances or rolls back; it reports and notifies. Use after /gdd:ship to track the post-merge journey."
+description: "Shows where a finished design cycle actually is in production rollout - unrolled / staging-only / canary-N% / prod-100% - by reading the feature-flag service (LaunchDarkly/Statsig/GrowthBook) via the rollout-coordinator. Surfaces STUCK rollouts (a canary that hasn't advanced for N days) and the design_arms outcome weighting. Read-only - GDD never advances or rolls back; it reports and notifies. Use after /gdd:ship to track the post-merge journey."
 argument-hint: "[<cycle>] [--all] [--stuck]"
 user-invocable: true
 tools: Read, Bash, Grep, Glob, ToolSearch, Task
@@ -8,7 +8,7 @@ tools: Read, Bash, Grep, Glob, ToolSearch, Task
 
 # /gdd:rollout-status
 
-Closes the visibility gap after `/gdd:ship`: a PR merges, but staging → canary → 100% rollout happens outside GDD. This skill reports where each cycle's design actually is in production, by delegating to `agents/rollout-coordinator.md` (which reads the feature-flag service via the Phase 38 connections). **Read-only** — it reports + notifies; it never advances or rolls back a rollout. Contract + the `<rollout_status>` schema: `../../reference/rollout-coordination.md`.
+Closes the visibility gap after `/gdd:ship`: a PR merges, but staging → canary → 100% rollout happens outside GDD. This skill reports where each cycle's design actually is in production, by delegating to `agents/rollout-coordinator.md` (which reads the feature-flag service via the Phase 38 connections). **Read-only** - it reports + notifies; it never advances or rolls back a rollout. Contract + the `<rollout_status>` schema: `../../reference/rollout-coordination.md`.
 
 ## Invocation
 
@@ -16,7 +16,7 @@ Closes the visibility gap after `/gdd:ship`: a PR merges, but staging → canary
 |---|---|
 | `/gdd:rollout-status` | The current cycle's rollout state (from `.design/STATE.md <rollout_status>`, refreshed via the coordinator). |
 | `/gdd:rollout-status <cycle>` | A specific cycle's rollout state. |
-| `/gdd:rollout-status --all` | Every cycle with a `<rollout_status>` block — a rollout dashboard. |
+| `/gdd:rollout-status --all` | Every cycle with a `<rollout_status>` block - a rollout dashboard. |
 | `/gdd:rollout-status --stuck` | Only the **stuck** rollouts (partial rollouts that haven't advanced for ≥ the threshold). |
 
 ## Steps
@@ -24,7 +24,7 @@ Closes the visibility gap after `/gdd:ship`: a PR merges, but staging → canary
 1. **Probe the flag service.** Check a flag connection is `available` (`connections/launchdarkly.md` / `statsig.md` / `growthbook.md`). None → print `rollout-status: no flag service configured — connect one via /gdd:connections.` and exit.
 2. **Delegate to `rollout-coordinator`** (via `Task`): it reads the service, classifies via `scripts/lib/rollout/rollout-status.cjs`, refreshes the `<rollout_status>` block, and reports state + deployed % + stuck.
 3. **Render.** Show each cycle: `state` · `deployed_pct` · `last_changed` · `stuck?`. For `--stuck`, list only stuck cycles with the days-since-change and an advance-or-rollback suggestion.
-4. **Do not act.** Never run a flag-service mutation, advance a canary, or roll back — GDD reports; the human + the flag service decide.
+4. **Do not act.** Never run a flag-service mutation, advance a canary, or roll back - GDD reports; the human + the flag service decide.
 
 ## Output
 

package/skills/router/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: gdd-router
-description: "Routes a /gdd command to fast|quick|full path + S|M|L|XL complexity_class and returns {path, complexity_class, model_tier_overrides, resolved_models, estimated_cost_usd, cache_hits}. Deterministic — no model call. Invoked once at command entry before any Agent spawn. Read by hooks/budget-enforcer.js."
+description: "Routes a /gdd command to fast|quick|full path + S|M|L|XL complexity_class and returns {path, complexity_class, model_tier_overrides, resolved_models, estimated_cost_usd, cache_hits}. Deterministic - no model call. Invoked once at command entry before any Agent spawn. Read by hooks/budget-enforcer.js."
 argument-hint: "<intent-string> [<target-artifacts-csv>]"
 tools: Read, Bash, Grep
 ---
@@ -14,7 +14,7 @@ You are a deterministic routing skill. You do not spawn agents. You read `.desig
 ## Invocation Contract
 
 - **Input**: `intent-string` (e.g., `"run discover stage on greenfield project"`) + optional comma-separated list of target artifacts (files this command will touch).
-- **Output**: a single JSON object to stdout — nothing else on the line, no prose wrapper:
+- **Output**: a single JSON object to stdout - nothing else on the line, no prose wrapper:
   ```json
   {
     "path": "fast",
@@ -30,9 +30,9 @@ You are a deterministic routing skill. You do not spawn agents. You read `.desig
   }
   ```
 - `path` enum: `fast` (single Haiku + no checkers), `quick` (Sonnet mappers + Haiku verify), `full` (Opus planners + full quality gates). Stays unchanged for back-compat per D-05.
-- `complexity_class` enum: `S | M | L | XL` (Phase 25 / D-04, D-05). Additive to `path` — existing consumers reading only `path` keep working. Mapping is documented in the Path Selection Heuristic table below.
-- `model_tier_overrides` merges agent frontmatter `default-tier` with `.design/budget.json.tier_overrides` — budget.json wins per D-04. Enum stays `opus|sonnet|haiku` for back-compat across all 14 runtimes; consumers that need the **concrete** model name for the active runtime read `resolved_models` instead.
-- `resolved_models` is a per-agent map of concrete model IDs for the runtime in use (Phase 26 / D-07). Keys are agent names; values are runtime-specific model strings (e.g. `"gpt-5"` under codex, `"gemini-2.5-pro"` under gemini, `"claude-opus-4-7"` under claude) or `null` when the resolver can supply no model (missing tier-map row, missing tier on the row). Additive to `model_tier_overrides` — existing consumers reading the tier-name map keep working unchanged; new consumers (budget-enforcer cost computation, cost telemetry, bandit posterior store) read `resolved_models` for runtime-correct cost. See **Runtime-aware model resolution** below for the computation contract.
+- `complexity_class` enum: `S | M | L | XL` (Phase 25 / D-04, D-05). Additive to `path` - existing consumers reading only `path` keep working. Mapping is documented in the Path Selection Heuristic table below.
+- `model_tier_overrides` merges agent frontmatter `default-tier` with `.design/budget.json.tier_overrides` - budget.json wins per D-04. Enum stays `opus|sonnet|haiku` for back-compat across all 14 runtimes; consumers that need the **concrete** model name for the active runtime read `resolved_models` instead.
+- `resolved_models` is a per-agent map of concrete model IDs for the runtime in use (Phase 26 / D-07). Keys are agent names; values are runtime-specific model strings (e.g. `"gpt-5"` under codex, `"gemini-2.5-pro"` under gemini, `"claude-opus-4-7"` under claude) or `null` when the resolver can supply no model (missing tier-map row, missing tier on the row). Additive to `model_tier_overrides` - existing consumers reading the tier-name map keep working unchanged; new consumers (budget-enforcer cost computation, cost telemetry, bandit posterior store) read `resolved_models` for runtime-correct cost. See **Runtime-aware model resolution** below for the computation contract.
 - `estimated_cost_usd` is the sum of per-spawn estimates using the D-06 formula and `reference/model-prices.md`.
 - `cache_hits` is a list of `{agent}:{input-hash}` strings that exist in `.design/cache-manifest.json` and are within TTL; emitting a hit lets the hook short-circuit that spawn per D-05.
 
@@ -49,11 +49,11 @@ The router output contract is additive across phases. The current shape (Phase 2
 | `complexity_class` | v1.25.0 (25-02) | stable, additive |
 | `resolved_models` | v1.26.0 (26-04) | stable, additive |
 
-Existing consumers reading any subset of the older fields keep working unchanged across these bumps — the schema is a strict superset at every phase boundary. New fields are documented inline in this skill rather than in a separate JSON-schema file (the SKILL is the contract — same convention Phase 25 followed for `complexity_class`).
+Existing consumers reading any subset of the older fields keep working unchanged across these bumps - the schema is a strict superset at every phase boundary. New fields are documented inline in this skill rather than in a separate JSON-schema file (the SKILL is the contract - same convention Phase 25 followed for `complexity_class`).
 
 ## Path Selection Heuristic
 
-The router emits `path` (3-tier: `fast|quick|full`, legacy enum, stable for back-compat) AND `complexity_class` (4-tier: `S|M|L|XL`, Phase 25 / D-04 additive). Full mapping table, bucket-assignment signal list, `--dry-run` downgrade rule, and the S-class short-circuit semantics live in `./router-rules.md#path-selection-heuristic`. The S-class short-circuit is load-bearing: when `complexity_class` would be `S`, the router does not run; the deterministic skip list lives in the `/gdd:*` SKILL.md entry, and the budget-enforcer hook treats "no payload + matching command name" as the S signal.
+The router emits `path` (3-tier: `fast|quick|full`, legacy enum, stable for back-compat) AND `complexity_class` (4-tier: `S|M|L|XL`, Phase 25 / D-04 additive). Full mapping table, bucket-assignment signal list, `--dry-run` downgrade rule, and the S-class short-circuit semantics live in `./router-rules.md#path-selection-heuristic`. The S-class short-circuit is essential: when `complexity_class` would be `S`, the router does not run; the deterministic skip list lives in the `/gdd:*` SKILL.md entry, and the budget-enforcer hook treats "no payload + matching command name" as the S signal.
 
 ## Cost Estimation Algorithm
 
@@ -73,17 +73,17 @@ Every `/gdd:*` SKILL.md's first substantive step is: spawn the router via `Task`
 
 ## Failure Modes
 
-If `.design/budget.json` is missing, assume defaults from `reference/config-schema.md` per D-12. If `reference/model-prices.md` is missing, emit `estimated_cost_usd: null` and log a warning — do not block.
+If `.design/budget.json` is missing, assume defaults from `reference/config-schema.md` per D-12. If `reference/model-prices.md` is missing, emit `estimated_cost_usd: null` and log a warning - do not block.
 
 ## Emitting capability_gap on unmatched intent
 
-When the router cannot resolve `intent-string` to a known agent (no `description` match, no `default-tier` rule, no path-selection fallback), emit ONE `capability_gap` event with `source: "router"` before returning the conservative-fallback JSON. Feeds Phase 29 Stage-0 telemetry — see `./capability-gap-emitter.md` for the synchronous Node snippet, semantic notes (suggested_kind = `"agent"`, MCP-probe exclusion per D-08, back-compat invariant on router output), and the opaque-extras payload routing through `appendChainEvent`.
+When the router cannot resolve `intent-string` to a known agent (no `description` match, no `default-tier` rule, no path-selection fallback), emit ONE `capability_gap` event with `source: "router"` before returning the conservative-fallback JSON. Feeds Phase 29 Stage-0 telemetry - see `./capability-gap-emitter.md` for the synchronous Node snippet, semantic notes (suggested_kind = `"agent"`, MCP-probe exclusion per D-08, back-compat invariant on router output), and the opaque-extras payload routing through `appendChainEvent`.
 
 ## Emitting router_pick on a resolved pick
 
-When the router DID resolve a pick — it has the `path`/`complexity_class`/`resolved_models` decision and is about to return the decision JSON — emit ONE `router_pick` event (`source: "router"`) recording which skill/agent was auto-picked, as the last step before returning. Side-effect only; the output JSON contract is UNCHANGED. Feeds the D-02 under-reached-skill instrument (Phase 33 baselines per-skill pick rates) — see `./router-pick-emitter.md` for the synchronous Node snippet, the 7-field no-PII payload (context_hash only — never the raw prompt), and the opaque-extras routing through `appendChainEvent`.
+When the router DID resolve a pick - it has the `path`/`complexity_class`/`resolved_models` decision and is about to return the decision JSON - emit ONE `router_pick` event (`source: "router"`) recording which skill/agent was auto-picked, as the last step before returning. Side-effect only; the output JSON contract is UNCHANGED. Feeds the D-02 under-reached-skill instrument (Phase 33 baselines per-skill pick rates) - see `./router-pick-emitter.md` for the synchronous Node snippet, the 7-field no-PII payload (context_hash only - never the raw prompt), and the opaque-extras routing through `appendChainEvent`.
 
 ## Non-Goals
 
 The router does not: (a) make a model call, (b) write files, (c) enforce budget caps (that's the hook's job), (d) learn from history (Phase 11 reflector territory per D-07).
-The router does not author capability-gap CLUSTERS — Stage-0 emit is single-event-per-failure. Aggregation across events is Plan 29-03's reflector pass.
+The router does not author capability-gap CLUSTERS - Stage-0 emit is single-event-per-failure. Aggregation across events is Plan 29-03's reflector pass.

package/skills/router/capability-gap-emitter.md

@@ -1,6 +1,6 @@
-# gdd-router — capability_gap emitter (Phase 29 / D-02 / D-08)
+# gdd-router - capability_gap emitter (Phase 29 / D-02 / D-08)
 
-Co-located reference for `skills/router/SKILL.md` — split out per Phase 28.5
+Co-located reference for `skills/router/SKILL.md` - split out per Phase 28.5
 contract (router SKILL ≤100 lines) and the Phase 28.6 co-location pattern.
 
 ## When to emit
@@ -10,7 +10,7 @@ If the router cannot resolve `intent-string` to a known agent (no agent's
 path-selection table returns nothing meaningful), emit ONE `capability_gap`
 event before returning the conservative-fallback JSON output to the caller.
 
-This feeds Phase 29 Stage-0 telemetry — the reflector pattern-detection pass
+This feeds Phase 29 Stage-0 telemetry - the reflector pattern-detection pass
 (Plan 29-02) and aggregation (Plan 29-03) read these events from the chain
 file (`.design/gep/events.jsonl`) to surface recurring router-unmatched
 intents as candidate agents in `/gdd:apply-reflections`.
@@ -50,16 +50,16 @@ appendChainEvent({
   describe multi-step workflows (the unit the router resolves).
 - Router-unmatched is NOT the same as MCP-probe failure (per D-08). If
   gdd-router returns a fallback because a peer-CLI connection is down, do
-  NOT emit capability_gap — that's a Phase 22 connection-status concern.
+  NOT emit capability_gap - that's a Phase 22 connection-status concern.
 - The emitter is the LAST step before returning the fallback JSON. Router
   output is unchanged (back-compat per the existing `## Output schema
   versioning` table in `SKILL.md`); the event is a SIDE EFFECT, not a
   payload addition.
-- Router output JSON contract is UNCHANGED — back-compat preserved.
+- Router output JSON contract is UNCHANGED - back-compat preserved.
 - The 7-field payload flows through `appendChainEvent`'s opaque-extras
   pattern verbatim; the chain row carries `type`, `timestamp`, `sessionId`,
   `payload` as opaque extras and is projected back to the events-schema
   envelope by Plan 29-03 aggregation.
 
 MCP-probe failures (connection down, transport-layer errors) do NOT emit
-`capability_gap` — those are Phase 22 connection-status concerns (D-08).
+`capability_gap` - those are Phase 22 connection-status concerns (D-08).

package/skills/router/router-pick-emitter.md

@@ -1,14 +1,14 @@
-# gdd-router — router_pick emitter (Phase 32-08 / D-02)
+# gdd-router - router_pick emitter (Phase 32-08 / D-02)
 
-Co-located reference for `skills/router/SKILL.md` — split out per the Phase 28.5
+Co-located reference for `skills/router/SKILL.md` - split out per the Phase 28.5
 contract (router SKILL ≤100 lines) and the Phase 28.6 co-location pattern (same
 convention as the sibling `./capability-gap-emitter.md`).
 
 ## When to emit
 
-When the router resolves an intent to a concrete pick — i.e. it has selected the
+When the router resolves an intent to a concrete pick - i.e. it has selected the
 `path` / `complexity_class` / `resolved_models` decision and is about to return
-its decision JSON — emit ONE `router_pick` event recording WHICH skill/agent it
+its decision JSON - emit ONE `router_pick` event recording WHICH skill/agent it
 auto-picked. Emit exactly once per resolved pick, as the LAST step before
 returning the decision JSON to the caller.
 
@@ -25,7 +25,7 @@ when it could not resolve the intent at all. They are disjoint surfaces.
 ## Synchronous emitter snippet
 
 Builds the 7-field `RouterPickPayload` and writes it via `appendChainEvent`.
-The intent is hashed — the raw prompt is NEVER stored (no PII). `picked_skill`,
+The intent is hashed - the raw prompt is NEVER stored (no PII). `picked_skill`,
 `rank`, and `alternatives` come from the router's resolved decision:
 
 ```bash
@@ -55,17 +55,17 @@ appendChainEvent({
 
 `GDD_PICKED_SKILL` is the resolved pick; `GDD_PICK_RANK` is its rank among
 candidates (0 = top pick); `GDD_ALTERNATIVES` is a comma-separated list of the
-OTHER candidate skill/agent names the router considered (names only — no scores,
+OTHER candidate skill/agent names the router considered (names only - no scores,
 no prompt text). `GDD_INTENT` is hashed in-process and is never written to disk.
 
 ## Notes
 
-- **No PII**: only `context_hash` (sha256 of the intent) is stored — never the
+- **No PII**: only `context_hash` (sha256 of the intent) is stored - never the
   raw prompt or intent string. The `RouterPickPayload` is
   `additionalProperties: false`, so a stray `raw_prompt` field would be rejected
   by `events.schema.json` validation. This mirrors `capability_gap`'s hash
   discipline.
-- **Router output JSON contract is UNCHANGED** — `router_pick` is a SIDE EFFECT,
+- **Router output JSON contract is UNCHANGED** - `router_pick` is a SIDE EFFECT,
   not a new output field. Back-compat is preserved exactly as the existing
   `## Output schema versioning` table in `SKILL.md` guarantees; the emitter runs
   AFTER the decision is computed and does not alter the returned blob.
@@ -74,5 +74,5 @@ no prompt text). `GDD_INTENT` is hashed in-process and is never written to disk.
   opaque extras and is projected back to the events-schema envelope by Phase 33
   aggregation (same projection the capability_gap aggregation uses).
 - Validated against the additive `RouterPickPayload` branch (allOf[2]) in
-  `reference/schemas/events.schema.json` — see
+  `reference/schemas/events.schema.json` - see
   `test/suite/router-pick-event.test.cjs`.

package/skills/router/router-rules.md

@@ -30,7 +30,7 @@ Bucket assignment:
 
 | Signal | complexity_class | path |
 |--------|------------------|------|
-| Command is `/gdd:help`, `/gdd:stats`, `/gdd:note`, `/gdd:health`, single-Haiku skill | `S` | `fast` (short-circuited — see below) |
+| Command is `/gdd:help`, `/gdd:stats`, `/gdd:note`, `/gdd:health`, single-Haiku skill | `S` | `fast` (short-circuited - see below) |
 | Command is `/gdd:scan`, `/gdd:brief`, `/gdd:sketch`, `/gdd:spike`, `/gdd:fast` | `M` | `fast` |
 | Command spawns exactly one agent (no orchestration), not in S list | `M` | `fast` |
 | Command is `/gdd:explore`, `/gdd:discover`, standalone `/gdd:verify`, standalone `/gdd:plan` | `L` | `quick` |
@@ -41,7 +41,7 @@ Bucket assignment:
 
 ### S-class short-circuit
 
-When `complexity_class` would be `S`, the router itself **does not run** for that invocation — the deterministic skip list is encoded in the `/gdd:*` SKILL.md entry of the matching command. The budget-enforcer hook treats "no router decision payload + matching command name" as the S-class signal and skips enforcement entirely (no telemetry row, no cache lookup, no event emission). When the router *is* invoked explicitly (e.g., debugging) it still emits `complexity_class: "S"` in the JSON for observability, but the runtime path is the no-op.
+When `complexity_class` would be `S`, the router itself **does not run** for that invocation - the deterministic skip list is encoded in the `/gdd:*` SKILL.md entry of the matching command. The budget-enforcer hook treats "no router decision payload + matching command name" as the S-class signal and skips enforcement entirely (no telemetry row, no cache lookup, no event emission). When the router *is* invoked explicitly (e.g., debugging) it still emits `complexity_class: "S"` in the JSON for observability, but the runtime path is the no-op.
 
 ## Cost Estimation Algorithm
 
@@ -57,7 +57,7 @@ return total
 
 ## Runtime-aware model resolution
 
-The router emits `resolved_models` alongside `model_tier_overrides` so downstream consumers (budget-enforcer cost computation, Phase 22 cost telemetry, Phase 23.5 bandit posterior store) can read the **concrete model ID** for the active runtime without re-deriving it from the tier name. The resolution is per-agent and additive — `model_tier_overrides` keeps its `opus|sonnet|haiku` enum for back-compat across all 14 runtimes, and `resolved_models` runs the runtime-specific translation on top of it.
+The router emits `resolved_models` alongside `model_tier_overrides` so downstream consumers (budget-enforcer cost computation, Phase 22 cost telemetry, Phase 23.5 bandit posterior store) can read the **concrete model ID** for the active runtime without re-deriving it from the tier name. The resolution is per-agent and additive - `model_tier_overrides` keeps its `opus|sonnet|haiku` enum for back-compat across all 14 runtimes, and `resolved_models` runs the runtime-specific translation on top of it.
 
 Computation contract (per D-07):
 
@@ -71,14 +71,14 @@ for each agent in planned spawn graph:
 
 Implementation surfaces (Phase 26 / Wave A):
 
-- `scripts/lib/runtime-detect.cjs` — `detect() → runtime-id | null`. Reads the same `*_CONFIG_DIR` / `*_HOME` env-vars Phase 24's installer uses (single source of truth in `scripts/lib/install/runtimes.cjs`). Returns `null` when no recognized runtime env-var is set; the router falls back to `'claude'` so the resolver always has a runtime ID to work with.
-- `scripts/lib/tier-resolver.cjs` — `resolve(runtime, tier, opts?) → model | null`. Translates `opus|sonnet|haiku` to the concrete model the runtime understands using the `./runtime-models.md` mapping (Phase 26 / Wave A). Fallback chain (D-04): runtime-specific entry → `claude` row default with `tier_resolution_fallback` event → `null` with `tier_resolution_failed` event. Never throws; `null` is a valid output the consumer must handle.
+- `scripts/lib/runtime-detect.cjs` - `detect() → runtime-id | null`. Reads the same `*_CONFIG_DIR` / `*_HOME` env-vars Phase 24's installer uses (single source of truth in `scripts/lib/install/runtimes.cjs`). Returns `null` when no recognized runtime env-var is set; the router falls back to `'claude'` so the resolver always has a runtime ID to work with.
+- `scripts/lib/tier-resolver.cjs` - `resolve(runtime, tier, opts?) → model | null`. Translates `opus|sonnet|haiku` to the concrete model the runtime understands using the `./runtime-models.md` mapping (Phase 26 / Wave A). Fallback chain (D-04): runtime-specific entry → `claude` row default with `tier_resolution_fallback` event → `null` with `tier_resolution_failed` event. Never throws; `null` is a valid output the consumer must handle.
 
 Per-agent emission rules:
 
 - One key per agent in the planned spawn graph (same key set the cost-estimation loop iterates over). Keys MUST match agent names exactly so consumers can join `resolved_models` against `model_tier_overrides` and the spawn graph by name.
 - Value is the concrete model string returned by `tier-resolver.resolve(runtime, tier)`.
-- When the resolver returns `null` (missing tier-map row, missing tier, garbage input), the value is JSON `null` — NOT omitted, NOT the empty string. Consumers (budget-enforcer, telemetry) MUST handle `null`: typically by skipping the cost row for that spawn and emitting their own diagnostic event, never by crashing.
-- When `complexity_class` is `S` and the router itself short-circuits (see **S-class short-circuit** above), no payload is emitted at all and `resolved_models` does not exist for that invocation — the budget-enforcer's "no router decision payload" branch already handles this case.
+- When the resolver returns `null` (missing tier-map row, missing tier, garbage input), the value is JSON `null` - NOT omitted, NOT the empty string. Consumers (budget-enforcer, telemetry) MUST handle `null`: typically by skipping the cost row for that spawn and emitting their own diagnostic event, never by crashing.
+- When `complexity_class` is `S` and the router itself short-circuits (see **S-class short-circuit** above), no payload is emitted at all and `resolved_models` does not exist for that invocation - the budget-enforcer's "no router decision payload" branch already handles this case.
 
 Back-compat assertion: a router invocation in a Claude runtime (or any environment where `runtime-detect.detect()` returns `null` and the router falls back to `'claude'`) produces `resolved_models` values that are the canonical Anthropic model IDs (`claude-opus-4-7`, `claude-sonnet-4-6`, `claude-haiku-4-5`) for the corresponding tiers. Pre-Phase-26 consumers that ignore `resolved_models` see the same `model_tier_overrides` they always saw (Plan 26-09 owns the runtime fixture diff that asserts this).

package/skills/scan/SKILL.md

@@ -5,15 +5,15 @@ argument-hint: "[--quick] [--full]"
 user-invocable: true
 ---
 
-# Get Design Done — Scan
+# Get Design Done - Scan
 
 **Pre-pipeline initializer.** Run once in any new or existing repo before starting the Discover -> Plan -> Design -> Verify pipeline.
 
 Full procedure detail: `./scan-procedure.md`.
 
 Produces:
-- `DESIGN.md` — snapshot of the existing design system as it actually is
-- `.design/DESIGN-DEBT.md` — prioritized debt roadmap
+- `DESIGN.md` - snapshot of the existing design system as it actually is
+- `.design/DESIGN-DEBT.md` - prioritized debt roadmap
 
 `--quick`: Skip component inventory, focus on tokens + anti-patterns only (~2 min)
 `--full`: Include component-by-component analysis (slower, more thorough)
@@ -36,41 +36,41 @@ At scan entry, before running any step:
 
 ## Workflow
 
-The scan executes eight steps in order. Each step's full grep commands, analysis prompts, and decision rules live in `./scan-procedure.md` — keep that file open while executing.
+The scan executes eight steps in order. Each step's full grep commands, analysis prompts, and decision rules live in `./scan-procedure.md` - keep that file open while executing.
 
-### Step 1 — Orient
+### Step 1 - Orient
 
 Detect framework, CSS approach, component count, style file count, token system. Detect source root by ordered fallback (`src/` -> `app/` -> `pages/` -> `lib/`) and substitute into subsequent grep commands. Log the detected source root in DESIGN.md frontmatter. Detail: `./scan-procedure.md` §Step 1.
 
-### Step 2 — Extract Color System
+### Step 2 - Extract Color System
 
 Grep hex / `oklch()` / `hsl()` / `rgb()` colors, CSS custom properties, and Tailwind color config. Analyze palette size, token discipline, AI-slop colors (#6366f1, #8b5cf6, #06b6d4), semantic naming, dark-mode purity. Produce a color inventory table. Detail: `./scan-procedure.md` §Step 2.
 
-### Step 2A — Figma Token Augmentation
+### Step 2A - Figma Token Augmentation
 
 If `figma: available` in STATE.md `<connections>`: call `{prefix}get_variable_defs`, translate variables by type/name pattern, merge with grep-derived tokens (never replace). Skip silently if `figma` is `not_configured` or `unavailable`. Detail: `./scan-procedure.md` §Step 2A.
 
-### Step 3 — Extract Typography System
+### Step 3 - Extract Typography System
 
 Grep font families, sizes, weights, line-heights. Analyze family count, scale compliance, weight hierarchy, line-height on body, reflex-font signals. Read `${CLAUDE_PLUGIN_ROOT}/reference/typography.md` for comparison criteria. Detail: `./scan-procedure.md` §Step 3.
 
-### Step 4 — Extract Spacing System
+### Step 4 - Extract Spacing System
 
 Grep CSS spacing values, Tailwind spacing overrides, space tokens. Score grid compliance against the 4/8/12/16/24/32/48/64 series. Detail: `./scan-procedure.md` §Step 4.
 
-### Step 5 — Anti-Pattern Audit
+### Step 5 - Anti-Pattern Audit
 
 Read `${CLAUDE_PLUGIN_ROOT}/reference/anti-patterns.md`. Run all BAN-XX and SLOP-XX grep commands, plus a11y checks (focus rings, reduced-motion, div onClick, small fonts). Detail: `./scan-procedure.md` §Step 5.
 
-### Step 6 — Component Inventory
+### Step 6 - Component Inventory
 
 If `--quick`, skip. Otherwise run the three-pass multi-signal filter (JSX-return + className + framework-import) to produce an authoritative component list, then enumerate primitives. In `--full` mode, emit one row per file. Detail: `./scan-procedure.md` §Step 6.
 
-### Step 7 — Score All 7 Categories
+### Step 7 - Score All 7 Categories
 
 Read `${CLAUDE_PLUGIN_ROOT}/reference/audit-scoring.md`. Score each category 0–10 and apply the weighted formula `(A11Y * 0.25) + (Visual Hierarchy * 0.20) + (Typography * 0.15) + (Color * 0.15) + (Layout * 0.10) + (Anti-Patterns * 0.10) + (Motion * 0.05)`. Grade A=90+, B=75+, C=60+, D=45+, F<45.
 
-### Step 8 — Generate Design Debt Roadmap
+### Step 8 - Generate Design Debt Roadmap
 
 Classify each finding P0/P1/P2/P3, estimate effort XS/S/M/L/XL, group by debt theme, compute `priority_score = (severity_weight * effort_weight) + (dependency_depth * 2)`. Mark P1+XS/S items as quick wins. Detail: `./scan-procedure.md` §Step 8.
 
@@ -80,13 +80,13 @@ Classify each finding P0/P1/P2/P3, estimate effort XS/S/M/L/XL, group by debt th
 
 Write both artifacts using the templates in `./scan-procedure.md`:
 
-- **`DESIGN.md`** (project root) — design-system snapshot with score table, color/typography/spacing/component inventories, anti-pattern status, motion summary. Frontmatter records `score`, `framework`, `css_approach`, `token_layer`, and (if Figma ran) `figma_variables_used` + `figma_source`. Template: `./scan-procedure.md` §Output 1.
-- **`.design/DESIGN-DEBT.md`** — prioritized debt roadmap grouped P0/P1/P2/P3, with priority_score ordering, recommended fix order, and pipeline recommendation. Template: `./scan-procedure.md` §Output 2.
+- **`DESIGN.md`** (project root) - design-system snapshot with score table, color/typography/spacing/component inventories, anti-pattern status, motion summary. Frontmatter records `score`, `framework`, `css_approach`, `token_layer`, and (if Figma ran) `figma_variables_used` + `figma_source`. Template: `./scan-procedure.md` §Output 1.
+- **`.design/DESIGN-DEBT.md`** - prioritized debt roadmap grouped P0/P1/P2/P3, with priority_score ordering, recommended fix order, and pipeline recommendation. Template: `./scan-procedure.md` §Output 2.
 
 ---
 
 ## After Writing
 
-Print the user-facing summary block from `./scan-procedure.md` §After Writing — project name, score, P0/P1 counts, quick-win count, artifact paths, and next-step options (start pipeline, fix quick wins first, or just reference the debt).
+Print the user-facing summary block from `./scan-procedure.md` §After Writing - project name, score, P0/P1 counts, quick-win count, artifact paths, and next-step options (start pipeline, fix quick wins first, or just reference the debt).
 
 ## SCAN COMPLETE