get-shit-pretty 0.2.0 → 0.4.0

package/commands/gsp/brand-identity.md

@@ -0,0 +1,200 @@
+---
+name: gsp:brand-identity
+description: Brand identity — verbal + visual identity (phases 3-4)
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Task
+  - WebSearch
+  - WebFetch
+---
+<context>
+Phases 3-4 of the GSP branding diamond. Runs verbal identity (voice, tone, messaging) and visual identity (logo, color, typography) as a single command. Handles skip logic — if one phase is already complete, runs only the remaining one.
+</context>
+
+<objective>
+Build the brand's verbal and visual identity.
+
+**Input:** Strategy chunks + BRIEF.md
+**Output:** `.design/branding/{brand}/verbal/` + `.design/branding/{brand}/identity/` + `palettes.json`
+**Agents:** `gsp-verbal-strategist` (phase 3), `gsp-identity-designer` (phase 4)
+</objective>
+
+<execution_context>
+@/Users/jubs/.claude/get-shit-pretty/templates/phases/verbal.md
+@/Users/jubs/.claude/get-shit-pretty/references/voice-tone.md
+@/Users/jubs/.claude/get-shit-pretty/prompts/02-brand-identity-creator.md
+@/Users/jubs/.claude/get-shit-pretty/templates/phases/identity.md
+</execution_context>
+
+<process>
+## Step 0: Resolve brand
+
+Scan `.design/branding/` for brand directories. If only one brand exists, use it. If multiple, ask the user which brand to work on.
+
+Set `BRAND_PATH` = `.design/branding/{brand}`
+
+If BRAND_PATH doesn't exist, tell the user to run `/gsp:new` first.
+
+## Step 1: Validate prerequisites
+
+Read `{BRAND_PATH}/STATE.md`. Strategy (phase 2) must be complete. If not, tell the user: "Strategy isn't complete yet. Run `/gsp:brand-strategy` first."
+
+Load:
+- `{BRAND_PATH}/BRIEF.md` — company, audience, goals
+- `{BRAND_PATH}/strategy/INDEX.md` → load all strategy chunks
+- Fallback: `{BRAND_PATH}/strategy/STRATEGY.md` (legacy monolith). Log: "⚠️ Legacy strategy format detected."
+
+## Step 2: Check progress
+
+Read `{BRAND_PATH}/STATE.md` for phases 3 and 4 status.
+
+- Phase 3 `complete` → skip verbal, go to phase 4
+- Phase 4 `complete` → skip visual, go to summary
+- Both `complete` → show summary and route to next command
+- `pending` or `needs-revision` → run that phase
+
+## Step 2.5: Voice direction (interactive, before verbal agent)
+
+Load `{BRAND_PATH}/strategy/archetype.md` communication style + `{BRAND_PATH}/strategy/brand-prism.md` personality.
+If `{BRAND_PATH}/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 3: Verbal identity (if needed)
+
+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 2.5
+- `{BRAND_PATH}/audit/brand-inventory.md` voice samples (if exist)
+- **Output path:** `{BRAND_PATH}/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`
+
+Update `{BRAND_PATH}/STATE.md`:
+- Set Phase 3 (Verbal) status to `complete`
+- Record completion date
+
+Display progress: "Verbal identity complete. Moving to visual identity..."
+
+## Step 3.5: Visual direction (interactive, before identity agent)
+
+Load `{BRAND_PATH}/discover/mood-board-direction.md` + `{BRAND_PATH}/strategy/archetype.md` visual tendencies.
+If `{BRAND_PATH}/audit/` exists, load `audit/brand-inventory.md` (current colors, typography).
+
+Present visual direction:
+
+"Here's where research and strategy point visually:
+
+ From research mood board:
+   Colors: {hex values from mood-board-direction.md}
+   Typography: {typefaces from mood-board-direction.md}
+   Imagery: {style from mood-board-direction.md}
+
+ From archetype ({name}):
+   Visual tendencies: {from archetype.md}
+
+ {If evolve: "Current brand uses {colors, fonts from audit}.
+  Evolution map says: preserve {X}, evolve {Y}, replace {Z}."}
+
+ My recommendation: {direction + reasoning}
+
+ Logo exploration angles:
+ 1. {concept A}
+ 2. {concept B}
+ 3. {concept C}
+
+ Thoughts? Visual references or hard constraints?"
+
+Confirm visual direction. This direction and the mood-board-direction.md content are passed to the identity designer agent.
+
+## Step 4: Visual identity (if needed)
+
+Load verbal chunks (just created or pre-existing):
+- `{BRAND_PATH}/verbal/INDEX.md` → load `brand-voice.md`, `tone-spectrum.md`
+- Fallback: `{BRAND_PATH}/verbal/VERBAL.md` (legacy monolith). Log: "⚠️ Legacy verbal format detected."
+
+Spawn the `gsp-identity-designer` agent with:
+- The BRIEF.md content
+- Selected strategy chunks (brand-prism, archetype, positioning, brand-platform)
+- Selected verbal chunks (brand-voice, tone-spectrum)
+- The Brand Identity Creator prompt (02)
+- The identity output template
+- `{BRAND_PATH}/discover/mood-board-direction.md` content
+- User-confirmed visual direction from Step 3.5
+- `{BRAND_PATH}/audit/brand-inventory.md` (if exists)
+- `{BRAND_PATH}/audit/evolution-map.md` (if exists)
+- **Output path:** `{BRAND_PATH}/identity/`
+
+The agent writes chunks directly to the identity directory:
+1. `logo-directions.md`
+2. `color-system.md`
+3. `typography.md`
+4. `imagery-style.md`
+5. `brand-applications.md`
+6. `brand-book.md`
+7. `palettes.json`
+8. `INDEX.md`
+
+Update `{BRAND_PATH}/STATE.md`:
+- Set Phase 4 (Identity) status to `complete`
+- Record completion date
+- Set Prettiness Level to 80%
+
+## Step 4.5: Perspective check
+
+Before finalizing, load `{BRAND_PATH}/discover/audience-personas.md` and present stakeholder reactions:
+
+"Before we finalize the identity, let me stress-test from three angles:
+
+ The Customer ({primary persona name from audience-personas.md}):
+ "{reaction to specific visual and verbal elements — would they trust/engage/buy?}"
+
+ The Skeptic (internal stakeholder):
+ "{challenges the boldest visual decision — color gamble, typography risk, logo direction. Raises the 'what if' scenario.}"
+
+ The Competitor ({top competitor name}):
+ "{how they'd respond — is the brand visually differentiated enough? Where's the vulnerability?}"
+
+ Any of these concerns resonate? Want to adjust before we lock in?"
+
+If user wants changes → loop back to adjust identity outputs.
+If confirmed → proceed.
+
+## Step 5: Present identity summary
+
+Display a summary covering both verbal and visual:
+- **Archetype expression** — how the archetype manifests in voice and visuals
+- **Voice attributes** — top 3 voice characteristics
+- **Logo directions** — number of directions and brief descriptions
+- **Color system** — primary palette summary
+- **Typography** — chosen typefaces
+
+## Step 6: Route next
+
+"Run `/gsp:brand-patterns` to build your design system and see the full brand preview."
+</process>

package/commands/gsp/brand-patterns.md

@@ -0,0 +1,223 @@
+---
+name: gsp:brand-patterns
+description: Design system + brand preview + diamond transition
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Task
+  - Grep
+  - Glob
+---
+<context>
+Phase 5 of the GSP branding diamond. Builds the design system (foundations, components, tokens), generates a self-contained brand preview HTML, and transitions the user from the branding diamond to the project diamond.
+
+Adapts strategy based on codebase context — generates from scratch, extends an existing system, or redesigns with migration mapping.
+</context>
+
+<objective>
+Build the design system, generate brand preview, and complete the branding diamond.
+
+**Input:** Brand identity + strategy + verbal + BRIEF.md
+**Output:** `{brand}/system/` (foundations/, components/, principles.md, tokens.json, INDEX.md) + `{brand}/preview.html`
+**Agent:** `gsp-system-architect`
+</objective>
+
+<execution_context>
+@/Users/jubs/.claude/get-shit-pretty/prompts/01-design-system-architect.md
+@/Users/jubs/.claude/get-shit-pretty/templates/phases/system.md
+@/Users/jubs/.claude/get-shit-pretty/references/design-tokens.md
+</execution_context>
+
+<process>
+## Step 0: Resolve brand
+
+Scan `.design/branding/` for brand directories. If only one brand exists, use it. If multiple, ask the user which brand to work on.
+
+Set `BRAND_PATH` = `.design/branding/{brand}`
+
+If BRAND_PATH doesn't exist, tell the user to run `/gsp:new` first.
+
+## Step 1: Load context
+
+### Identity (chunk-first)
+
+Read `{BRAND_PATH}/identity/INDEX.md`. If it exists, load all identity chunks + `palettes.json`.
+
+Fallback: read `{BRAND_PATH}/identity/IDENTITY.md` (legacy monolith) + `palettes.json`. Log: "⚠️ Legacy identity format detected — consider re-running /gsp:brand-identity for chunk output."
+
+If neither exists, check if identity phase is complete in brand STATE.md. If not, tell the user to complete brand identity first (run `/gsp:brand-identity`).
+
+### Strategy + Verbal (selective, chunk-first)
+
+Read `{BRAND_PATH}/strategy/INDEX.md`. If it exists, load selective chunks.
+Fallback: read `{BRAND_PATH}/strategy/STRATEGY.md`.
+
+Read `{BRAND_PATH}/verbal/INDEX.md`. If it exists, load selective chunks.
+Fallback: read `{BRAND_PATH}/verbal/VERBAL.md`.
+
+### Brand context
+
+Read:
+- `{BRAND_PATH}/BRIEF.md` — company, audience, goals
+- `{BRAND_PATH}/config.json` — get `system_config.system_strategy`, `system_config.tech_stack`
+
+## Step 1.5: Codebase awareness
+
+Ask the user:
+1. "Will this brand target a specific tech stack?" (React + Tailwind, React Native + NativeWind, vanilla CSS, etc.)
+   - Store answer in `{BRAND_PATH}/config.json` → `system_config.tech_stack`
+2. "Is there an existing design system to incorporate?"
+   - If yes: scan codebase for INVENTORY (existing tokens, components, architecture)
+   - Store strategy in `{BRAND_PATH}/config.json` → `system_config.system_strategy`
+
+## Step 2: Determine system strategy
+
+Read `system_config.system_strategy` from config.json (defaults to `generate` if missing).
+
+Three strategies:
+
+**GENERATE** (when `system_strategy` is `generate` or missing):
+Full system from scratch. For `boilerplate` codebases, respect existing config structure (extend tailwind.config, not replace) and output tokens in the format the existing config uses (Tailwind extend, CSS custom properties, etc).
+
+**EXTEND** (when `system_strategy` is `extend`):
+Evolve the existing system rather than replacing it.
+1. Audit existing tokens against the brand identity — keep what works, adjust what doesn't, fill gaps
+2. Classify each existing component: KEEP / RESTYLE / REFACTOR / REPLACE
+3. Design only net-new components not covered by existing ones
+4. Output delta tokens — only new and changed values
+5. Preserve existing naming conventions from INVENTORY.md
+
+**REFACTOR** (when `system_strategy` is `refactor`):
+Redesign the system from the ground up, informed by what exists.
+1. Read and understand existing tokens, components, patterns from INVENTORY.md
+2. Design a complete new system — same scope as GENERATE
+3. Produce a migration mapping for every change
+4. Preserve conventions unless the brand requires changes
+5. Flag breaking changes explicitly
+
+## Step 3: Spawn system architect — Pass 1: Foundations
+
+Spawn the `gsp-system-architect` agent with:
+- All identity chunks (or IDENTITY.md fallback) + palettes.json
+- The BRIEF.md content
+- The Design System Architect prompt (01)
+- The system output template
+- The design tokens reference
+- The `system_strategy` and `tech_stack` values
+- The INVENTORY.md content (when exists)
+- **Execution mode:** `"foundations"`
+- **Output path:** `{BRAND_PATH}/system/`
+
+The agent writes foundations only:
+- `system/foundations/` (6 foundation chunks)
+- `system/principles.md`
+- `system/tokens.json` (foundations-only)
+
+## Step 3.5: Foundation review (interactive)
+
+Read the foundation outputs and present:
+
+"Here are the design system foundations:
+ Color: {semantic mapping summary from foundations/color-system.md}
+ Typography: {type scale summary from foundations/typography.md}
+ Spacing: 8px base → {scale from foundations/spacing.md}
+ Design principles: {list from principles.md}
+
+ Everything right? Adjustments before building components?"
+
+Wait for user input. If adjustments needed, update the relevant foundation chunks.
+
+## Step 3.75: Perspective check
+
+Before building components, load `{BRAND_PATH}/discover/audience-personas.md` and present stakeholder reactions:
+
+"Before we build the component library on these foundations:
+
+ The Customer ({primary persona name from audience-personas.md}):
+ "{would a user recognize this as {brand}? Does the system feel like the brand?}"
+
+ The Skeptic (internal stakeholder):
+ "{challenges system decisions — are the tokens flexible enough? Are the principles actionable?}"
+
+ The Competitor ({top competitor name}):
+ "{how does this system compare to industry standards? Any gaps?}"
+
+ Any of these concerns resonate? Want to adjust foundations before building components?"
+
+If user wants changes → update foundations.
+If confirmed → proceed to components pass.
+
+## Step 4: Spawn system architect — Pass 2: Components
+
+Spawn the `gsp-system-architect` agent with:
+- The existing foundations from Pass 1
+- All identity chunks + palettes.json
+- Strategy + verbal chunks (for content component guidelines)
+- **Execution mode:** `"components"`
+- Confirmed component scope from Step 1.5
+- **Output path:** `{BRAND_PATH}/system/`
+
+The agent writes components:
+- `system/components/` (one per component)
+- Updates `system/tokens.json` (adds component tokens)
+- `system/INDEX.md`
+
+## Step 4.5: Update state
+
+Update `{BRAND_PATH}/STATE.md`:
+- Set Phase 5 (System) status to `complete`
+- Record completion date
+- Set Prettiness Level to 100%
+
+## Step 4.75: Generate brand preview
+
+Create a self-contained HTML file at `{BRAND_PATH}/preview.html`.
+
+Read all available brand outputs:
+- `{BRAND_PATH}/identity/palettes.json` — color palette data
+- `{BRAND_PATH}/identity/color-system.md` — color roles and usage
+- `{BRAND_PATH}/identity/typography.md` — type scale and families
+- `{BRAND_PATH}/verbal/brand-voice.md` — voice attributes (means / doesn't mean)
+- `{BRAND_PATH}/verbal/tagline-directions.md` — tagline candidates
+- `{BRAND_PATH}/identity/logo-directions.md` — logo direction descriptions
+- `{BRAND_PATH}/strategy/archetype.md` — brand archetype
+
+Generate a single self-contained HTML file with:
+- **Embedded Google Fonts** `<link>` for the chosen typefaces
+- **Page styled with brand colors** — background, text, and accent colors from palettes.json
+- **Color palette swatches** — full ramp from 50→900 stops for each palette
+- **Typography samples** — headings and body text at the defined type scale, using the chosen font families
+- **Voice attributes** — each attribute with "means / doesn't mean" columns
+- **Tagline directions** — listed with descriptions
+- **Logo direction descriptions** — each direction with rationale
+- **Archetype summary** — the selected archetype and its expression
+
+Tell the user: "Brand preview saved — open it in your browser to see the full brand at a glance."
+
+## Step 5: Diamond transition
+
+Display the branding diamond completion summary:
+
+```
+🎨 Brand Complete — {brand-name}
+═══════════════════════════════════════
+
+  ✅ Research     — {key finding from discover}
+  ✅ Strategy     — {archetype}, {positioning summary}
+  ✅ Verbal       — voice: {top 3 voice attributes}
+  ✅ Visual       — {N} logo directions, {primary colors}, {typefaces}
+  ✅ Patterns     — {N} foundations, {N} components, tokens.json
+
+  📄 Preview: {BRAND_PATH}/preview.html
+
+───────────────────────────────────────
+
+GSP uses a dual-diamond process. Your brand is Diamond 1.
+
+Diamond 2 is design projects — each uses a brand as foundation.
+You can have multiple projects per brand (website, app, dashboard...).
+
+Ready to start a design project? Run /gsp:new to set one up.
+```
+</process>

package/commands/gsp/brand-research.md

@@ -0,0 +1,99 @@
+---
+name: gsp:brand-research
+description: Brand research — competitive audit, personas, SWOT, trend analysis
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Task
+  - WebSearch
+  - WebFetch
+---
+<context>
+Phase 1 of the GSP branding diamond. Researches the market landscape, builds audience personas, runs competitive audit, and performs SWOT analysis to inform brand strategy.
+</context>
+
+<objective>
+Research and discover insights that will inform brand strategy.
+
+**Input:** `.design/branding/{brand}/BRIEF.md`
+**Output:** `.design/branding/{brand}/discover/` (7 chunks + INDEX.md)
+**Agent:** `gsp-researcher`
+</objective>
+
+<execution_context>
+@/Users/jubs/.claude/get-shit-pretty/prompts/07-design-trend-synthesizer.md
+@/Users/jubs/.claude/get-shit-pretty/templates/phases/discover.md
+@/Users/jubs/.claude/get-shit-pretty/references/design-trends.md (index — load specific trend files from references/trends/ as needed)
+</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.
+
+Set `BRAND_PATH` = `.design/branding/{brand}`
+
+Read `{BRAND_PATH}/BRIEF.md` to understand:
+- Company, industry, audience
+- Competitive landscape
+- Brand personality and goals
+
+If BRIEF.md doesn't exist, tell the user to run `/gsp:new` first.
+
+Read `{BRAND_PATH}/config.json` to confirm `project_type` is `brand`. Note `brand_mode` value.
+
+## Step 1.5: Research direction (interactive)
+
+Load BRIEF.md context. If `{BRAND_PATH}/audit/` exists, also load `audit/evolution-map.md` and `audit/market-fit.md`.
+
+Present the research plan:
+
+"Here's my research plan:
+ Market focus: {industry from BRIEF.md}
+ Competitors to analyze: {3-5 from brief + audit}
+ Audience segments: {from brief}
+ Research emphasis: {competitive gaps / audience pain / trends}
+ {If evolve mode: "I'll benchmark your current brand against these competitors to validate what's working."}
+
+ Any competitors I'm missing? Emphasis you'd shift?"
+
+Wait for user input. Incorporate their additions/adjustments.
+
+## Step 2: Spawn researcher
+
+Spawn the `gsp-researcher` agent with:
+- The full BRIEF.md content
+- The Design Trend Synthesizer prompt (07)
+- The discover output template
+- Instruction to focus on the brand's specific industry
+- User-confirmed research scope from Step 1.5
+- `brand_mode` from config.json
+- Audit chunks if they exist: `{BRAND_PATH}/audit/brand-inventory.md`, `{BRAND_PATH}/audit/market-fit.md`, `{BRAND_PATH}/audit/evolution-map.md`
+- **Output path:** `{BRAND_PATH}/discover/`
+
+## Step 2.5: Confirm scope
+
+After confirming the research scope with the user, proceed to spawn the researcher agent with the confirmed parameters.
+
+The agent writes chunks directly to the discover directory:
+1. `market-landscape.md`
+2. `competitive-audit.md`
+3. `swot-analysis.md`
+4. `audience-personas.md`
+5. `trend-analysis.md`
+6. `strategic-recommendations.md`
+7. `mood-board-direction.md`
+8. `INDEX.md`
+
+## Step 3: Update state
+
+Update `.design/branding/{brand}/STATE.md`:
+- Set Phase 1 (Discover) status to `complete`
+- Record completion date
+
+## Step 4: Route next
+
+Display a summary of key findings and end with:
+"Run `/gsp:brand-strategy` to define your brand's strategic direction."
+</process>

package/commands/gsp/brand-strategy.md

@@ -0,0 +1,140 @@
+---
+name: gsp:brand-strategy
+description: Brand strategy — archetype, positioning, personality (interactive)
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Task
+  - WebSearch
+  - WebFetch
+---
+<context>
+Phase 2 of the GSP branding diamond. An interactive creative challenge — you present research insights, push opinionated strategic recommendations, and collaborate with the user to lock brand positioning before spawning the strategist agent.
+</context>
+
+<objective>
+Define brand strategy through interactive creative direction, then produce full strategy chunks.
+
+**Input:** `.design/branding/{brand}/BRIEF.md` + discover chunks
+**Output:** `.design/branding/{brand}/strategy/` (6 chunks + INDEX.md)
+**Agent:** `gsp-brand-strategist`
+</objective>
+
+<execution_context>
+@/Users/jubs/.claude/get-shit-pretty/templates/phases/strategy.md
+@/Users/jubs/.claude/get-shit-pretty/references/brand-prism.md
+@/Users/jubs/.claude/get-shit-pretty/references/brand-archetypes.md
+@/Users/jubs/.claude/get-shit-pretty/references/positioning-frameworks.md
+</execution_context>
+
+<process>
+## Step 0: Resolve brand
+
+Scan `.design/branding/` for brand directories. If only one brand exists, use it. If multiple, ask the user which brand to work on.
+
+Set `BRAND_PATH` = `.design/branding/{brand}`
+
+If BRAND_PATH doesn't exist, tell the user to run `/gsp:new` first.
+
+## Step 1: Load research findings
+
+Read `{BRAND_PATH}/BRIEF.md` — company, audience, personality, goals.
+
+**Chunk-first:** Read `{BRAND_PATH}/discover/INDEX.md`. If it exists, load all 7 discover chunks.
+
+**Fallback:** If INDEX.md doesn't exist, read `{BRAND_PATH}/discover/DISCOVER.md` (legacy monolith). Log: "⚠️ Legacy discover format detected — consider re-running /gsp:brand-research for chunk output."
+
+Proceed without discover output if neither exists (strategy can run independently).
+
+## Step 2: Present research highlights
+
+Synthesize and present the most strategically relevant findings:
+- **Competitive gaps** — where the market is underserving or homogeneous
+- **White space** — unoccupied positions in the competitive landscape
+- **Audience tension points** — unmet needs, frustrations, aspirations
+- **Key trends** — relevant shifts that create strategic opportunity
+
+Frame the strategic opportunity: "Here's what the research tells us about where this brand can win."
+
+## Step 3: Archetype selection
+
+Present 2-3 archetype candidates with strong opinions. Don't just list options — push a recommendation:
+
+"Based on your market position, I'd push for **The Creator** over **The Sage**. Here's why: [reasoning from research]. The Sage space is crowded in your category — [competitor A] and [competitor B] already own it. The Creator lets you own [specific territory]."
+
+Let the user choose, adjust, or blend. Confirm the selected archetype.
+
+## Step 4: Positioning challenge
+
+Show the competitive landscape as a positioning map (two key axes relevant to the industry).
+
+Identify where competitors cluster and where the white space is:
+
+"Everyone clusters in the [safe zone]. The white space is [bold position] — that's where you differentiate. It's riskier but ownable."
+
+Present 2 positioning options: the safe play and the bold play. Push for differentiation. Let the user decide.
+
+Confirm the positioning statement.
+
+## Step 5: Brand personality
+
+Reference the personality words from BRIEF.md. Challenge generic choices:
+
+"'Professional' doesn't differentiate — every B2B brand claims it. What about **'precise'** or **'exacting'**? That says the same thing but only you can own it."
+
+Sharpen to 3 distinctive personality words. Confirm with the user.
+
+## Step 6: Spawn brand strategist
+
+With confirmed strategic choices (archetype, positioning, personality), spawn the `gsp-brand-strategist` agent with:
+- The full BRIEF.md content
+- All discover chunks (or DISCOVER.md fallback content)
+- The confirmed archetype, positioning, and personality decisions
+- The strategy output template
+- The brand-prism reference
+- The brand-archetypes reference
+- The positioning-frameworks reference
+- `{BRAND_PATH}/audit/evolution-map.md` (if exists)
+- `{BRAND_PATH}/audit/equity-analysis.md` (if exists)
+- `brand_mode` from config.json
+- **Output path:** `{BRAND_PATH}/strategy/`
+
+The agent writes chunks directly to the strategy directory:
+1. `brand-prism.md`
+2. `archetype.md`
+3. `golden-circle.md`
+4. `positioning.md`
+5. `brand-platform.md`
+6. `messaging-hierarchy.md`
+7. `INDEX.md`
+
+## Step 6.5: Perspective check
+
+Before finalizing strategy, load `{BRAND_PATH}/discover/audience-personas.md` and present stakeholder reactions:
+
+"Before we lock this in, let me stress-test from three angles:
+
+ The Customer ({primary persona name from audience-personas.md}):
+ "{reaction to the positioning, archetype, and messaging — would they trust/engage/buy?}"
+
+ The Skeptic (internal stakeholder):
+ "{challenges the boldest decision — archetype choice, positioning gamble, messaging risk. Raises the 'what if' scenario.}"
+
+ The Competitor ({top competitor name from discover/competitive-audit.md}):
+ "{how they'd respond — is the brand differentiated enough to threaten them? Where's the vulnerability?}"
+
+ Any of these concerns resonate? Want to adjust before we lock in?"
+
+If user wants changes → loop back to adjust strategy outputs.
+If confirmed → proceed to state update.
+
+## Step 7: Update state and route
+
+Update `{BRAND_PATH}/STATE.md`:
+- Set Phase 2 (Strategy) status to `complete`
+- Record completion date
+
+Display strategy summary (archetype, positioning, core message) and end with:
+"Strategy locked. Run `/gsp:brand-identity` to bring this to life."
+</process>

package/commands/gsp/brand-system.md

@@ -0,0 +1,17 @@
+---
+name: gsp:brand-system
+description: Design system (alias for /gsp:brand-patterns)
+allowed-tools:
+  - Read
+---
+<process>
+Display:
+```
+🎨 GSP — Redirecting...
+
+/gsp:brand-system now redirects to /gsp:brand-patterns.
+The branding diamond is 4 commands: brand-research → brand-strategy → brand-identity → brand-patterns.
+```
+
+Tell the user to run `/gsp:brand-patterns` instead.
+</process>