@hegemonart/get-design-done 1.0.7

package/skills/progress/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: gdd-progress
+description: "Shows current pipeline position and routes to next action. --forensic runs 6-check integrity audit."
+argument-hint: "[--forensic]"
+tools: Read, Bash, Grep, Glob
+---
+
+# /gdd:progress
+
+**Role:** Show current position in the pipeline and recommend the next action. With `--forensic`, run a 6-check integrity audit.
+
+## Step 1 — Read state
+
+Read `.design/STATE.md`. Extract:
+- `stage:`, `cycle:`, `last_checkpoint`
+- `<position>` `task_progress`, `status`
+- D-XX count, open todos from `.design/TODO.md` (count unchecked `- [ ]`)
+
+If STATE.md does not exist, print: "No pipeline state. Run `/gdd:brief` first." and stop.
+
+## Step 2 — Default output
+
+```
+━━━ Pipeline state ━━━
+Stage: <stage>   Cycle: <cycle or "default">   Wave: <wave>
+Last checkpoint: <timestamp>
+Decisions: <N>   Open todos: <N>
+Next: /gdd:<next-stage>
+━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Recommend next stage via the same logic as `/gdd:next` (route by which artifacts exist).
+
+## Step 3 — Forensic audit (only if `--forensic`)
+
+Run these six checks and print PASS/WARN/FAIL per check:
+
+1. **Stale artifacts** — compare mtime of `.design/DESIGN.md` against most recent file under `src/` via `ls -lt`. WARN if DESIGN.md is older by >7 days.
+2. **Missing transitions** — STATE.md `stage:` vs artifacts present. e.g. stage=`plan` requires DESIGN-CONTEXT.md. FAIL if expected artifact missing.
+3. **Token drift** — `wc -c .design/DESIGN.md .design/DESIGN-CONTEXT.md`; tokens ≈ bytes/4. WARN if combined >50000 tokens.
+4. **Aged DESIGN-DEBT** — read `.design/DESIGN-DEBT.md`; any item whose line predates HEAD by >14 days (check `git blame` or file mtime fallback) → WARN.
+5. **Cycle alignment** — if `cycle:` is set but `.design/CYCLES.md` has no matching heading → FAIL.
+6. **Connection status** — re-probe figma/refero via ToolSearch; compare to STATE.md `<connections>`. WARN on mismatch.
+
+Also scan `.design/SEEDS.md` (if present) for seeds whose trigger keywords match STATE.md or CYCLES.md content; list them as "Seed ready to germinate: <text>".
+
+Print:
+```
+━━━ Forensic audit ━━━
+[PASS] Stale artifacts
+[WARN] Token drift — 53,400 tokens combined
+[PASS] Missing transitions
+[PASS] Aged DESIGN-DEBT
+[PASS] Cycle alignment
+[WARN] Connection status — figma now unavailable
+Seeds ready: 0
+━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## PROGRESS COMPLETE

package/skills/quick/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: gdd-quick
+description: "Run the pipeline with optional agents skipped for speed. Skips: phase-researcher, design-assumptions-analyzer, design-integration-checker. Keeps: planner, executor, verifier, auditor."
+argument-hint: "[--skip <agent-name>] [stage]"
+tools: Read, Task
+---
+
+# /gdd:quick
+
+Fast pipeline run. Skips optional-quality agents for speed while keeping the core decision chain (planner → executor → verifier → auditor) intact.
+
+## Default skipped agents
+
+- `design-phase-researcher` — no external research step
+- `design-assumptions-analyzer` — no assumption surfacing
+- `design-integration-checker` — skipped (verifier still runs)
+
+## Default kept agents
+
+- `design-planner`, `design-executor`, `design-verifier`, `design-auditor`
+
+## Steps
+
+1. Parse args:
+   - Optional stage name (defaults to full pipeline from the current STATE.md position).
+   - `--skip <agent-name>` (repeatable) adds to the skip list.
+2. Read `.design/STATE.md` to determine entry stage if none was passed.
+3. For each stage to execute, spawn the stage skill with a `quick_mode: true` flag and the effective skip list in the spawn context. Stage skills read this flag and route around the listed agents.
+4. After each stage, print: "Stage <name> done. Skipped: <list>."
+5. Final summary prints which agents were skipped across the full run.
+
+## Use When
+
+- You trust the problem scope (no need for fresh research).
+- The project has a mature DESIGN-CONTEXT.md (assumptions already surfaced).
+- You want verify + audit coverage without integration-checker overhead.
+
+## Do Not Use When
+
+- First pipeline run in a new project — use the full pipeline.
+- Large or cross-cutting changes — skip risks are higher.
+
+## QUICK COMPLETE

