@hegemonart/get-design-done 1.57.1 → 1.57.3

package/skills/router/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: gdd-router
-description: "Routes a /gdd command to fast|quick|full path + S|M|L|XL complexity_class and returns {path, complexity_class, model_tier_overrides, resolved_models, estimated_cost_usd, cache_hits}. Deterministic - no model call. Invoked once at command entry before any Agent spawn. Read by hooks/budget-enforcer.js."
+description: "Routes a /gdd command to fast|quick|full path + S|M|L|XL complexity_class and returns {path, complexity_class, model_tier_overrides, resolved_models, estimated_cost_usd, cache_hits}. Deterministic - no model call. Invoked once at command entry before any Agent spawn. Read by hooks/budget-enforcer.ts."
 argument-hint: "<intent-string> [<target-artifacts-csv>]"
 tools: Read, Bash, Grep
 ---
@@ -9,7 +9,7 @@ tools: Read, Bash, Grep
 
 ## 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.
+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.ts`) consumes your output on every `Agent` tool call.
 
 ## Invocation Contract
 

package/skills/synthesize/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: synthesize
-description: "Streaming synthesizer - collapses N parallel-agent markdown outputs into one compact merged summary via a single Haiku 4.5 call. Invoked inline by orchestrators (skills/map/, skills/discover/, skills/plan/) after parallel spawns return. Not user-invocable."
+description: "Streaming synthesizer - collapses N parallel-agent markdown outputs into one compact merged summary via a single Haiku 4.5 call. Invoked inline by orchestrators (skills/map/, skills/explore/, skills/plan/) after parallel spawns return. Not user-invocable."
 tools: Read, Task
 user-invocable: false
 disable-model-invocation: true

package/skills/turn-closeout/SKILL.md

@@ -9,7 +9,7 @@ tools: Read, Bash
 
 ## Role
 
-You are a deterministic **closeout** skill. You close the per-turn telemetry gap on runtimes that don't expose a Stop event (codex, gemini, and 11 others). You are a code-level mirror of `hooks/gdd-turn-closeout.js` (D-10): same conditions, same idempotence, same emitted event shape. The only difference: the JS hook emits the nudge as `additionalContext` via the harness; this skill prints the nudge directly to the user. See `./../new-cycle/milestone-completeness-rubric.md` §"Task level" for the broader closeout discipline (what "turn complete" means within a stage).
+You are a deterministic **closeout** skill. You close the per-turn telemetry gap on runtimes that don't expose a Stop event (codex, gemini, and 11 others). You are a code-level mirror of `hooks/gdd-turn-closeout.js` (D-10): same conditions, same idempotence, same emitted event shape. The only difference: the JS hook emits the nudge as `additionalContext` via the harness; this skill prints the nudge directly to the user. A turn is "complete" when the verify command exits 0, the `<done>` criterion is observable, and the diff stays within the declared scope - any deviation is logged for the run summary.
 
 **When to invoke:** orchestrator skills (`/gdd:next`, `/gdd:design`, `/gdd:verify`) tail-call this skill as their final step before returning. Adoption is incremental - each orchestrator can wire the tail-call independently; the skill exists as a stable, callable surface today.
 

package/skills/verify/verify-procedure.md

@@ -2,12 +2,11 @@
 name: verify-procedure
 type: meta-rules
 version: 1.0.0
-phase: 28.5
 tags: [verify, procedure, extracted, pipeline-stage, gap-loop, must-have, quality-gate]
 last_updated: 2026-05-18
 ---
 
-Source: extracted from `skills/verify/SKILL.md` (Phase 28.5 rework - D-10 extract-then-link).
+Source: extracted from `skills/verify/SKILL.md` to keep the SKILL focused on the essential workflow.
 The skill's essential workflow stays in `../skills/verify/SKILL.md`; this file holds the
 detail the agent reaches for when executing a specific step (state integration, quality-gate
 decision tree, agent spawn protocols, gap-response loop, must-have flipping).
@@ -28,9 +27,9 @@ methodology, agent prompts, and gap-loop semantics.
 1. `mcp__gdd_state__transition_stage` with `to: "verify"`.
 2. `mcp__gdd_state__get` → snapshot `state`. Read `state.must_haves` - this is the verification checklist; each M-XX starts at `status: pending` and will be flipped to `pass` or `fail` as verification concludes.
 
-#### Step 2.5 - Quality-gate gate (D-08, D-09)
+#### Step 2.5 - Quality-gate gate
 
-Before resume detection, inspect `state.quality_gate` from the same snapshot. The Stage 4.5 quality-gate skill (see `skills/quality-gate/SKILL.md`) writes a single `<run/>` element capturing the most recent run; this step is the verify-side consumer of that result. Three branches, evaluated in order:
+Before resume detection, inspect `state.quality_gate` from the same snapshot. The quality-gate skill (see `skills/quality-gate/SKILL.md`) writes a single `<run/>` element capturing the most recent run; this step is the verify-side consumer of that result. Three branches, evaluated in order:
 
 - **`state.quality_gate?.run?.status === "fail"`** → Refuse to advance. The fix loop in `quality-gate/SKILL.md` Step 4 reached `max_iters` without converging, and the verify stage MUST NOT paper over it. Print a blocker reason that includes the iteration count and the `commands_run` field from the run, then call:
 
@@ -43,9 +42,9 @@ Before resume detection, inspect `state.quality_gate` from the same snapshot. Th
 
   Exit immediately with the failure surface visible to the user. Do NOT call `mcp__gdd_state__update_progress` to open the verify stage; the gate refused entry, so the stage was never opened.
 
-- **`state.quality_gate?.run?.status === "timeout"` OR `=== "skipped"`** → Print a one-line warning naming the status and the `commands_run` value, then continue normally. Per D-07 these are signals, not walls: a slow test suite must not hostage the pipeline, and a project with no detectable quality commands must not block verify entry. The warning surfaces the degraded state without halting.
+- **`state.quality_gate?.run?.status === "timeout"` OR `=== "skipped"`** → Print a one-line warning naming the status and the `commands_run` value, then continue normally. These are signals, not walls: a slow test suite must not hostage the pipeline, and a project with no detectable quality commands must not block verify entry. The warning surfaces the degraded state without halting.
 
-- **`state.quality_gate?.run?.status === "pass"` OR `state.quality_gate === null`** → Continue silently. `pass` is the happy path; `null` means the gate has never been run for this cycle (the user skipped Stage 4.5 entirely, which is permitted - verify only *checks* the gate result, never *runs* the gate itself, per the 25-07 out-of-scope clause).
+- **`state.quality_gate?.run?.status === "pass"` OR `state.quality_gate === null`** → Continue silently. `pass` is the happy path; `null` means the gate has never been run for this cycle (the user skipped the quality-gate stage entirely, which is permitted - verify only *checks* the gate result, never *runs* the gate itself).
 
 This step is a pure read against the snapshot already loaded in Step 2 - no extra MCP call is required.
 
@@ -93,7 +92,7 @@ Step P2 — Live tool call:
 Record the preview probe result via `mcp__gdd_state__probe_connections` (batched with the storybook and chromatic probes below — one call per stage, see "Batched connections write" at the end of this section).
 ```
 
