@hegemonart/get-design-done 1.57.1 → 1.57.3

package/dist/claude-code/.claude/skills/review-backlog/SKILL.md

@@ -1,46 +0,0 @@
----
-name: gdd-review-backlog
-description: "Review parked backlog items and promote any to active cycle todo."
-tools: Read, Write, AskUserQuestion
-disable-model-invocation: true
----
-
-# /gdd:review-backlog
-
-**Role:** Walk through parked backlog items and for each ask: promote to this cycle, keep parked, or archive.
-
-## Step 1 - Read backlog
-
-Read `.design/backlog/BACKLOG.md`. Parse each `## <title>` block with its metadata and body. If no parked items, print "No parked backlog items." and stop.
-
-## Step 2 - Loop
-
-For each item with `**Status**: parked`:
-
-Use `AskUserQuestion`:
-```
-Title: <title>
-Added: <date>
-<truncated body>
-
-Promote to this cycle | Keep parked | Archive
-```
-
-## Step 3 - Apply decision
-
-- **Promote**: append `- [ ] [YYYY-MM-DD] <title>` under `## P1 — High` in `.design/TODO.md` (create file from the TODO.md skeleton if missing). Update backlog item status to `**Status**: promoted` + `**Promoted**: YYYY-MM-DD`.
-- **Keep parked**: leave unchanged.
-- **Archive**: update status to `**Status**: archived` + `**Archived**: YYYY-MM-DD`.
-
-Rewrite `.design/backlog/BACKLOG.md` after each decision so crashes preserve progress.
-
-## Output
-
-```
-━━━ Backlog review ━━━
-Reviewed: 5
-Promoted: 2   Kept parked: 2   Archived: 1
-━━━━━━━━━━━━━━━━━━━━━━
-```
-
-## REVIEW-BACKLOG COMPLETE

package/dist/claude-code/.claude/skills/review-decisions/SKILL.md

@@ -1,42 +0,0 @@
----
-name: gdd-review-decisions
-description: "Surfaces the async decision-review queue for team mode. Reads .design/reviews/<decision-id>/ entries and reports each decision's state in the proposed → reviewing → approved → locked machine (via scripts/lib/collab/review-queue.cjs), so a team can see what's awaiting review, what's approved, and what's locked. --pending shows only decisions still needing action. Read-only - it reports the queue; it never advances a decision (that's a reviewer's explicit call). Use to run an async design-decision review without a meeting."
-argument-hint: "[<decision-id>] [--pending]"
-user-invocable: true
-tools: Read, Bash, Grep, Glob
----
-
-# /gdd:review-decisions
-
-Closes the async-review gap for team mode: design decisions move through an explicit review queue
-instead of being decided in a single operator's head. This skill reports where each decision is.
-**Read-only** - it surfaces state; advancing a decision is a reviewer's explicit action. Contract:
-`../../reference/multi-author-model.md`.
-
-## Invocation
-
-| Command | Behavior |
-|---|---|
-| `/gdd:review-decisions` | Every decision in the queue, grouped by state. |
-| `/gdd:review-decisions <decision-id>` | One decision's state + audit trail. |
-| `/gdd:review-decisions --pending` | Only decisions not yet `locked` (awaiting action). |
-
-## Steps
-
-1. **Find the queue.** List `.design/reviews/*/` (each dir is a `<decision-id>`). No reviews dir →
-   print `review-decisions: no review queue yet (team mode not in use).` and exit.
-2. **Read each entry** (`.design/reviews/<id>/state.json` → `{ id, state, audit }`). Validate the
-   state against `scripts/lib/collab/review-queue.cjs` `STATES`.
-3. **Render** grouped by state: `proposed` / `reviewing` / `approved` / `locked`, each listing the
-   decision id + a one-line summary. For `--pending`, use `review-queue.pending(entries)` to show only
-   non-locked ones. For a single `<decision-id>`, also print its audit trail (transitions + approvers).
-4. **Do not advance.** Reporting only - moving a decision forward (or `/gdd:unlock-decision`) is the
-   reviewer's explicit call.
-
-## Output
-
-End with:
-
-```
-## REVIEW-DECISIONS COMPLETE
-```

package/dist/claude-code/.claude/skills/roi/SKILL.md