package/skills/reapply-patches/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: gdd-reapply-patches
+description: "Reapply user modifications to reference/ files after a plugin update. Detects customizations via git diff against pristine baseline."
+argument-hint: "[--dry-run]"
+tools: Read, Write, Bash
+---
+
+# gdd-reapply-patches
+
+Re-applies user customizations to `reference/*.md` files after `/gdd:update` resyncs the plugin. Customizations are detected by diffing each `reference/` file against a pristine baseline stored in `.gdd-baseline/`.
+
+## Steps
+
+1. **Detect baseline** — check for `.gdd-baseline/reference/`. If it does not exist, warn the user and offer to initialize it from the current `reference/` state (no diffs will be generated on this run; the next `/gdd:update` will use the new baseline).
+2. **Generate diffs** — for each `reference/*.md`, run `git diff --no-index .gdd-baseline/reference/<file> reference/<file>` (or plain `diff -u`). Non-empty diffs are candidate user patches.
+3. **Review patches** — for each non-empty diff, print the hunk and ask: `Apply this customization to the updated reference/<file>? (yes/no/view)`. `view` shows the full diff; `yes` queues the patch; `no` skips it.
+4. **Apply** — for each confirmed patch, apply it with `patch -p0` or with a targeted `Edit` call. Log every applied patch.
+5. **Refresh baseline** — after applying, copy the current `reference/*.md` tree into `.gdd-baseline/reference/` to record the new pristine-for-this-user state.
+6. **Dry-run** — if `--dry-run` is passed, perform steps 1–3 but do not apply patches or refresh the baseline.
+
+## Design note
+
+`.gdd-baseline/` is per-install and user-local. It must be gitignored by the host project — it is never committed to the plugin repo.
+
+## Output
+
+End every invocation with:
+
+```
+## REAPPLY-PATCHES COMPLETE
+```

package/skills/reflect/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: gdd-reflect
+description: "Run design-reflector on demand — produces .design/reflections/<cycle-slug>.md with improvement proposals. Review proposals with /gdd:apply-reflections."
+argument-hint: "[--dry-run] [--cycle <slug>]"
+tools: Read, Write, Task
+---
+
+# /gdd:reflect
+
+Run `design-reflector` on demand against the current (or specified) cycle. Produces `.design/reflections/<cycle-slug>.md` with numbered improvement proposals. Every proposal requires explicit user review — nothing is auto-applied.
+
+## Steps
+
+1. **Parse args**: extract `--dry-run` flag and `--cycle <slug>` value.
+
+2. **Resolve cycle slug**:
+   - If `--cycle <slug>` given: use that slug directly
+   - Else: read `.design/STATE.md`, extract the active `cycle:` ID from the `<position>` block
+   - If STATE.md not found: abort with "No .design/STATE.md found. Run `/gdd:new-project` first."
+
+3. **Build required-reading list**:
+   ```
+   .design/STATE.md
+   .design/DESIGN-VERIFICATION.md
+   .design/learnings/*.md (glob)
+   .design/telemetry/costs.jsonl
+   .design/agent-metrics.json
+   .design/learnings/question-quality.jsonl
+   .design/cycles/<slug>/CYCLE-SUMMARY.md
+   ```
+   Use the resolved slug where `<slug>` appears.
+
+4. **Spawn design-reflector**:
+   ```
+   Task("design-reflector", """
+   <required_reading>
+   @.design/STATE.md
+   @.design/DESIGN-VERIFICATION.md
+   @.design/agent-metrics.json
+   @.design/telemetry/costs.jsonl
+   @.design/learnings/question-quality.jsonl
+   </required_reading>
+
+   Cycle slug: <slug>
+   Dry-run: <true|false>
+
+   Produce .design/reflections/<slug>.md with all reflection sections and proposals.
+   If dry-run is true, print proposals to stdout only — do not write the file.
+   """)
+   ```
+
+5. **After completion**:
+   - If `--dry-run`: print the agent output directly; skip steps below
+   - Else: read `.design/reflections/<slug>.md`
+   - Count proposals by type (scan for `[FRONTMATTER]`, `[REFERENCE]`, `[BUDGET]`, `[QUESTION]`, `[GLOBAL-SKILL]`)
+   - Print summary:
+     ```
+     Reflection complete — cycle: <slug>
+     Proposals: N total
+       [FRONTMATTER] N
+       [REFERENCE] N
+       [BUDGET] N
+       [QUESTION] N
+       [GLOBAL-SKILL] N
+
+     Review and apply: /gdd:apply-reflections
+     ```
+
+## Do Not
+
+- Do not auto-apply any proposal.
+- Do not modify agent files, reference files, or budget.json.
+- Do not run the full audit pipeline — this is a standalone reflection run.

