@cofoundr/init 1.5.0

package/README.md

@@ -0,0 +1,140 @@
+# `@cofoundr/init`
+
+Universal installer for the **CoFoundr** spec-driven starter kit. Runs in any project, drops a tool-agnostic `.cofoundr/` workspace and an `AGENTS.md` at the root, then installs per-tool shims for the AI tools you actually use.
+
+## Why this exists
+
+The CoFoundr starter kit was originally a Claude Code plugin. That left out everyone using Cursor, Windsurf, Cline, Codex, Aider, GitHub Copilot, Gemini, and the rest of the modern AI-coding stack. This package fixes that — one canonical workflow, every tool.
+
+```
+                      ┌──────────────────────┐
+                      │  .cofoundr/          │ ← single source of truth
+                      │   constitution.md    │
+                      │   memory/            │
+                      │   specs/             │
+                      │   commands/          │
+                      │   agents/            │
+                      └──────────┬───────────┘
+                                 │
+                                 ▼
+       ┌──────────┬───────────┬──────┬────────┬──────────┬──────────┬──────────┬─────────┐
+       │ Claude   │ Cursor    │ Wind │ Cline /│ Codex    │ Aider    │ GitHub   │ Gemini  │
+       │ Code     │           │ surf │ Roo    │ CLI      │          │ Copilot  │ CLI     │
+       └──────────┴───────────┴──────┴────────┴──────────┴──────────┴──────────┴─────────┘
+                       (per-tool shim files written by adapters)
+
+                            and AGENTS.md at the repo root
+                          (read by ~25+ other agents natively)
+```
+
+## Install + run
+
+```bash
+# Greenfield or existing project — interactive picker
+npx @cofoundr/init init
+
+# Non-interactive, install everything
+npx @cofoundr/init init --all-tools --yes
+
+# Pick specific tools
+npx @cofoundr/init init --tools claude-code,cursor,codex
+
+# Map an existing codebase before specing
+npx @cofoundr/init onboard
+
+# Refresh after a CoFoundr upgrade
+npx @cofoundr/init sync
+
+# Health check
+npx @cofoundr/init doctor
+
+# What's supported, what's detected here
+npx @cofoundr/init tools
+```
+
+## Supported tools
+
+| Tool                   | Tool reads                                                      |
+|------------------------|------------------------------------------------------------------|
+| Claude Code            | `.claude/commands/`, `.claude/agents/`, `CLAUDE.md`              |
+| Cursor                 | `.cursor/rules/cofoundr.mdc`                                     |
+| Windsurf               | `.windsurfrules`, `.windsurf/rules/cofoundr.md`                  |
+| Cline / Roo Code       | `.clinerules/cofoundr.md`                                        |
+| OpenAI Codex CLI       | `AGENTS.md`, `.codex/instructions.md`                            |
+| Aider                  | `AGENTS.md`, `.aider.conf.yml`                                   |
+| GitHub Copilot         | `.github/copilot-instructions.md`                                |
+| Gemini CLI             | `GEMINI.md`                                                      |
+
+`AGENTS.md` is the open-standard universal context file ([agents.md](https://agents.md/)) read by 20+ additional agents — Junie, Jules, Goose, opencode, Zed, Warp, Devin, Amp, Augment, Kilo, Phoenix, Roo, Ona, Factory, and more — so even tools without a dedicated adapter pick up the workspace automatically.
+
+## What gets installed
+
+### Always — universal source of truth
+
+```
+AGENTS.md                      # universal context, read by ~25 tools
+.cofoundr/
+├── manifest.json              # version stamp + selected tools
+├── README.md
+├── constitution.md            # the project's binding rules
+├── memory/
+│   ├── project.md
+│   ├── decisions.md           # append-only decision log
+│   └── knowledge.md           # patterns and gotchas
+├── specs/                     # feature- and phase-level specs
+├── commands/                  # canonical workflow commands (read by all tools)
+├── agents/                    # canonical agent definitions
+└── templates/                 # editable scaffolds
+```
+
+### Per tool — only the shims you asked for
+
+The adapter for each tool writes a thin file that points the tool back to `.cofoundr/`. There is **one** source of truth — the per-tool files are routers.
+
+## Workflow commands
+
+Every command works the same in every tool — the user types `/cofoundr:<name>` (or `cofoundr <name>`) and the tool reads `.cofoundr/commands/<name>.md` and follows it.
+
+| Category    | Command                | What it does |
+|-------------|------------------------|--------------|
+| Session     | `resume`               | First command of every session — recap, confirm, then code |
+| Planning    | `quick-brief`          | 4-question fast pass; produces `product.md` |
+|             | `new-project`          | Full pipeline — planning, research, six-file spec |
+|             | `plan`                 | Standalone planning conversation (15-item rubric) |
+|             | `next`                 | Planning driver — does the next unblocked thing |
+|             | `new-feature`          | Add a feature to an existing project |
+| SDD         | `constitution`         | Establish or amend the binding rules |
+|             | `specify`              | Produce or refresh the formal spec (project / feature / phase) |
+|             | `tasks`                | Break a phase or feature into ordered, copy-paste tasks |
+|             | `implement`            | Execute the next task with HALT enforcement |
+| Brownfield  | `onboard`              | Map an existing codebase. Drafts a back-filled spec |
+|             | `document`             | Generate or refresh living docs from code |
+|             | `audit`                | Drift, dead surfaces, security smells, constitution violations |
+| Guardrails  | `scope-guard`          | Check a proposed change vs. product.md non-goals |
+|             | `rules-check`          | Audit current work vs. rules.md tiers |
+|             | `review`               | 22-check spec quality audit |
+| Comms       | `translate`            | Plain-English companion (`docs/plan-for-humans.md`) |
+| Setup       | `setup-skills`         | Install recommended skill packs |
+
+## Safety
+
+- **Idempotent.** `init` and `sync` skip files that already exist unless you pass `--force`. Files inside `.cofoundr/memory/`, `.cofoundr/specs/`, `.cofoundr/reports/`, and your code are **never** overwritten by the CLI.
+- **No source modification.** The CLI only writes to `.cofoundr/`, `AGENTS.md`, and the per-tool shim files. It does not touch `src/`, `app/`, `lib/`, etc.
+- **Dry run.** Pass `--dry-run` to see what would change without writing.
+- **Reversible.** `cofoundr remove` strips the shims (preserves your specs and memory). `--hard` wipes `.cofoundr/` entirely.
+
+## Development
+
+The package uses a monorepo layout. The canonical content lives at the repo root (`cofoundr-system/`) and is bundled into `packages/cofoundr-cli/content/` at publish time via `prepack`. In dev mode the CLI reads directly from `cofoundr-system/`.
+
+```bash
+# Run from a checkout
+node packages/cofoundr-cli/bin/cofoundr.mjs init --cwd /tmp/test-project --all-tools --yes
+
+# Smoke test
+node packages/cofoundr-cli/test/smoke.mjs
+```
+
+## License
+
+See the LICENSE at the repository root.

package/bin/cofoundr.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { run } from '../src/cli.mjs';
+
+run(process.argv.slice(2)).catch((err) => {
+  process.stderr.write(`\ncofoundr: ${err?.message ?? err}\n`);
+  if (process.env.COFOUNDR_DEBUG) {
+    console.error(err);
+  }
+  process.exit(1);
+});

package/content/.claude-plugin/plugin.json

@@ -0,0 +1,18 @@
+{
+  "name": "cofoundr",
+  "description": "Spec-driven development workflow for non-technical founders. Forces a structured requirements interview before any AI builds anything, produces six specification files that any AI coding tool reads as source of truth, and guards scope during builds.",
+  "version": "1.4.1",
+  "author": {
+    "name": "CoFoundr",
+    "url": "https://cofoundr.ai"
+  },
+  "homepage": "https://cofoundr.ai",
+  "license": "SEE LICENSE",
+  "keywords": [
+    "spec-driven",
+    "prd",
+    "founders",
+    "requirements",
+    "planning"
+  ]
+}

package/content/README.md

@@ -0,0 +1,227 @@
+# CoFoundr Starter Kit
+
+A spec-driven workflow that turns vague product ideas into buildable specifications. Plan before you build.
+
+**Tool-agnostic.** Runs in Claude Code, Cursor, Windsurf, Cline, Codex CLI, Aider, GitHub Copilot, Gemini CLI, and any other agent that reads `AGENTS.md` (Junie, Jules, Goose, opencode, Zed, Warp, Devin, Amp, Augment, Kilo, Roo, …).
+
+## What It Does
+
+CoFoundr walks you through a structured planning conversation and produces a complete spec bundle your AI coding tools can read as source of truth. Every phase of your MVP ends up meticulously mapped: plain-English spec, technical spec, UI spec with real copy, research notes, tests with acceptance criteria, and a decisions log.
+
+The six core files: `product.md`, `prd.md`, `tech.md`, `rules.md`, `phases.md`, `agents.md`.
+
+After install, `.cofoundr/` becomes the single source of truth — the workspace where every coding agent reads the constitution, memory, specs, and workflow commands. `AGENTS.md` at the repo root teaches every modern AI tool how to use it.
+
+Optionally, `/cofoundr:translate` generates `docs/plan-for-humans.md` — a plain-English companion to the spec, for sharing with a co-founder or advisor who doesn't need to read the technical files.
+
+**New in v1.4.0:** works on projects you've already started. `/cofoundr:onboard` reads an existing codebase and back-fills the spec from what's there. `/cofoundr:document` keeps living docs in sync with the code. `/cofoundr:audit` finds drift, dead surfaces, security smells, and constitution violations.
+
+## Installation
+
+### Option A — Universal CLI (any AI tool) — recommended
+
+```bash
+# In any project directory:
+npx @cofoundr/init init
+```
+
+The CLI detects which AI tools your project uses, asks which ones to set up shims for, and drops a `.cofoundr/` workspace plus an `AGENTS.md` at the repo root. Re-run any time with `npx @cofoundr/init sync`.
+
+Existing codebase? Map it first:
+
+```bash
+npx @cofoundr/init onboard
+```
+
+Then open the project in your AI tool and run `/cofoundr:onboard` for the deep pass (route extraction, schema parsing, doc backfill).
+
+See [`packages/cofoundr-cli/README.md`](../packages/cofoundr-cli/README.md) for the full CLI reference.
+
+### Option B — Claude Desktop (Cowork tab)
+
+1. Go to Cowork > Customize > Plugins
+2. Upload or install the plugin
+
+### Option C — Claude Code (terminal, direct plugin)
+
+```bash
+claude plugin install ./cofoundr-system
+```
+
+Or for a single session:
+
+```bash
+claude --plugin-dir ./cofoundr-system
+```
+
+### Option D — Without installing
+
+Copy the contents of the `commands/` and `templates/` folders into your project, and reference the instructions directly when prompting your AI tool.
+
+## Commands
+
+Everything is command-based — the plugin never fires unless you ask it to. This keeps it out of your way during research, brainstorming, or general work.
+
+| Command | When to use it | What it does |
+|---------|---------------|-------------|
+| `/cofoundr:resume` | **Start of every session** | Reads active feature docs and phases.md, presents a recap of where things stand, and asks for confirmation before any code is written |
+| `/cofoundr:quick-brief` | First time trying the plugin | Fast path: 4 questions, produces `product.md` only. See the shape of the output before committing to the full pipeline |
+| `/cofoundr:new-project` | Starting a new product | Full pipeline: planning conversation, research, six-file spec generation, CLAUDE.md setup |
+| `/cofoundr:plan` | Want just the planning conversation | Standalone planning conversation. Asks questions until a 15-item sufficiency rubric is satisfied — no hard question minimum, no release token |
+| `/cofoundr:next` | After `/cofoundr:new-project` | **Planning driver.** Reads the filesystem and does the next unblocked planning step. Accepts targeting: `phase [N]`, `brand`, `consolidate`, `research [topic]`. Runs as many times as needed — does work only if work is needed |
+| `/cofoundr:new-feature` | Adding to an existing project | Scope-check, 4-question planning conversation, living feature doc in `docs/features/`, shows a diff of spec-file changes before writing them |
+| `/cofoundr:scope-guard` | "Should we add this?" | Checks a proposed change against product.md non-goals and prd.md scope. Flags conflicts, offers to log ideas |
+| `/cofoundr:rules-check` | After a build session | Audits current work against rules.md Always/Ask First/Never tiers. Reports violations and suggests fixes |
+| `/cofoundr:review` | Before starting a build | 22-check quality audit of all spec files, CLAUDE.md, ACTIVE.md, and milestone structure |
+| `/cofoundr:translate` | After specs exist | Generates `docs/plan-for-humans.md` — a plain-English companion to the six files. Good for sharing or re-reading |
+| `/cofoundr:constitution` | After planning, or any time | Establishes or amends the project's binding rules. SDD-canonical alias to the rules pass of `/cofoundr:plan` |
+| `/cofoundr:specify` | Any time you need a formal spec | SDD-canonical alias. Routes to `/cofoundr:new-project`, `/cofoundr:new-feature`, or the spec-phase agent |
+| `/cofoundr:tasks` | After a phase or feature has a spec | Breaks the active phase or feature into ordered, copy-paste-ready tasks with `<verify>` checks |
+| `/cofoundr:implement` | After tasks exist | Executes the next task with HALT enforcement and Session Notes |
+| `/cofoundr:onboard` | Existing codebase, no spec | Maps the codebase, drafts a back-filled spec from what's already there, surfaces gaps. The "already mid-project?" command |
+| `/cofoundr:document` | Anytime docs go stale | Generates or refreshes living documentation from the code itself |
+| `/cofoundr:audit` | Before a release, after a refactor | Drift detection, dead surfaces, security smells, constitution violations |
+
+### Templates
+
+The `templates/` folder contains scaffolds for all spec files with inline `<!-- HOW-TO: -->` comments explaining each section. These are reference examples — the commands use them automatically.
+
+## Quick Start
+
+### Fast path — 5 minutes
+
+1. Install the plugin
+2. Open a workspace folder for your project
+3. Run `/cofoundr:quick-brief`
+4. Answer the 4 questions
+5. `product.md` appears. Decide whether to continue.
+
+### Full path — 20–30 minutes
+
+1. Install the plugin
+2. Open a workspace folder for your project
+3. Run `/cofoundr:new-project`
+4. Have the planning conversation — the AI asks questions until it has enough detail to build a spec that leaves no guesswork
+5. Say `go` when the summary looks right
+6. Six spec files appear in `/docs`, plus a `CLAUDE.md` in the project root
+7. Optionally run `/cofoundr:translate` for a plain-English companion
+8. Every future Claude Code session in this folder automatically loads your spec — rules enforced, stack known, phases visible
+
+### Recommended workflow
+
+```
+/cofoundr:quick-brief          # (optional) fast first pass — 4 Qs, 1 file
+/cofoundr:new-project          # Full pipeline — planning + specs + CLAUDE.md
+/cofoundr:next                 # Spec the next phase (6-file pack per phase). Run until every phase has a pack
+/cofoundr:next consolidate     # After all phases — produces data model, API contracts, and other build-ready artifacts
+/cofoundr:review               # Audit the specs before building
+/cofoundr:translate            # (optional) plain-English companion
+
+# Every session thereafter:
+/cofoundr:resume               # Always run first — surfaces where things stand, waits for confirmation
+
+  ... build Phase 0, Phase 1 ...
+
+/cofoundr:rules-check          # Check for violations after a session
+/cofoundr:scope-guard          # Before adding anything mid-build
+/cofoundr:new-feature          # When you're sure the addition belongs
+```
+
+## What You Get
+
+After running `/cofoundr:new-project` then looping `/cofoundr:next` until every phase has a pack:
+
+- **Six top-level docs** (`product.md`, `prd.md`, `tech.md`, `rules.md`, `phases.md`, `agents.md`)
+- **`brand.md`** — visual and voice spec
+- **Per-phase spec packs** — 6 files each (README, spec, ui-spec, research, tests, decisions)
+- **Roadmap-level consolidation artifacts** — data-model ERD, Zod API contracts, integrations catalog, fixtures, sequence diagrams, migration dependencies
+- **CLAUDE.md** at the project root that auto-loads your spec at every session
+
+## Phase Spec Packs
+
+After `/cofoundr:new-project` produces the six top-level docs, `/cofoundr:next` generates a detailed spec pack for each phase. Every pack is six files under `docs/phases/<slug>/`:
+
+- `README.md` — plain-English spec (the gut-check)
+- `spec.md` — technical spec (the AI build manual)
+- `ui-spec.md` — screens, states, copy, brand tokens
+- `research.md` — competitor findings, prior art, API quirks
+- `tests.md` — happy path, edge cases, acceptance criteria
+- `decisions.md` — append-only decision log for the phase
+
+The driver reads your project filesystem every run — no state file — and picks the next unspec'd phase. Target a specific phase with `/cofoundr:next phase 3`, or a different artifact with `/cofoundr:next brand` or `/cofoundr:next research [topic]`. The driver dispatches internally to subagents; you don't invoke them directly.
+
+## Consolidation Artifacts
+
+Once every phase has a spec pack, `/cofoundr:next` (or `/cofoundr:next consolidate`) produces roadmap-level artifacts that make the bundle genuinely build-ready:
+
+- **`data-model.md`** — ERD cross-reference of every table across every phase, with permissions matrix
+- **`api-contracts.md`** — Zod schemas for every endpoint (request, response, errors)
+- **`integrations.json`** — machine-readable catalog of every third-party service and its env vars
+- **`fixtures.md`** — seed data spec for every fixture referenced in tests
+- **`sequence-diagrams.md`** — Mermaid diagrams for the 3-5 most complex cross-component flows
+- **`migration-dependencies.md`** — dependency graph of SQL migrations across phases
+
+Without these, an AI agent building the app will re-interrogate for 15-30 implementation details per phase. With them, the bundle answers its own questions.
+
+## Persona and Tone
+
+All commands that talk to you use the same stance:
+
+- **Firm on detail, kind in tone.** Vague answers produce vague specs. The plugin will ask follow-ups — but never lecture, never test, never jargon-without-translation.
+- **Research-backed pushback only.** If the AI wants to correct a claim about a library, API, or market fact, it verifies with up-to-date sources (Context7, WebSearch) and shares the link. It does not correct from memory.
+- **Humble about what it doesn't know.** Training data goes stale. When your information is more recent, the AI defers.
+- **No pushback on preference or product-judgement calls.** The AI is not an investor.
+
+## Pair with the Launch Kit
+
+The Starter Kit produces the spec. The [CoFoundr Launch Kit](https://cofoundr.ai/kit) takes that spec and gives you the pre-wired infrastructure (Next.js + Supabase + Stripe + Resend, auth, admin, multi-tenant teams) to build it on. The two are designed to compose: the Starter Kit's output feeds the Launch Kit's `/kit:new-feature` and `/kit:migrate` commands directly.
+
+If the project is built on the CoFoundr Launch Kit, the plugin auto-detects it and emits kit-aware specs (references to `enhanceRouteHandler`, kit migration helpers, shadcn/ui components). If not, the specs stay stack-agnostic and follow whatever `tech.md` declares.
+
+## Plugin Structure
+
+```
+cofoundr-system/
+├── .claude-plugin/
+│   └── plugin.json              # Plugin manifest (name, version, author)
+├── commands/
+│   ├── plan.md                  # /cofoundr:plan
+│   ├── quick-brief.md           # /cofoundr:quick-brief
+│   ├── new-project.md           # /cofoundr:new-project
+│   ├── next.md                  # /cofoundr:next — planning driver
+│   ├── new-feature.md           # /cofoundr:new-feature
+│   ├── resume.md                # /cofoundr:resume
+│   ├── scope-guard.md           # /cofoundr:scope-guard
+│   ├── rules-check.md           # /cofoundr:rules-check
+│   ├── review.md                # /cofoundr:review
+│   └── translate.md             # /cofoundr:translate
+├── agents/                      # Subagents dispatched by /cofoundr:next
+│   ├── launch-kit-detect.md     # Detects CoFoundr Launch Kit posture
+│   ├── spec-phase.md            # Produces the 6-file phase spec pack
+│   ├── brand-intake.md          # Produces docs/brand.md
+│   └── consolidate.md           # Produces roadmap-level consolidation artifacts
+├── templates/                   # Scaffolds with inline HOW-TO comments
+│   ├── product.md
+│   ├── prd.md
+│   ├── tech.md
+│   ├── rules.md
+│   ├── phases.md
+│   ├── agents.md
+│   ├── feature.md
+│   ├── brand.md
+│   └── phases/
+│       └── phase-template/      # 6-file per-phase pack scaffold
+│           ├── README.md
+│           ├── spec.md
+│           ├── ui-spec.md
+│           ├── research.md
+│           ├── tests.md
+│           └── decisions.md
+├── CHANGELOG.md
+├── LICENSE
+└── README.md                    # This file
+```
+
+## Version
+
+Current version: **1.3.0** — see [CHANGELOG.md](CHANGELOG.md) for release history.

package/content/agents/brand-intake.md

@@ -0,0 +1,129 @@
+---
+name: brand-intake
+description: Produces docs/brand.md by reading product.md voice, prd.md surfaces, tech.md stack, and the launch-kit-detect verdict, then asking the founder 5-6 targeted questions. Emits a brand spec that ui-spec.md files across phases can reference. Spawn whenever brand.md is missing and the six top-level docs exist. Brief with the project root and the launch-kit verdict.
+tools: Read, Write, Edit, Glob, AskUserQuestion
+---
+
+# brand-intake
+
+You produce the single brand.md that every downstream ui-spec.md references. Your output must be concrete enough that an AI coding agent can build a branded UI from it without inventing colors, fonts, or voice rules. You do not design; you capture what the founder has already decided (or get them to decide what they have not).
+
+## Inputs you expect
+
+- `project_root` — absolute path to the project directory with docs/.
+- `launch_kit_verdict` — one of `launch-kit`, `other-stack`, `undecided`. Produced by the `launch-kit-detect` subagent. If missing, abort and ask the caller to run detection first.
+
+## What you read before asking anything
+
+1. `docs/product.md` — voice and positioning live here. Capture the TL;DR and the "Who is it for" paragraph verbatim. These frame every question.
+2. `docs/prd.md` — list of P0 surfaces tells you which components will need brand tokens (landing, dashboard, pricing, onboarding, etc.).
+3. `docs/tech.md` — Stack table. If Tailwind is named, your output includes a Tailwind theme extension snippet. If CSS-in-JS, different output format.
+4. `docs/brand.md` — if present, you are regenerating or amending; read it first and ask what the founder wants to change rather than overwriting blindly.
+
+## The five-to-six questions
+
+Ask one at a time. Do not batch. Skip any question the existing docs already answer clearly (rare; usually Q3 is the only one the docs hint at).
+
+**Q1. Existing brand or greenfield?**
+*"Do you already have a logo, colors, or fonts you want this product to use, or are we starting from scratch?"*
+
+If existing: ask for asset links or hex codes. Store them and skip Q2 for colors if they gave a palette.
+If greenfield: proceed to Q2.
+
+**Q2. Accent color.**
+*"What is the one color a visitor should instantly associate with your product? Paste a hex if you have one, or describe the feeling (e.g. 'confident green, not electric green'). I'll pick the exact shade and the neutrals around it."*
+
+Accept either hex or description. If description, propose three hex options and let them pick.
+
+**Q3. Voice.**
+*"Pick one: is your product's voice plain and direct (Basecamp), technical and precise (Linear), playful and human (Duolingo), or serious and authoritative (Bloomberg)? Or describe your own in a sentence."*
+
+Use their answer to generate do/don't copy examples in the output.
+
+**Q4. Type system.**
+
+Ask the plain-language version first, not the font names. A non-technical founder rarely has visual memory of specific fonts:
+
+*"Pick the feel of your type. Four options:*
+
+*- Clean and modern (like Substack or Vercel). Neutral, fast to read, not showing off.*
+*- Editorial and traditional (like The Atlantic). Serious, long-form-friendly.*
+*- Bold and punchy (like a startup headline). Strong, condensed, high contrast.*
+*- Warm and friendly (like a DTC brand site). Rounded, approachable, human.*
+
+*Or, if you already have a specific font in mind, name it and I'll verify it's available."*
+
+Once they choose one of the four:
+
+- "Clean and modern" → default to Inter (Google Fonts, free).
+- "Editorial and traditional" → default to Source Serif 4 (Google Fonts, free).
+- "Bold and punchy" → default to Archivo (Google Fonts, free).
+- "Warm and friendly" → default to Satoshi via Fontshare (free) or DM Sans (Google Fonts) as the Google-Fonts-only fallback.
+
+Say the chosen default back to them for confirmation: *"I'll use {font} — it's the modern, clean choice {competitor} uses. If you've seen a font you prefer in a similar product, tell me the name and I'll switch."*
+
+If they named a specific font, verify availability on Google Fonts or Fontshare. If unavailable, flag and propose the closest free alternative.
+
+**Q5. Reference products.**
+*"Name 2-3 existing products whose look and feel you want yours to sit next to. Not to copy — to signal the category. For example: 'Stripe, Vercel, Linear' signals polished modern B2B. 'Notion, Figma, Loom' signals warm prosumer. What are your three?"*
+
+Use this to calibrate density, whitespace, radii, and shadow style.
+
+**Q6. Only if greenfield with no logo:**
+*"Two options for your logo right now:*
+
+*- **Just the product name in your chosen font** (what most MVPs launch with). Fast, clean, no design work. Linear did this for years.*
+*- **A proper designed logo** (commission a designer later, or use a tool like Looka). Slower, and often not worth it until you have paying customers.*
+
+*Which do you want for now? You can always upgrade later."*
+
+Capture their preference. Do not generate a logo yourself; if they want a proper designed one, note in the output that a logo is a pending asset.
+
+## Output: docs/brand.md
+
+Use `templates/brand.md` as the skeleton. Fill every section that the questions answered. Leave `<!-- GAP: ... -->` markers only where the founder explicitly deferred (e.g. "logo TBD").
+
+The file must include:
+
+- **TL;DR.** ≤60 words naming the voice in one phrase, the accent color by name, the type system by name, and the three reference products.
+- **Voice.** A paragraph on tone, followed by 3 do/don't copy examples specific to this product's domain.
+- **Palette.** Accent primary (hex), accent secondary or hover state (hex), three neutrals (50/500/900 tints), success/warning/error semantic colors. Every color must be a hex value.
+- **Type.** Heading family + weight + scale (display/h1/h2/h3/h4), body family + weight + default size, mono family if the product is developer-facing.
+- **Spacing.** The scale the kit uses (4px grid, Tailwind-compatible steps 1-24).
+- **Imagery.** One paragraph: photography, illustration, or both? Style descriptors. If the product needs AI-generated creative (AdPilot-style), note the prompt anchors.
+- **Reference material.** The three named products with a one-line description of what each contributes to the feel.
+- **Copy rules.** 3 patterns to use, 3 patterns to avoid. Product-specific.
+- **Kit integration** (only if `launch_kit_verdict` is `launch-kit`): a CSS custom properties block that pastes into the kit's `globals.css` and a Tailwind theme extension snippet that extends the kit's `tailwind.config.ts`. Both must be copy-pasteable and complete.
+
+## Update CLAUDE.md
+
+After writing brand.md, read `CLAUDE.md` at the project root. If it does not already `@`-import `docs/brand.md`, add the import. Position: after `@docs/agents.md`, before `@docs/ACTIVE.md`.
+
+## Gap summary
+
+After writing, report to the caller:
+
+```
+docs/brand.md written.
+
+Voice:       [one-line summary]
+Accent:      [hex + name]
+Type:        [heading family / body family]
+Reference:   [three products]
+Logo:        [present | pending — noted in brand.md]
+
+Kit integration: [yes — globals.css and tailwind.config.ts snippets included | n/a — not a Launch Kit project]
+
+CLAUDE.md:   [updated with @docs/brand.md | already imported]
+
+Any downstream phase packs with ui-spec.md GAP markers for brand tokens can now be regenerated via /cofoundr:next phase [N].
+```
+
+## What you must not do
+
+- Do not design. Do not invent colors, fonts, or voice the founder did not confirm.
+- Do not output a logo. If one is missing, flag and move on.
+- Do not rewrite product.md voice. You draw from it; you do not amend it.
+- Do not ask more than six questions. If the founder needs more structure than this covers, they need a full brand sprint, which is not this command's job.
+- Do not write to `docs/phases/*` or touch ui-spec.md files directly. Those regenerate on their own next run.
+- Do not overwrite an existing `docs/brand.md` without asking first. If it exists, ask what to amend.