-When `preview: available`, the design-verifier agent runs Phase 4B - Screenshot Evidence to resolve `? VISUAL` heuristic flags with real screenshot evidence. See `agents/design-verifier.md` Phase 4B for the screenshot evidence loop.
+When `preview: available`, the design-verifier agent runs Stage 4B - Screenshot Evidence to resolve `? VISUAL` heuristic flags with real screenshot evidence. See `agents/design-verifier.md` Stage 4B for the screenshot evidence loop.
 
 ### Probe Storybook connection
 
@@ -202,7 +201,7 @@ Initialize iteration counter to 0 (used for fix loop limit in Step 3).
 
 Three agents run in sequence. Each waits for its completion marker before the next is spawned.
 
-**Note on lazy gates (Plan 10.1-04 / D-21):** Each full checker is preceded by a cheap Haiku gate that reads the diff and may return `{spawn: false}` to short-circuit. When gated out, `lazy_skipped: true` is appended to `.design/telemetry/costs.jsonl`. Gates: `design-verifier-gate` (before 1b), `design-integration-checker-gate` (before 1c). `design-context-checker-gate` is wired into `skills/discover/SKILL.md` Step 1.75.
+**Note on lazy gates:** Each full checker is preceded by a cheap Haiku gate that reads the diff and may return `{spawn: false}` to short-circuit. When gated out, `lazy_skipped: true` is appended to `.design/telemetry/costs.jsonl`. Gates: `design-verifier-gate` (before 1b), `design-integration-checker-gate` (before 1c). `design-context-checker-gate` is wired into `skills/discover/SKILL.md` Step 1.75.
 
 ### 1a. Run design-auditor first (retrospective 7-pillar audit)
 
