@hegemonart/get-design-done 1.48.0 → 1.50.0

package/dist/claude-code/.claude/skills/new-skill/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: gdd-new-skill
+description: "Scaffolds a new Phase-28.5 + Phase-50-compliant skill: gathers a name, a multi-paragraph v3 description, a lifecycle stage, an allowed-tools list, and optional composes_with neighbours, then writes source/skills/<name>/SKILL.md from the pure generator. Use when adding a brand-new gdd skill and you want the frontmatter, length cap, and v3 description form correct from the first commit. Activates for requests involving authoring a skill, scaffolding a command, creating a new SKILL.md, or adding a slash command."
+argument-hint: "<skill-name>"
+tools: Read, Write, Bash, AskUserQuestion
+user-invocable: true
+---
+
+# /gdd:new-skill
+
+**Role:** Interactively scaffold a contract-compliant skill. Gather the fields, then write `source/skills/<name>/SKILL.md` from the pure generator at `scripts/lib/manifest/scaffolder.cjs`. This skill writes ONE source file. It does NOT touch `scripts/lib/manifest/skills.json` and does NOT run the build; it prints the exact follow-up commands instead.
+
+Read `reference/skill-authoring-contract.md` first for the length cap, the frontmatter required fields, and the v3 description form.
+
+## Prompt strategy (clack with a fallback)
+
+Mirror the installer pattern in `scripts/install.cjs`: try `@clack/prompts` lazily, and degrade to `AskUserQuestion` (or plain text) when it is absent. Use this probe at the start:
+
+```bash
+node -e "try { require.resolve('@clack/prompts'); console.log('clack'); } catch { console.log('fallback'); }"
+```
+
+- `clack`: drive `clack.text`, `clack.select`, and `clack.confirm` from a short Node script.
+- `fallback`: ask the same questions with `AskUserQuestion` (one prompt per field), or read plain answers.
+
+Either way the answers feed the same record builder. Never block waiting on a TTY in a non-interactive run; fall back to `AskUserQuestion`.
+
+## Step 1 - Gather the fields
+
+1. **name**: the slug from `$ARGUMENTS` if present, else ask. Must match `^[a-z0-9][a-z0-9-._]*$`. Reject `source/skills/<name>/` collisions.
+2. **description**: a multi-paragraph v3 form. Sentence one is what the skill does. Sentence two is `Use when <triggers>`. Sentence three is `Activates for requests involving <kw1>, <kw2>, <kw3>.` Keep it 20 to 1024 chars.
+3. **lifecycle stage**: pick one of brief / explore / plan / verify / ship / figma / token / report (free text allowed). This seeds the composition suggestions.
+4. **tools**: a comma list (for example `Read, Write, Bash`). Empty means inherit-all.
+5. **composes_with**: auto-suggest neighbours, then confirm. Compute the suggestion list:
+
+```bash
+node -e "
+const s = require('./scripts/lib/manifest/scaffolder.cjs');
+const m = require('./scripts/lib/manifest/skills.json');
+console.log(JSON.stringify(s.suggestComposesWith(process.argv[1], m.skills)));
+" "<name>"
+```
+
+Present the suggestions; let the user accept, edit, or clear them.
+
+## Step 2 - Length pre-check
+
+Before writing, estimate the body length. If the planned body would exceed about 100 lines, warn the user (the authoring contract warns at 100 and blocks at 250) and suggest extracting domain content into a co-located `source/skills/<name>/<topic>.md` reference. The generated skeleton is small; the warning is for the prose the user will add next.
+
+## Step 3 - Write the file
+
+Build the record and render the file with the pure generator, then write it with the Write tool (not shell redirection):
+
+```bash
+node -e "
+const s = require('./scripts/lib/manifest/scaffolder.cjs');
+const rec = s.buildSkillRecord({
+  name: process.env.SK_NAME,
+  description: process.env.SK_DESC,
+  argumentHint: process.env.SK_HINT || undefined,
+  tools: process.env.SK_TOOLS || undefined,
+  userInvocable: process.env.SK_UI === 'true',
+  composesWith: (process.env.SK_COMPOSES || '').split(',').map(x => x.trim()).filter(Boolean),
+});
+process.stdout.write(s.renderSkillMd(rec));
+"
+```
+
+`buildSkillRecord` throws on an invalid name, an out-of-budget description, or a malformed tools list. Surface the thrown message to the user and re-prompt the offending field. Capture stdout and write it verbatim to `source/skills/<name>/SKILL.md` via the Write tool.
+
+## Step 4 - Tell the user the follow-up
+
+The skill stops here by contract. Print the next two commands for the user to run after they add the manifest record:
+
+```
+1. Add a record for "<name>" to scripts/lib/manifest/skills.json
+   (description, argument_hint, tools, user_invocable; put composes_with in extra_frontmatter).
+2. npm run generate:skill-frontmatter && npm run build:skills
+```
+
+Note that `npm run generate:skill-frontmatter:check` and the skills-coverage test stay red until the manifest record exists; that is expected and is the maintainer's step.
+
+## Do Not
+
+- Do not edit `scripts/lib/manifest/skills.json`, `package.json`, or any reference doc.
+- Do not run `build:skills` or `generate:skill-frontmatter` for the user; print the commands.
+- Do not write the SKILL.md with shell redirection; use the Write tool so the content is exact.
+- Do not invent a description; require the v3 three-sentence form from the user.
+
+## NEW-SKILL COMPLETE

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

