@hegemonart/get-design-done 1.41.5 → 1.42.0

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

@@ -0,0 +1,91 @@
+---
+name: gdd-fast
+description: "Trivial inline design task. No subagents, no planning documents, no pipeline stages. Just do the thing described."
+argument-hint: "<task description>"
+tools: Read, Write, Edit, Bash, Grep, Glob
+disable-model-invocation: true
+---
+
+# /gdd:fast
+
+The leanest possible execution path. No subagents, no STATE.md update, no DESIGN-*.md artifacts. Read the target file, apply the change inline, commit.
+
+## When to use
+
+- "Change this button's border-radius to 8px"
+- "Add a hover state to the nav links"
+- "Fix the mobile breakpoint on the hero"
+- Single-file or single-component obvious changes
+
+## When NOT to use
+
+- Multi-component changes.
+- Anything touching tokens used across the app.
+- Anything requiring a design decision (taste, tradeoff, scope).
+- Use `/gdd:quick` or the full pipeline instead.
+
+## Steps
+
+1. Parse the task description from the argument.
+2. Use Grep/Glob to locate the target file(s). If ambiguous (>2 candidates), stop and ask the user which to edit — do not guess.
+3. Read the target file(s).
+4. Apply the described change with Edit.
+5. Run a relevant sanity check (grep for the old value to confirm it's gone; grep for the new value to confirm it's in).
+6. Commit with message: `fix: <task description>` (one commit, one change).
+7. Print: "Done: <summary of what changed>."
+
+## Do Not
+
+- No subagent spawns.
+- No `.design/` writes.
+- No STATE.md mutation.
+- No pipeline stage invocation.
+- Do not proceed if the change turns out to be non-trivial — bail out and recommend `/gdd:quick` or the full pipeline.
+- Do not skip the `capability_gap` emit on bail-out — Stage-0 telemetry depends on it (Phase 29 D-01).
+
+## Emitting capability_gap on no-skill-match
+
+If step 2 cannot locate any candidate files for the task description (or all candidates are filtered out as off-topic), or if the change in step 4 turns out to be non-trivial in a way that has no obvious resolution without a dedicated skill/agent, emit ONE `capability_gap` event before returning control to the user. 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 capability gaps in `/gdd:apply-reflections`.
+
+Synchronous emitter call (via Bash):
+
+```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: "fast",
+  context_hash: createHash("sha256").update(intent).digest("hex"),
+  intent_summary: intent.slice(0, 256),
+  suggested_kind: "skill",
+  evidence_refs: [],
+};
+appendChainEvent({
+  agent: "fast",
+  outcome: "capability_gap",
+  payload,
+  type: "capability_gap",
+  timestamp: new Date().toISOString(),
+  sessionId: process.env.GDD_SESSION_ID || "fast-cli",
+});
+'
+```
+
+Notes:
+- `evidence_refs` is empty `[]` for fast (no trajectory in `/gdd:fast` — that path is too lean by design).
+- `parent_event_id` is null (root event for the fast bail-out).
+- `suggested_kind` is `"skill"` because fast bail-outs are usually narrow primitives, not multi-step workflows. Plan 29-03's aggregator may upgrade to `"agent"` if a `context_hash` cluster shows multi-step usage.
+- The emitter MUST NOT block — `appendChainEvent` already swallows IO errors via its existing try/catch (see `scripts/lib/event-chain.cjs:97-105`).
+- The 7-field payload is preserved verbatim through `appendChainEvent`'s opaque-extras pattern; the chain row carries `type`, `timestamp`, `sessionId`, `payload` as opaque caller-supplied fields and is projected back to the events-schema envelope shape by readers (Plan 29-03 aggregator).
+
+Trigger conditions:
+- **Trigger 1**: Step 2 returns zero candidate files for the task description (target is genuinely missing).
+- **Trigger 2**: Step 2 returns more than 2 candidates AND the user bail-out in step 2 fires (stop and ask).
+- **Trigger 3**: Step 4 reveals the change is non-trivial in a way that has no obvious primitive resolution (the `## Do Not` "Do not proceed" line fires).
+
+MCP-probe failures (connection down, transport-layer errors) do NOT emit `capability_gap` — those are Phase 22 connection-status concerns (D-08).
+
+## FAST COMPLETE