@@ -1,54 +0,0 @@
----
-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."
-argument-hint: "[--since <date>] [--window-days 14]"
-user-invocable: true
-tools: Read, Bash, Grep, Glob
----
-
-# /gdd:roi
-
-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 +
-the "shipped" definition: `../../reference/cost-governance.md`.
-
-## Invocation
-
-| Command | Behavior |
-|---|---|
-| `/gdd:roi` | ROI table across all cycles with cost telemetry (14-day stick window). |
-| `/gdd:roi --since <date>` | Only cycles since `<date>`. |
-| `/gdd:roi --window-days N` | "Shipped" = a commit surviving ≥ N days (default 14). |
-
-## Steps
-
-1. **Check telemetry exists.** No `.design/telemetry/costs.jsonl` (or zero rows) → print
-   `roi: no cost telemetry yet — run a cycle first.` and exit.
-2. **Per-cycle cost.** Group `est_cost_usd` in `costs.jsonl` by `cycle`.
-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:
-
-   ```bash
-   node -e '
-     const { computeRoi, roiTableMarkdown } = require("./scripts/lib/budget/roi.cjs");
-     const cycles = JSON.parse(process.argv[1]); // [{cycle,costUsd,commitsShipped,commitsReverted},...]
-     console.log(roiTableMarkdown(computeRoi(cycles)));
-   ' "$CYCLES_JSON"
-   ```
-
-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.
-
-## Output
-
-End with:
-
-```
-## ROI COMPLETE
-```

package/dist/claude-code/.claude/skills/rollout-status/SKILL.md

@@ -1,35 +0,0 @@
----
-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."
-argument-hint: "[<cycle>] [--all] [--stuck]"
-user-invocable: true
-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`.
-
-## Invocation
-
-| Command | Behavior |
-|---|---|
-| `/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 --stuck` | Only the **stuck** rollouts (partial rollouts that haven't advanced for ≥ the threshold). |
-
-## Steps
-
-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.
-
-## Output
-
-End with:
-
-```
-## ROLLOUT-STATUS COMPLETE
-```

package/dist/claude-code/.claude/skills/router/SKILL.md

@@ -1,89 +0,0 @@
----
-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."
-argument-hint: "<intent-string> [<target-artifacts-csv>]"
-tools: Read, Bash, Grep
----
-
-# gdd-router
-
-## Role
-
-You are a deterministic routing skill. You do not spawn agents. You read `.design/budget.json`, `reference/model-prices.md`, `.design/cache-manifest.json` (if present), and the agent frontmatter list, then emit a single JSON object describing the planned spawn graph. The budget-enforcer hook (`hooks/budget-enforcer.js`) consumes your output on every `Agent` tool call.
-
-## 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:
-  ```json
-  {
-    "path": "fast",
-    "complexity_class": "M",
-    "model_tier_overrides": {"design-verifier": "haiku"},
-    "resolved_models": {
-      "design-reflector": "gpt-5",
-      "design-context-checker": "gpt-5-nano",
-      "design-verifier": "gpt-5-nano"
-    },
-    "estimated_cost_usd": 0.034,
-    "cache_hits": ["design-context-builder:abc123"]
-  }
-  ```
-- `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.
-- `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.
-
-### Output schema versioning
-
-The router output contract is additive across phases. The current shape (Phase 26, v1.26.0) carries:
-
-| Field | Added in | Status |
-|-------|----------|--------|
-| `path` | v1.10.1 (10.1-01) | stable |
-| `model_tier_overrides` | v1.10.1 (10.1-01) | stable, enum unchanged |
-| `estimated_cost_usd` | v1.10.1 (10.1-01) | stable |
-| `cache_hits` | v1.10.1 (10.1-01) | stable |
-| `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`).
-
-## 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 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
-
-Standard cost-estimation pseudocode (sum over planned spawn graph; per-agent `(in_tok / 1e6) * in_rate + (out_tok / 1e6) * out_rate` using `./reference/model-prices.md`) lives in `./router-rules.md#cost-estimation-algorithm`.
-
-## Runtime-aware model resolution
-
-Computation contract for `resolved_models`, implementation surfaces (`scripts/lib/runtime-detect.cjs` + `scripts/lib/tier-resolver.cjs`), per-agent emission rules (including the JSON-`null` contract), and the Claude-runtime back-compat assertion live in `./router-rules.md#runtime-aware-model-resolution`. Top-line: `model_tier_overrides` keeps its `opus|sonnet|haiku` enum for back-compat; `resolved_models` runs the per-runtime translation additively on top.
-
-## Cache-Hit Detection
-
-Delegate to `skills/cache-manager/SKILL.md` (Plan 10.1-02). The router lists candidate `{agent}:{input-hash}` tuples; the cache-manager confirms freshness against TTL from `budget.json.cache_ttl_seconds`.
-
-## Integration Point
-
-Every `/gdd:*` SKILL.md's first substantive step is: spawn the router via `Task` or inline invocation; receive the JSON blob; pass it to downstream agents as context so the budget-enforcer hook has the router decision available in tool_input metadata when the first Agent spawn fires.
-
-## 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.
-
-## 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`.
-
-## 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`.
-
-## 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.

