get-shit-pretty 0.2.0 → 0.4.0

package/commands/gsp/launch.md

@@ -9,14 +9,16 @@ allowed-tools:
   - WebSearch
 ---
 <context>
-Phase 8 of the GSP design pipeline. Uses the Marketing Asset Factory prompt to create a full campaign asset library across channels.
+Optional GSP project phase. Uses the Marketing Asset Factory prompt to create a full campaign asset library across channels. Not a mandatory phase — run when needed.
+
+Works with the dual-diamond architecture: reads brand identity from `.design/branding/{brand}/` via `brand.ref`, reads/writes project assets in `.design/projects/{project}/`.
 </context>
 
 <objective>
 Create marketing campaign assets for product launch.
 
-**Input:** `.design/brand/IDENTITY.md` + `.design/screens/SCREENS.md`
-**Output:** `.design/launch/CAMPAIGN.md`
+**Input:** Brand identity + verbal chunks (selective) + screen chunks
+**Output:** `{project}/launch/` (6 chunks + INDEX.md) + exports/INDEX.md update
 **Agent:** `gsp-campaign-director`
 </objective>
 
@@ -26,50 +28,68 @@ Create marketing campaign assets for product launch.
 </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:
-- `.design/brand/IDENTITY.md` — brand voice, visual identity
-- `.design/screens/SCREENS.md` — product screens for showcase
-- `.design/BRIEF.md` — audience, goals, messaging
-- `.design/system/SYSTEM.md` — design system for consistency
+Read `{PROJECT_PATH}/config.json` to get `design_scope`.
 
-If IDENTITY.md doesn't exist, tell the user to run `/gsp:brand` first.
+**If `design_scope` is `tokens`:**
+1. Display: "Launch phase skipped — tokens-only projects don't need marketing campaign assets."
+2. **Stop here**
 
-## Step 2: Spawn campaign director
+### Identity (selective, chunk-first)
+
+Read `{BRAND_PATH}/identity/INDEX.md`. If it exists, load all identity chunks.
+Fallback: read `{BRAND_PATH}/identity/IDENTITY.md`. Log: "⚠️ Legacy identity format detected."
+
+If neither exists, tell the user to complete the brand identity first.
 
-Spawn the `gsp-campaign-director` agent with:
-- Brand identity, screens, and brief
-- The Marketing Asset Factory prompt (04)
-- The launch output template
+### Verbal (selective, chunk-first)
 
-The agent should deliver:
-1. Campaign strategy (objective, audience, key message, tone)
-2. Google Ads (copy, visual direction, CTAs, A/B variants)
-3. Meta/Instagram and TikTok ads
-4. Email sequences (welcome, promo, nurture, re-engagement)
-5. Landing page copy and structure
-6. Social media posts
-7. Sales enablement materials
-8. Content marketing outlines
+Read `{BRAND_PATH}/verbal/INDEX.md`. If it exists, load selective chunks (brand-voice, messaging-matrix, brand-narrative).
+Fallback: read `{BRAND_PATH}/verbal/VERBAL.md`.
 
-## Step 3: Write output
+### Design (chunk-first)
 
-Write campaign to `.design/launch/CAMPAIGN.md`.
+Read `{PROJECT_PATH}/design/INDEX.md`. If it exists, load all screen chunks.
+Fallback: read `{PROJECT_PATH}/screens/INDEX.md` (legacy path).
 
-## Step 4: Update state
+### Other
 
-Update `.design/STATE.md`:
-- Set Phase 8 (Launch) status to `complete`
+Read `{PROJECT_PATH}/BRIEF.md` — audience, goals.
+
+## Step 2: Spawn campaign director
+
+Spawn the `gsp-campaign-director` agent with identity chunks, verbal chunks, screen chunks, and brief. The Marketing Asset Factory prompt (04). The launch output template.
+
+**Output path:** `{PROJECT_PATH}/launch/`
+
+The agent writes chunks directly:
+- `launch/campaign-strategy.md`
+- `launch/digital-ads.md`
+- `launch/email-sequences.md`
+- `launch/landing-page.md`
+- `launch/social-media.md`
+- `launch/sales-content.md`
+- `launch/INDEX.md`
+- Updates `{PROJECT_PATH}/exports/INDEX.md` (launch section)
+
+## Step 3: Update state
+
+Update `{PROJECT_PATH}/STATE.md`:
+- Add Launch status to `complete` under the Launch section
 - Record completion date
