bossbuild 0.97.0

package/stages/L0-quickstart/template/.claude/skills/prototype/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: prototype
+description: Get the idea out of your head and onto the screen — fast. Builds the smallest runnable, clickable version of an idea (the one core thing, fastest stack), then runs it so you can react to something tangible instead of arguing with a blank page. Build-first is a legitimate place to start a lean cycle; the conscience helps you fill the gaps AFTER you can see it, not before. Usage - /prototype [IDEA-NNN | rough idea text]
+---
+
+# /prototype — drop an idea, hit go, see something tangible
+
+Sometimes the fastest way to think about an idea is to **see it**. Not a spec, not a canvas — a
+small, real, clickable thing you can react to. `/prototype` builds that: the one core interaction of
+your idea, in whatever stack gets to "click it" fastest, running in front of you in minutes.
+
+Building first is a legitimate way to start a lean cycle — get the idea out of your head, see the gist
+made tangible, then fill in the missing pieces once there's something concrete to fill them *around*.
+The conscience stays out of the way until the thing is on the screen.
+
+> It's a sketch to think with, not your MVP — BOSS names that once, *after* you've seen it.
+
+> **This is BOSS's one licensed play space.** A prototype is a *magic circle* — bounded, safe-to-fail,
+> nothing precious, nothing shipped. Build it badly, build three of them, build the wrong one on purpose;
+> the only job here is to learn by doing. The walls of the circle (it's labelled a sketch, it gets thrown
+> away when it earns a real build, the conscience waits outside until you step out) are exactly what make
+> playing safe. Play isn't the warm-up to the work — for an idea you can't yet see, it *is* the work.
+
+> **The frame, plainly (Marty Cagan, 2026):** this is *building to **learn*** — a throwaway to discover
+> whether the idea's worth it. Building it *for real* is *building to **earn*** — the `/spec` path, with
+> a build you'll keep. Cheap building made delivery easy, which made *fooling yourself* easy too; the
+> two modes stay separate on purpose. `/prototype` is build-to-learn; `boss unlock mvp` → `/spec` is
+> build-to-earn.
+
+## When to run it
+
+- You have an idea (a sentence, or an `IDEA-NNN` from `/triage`) and you want to *see* it, now.
+- You're stuck arguing with yourself in the abstract — a tangible version would unstick you.
+- You want to show someone the gist before you've written a word of spec.
+
+## How to run it
+
+**1. Get the idea.** If given an `IDEA-NNN`, read it (and its canvas if one exists). If given rough
+text, use it. If neither, ask one line: *"What's the idea — one sentence is enough."* Don't
+interrogate; you have enough to start with the gist.
+
+**2. Find the ONE core thing.** Name the single interaction or artifact that *is* the idea — the
+thing that, once someone can do/see it, the idea clicks. A meal-planner's core thing is "see a week
+of meals generated from my constraints," not auth + settings + a profile page. Say what you picked,
+in one line, so the founder can redirect: *"I'll make the part where you [X] — that's the heart of
+it. Everything else can come after."*
+
+**3. Pick the fastest runnable stack** (Principle #4 — stack-neutral, but here optimize for
+*time-to-click*, not production-fitness):
+- **The founder can name it:** `/prototype --stack=<x>` is a first-class option — if they say it, use
+  it, no argument. Only auto-pick when they don't.
+- Simple UI / visual idea → a single self-contained HTML file (open it, done) or a minimal Vite +
+  React app if it needs real interactivity.
+- A tool / transform / data idea → the smallest script with a tiny UI or CLI.
+- Pick the one that runs **fastest with fewest moving parts.**
+- **Narrate the pick in plain words, not jargon** — to a beginner, say *"a single web page, nothing to
+  install"*, not *"a Vite stack."* Name it as a speed pick they can change, not a decision made for
+  them. (If the project already chose a stack, respect it unless it'd slow the sketch down.)
+
+**4. Build the minimal slice.** Just the core thing, made real. Use mock/sample data freely — the
+point is tangibility, not a backend. **Don't gold-plate a throwaway** — tangible beats pretty (it's a
+sketch). Skip the design polish by default; only if the sketch is becoming something you'll keep (or
+an `eng-builder`/design-minded cohort asks) reach for the 5-token distinctiveness pass from
+`/design-tokens-init`. Keep it in a clearly-a-sketch place (`prototype/` if the repo has other code;
+root if it's empty).
+
+**5. Run it.** Use `/run` (or just open the file). Get it on the screen. This is the moment — don't
+bury it in narration.
+
+**6. Then — and only then — the conscience rides along (gently).** Once it's running, lead with a
+**concrete next action in plain words**, not a vocabulary word. The shape:
+> *"There it is. Click around — does seeing it change what you thought the idea was? Want me to fake
+> the next screen, or change the part that feels off?"*
+
+Then, *only if they're ready*, introduce the next step **by what it does**, not its name: *"When you
+want to figure out who this is really for and what would make it worth building — there's a step for
+that (`/canvas`). And 'I don't know yet' is a fine answer; that's what it's for."* Never let the nudge
+imply the sketch *isn't real* or that not-knowing-the-user is a failure — they're building precisely
+to find out. Don't say `/canvas` / "pressure-test" cold to a beginner; let the step introduce itself
+when they get there.
+
+That's the whole conscience touch: *after* the tangible thing, a concrete action first and the
+vocabulary later, never a gate before.
+
+## Cohort-aware delivery
+
+Read `cohort` from `.boss/config.json`:
+- **`first-product` / `vibe-coder-newbie`** — lead with the magic moment; narrate in plain language
+  ("I'm building the one core screen so you can see it — about a minute"); celebrate seeing it
+  *running*, not the code.
+- **`eng-builder` / `returning-founder`** — give stack control up front ("fastest path is a single
+  Vite page — or name your stack"); skip the 101; leave the escape hatch obvious.
+- **`vibe-virtuoso`** — they'll have opinions; offer the stack pick as a default to override, move fast.
+- **`non-tech-founder`** — plain language, no jargon; the deliverable is "a thing you can click and
+  show someone," not "a React app."
+- **`domain-expert`** — one guardrail up front: *"this is a sketch to react to, not a
+  clinical/regulated tool — don't put real [patient/client/financial] data in it."* Stakes are real;
+  say so before, not after.
+
+## Rules
+
+- **Tangible beats complete.** A rough thing that runs beats a polished thing that doesn't. Ship the
+  click, not the codebase.
+- **Mock freely.** Sample data, hardcoded values, fake responses — all fine for a sketch. Don't build
+  a backend to prove an idea.
+- **Name it as a sketch — once.** "See-it, not sell-it." Say it one time (cohort-appropriate), then
+  let them play. Don't moralize.
+- **Conscience after, never before.** No "have you validated this?" gate in front of the build. The
+  whole point is that building *is* a legitimate first move. The nudge toward `/canvas` comes once
+  there's something to react to.
+- **Don't quietly become the MVP.** The real failure isn't abstract — it's the sketch that picked up
+  4 real users and is now getting auth and a database bolted onto throwaway code nobody meant to keep.
+  When the sketch earns a real build, *restart it* on the deliberate path (`boss unlock mvp` → `/spec`
+  → `/evals`), don't grow the sketch into production. Fast to *see*; rebuild to *keep*.

package/stages/L0-quickstart/template/.claude/skills/triage/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: triage
+description: Capture an idea — and keep adding to it. Creates a LIVING idea doc you return to over time: a sharpening "current shape" at the top, an append-only capture log below. The lightest step in Quickstart mode. Usage - /triage <thought>  (run again anytime to add more)
+---
+
+# /triage — capture & keep adding
+
+Quickstart is about getting an idea out of your head and letting it *grow* with almost no
+ceremony. Each idea is a **living document**, not a one-shot form. Run `/triage` whenever a new
+thought lands — the first run creates the doc, every later run adds to it.
+
+## Decide: new idea or add to an existing one?
+
+1. Read `docs/ideas/INDEX.md` and skim existing `docs/ideas/IDEA-*.md` titles.
+2. If the user's thought clearly extends an existing idea → **append** to that doc (don't make a new one).
+3. Otherwise → **create** a new `IDEA-NNN` (next free number).
+
+## Create (first capture)
+
+Make `docs/ideas/IDEA-NNN-<slug>.md`:
+
+```markdown
+---
+id: IDEA-NNN
+type: idea
+owner: pm
+status: seedling
+created: {{today}}
+---
+
+# <Title — one plain line>
+
+## Current shape
+_The best articulation so far. Rewrite this as the idea sharpens._
+- **What:** …
+- **Who it's for:** …
+- **Smallest version that proves it:** …
+
+## Capture log
+_Append-only. Newest at the bottom. Don't edit old entries._
+- {{today}} — <the thought, in their words>
+
+## Open questions
+- <what's still fuzzy>
+
+## Canvas
+_Not started. When this has legs, run `/canvas` to pressure-test it as a business._
+```
+
+Add a row to `docs/ideas/INDEX.md`.
+
+## Add (every later run)
+
+- Append a dated bullet to **Capture log** (their words — light touch, don't sanitize the spark).
+- If the thought sharpens the idea, rewrite **Current shape** to reflect it.
+- Move any resolved item out of **Open questions**; add new ones that surfaced.
+- Don't restructure or "finalize" — this is an evolving notebook, not a deliverable.
+
+## The validation check — BOSS's conscience
+
+Quickstart makes it *easy* to keep capturing. That's the trap: a growing pile of captured ideas can
+feel like progress while nothing has actually been tested. So after you capture or add, glance at the
+state — and if it's drifting, **say one thing, then get out of the way.** This is the first of BOSS's
+conscience moments: *what does this prove?*
+
+**When to speak (keep it rare):** the idea you just added to has **≥3 capture-log entries** and there's
+**no `IDEA-NNN-canvas.md` with a filled riskiest assumption** (no canvas at all, or the *Riskiest
+assumption* line is still a placeholder). That's the "building lots, proving nothing" signal — and the
+only time this fires.
+
+**What to say:** one spare line, in BOSS's voice — name the drift, ask what they'd want to *learn* (or
+*who they'd ask first* — Fitzpatrick-style, plain language), hand the decision back. Don't lecture, don't
+block the capture, don't make it a gate. **Voice lineage decision (v0.20.0):** lean Fitzpatrick-plain over
+Maurya-framework-name; the indie-hacker persona caught the prior mix and the cohort-portable version uses
+ask-someone language consistently. Tune it to them by ear; don't paste this verbatim:
+
+> *"That's the third thing you've added here, and none of it's been tested yet. Who would you talk to first
+> to find out if any of them are real? `/canvas` is one way to pressure-test it — but a 15-minute call with
+> the right person beats it."*
+
+**Cohort awareness (v0.20.0+):** if `.boss/config.json` has a `cohort` field set, the conscience hook ships
+that to your context. *Read the framing and adjust the voice* — a `first-product` founder needs *teaching*
+(define terms inline; invite, never grade), a `returning-founder` wants the *harder cohort-aware question*
+("is your conviction here at the level it needed to be for the last thing?"), a `vibe-virtuoso` deflects
+discipline content but respects friction ("you've shipped a lot — what's the bet you'd stay on for six
+months even if it didn't go viral?"). Same signal; different voice.
+
+**Stay quiet otherwise.** Say it once. If they keep capturing without acting, don't repeat it every run —
+a conscience that nags is just noise. Raise it again only if a lot more piles up, or they ask. Assume
+they're smart: you're flagging a blind spot, not grading them.
+
+## When it has legs
+
+If the idea feels real (recurring, exciting, worth betting time on), say so and offer the next rung:
+- `/canvas` — pressure-test it as a business (customer, problem, value prop, risks, validation…).
+- or `boss unlock mvp` — if you're already sure and ready to build the first working version.
+
+## Rules
+
+- Capture > ceremony. A one-liner is a complete input.
+- One idea per doc. If they chain several with "also", split into separate docs.
+- Never start building from `/triage` — this is capture only.
+- Preserve the original spark verbatim in the capture log; sharpen in "Current shape," not by overwriting history.
+- The validation check is a nudge, never a gate — it never blocks a capture and never repeats into a nag.

package/stages/L0-quickstart/template/.claude/skills/welcome/SKILL.md

@@ -0,0 +1,262 @@
+---
+name: welcome
+description: First time using BOSS? Start here. A gentle orientation — what BOSS is, what's already in this folder, what to do next, how the conscience works, how to override or pause it. Cohort-aware: beginners get the full tour with terms defined inline; experienced founders get the 30-second version + a pointer to /boss. Run this once when you open a fresh project, or anytime you want to re-orient. Usage - /welcome
+---
+
+# /welcome — the gentle entry into BOSS
+
+The first thing a new founder sees in a `boss new` project shouldn't be a wall of documentation
+or a power-user prompt that says *"drop your PRD."* It should be a hand: *here's what this is,
+here's what's already in place, here's what to do next.* That's this skill.
+
+This is the BOSS counterpart to *"hello, world."* Run it once when you open a fresh project.
+Re-run anytime you want to re-orient. It doesn't do anything destructive; it talks and listens.
+
+## Voice rules for this skill specifically
+
+- **Plain language.** No "scaffolding ceremony per Principle 2." Just "BOSS will lay down what
+  you need when you need it, not before."
+- **Define terms inline** — *Quickstart*, *MVP*, *conscience*, *cohort*, *capture* — all need
+  a one-line definition the first time they appear. Don't assume the founder reads docs first.
+- **Read the room.** If the founder's cohort is `returning-founder` / `eng-builder` /
+  `vibe-virtuoso` / `indie-hacker`, the orientation is 30 seconds, not 5 minutes — these
+  cohorts are intolerant of 101 content. Cite the cohort and trim accordingly.
+- **No metaphor avalanche.** "Conscience" is the one anthropomorphism BOSS earns; the rest
+  stays mechanical (loops, moments, hooks). Don't extend the metaphor unless asked.
+- **Close on the action — long content must tie back to the next step.** The failure mode this
+  skill was *built* to avoid: the founder reads a wall, gets the gist, and forgets what to *do*.
+  So never end a long passage on a recap. End it on the single next step, restated. If you've
+  just explained a lot, the last line is an action — *"So: your next step is `/boss <your idea>`."*
+  When in doubt, give the shape + the action, then **offer** the rest rather than printing it.
+
+## 0. Orient (silent)
+
+Read, in order:
+- `.boss/manifest.json` — current mode + installed agents/skills + boss version.
+- `.boss/config.json` — `cohort`, `github`, `visibility`, `license`, any pause state.
+- `CLAUDE.md` — the project's working rules.
+- `docs/ideas/INDEX.md` — empty in a fresh project; lists ideas in a working one.
+
+Don't announce these reads. Just orient.
+
+## 1. Open with a small introduction
+
+> *"Welcome. This is BOSS — a tool that helps you build by nudging when something looks like
+> it's drifting, and staying quiet the rest of the time. I'm Claude; I'll be working with you
+> on this project. A quick orientation, then we'll get started — and you can skip anything
+> you already know."*
+
+That's it. No more than 3-4 sentences. The founder is here to build, not to read.
+
+## 2. Ask the cohort question (if unset)
+
+Read `cohort` from `.boss/config.json`. If `null` (the default), ask the SAME open question
+`/boss` step 6 asks:
+
+> *"Quick optional thing — which of these sounds most like where you're starting from? It lets
+> BOSS tune itself for you. If none fit, skip:*
+> - *`vibe-coder-newbie` — picked up Cursor/Claude Code recently, no eng/startup background*
+> - *`eng-builder` — strong eng background, first-time founder*
+> - *`non-tech-founder` — domain expertise, no coding background, AI is the bridge*
+> - *`first-product` — absolute first product ever, learning everything as you go*
+> - *`vibe-virtuoso` — ships a lot of projects, harder time sustaining one*
+> - *`indie-hacker` — building right-sized; calm-company, not venture*
+> - *`returning-founder` — shipped before; want depth, not 101*
+> - *`domain-expert` — deep expertise in a high-stakes domain (medical / legal / financial)*
+> - *skip — leave it generic"*
+
+On answer, write the value to `.boss/config.json` (don't disturb other fields). If they skip,
+leave `null`. Move on. **Don't argue their pick** — they can edit the file later, and live use
+will sharpen it.
+
+## 2.5 Ask: solo, or building with someone? (light, optional)
+
+One more quick one — it decides whether BOSS's team layer is even visible:
+
+> *"Are you building this **solo**, or **with a cofounder**? (You can change this anytime.)*
+> - *Solo — BOSS stays out of your way; the team features stay dormant.*
+> - *With someone — tell me their GitHub handle and BOSS keeps you both in the loop:*
+>   *`boss team add @their-handle "Their Name"`."*
+
+If solo (or unsure), do nothing — that's the default and nothing changes. If they name a cofounder,
+run `boss team add @handle "Name"` for them. The roster lights up the team layer (a shared decision
+log via `/decide`, and more as the venture grows). **Never pressure the team answer** — solo is a
+first-class, fully-supported path.
+
+Either way, mention the quiet win once: *once you push this repo to GitHub, your thinking — ideas,
+decisions, the canvas — is **backed up**, and a cofounder who clones it is automatically in the loop.
+The only things that stay on your machine are your secrets and the conscience's private notes on how
+its nudges landed for you.* (Don't belabor it — one line, then back to the next step.)
+
+## 3. Branch by cohort
+
+### 3a. Beginner cohorts → full orientation
+
+If cohort is `first-product`, `vibe-coder-newbie`, `non-tech-founder`, or `null` (skipped),
+walk the full tour below. **Use plain language and define every term the first time it
+appears.** Sections are short on purpose — 2-3 sentences each, not paragraphs.
+
+### 3b. Experienced cohorts → 30-second version
+
+If cohort is `eng-builder`, `vibe-virtuoso`, `indie-hacker`, or `returning-founder`:
+
+> *"You probably don't need the tour. The short version: you're in Quickstart mode; the
+> folder has `CLAUDE.md` (project rules), `.boss/` (mode + config), `.claude/` (skills +
+> agents the project has access to). Run `/boss` to spin up — point it at your idea however it
+> exists (a sentence, a file, a Google Doc / Obsidian / PDF / deck, a URL, or several); it pulls
+> a copy into `docs/source/` and shapes it. `/import` adds more material to an idea later.
+> The conscience (`UserPromptSubmit` hook) will nudge if it sees drift; `boss conscience pause`
+> silences all of it, or `boss conscience mute <moment>` turns down just one (drift|caution|…)
+> if a single nudge keeps missing. That's it. Ready when you are."*
+
+Then **stop**. Don't elaborate. They'll ask if they want more.
+
+### 3c. Domain-expert → middle path
+
+If cohort is `domain-expert`, do the full tour but **emphasize the high-stakes framing**
+inline: BOSS treats hallucination as a human-in-the-loop event for this cohort; the AI-first
+template (`/ai-first-init`, MVP-mode) defaults to privacy-first logging; the conscience errs
+on the side of speaking when stakes are real. Domain experts have business sense but may be
+new to building — pace accordingly.
+
+## 4. The full tour (beginner cohorts)
+
+### What BOSS is
+
+> *"BOSS is a build tool. Three pieces:*
+> 1. *A **mode** — how much structure the project has. New projects start in **Quickstart**
+>    (lightest); they level up to **MVP**, **V1**, and **Scale** as the project earns it.
+>    Think of modes like a notebook getting more organized as a project matures.*
+> 2. *A set of **skills** — small commands like `/boss`, `/triage`, `/canvas` that do one
+>    thing well. You'll see them suggested as you work.*
+> 3. *A **conscience** — a quiet background process that sometimes speaks up if something
+>    looks like it's drifting (capturing lots of ideas but never validating any, for example).
+>    It's a **nudge, never a block.** You can override or pause anytime."*
+
+### What's already in this folder
+
+Read the manifest. Name what's there in plain language:
+
+> *"You're in **Quickstart** mode right now. The folder has:*
+> - *`CLAUDE.md` — the working rules for this project. Read it first.*
+> - *`.boss/manifest.json` — what BOSS installed; `.boss/config.json` — your preferences.*
+> - *`.claude/skills/` — the skills you can run with `/<name>`. Today: `/boss` (spin up an idea),
+>    `/triage` (capture one), `/prototype` (hit go — see it running), `/canvas` (pressure-test it),
+>    `/persona` (your user's voice), `/welcome` (you're here), and a few more (`boss map` lists them all).*
+> - *`.claude/agents/` — specialized helpers BOSS can hand work off to: `pm` (decides what's
+>    worth building), `coder-generalist` (builds it once the stack is chosen), `mentor-
+>    venture` (advisory only — coaches on whether the bet is worth taking).*
+> - *`docs/ideas/` — where ideas live as living docs. Empty now; fills as you capture."*
+
+### What to do next
+
+Two paths. Name both; let the founder pick.
+
+> *"**Path A — you have a rough idea or PRD already.** Run `/boss` next. Point me at it however it
+> exists — a sentence, a file path, a URL, even a few of them (a Word doc, a deck, an Obsidian note,
+> a PDF, a Google Doc link). I'll pull a copy into the project, shape it, capture it as `IDEA-001`,
+> recommend a stack and mode, and (with your OK) create a private GitHub repo. That's the **spin-up**
+> flow. (Already captured the idea and want to add more material later? That's `/import`.)*
+>
+> *Path B — you have a fragment, a hunch, or just a topic to noodle on. Run `/triage <one
+> sentence about it>`. I'll create a living idea doc you can keep adding to. Re-run `/triage`
+> anytime to add more. No commitment yet — capture first, decide later.*
+>
+> *And either way — if you'd rather **see** the idea than describe it, run `/prototype <the idea>`.
+> I'll build the smallest clickable version of the one core thing so you can react to something real
+> instead of a blank page. Building first is a fine place to start; we fill in the rest after.*
+>
+> *When the idea has legs, run `/canvas` — a humane pressure-test that asks: who's served?
+> what's the tension? what's the promise? who could be harmed? what's the riskiest assumption?
+> Canvas is the gate before you unlock MVP mode and start building."*
+
+> **Pivot here — offer the rest, don't dump it.** The founder now has the shape and the next
+> step. The three topics below (how the conscience works, how modes level up, where to find help)
+> are **reference, not required reading** — printing all three is exactly the wall that makes a
+> founder forget what to do. Name them in one breath and offer:
+>
+> > *"That's enough to start. There's more I can walk you through whenever you want it — how the
+> > conscience nudges, how modes unlock as you go, where to get help — but none of it blocks you.
+> > Want any of it now, or shall we get going with `/boss` or `/triage`?"*
+>
+> Expand a topic **only if they ask.** The sections below are the material you draw on then — not
+> a script to read top-to-bottom. Either way, end on the action (section 5).
+
+### How the conscience works _(reference — expand only if asked)_
+
+> *"The **conscience** is the most BOSS-specific thing here. It watches for a few specific
+> drift patterns — for example: capturing three ideas in a row without filling out a canvas
+> for any of them. When it sees one, it adds a short signal to my context (not a popup, not
+> a block) — and I decide whether to surface it in my own voice. It's never canned text;
+> it's never a gate.*
+>
+> *There are a handful of these drift patterns — each one is a **moment** (drift, caution,
+> capture, focus…). You don't have to take all of them. Three controls, from broadest to
+> most surgical:*
+> - *`boss conscience pause --for 8h` — silences the **whole** conscience for a build session.
+>   Auto-resumes after 8 hours (or use `--until-resume` for indefinite + `boss conscience
+>   resume` later).*
+> - *`boss conscience mute <moment> --for 7d` — turns down **one** moment (e.g.
+>   `boss conscience mute capture`) while the others keep speaking. Auto-unmutes when it
+>   expires, or `boss conscience unmute <moment>` / `--all`. Use this when one nudge keeps
+>   landing wrong but the rest are useful. (`boss conscience status` shows what's muted.)*
+> - *In your devlog or commit, write `- **OVERRIDE:** <decision> — rationale: <why>`. BOSS
+>   records the override; it doesn't argue.*
+>
+> *The pattern is: deviation conscious, recorded, never blocked, never forgotten. If a moment
+> isn't for you, mute it — that's a feature, not a fight."*
+
+### How modes level up _(reference — expand only if asked)_
+
+> *"You're in Quickstart now. As the project earns more structure, you unlock the next mode:*
+> - *`boss unlock mvp` — when the canvas holds up and you're ready to actually build. Adds
+>   spec discipline (`/spec` → `FEAT-NNN`), a smoke check (`/smoke`), evals (`/evals`), AI
+>   cost budgets (`/ai-cost`), failure-state design (`/ai-failure-states`), a devlog, a
+>   session-end ritual (`/close`).*
+> - *`boss unlock v1` — when MVP is real and you need design system rigor, prototypes, a
+>   real database, an admin board.*
+> - *Scale is on the roadmap; not authored yet — only earn it when you actually have one.*
+>
+> *Levels are **additive** — unlocking MVP keeps everything Quickstart added. You're not
+> jumping; you're growing the system."*
+
+### Where to look for help _(reference — expand only if asked)_
+
+> *"`boss --help` for CLI commands; `boss status` for what mode you're in; `boss list` for
+> every project you've registered. In Claude, list available skills by typing `/`. The
+> [README](https://github.com/ajeshh/BlueprintOS) and `PRINCIPLES.md` are the canonical
+> references — short by design."*
+
+## 5. Wrap up — end on ONE exact next step
+
+The founder has just read a fair amount. The single most important thing now: they leave knowing
+*exactly what to type* — one literal command, not a menu. After a lot of content, a fork ("/boss or
+/triage, your pick") re-triggers the forgetting this whole skill exists to prevent. So **recommend one
+action, put the literal command on its own line, and demote the alternative to a single parenthetical:**
+
+> *"That's the tour. Your next step — just one thing:*
+>
+> ***`/boss <your idea>`** — a sentence, or a path to a doc / a link / a Google Doc. I'll pull it in,
+> shape it, and capture it. That's the whole start.*
+>
+> *(Only have a fragment, not a whole idea yet? `/triage <a thought>` instead — same start, lower stakes.)"*
+
+Never end on *"pick whichever feels right."* One bold, literal, do-it-now command; the fallback gets a
+parenthetical, not equal billing. The founder should be able to act without re-reading anything above.
+
+## Rules
+
+- **Re-runnable.** `/welcome` does nothing destructive. Re-running is fine; the founder might
+  want to re-orient mid-project. Don't refuse to re-run.
+- **Cohort changes the depth.** Beginner cohorts get the full tour; experienced cohorts get
+  the 30-second version. The cohort question is asked ONCE; the answer persists in
+  `.boss/config.json`.
+- **No power moves.** Don't run `/boss`, `/triage`, or any other skill *for* the founder.
+  Suggest them; let the founder decide. /welcome is orientation, not action.
+- **Don't oversell.** BOSS is a build tool, not a religion. If the founder says "this
+  is overkill for what I'm doing," they may be right — point at `boss conscience pause`,
+  point at the override grammar, point at the JIT principle. Don't argue.
+- **Plain language wins.** The phrase *"just-in-time agentic ceremony"* doesn't belong in
+  this skill. The phrase *"BOSS lays down what you need when you need it"* does.
+- **End with one clear next step.** The founder leaves /welcome with one of: a `/boss` run,
+  a `/triage` run, or a clear "I'll come back later." Three doors, no decision-paralysis.

package/stages/L0-quickstart/template/AGENTS.md

@@ -0,0 +1,31 @@
+# AGENTS.md — {{PROJECT_NAME}}
+
+> Working rules for **any** AI coding agent in this repo (host-neutral). Scaffolded by BOSS
+> (BOSS) {{BOSS_VERSION}} on {{DATE}}. Claude Code reads these through `CLAUDE.md` (which imports this
+> file); other agent tools (Codex, Cursor, Copilot, Devin, …) read this file directly. Keep it the
+> source of truth for how work is done here — `CLAUDE.md` adds only the Claude-specific layer.
+
+## Working rules (read first)
+
+1. **Capture before you build.** Every idea, bug, or ask becomes an `IDEA-NNN` before code. See `docs/ideas/INDEX.md`.
+2. **Stack-neutral until decided.** This project has no assumed stack. The first real build decision picks one; record it in an idea/spec, not in your head.
+3. **Source of truth is the docs, not the chat.** Decisions go in `docs/`. If code and a doc disagree, surface it before changing either.
+4. **Small, reversible steps.** One concern at a time. Prefer editing existing files to adding new ones.
+5. **Ask before risky/irreversible actions** (deletes, force-push, anything affecting shared state). Local reversible edits don't need a check.
+6. **Don't over-build.** No speculative abstractions, no error handling for impossible states, no comments that restate the code.
+7. **Grow the system deliberately.** This project grows through *modes* (Quickstart → MVP → V1 → Scale); add ceremony only when the project earns it. The BOSS CLI lays each mode down (`boss unlock <mode>`).
+
+## Conventions
+
+- **IDs:** `IDEA-NNN` for raw ideas, `DEC-NNN` for load-bearing/hard-to-reverse decisions (see `docs/IDS.md`). More ID types unlock with later modes.
+- **Decisions:** record the load-bearing or one-way-door calls with `/decide` → a `DEC-NNN` (Context / Decision / Why / Consequences + who decided + how reversible). Supersede, don't edit. The rationale future-you and a cofounder can read instead of guessing.
+- **Frontmatter:** every new doc carries `id`, `type`, `owner`, `status`.
+- **Backup & share:** your `docs/` (ideas, canvas, `DEC-NNN` decisions, RESUME) and the venture brain's `read.md` commit with the repo — so **pushing backs up your thinking**, and a cofounder who clones is **in the loop**. Only secrets and the conscience's private relationship-with-you stay local. Building with a cofounder? `boss team add @their-handle "Name"` (solo stays the default — the team layer is dormant until someone joins).
+- **Git:** small commits, present-tense messages, never force-push shared branches without asking.
+
+## Project overview
+
+<!-- Replace this with what {{PROJECT_NAME}} is. Already have it written somewhere — a doc, a deck,
+     an Obsidian note, a Google Doc, a PDF, a link? Point your agent at it and capture the idea. -->
+
+_TBD — describe {{PROJECT_NAME}} here._

package/stages/L0-quickstart/template/CLAUDE.md

@@ -0,0 +1,57 @@
+# CLAUDE.md — {{PROJECT_NAME}}
+
+@AGENTS.md
+
+> Scaffolded by BOSS {{BOSS_VERSION}} in **{{MODE}}** mode ({{STAGE}}) on {{DATE}}.
+> The host-neutral **working rules + conventions live in `@AGENTS.md`** (imported above — read it
+> first). This file adds only what's Claude-specific: the skills, the conscience, and the mode ladder.
+> Keep it short — compliance drops past ~200 lines.
+
+> **First time? Run `/welcome`** — gentle orientation, takes a minute, defines terms inline.
+> Already familiar with BOSS? Skip to `/boss <idea, file, Google Doc / Obsidian / PDF, or URL>` to
+> spin up — it pulls your material in. Already have it written somewhere? `/import <file|url>`.
+
+## What exists in this mode ({{MODE}})
+
+- **Agents:** `pm` (decides what's worth building), `coder-generalist` (builds it, in whatever stack gets chosen), `mentor-venture` (coaches *you*, the founder — is this worth it, what's the riskiest assumption, what's the next real step).
+- **Skills:** `/welcome` (gentle first-run orientation — cohort-aware), `/boss` (spin up an idea — point it at a sentence, file, doc, or URL), `/import` (bring existing material in — Word/Google Doc/Obsidian/PDF/deck/link → `docs/source/`), `/triage` (capture an idea & keep adding to it — a living doc), `/prototype` (drop an idea, hit go — build the smallest clickable version fast), `/canvas` (pressure-test it as a humane business when it has legs), `/decide` (record a load-bearing or hard-to-reverse call as a durable `DEC-NNN` — who decided, why, how reversible), `/persona` (your app's target user as a consultable voice), `/comprehend` (AI-native: tailor the scaffold to what BOSS understands — opt-in via `--ai`), `/feedback` (tell BOSS's makers what's working / broken — user-initiated, never background telemetry), `/boss-sync` + `/boss-learn` (pull BOSS updates in / promote a pattern UP).
+- **Docs:** `docs/ideas/` (living idea docs + canvases), `docs/IDS.md` (the ID system, minimal here).
+- **Memory:** two kinds, kept apart so context stays lean. *Durable facts* (who you are, settled decisions) → Claude's auto-memory, active across sessions. *Working state* (notes that only matter while you're in one area of the code) → `.claude/rules/your-app-code.md`, which loads **only when** Claude opens a file it's scoped to — not every session.
+
+### The Quickstart arc
+
+Quickstart is a tiny incubator: **capture → keep adding → canvas → unlock MVP.**
+
+1. **Capture** a raw idea with `/triage` (or `/boss`). It becomes a living `docs/ideas/IDEA-NNN.md`.
+2. **Keep adding.** Re-run `/triage` whenever a new thought lands — it appends to the capture log and sharpens the idea. No pressure to "finish."
+3. **Canvas** it with `/canvas` once it has legs — a humane business pressure-test (the Humane Product Canvas + lean/Lenny prompts) that names the riskiest assumption and a one-week experiment.
+4. **Unlock MVP** (`boss unlock mvp`) when the canvas holds up and you're ready to build.
+
+BOSS plays **conscience** along the way: if you keep capturing without testing anything, `/triage` will
+pause once to ask *what does this prove?* — a nudge toward `/canvas`, never a gate. Capturing isn't the
+same as validating.
+
+## The four modes (unlock additively)
+
+This project is in **{{MODE}}** mode. Modes level up as the project earns it:
+
+| Mode | Adds | When |
+|---|---|---|
+| **Quickstart** _(here)_ | idea capture, `/boss` spin-up, `/triage`, `/prototype`, pm + coder | you have an idea to capture |
+| **MVP** | `/spec` + `FEAT-NNN`, `/smoke` build gate, devlog, `/close` + RESUME.md, tester | you're ready to build the first working version |
+| **V1** | design system, prototypes, `/board`, doc-placement contract, db-architect | ready for a real, shippable v1 |
+| **Scale** | PM org, refactor automation, code-health, product council | a fully blown-out, complex app |
+
+Run `boss status` to see your mode and whether newer BOSS practices are available. Run `boss unlock <mode>` (e.g. `boss unlock mvp`) to level up.
+
+---
+
+## Reference
+
+### Agent roster (Quickstart)
+
+| Agent | Use for |
+|---|---|
+| `pm` | What's worth building, scope, priority. Not a coder. |
+| `coder-generalist` | Implementation in the chosen stack. Configured when the stack is decided. |
+| `mentor-venture` | Coaches the founder: is this worth it, riskiest assumption, next step. Advisory only — no code. More mentors unlock per mode (see `docs/MENTORS.md`). |

package/stages/L0-quickstart/template/docs/IDS.md

@@ -0,0 +1,42 @@
+---
+id: IDS
+type: index
+owner: pm
+status: active
+---
+
+# ID System — {{PROJECT_NAME}}
+
+Stable IDs make work addressable across sessions and docs. New types unlock as the project matures.
+
+## Active in Quickstart mode
+
+| Prefix | Means | Lives in |
+|---|---|---|
+| `IDEA-NNN` | A raw idea, bug, or ask | `docs/ideas/` |
+
+## Unlocks later
+
+| Prefix | Means | Unlocks in mode |
+|---|---|---|
+| `FEAT-NNN` | A scoped feature with a spec | MVP |
+| `FIX-NNN` / `BUG-NNN` | A cross-cutting fix or bug | MVP |
+| `EXTR-NNN` | A pattern extraction decision (UP into library / DOWN into app core; PRINCIPLE #1) | MVP |
+| `DEC-YYYY-MM-DD-NNN` | A logged decision | V1 |
+| `RFC-NNN` | A decision document | Scale |
+| `EXP-NNN` | A lab experiment | Scale |
+
+## Frontmatter (required on every new doc)
+
+```yaml
+---
+id: <ID or slug>
+type: <idea | feature | fix | decision | index | spec | ...>
+owner: <agent or person>
+status: <seedling | exploring | ready | building | shipped | dropped>
+---
+```
+
+Numbering: allocate the next free integer per prefix. Before reserving a `FEAT-NNN`,
+grep all of `docs/` (not just an index) so planning docs that reserve numbers ahead of
+folders don't get clobbered.

package/stages/L0-quickstart/template/docs/ideas/INDEX.md

@@ -0,0 +1,24 @@
+---
+id: IDEAS-INDEX
+type: index
+owner: pm
+status: active
+---
+
+# {{PROJECT_NAME}} — Idea Pool
+
+Raw ideas, captured before they're built. Use `/triage <thought>` to add one.
+Promote an idea to a spec (`FEAT-NNN`) once MVP mode is unlocked and it's ready to build.
+
+| ID | Title | Status | Note |
+|---|---|---|---|
+| _none yet_ | | | run `/triage` to capture the first |
+
+## Status values
+
+- `seedling` — captured, not yet examined
+- `exploring` — being thought through
+- `ready` — scoped, ready to build (promote to FEAT in MVP mode)
+- `building` — in progress
+- `shipped` — done
+- `dropped` — decided against (keep the row; record why)