@hegemonart/get-design-done 1.57.2 → 1.58.0

package/dist/claude-code/.claude/skills/explore/explore-procedure.md

@@ -1,267 +0,0 @@
----
-name: explore-procedure
-type: meta-rules
-version: 1.0.0
-phase: 28.5
-tags: [explore, procedure, extracted, pipeline-stage, connection-probe, design-interview, i18n]
-last_updated: 2026-05-18
----
-
-Source: extracted from `skills/explore/SKILL.md` (Phase 28.5 rework - D-10 extract-then-link).
-The skill's essential workflow stays in `../skills/explore/SKILL.md`; this file holds the
-detail the agent reaches for when executing a specific step (six connection probes, 21st.dev
-prior-art check, inventory scan grep, design interview protocol, i18n probe, decision
-recording).
-
-# Explore Procedure
-
-Detailed procedure for the get-design-done `explore` Stage 2 orchestrator. Companion to
-`../skills/explore/SKILL.md`. Read this file when executing a specific step; the SKILL.md
-keeps the essential workflow + decision tree, this file holds the deep methodology.
-
----
-
-## Stage entry
-
-All STATE.md persistence in this skill goes through `gdd-state` MCP tools - no direct edits. The skill writes to `.design/STATE.md` (connections, decisions, progress, checkpoint) via those tools, and to plain design docs (DESIGN.md / DESIGN-DEBT.md / DESIGN-CONTEXT.md) via `Write`.
-
-1. Call `mcp__gdd_state__transition_stage` with `to: "explore"`.
-   - On success: proceed to probes.
-   - On gate failure: emit blockers to the user (do not advance). Each blocker is a line in the `error.context.blockers` array; print them verbatim.
-2. Call `mcp__gdd_state__get` with no arguments - snapshot the parsed state into a local `state` variable for downstream steps.
-
----
-
-## Step 1 - Connection probe
-
-Probe connection availability (the batched write lands at the end of this step - see "Commit probe results" below):
-
-**A - Figma probe (variant-agnostic):**
-```
-ToolSearch({ query: "figma get_metadata use_figma", max_results: 10 })
-Parse tool names matching /^mcp__([^_]*figma[^_]*)__(get_metadata|use_figma)$/i
-  into read-capable and write-capable prefix sets.
-Empty read set -> figma: not_configured
-One+ matches  -> pick prefix via tiebreaker:
-                (1) both-sets > reads-only,
-                (2) `figma` > others,
-                (3) non-`figma-desktop` > desktop,
-                (4) alphabetical.
-Then call {prefix}get_metadata:
-  success -> figma: available (prefix=mcp__<prefix>__, writes=<true|false>)
-  error   -> figma: unavailable
-```
-
-**B - Refero probe:**
-```
-ToolSearch({ query: "refero", max_results: 5 })
-Empty -> refero: not_configured
-Non-empty -> refero: available
-```
-
-**C - 21st.dev probe:**
-```
-ToolSearch({ query: "mcp__21st", max_results: 5 })
-Empty -> 21st-dev: not_configured
-Non-empty -> 21st-dev: available
-```
-
-**D - Magic Patterns probe:**
-```
-ToolSearch({ query: "mcp__magic_patterns", max_results: 5 })
-Empty -> magic-patterns: not_configured
-Non-empty -> magic-patterns: available
-```
-
-**E - paper.design probe:**
-```
-ToolSearch({ query: "mcp__paper", max_results: 5 })
-Empty -> paper-design: not_configured
-Non-empty -> call mcp__paper-design__get_selection; success -> available; error -> unavailable
-```
-
-**F - pencil.dev probe (file-based):**
-```bash
-find . -name "*.pen" -not -path "*/node_modules/*" 2>/dev/null | head -1
-Empty -> pencil-dev: not_configured
-Found -> pencil-dev: available
-```
-
-## Commit probe results
-
-After all probes complete, commit results in a single call:
-
-`mcp__gdd_state__probe_connections` with `probe_results` = an array of `{ name, status }` entries - one per probed connection. Example:
-
-```json
-{
-  "probe_results": [
-    { "name": "figma", "status": "available" },
-    { "name": "refero", "status": "not_configured" },
-    { "name": "preview", "status": "unavailable" }
-  ]
-}
-```
-
-Unspecified connections keep their existing value. Do NOT issue multiple `probe_connections` calls - the tool is designed for a single batch write per stage.
-
-## Step 1.5 - 21st.dev Prior-Art Check (when 21st-dev: available)
-
-If `state.connections.21st-dev === "not_configured"` (from the snapshot captured at stage entry): skip this step entirely.
-
-When the explore stage identifies any greenfield component in scope (component name from BRIEF.md or user request that does not yet have an implementation file):
-
-1. `21st_magic_component_search(component_name, limit: 3)`
-2. Evaluate top result:
-   - **fit >= 80%**: add `<prior-art>` block to DESIGN.md:
-     ```xml
-     <prior-art source="21st.dev" component="<name>" fit="<score>%" id="<component_id>">
-       Recommendation: adopt — do not build custom. Confirm with design-executor.
-     </prior-art>
-     ```
-   - **fit < 80%**: note top candidate in DESIGN.md as a reference, proceed with custom build:
-     ```xml
-     <prior-art source="21st.dev" component="<name>" fit="<score>%" id="<component_id>">
-       Low fit — noted for reference. Building custom component.
-     </prior-art>
-     ```
-3. If `svgl_get_brand_logo` is available and explore scope includes brand logo assets: call `svgl_get_brand_logo(brand_name)` for each required brand asset; add SVG results to `.design/assets/` and note in DESIGN.md.
-
-If no greenfield components in scope: skip this step.
-
----
-
-## Step 2 - Inventory scan (unless `--skip-scan`)
-
-**Map pre-check:** If `.design/map/` exists and all 5 files (`tokens.md`, `components.md`, `visual-hierarchy.md`, `a11y.md`, `motion.md`) are present AND fresher than `src/` (mtime), consume them as the inventory source and skip the grep pass. Otherwise proceed with grep below and, after Step 4, suggest running `/gdd:map` for richer parallel-scanned data on the next cycle.
-
-**Parallelism decision (before any multi-agent spawn):**
-1. Read `.design/config.json` `parallelism` (or defaults from `reference/config-schema.md`).
-2. Apply rules from `reference/parallelism-rules.md` (hard -> soft).
-3. Record the verdict via `mcp__gdd_state__set_status` with a short status label (e.g., `status: "explore_parallel"` or `"explore_serial"`) carrying the stage/verdict/reason/agents payload.
-4. If verdict is `parallel`, dispatch via multiple `Task()` calls in one response; if `serial`, spawn sequentially.
-
-Run the canonical scan grep/glob inventory (preserves PLAT-01/02 POSIX ERE patterns from Phase 1):
-
-- **Component detection** - `Glob` for `**/*.{tsx,jsx,vue,svelte}`; count exports, identify shared UI primitives.
-- **Color extraction** - `Grep` for hex (`#[0-9a-fA-F]{3,8}`), `rgb(`, `hsl(`, Tailwind arbitrary color classes; dedupe.
-- **Typography scan** - Grep font-family declarations, Tailwind `font-*`, `text-*` size classes; identify type scale.
-- **Motion scan** - Grep `transition`, `animate-`, `@keyframes`, `framer-motion` imports.
-- **Token detection** - Check for `tailwind.config.{js,cjs,mjs,ts}`, CSS custom properties (`--*`), design-token JSON.
-- **Layout detection** - Ordered fallback: `src/` -> `app/` -> `pages/` -> `lib/` -> unknown.
-
-Write findings to:
-- `.design/DESIGN.md` - current design system inventory + baseline score
-- `.design/DESIGN-DEBT.md` - prioritized debt roadmap
-
-Record scan progress: call `mcp__gdd_state__update_progress` with `task_progress: "<completed>/<total>"` to reflect the scan pass.
-
-### Step 2.x - i18n readiness probe (informational)
-
-Phase 28 D-04 probe - 3-state classification, **informational only**. NO gate, NO blocking, NO required-action. Output appears as a single line in the explore report.
-
-Classification logic (matches `./reference/i18n.md` §Explore Integration Spec):
-
-```txt
-1. Read package.json (dependencies + devDependencies).
-
-2. Check against library matrix:
-     react-intl, next-intl, i18next, vue-i18n, formatjs, lingui
-   >=1 library found in deps or devDeps -> state = "framework-managed"
-                                          -> STOP, emit line, exit probe.
-
-3. Else (no library):
-     grep -RE "Intl\.(DateTimeFormat|NumberFormat|PluralRules|RelativeTimeFormat|ListFormat|Collator|Segmenter)" src/
-   >=1 match -> state = "partial"
-              -> emit line, exit probe.
-
-4. Else: state = "none"
-         -> emit line, exit probe.
-```
-
-Output line in explore report (single informational line, per D-04):
-
-```txt
-Localization readiness: framework-managed | partial | none
-```
-
-(Exactly one of the three values, single line.) A consumer downstream (a planning agent, a roadmap reviewer, the user) can act on the signal if a gap is meaningful for the project, but the probe itself never forces a step - surface signal, do not bolt on a new pillar (D-07 orthogonal-lens discipline).
-
-## Step 2.5 - Detect prior sketches and project-local conventions
-
-**Sketches**: If `.design/sketches/` exists, list all sketch slugs - group by those with `WINNER.md` (completed wrap-ups) vs without (pending). Call `mcp__gdd_state__set_status` with a brief note (e.g., `status: "explore_sketches_present"`) so downstream stages see the history. Include the inventory in DESIGN.md under a "Prior Explorations" section.
-
-**Project-local skills**: Read any `./.claude/skills/design-*-conventions.md` files if present. Include their content in DESIGN-CONTEXT.md under a `<project_conventions>` section - these are codified decisions from prior `/gdd:sketch-wrap-up` runs or manual edits, and they override defaults.
-
-**Global skills**: If `~/.claude/gdd/global-skills/` exists and contains `.md` files (other than README.md), read them and prepend their content to the `<project_conventions>` section under a `<global_conventions>` sub-block. Global skills represent cross-project personal conventions. They inform but do not override project-local decisions - when a project-local D-XX decision conflicts with a global skill, the project-local decision wins.
-
----
-
-## Step 3 - Design interview (unless `--skip-interview`)
-
-**Run this inline - do NOT spawn `design-discussant` as a subagent.** Subagent UI tools (`AskUserQuestion`) only render the native picker when called from the top-level skill context; spawning a Task() degrades the interview to plain markdown in chat (broken in Claude Desktop).
-
-### 3.a - Pre-load context
-
-Read in this order:
-1. `state.decisions` from the snapshot captured at stage entry - existing D-XX entries (do NOT re-ask anything covered). If the snapshot is stale, refresh by calling `mcp__gdd_state__get`.
-2. `.design/BRIEF.md` - problem statement, audience, constraints
-3. `.design/DESIGN.md` - auto-detected inventory from Step 2
-4. `.design/DESIGN-CONTEXT.md` if it exists - `<gray_areas>` block lists unresolved topics
-5. `./.claude/skills/design-*-conventions.md` if any - locked project conventions, treat as authoritative
-
-If `state.connections` shows `figma: available`, read the resolved `prefix=` from the same entry and call `{prefix}get_variable_defs`, then draft tentative D-XX entries (mark `(tentative — confirm with user)`) before asking.
-
-### 3.b - Identify question set
-
-Build the list of areas needing input. Skip any area already answered by an existing D-XX or covered by a project convention. Default coverage:
-
-- Cycle goal / outcome that matters most
-- Audience and primary use context
-- Brand direction (only if no tokens detected in DESIGN.md)
-- Color primitives (only if no palette detected)
-- Typography scale (only if no type system detected)
-- Spacing scale (only if no spacing tokens detected)
-- Motion preferences (only if no motion patterns detected)
-- Any `<gray_areas>` from DESIGN-CONTEXT.md
-
-### 3.c - Ask, one question at a time
-
-For each area, call `AskUserQuestion` with a single focused question. Provide 4 concrete options plus "Other" / "Skip" where it helps. Do not batch questions into one call. Do not print the question as markdown - always go through the tool.
-
-Reject generic answers ("modern", "clean", "professional"). If the answer is vague, ask one follow-up before recording.
-
-### 3.d - Record after each answer
-
-After each confirmed answer:
-1. Call `mcp__gdd_state__add_decision` with the decision payload. The tool assigns the next `D-NN` id and persists atomically. Format the summary as:
-   ```
-   [Category] Decision summary — short rationale
-   ```
-2. Append one JSON line to `.design/learnings/question-quality.jsonl` (create if absent):
-   ```json
-   {"ts":"<iso>","question_id":"Q-NN","question_text":"<verbatim>","answer_summary":"<one sentence>","quality":"high|medium|low|skipped","evidence":"<why>","cycle":"<active-cycle-slug>"}
-   ```
-   Quality classification: `skipped` if user picked Skip / "doesn't matter"; `low` if < 10 words and not a specific value; `medium` if hedged ("maybe", "I think", "not sure"); `high` otherwise.
-3. `add_decision` commits incrementally - the decision survives a crash mid-interview without an explicit save step.
-
-### 3.e - Produce DESIGN-CONTEXT.md
-
-When all questions are answered, write `.design/DESIGN-CONTEXT.md` summarizing the locked decisions, remaining gray areas, and any Figma-sourced tentatives that were confirmed or rejected. Set frontmatter `status: complete`.
-
----
-
-## Step 4 - Close out explore
-
-- If the synthesizer (or equivalent mapper batch) ran in Step 2, call `mcp__gdd_state__update_progress` with `task_progress: "<mappers-completed>/<mappers-total>"` and `status: "explore_mappers_done"` before advancing.
-- Call `mcp__gdd_state__checkpoint` - bumps `frontmatter.last_checkpoint` + appends a timestamp entry.
-- Stage advance to `plan` happens at the next stage's entry (the plan skill will transition from its own entry step); do not edit frontmatter directly from this skill.
-
-## After Writing
-
-```
-=== Explore complete ===
-Saved: .design/DESIGN.md, .design/DESIGN-DEBT.md, .design/DESIGN-CONTEXT.md
-Next: @get-design-done plan
-=========================
-```

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