-- Set Prettiness Level to 100%
 
-## Step 5: Celebrate
+## Step 4: Done
 
 Display campaign summary and:
-```
-🎨 Project is fully pretty! All 8 phases complete.
-
-Run /gsp:progress to see the full journey.
-```
+"Launch assets complete! Run `/gsp:progress` to see the full journey."
 </process>

package/commands/gsp/new-project.md

@@ -1,98 +1,17 @@
 ---
 name: gsp:new-project
-description: Initialize a new design project with a design brief, roadmap, and state tracking
+description: Initialize a new design project (redirects to /gsp:new)
 allowed-tools:
   - Read
-  - Write
-  - Bash
-  - AskUserQuestion
 ---
-<context>
-You are the GSP (Get Shit Pretty) project initializer. Your job is to gather design requirements through conversational Q&A and produce a complete design brief.
-</context>
-
-<objective>
-Initialize a new design project through guided questioning → brief → roadmap → state.
-
-**Creates:**
-- `.design/BRIEF.md` — design brief (brand, audience, goals, constraints)
-- `.design/ROADMAP.md` — phase plan (8 phases)
-- `.design/STATE.md` — progress tracking
-- `.design/config.json` — project preferences
-
-**After this command:** Run `/gsp:research` to begin the design pipeline.
-</objective>
-
-<execution_context>
-@/Users/jubs/.claude/get-shit-pretty/references/questioning.md
-@/Users/jubs/.claude/get-shit-pretty/templates/project.md
-@/Users/jubs/.claude/get-shit-pretty/templates/roadmap.md
-@/Users/jubs/.claude/get-shit-pretty/templates/state.md
-@/Users/jubs/.claude/get-shit-pretty/templates/config.json
-</execution_context>
-
 <process>
-## Step 1: Greet and orient
-
 Display:
 ```
-🎨 GSP — Get Shit Pretty
-Starting new design project...
-```
-
-## Step 2: Gather the brief
-
-Use the questioning techniques from the reference. Ask in 3 conversational rounds:
+🎨 GSP — Redirecting...
 
-**Round 1 — Context & Brand:**
-- What is this project? (app, website, rebrand, campaign)
-- Who is it for? (audience)
-- Why does it exist? (business goal, user need)
-- Existing brand? Brand personality?
-- Brands admired / styles to avoid?
-
-**Round 2 — Scope & Constraints:**
-- Platforms (web, iOS, Android)?
-- Tech stack preferences?
-- Implementation target — how will designs become code?
-  - Using a UI kit? (shadcn/ui → `shadcn`, React Native Reusables → `rn-reusables`)
-  - Existing design system already in the codebase? (`existing`)
-  - Need Figma handoff? (`figma`)
-  - Straight to code with no specific UI kit? (`code`)
-  - Skip specs entirely, build directly from screen designs? (`skip`)
-  - Default: `code`
-- Key screens/pages needed?
-- Accessibility level (default: WCAG 2.2 AA)?
-- Timeline and constraints?
-
-**Round 3 — Success & Gaps:**
-- What does success look like?
-- Any remaining questions based on gaps in rounds 1-2
-
-Use inference over interrogation — state assumptions and let them correct. Offer concrete options when answers are vague.
-
-## Step 3: Create project structure
-
-```bash
-mkdir -p .design/{research,brand,system,screens,specs,review,build,launch}
+/gsp:new-project has been replaced by /gsp:new in GSP 0.4.0.
+/gsp:new is a smart entry point that handles both brand creation and project setup.
 ```
 
-## Step 4: Write artifacts
-
-Using the templates, fill in the gathered information:
-1. Write `.design/BRIEF.md` from the project template with all gathered info
-2. Write `.design/ROADMAP.md` from the roadmap template with project name and date
-3. Write `.design/STATE.md` from the state template
-4. Write `.design/config.json` from the config template with preferences (including `implementation_target` from Round 2)
-
-## Step 5: Confirm and route
-
-Display a summary of the brief and confirm with the user. Show:
-- Project name and type
-- Brand personality
-- Target audience
-- Key deliverables
-- Phase roadmap overview
-
-End with: "Run `/gsp:research` to begin trend analysis, or `/gsp:brand` to jump straight to brand identity."
+Tell the user to run `/gsp:new` instead.
 </process>