package/dist/claude-code/.claude/skills/figma-extract/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: gdd-figma-extract
+description: Off-context Figma design-system extraction into a compact local digest (DESIGN.md + tokens.json + components.json). Pulls the file via the Figma REST API and digests it without the raw JSON ever entering the model context.
+---
+
+# gdd-figma-extract
+
+Pull a whole Figma design system into a compact, queryable local digest — **without** the raw JSON ever entering Claude context. The heavy lifting runs in tested `.cjs` tools; the model reads only the digest outputs.
+
+## Usage
+
+```
+/gdd:figma-extract <file-key-or-url>                  # full design-system digest
+/gdd:figma-extract <file-key-or-url> --component Button  # ~500-token single-component slice
+```
+
+`<file-key-or-url>` is a Figma file URL (`https://www.figma.com/file/<key>/…` or `/design/<key>/…`) or a bare file key.
+
+## Behavior
+
+1. **Preflight (D-10).** Confirm `FIGMA_TOKEN` is set in the environment:
+   ```
+   node -e "process.exit(process.env.FIGMA_TOKEN||process.env.FIGMA_PERSONAL_ACCESS_TOKEN?0:1)"
+   ```
+   If unset, tell the user to `export FIGMA_TOKEN=figd_…` (from https://www.figma.com/developers/api#access-tokens). The token comes from the environment **only** — never ask the user to paste it into a file or the chat, and never echo it back.
+
+2. **Stage 1 — pull.** Pull the file's REST endpoints into the gitignored raw cache (D-09):
+   ```
+   node scripts/lib/figma-extract/pull.cjs "<file-key-or-url>"
+   ```
+   This caches to `.figma-extract-cache/raw/<file-key>/` and skips re-pulling when Figma's `version` is unchanged (D-11). Add `--force` to bypass the cache, `--out <dir>` to relocate the cache. The tool prints a JSON summary (endpoints, bytes, cached) on stdout — the raw bodies stay on disk.
+
+3. **Stage 2 — plugin sync (OPTIONAL, Path C).** Only when the design tokens live in Figma Variables that the REST API cannot return (non-Enterprise plans → the pull summary shows `variables` skipped) and the user wants token coverage:
+   ```
+   node scripts/lib/figma-extract/receiver.cjs --out .figma-extract-cache/raw/<file-key>
+   ```
+   This binds `127.0.0.1:5179` (D-06). Tell the user to run the dev-installed **"GDD Sync"** plugin in Figma and click **"Export to GDD"** — see `figma-plugin/README.md` for the one-time dev-install. The receiver writes `variables.json` into the cache and exits on receipt or timeout. Skip this stage entirely for design systems whose tokens already come through the REST pull.
+
+4. **Stage 3 — digest.** Transform the cache into the compact digest:
+   ```
+   node scripts/lib/figma-extract/digest.cjs --raw .figma-extract-cache/raw/<file-key> --out .figma-extract-cache/digest
+   ```
+   This writes `DESIGN.md`, `tokens.json`, and `components.json`. Add `--prefer-styles` to invert the token priority to styles-first (D-04). Add `--component <name>` (D-08) to emit a single-component slice instead of the full digest.
+
+5. **Read the digest.** Open **only** `.figma-extract-cache/digest/DESIGN.md` (plus `tokens.json` / `components.json` when you need structured data). For a single component, pass `--component <name>` in Stage 3 and read the ~500-token slice instead of the full ~16K-token spec.
+
+## Required Reading
+
+- `.figma-extract-cache/digest/DESIGN.md` — the compact human/LLM-readable spec
+- `.figma-extract-cache/digest/tokens.json` — resolved design tokens (when structured token data is needed)
+- `.figma-extract-cache/digest/components.json` — components with variants/props/defaults (when structured component data is needed)
+
+## Notes
+
+- Two-stage pipeline (D-01): re-run Stage 3 against an existing cache without re-pulling. The digest does zero network calls.
+- The spike proved **0 Claude tokens** during extraction (898× compression, 223 MB → 254 KB). That property holds only because this skill never surfaces the raw cache.
+- Figma MCP remains the right tool for spot questions on a single live component; this skill is the cheaper path for whole-design-system workflows.
+
+## Do Not
+
+- **Do NOT read or `cat` the `raw/*.json` cache** (e.g. `.figma-extract-cache/raw/<file-key>/file.json`). It is tool-internal and often 100+ MB; loading it into context defeats the off-context guarantee (D-12). Read only the digest outputs above.
+- **Do not persist, log, echo, or print `FIGMA_TOKEN`** (D-10). It belongs in the environment only — never write it to a file, a commit, or chat output.
+
+## FIGMA-EXTRACT COMPLETE

package/dist/claude-code/.claude/skills/figma-write/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: gdd-figma-write
+description: "Write design decisions from `.design/DESIGN-CONTEXT.md` back into the active Figma file by dispatching the `design-figma-writer` agent in one of three modes (annotate / tokenize / mappings). Use when the user has completed a design pipeline cycle and wants the decisions (layer comments, variable bindings, or Code Connect mappings) reflected in Figma. Operates proposal→confirm with `--dry-run` and `--confirm-shared` flags."
+---
+
+# gdd-figma-write
+
+Dispatches the `design-figma-writer` agent to write design decisions back to the open Figma file. The shared probe pattern (ToolSearch → live call → STATE.md write) and connection handshake are documented at `../../reference/shared-preamble.md#connection-handshake-summary` and `../../connections/figma.md`.
+
+## Usage
+
+```
+/get-design-done figma-write <mode> [--dry-run] [--confirm-shared]
+```
+
+Modes:
+- `annotate` — add design decision comments to Figma layers
+- `tokenize` — bind hard-coded color/spacing/type values to Figma variables
+- `mappings` — write Code Connect component↔code file mappings
+
+Flags:
+- `--dry-run` — emit the proposal without executing any Figma writes
+- `--confirm-shared` — authorize writes to shared team library components
+
+## Prerequisites
+
+1. Remote Figma MCP registered (writes are remote-only). Preferred: `claude plugin install figma@claude-plugins-official`. Manual: `claude mcp add --transport http figma https://mcp.figma.com/mcp`.
+2. `.design/DESIGN-CONTEXT.md` exists (run `discover` first)
+3. `.design/STATE.md` `<connections>` shows `figma: available (…, writes=true)`. If `writes=false` (desktop-only variant), writes are not supported — the agent will STOP with an instruction to install the remote MCP.
+
+## Required Reading
+
+Read `.design/STATE.md` and `.design/DESIGN-CONTEXT.md` before dispatching the agent.
+
+## Dispatch
+
+<agent>design-figma-writer</agent>
+
+Pass through all flags and arguments from the invocation to the agent.

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

@@ -0,0 +1,49 @@
+---
+name: gdd-graphify
+description: Manage the Graphify knowledge graph for the current project. Build, query, status, diff. When available, design-planner and design-integration-checker use the graph for pre-search consultation.
+---
+
+# gdd-graphify
+
+Thin command wrapper around the GSD graphify tools integration.
+
+## Usage
+
+```
+/get-design-done graphify build          # Build or rebuild the knowledge graph
+/get-design-done graphify query <term>   # Query graph for a node and neighbors
+/get-design-done graphify status         # Check graph age, enabled, node count
+/get-design-done graphify diff           # Show topology changes since last build
+```
+
+## Behavior
+
+1. Read `.design/STATE.md` to check `graphify` status in `<connections>`.
+2. Check `graphify.enabled` in `.design/config.json` via a direct file read (per D-09 — no `config-get` CLI subcommand):
+   ```
+   node -e "try{const c=JSON.parse(require('fs').readFileSync('.design/config.json','utf8'));process.stdout.write(String(c.graphify?.enabled===true))}catch{process.stdout.write('false')}"
+   ```
+3. If not enabled, print:
+   ```
+   "Graphify is not enabled. Edit `.design/config.json` to set `graphify.enabled: true`."
+   "Then run /gdd:graphify build to generate the knowledge graph."
+   ```
+   STOP.
+4. Execute the requested subcommand via the native CLI:
+   - build:  `node bin/gdd-graph build`
+   - query:  `node bin/gdd-graph query "<term>" --budget 2000`
+   - status: `node bin/gdd-graph status`
+   - diff:   `node bin/gdd-graph diff`
+5. After `build` completes, update `.design/STATE.md` `<connections>`: `graphify: available`
+
+## Required Reading
+
+- `.design/STATE.md` — for graphify status in `<connections>`
+- `.design/config.json` — for `graphify.enabled` flag
+
+## Notes
+
+- Graphify is optional. The native CLI ships in this repo at `bin/gdd-graph` (no external install — Node only).
+- Graph is stored at `.design/graph/graph.json` (Ajv-validated against `scripts/lib/graph/schema.json`).
+- Graph covers source code (`src/`, `components/`). It does NOT index `.design/` artifacts by default.
+- Use `query` with node IDs from the graph schema: `component:<name>`, `token:color/<name>`, `decision:D-<nn>`, etc.

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

@@ -0,0 +1,99 @@
+---
+name: gdd-health
+description: "Reports .design/ artifact health — staleness, missing files, token drift, broken state transitions."
+tools: Read, Bash, Glob, Grep, mcp__gdd_state__get
+disable-model-invocation: true
+---
+
+# /gdd:health
+
+**Role:** Report the health of the `.design/` directory. Print a score and list the checks that failed.
+
+## Checks
+
+1. **Artifact inventory** — `ls -la .design/*.md` with size and mtime. Print a table.
+2. **Missing expected artifacts** — by `stage` field from the `mcp__gdd_state__get` snapshot:
+   - `brief` expects BRIEF.md
+   - `explore` expects DESIGN.md, DESIGN-DEBT.md, DESIGN-CONTEXT.md
+   - `plan` expects DESIGN-PLAN.md
+   - `design` expects DESIGN-SUMMARY.md
+   - `verify` expects DESIGN-VERIFICATION.md
+   FAIL per missing.
+3. **Token drift** — `wc -c .design/DESIGN.md .design/DESIGN-CONTEXT.md`; approx tokens = bytes/4. WARN if combined >40000.
+4. **Aged DESIGN-DEBT** — items in `.design/DESIGN-DEBT.md` not touched in >14 days (file mtime). WARN.
+5. **Broken state transitions** — `stage` field from the snapshot inconsistent with artifacts present (e.g. stage=`verify` but DESIGN-SUMMARY.md missing). FAIL.
+6. **Pending sketch/spike wrap-ups** — any `.design/sketches/*` or `.design/spikes/*` directory lacking a SUMMARY.md. WARN.
+7. **Seed germination** — scan `.design/SEEDS.md` (if present) for seeds whose trigger keywords match the snapshot or CYCLES.md content. List as "Seed ready: <text>".
+
+## State snapshot
+
+Call `mcp__gdd_state__get` once at the start to pull the snapshot used by checks 2, 5, and 7. Aggregate health math stays prose-level:
+- Count available connections from `<connections>`.
+- Count open blockers from `<blockers>` where `resolved` is absent.
+- Count pending must-haves from `<must_haves>` where `status: "pending"`.
+
+## Output
+
+```
+━━━ Design health ━━━
+Artifacts:
+  BRIEF.md           2.1 KB   2026-04-14
+  DESIGN.md          18.4 KB  2026-04-17
+  DESIGN-CONTEXT.md  7.2 KB   2026-04-17
+
+Checks:
+  [PASS] Missing artifacts
+  [WARN] Token drift (42,100)
+  [PASS] Aged DESIGN-DEBT
+  [PASS] State transitions
+  [PASS] Sketch/spike wrap-ups
+  [PASS] Seed germination
+
+Health: 5 / 6 checks passing.
+━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Figma-extract readiness (figma_extract)
+
+After the health table, the `gdd_health` MCP surface (`scripts/lib/health-mirror/index.cjs`) reports a `figma_extract` check so a user knows whether figma-extract is usable. The detail is one of three exact strings:
+
+- `figma extract: ready (token set)` — `FIGMA_TOKEN` (or `FIGMA_PERSONAL_ACCESS_TOKEN`) is present (status `ok`).
+- `figma extract: token missing` — no token env is set (status `warn`).
+- `figma extract: plugin sync needed for variables (Free tier detected)` — token present but a prior pull recorded a 403/skip on the Variables REST path, so run the plugin-sync step (status `warn`).
+
+Token PRESENCE only is detected (D-10) — the token value is never read, logged, or shown. The Free-tier signal is read from the local raw-pull cache only; no network call is made.
+
+## Skill-discipline bootstrap (skill_discipline)
+
+The `gdd_health` MCP surface also reports a `skill_discipline` check (Phase 32) confirming the using-gdd SessionStart bootstrap is live — detail is one of three exact strings:
+- `skill-discipline: ready` — `skills/using-gdd/SKILL.md` exists AND `hooks/hooks.json` SessionStart wires `inject-using-gdd.sh` (status `ok`).
+- `skill-discipline: missing using-gdd` (skill absent) or `skill-discipline: hook not wired` (skill present, no SessionStart inject) — both `warn`.
+
+## Check MCP registration (gdd-mcp)
+
+After the health table, inspect whether `gdd-mcp` (Phase 27.7+) is registered with any installed harness and render a one-line status row. Dismissable via `.design/config.json#mcp_nudge=false`. Non-blocking: failure paths render `MCP server: unknown` rather than crash. Full detection procedure (dismissal check, detection via `scripts/lib/install/mcp-register.cjs`, row rendering for claude/codex/both/neither, fallback) lives in `./health-mcp-detection.md`.
+
+## Update notice (safe-window surface)
+
+After the health table, emit the plugin-update banner if one is present:
+
+```bash
+[ -f .design/update-available.md ] && cat .design/update-available.md
+```
+
+Written by `hooks/update-check.sh`; suppressed mid-pipeline and when the latest release is dismissed.
+
+## Skill-length report
+
+After the health table, surface the Phase 28.5 skill-authoring contract drift signal by running `node scripts/validate-skill-length.cjs --quiet --json` and reading `summary` from stdout. Print two prose lines:
+
+- `Skill-length: <total> total | <clean> clean | <warnings> warn (>=100) | <blockers> block (>=250)`
+- If blockers > 0: list each blocker as a row `- <name> (<lines> lines)`. Else: print `All skills within contract.`
+
+Thresholds: warn >=100, block >=250 (D-01). Strict description-format off by default (D-02). See `./health-skill-length-report.md` for the JSON shape and threshold rationale.
+
+## Do Not
+
+- Do not mutate STATE.md — this skill is read-only. Only `mcp__gdd_state__get` is permitted.
+
+## HEALTH COMPLETE

package/dist/claude-code/.claude/skills/health/health-mcp-detection.md

@@ -0,0 +1,44 @@
+---
+name: health-mcp-detection
+type: heuristic
+version: 1.0.0
+phase: 28.5
+tags: [health, mcp, detection, gdd-mcp, registration-nudge]
+last_updated: 2026-05-18
+---
+
+# Health MCP-Registration Detection Procedure
+
+Extracted from `skills/health/SKILL.md` per Phase 28.5 D-10 (extract-then-link, never delete content).
+This file documents the canonical procedure for inspecting whether `gdd-mcp` (Phase 27.7+) is
+registered with any installed harness and rendering a one-line status row after the health
+table. The procedure is non-blocking by design: any failure path renders `unknown` rather
+than crashing the skill.
+
+## Dismissal check
+
+1. Read `.design/config.json` (if present). Parse JSON inside a try/catch.
+2. If `config.mcp_nudge === false`, SKIP this step entirely (render nothing).
+3. On parse failure: default to `mcp_nudge=true` (show the row) — fail-safe per threat T-27.7-04-05.
+
+## Detection
+
+1. Read `.claude/settings.local.json` (or equivalent harness settings file) and inspect its `mcpServers` object — alternatively run `claude mcp list` / `codex mcp list` if a CLI is available (see fallback below).
+2. Preferred invocation via the install-lib: call `detectMcpRegistration()` from `scripts/lib/install/mcp-register.cjs`. Returns `{harnesses: [{harness, present, registered}], summary}`.
+
+## Row rendering
+
+Based on the detection result, render exactly ONE of these row strings:
+
+- When `claude` and `codex` both present + both registered:
+  `MCP server: registered with claude+codex`
+- When only one harness is present and registered:
+  `MCP server: registered with claude` (or `MCP server: registered with codex`)
+- When at least one harness is present but `gdd-mcp` is NOT in its registered list:
+  `MCP server: not registered  (run: npx @hegemonart/get-design-done --register-mcp; dismiss: .design/config.json#mcp_nudge=false)`
+- When neither harness CLI is found on PATH:
+  `MCP server: unknown (claude/codex CLI not found)`
+
+## Fallback (if `mcp-register.cjs` not yet shipped)
+
+Skip this step silently with status `MCP server: unknown`. This step is non-blocking — failures here MUST NOT crash the SKILL.

package/dist/claude-code/.claude/skills/health/health-skill-length-report.md

@@ -0,0 +1,69 @@
+# Health skill — skill-length report subsection
+
+Phase 28.5-11 / D-11 reference. Read by `skills/health/SKILL.md` to render the
+"Skill-length report" subsection after the standard health checks.
+
+## JSON shape (from `validate-skill-length.cjs --quiet --json`)
+
+```jsonc
+{
+  "summary": {
+    "total":    70,   // number of SKILL.md files under skills/
+    "clean":    70,   // skills with 0 errors and 0 warnings
+    "warnings": 0,    // skills with >=100 lines but <250 (D-01 warn band)
+    "blockers": 0     // skills with any block-level error (>=250 lines,
+                      //   missing frontmatter field, description out of
+                      //   range, disable-model-invocation non-whitelisted)
+  },
+  "skills": [
+    {
+      "name": "...",           // skill folder name (matches skills/<name>/SKILL.md)
+      "path": "...",           // absolute path to the file on disk
+      "lines": 0,              // wc -l semantics
+      "descriptionLength": 0,  // length of frontmatter.description string
+      "hasRequiredFields": true,
+      "level": "clean",        // "clean" | "warn" | "block"
+      "errors": [{ "code": "...", "message": "..." }],
+      "warnings": [{ "code": "...", "message": "..." }],
+      "reasons": ["..."]       // human-readable summary lines
+    }
+  ]
+}
+```
+
+## Render contract
+
+The health skill prints two lines after the existing checks table:
+
+```
+Skill-length: <total> total | <clean> clean | <warnings> warn (>=100) | <blockers> block (>=250)
+  All skills within contract.
+```
+
+If `summary.blockers > 0`, replace the second line with one indented row per
+blocker entry (skills where `level === "block"`):
+
+```
+Skill-length: 70 total | 67 clean | 2 warn (>=100) | 1 block (>=250)
+  - <name> (<lines> lines)
+```
+
+## Thresholds (D-01)
+
+- `warn >=100` — skill flagged as advisory; CI emits `::warning::` annotation
+  but does not fail the build.
+- `block >=250` — skill flagged as blocker; CI emits `::error::` and fails
+  the build via exit code 2.
+
+## Strict description-format (D-02)
+
+`STRICT_DESCRIPTION=1` / `--strict-description` is OFF by default. Phase 33
+will graduate the strict `<what>. Use when <triggers>.` regex from advisory
+to hard-block based on A/B evidence at
+`.design/research/description-format-ab.md`.
+
+## Cross-link from health
+
+- `skills/health/SKILL.md` — emits the report after the main checks table.
+- `scripts/validate-skill-length.cjs` — provides the JSON.
+- `tests/phase-28.5-baseline.test.cjs` — locks the post-rework distribution.

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

@@ -0,0 +1,87 @@
+---
+name: gdd-help
+description: "Lists all available get-design-done commands with one-line descriptions"
+tools: Read
+disable-model-invocation: true
+---
+
+# Get Design Done — Help
+
+**Role:** Print a formatted reference of all `/gdd:` commands, grouped by purpose.
+
+---
+
+## Output
+
+Print the following table:
+
+```
+━━━ Get Design Done — Command Reference ━━━
+
+Pipeline stages (run in order):
+  brief              Stage 1 — capture problem statement, audience, constraints → BRIEF.md
+  explore            Stage 2 — inventory scan + design context interview → DESIGN.md, DESIGN-DEBT.md, DESIGN-CONTEXT.md
+  plan               Stage 3 — decompose into executable tasks → DESIGN-PLAN.md
+  design             Stage 4 — execute tasks with wave coordination → DESIGN-SUMMARY.md
+  verify             Stage 5 — audit, verify, score → DESIGN-VERIFICATION.md
+
+Standalone analysis:
+  style [Component]  Generate component handoff doc → DESIGN-STYLE-[Name].md
+  darkmode           Audit dark mode architecture + contrast → DARKMODE-AUDIT.md
+  compare            Delta between baseline and verification → COMPARE-REPORT.md
+
+Ergonomics:
+  next               Route to the next pipeline stage based on STATE.md
+  help               This reference
+  progress           Show current pipeline state
+  health             Health check of .design/ artifacts
+  quick              Fast pass through the whole pipeline
+  fast               Aggressive speed mode
+
+Exploration:
+  discuss            Open discussion thread with design-discussant agent
+  list-assumptions   Print active D-XX decisions from STATE.md
+  sketch             Open a design sketch scratchpad
+  sketch-wrap-up     Close sketch and merge learnings
+  spike              Time-boxed exploratory spike
+  spike-wrap-up      Close spike and capture outcomes
+  map                Map the codebase structure
+  audit              Run audit-only pass
+
+Maintenance:
+  note               Record a quick note to STATE.md
+  plant-seed         Record an idea for later
+  add-backlog        Append item to backlog
+  review-backlog     Review pending backlog
+  todo               List/manage design TODOs
+  stats              Print pipeline stats
+  settings           View/edit plugin settings
+  update             Update the plugin
+  reapply-patches    Reapply any pending patches
+  debug              Enter systematic debugging mode
+  undo               Revert the last stage action
+
+Lifecycle:
+  new-project        Initialize STATE.md + .design/ directory
+  new-cycle          Start a new design cycle on an existing project
+  complete-cycle     Archive the current cycle
+  pause              Pause work and save context
+  resume             Resume paused work
+  do                 Execute a specific task
+  ship               Create PR from completed work
+  pr-branch          Create/switch PR branch
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Update notice (safe-window surface)
+
+After the command reference, emit the plugin-update banner if one is present:
+
+```bash
+[ -f .design/update-available.md ] && cat .design/update-available.md
+```
+
+Written by `hooks/update-check.sh`; suppressed mid-pipeline and when the latest release is dismissed.
+
+## HELP COMPLETE

package/dist/claude-code/.claude/skills/list-assumptions/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: gdd-list-assumptions
+description: "Surfaces hidden design assumptions baked into the codebase before planning — pattern-based detection plus user-surfaced items."
+argument-hint: "[--area typography|color|layout|motion|a11y]"
+tools: Read, Grep, Glob
+disable-model-invocation: true
+---
+
+# /gdd:list-assumptions
+
+**Role:** Surface implicit design assumptions that were never explicitly decided. Output a numbered list tagging each as `[EXPLICIT]` (found in STATE.md/DESIGN-CONTEXT.md decisions) or `[IMPLICIT]` (inferred from code patterns).
+
+## Step 1 — Read explicit decisions
+
+Read `.design/STATE.md` `<decisions>` and `.design/DESIGN-CONTEXT.md` (if present). Collect every D-XX as `[EXPLICIT]` entries keyed by category.
+
+## Step 2 — Scan codebase for implicit patterns
+
+If `--area <name>` is given, restrict to that area. Otherwise scan all.
+
+**Layout**
+- Grep for `@media` queries → "Is mobile-first or desktop-first assumed?"
+- Grep for `grid-template`, `flex-direction` → "Is F-pattern or Z-pattern layout assumed?"
+
+**Typography**
+- Grep for `font-family` declarations → "Does the chosen font stack assume brand acceptance?"
+- Grep for `font-size: [0-9]+px` with varying values → "Is a modular scale assumed or ad-hoc sizing?"
+
+**Color**
+- Grep for hex literals `#[0-9a-fA-F]{3,8}` → "Is the palette assumed to be fixed without a token layer?"
+
+**Motion**
+- Grep for `@keyframes`, `transition`, `animate` → "Does the brand tolerate animation?"
+- Grep for `prefers-reduced-motion` → "Is reduced-motion honored or assumed ignored?"
+
+**A11y**
+- Grep for `aria-`, `role=`, `alt=` coverage → "Is WCAG AA the target, or AAA?"
+- Grep for `outline: none`, `outline: 0` → "Are focus rings intentionally removed?"
+
+For each hit, emit `Detected assumption: [pattern] at [file:line]` and flag as `[IMPLICIT]`.
+
+## Step 3 — Output
+
+```
+━━━ Design assumptions ━━━
+
+Typography
+  01 [EXPLICIT] D-03: Font family Inter
+  02 [IMPLICIT] 18 px font-size values found — scale not explicit (src/Card.css:12, ...)
+
+Color
+  03 [IMPLICIT] 47 hex literals — no token layer (see /gdd:discuss color)
+
+...
+
+N assumptions total — M implicit.
+Next: /gdd:discuss --all to resolve implicit ones.
+━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## LIST-ASSUMPTIONS COMPLETE

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

@@ -0,0 +1,51 @@
+---
+name: gdd-locale
+description: "Inspects or sets the GDD CLI locale for this project. With no argument, reports the resolved locale (config.locale > env LANG > en), the fallback chain, and per-locale coverage (which message tables are complete vs placeholder). With a <code> (en/ru/uk/de/fr/zh/ja), sets .design/config.json#locale after previewing the change. Localizes --help, common error messages, and skill prompt headers via scripts/lib/i18n/; missing keys fall back to English, so a partial locale never breaks the CLI. Use to switch GDD's own output language."
+argument-hint: "[<code>]"
+user-invocable: true
+tools: Read, Write, Bash, Grep, Glob
+---
+
+# /gdd:locale
+
+Closes the English-only CLI gap: GDD's README is multilingual, but `--help`, errors, and skill prompt
+headers spoke English until now. This skill inspects or sets the project's locale. Contract:
+`../../reference/cli-localization.md`.
+
+## Invocation
+
+| Command | Behavior |
+|---|---|
+| `/gdd:locale` | Report the resolved locale, the fallback chain, and per-locale coverage. |
+| `/gdd:locale <code>` | Set `.design/config.json#locale` to `<code>` (en/ru/uk/de/fr/zh/ja), after preview. |
+
+## Steps
+
+1. **Resolve current.** Read `.design/config.json#locale` (if any) and the environment, then call the
+   resolver to report the active locale + chain:
+
+   ```bash
+   node -e '
+     const i = require("./scripts/lib/i18n/index.cjs");
+     let cfg = {}; try { cfg = JSON.parse(require("fs").readFileSync(".design/config.json","utf8")); } catch {}
+     const loc = i.resolveLocale({ env: process.env, configLocale: cfg.locale });
+     const cov = i.KNOWN_LOCALES.map((l) => `${l}:${(i.loadTable(l)._meta||{}).coverage||"?"}`).join("  ");
+     console.log(JSON.stringify({ resolved: loc, chain: i.fallbackChain(loc), coverage: cov }));
+   '
+   ```
+
+2. **No argument** → print the resolved locale, the fallback chain, and the coverage line (which
+   tables are `complete` vs `placeholder`). Stop.
+3. **`<code>` argument** → validate it is in `KNOWN_LOCALES` (en/ru/uk/de/fr/zh/ja). Unknown → print the
+   `error.invalid_locale` message + the known list, change nothing.
+4. **Preview + set.** Show `locale: <old> -> <code>`, then write `locale` into `.design/config.json`
+   (create the file if absent, preserving any existing keys). Confirm, and note that missing keys in a
+   placeholder locale fall back to English.
+
+## Output
+
+End with:
+
+```
+## LOCALE COMPLETE
+```