package/skills/resume/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: gdd-resume
+description: "Restore session context from .design/HANDOFF.md and route to where work left off."
+argument-hint: ""
+tools: Read, Write, Bash, Glob
+---
+
+# /gdd:resume
+
+Inverse of `/gdd:pause`. Reads the handoff file, prints a clear "you were here" summary, and routes to the next command.
+
+## Steps
+
+1. Try to read `.design/HANDOFF.md`. If missing, read `.design/STATE.md` and infer position from the `stage:` and `cycle:` fields.
+2. Print a summary in this exact shape:
+   ```
+   Last paused: <timestamp>
+   You were: <in-progress description>
+   Next step: <next>
+   Active sketch: <path or none>
+   Open todos: <N>
+   ```
+3. **Staleness check** — compare mtime of `.design/` artifacts vs `src/` (via Glob + Bash `stat` when available). If `src/` has commits/changes newer than the last pipeline artifact, warn: "Source has changed since last pipeline run — consider re-running explore or verify."
+4. **Route recommendation** based on stage:
+   - `brief` → "Run `@get-design-done brief`"
+   - `explore` → "Run `@get-design-done explore`"
+   - `plan` → "Run `@get-design-done plan`"
+   - `design` → "Run `@get-design-done design` to continue"
+   - `verify` → "Run `@get-design-done verify`"
+5. Do not auto-execute the next command — just recommend.
+
+## Do Not
+
+- Do not delete HANDOFF.md (leave it; next `/gdd:pause` overwrites it).
+- Do not modify STATE.md.
+
+## RESUME COMPLETE

package/skills/review-backlog/SKILL.md

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

package/skills/router/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: gdd-router
+description: "Routes a /gdd command to fast|quick|full path and returns {path, model_tier_overrides, estimated_cost_usd, cache_hits}. Deterministic — no model call. Invoked once at command entry before any Agent spawn. Read by hooks/budget-enforcer.js."
+argument-hint: "<intent-string> [<target-artifacts-csv>]"
+tools: Read, Bash, Grep
+---
+
+# gdd-router
+
+## Role
+
+You are a deterministic routing skill. You do not spawn agents. You read `.design/budget.json`, `reference/model-prices.md`, `.design/cache-manifest.json` (if present), and the agent frontmatter list, then emit a single JSON object describing the planned spawn graph. The budget-enforcer hook (`hooks/budget-enforcer.js`) consumes your output on every `Agent` tool call.
+
+## Invocation Contract
+
+- **Input**: `intent-string` (e.g., `"run discover stage on greenfield project"`) + optional comma-separated list of target artifacts (files this command will touch).
+- **Output**: a single JSON object to stdout — nothing else on the line, no prose wrapper:
+  ```json
+  {
+    "path": "fast",
+    "model_tier_overrides": {"design-verifier": "haiku"},
+    "estimated_cost_usd": 0.034,
+    "cache_hits": ["design-context-builder:abc123"]
+  }
+  ```
+- `path` enum: `fast` (single Haiku + no checkers), `quick` (Sonnet mappers + Haiku verify), `full` (Opus planners + full quality gates).
+- `model_tier_overrides` merges agent frontmatter `default-tier` with `.design/budget.json.tier_overrides` — budget.json wins per D-04.
+- `estimated_cost_usd` is the sum of per-spawn estimates using the D-06 formula and `reference/model-prices.md`.
+- `cache_hits` is a list of `{agent}:{input-hash}` strings that exist in `.design/cache-manifest.json` and are within TTL; emitting a hit lets the hook short-circuit that spawn per D-05.
+
+## Path Selection Heuristic
+
+| Signal | path |
+|--------|------|
+| Command is `/gdd:scan`, `/gdd:stats`, `/gdd:health`, `/gdd:help` | `fast` |
+| Command spawns exactly one agent (no orchestration) | `fast` |
+| Command spawns parallel mappers but no planners/auditors (`/gdd:discover` in `--auto` mode) | `quick` |
+| Command spawns planners, auditors, verifiers, or integration-checkers (`/gdd:plan`, `/gdd:verify`, `/gdd:audit`) | `full` |
+| `--dry-run` flag present on any command | downgrade one tier (fast↔quick↔full) |
+
+## Cost Estimation Algorithm
+
+```
+total = 0
+for each agent in planned spawn graph:
+  tier = resolve_tier(agent)   # budget.json tier_overrides > agent frontmatter default-tier
+  (in_tok, out_tok) = token_range_from_size_budget(agent.size_budget)  # from reference/model-prices.md
+  (in_rate, out_rate) = price_from_tier(tier)
+  total += (in_tok / 1e6) * in_rate + (out_tok / 1e6) * out_rate
+return total
+```
+
+## Cache-Hit Detection
+
+Delegate to `skills/cache-manager/SKILL.md` (Plan 10.1-02). The router lists candidate `{agent}:{input-hash}` tuples; the cache-manager confirms freshness against TTL from `budget.json.cache_ttl_seconds`.
+
+## Integration Point
+
+Every `/gdd:*` SKILL.md's first substantive step is: spawn the router via `Task` or inline invocation; receive the JSON blob; pass it to downstream agents as context so the budget-enforcer hook has the router decision available in tool_input metadata when the first Agent spawn fires.
+
+## Failure Modes
+
+If `.design/budget.json` is missing, assume defaults from `reference/config-schema.md` per D-12. If `reference/model-prices.md` is missing, emit `estimated_cost_usd: null` and log a warning — do not block.
+
+## Non-Goals
+
+The router does not: (a) make a model call, (b) write files, (c) enforce budget caps (that's the hook's job), (d) learn from history (Phase 11 reflector territory per D-07).