package/commands/gsp/new.md

@@ -0,0 +1,237 @@
+---
+name: gsp:new
+description: Start a new brand or design project — smart entry point
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+  - Glob
+  - Grep
+  - Agent
+---
+<context>
+You are the GSP (Get Shit Pretty) entry point — a design lead starting a first call with a client. You scan the codebase and `.design/` directory, greet the user with what you found, and flow naturally into the right workflow.
+
+GSP uses a dual-diamond architecture:
+- **Diamond 1 — Branding** (5 commands, 6 phases): [brand-audit] → brand-research → brand-strategy → brand-identity → brand-patterns
+- **Diamond 2 — Project** (6 phases): brief → research → design → critique → build → review
+- **Optional:** launch (on request)
+
+Multiple brands and projects can coexist. Projects reference a brand.
+</context>
+
+<objective>
+Through 2-3 rounds of natural conversation, gather a complete brief and create the right project structure (brand, project, or both). Route the user to their first phase command.
+</objective>
+
+<execution_context>
+@/Users/jubs/.claude/get-shit-pretty/references/questioning.md
+@/Users/jubs/.claude/get-shit-pretty/templates/branding/brief.md
+@/Users/jubs/.claude/get-shit-pretty/templates/branding/state.md
+@/Users/jubs/.claude/get-shit-pretty/templates/branding/config.json
+@/Users/jubs/.claude/get-shit-pretty/templates/branding/roadmap.md
+@/Users/jubs/.claude/get-shit-pretty/templates/projects/brief.md
+@/Users/jubs/.claude/get-shit-pretty/templates/projects/state.md
+@/Users/jubs/.claude/get-shit-pretty/templates/projects/config.json
+@/Users/jubs/.claude/get-shit-pretty/templates/projects/roadmap.md
+@/Users/jubs/.claude/get-shit-pretty/templates/codebase-inventory.md
+@/Users/jubs/.claude/get-shit-pretty/templates/exports-index.md
+</execution_context>
+
+<questioning_principles>
+Follow these principles throughout all conversations:
+
+1. **Inference over interrogation** — state assumptions, let them correct. "SaaS dashboard for enterprise" → you already know: professional, data-dense, web-first.
+2. **Progressive disclosure** — don't dump all questions at once. Flow in natural rounds.
+3. **Concrete options over open-ended** — "More like Stripe's clean approach or Duolingo's playful style?" beats "What style do you want?"
+4. **Know when you have enough** — fill gaps with smart defaults. Don't over-ask.
+5. **One message per round** — ask a cohesive set of related questions, not one at a time.
+</questioning_principles>
+
+<process>
+## Step 1: Scan and greet (parallel)
+
+### Step 1a: Scan `.design/` (sync — fast)
+
+Scan `.design/` for existing brands and projects:
+- Check `.design/branding/` for brand directories (each has a `config.json` with `project_type: "brand"`)
+- Check `.design/projects/` for project directories (each has a `config.json` with `project_type: "design"`)
+- Check for legacy flat `.design/config.json` at root (pre-0.4.0 structure)
+- For each brand/project found, read its `config.json` to get phase statuses
+- If `.design/CHANGELOG.md` doesn't exist, create it from `templates/changelog.md`
+
+### Step 1b: Spawn codebase scanner (background)
+
+Spawn the `gsp-codebase-scanner` agent with `run_in_background: true`:
+- Use `subagent_type: "Explore"` with the scanner's methodology
+- Prompt: "Scan this codebase following the gsp-codebase-scanner methodology. Return a structured report with classification, tech stack, components, tokens, architecture patterns, conventions, and key paths. Read `.design/CHANGELOG.md` and scan `.design/projects/*/STATE.md` for sibling project context. If no package.json exists, return a minimal greenfield report."
+- Store the task reference — you'll consume results in Step 3 Round 2 or Step 4.
+
+### Step 1c: Greet
+
+Greet based on `.design/` findings from Step 1a. No menus, no formal option lists — just talk.
+
+If a `package.json` exists (quick check via glob — don't wait for the full scan), add to the greeting: "I'm scanning your codebase in the background — I'll factor in what I find."
+
+Adapt the greeting based on what the scan revealed:
+
+**Fresh start (no `.design/`):**
+```
+🎨 GSP — Get Shit Pretty
+
+Looks like a fresh start! Tell me about what you're building — I'll figure out whether we need brand work, a design project, or both.
+```
+
+**Legacy `.design/` detected (flat structure, pre-0.4.0):**
+Acknowledge the legacy project, note it still works with current commands. Offer to start a new brand or project alongside it using the new dual-diamond structure.
+
+**Brands exist, no projects:**
+Show existing brands with status. Then: "Want to start a design project with one of these, or create a new brand?"
+
+**Brands + projects exist:**
+Show a brief overview of brands and projects with status. Then: "Starting something new, or continuing work on one of these?" If continuing → route to `/gsp:progress`.
+
+**Codebase signals found (any state):**
+Weave in what you found: "I see you've got a [Next.js/React Native/etc.] project here with [Tailwind/shadcn/etc.] — I'll factor that into the design scope."
+
+**Important:** Only use `AskUserQuestion` if there's genuine ambiguity that can't be resolved conversationally — e.g., picking between 3+ existing brands. For the initial "what are you building?" — just ask in prose and let them answer naturally.
+
+## Step 2: Route based on conversation
+
+From the greeting exchange, determine which flow to run:
+
+- **Brand identity (new)** → Brand flow (Step 3) with `brand_mode: "new"`
+- **Brand identity (evolve)** → Brand flow (Step 3) with `brand_mode: "evolve"`. Detect evolve signals: user mentions existing brand, assets, guidelines, rebrand, refresh, modernize, evolve, update, redesign.
+- **Design project** → Check for brands first. If none exist, explain they need a brand first. Offer to create one, then auto-transition to project flow.
+- **Full design (brand + project)** → Brand flow (Step 3), with E2E flag so brand completion auto-transitions to project flow (Step 4)
+- **Continue existing work** → route to `/gsp:progress`
+
+## Step 3: Brand flow
+
+1. Ask for brand name (kebab-case, e.g., "acme-corp")
+2. Create directory structure:
+```bash
+mkdir -p .design/branding/{name}/{audit,discover,strategy,verbal,identity,system}
+```
+
+3. Gather brand brief in 2 rounds:
+
+**Round 1 — Core:**
+- Company name, industry, founding story
+- Target audience (primary + secondary)
+- Brand personality — how should the brand feel? Offer concrete comparisons: "More like Stripe's precision or Mailchimp's warmth?"
+- Mission and vision
+- Brands admired / styles to avoid
+- What the brand should NEVER be
+
+Use inference: if they say "fintech for Gen Z" → infer modern, mobile-first, bold. State your inferences and let them correct.
+
+**Round 2 — Gaps & constraints:**
+- Existing brand assets? (logo, colors, guidelines)
+- Competitive landscape — who are the main competitors?
+- Timeline and budget constraints
+- Any non-negotiables?
+- **Check background scan:** If the codebase scanner has returned results, weave tech findings into the conversation naturally — e.g., "I see you're running Next.js with Tailwind and shadcn — that'll inform the design system." If not done yet, continue without — results will be available by Step 4.
+- State your understanding back: "Here's what I'm hearing: [summary]. Anything I'm missing?"
+
+**Evolve mode additions (when `brand_mode` is `evolve`):**
+Add to Round 2:
+- Current brand age — how long has the current brand been in use?
+- Existing guidelines? — do they have a brand book, style guide, or guidelines doc?
+- Brand equity — what's working well with the current brand?
+- Pain points — what's not working or feels outdated?
+- Evolution scope — what should be preserved vs evolved vs replaced?
+
+Fill in the Brand Mode and Existing Brand State sections of the brief template.
+
+Skip or compress rounds if the user gives enough upfront. Don't over-ask.
+
+4. Write artifacts:
+- `.design/branding/{name}/BRIEF.md` from brand brief template
+- `.design/branding/{name}/STATE.md` from brand state template
+- `.design/branding/{name}/config.json` from brand config template
+- `.design/branding/{name}/ROADMAP.md` from brand roadmap template
+
+5. Set `brand_mode` in config.json based on Step 2 routing decision.
+
+6. Route:
+- **Brand-only, new →** "Run `/gsp:brand-research` to start brand research."
+- **Brand-only, evolve →** "Let's audit your current brand first. Run `/gsp:brand-audit`."
+- **E2E, new →** "Brand brief created. Now let's scope the design project." → continue to Step 4.
+- **E2E, evolve →** "Brand brief created. Run `/gsp:brand-audit` to audit your existing brand first, then we'll scope the design project."
+
+## Step 4: Project flow
+
+1. Show available brands:
+```
+Available brands:
+  • acme-corp (complete — all 5 phases)
+  • beta-labs (in progress — 2/5 phases)
+```
+
+If no brands exist, explain that a brand is needed first and offer to create one.
+If only one complete brand exists, suggest it as default.
+
+2. User selects a brand.
+
+3. Ask for project name (kebab-case, e.g., "acme-website")
+
+4. Create directory structure:
+```bash
+mkdir -p .design/projects/{name}/{brief,research,design,critique,build,review,codebase,exports}
+```
+
+### Detect git context
+
+1. Run `git branch --show-current` to detect current branch
+2. If a branch is detected, present it: "I see you're on `{branch}` — I'll track this as the project branch."
+3. Let user confirm or provide a different branch name
+4. Store in config.json `git.branch` and STATE.md `## Git` table
+5. If no git repo detected, skip silently — leave fields as "—"
+
+5. Write `brand.ref`:
+```
+brand: {brand-name}
+path: ../../branding/{brand-name}/
+consumed_at: {ISO_DATE}
+identity_hash: {first 8 chars of md5 of IDENTITY.md content, or "pending" if identity not complete}
+```
+Write to `.design/projects/{name}/brand.ref`
+
+6. Consume background scan results:
+- Retrieve the codebase scanner's structured report (guaranteed done by now — conversation has been going for multiple rounds)
+- If **greenfield**: no INVENTORY.md needed, note classification for config.json
+- If **boilerplate** or **existing**: write INVENTORY.md to `.design/projects/{name}/codebase/INVENTORY.md` using the scanner's report and the `templates/codebase-inventory.md` template
+- Auto-infer `implementation_target` from the scanner's tech stack and components
+
+7. Gather project brief in 2 rounds:
+
+**Round 1 — What we're building:**
+- What are we building? (app, website, dashboard, etc.)
+- Present background scan findings: "I found a {classification} {framework} project with {details}. Want to build on that?"
+- Platforms (web, iOS, Android)?
+- Tech stack preferences? (confirm inferred or ask)
+- Implementation target (present options based on codebase analysis)
+- Design scope (full | partial | tokens)
+- Key screens/flows needed?
+
+Use inference from the codebase scan — don't re-ask what you can already see.
+
+**Round 2 — Success & gaps:**
+- Success criteria
+- Timeline, constraints
+- Any remaining gaps
+- State your understanding back: "Here's what I'm hearing: [summary]. Anything I'm missing?"
+
+Skip or compress rounds if the user gives enough upfront. Don't over-ask.
+
+8. Write artifacts:
+- `.design/projects/{name}/BRIEF.md` from project brief template
+- `.design/projects/{name}/STATE.md` from project state template — populate `## Git` table with detected/confirmed branch (or "—")
+- `.design/projects/{name}/config.json` from project config template (include `brand_ref` field) — populate `git.branch` with detected/confirmed branch (or empty string)
+- `.design/projects/{name}/ROADMAP.md` from project roadmap template
+- `.design/projects/{name}/exports/INDEX.md` from exports-index template
+
+9. Route: "Run `/gsp:brief` to scope the project. Treat this project as a bounded issue (or set of issues) and a PR — ship small, ship complete."
+</process>

package/commands/gsp/plan.md

@@ -0,0 +1,18 @@
+---
+name: gsp:plan
+description: Project scoping (alias for /gsp:brief)
+allowed-tools:
+  - Read
+---
+<process>
+Display:
+```
+🎨 GSP — Redirecting...
+
+/gsp:plan now redirects to /gsp:brief in GSP 0.4.0.
+The brief phase handles project scoping, adaptations, and gap analysis.
+```
+
+Tell the user to run `/gsp:brief` instead.
+</process>
+</output>

package/commands/gsp/progress.md

@@ -1,61 +1,93 @@
 ---
 name: gsp:progress
-description: Check design project progress — "How pretty are we?"
+description: Check design progress — "How pretty are we?"
 allowed-tools:
   - Read
   - Glob
 ---
 <context>
-Status check for GSP design projects. Reads STATE.md and shows phase progress with a prettiness meter.
+Status check for GSP design projects. Shows progress for all brands and projects with prettiness meters.
 </context>
 
 <objective>
-Display current project progress and route to next action.
+Display current progress across all brands and projects.
 </objective>
 
 <process>
-## Step 1: Find project
+## Step 1: Scan for instances
 
-Check for `.design/STATE.md` in the current directory.
+Check `.design/branding/` for brand directories and `.design/projects/` for project directories.
 
-If not found, display:
-```
-No GSP project found. Run /gsp:new-project to start one.
-```
+If neither found, check for legacy `.design/STATE.md`:
+- If found: show legacy progress (same as v0.3.0)
+- If not: display "No GSP project found. Run `/gsp:new` to start one."
 
-## Step 2: Read state
+## Step 2: Read state for each instance
 
-Read `.design/STATE.md` and `.design/BRIEF.md`.
+For each brand: read `STATE.md` and `BRIEF.md`
+For each project: read `STATE.md`, `BRIEF.md`, and `brand.ref`
 
 ## Step 3: Calculate prettiness
 
-Count completed and skipped phases out of 8. Both count toward progress. Calculate percentage.
+Brands: count completed/skipped phases out of 5
+Projects: count completed/skipped phases out of 6
 
 ## Step 4: Display progress
 
 ```
 🎨 GSP — How Pretty Are We?
 
-Project: {PROJECT_NAME}
-Prettiness: ██████░░░░░░░░░░ 37.5% (3/8 phases)
+─── Brands ────────────────────────────
+
+  acme-corp
+  ████████████████ 100% (5/5 phases)
+  ✅ Research  ✅ Strategy  ✅ Verbal  ✅ Identity  ✅ Patterns
+
+  beta-labs
+  ██████░░░░░░░░░░ 40% (2/5 phases)
+  ✅ Research  ✅ Strategy  ⬜ Verbal  ⬜ Identity  ⬜ Patterns
+  → Next: /gsp:brand-identity
+
+─── Projects ──────────────────────────
+
+  acme-website (brand: acme-corp)
+  ██████████░░░░░░ 66% (4/6 phases)
+  ✅ Brief  ✅ Research  ✅ Design  ✅ Critique  ⬜ Build  ⬜ Review
+  → Next: /gsp:build
 
-Phase Progress:
-  ✅ 1. Research    — complete
-  ✅ 2. Brand       — complete
-  ✅ 3. System      — complete
-  ⬜ 4. Design      — pending        ← you are here
-  ⬜ 5. Spec        — pending
-  ⬜ 6. Review      — pending
-  ⬜ 7. Build       — pending
-  ⬜ 8. Launch      — pending
+  acme-mobile (brand: acme-corp)
+  ███░░░░░░░░░░░░░ 16% (1/6 phases)
+  ✅ Brief  ⬜ Research  ⬜ Design  ⬜ Critique  ⬜ Build  ⬜ Review
+  → Next: /gsp:research
+  📦 Launch: complete
 
-Review Loops: {COUNT}
+─── Overall ───────────────────────────
+
+  Brands:   1 complete, 1 in progress
+  Projects: 0 complete, 2 in progress
 ```
 
 Use ✅ for complete, ⏭️ for skipped, 🔄 for in-progress/needs-revision, ⬜ for pending.
 
+Show Launch status separately if present (not counted in phase progress).
+
 ## Step 5: Route next
 
-Identify the next pending phase and suggest the command:
-"Next up: Run `/gsp:{next_phase}` to continue."
+For each in-progress instance, identify the next pending phase and suggest the command:
+
+**Brand routing:**
+- Phase 1 (Research) pending → `/gsp:brand-research`
+- Phase 2 (Strategy) pending → `/gsp:brand-strategy`
+- Phase 3 or 4 (Verbal/Identity) pending → `/gsp:brand-identity` (handles both phases with skip logic)
+- Phase 5 (Patterns) pending → `/gsp:brand-patterns`
+
+**Project routing:**
+- Brief pending → `/gsp:brief`
+- Research pending → `/gsp:research`
+- Design pending → `/gsp:design`
+- Critique pending → `/gsp:critique`
+- Build pending → `/gsp:build`
+- Review pending → `/gsp:review`
+
+If everything is complete: "All brands and projects are fully pretty! 🎨"
 </process>