@@ -1,6 +1,6 @@
 ---
 name: plan
-description: "Stage 3 of 5 orchestrator that reads DESIGN-CONTEXT.md, runs optional research (phase-researcher / pattern-mapper / assumptions-analyzer / synthesizer), spawns design-planner + design-plan-checker, and writes DESIGN-PLAN.md. Use when DESIGN-CONTEXT.md is locked and you need a wave-ordered execution plan."
+description: "Stage 3 of 5 orchestrator that reads DESIGN-CONTEXT.md, runs optional research (phase-researcher / pattern-mapper / assumptions-analyzer / synthesizer), spawns design-planner + design-plan-checker, and writes DESIGN-PLAN.md. Use when DESIGN-CONTEXT.md is locked and you need a wave-ordered execution plan. Activates for requests involving breaking design work into steps, sequencing implementation, or planning a build."
 argument-hint: "[--auto] [--parallel]"
 user-invocable: true
 tools: Read, Write, Bash, Glob, Task, AskUserQuestion, ToolSearch, mcp__gdd_state__get, mcp__gdd_state__transition_stage, mcp__gdd_state__add_decision, mcp__gdd_state__add_must_have, mcp__gdd_state__update_progress, mcp__gdd_state__set_status, mcp__gdd_state__add_blocker, mcp__gdd_state__checkpoint, mcp__gdd_state__probe_connections

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

@@ -1,6 +1,6 @@
 ---
 name: gdd-progress
-description: "Shows current pipeline position and routes to next action. --forensic runs 6-check integrity audit."
+description: "Shows current pipeline position and routes to next action. --forensic runs 6-check integrity audit. Activates for requests involving showing current project state, routing to the next action, or a status check."
 argument-hint: "[--forensic]"
 tools: Read, Bash, Grep, Glob, mcp__gdd_state__get, mcp__gdd_status, mcp__gdd_phase_current
 ---
