get-shit-pretty 0.2.0 → 0.4.0

package/commands/gsp/brand-verbal.md

@@ -0,0 +1,94 @@
+---
+name: gsp:brand-verbal
+description: Verbal identity — voice, tone spectrum, messaging matrix, naming
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Task
+  - WebSearch
+  - WebFetch
+---
+<context>
+Phase 3 of the GSP branding diamond. Creates the brand's verbal identity — how it speaks, what it says, and how tone adapts across contexts. Built on the brand strategy (archetype, prism, positioning).
+</context>
+
+<objective>
+Create the brand's verbal identity system.
+
+**Input:** Strategy chunks (or STRATEGY.md fallback)
+**Output:** `.design/branding/{brand}/verbal/` (7 chunks + INDEX.md)
+**Agent:** `gsp-verbal-strategist`
+</objective>
+
+<execution_context>
+@/Users/jubs/.claude/get-shit-pretty/templates/phases/verbal.md
+@/Users/jubs/.claude/get-shit-pretty/references/voice-tone.md
+</execution_context>
+
+<process>
+## Step 1: Find brand
+
+Scan `.design/branding/` for brand directories. If only one brand exists, use it. If multiple, ask the user which brand to work on.
+
+Also read BRIEF.md for audience context.
+
+## Step 1.5: Load strategy output
+
+**Chunk-first:** Read `.design/branding/{brand}/strategy/INDEX.md`. If it exists, load all 6 strategy chunks.
+
+**Fallback:** If INDEX.md doesn't exist, read `.design/branding/{brand}/strategy/STRATEGY.md` (legacy monolith). Log: "⚠️ Legacy strategy format detected — consider re-running /gsp:brand-strategy for chunk output."
+
+If neither exists, tell the user to run `/gsp:brand-strategy` first.
+
+## Step 1.75: Voice direction (interactive)
+
+Load strategy/archetype.md communication style + strategy/brand-prism.md personality.
+If `.design/branding/{brand}/audit/` exists, load `audit/brand-inventory.md` voice samples.
+
+Present voice direction:
+
+"Your archetype ({archetype}) communicates with {style}.
+ {If evolve: "Your current voice sounds like: {samples from audit}.
+  We're {preserving/evolving} it."}
+
+ Here are two directions:
+ A: {direction} — '{example sentence}'
+ B: {direction} — '{example sentence}'
+
+ Which resonates? Or describe what you hear."
+
+Confirm voice direction. This direction is passed to the verbal strategist agent.
+
+## Step 2: Spawn verbal strategist
+
+Spawn the `gsp-verbal-strategist` agent with:
+- All strategy chunks (or STRATEGY.md fallback content)
+- The BRIEF.md content (for audience context)
+- The verbal identity template
+- The voice-tone reference
+- User-confirmed voice direction from Step 1.75
+- `.design/branding/{brand}/audit/brand-inventory.md` voice samples (if exist)
+- **Output path:** `.design/branding/{brand}/verbal/`
+
+The agent writes chunks directly to the verbal directory:
+1. `brand-voice.md`
+2. `tone-spectrum.md`
+3. `voice-chart.md`
+4. `messaging-matrix.md`
+5. `brand-narrative.md`
+6. `tagline-directions.md`
+7. `nomenclature.md`
+8. `INDEX.md`
+
+## Step 3: Update state
+
+Update `.design/branding/{brand}/STATE.md`:
+- Set Phase 3 (Verbal) status to `complete`
+- Record completion date
+
+## Step 4: Route next
+
+Display verbal identity summary (voice attributes, tone position, tagline directions) and end with:
+"Verbal identity updated. Run `/gsp:brand-identity` to continue — it will skip verbal and run visual identity."
+</process>

package/commands/gsp/brand.md

@@ -1,94 +1,20 @@
 ---
 name: gsp:brand
-description: Create brand identity — strategy, logo directions, color, typography
+description: Brand identity (alias for /gsp:brand-identity)
 allowed-tools:
   - Read
-  - Write
-  - Bash
-  - Task
-  - WebSearch
-  - WebFetch
 ---
-<context>
-Phase 2 of the GSP design pipeline. Uses the Brand Identity Creator prompt to develop a complete brand identity from strategy to visual applications.
-</context>
-
-<objective>
-Create a complete brand identity for the project.
-
-**Input:** `.design/BRIEF.md` + `.design/research/TRENDS.md`
-**Output:** `.design/brand/IDENTITY.md`
-**Agent:** `gsp-brand-strategist`
-</objective>
-
-<execution_context>
-@/Users/jubs/.claude/get-shit-pretty/prompts/02-brand-identity-creator.md
-@/Users/jubs/.claude/get-shit-pretty/templates/phases/brand.md
-</execution_context>
-
 <process>
-## Step 1: Load context
-
-Read:
-- `.design/BRIEF.md` — project context, audience, personality
-- `.design/research/TRENDS.md` — trend insights (if available; proceed without if not)
-
-If BRIEF.md doesn't exist, tell the user to run `/gsp:new-project` first.
-
-## Step 2: Spawn brand strategist
-
-Spawn the `gsp-brand-strategist` agent with:
-- The full BRIEF.md and TRENDS.md content
-- The Brand Identity Creator prompt (02)
-- The brand output template
-
-The agent should deliver:
-1. Brand strategy (story, archetype, voice matrix, messaging hierarchy)
-2. 3 logo directions with variations and usage rules
-3. Complete color system (Hex, RGB, Pantone, CMYK + rationale)
-4. Typography system
-5. Imagery and photography style guide
-6. Brand applications
-7. Brand book structure
-
-## Step 3: Generate color palettes via tints.dev
-
-For each brand color defined in the identity (primary, secondary, accent), generate a full 11-stop Tailwind palette using the [tints.dev](https://tints.dev) API by [Simeon Griggs](https://github.com/SimeonGriggs/tints.dev):
-
-```
-WebFetch: https://tints.dev/api/{colorName}/{hexWithout#}
+Display:
 ```
+🎨 GSP — Redirecting...
 
-Example: For primary color `#2522FC` → fetch `https://tints.dev/api/primary/2522FC`
-
-The API returns OKLCH values for stops 50–950. Store the raw palettes in `.design/brand/palettes.json` with this structure:
-
-```json
-{
-  "$schema": "tints.dev",
-  "$generator": "https://tints.dev by Simeon Griggs (https://github.com/SimeonGriggs/tints.dev)",
-  "primary": { "50": "oklch(...)", "100": "oklch(...)", ... "950": "oklch(...)" },
-  "secondary": { ... },
-  "accent": { ... }
-}
+/gsp:brand now redirects to /gsp:brand-identity.
+The branding diamond is 4 commands: brand-research → brand-strategy → brand-identity → brand-patterns.
 ```
 
-Also generate palette preview links for the user:
-- `https://tints.dev/primary/{hex}` — interactive palette editor
-
-## Step 4: Write output
-
-Write the completed identity to `.design/brand/IDENTITY.md`.
-Write the generated palettes to `.design/brand/palettes.json`.
-
-## Step 5: Update state
-
-Update `.design/STATE.md`:
-- Set Phase 2 (Brand) status to `complete`
-- Record completion date
-
-## Step 6: Route next
-
-Display brand identity summary and end with:
-"Run `/gsp:system` to build the design system from this identity."
+Tell the user:
+- To create a full brand from scratch: run `/gsp:new` and choose "Brand identity"
+- To run the identity phase (verbal + visual): run `/gsp:brand-identity`
+- To see all brand commands: run `/gsp:help`
 </process>

package/commands/gsp/brief.md

@@ -0,0 +1,142 @@
+---
+name: gsp:brief
+description: Project scoping — screen list, adaptations, gap analysis
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Task
+  - Grep
+  - Glob
+---
+<context>
+Phase 1 of the GSP project diamond. Scopes the project by determining what screens and components are needed, what adaptations the brand system requires for this specific project, and performs gap analysis against the codebase.
+
+Encourages treating the project as a bounded issue (or set of issues) and a PR — ship small, ship complete.
+
+Works with the dual-diamond architecture: reads brand system from `.design/branding/{brand}/system/` via `brand.ref`, reads/writes project assets in `.design/projects/{project}/`.
+</context>
+
+<objective>
+Scope the project and plan adaptations from the brand system.
+
+**Input:** Brand system (via brand.ref) + project BRIEF.md + config.json
+**Output:** `{project}/brief/` (scope.md, target-adaptations.md, conditionals, INDEX.md)
+**Agent:** `gsp-scoper`
+</objective>
+
+<execution_context>
+@/Users/jubs/.claude/get-shit-pretty/prompts/10-project-scoper.md
+@/Users/jubs/.claude/get-shit-pretty/templates/phases/brief.md
+</execution_context>
+
+<process>
+## Step 0: Resolve project and brand
+
+Scan `.design/projects/` for project directories. If only one project exists, use it. If multiple, ask the user which project to work on.
+
+Set `PROJECT_PATH` = `.design/projects/{project}`
+
+Read `{PROJECT_PATH}/brand.ref` to resolve brand path:
+- Extract `brand` name and `path` from brand.ref
+- Set `BRAND_PATH` = `.design/branding/{brand}`
+
+If brand.ref doesn't exist, tell the user to run `/gsp:new` to set up the project with a brand reference.
+
+## Step 1: Load context
+
+### Brand system (chunk-first)
+
+Read `{BRAND_PATH}/system/INDEX.md`. If it exists, load all foundation chunks + selective component chunks.
+
+Fallback: read `{BRAND_PATH}/system/SYSTEM.md` (legacy monolith). Log: "⚠️ Legacy system format detected."
+
+If neither exists, tell the user to run `/gsp:brand-system` first to create the brand's design system.
+
+Also read `{BRAND_PATH}/system/tokens.json`.
+
+### Project context
+
+Read:
+- `{PROJECT_PATH}/BRIEF.md` — what we're building, platforms, tech stack
+- `{PROJECT_PATH}/config.json` — get `implementation_target`, `design_scope`, `codebase_type`
+
+### Codebase context
+
+Read `{PROJECT_PATH}/codebase/INVENTORY.md` (if exists) — existing tokens, components, architecture.
+
+Read `.design/CHANGELOG.md` — quick history of what prior projects built.
+For projects with overlapping scope, read their `codebase/MANIFEST.md` for detail.
+Glob `.design/projects/*/STATE.md` — detect active sibling projects.
+
+## Step 1.5: Scope check
+
+**If `design_scope` is `tokens`:**
+1. Update `{PROJECT_PATH}/STATE.md` — set Phase 1 (Brief) status to `skipped`
+2. Display: "Brief phase skipped — design scope is `tokens`."
+3. Route: "Run `/gsp:build`."
+4. Stop here.
+
+## Step 1.7: Issue framing
+
+Suggest to the user:
+"Consider framing this project as a bounded issue (or set of issues) and a PR. Smaller scope = higher quality. What's the tightest version of this that ships?"
+
+If the project scope feels large, suggest breaking it into multiple bounded issues — each one a focused deliverable that can be reviewed independently.
+
+## Step 2: Spawn scoper
+
+Spawn the `gsp-scoper` agent with:
+- Brand system chunks (or fallback)
+- tokens.json
+- BRIEF.md
+- config.json preferences
+- INVENTORY.md (when exists)
+- CHANGELOG.md + relevant MANIFEST.md files — for overlap detection and provenance
+- The Project Scoper prompt (10)
+- The brief output template
+- `implementation_target`, `design_scope`, `codebase_type`
+- **Output path:** `{PROJECT_PATH}/brief/`
+
+If any sibling project is active and its scope overlaps with this project, flag it: "⚠️ {name} is actively working on {scope}. Coordinate to avoid conflicts."
+If this project modifies components from a sibling's manifest, note provenance.
+
+The agent writes chunks directly:
+- `brief/scope.md`
+- `brief/target-adaptations.md`
+- `brief/install-manifest.md` (shadcn/rn-reusables)
+- `brief/gap-analysis.md` (existing target)
+- `brief/file-references.md` (existing target)
+- `brief/INDEX.md`
+
+## Step 3: Write exports
+
+Update `{PROJECT_PATH}/exports/INDEX.md`:
+- If INDEX.md doesn't exist, copy it from `templates/exports-index.md`
+- Replace everything between `<!-- BEGIN:brief -->` and `<!-- END:brief -->` with populated table:
+
+```markdown
+<!-- BEGIN:brief -->
+| Section | File |
+|---------|------|
+| Scope | [scope.md](../brief/scope.md) |
+| Target Adaptations | [target-adaptations.md](../brief/target-adaptations.md) |
+| Install Manifest | [install-manifest.md](../brief/install-manifest.md) |
+| Gap Analysis | [gap-analysis.md](../brief/gap-analysis.md) |
+| File References | [file-references.md](../brief/file-references.md) |
+<!-- END:brief -->
+```
+
+Only include rows for chunks that were actually produced.
+
+## Step 4: Update state
+
+Update `{PROJECT_PATH}/STATE.md`:
+- Set Phase 1 (Brief) status to `complete`
+- Record completion date
+
+## Step 5: Route next
+
+"Run `/gsp:research` to research UX patterns, competitor experiences, and technical approaches for this project."
+</process>
+</output>

package/commands/gsp/build.md

@@ -8,15 +8,17 @@ allowed-tools:
   - Task
 ---
 <context>
-Phase 7 of the GSP design pipeline. Uses the Design-to-Code Translator prompt to convert implementation specs and design system into production-ready frontend components.
+Phase 5 of the GSP project diamond. Uses the Design-to-Code Translator prompt to convert design, research, and brief into production-ready frontend components.
+
+Works with the dual-diamond architecture: reads brand system from `.design/branding/{brand}/system/` via `brand.ref`, reads/writes project assets in `.design/projects/{project}/`.
 </context>
 
 <objective>
 Translate designs into production-ready frontend code.
 
-**Input:** `.design/specs/SPECS.md` (or SCREENS.md + SYSTEM.md if spec was skipped) + `.design/system/SYSTEM.md`
-**Output:** `.design/build/CODE.md` + `.design/build/components/`
-**Agent:** `gsp-design-engineer`
+**Input:** Design chunks + research chunks + brief chunks + brand system chunks
+**Output:** `{project}/build/CODE.md` + `{project}/build/components/`
+**Agent:** `gsp-builder`
 </objective>
 
 <execution_context>
@@ -25,60 +27,66 @@ Translate designs into production-ready frontend code.
 </execution_context>
 
 <process>
-## Step 1: Load context
+## Step 0: Resolve project and brand
 
-Read `.design/config.json` to get `implementation_target`.
+Scan `.design/projects/` for project directories. If only one project exists, use it. If multiple, ask the user which project to work on.
 
-Read:
-- `.design/specs/SPECS.md` — implementation specs (primary input)
-- `.design/system/SYSTEM.md` — design system
-- `.design/system/tokens.json` — design tokens
-- `.design/BRIEF.md` — tech stack preference
-- `.design/review/CRITIQUE.md` — any fixes to incorporate
+Set `PROJECT_PATH` = `.design/projects/{project}`
 
-If SPECS.md doesn't exist, check if `implementation_target` is `skip`:
-- **If `skip`:** Read `.design/screens/SCREENS.md` + `.design/system/SYSTEM.md` as primary input instead
-- **If not `skip`:** Tell the user to run `/gsp:spec` first
+Read `{PROJECT_PATH}/brand.ref` to resolve brand path:
+- Set `BRAND_PATH` = `.design/branding/{brand}`
+
+## Step 1: Load context
 
-Determine tech stack from BRIEF.md config (default: React + Tailwind).
+Read `{PROJECT_PATH}/config.json` to get `implementation_target`, `design_scope`, `codebase_type`.
 
-## Step 2: Spawn design engineer
+**When building a specific screen** (user specifies which) and chunks are available:
+1. Read `{PROJECT_PATH}/exports/INDEX.md` — find chunk file paths
+2. Load screen chunk: `{PROJECT_PATH}/design/screen-{NN}-{name}.md`
+3. Load referenced component chunks from `{BRAND_PATH}/system/components/`
+4. Load `{PROJECT_PATH}/brief/target-adaptations.md`
+5. Load `{PROJECT_PATH}/brief/install-manifest.md` (shadcn/rn-reusables)
+5b. Load `{PROJECT_PATH}/brief/gap-analysis.md` + `file-references.md` (existing target)
+5d. Load `{PROJECT_PATH}/research/reference-specs.md` (if exists)
+5e. Load `{PROJECT_PATH}/research/technical-research.md` (if exists)
+5c. Load `{PROJECT_PATH}/codebase/INVENTORY.md` (when exists)
+6. Load `{BRAND_PATH}/system/tokens.json`
+7. Read `{PROJECT_PATH}/BRIEF.md` — tech stack preference
+8. Load `{PROJECT_PATH}/critique/prioritized-fixes.md` (if available)
 
-Spawn the `gsp-design-engineer` agent with:
-- All specs/screens, system, and token files
-- The Design-to-Code Translator prompt (09)
-- The build output template
-- The target tech stack
-- The `implementation_target` value
+**When building all screens** (or no chunks available):
+Read full monolith files from `{PROJECT_PATH}/` as fallback. Log: "⚠️ Legacy format detected — consider re-running phases for chunk output."
 
-**When `shadcn`:** Agent should use `npx shadcn@latest add` for components, extend with custom variants as defined in SPECS.md.
+If design doesn't exist (no INDEX.md in design/), tell the user to run `/gsp:design` first.
 
-**When `rn-reusables`:** Agent should use `npx @react-native-reusables/cli add` for components, configure NativeWind theming.
+## Step 2: Spawn builder
 
-The agent should deliver:
-1. Component hierarchy with props, state, data flow
-2. Production-ready code for each component
-3. Responsive layout implementation
-4. ARIA and accessibility implementation
-5. Error, loading, and empty states
-6. Animations and transitions
-7. Styling with design tokens (dark mode, breakpoints)
-8. Performance optimization notes
-9. Testing strategy
+Spawn the `gsp-builder` agent with all design, plan, system, and token files, the Design-to-Code Translator prompt (09), build output template, target tech stack, implementation_target, design_scope, and codebase inventory.
+
+**When `design_scope` is `tokens`:**
+- Output token files only
+- Skip component code generation
 
 ## Step 3: Write output
 
-1. Write implementation guide to `.design/build/CODE.md`
-2. Write individual components to `.design/build/components/`
+1. Write implementation guide to `{PROJECT_PATH}/build/CODE.md`
+2. Write individual components to `{PROJECT_PATH}/build/components/`
+
+### Write manifest
+
+Write `{PROJECT_PATH}/codebase/MANIFEST.md` from `templates/manifest.md`:
+1. **Components table** — one row per component produced (scan `build/components/`). Action = `added` or `modified` based on INVENTORY.md.
+2. **Patterns table** — patterns established (infer from CODE.md).
+3. **Files Touched** — flat list of all target file paths.
 
 ## Step 4: Update state
 
-Update `.design/STATE.md`:
-- Set Phase 7 (Build) status to `complete`
+Update `{PROJECT_PATH}/STATE.md`:
+- Set Phase 5 (Build) status to `complete`
 - Record completion date
 
 ## Step 5: Route next
 
-Display component summary and end with:
-"Run `/gsp:launch` to create marketing campaign assets."
+"Run `/gsp:review` to validate built deliverables against design intent."
 </process>
+</output>

package/commands/gsp/critique.md

@@ -0,0 +1,140 @@
+---
+name: gsp:critique
+description: Design critique (Nielsen's heuristics) + WCAG accessibility audit
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Task
+---
+<context>
+Phase 4 of the GSP project diamond. Runs two agents in parallel: the Design Critique Partner (Nielsen's 10 heuristics) and the Accessibility Auditor (WCAG 2.2 AA).
+
+Works with the dual-diamond architecture: reads brand context from `.design/branding/{brand}/` via `brand.ref`, reads/writes project assets in `.design/projects/{project}/`.
+</context>
+
+<objective>
+Critique design quality and audit accessibility compliance.
+
+**Input:** All prior project chunks + brand identity
+**Output:** `{project}/critique/` (critique + accessibility chunks + INDEX.md) + exports/INDEX.md update
+**Agents:** `gsp-critic` + `gsp-auditor`
+</objective>
+
+<execution_context>
+@/Users/jubs/.claude/get-shit-pretty/prompts/06-design-critique-partner.md
+@/Users/jubs/.claude/get-shit-pretty/prompts/08-accessibility-auditor.md
+@/Users/jubs/.claude/get-shit-pretty/templates/phases/critique.md
+@/Users/jubs/.claude/get-shit-pretty/references/nielsen-heuristics.md
+@/Users/jubs/.claude/get-shit-pretty/references/wcag-checklist.md
+</execution_context>
+
+<process>
+## Step 0: Resolve project and brand
+
+Scan `.design/projects/` for project directories. If only one project exists, use it. If multiple, ask the user which project to work on.
+
+Set `PROJECT_PATH` = `.design/projects/{project}`
+
+Read `{PROJECT_PATH}/brand.ref` to resolve brand path:
+- Set `BRAND_PATH` = `.design/branding/{brand}`
+
+## Step 1: Load context
+
+Read `{PROJECT_PATH}/config.json` to get `implementation_target`, `design_scope`, and `accessibility_level`.
+
+### Load all prior chunks (chunk-first with fallbacks)
+
+**BRIEF:** `{PROJECT_PATH}/BRIEF.md`
+
+**Identity:** Read `{BRAND_PATH}/identity/INDEX.md` → load all chunks.
+Fallback: `{BRAND_PATH}/identity/IDENTITY.md`.
+
+**System:** Read `{BRAND_PATH}/system/INDEX.md` → load all chunks.
+Fallback: `{BRAND_PATH}/system/SYSTEM.md`.
+
+**Design:** Read `{PROJECT_PATH}/design/INDEX.md` → load all chunks.
+Fallback: `{PROJECT_PATH}/design/SCREENS.md` or `{PROJECT_PATH}/screens/INDEX.md` (legacy).
+
+**Brief:** Read `{PROJECT_PATH}/brief/INDEX.md` → load all chunks (if exists).
+
+**Research:** Read `{PROJECT_PATH}/research/INDEX.md` → load `recommendations.md` (if exists).
+
+## Step 1.5: Scope check
+
+**If `design_scope` is `tokens`:**
+1. Review system chunks only — token foundations, naming, scale consistency
+2. Run accessibility audit on color contrast and token values only
+3. Write results to `{PROJECT_PATH}/critique/accessibility-audit.md` and `accessibility-fixes.md`
+4. Write `{PROJECT_PATH}/critique/INDEX.md`
+5. Update STATE.md — set Phase 4 to `complete`
+6. Route: "Run `/gsp:build`."
+7. **Stop here**
+
+**Otherwise:** If design chunks don't exist and scope is not `tokens`, tell the user to complete the design phase first.
+
+## Step 2: Spawn critics (parallel)
+
+**Agent 1: gsp-critic** — Design critique using Nielsen's 10 Heuristics reference + all design chunks.
+Output path: `{PROJECT_PATH}/critique/`
+
+**Agent 2: gsp-auditor** — WCAG 2.2 audit using WCAG checklist + all design chunks. Pass `accessibility_level` from config (defaults to "WCAG 2.2 AA") so the auditor adapts its criteria (AA vs AAA).
+Output path: `{PROJECT_PATH}/critique/`
+
+## Step 3: Write critique INDEX.md
+
+After both agents complete, write `{PROJECT_PATH}/critique/INDEX.md`:
+
+```markdown
+# Critique
+> Phase: critique | Project: {name} | Generated: {DATE}
+
+## Critique
+
+| Chunk | File | ~Lines |
+|-------|------|--------|
+| Critique | [critique.md](./critique.md) | ~{N} |
+| Prioritized Fixes | [prioritized-fixes.md](./prioritized-fixes.md) | ~{N} |
+| Alternative Directions | [alternative-directions.md](./alternative-directions.md) | ~{N} |
+| Strengths | [strengths.md](./strengths.md) | ~{N} |
+
+## Accessibility
+
+| Chunk | File | ~Lines |
+|-------|------|--------|
+| Accessibility Audit | [accessibility-audit.md](./accessibility-audit.md) | ~{N} |
+| Accessibility Fixes | [accessibility-fixes.md](./accessibility-fixes.md) | ~{N} |
+```
+
+Update `{PROJECT_PATH}/exports/INDEX.md`:
+
+```markdown
+<!-- BEGIN:critique -->
+| Section | File |
+|---------|------|
+| Critique | [critique.md](../critique/critique.md) |
+| Prioritized Fixes | [prioritized-fixes.md](../critique/prioritized-fixes.md) |
+| Alternative Directions | [alternative-directions.md](../critique/alternative-directions.md) |
+| Strengths | [strengths.md](../critique/strengths.md) |
+| Accessibility Audit | [accessibility-audit.md](../critique/accessibility-audit.md) |
+| Accessibility Fixes | [accessibility-fixes.md](../critique/accessibility-fixes.md) |
+<!-- END:critique -->
+```
+
+## Step 4: Assess results
+
+**If critical issues found:** Display issues, recommend looping back, update STATE.md review loops.
+**If no critical issues:** Display positive summary, proceed.
+
+## Step 5: Update state
+
+Update `{PROJECT_PATH}/STATE.md`:
+- Set Phase 4 (Critique) status to `complete` or `needs-revision`
+- Record review loop count and completion date
+
+## Step 6: Route next
+
+If clean: "Run `/gsp:build` to translate designs to code."
+If issues: "Address the critical issues above, then run `/gsp:critique` again."
+</process>
+</output>