package/dist/claude-code/.claude/skills/router/capability-gap-emitter.md

@@ -1,65 +0,0 @@
-# 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
-contract (router SKILL ≤100 lines) and the Phase 28.6 co-location pattern.
-
-## When to emit
-
-If the router cannot resolve `intent-string` to a known agent (no agent's
-`description` field matches, no `default-tier` rule applies, and the fallback
-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
-(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`.
-
-## Synchronous emitter snippet
-
-Same shape as fast, with `source: "router"`:
-
-```bash
-node -e '
-const { appendChainEvent } = require("./scripts/lib/event-chain.cjs");
-const { createHash, randomUUID } = require("node:crypto");
-const intent = process.env.GDD_INTENT || "";
-const payload = {
-  event_id: randomUUID(),
-  parent_event_id: null,
-  source: "router",
-  context_hash: createHash("sha256").update(intent).digest("hex"),
-  intent_summary: intent.slice(0, 256),
-  suggested_kind: "agent",
-  evidence_refs: [],
-};
-appendChainEvent({
-  agent: "router",
-  outcome: "capability_gap",
-  payload,
-  type: "capability_gap",
-  timestamp: new Date().toISOString(),
-  sessionId: process.env.GDD_SESSION_ID || "router-cli",
-});
-'
-```
-
-## Notes
-
-- `suggested_kind` is `"agent"` because router unmatched intents typically
-  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.
-- 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.
-- 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).

package/dist/claude-code/.claude/skills/router/router-pick-emitter.md

@@ -1,78 +0,0 @@
-# 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
-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
-`path` / `complexity_class` / `resolved_models` decision and is about to return
-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.
-
-This is the D-02 router_pick instrument: GDD routes by description-match but has
-no record of what the router actually reaches for, so there is no data on
-under-reached skills. Phase 33 reads these events from the chain file
-(`.design/gep/events.jsonl`) to baseline per-skill auto-pick rates (the
-"pick-rate regression" expansion in the ROADMAP).
-
-`router_pick` is NOT `capability_gap`: emit `router_pick` when the router DID
-resolve a pick; emit `capability_gap` (see `./capability-gap-emitter.md`) only
-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`,
-`rank`, and `alternatives` come from the router's resolved decision:
-
-```bash
-node -e '
-const { appendChainEvent } = require("./scripts/lib/event-chain.cjs");
-const { createHash, randomUUID } = require("node:crypto");
-const intent = process.env.GDD_INTENT || "";
-const payload = {
-  event_id: randomUUID(),
-  source: "router",
-  picked_skill: process.env.GDD_PICKED_SKILL || "",
-  context_hash: createHash("sha256").update(intent).digest("hex"),
-  rank: Number(process.env.GDD_PICK_RANK || 0),
-  alternatives: (process.env.GDD_ALTERNATIVES || "").split(",").filter(Boolean),
-  ts: new Date().toISOString(),
-};
-appendChainEvent({
-  agent: "router",
-  outcome: "router_pick",
-  payload,
-  type: "router_pick",
-  timestamp: new Date().toISOString(),
-  sessionId: process.env.GDD_SESSION_ID || "router-cli",
-});
-'
-```
-
-`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,
-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
-  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,
-  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.
-- 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 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
-  `test/suite/router-pick-event.test.cjs`.

package/dist/claude-code/.claude/skills/router/router-rules.md

@@ -1,84 +0,0 @@
----
-name: router-rules
-type: heuristic
-version: 1.0.0
-phase: 28.5
-tags: [router, path-selection, complexity-class, model-tier, runtime-resolution, cost-estimation]
-last_updated: 2026-05-18
----
-
-# Router Path-Selection + Runtime Resolution Rules
-
-Extracted from `skills/router/SKILL.md` per Phase 28.5 D-10 (extract-then-link, never delete
-content). The router SKILL keeps its invocation contract, output schema versioning table,
-integration point, and failure modes. The path-selection heuristic tables, the cost
-estimation algorithm, and the runtime-aware model resolution computation contract live
-here so the SKILL stays under the 100-line cap.
-
-## Path Selection Heuristic
-
-The router emits both `path` (legacy 3-tier enum) and `complexity_class` (Phase 25 4-tier enum). The canonical mapping is:
-
-| complexity_class | path | Behavior |
-|------------------|------|----------|
-| `S` | `fast` (short-circuited) | Skip router itself, skip cache-manager, skip telemetry write. Deterministic no-op decision. |
-| `M` | `fast` | Single Haiku + no checkers. |
-| `L` | `quick` | Sonnet mappers + Haiku verify. |
-| `XL` | `full` | Opus planners + full quality gates. Recommends worktree-isolation default + mandatory inter-stage checkpoint + reflector auto-spawn. |
-
-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: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` |
-| Command spawns parallel mappers but no planners/auditors (`/gdd:discover` in `--auto` mode) | `L` | `quick` |
-| Command is `/gdd:next`, `/gdd:do`, `/gdd:autonomous`, end-to-end Brief→Verify, anything spawning planners + auditors + verifiers in series | `XL` | `full` |
-| Command spawns planners, auditors, verifiers, or integration-checkers (`/gdd:plan`, `/gdd:verify`, `/gdd:audit`) and is not standalone | `XL` | `full` |
-| `--dry-run` flag present on any command | downgrade one tier (XL→L→M→S; `path` follows the mapping table) |
-
-### 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.
-
-## Cost Estimation Algorithm
-
-```
-total = 0
-for each agent in planned spawn graph:
-  tier = resolve_tier(agent)   # budget.json tier_overrides > agent frontmatter default-tier
-  (in_tok, out_tok) = token_range_from_size_budget(agent.size_budget)  # from reference/model-prices.md
-  (in_rate, out_rate) = price_from_tier(tier)
-  total += (in_tok / 1e6) * in_rate + (out_tok / 1e6) * out_rate
-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.
-
-Computation contract (per D-07):
-
-```
-runtime = runtimeDetect.detect() ?? 'claude'
-for each agent in planned spawn graph:
-  tier = resolve_tier(agent)                          # same merge as model_tier_overrides
-  resolved_models[agent] = tierResolver.resolve(runtime, tier)
-                                                       # → concrete model string OR null
-```
-
-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.
-
-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.
-
-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/dist/claude-code/.claude/skills/scan/SKILL.md

@@ -1,92 +0,0 @@
----
-name: scan
-description: "Pre-pipeline initializer that maps an existing repo's design system (colors, typography, spacing, components, tokens), runs the anti-pattern audit, scores the 7 weighted categories, and writes DESIGN.md + .design/DESIGN-DEBT.md. Use when starting work in any new or existing repo before /gdd:discover. Activates for requests involving a fast read-only anti-pattern sweep, a quick design lint, or spotting slop without a full audit."
-argument-hint: "[--quick] [--full]"
-user-invocable: true
----
-
-# 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
-
-`--quick`: Skip component inventory, focus on tokens + anti-patterns only (~2 min)
-`--full`: Include component-by-component analysis (slower, more thorough)
-
-Default: full scan of tokens, patterns, and anti-patterns. Component inventory is a summary count, not per-file.
-
----
-
-## State Integration
-
-At scan entry, before running any step:
-
-1. Read or create `.design/STATE.md` from `reference/STATE-TEMPLATE.md` (set `stage=scan`, `status=in_progress`, `task_progress=0/8`; preserve `started_at` on resume). See `./scan-procedure.md` §State Integration for the full read/create/resume decision tree.
-2. Probe Figma + Refero connections (variant-agnostic ToolSearch + tiebreaker resolution). Detail: `./scan-procedure.md` §Probe connection availability.
-3. Run the four Phase 8 probes (preview, storybook, chromatic, graphify) and batch-write results to STATE.md `<connections>`. Detail: `./scan-procedure.md` §Phase 8 Connection Probes.
-4. Emit the first-run connection nudge if every probe returned `not_configured` AND `.design/config.json > connections_onboarding` is absent.
-5. Update `last_checkpoint`; persist STATE.md before proceeding to Step 1.
-
----
-
-## 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.
-
-### 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
-
-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
-
-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
-
-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
-
-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
-
-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
-
-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
-
-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
-
-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.
-
----
-
-## Outputs
-
-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.
-
----
-
-## 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).
-
-## SCAN COMPLETE