@@ -1,30 +0,0 @@
----
-name: gdd-export
-description: "Packages a completed design cycle (.design artifacts + decisions + screenshots) into a stakeholder-shareable artifact - self-contained HTML, print-styled PDF (Paged.js-compatible), or a Notion page. Redacts secrets; --pseudonymize masks identity for external sharing; --pr posts the HTML preview as a PR comment. Use to hand a design-review packet to PMs/execs/brand who aren't in the repo."
-argument-hint: "<cycle-id> --format html|pdf|notion [--pseudonymize] [--pr]"
-user-invocable: true
-tools: Read, Write, Bash, Glob, Grep, ToolSearch, Task
----
-
-# /gdd:export
-
-Turns a completed cycle's in-repo design output into a shareable artifact. Closes the gap that `.design/*.md` lives only in the repo - stakeholders not in code can't consume it. The format contract + source set live in `../../reference/export-formats.md`; the Notion write-path in `../../connections/notion.md`.
-
-## Steps
-
-1. **Resolve the cycle.** `<cycle-id>` (or the current cycle from `.design/STATE.md`). Read the **source set**: `EXPERIENCE.md` (Phase 19.5), `.design/DESIGN.md`, `.design/DESIGN-VERIFICATION.md`, `.design/DESIGN-AUDIT.md` (if present), the decision log, and any Preview/Chromatic screenshots.
-2. **Redact (always) + pseudonymize (opt-in).** Pass every section through `scripts/lib/redact.cjs` (secrets). If `--pseudonymize`, additionally apply `scripts/lib/pseudonymize.cjs` (git identity / paths / hostname) for external sharing. Honor `GDD_DISABLE_NOTION` for the notion format.
-3. **Assemble per `--format`:**
-   - **`html`** (default) - `node -e "require('scripts/lib/export/build-html.cjs').buildHtml({...})"` → a **self-contained** HTML (inline CSS, base64-embedded screenshots, no external refs). Write to `.design/export/<cycle>.html`.
-   - **`pdf`** - the same `buildHtml({ ..., print: true })` (Paged.js-compatible `@page` print CSS). Write `.design/export/<cycle>.print.html`; instruct the user to render it via Paged.js / headless-Chrome (GDD ships **no** PDF runtime - D-02).
-   - **`notion`** - probe the Notion MCP (`ToolSearch({query:"notion"})`); if `available`, create a page from the same source (nested toggles + image upload) per `connections/notion.md`; if `not_configured`/disabled → degrade to the `html` format + a note.
-4. **`--pr`** - hand the generated HTML preview to `agents/pr-commenter.md` (via `Task`) to post as a PR comment (degrade-to-noop if no PR / pr-commenter unavailable).
-5. **Print the artifact path** (and the Notion URL / PR comment status when applicable).
-
-## Do Not
-
-- Do not add a PDF/markdown runtime dependency (`paged`/`puppeteer`/`pdfkit`/a markdown lib) - `build-html.cjs` is pure and the PDF is render-it-yourself print HTML (D-02).
-- Do not emit an un-redacted artifact - redact is mandatory; pseudonymize is the external-sharing opt-in.
-- Do not block on Notion/PR - both degrade to a noop / the html file.
-
-## EXPORT COMPLETE

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

