get-shit-pretty 0.5.2 → 0.6.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gsp",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "Design engineering system for AI coding agents. Brand identity + design projects, from strategy to code.",
   "author": {
     "name": "jubscodes",

package/README.md

@@ -240,7 +240,7 @@ GSP works across all major AI coding tools. The installer converts Claude Code's
 
 | Feature | Claude Code | OpenCode | Gemini CLI | Codex CLI |
 |---------|:-----------:|:--------:|:----------:|:---------:|
-| Skills | 24 | 24 | 24 | 24 |
+| Skills | 30 | 30 | 30 | 30 |
 | Agents | 15 | 15 | 15 (experimental) | — |
 | Slash syntax | `/gsp:command` | `/gsp-command` | `/gsp:command` | `$gsp-command` |
 | Prompts + templates | Yes | Yes | Yes | Yes |
@@ -329,8 +329,7 @@ get-shit-pretty/
 ├── scripts/               Hook scripts and utilities
 ├── gsp/                   Source of truth for all content
 │   ├── agents/            15 subagents (gsp-*.md)
-│   ├── commands/gsp/      20 slash commands (backward compat)
-│   ├── skills/            24 skills (*/SKILL.md — primary)
+│   ├── skills/            30 skills (*/SKILL.md)
 │   ├── hooks/             Plugin-level hooks (hooks.json)
 │   ├── prompts/           12 agent system prompts
 │   ├── templates/         Config, state, brief, roadmap templates
@@ -343,7 +342,7 @@ get-shit-pretty/
 └── CLAUDE.md              AI agent instructions for this repo
 ```
 
-Skills take precedence over commands when both exist. The installer reads from `gsp/` and writes to each runtime's config directory.
+The installer reads from `gsp/` and writes to each runtime's config directory.
 
 ---
 

package/bin/install.js

@@ -915,6 +915,7 @@ function copyOpencodeSkills(srcDir, destDir, pathPrefix) {
     content = content.replace(/\.\/\.claude\//g, './.opencode/');
     content = convertClaudeSkillToOpencode(content, skillName);
     fs.writeFileSync(path.join(skillDest, 'SKILL.md'), content);
+    copySiblingFiles(path.join(srcDir, dir.name), skillDest, pathPrefix);
     count++;
   }
 
@@ -946,6 +947,7 @@ function copyCodexSkillsFromSource(srcDir, destDir, pathPrefix) {
     content = content.replace(/~\/\.claude\//g, pathPrefix);
     content = convertClaudeSkillToCodex(content, skillName);
     fs.writeFileSync(path.join(skillDest, 'SKILL.md'), content);
+    copySiblingFiles(path.join(srcDir, dir.name), skillDest, pathPrefix);
     count++;
   }
   return count;
@@ -986,6 +988,7 @@ function copyGeminiSkills(srcDir, destDir, pathPrefix) {
     content = content.replace(/\.\/\.claude\//g, './.gemini/');
     content = convertClaudeSkillToGemini(content, skillName);
     fs.writeFileSync(path.join(skillDest, 'SKILL.md'), content);
+    copySiblingFiles(path.join(srcDir, dir.name), skillDest, pathPrefix);
     count++;
   }
   return count;
@@ -1030,6 +1033,24 @@ function copyAgents(srcDir, destDir, pathPrefix, runtime, { clean = false } = {}
  * Copy Claude Code skills (global install path — no body conversion, only path replacement).
  * Returns skill count.
  */
+/**
+ * Recursively copy sibling files in a skill directory (everything except SKILL.md).
+ * All sibling files are copied verbatim — no path replacement applied.
+ */
+function copySiblingFiles(srcDir, destDir, pathPrefix) {
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    if (entry.name === 'SKILL.md') continue; // already handled by caller
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      fs.mkdirSync(destPath, { recursive: true });
+      copySiblingFiles(srcPath, destPath, pathPrefix);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
 function copyClaudeSkills(srcDir, destDir, pathPrefix) {
   fs.mkdirSync(destDir, { recursive: true });
 
@@ -1045,11 +1066,13 @@ function copyClaudeSkills(srcDir, destDir, pathPrefix) {
     if (!dir.isDirectory()) continue;
     const skillMd = path.join(srcDir, dir.name, 'SKILL.md');
     if (!fs.existsSync(skillMd)) continue;
-    const destSkillDir = path.join(destDir, dir.name);
+    const skillName = dir.name.startsWith('gsp-') ? dir.name : `gsp-${dir.name}`;
+    const destSkillDir = path.join(destDir, skillName);
     fs.mkdirSync(destSkillDir, { recursive: true });
     let content = fs.readFileSync(skillMd, 'utf8');
     content = content.replace(/~\/\.claude\//g, pathPrefix);
     fs.writeFileSync(path.join(destSkillDir, 'SKILL.md'), content);
+    copySiblingFiles(path.join(srcDir, dir.name), destSkillDir, pathPrefix);
     skillCount++;
   }
   return skillCount;
@@ -1704,6 +1727,9 @@ function finishInstall(settingsPath, settings, statuslineCommand, shouldInstallS
   if (!onboardingShown && !hasQuiet) {
     onboardingShown = true;
     console.log(`
+  ${c.secondary}Design engineering for AI coding tools.${c.reset}
+  ${c.secondary}Brand strategy, visual identity, design systems, UI — built by agents.${c.reset}
+
   ${c.bold}Get started:${c.reset}
     ${c.accent}${newCmd}${c.reset}     ${c.secondary}start here — brand, project, or both${c.reset}
     ${c.accent}${helpCmd}${c.reset}      ${c.secondary}all commands${c.reset}

package/gsp/agents/gsp-builder.md

@@ -50,7 +50,7 @@ Build a single screen. You receive only that screen's design chunk and its refer
 ### `full`
 Legacy mode — build everything in one pass. Used as backward-compatible default.
 
-**Chunk-aware mode:** When chunks are provided instead of full monoliths (screen chunks from `design/`, brief chunks from `brief/`, research specs from `research/`, component chunks from brand `patterns/components/`), work with the focused context. Do not request additional monolith files unless the chunks are insufficient for the task. This keeps your context lean and focused on the specific screen being built.
+**Chunk-aware mode:** Work with the chunk context provided. Do not request additional files unless the chunks are insufficient for the task. This keeps your context lean and focused on the specific screen being built.
 
 **Revision mode:** When `review/issues.md` is provided, you are re-entering the build phase to address QA issues. Read the issues, fix them in the codebase, and update BUILD-LOG.md with the revision.
 </role>

package/gsp/references/questioning.md

@@ -5,10 +5,18 @@ Guide brief-gathering conversations — used by `/gsp:start` for both brand brie
 
 ---
 
+## Core Rules
+
+**One decision per question.** Every question must be its own `AskUserQuestion` call. Never group multiple questions into a single message. Ask one thing, wait for the answer, use it to inform the next question.
+
+**Never re-ask what the user already answered.** If information was gathered in a prior phase and is available in BRIEF.md or other artifacts, use it — don't ask again. If you need to validate stale information, confirm it ("I see X from earlier — still accurate?") rather than asking from scratch. Each phase reads the prior phase's output; the user should never feel like they're repeating themselves.
+
+---
+
 ## Question Flow
 
 ### Phase 1: Context (Who & Why)
-Start broad, then narrow.
+Start broad, then narrow. Each is a separate `AskUserQuestion`.
 
 1. **What** is this project? (app, website, rebrand, campaign)
 2. **Who** is it for? (audience demographics, psychographics)
@@ -41,11 +49,11 @@ Start broad, then narrow.
 
 ## Questioning Techniques
 
-### Progressive Disclosure
-Don't ask all 18 questions at once. Group into 3-4 conversational rounds:
-- Round 1: Context + Brand (questions 1-8)
-- Round 2: Scope + Constraints (questions 9-16)
-- Round 3: Success + Gaps (questions 17-18 + follow-ups)
+### One at a Time
+Ask each question as its own `AskUserQuestion` call. Wait for the answer before asking the next. Use each answer to decide whether to skip, reframe, or drill into the next question.
+
+### Adapt and Skip
+Don't follow the list rigidly. If an early answer reveals enough context, skip later questions. If an answer is surprising, follow up before moving on. The sequence is a guide, not a script.
 
 ### Follow-Up Patterns
 - **"Tell me more about..."** — When an answer is surface-level
@@ -66,9 +74,9 @@ Don't ask what you can infer:
 - Reserve prose questions for open-ended exploration where you genuinely don't know the option space
 
 ### When to Use `AskUserQuestion` vs Prose
-- **Use `AskUserQuestion`** for: picking between defined directions (archetypes, styles, brands), yes/no/which decisions, selecting from existing items (brands, projects), mood/tone/size preferences
-- **Use prose** for: open-ended creative input ("tell me about your brand"), gathering context you can't predict ("what problem does this solve?"), follow-up clarifications where the answer space is unbounded
-- **Rule of thumb:** if you can write 2-4 meaningful options with descriptions, use `AskUserQuestion`. If you'd be guessing at what the options should be, use prose.
+- **Always use `AskUserQuestion`** — this is the default for every user-facing question
+- **Prose is only for** follow-up clarifications where the answer space is truly unbounded and you cannot write meaningful options
+- **Rule of thumb:** if you can write 2-4 meaningful options with descriptions, use `AskUserQuestion`. If you'd be guessing at what the options should be, still use `AskUserQuestion` with an open-ended framing.
 
 ### Knowing When You Have Enough
 A brief is complete when you can answer:

package/gsp/skills/gsp-accessibility/SKILL.md

@@ -1,42 +1,38 @@
 ---
 name: accessibility
-description: Accessibility audit — contrast checks, WCAG compliance, code audits, token verification
+description: Quick contrast checks and token WCAG audits — inline, no agent
 user-invocable: true
 allowed-tools:
   - Read
   - Write
   - Bash
-  - Agent
   - Glob
   - Grep
   - AskUserQuestion
 ---
 <context>
 Standalone composable accessibility skill. Works two ways:
-1. **Standalone** — user runs `/gsp:accessibility` directly for design, code, or token audits
+1. **Standalone** — user runs `/gsp:accessibility` directly for quick contrast checks or token audits
 2. **As a building block** — critique and review phases detect prior accessibility output and reuse it
 
 Follows the composable pattern: deterministic modes, predictable output paths, filesystem as integration layer.
+
+For full design audits, code audits, or statement generation, use `/gsp:accessibility-audit`.
 </context>
 
 <objective>
-Run accessibility audits in multiple modes — design, code, tokens, quick check, or statement generation.
+Run lightweight accessibility checks inline — contrast ratio lookups and token WCAG verification.
 
 **Input:** Mode flag + optional arguments
-**Output:** Audit chunks in the appropriate project directory
-**Agent:** `gsp-accessibility-auditor` (for design and code modes), inline for tokens/check/statement
+**Output:** Display output (check mode) or audit chunk (token mode)
+**Agent:** None — this skill runs entirely inline
 </objective>
 
-<execution_context>
-@${CLAUDE_SKILL_DIR}/../../prompts/08-accessibility-auditor.md
-@${CLAUDE_SKILL_DIR}/../../references/wcag-checklist.md
-</execution_context>
-
 <rules>
 - Always use `AskUserQuestion` for user interaction — never prompt via plain text
+- One decision per question — never batch multiple questions in a single message
 - Quick check mode (`--check`) produces display output only — no files written
 - Token audit mode runs inline — no agent spawned
-- Statement mode reads prior audit results — fails gracefully if none exist
 - Default conformance level is AA unless overridden by `--level AAA` or config
 - Foundation chunks follow `references/chunk-format.md` format
 </rules>
@@ -46,39 +42,34 @@ Run accessibility audits in multiple modes — design, code, tokens, quick check
 
 Read `$ARGUMENTS` to determine the mode:
 
-| Input | Mode | Agent? | Output |
-|-------|------|--------|--------|
-| (no args) | Design audit on `.design/` chunks | Yes (`gsp-accessibility-auditor`) | `critique/accessibility-audit.md` + `accessibility-fixes.md` |
-| `--tokens` | Token-only: contrast pairs, sizing, spacing | No (inline) | `critique/accessibility-token-audit.md` |
-| `--code` | Codebase audit: ARIA, keyboard, semantic HTML | Yes (`gsp-accessibility-auditor`) | `review/accessibility-audit.md` + `accessibility-fixes.md` |
-| `--statement` | Generate accessibility statement from prior audits | No (inline) | `exports/accessibility-statement.md` |
-| `--check #FG #BG` | Quick contrast check | No (inline, no files) | Display only |
+| Input | Mode | Output |
+|-------|------|--------|
+| `--check #FG #BG` | Quick contrast check | Display only |
+| `--tokens` | Token-only: contrast pairs, sizing, spacing | `critique/accessibility-token-audit.md` |
+| (no args) | Mode picker | Prompt user |
 
 Additional flag: `--level AAA` overrides conformance level (default: AA).
 
-## Step 2: Resolve context
+## Step 2: Route by mode
 
-### Quick check mode (`--check`)
+### No args → mode picker
 
-If args contain `--check`, extract the two hex color values and skip to Step 3.
+If no arguments provided, use `AskUserQuestion`:
 
-### All other modes
+**"What would you like to do?"**
+- **Quick contrast check** — "check specific color pairs for WCAG contrast compliance"
+- **Token audit** — "audit tokens.json for WCAG compliance"
+- **Full design/code audit** — "run `/gsp:accessibility-audit` for full WCAG audits, code audits, or statement generation"
 
-Scan `.design/projects/` for project directories. If only one project exists, use it. If multiple, use `AskUserQuestion` to ask which project.
+If user picks "Full design/code audit", tell them to run `/gsp:accessibility-audit` and stop.
 
-Set `PROJECT_PATH` = `.design/projects/{project}`
+### Quick check mode (`--check`)
 
-Read `{PROJECT_PATH}/config.json` to get:
-- `accessibility_level` — override conformance level (if not set via `--level` flag)
-- `implementation_target` — needed for code mode
+If args contain `--check`, extract the two hex color values and skip to Step 3.
 
-Read `{PROJECT_PATH}/brand.ref` to resolve brand path:
-- Set `BRAND_PATH` = `.design/branding/{brand}`
+### Token audit mode (`--tokens`)
 
-Determine final conformance level:
-1. `--level` flag (highest priority)
-2. `accessibility_level` from config.json
-3. Default: "WCAG 2.2 AA"
+Skip to Step 4.
 
 ## Step 3: Quick check mode (`--check #FG #BG`)
 
@@ -114,7 +105,24 @@ Convert hex to relative luminance (sRGB linearization), then:
 
 ## Step 4: Token audit mode (`--tokens`)
 
-Read token and palette files from the brand/project:
+### Resolve context
+
+Resolve project from `.design/projects/` (one → use it, multiple → ask). Set `PROJECT_PATH`.
+
+Read `{PROJECT_PATH}/config.json` to get:
+- `accessibility_level` — override conformance level (if not set via `--level` flag)
+
+Read `{PROJECT_PATH}/brand.ref` to resolve brand path:
+- Set `BRAND_PATH` = `.design/branding/{brand}`
+
+Determine final conformance level:
+1. `--level` flag (highest priority)
+2. `accessibility_level` from config.json
+3. Default: "WCAG 2.2 AA"
+
+### Read token and palette files
+
+Read from the brand/project:
 - `{BRAND_PATH}/identity/palettes.json`
 - `{BRAND_PATH}/identity/color-system.md`
 - `{BRAND_PATH}/patterns/tokens.json`
@@ -124,28 +132,28 @@ If files don't exist, report which are missing and stop.
 
 ### Token checks
 
-**5.1 Contrast Pairs:**
+**4.1 Contrast Pairs:**
 - Extract every semantic foreground/background pair from tokens.json
 - Calculate WCAG 2.x contrast ratio for each pair
 - Flag failures: normal text < 4.5:1, large text < 3:1, non-text < 3:1
 
-**5.2 Interactive States:**
+**4.2 Interactive States:**
 - Check hover, active, focus, disabled state color pairs
 - Verify disabled states still meet 3:1 non-text contrast
 
-**5.3 Focus Ring:**
+**4.3 Focus Ring:**
 - Find focus ring token — check >= 3:1 contrast against adjacent backgrounds
 - Verify ring width >= 2px
 
-**5.4 Dark Mode:**
+**4.4 Dark Mode:**
 - If dark mode tokens exist, re-verify all contrast pairs
 - Dark mode is a separate verification pass, not assumed from light mode
 
-**5.5 Touch Targets:**
+**4.5 Touch Targets:**
 - Check button/link sizing tokens >= 44px for primary actions, >= 24px minimum
 - Check spacing tokens between adjacent interactive elements
 
-**5.6 Typography Minimums:**
+**4.6 Typography Minimums:**
 - Body text >= 16px (1rem)
 - Caption/small text >= 12px
 - Line-height >= 1.5 for body text
@@ -193,156 +201,14 @@ Conformance target: {level}
 ### Completion
 
 Display result and use `AskUserQuestion`:
-- **Run full design audit** — "audit design screens for WCAG compliance"
-- **Run code audit** — "check the codebase for accessibility issues"
+- **Run full design audit** — "run `/gsp:accessibility-audit` for full WCAG design audit"
+- **Run code audit** — "run `/gsp:accessibility-audit --code` to check the codebase"
 - **Done** — "that's all for now"
 
-## Step 5: Design audit mode (default, no flags)
-
-Verify design chunks exist:
-- Read `{PROJECT_PATH}/design/INDEX.md` to find screen chunks
-- If no design chunks, tell user to complete design phase first and stop
-
-### Spawn agent
-
-Spawn `gsp-accessibility-auditor` with:
-- All design chunks from `{PROJECT_PATH}/design/`
-- Brand identity context (color system, typography)
-- Brand system context (tokens, components)
-- Conformance level
-- WCAG checklist reference
-- **Output path:** `{PROJECT_PATH}/critique/`
-- **Instructions:** "Audit all design screens against {level}. Write `accessibility-audit.md` and `accessibility-fixes.md` to the output path."
-
-### Completion
-
-Display result:
-
-```
-  /gsp:accessibility — design audit complete
-  ═══════════════════════════════════════
-
-  {PROJECT_PATH}/critique/
-  ├── accessibility-audit.md
-  └── accessibility-fixes.md
-
-  ─────────────────────────────────────
-```
-
-Use `AskUserQuestion`:
-- **Run token audit** — "check design token contrast pairs"
-- **Continue to build** — "implement designs in the codebase"
-- **View audit** — "read the accessibility report"
-- **Done** — "that's all for now"
-
-## Step 6: Code audit mode (`--code`)
-
-Determine codebase scope:
-- Read `{PROJECT_PATH}/config.json` for `implementation_target`
-- If build phase completed, read `{PROJECT_PATH}/build/BUILD-LOG.md` for file paths
-- Otherwise, use `implementation_target` to determine where to look
-
-### Spawn agent
-
-Spawn `gsp-accessibility-auditor` with:
-- Codebase paths to audit
-- Brand system tokens (for contrast verification against hardcoded values)
-- Conformance level
-- WCAG checklist reference
-- **Output path:** `{PROJECT_PATH}/review/`
-- **Instructions:** "Code audit mode. Use Grep and Glob to find accessibility issues in the codebase. Check ARIA, keyboard handlers, semantic HTML, heading hierarchy, alt text, lang attributes, skip-nav, focus management. Write `accessibility-audit.md` and `accessibility-fixes.md` to the output path with actual file paths and line numbers."
-
-### Completion
-
-Display result:
-
-```
-  /gsp:accessibility --code — code audit complete
-  ═══════════════════════════════════════
-
-  {PROJECT_PATH}/review/
-  ├── accessibility-audit.md
-  └── accessibility-fixes.md
-
-  ─────────────────────────────────────
-```
-
-Use `AskUserQuestion`:
-- **Fix issues** — "address the accessibility issues found"
-- **Generate statement** — "create an accessibility statement"
-- **View audit** — "read the code accessibility report"
-- **Done** — "that's all for now"
-
-## Step 7: Statement mode (`--statement`)
-
-Read prior audit results:
-- `{PROJECT_PATH}/critique/accessibility-audit.md`
-- `{PROJECT_PATH}/critique/accessibility-token-audit.md`
-- `{PROJECT_PATH}/review/accessibility-audit.md`
-
-If none exist, tell the user to run an audit first and stop.
-
-### Generate statement
-
-Write `{PROJECT_PATH}/exports/accessibility-statement.md`:
-
-```markdown
-# Accessibility Statement
-
-> Project: {name} | Generated: {DATE}
-
----
-
-## Conformance Status
-
-**Target:** {level}
-**Status:** {Partially Conformant / Fully Conformant}
-
-This {project description} has been evaluated against {level} standards.
-
-## Scope
-
-{Brief description of what was audited — design, code, or both}
-
-## Known Limitations
-
-{List from audit findings — critical/major issues not yet resolved}
-
-- {Issue}: {brief description} — {planned resolution or workaround}
-
-## Testing Methodology
-
-- Design audit: WCAG 2.2 checklist review of all screens
-- Token audit: Automated contrast ratio verification of all semantic color pairs
-- Code audit: Manual and grep-based review of ARIA, keyboard, semantic HTML
-- Tools used: {list from testing methodology}
-
-## Feedback
-
-If you encounter accessibility barriers, please contact:
-
-- **Email:** [placeholder@example.com]
-- **Response time:** [X business days]
-
-## Assessment Date
-
-Last reviewed: {DATE}
-```
-
-### Completion
-
-Display result and use `AskUserQuestion`:
-- **View statement** — "read the accessibility statement"
-- **Done** — "that's all for now"
-
-## Step 8: Update STATE.md
+## Step 5: Update STATE.md
 
 If within a project and files were written:
 - Read `{PROJECT_PATH}/STATE.md`
 - Note accessibility audit completion in the relevant phase section
 - Do not change phase status — accessibility is a supplementary check
-
-## Step 9: Completion output
-
-If not already displayed by a mode-specific step above, display the appropriate completion output and `AskUserQuestion` routing.
 </process>