@@ -78,6 +78,14 @@ Seeds ready: 0
 ━━━━━━━━━━━━━━━━━━━━━━
 ```
 
+## Step 3.5 - Composition-graph readiness
+
+After the pipeline state (and forensic audit if run), surface a one-line composition-graph hint from `scripts/lib/manifest/skills.json`. Count skill records declaring `composes_with` or `next_skills`, then probe for structural problems (cycles in the directed graph, or edges pointing at a skill name that has no record). Print one line:
+
+- `Composition graph: <edges> edges, <skills-with-edges> skills wired | cycles: <n> | dangling: <n>`
+
+Run `scripts/validate-composition-graph.cjs` for the authoritative cycle and dangling-edge counts when that validator is present; until then report `0` and note the graph is not yet wired. This is a readiness hint, not a gate.
+
 ## Step 4 - Update notice (safe-window surface)
 
 After printing the pipeline state, emit the plugin-update banner if one is present. This file is written by `hooks/update-check.sh` subject to the state-machine guard (mid-pipeline stages suppress it) and per-version dismissal.

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

@@ -1,6 +1,6 @@
 ---
 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."
+description: "Run the pipeline with optional agents skipped for speed. Skips: phase-researcher, design-assumptions-analyzer, design-integration-checker. Keeps: planner, executor, verifier, auditor. Activates for requests involving a lightweight design pass, a fast iteration, or a quick low-ceremony change."
 argument-hint: "[--skip <agent-name>] [stage]"
 tools: Read, Task
 disable-model-invocation: true

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

@@ -1,6 +1,6 @@
 ---
 name: scan
-description: "Pre-pipeline initializer that maps an existing repo's design system (colors, typography, spacing, components, tokens), runs the anti-pattern audit, scores the 7 weighted categories, and writes DESIGN.md + .design/DESIGN-DEBT.md. Use when starting work in any new or existing repo before /gdd:discover."
+description: "Pre-pipeline initializer that maps an existing repo's design system (colors, typography, spacing, components, tokens), runs the anti-pattern audit, scores the 7 weighted categories, and writes DESIGN.md + .design/DESIGN-DEBT.md. Use when starting work in any new or existing repo before /gdd:discover. Activates for requests involving a fast read-only anti-pattern sweep, a quick design lint, or spotting slop without a full audit."
 argument-hint: "[--quick] [--full]"
 user-invocable: true
 ---

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

@@ -1,6 +1,6 @@
 ---
 name: gdd-ship
-description: "Post-verify PR flow - creates a clean PR branch, invokes code review check, and prepares the PR for merge."
+description: "Post-verify PR flow - creates a clean PR branch, invokes code review check, and prepares the PR for merge. Activates for requests involving finishing a cycle, packaging design output, or moving work to a pull request."
 argument-hint: "[--title <PR title>] [--draft]"
 tools: Read, Write, Bash, AskUserQuestion, Task
 disable-model-invocation: true

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

@@ -1,6 +1,6 @@
 ---
 name: verify
-description: "Stage 5 of 5 orchestrator that spawns design-auditor, design-verifier, and design-integration-checker in sequence, interprets pass/gap result, and drives the gap-response loop (inline fix, save-and-exit, or accept-as-is). Use when implementation is complete and ready for final pre-ship verification."
+description: "Stage 5 of 5 orchestrator that spawns design-auditor, design-verifier, and design-integration-checker in sequence, interprets pass/gap result, and drives the gap-response loop (inline fix, save-and-exit, or accept-as-is). Use when implementation is complete and ready for final pre-ship verification. Activates for requests involving checking finished UI against the design system, running a pre-ship review, or final verification."
 argument-hint: "[--auto] [--post-handoff]"
 user-invocable: true
 tools: mcp__gdd_state__get, mcp__gdd_state__transition_stage, mcp__gdd_state__add_must_have, mcp__gdd_state__add_blocker, mcp__gdd_state__resolve_blocker, mcp__gdd_state__update_progress, mcp__gdd_state__set_status, mcp__gdd_state__checkpoint, mcp__gdd_state__probe_connections

package/hooks/gdd-design-quality-check.js

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * hooks/gdd-design-quality-check.js — advisory PostToolUse hook for the
+ * default-AI-aesthetic regex floor (Phase 49, Quick Anti-Slop Floor).
+ *
+ * The cheapest possible anti-slop pass: on every front-end file write, scan the
+ * written content for the visual tells that mark a UI as "an AI generated this"
+ * (gradient spam, the purple/violet default palette, glassmorphism stacks, the
+ * Inter default, centered-everything heroes, undraw/isometric clip art, filler
+ * CTA copy, decorative motion with no loading intent). Each match is a non
+ * blocking WARN. The catalog the rules come from lives at
+ * reference/visual-tells.md (8 named categories, 1:1 with the 8 rules here).
+ *
+ * Contract (mirrors hooks/gdd-a11y-gate.js):
+ *   - Read stdin JSON (the PostToolUse payload: {tool_name, tool_input,
+ *     tool_response, cwd, ...}).
+ *   - Only act on Write/Edit/MultiEdit tools targeting a .tsx/.vue/.svelte/.astro
+ *     file. Everything else is a bare {continue:true}.
+ *   - Scan the written content against 8 regex rules; collect matches as warnings.
+ *   - Emit one `design_quality_warn` event through scripts/lib/event-chain.cjs
+ *     (baseDir injected from cwd; the emit is best-effort and never fatal).
+ *   - Print a concise advisory to stdout and ALWAYS write {continue:true}, exit 0.
+ *     This hook is WARN-only. It never blocks a write.
+ *
+ * Dependency-free: core fs/path plus the in-repo event-chain helper. No npm deps.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/** Front-end source extensions this hook scans. */
+const FRONTEND_EXT = ['.tsx', '.vue', '.svelte', '.astro'];
+
+/**
+ * The 8 v1 rules. Each `category` matches a heading in reference/visual-tells.md.
+ * `test(content)` returns an array of { line, match } hits (possibly empty).
+ * Regexes are tuned for precision (low false-positive) over recall.
+ */
+
+/** Find the 1-based line number for a character offset in `content`. */
+function lineOf(content, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < content.length; i++) {
+    if (content[i] === '\n') line += 1;
+  }
+  return line;
+}
+
+/** Collect up to `cap` global-regex matches as {line, match}. */
+function collect(content, re, cap = 5) {
+  const hits = [];
+  let m;
+  re.lastIndex = 0;
+  while ((m = re.exec(content)) !== null) {
+    hits.push({ line: lineOf(content, m.index), match: m[0] });
+    if (m.index === re.lastIndex) re.lastIndex += 1; // zero-width guard
+    if (hits.length >= cap) break;
+  }
+  return hits;
+}
+
+/** Count global-regex matches without allocating the match list. */
+function countMatches(content, re) {
+  let n = 0;
+  let m;
+  re.lastIndex = 0;
+  while ((m = re.exec(content)) !== null) {
+    n += 1;
+    if (m.index === re.lastIndex) re.lastIndex += 1;
+  }
+  return n;
+}
+
+const RULES = [
+  {
+    rule: 'gradient-spam',
+    category: 'gradient-spam',
+    // >=3 Tailwind gradient-direction utilities in one file.
+    run(content) {
+      const re = /\bbg-gradient-to-(?:r|br|tr|b|bl|l|tl|t)\b/g;
+      const count = countMatches(content, re);
+      if (count < 3) return [];
+      const hits = collect(content, re, 5);
+      // Tag the first hit with the aggregate count for the advisory.
+      if (hits.length) hits[0].match = `${hits[0].match} (x${count})`;
+      return hits;
+    },
+  },
+  {
+    rule: 'generic-cta',
+    category: 'default-AI-hero',
+    // Filler hero / CTA copy. Word-boundaried, case-insensitive.
+    run(content) {
+      const re = /\b(?:Get Started|Welcome to|Lorem ipsum|Learn More)\b/gi;
+      return collect(content, re, 5);
+    },
+  },
+  {
+    rule: 'centered-everything-syndrome',
+    category: 'centered-everything-syndrome',
+    // mx-auto AND text-center co-occurring inside one className string.
+    run(content) {
+      // Match a quoted class string that contains both utilities, in either order.
+      const re =
+        /(["'`])(?=[^"'`]*\bmx-auto\b)(?=[^"'`]*\btext-center\b)[^"'`]*\1/g;
+      return collect(content, re, 5);
+    },
+  },
+  {
+    rule: 'inter-everything',
+    category: 'inter-everything',
+    // font-inter utility OR a font-family: Inter declaration, when no other
+    // custom font token (font-<name>, --font-*, or a second font-family) is near.
+    run(content) {
+      const interRe = /\bfont-inter\b|font-family:\s*['"]?Inter\b/gi;
+      const interCount = countMatches(content, interRe);
+      if (interCount === 0) return [];
+      // A sibling custom-font signal suppresses the warning (a deliberate stack).
+      const siblingFont =
+        /\bfont-(?!inter\b|sans\b|serif\b|mono\b|medium\b|semibold\b|bold\b|light\b|normal\b|thin\b|black\b|extrabold\b|extralight\b)[a-z]/i.test(
+          content,
+        ) ||
+        /--font-[a-z]/i.test(content) ||
+        /font-family:\s*['"]?(?!Inter\b)[A-Za-z]/i.test(content);
+      if (siblingFont) return [];
+      return collect(content, interRe, 5);
+    },
+  },
+  {
+    rule: 'purple-violet-default',
+    category: 'purple-violet-default',
+    // The default-AI palette bg-(purple|violet)-(500|600|700) with no theme
+    // token class (bg-primary / bg-brand / bg-accent / a CSS var) nearby.
+    run(content) {
+      const re = /\bbg-(?:purple|violet)-(?:500|600|700)\b/g;
+      if (countMatches(content, re) === 0) return [];
+      const themeToken =
+        /\bbg-(?:primary|brand|accent|surface|foreground|background|muted)\b/i.test(
+          content,
+        ) || /bg-\[(?:var\(--|hsl|oklch|rgb)/i.test(content);
+      if (themeToken) return [];
+      return collect(content, re, 5);
+    },
+  },
+  {
+    rule: 'glassmorphism-spam',
+    category: 'glassmorphism-spam',
+    // >=3 of backdrop-blur* / bg-white/(10|20|30) in one file.
+    run(content) {
+      const re = /\bbackdrop-blur(?:-\w+)?\b|\bbg-white\/(?:10|20|30)\b/g;
+      const count = countMatches(content, re);
+      if (count < 3) return [];
+      const hits = collect(content, re, 5);
+      if (hits.length) hits[0].match = `${hits[0].match} (x${count})`;
+      return hits;
+    },
+  },
+  {
+    rule: 'isometric-illustration-fallback',
+    category: 'isometric-illustration-fallback',
+    // undraw / isometric markers in an asset path or src attribute.
+    run(content) {
+      const re = /\b(?:undraw|isometric)[\w./-]*/gi;
+      return collect(content, re, 5);
+    },
+  },
+  {
+    rule: 'decorative-motion-without-intent',
+    category: 'decorative-motion-without-intent',
+    // animate-(pulse|bounce|spin) on a non-loading, non-icon element.
+    // Conservative: only flag a className that has the animate utility but no
+    // loading/skeleton/spinner/icon signal on the same class string.
+    run(content) {
+      const re =
+        /(["'`])(?=[^"'`]*\banimate-(?:pulse|bounce|spin)\b)(?![^"'`]*(?:\b(?:animate-(?:pulse|bounce|spin)\s+)?(?:loading|loader|spinner|skeleton|icon|i-)\b|sr-only))[^"'`]*\1/g;
+      return collect(content, re, 5);
+    },
+  },
+];
+
+/**
+ * Resolve the written content from a PostToolUse payload, tolerating Write
+ * (tool_input.content), Edit (new_string), and MultiEdit (edits[].new_string),
+ * and falling back to a tool_response filePath/content when present.
+ *
+ * Returns { filename, content } or null when there is nothing front-end to scan.
+ */
+function extractWrite(payload) {
+  if (!payload || typeof payload !== 'object') return null;
+  const tool = payload.tool_name || payload.toolName;
+  if (tool !== 'Write' && tool !== 'Edit' && tool !== 'MultiEdit') return null;
+
+  const input = payload.tool_input || payload.toolInput || {};
+  const filename =
+    input.file_path ||
+    input.filePath ||
+    input.path ||
+    (payload.tool_response &&
+      (payload.tool_response.filePath || payload.tool_response.file_path)) ||
+    '';
+  if (!filename) return null;
+
+  const ext = path.extname(String(filename)).toLowerCase();
+  if (!FRONTEND_EXT.includes(ext)) return null;
+
+  const parts = [];
+  if (typeof input.content === 'string') parts.push(input.content);
+  if (typeof input.new_string === 'string') parts.push(input.new_string);
+  if (Array.isArray(input.edits)) {
+    for (const e of input.edits) {
+      if (e && typeof e.new_string === 'string') parts.push(e.new_string);
+    }
+  }
+  // Fall back to a post-write file content echo if the input carried none.
+  if (parts.length === 0 && payload.tool_response) {
+    const tr = payload.tool_response;
+    if (typeof tr.content === 'string') parts.push(tr.content);
+  }
+
+  const content = parts.join('\n');
+  if (!content) return null;
+  return { filename: String(filename), content };
+}
+
+/**
+ * Pure evaluator: scan `content` (with `filename` for category context) against
+ * the 8 rules. Exported for unit testing without a process.
+ *
+ * @returns {{ warnings: Array<{rule, category, line, match}>, count: number }}
+ */
+function evaluate(content, filename) {
+  const warnings = [];
+  if (typeof content !== 'string' || content.length === 0) {
+    return { warnings, count: 0 };
+  }
+  for (const r of RULES) {
+    let hits = [];
+    try {
+      hits = r.run(content) || [];
+    } catch {
+      hits = []; // a misbehaving rule must never break the advisory
+    }
+    for (const h of hits) {
+      warnings.push({
+        rule: r.rule,
+        category: r.category,
+        line: h.line,
+        match: h.match,
+      });
+    }
+  }
+  return { warnings, count: warnings.length };
+}
+
+/** Best-effort event emit through the in-repo event-chain helper. Never throws. */
+function emitEvent(cwd, filename, result) {
+  try {
+    const { appendChainEvent } = require('../scripts/lib/event-chain.cjs');
+    appendChainEvent({
+      agent: 'gdd-design-quality-check',
+      outcome: 'warn',
+      event: 'design_quality_warn',
+      file: filename,
+      warning_count: result.count,
+      categories: [...new Set(result.warnings.map((w) => w.category))],
+      warnings: result.warnings.slice(0, 20),
+      baseDir: cwd,
+    });
+  } catch {
+    /* observability is best-effort — swallow */
+  }
+}
+
+/** Build the concise stdout advisory string for a non-empty result. */
+function advisoryNote(filename, result) {
+  const cats = [...new Set(result.warnings.map((w) => w.category))];
+  const base = path.basename(filename);
+  const lines = [
+    `gdd-design-quality-check: ${result.count} visual-tell ` +
+      `warning${result.count === 1 ? '' : 's'} in ${base} ` +
+      `across ${cats.length} categor${cats.length === 1 ? 'y' : 'ies'} ` +
+      `(${cats.join(', ')}).`,
+  ];
+  for (const w of result.warnings.slice(0, 8)) {
+    lines.push(`  - [${w.rule}] line ${w.line}: ${w.match}`);
+  }
+  lines.push('  See reference/visual-tells.md for remediation patterns. (advisory, non-blocking)');
+  return lines.join('\n');
+}
+
+/**
+ * Core hook entry. Accepts a parsed payload, returns the decision object to
+ * write to stdout. Always returns { continue: true } (advisory only).
+ * Exported for unit testing without spawning a process.
+ */
+function main(payload, opts = {}) {
+  const cwd = (payload && payload.cwd) || opts.cwd || process.cwd();
+  const write = extractWrite(payload);
+  if (!write) return { continue: true };
+
+  const result = evaluate(write.content, write.filename);
+  if (result.count === 0) return { continue: true };
+
+  emitEvent(cwd, write.filename, result);
+  const note = advisoryNote(write.filename, result);
+  return { continue: true, systemMessage: note };
+}
+
+async function run(stdin = process.stdin, stdout = process.stdout) {
+  let buf = '';
+  for await (const chunk of stdin) buf += chunk;
+  let payload;
+  try {
+    payload = JSON.parse(buf || '{}');
+  } catch {
+    stdout.write(JSON.stringify({ continue: true }));
+    return;
+  }
+  const decision = main(payload);
+  if (decision.systemMessage) {
+    // Surface the advisory on stderr too so it is visible in plain hook logs.
+    try {
+      process.stderr.write(decision.systemMessage + '\n');
+    } catch {
+      /* swallow */
+    }
+  }
+  stdout.write(JSON.stringify(decision));
+}
+
+// Run as a CLI only when invoked directly; tests require() this module and call
+// evaluate()/main() against mock payloads without triggering stdin reads.
+if (require.main === module) {
+  run().catch(() => {
+    process.stdout.write(JSON.stringify({ continue: true }));
+  });
+}
+
+module.exports = { main, evaluate, extractWrite, RULES, FRONTEND_EXT };

package/hooks/hooks.json

@@ -124,6 +124,15 @@
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gdd-a11y-gate.js\""
           }
         ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gdd-design-quality-check.js\""
+          }
+        ]
       }
     ],
     "Stop": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hegemonart/get-design-done",
-  "version": "1.48.0",
+  "version": "1.50.0",
   "description": "A design-quality pipeline for AI coding agents: brief, plan, implement, and verify UI work against your design system.",
   "author": "Hegemon",
   "homepage": "https://github.com/hegemonart/get-design-done",
@@ -73,6 +73,10 @@
     "verify:harness": "node scripts/verify-harness.cjs",
     "check:domain-links": "node scripts/check-domain-cross-links.cjs",
     "check:no-duplication": "node scripts/check-no-duplication.cjs",
+    "validate:composition-graph": "node scripts/validate-composition-graph.cjs",
+    "validate:skill-frontmatter": "node scripts/validate-skill-frontmatter.cjs",
+    "build:skill-graph": "node scripts/generate-skill-graph.cjs",
+    "build:skill-graph:check": "node scripts/generate-skill-graph.cjs --check",
     "sync:rule-catalogue": "node scripts/sync-rule-catalogue.cjs --check",
     "validate:manifest": "node scripts/validate-manifest.cjs --check",
     "validate:schemas": "node --experimental-strip-types scripts/validate-schemas.ts",
@@ -115,7 +119,13 @@
     "agent-sdk",
     "figma",
     "extractor",
-    "design-system-sync"
+    "design-system-sync",
+    "worktree-safe",
+    "anti-slop",
+    "confidence-gate",
+    "anti-slop-rubric",
+    "skill-composition",
+    "skill-graph"
   ],
   "skills": [
     "SKILL.md"