@@ -1,114 +0,0 @@
----
-name: gdd-extract-learnings
-description: "Extracts project-specific design patterns and decisions from .design/ artifacts and writes them to .design/learnings/. Optionally proposes updates to reference/ files for user review."
-tools: Bash, Read, Write, Glob, Grep
----
-
-# /gdd:extract-learnings
-
-**Role:** Scan `.design/` artifacts for recurring patterns, successful decisions, and validated approaches. Write structured learnings to `.design/learnings/`. Optionally propose additions to tracked `reference/` files for the user to review and approve.
-
-## When to run
-
-- After `/gdd:complete-cycle` (auto-suggested by complete-cycle skill)
-- After a major verify/audit pass surfaces new patterns
-- Manually, to checkpoint what the project has learned
-
-## Protocol
-
-### Step 1 - Gather source artifacts
-
-Collect content from available `.design/` files:
-
-```bash
-ls .design/*.md 2>/dev/null
-```
-
-Read (if present): DESIGN-CONTEXT.md, DESIGN-VERIFICATION.md, DESIGN-DEBT.md, DESIGN-SUMMARY.md, CYCLES.md
-
-### Step 2 - Invoke gdd-learnings-extractor agent
-
-Delegate extraction to the `gdd-learnings-extractor` agent, passing it the list of available files. The agent extracts structured learning entries.
-
-### Step 3 - Write learnings artifact
-
-The agent writes or appends to `.design/learnings/LEARNINGS.md`.
-
-Layout of `.design/learnings/LEARNINGS.md`:
-
-```markdown
-# Project Learnings
-
-## <Category> — <Date>
-
-### L-<NN>: <Title>
-
-**Source:** <which .design/ file and section>
-**Pattern type:** decision | anti-pattern | validated-approach | token-convention | component-convention
-**Confidence:** high | medium | low
-**Summary:** <1-2 sentences>
-**Evidence:** <quote or paraphrase from source>
-**Proposed reference update:** <yes — see proposal below | no>
-
----
-```
-
-### Step 3b - Dual-emit atomic instinct units (Phase 51)
-
-Alongside the prose `LEARNINGS.md`, emit atomic instinct units for every learning the extractor tags as an `instinct-candidate`. A learning is an `instinct-candidate` when it states a single trigger plus a one-line response - the same shape the reflector emits. Broader narrative learnings stay prose-only.
-
-For each `instinct-candidate`, build a unit per `reference/instinct-format.md` (frontmatter: `id`, `trigger`, `confidence` from 0.3 to 0.9, `domain`, `scope`, `project_id`, `source`, `cycles_seen`, `first_seen`, `last_seen`, plus a short body). Set `source: extract-learnings`. Carry the learning's confidence (high / medium / low) into the numeric field (roughly 0.8 / 0.55 / 0.35), capped at 0.9.
-
-Write each unit through the store engine `scripts/lib/instinct-store.cjs` rather than by hand:
-
-```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/lib/instinct-store.cjs" add --scope project
-```
-
-If the engine exposes a module API only, drive `add(unit, { scope: 'project', baseDir })` from a short `node -e` script. The engine owns de-duplication and `cycles_seen` bookkeeping; do not pre-merge.
-
-The prose `LEARNINGS.md` is **retained read-only for one minor version** so existing readers keep working while tooling migrates to the units. Keep writing it; do not drop the prose path in this version.
-
-### Step 4 - Reference file proposal (optional)
-
-After writing LEARNINGS.md, check each learning entry with `Proposed reference update: yes`.
-
-For each such entry: generate a proposed addition to the appropriate `reference/` file (e.g., `reference/heuristics.md`, `reference/anti-patterns.md`).
-
-Print the proposal to the terminal and ask the user to review:
-
-```
-━━━ Reference update proposal ━━━
-
-Learning L-03 suggests adding to reference/anti-patterns.md:
-
-  ### Anti-pattern: Overloaded primary button
-  Using the primary button style for more than one action per screen
-  reduces clarity and violates Nielsen's heuristic #4 (consistency).
-  Evidence: DESIGN-VERIFICATION.md, cycle 3.
-
-Accept this update? [y/n/edit]
-```
-
-If user types `y`: write the addition to the reference file.
-If user types `n`: mark the learning as "proposal declined" in LEARNINGS.md.
-If user types `edit`: open the proposed text for the user to modify, then write.
-
-### Step 5 - Summary
-
-```
-━━━ Learnings extracted ━━━
-Source files scanned:    <N>
-Learnings written:       <N>
-Reference proposals:     <N>  (<M> accepted)
-Output: .design/learnings/LEARNINGS.md
-━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-## Required reading (conditional)
-
-@.design/intel/decisions.json (if present)
-@.design/intel/patterns.json (if present)
-@.design/learnings/LEARNINGS.md (if present)
-
-## EXTRACT-LEARNINGS COMPLETE

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

@@ -1,91 +0,0 @@
----
-name: gdd-fast
-description: "Trivial inline design task. No subagents, no planning documents, no pipeline stages. Just do the thing described. Activates for requests involving a single quick design fix, a one-shot change, or a fast targeted edit."
-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

@@ -1,64 +0,0 @@
----
-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

@@ -1,50 +0,0 @@
----
-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
-
-```
-Task("design-figma-writer", """
-mode: <annotate|tokenize|mappings>
-dry_run: <true|false>
-confirm_shared: <true|false>
-required_reading:
-  - .design/STATE.md
-  - .design/DESIGN-CONTEXT.md
-""")
-```
-
-Pass `mode` from the first positional argument; `dry_run` from `--dry-run`;
-`confirm_shared` from `--confirm-shared`. Wait for the agent's completion
-marker before returning.