@@ -274,9 +273,9 @@ Task("design-verifier", """
 You are the design-verifier agent. Run the 5-phase verification against completed design work.
 
 DESIGN-AUDIT.md (above) contains a retrospective 7-pillar qualitative audit from design-auditor.
-Read it as supplementary signal — incorporate the priority fix list into your Phase 5 gap analysis
+Read it as supplementary signal — incorporate the priority fix list into your Stage 5 gap analysis
 where relevant. The auditor's 1-4 scores complement your 0-10 category scores; they do not
-replace your Phase 1 category scoring.
+replace your Stage 1 category scoring.
 
 Context:
   auto_mode: <true|false>
@@ -432,7 +431,7 @@ Task("design-fixer", """
 @.design/DESIGN-CONTEXT.md
 </required_reading>
 
-Fix all BLOCKER and MAJOR gaps from ## Phase 5 - Gaps in DESIGN-VERIFICATION.md.
+Fix all BLOCKER and MAJOR gaps from ## Stage 5 - Gaps in DESIGN-VERIFICATION.md.
 For each gap: apply the targeted fix to the file/location in the gap's Location field.
 After each fix, make an atomic commit: fix(design-gap-GNN): [gap title].
 

package/skills/warm-cache/SKILL.md

@@ -62,7 +62,7 @@ Full + filtered command-output examples live in `./../cache-manager/cache-policy
 
 - **Pre-sprint**: `/gdd:warm-cache` is the recommended first line of a `/gdd:discover`, `/gdd:plan`, or `/gdd:verify` sprint. Users type it before the real command, or an orchestrator-level wrapper runs it automatically if `agent-metrics.json` (Plan 10.1-05) indicates the last sprint was > 5 min ago.
 - **`reference/shared-preamble.md`** (authored in Plan 10.1-04) is the essential file for this command - agents import it first per D-17, which makes the first N tokens of every agent's rendered system prompt identical, which is what Anthropic's prompt cache keys on.
-- **No interaction with `hooks/budget-enforcer.js`** - the hook is a PreToolUse gate; warm-cache runs as an ordinary Agent tool call itself and is subject to the hook (each no-op Haiku ping is budgeted and logged like any other spawn). This is intentional: warm-cache's own telemetry rows in `.design/telemetry/costs.jsonl` are the evidence that cache priming happened.
+- **No interaction with `hooks/budget-enforcer.ts`** - the hook is a PreToolUse gate; warm-cache runs as an ordinary Agent tool call itself and is subject to the hook (each no-op Haiku ping is budgeted and logged like any other spawn). This is intentional: warm-cache's own telemetry rows in `.design/telemetry/costs.jsonl` are the evidence that cache priming happened.
 
 ## Cost Model
 

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

@@ -1,48 +0,0 @@
----
-name: gdd-add-backlog
-description: "Park a design idea for a future cycle. Writes to .design/backlog/BACKLOG.md."
-argument-hint: "[text]"
-tools: Read, Write, AskUserQuestion
-disable-model-invocation: true
----
-
-# /gdd:add-backlog
-
-**Role:** Long-term parking lot for design ideas. Backing store: `.design/backlog/BACKLOG.md`.
-
-## Step 1 - Get text
-
-If `$ARGUMENTS` is empty, ask the user: "What should be added to the backlog?"
-
-## Step 2 - Append
-
-Create `.design/backlog/` directory and `BACKLOG.md` with `# Design Backlog` header if missing.
-
-Derive `<title>` = first 60 characters of the text (strip newlines). Append:
-
-```markdown
-## <title>
-**Added**: YYYY-MM-DD
-**Status**: parked
-
-<full text>
-
----
-```
-
-## Output
-
-```
-━━━ Backlog entry parked ━━━
-Title: <title>
-Status: parked
-Promote later via: /gdd:review-backlog
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-## Constraints
-
-- Do not modify files outside `.design/backlog/`.
-- Do not set status to anything other than `parked` here - `/gdd:review-backlog` owns status transitions.
-
-## ADD-BACKLOG COMPLETE

package/dist/claude-code/.claude/skills/analyze-dependencies/SKILL.md

@@ -1,95 +0,0 @@
----
-name: gdd-analyze-dependencies
-description: "Queries the intel store to surface token fan-out, component call-graphs, decision traceability, and circular dependency detection. Requires .design/intel/ to exist (run build-intel.cjs first)."
-tools: Bash, Read, Glob, Grep
----
-
-# /gdd:analyze-dependencies
-
-**Role:** Surface dependency relationships, token usage spread, component graphs, and decision traceability using `.design/intel/`. All queries are O(1) reads against pre-built JSON slices - no file greps. See `./reference/heuristics.md` for the underlying dependency-analysis heuristics (fan-out thresholds, orphan-token criteria, cycle-detection bias).
-
-## Pre-flight
-
-Verify the intel store exists:
-
-```bash
-ls .design/intel/files.json 2>/dev/null && echo "ready" || echo "missing"
-```
-
-If missing, print:
-
-```
-Intel store not found. Build it first:
-  node scripts/build-intel.cjs --force
-Then re-run /gdd:analyze-dependencies.
-```
-
-## Usage modes
-
-- `/gdd:analyze-dependencies` - run all four analyses and print a combined report
-- `/gdd:analyze-dependencies tokens` - token fan-out only
-- `/gdd:analyze-dependencies components` - component call-graph only
-- `/gdd:analyze-dependencies decisions` - decision traceability only
-- `/gdd:analyze-dependencies circular` - circular dependency detection only
-
-## Analysis 1 - Token fan-out
-
-Surfaces tokens referenced in many files + orphans (referenced exactly once).
-
-1. Read `.design/intel/tokens.json`; group by `token` value; count distinct `file` values.
-2. Sort descending; print top-20 with token / file count / category columns.
-3. Append orphans list (token + file:line of the single reference).
-
-Header: `━━━ Token fan-out ━━━` … `(top 20 shown)` … `Orphaned tokens (referenced in exactly 1 file):` … footer rule.
-
-## Analysis 2 - Component call-graph
-
-Surfaces widely-referenced components and the files referencing each.
-
-1. Read `.design/intel/components.json`; group by `component` name; count distinct `file` values.
-2. Sort descending; print top-20 with component / references / files columns.
-3. If `components <Name>` is passed, print only that component's referencing files (one per line).
-
-Header: `━━━ Component call-graph ━━━` … footer rule.
-
-## Analysis 3 - Decision traceability
-
-Maps decisions to skill/agent files that cite them.
-
-1. Read `.design/intel/decisions.json` (decision IDs D-01, D-02, …).
-2. Read `.design/intel/symbols.json` for heading anchors; `.design/intel/dependencies.json` for @-reference chains.
-3. For each decision, cross-reference which files cite the ID.
-4. Print per-decision block: `D-NN  <description>` then a 6-space-indented `Referenced by: <file:line>, …` line (or `(no explicit references found)`).
-5. Footer: `Total: N decisions tracked, M with file references`.
-
-Empty-state: `No decisions indexed. Run node scripts/build-intel.cjs after creating .design/DESIGN-CONTEXT.md.`
-
-## Analysis 4 - Circular dependency detection
-
-Detects cycles in the `@`-reference graph (File A → File B → File A). DFS with path-tracking detects back-edges; algorithm + adjacency-map shape detailed in `./reference/heuristics.md` §"Dependency-cycle detection".
-
-1. Read `.design/intel/graph.json`; build adjacency map from `edges`.
-2. Run DFS with path-tracking; collect back-edges as cycles.
-3. Print each cycle with the node sequence + `<- CYCLE` marker on the closing node.
-4. Footer: `Total cycles: N` (or `All clear — no circular dependencies detected.`).
-
-## Combined report
-
-When run without a mode argument, print all four analyses in sequence separated by blank lines, prefixed with:
-
-```
-━━━ Dependency Analysis ━━━
-Intel store: .design/intel/
-Generated:   <timestamp from files.json>
-Files indexed: <count>
-```
-
-## Required reading (conditional)
-
-@.design/intel/tokens.json (if present)
-@.design/intel/components.json (if present)
-@.design/intel/dependencies.json (if present)
-@.design/intel/decisions.json (if present)
-@.design/intel/graph.json (if present)
-
-## ANALYZE-DEPENDENCIES COMPLETE

package/dist/claude-code/.claude/skills/apply-reflections/SKILL.md

@@ -1,109 +0,0 @@
----
-name: gdd-apply-reflections
-description: "Review and selectively apply proposals from .design/reflections/<cycle-slug>.md. Diffs each proposal, prompts user to accept/skip/edit, then writes changes."
-argument-hint: "[--cycle <slug>] [--filter <FRONTMATTER|REFERENCE|BUDGET|QUESTION|GLOBAL-SKILL>] [--dry-run]"
-tools: Read, Write, Edit, Bash, Glob
----
-
-# /gdd:apply-reflections
-
-Interactive proposal review loop. Reads `.design/reflections/<cycle-slug>.md`, walks each numbered proposal, and applies accepted ones to the appropriate target file. Nothing is applied without explicit user confirmation.
-
-## Steps
-
-### 1. Resolve reflections file
-
-- If `--cycle <slug>` given: load `.design/reflections/<slug>.md`
-- Else: glob `.design/reflections/*.md`, sort by modified time descending, load the most recent
-- If no file found: error "No reflections found. Run `/gdd:reflect` first."
-- Print: "Reviewing reflections: <filename>"
-
-### 2. Parse proposals
-
-Scan file for lines matching `### Proposal N — [TYPE] ...`. Extract each proposal block (Why / Change / Risk).
-
-If `--filter <TYPE>` given: skip proposals whose type tag doesn't match.
-
-Print: "Found N proposals (N after filter)."
-
-### 3. Review loop
-
-For each proposal (in order):
-
-Print the full proposal block:
-```
-─────────────────────────────────────────
-Proposal N/TOTAL — [TYPE] Title
-Risk: low|medium
-
-Why: ...
-Change: ...
-─────────────────────────────────────────
-(a) apply   (s) skip   (e) edit   (q) quit
-```
-
-If `--dry-run`: print `[dry-run — would prompt here]` and continue to next proposal without prompting.
-
-Based on user choice:
-- **a** - apply (see Apply Logic below)
-- **s** - mark proposal as `**Reviewed: skipped**` in the reflections file; continue
-- **e** - show the Change text, ask user to provide edited version, then apply the edited version
-- **q** - stop processing; print "Stopped at proposal N. Resume with `/gdd:apply-reflections --cycle <slug>`."
-
-### 4. Apply Logic by Proposal Type
-
-After the user chooses `a` (apply) or `e` (edit-then-apply), branch on the proposal's bracketed type tag and follow the per-type apply procedure in `./apply-reflections-procedure.md` - one numbered procedure each for `[FRONTMATTER]`, `[REFERENCE]`, `[BUDGET]`, `[QUESTION]`, `[GLOBAL-SKILL]`. All branches end with `**Applied**: <date>` appended to the proposal block in the reflections file.
-
-### 5. Summary
-
-After all proposals processed (or `q`):
-```
-─────────────────────────────────────────
-Apply-reflections complete
-  Applied:  N
-  Skipped:  N
-  Remaining: N (run again to continue)
-─────────────────────────────────────────
-```
-
-## [INCUBATOR]
-
-Incubator drafts authored by `scripts/lib/incubator-author.cjs` (Phase 29-04) appear as a distinct proposal class. For each draft under `.design/reflections/incubator/<slug>/`, use `scripts/lib/apply-reflections/incubator-proposals.cjs`:
-
-1. `discoverIncubatorDrafts()` → list pending drafts.
-2. `renderProposal(draft)` → show full body + diff + origin signals.
-3. User chooses **accept** | **reject** | **defer** | **edit**.
-4. **accept** - scope-guard runs FIRST (`validateScope` from `scripts/validate-incubator-scope.cjs`); `applyAccept` then promotes draft → `agents/<slug>.md` or `skills/<slug>/SKILL.md` and appends a registry entry. Single-step per D-04.
-5. **reject** - `applyReject` removes the incubator subdir.
-6. **defer** - no-op; draft re-surfaces next run.
-7. **edit** - `applyEdit` opens `$EDITOR`; re-prompt user on close.
-
-**Stage-1 gate.** At session start, call `checkStage1Gate()`. If `thresholdMet && !optInRecorded`, display the opt-in prompt once. NEVER auto-flip per D-01 - recording opt-in requires explicit user confirmation via `recordOptIn()`. Full procedure: `./apply-reflections-procedure.md` §[INCUBATOR].
-
-## [KFM-CANDIDATE]
-
-KFM-catalogue proposals authored by `scripts/lib/reflector-kfm-proposer.cjs` (Phase 30.5-03 D-05) appear as a 6th proposal class. Drafts at `.design/reflections/incubator/kfm-<slug>/CATALOGUE-ENTRY.md`; pre-filled 11-field schema with `TODO:` placeholders for `pattern` + `fix`. Two upstream signals share the surface (D-06): `capability_gap` clusters (≥3, no existing match) + `kfm-candidate` events (whitelist-matched articles, 1-shot). User chooses **accept** | **reject** | **defer** | **edit**. `applyAccept` appends to `reference/known-failure-modes.md` + `reference/registry.json` (`origin: incubator-kfm`); `applyReject` removes the incubator subdir; `applyDefer` stamps `deferred_until`; `applyEdit` returns the draft path for `$EDITOR`. Full procedure: `./apply-reflections-procedure.md` §[KFM-CANDIDATE].
-
-## [INSTINCT]
-
-Atomic instinct units emitted by `design-reflector` (and surfaced from `/gdd:extract-learnings`) appear as a distinct proposal class, alongside `[INCUBATOR]` and `[KFM-CANDIDATE]`. Each unit is a fenced `yaml` block under the reflector's `## Atomic instincts` section, shaped per `reference/instinct-format.md` (`id`, `trigger`, `confidence`, `domain`, `scope`, `project_id`, `source`, `cycles_seen`, `first_seen`, `last_seen`, plus a short body). A unit is a proposal, never a stored fact - nothing lands until the user accepts it.
-
-Mirror the `[INCUBATOR]` flow:
-
-1. Discover the units: parse every `yaml` block under `## Atomic instincts` in the reflections file. Skip malformed blocks (warn on stderr, keep going).
-2. For each unit: show the parsed `trigger`, `domain`, `confidence`, and body so the user sees what would be stored.
-3. Prompt: `(a) accept   (r) reject   (d) defer   (e) edit   (q) quit`.
-
-**Per-action behavior:**
-
-1. **accept** - call `scripts/lib/instinct-store.cjs` `add(unit, { scope, baseDir })` with the unit at its emitted `confidence`. The store owns de-duplication and `cycles_seen` bookkeeping. On success print `Stored instinct <id> (<domain>, confidence <n>).` and append `**Applied**: <date>` to the proposal block.
-2. **reject** - do not store the unit. Append `**Reviewed: rejected**` to the reflections file.
-3. **defer** - no-op; the unit re-surfaces next run. Append `**Reviewed: deferred**`.
-4. **edit** - let the user adjust `trigger`, `confidence`, or `domain`, then accept the edited unit through the same `add(...)` call. Default `scope: 'project'` (write `global` only when the unit's frontmatter says so); never edit `.design/instincts/instincts.json` directly, and promote to global via the separate gated `/gdd:instinct promote`.
-
-## Do Not
-
-- Do not apply any proposal without the user explicitly choosing `a` or `e`.
-- Do not modify source code files (`.ts`, `.tsx`, `.css`, `.js`) - only agent files, reference files, budget.json, discussant questions, global skills, and incubator drafts.
-- Do not re-run the reflector - this skill only applies existing proposals.
-- Do not bypass the scope guard or auto-flip Stage-1 - both are non-negotiable per D-05 / D-01.

package/dist/claude-code/.claude/skills/apply-reflections/apply-reflections-procedure.md

@@ -1,170 +0,0 @@
----
-name: apply-reflections-procedure
-type: heuristic
-version: 1.3.0
-phase: 30.5
-tags: [apply-reflections, proposal, frontmatter, reference, budget, question, global-skill, incubator, kfm-candidate]
-last_updated: 2026-05-21
----
-
-# Apply-Reflections - Per-Type Procedure
-
-Extracted from `skills/apply-reflections/SKILL.md` per Phase 28.5 D-10 (extract-then-link,
-never delete content). The orchestrator loop in `apply-reflections` (resolve file → parse →
-review loop → summary) stays in the SKILL. The per-proposal-type apply logic below moves
-here because it is content-class methodology, not workflow.
-
-## Apply Logic by Proposal Type
-
-After the user chooses `a` (apply) or `e` (edit-then-apply) in the review loop, branch by
-the proposal's bracketed type tag.
-
-### [FRONTMATTER]
-
-1. Extract agent name from Change field (e.g., `agents/design-verifier.md`)
-2. Read the agent file
-3. Find the frontmatter line matching the field being changed
-4. Use Edit tool to update the specific line
-5. Append `**Applied**: <date>` to the proposal in reflections file
-
-### [REFERENCE]
-
-1. Extract target file path from Change field (e.g., `reference/heuristics.md`)
-2. If file exists: append the drafted text using Edit tool
-3. If file doesn't exist: create it with a minimal header + the drafted text using Write tool
-4. Append `**Applied**: <date>` to proposal in reflections file
-
-### [BUDGET]
-
-1. Read `.design/budget.json`
-2. Locate the key path from the Change field (e.g., `design-verifier.per_run_cap_usd`)
-3. Update the value
-4. Write updated JSON back to `.design/budget.json`
-5. Append `**Applied**: <date>` to proposal in reflections file
-
-### [QUESTION]
-
-1. Read `agents/design-discussant.md`
-2. Find the question text specified in the Change field
-3. If pruning: remove the question lines using Edit tool
-4. If rewording: replace the question text using Edit tool
-5. Append `**Applied**: <date>` to proposal in reflections file
-
-### [GLOBAL-SKILL]
-
-1. Extract target filename from Change field (e.g., `design-color-conventions.md`)
-2. Ensure `~/.claude/gdd/global-skills/` directory exists (create with `mkdir -p` if not)
-3. If target file exists: append new content using Edit tool (add a `---` separator first)
-4. If target file doesn't exist: create with header + content using Write tool:
-
-   ```markdown
-   # <Topic> Conventions (Global)
-   *Promoted from project: <project-name>, cycle: <cycle-slug>*
-
-   <content>
-   ```
-
-5. Print: "Global skill written to ~/.claude/gdd/global-skills/<name>.md - auto-loads in all future gdd sessions"
-6. Append `**Applied**: <date>` to proposal in reflections file
-
-### [INCUBATOR]
-
-Incubator drafts come from `scripts/lib/incubator-author.cjs` (Phase 29-04). They live at
-`.design/reflections/incubator/<slug>/` and contain `manifest.json` + `DRAFT.md` + (optional) `ORIGIN.md`.
-
-Use `scripts/lib/apply-reflections/incubator-proposals.cjs` for all actions.
-
-**Discovery + render** (once per cycle):
-
-1. Call `discoverIncubatorDrafts()` → `Array<Draft>`. Skip malformed entries silently (already warned on stderr by the helper).
-2. For each draft: call `renderProposal(draft)` and print the returned markdown block. The user sees a header (slug + kind), a diff vs the nearest existing artifact (or "net-new"), an Origin section listing capability-gap signals, and the full draft body.
-3. Prompt: `(a) accept   (r) reject   (d) defer   (e) edit   (q) quit`.
-
-**Per-action behavior:**
-
-1. **accept** - call `applyAccept(draft, { registryPath, repoRoot })`.
-   - The helper calls `validateScope(draft.target_path)` from `scripts/validate-incubator-scope.cjs` **before** any write. Out-of-scope paths throw and the registry stays untouched. This is the non-bypassable scope guard (D-05).
-   - On success: target artifact written, `reference/registry.json` appended with `{ slug, path, added, origin: 'incubator' }`, incubator subdir removed last (T-29.05-04 - partial-failure leaves draft retryable).
-   - Print: "Accepted - promoted to <target_path>; registered."
-   - Append `**Applied**: <date>` to the proposal block.
-
-2. **reject** - call `applyReject(draft)`. Only the incubator subdir is removed; registry is untouched. Append `**Reviewed: rejected**` to the reflections file.
-
-3. **defer** - no-op. Print "Deferred - draft re-surfaces next run." Append `**Reviewed: deferred**`.
-
-4. **edit** - call `applyEdit(draft)` (uses `$EDITOR` or the `editorCmd` array option). On clean exit, the helper reloads the draft and the caller re-runs `renderProposal` + the prompt. On non-zero exit, the original draft is preserved unchanged.
-
-**Stage-1 gate (D-01 - no auto-flip):**
-
-1. At the start of the cycle, call `checkStage1Gate({ gateSpecPath, statePath, registryPath })`. The call is **read-only** - never mutates state. The returned `{ thresholdMet, summary, optInRecorded }` is informational.
-2. If `thresholdMet && !optInRecorded`, surface a one-time prompt:
-   ```
-   Stage-1 capability-gap authoring threshold met: <summary>
-   Enable incubator-draft promotion?  (y/N)
-   ```
-3. **Only on explicit `y`**, call `recordOptIn({ statePath, confirmedBy })`. The function is idempotent - a second call detects the existing record and returns `{ alreadyRecorded: true }`. Never call it on any other input.
-
-**Why this is gated.** The `[INCUBATOR]` proposal class can write executable surface (agents + skills) into the plugin runtime. Both Phase 29 D-01 (no auto-flip) and D-05 (scope guard) exist because that surface has integration-test and security implications that exceed reflector autonomy. `validateScope` keeps the file landing zone confined to `agents/<slug>.md` or `skills/<slug>/SKILL.md`. The Stage-1 gate keeps the *whether* of opting in to incubator authoring under explicit user control even after the data threshold says we have enough signal.
-
-**Bandit-fairness gate on `accept` (Phase 29 Plan 06 / CONTEXT D-04).**
-
-When the `accept` action promotes an incubator draft, the bandit-router arms for the freshly-promoted agent/skill MUST be bootstrapped with `prior_class: 'promoted_incubator'`. This invokes a conservative `Beta(2, 8)` bootstrap prior (posterior mean 0.2) instead of the optimistic Phase 23.5 informed prior - the bandit-fairness gate IS the staging mechanism (D-04: no separate two-step ratify split). The conservative prior suppresses preferential selection until ~8-10 successful pulls accumulate.
-
-Call shape (whether eagerly invoked on promotion or via first-pull lazy bootstrap):
-
-```javascript
-const bandit = require('./scripts/lib/bandit-router.cjs');
-// Per arm bootstrapped for the freshly-promoted agent:
-bandit.update({
-  agent: '<promoted-slug>',
-  bin: '<touches-bin>',
-  tier: '<chosen-tier>',
-  reward: <bernoulli>,
-  prior_class: 'promoted_incubator',  // Phase 29 Plan 06 / D-04 — Beta(2,8) staging
-});
-// Or for the delegate-aware case (Plan 27-07):
-bandit.updateWithDelegate({
-  agent: '<promoted-slug>',
-  bin: '<touches-bin>',
-  tier: '<chosen-tier>',
-  delegate: '<peer-cli-or-none>',
-  reward: <bernoulli>,
-  prior_class: 'promoted_incubator',
-});
-```
-
-Omitting `prior_class` reverts to Phase 23.5 informed-prior bootstrap (non-breaking). The reward math is unchanged - `prior_class` only affects bootstrap.
-
-### [KFM-CANDIDATE]
-
-Known-failure-mode catalogue proposals come from `scripts/lib/reflector-kfm-proposer.cjs` (Phase 30.5-03 D-05). They live at `.design/reflections/incubator/kfm-<slug>/CATALOGUE-ENTRY.md` and contain a single fenced ```yaml block pre-filled with the Phase 30.5 schema-v2 11-field shape (`id` + `pattern` + `diagnosis` + `remedy` + `severity` + `propose_report` + `symptom` + `root_cause` + `fix` + `related_phases` + `first_observed_cycle`). Two of those — `pattern` and `fix` — are `TODO:` placeholders the reflector cannot infer; the user fills them via the **edit** action before accepting.
-
-Two upstream signals share this draft surface (D-06):
-- `capability_gap` clusters of size ≥3 with no existing-entry match (Phase 29-03 aggregator + `failure-mode-matcher.match()`).
-- `kfm-candidate` events from the Phase 30.5-03 Task 2 authority-watcher whitelist (D-06 - single events bypass the ≥3 gate).
-
-Use `scripts/lib/reflector-kfm-proposer.cjs` for all actions:
-
-**Discovery + render** (once per cycle):
-
-1. Glob `.design/reflections/incubator/kfm-*/CATALOGUE-ENTRY.md` → list pending KFM drafts.
-2. For each draft: read the body, show the origin header (source, parent event ids OR article url) + the proposed yaml block.
-3. Prompt: `(a) accept   (r) reject   (d) defer   (e) edit   (q) quit`.
-
-**Per-action behavior:**
-
-1. **accept** - call `applyAccept(draftPath, { repoRoot })`.
-   - The helper re-stamps the proposed `id` with the next available `KFM-NNN` from the catalogue (avoids collisions when multiple drafts promote in the same run).
-   - Appends a `### KFM-NNN — <symptom heading>` section into `reference/known-failure-modes.md` with the yaml block intact.
-   - Appends a `reference/registry.json` entry: `{ name: 'known-failure-modes/kfm-NNN', path: 'reference/known-failure-modes.md', type: 'failure-mode', phase: 30.5, origin: 'incubator-kfm', added: '<ISO date>' }`.
-   - Removes the incubator subdir LAST (partial-failure leaves the draft retryable).
-   - Print: "Accepted - promoted to KFM-NNN in reference/known-failure-modes.md."
-   - Append `**Applied**: <date>` to the proposal entry (when surfaced from a reflections file).
-
-2. **reject** - call `applyReject(draftPath)`. Only the incubator subdir is removed; catalogue + registry untouched. Print: "Rejected - draft removed."
-
-3. **defer** - call `applyDefer(draftPath, { deferredUntil })` where `deferredUntil` is an ISO date (default: today + 30d). The helper stamps `deferred_until: <ISO>` into the draft body. Print: "Deferred - draft re-surfaces next run."
-
-4. **edit** - call `applyEdit(draftPath)` which returns the draft path. The caller opens `$EDITOR` on the path; on clean exit, re-discover the draft and re-prompt. Typical edits: replace `pattern: 'TODO: ...'` with a conservative regex, replace `fix: 'TODO: ...'` with a step-by-step user-runnable remedy, set `severity` if `medium` default is wrong.
-
-**Why this is gated.** `reference/known-failure-modes.md` feeds Phase 30's `triage-matcher.cjs` BEFORE the consent prompt - a bad entry could mute legitimate issue reports. The user-review gate is non-negotiable (D-05). The proposer is strictly proposal-only; the canonical catalogue only changes via the accept action.

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

@@ -1,79 +0,0 @@
----
-name: gdd-audit
-description: "Run a design audit by spawning design-auditor, design-integration-checker, and (optionally) design-verifier + design-reflector agents, then printing a consolidated 7-pillar score summary. Use when the user wants to score the current design, retroactively verify a completed cycle, or quickly re-check after a fix. Activates for requests involving scoring an existing design, retroactively reviewing quality, or re-checking after a fix."
-argument-hint: "[--retroactive] [--quick] [--no-reflect]"
-tools: Read, Write, Task, Glob, Bash
----
-
-# /gdd:audit
-
-Wraps the existing `design-auditor`, `design-verifier`, and `design-integration-checker` agents - no new auditor logic here. Parses flags, spawns the right combination, prints summary.
-
-For the 7-pillar scoring rubric this skill aggregates, see `../../reference/audit-scoring.md`. For the shared design-quality pillar set that frames the score categories, see `../../reference/shared-preamble.md`.
-
-## Modes
-
-### Default
-Spawn `design-auditor` (7-pillar scoring 1–4) in parallel with `design-integration-checker`. After both finish, read `.design/DESIGN-AUDIT.md` and `.design/DESIGN-INTEGRATION.md` and print a consolidated summary (scores + top 3 findings each).
-
-After the auditor and integration checker complete, check if `.design/learnings/` exists and contains at least one `.md` file. If so - and unless `--no-reflect` is passed - spawn `design-reflector` for the current cycle. Append the reflection proposal count to the audit summary: "Reflection: N proposals → review with `/gdd:apply-reflections`".
-
-### `--retroactive`
-Spawn `design-verifier` with cycle-span scope. Verifier reads all tasks completed in the current cycle (from STATE.md `<completed_tasks>` list for the active `cycle:` ID) and uses `DESIGN-PLAN.md` goals as the reference baseline for what "should have been done." Output: `.design/DESIGN-VERIFICATION.md` with per-task pass/fail.
-
-### `--quick`
-Run only `design-auditor` (skip `design-integration-checker`). Faster health check when integration isn't the concern.
-
-## Steps
-
-1. Parse args for `--retroactive`, `--quick`, and `--no-reflect`.
-2. Verify `.design/STATE.md` exists; abort if not (suggest `/gdd:new-project`).
-3. Spawn the appropriate agents (Task tool). Default and `--retroactive` spawn two agents; `--quick` spawns one.
-4. Wait for completion, then read each output file and print a summary:
-   - Auditor scores per pillar
-   - Integration check pass/fail
-   - Verifier pass/fail per task (retroactive mode)
-5. **Reflection step** (default + retroactive modes only, skipped with `--no-reflect` or `--quick`):
-   - Check if `.design/learnings/` exists and has ≥1 `.md` file
-   - If yes: spawn `design-reflector` for the current cycle slug (read from STATE.md)
-   - After completion: count proposal types and append to summary
-6. Recommend next action based on findings (e.g., "Score 2/4 on typography - run `/gdd:discuss typography` to gather decisions").
-
-## Registered Audit Agents
-
-| Agent | Trigger | Output |
-|---|---|---|
-| `design-auditor` | Default, retroactive | `.design/DESIGN-AUDIT.md` |
-| `design-integration-checker` | Default, retroactive | `.design/DESIGN-INTEGRATION.md` |
-| `design-verifier` | `--retroactive` only | `.design/DESIGN-VERIFICATION.md` |
-| `design-reflector` | Default + retroactive when learnings exist | `.design/reflections/<slug>.md` |
-
-## Do Not
-
-- Do not modify source files.
-- Do not rerun stages; this is a read-only audit.
-
-## Step 7 - Update notice (post-closeout surface)
-
-After the consolidated audit summary has been printed (and any reflection-proposal count appended), 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.
-
-## Rationalizations - Thought to Reality
-
-The excuses an agent reaches for to skip or thin out an audit, and the drift each one misses:
-
-| Thought | Reality |
-|---------|---------|
-| "The audit passed last cycle, I can skip it this cycle." | Per-cycle audit catches drift the prior pass couldn't see; a skipped review is exactly where regressions accumulate unnoticed. |
-| "`--quick` is fine, integration isn't the concern here." | Dropping the integration-checker hides orphaned decisions - wiring breaks even when the 7-pillar score looks healthy. |
-| "I can eyeball the scores instead of spawning the auditor." | The auditor's rubric scores seven pillars consistently; an eyeballed review drifts toward whatever the agent already believes. |
-| "Reflection proposals are optional polish, skip the reflector." | The reflector turns this cycle's learnings into next-cycle improvements; skipping it lets the same mistakes repeat. |
-| "I'll modify the source while I'm in here fixing findings." | Audit is read-only by contract; editing source mid-audit invalidates the very scores you're producing. |
-| "Retroactive mode is overkill for a finished cycle." | Retroactive verification is the only check on tasks that shipped without per-task verify - skipping it leaves a completed cycle unaudited. |
-
-## AUDIT COMPLETE