bossbuild 0.97.0

package/stages/L1-mvp/template/docs/loops/design-tokens-loop.md

@@ -0,0 +1,98 @@
+---
+id: design-tokens-loop
+type: loop
+stage: L1-mvp
+runner_type: hook
+attributed_to: [Brad Frost, Nathan Curtis, Ajesh Shah]
+also_relevant: [Jina Anne, Diana Mounter, Dan Mall, John Maeda]
+entry:
+  - count_at_least:
+      path_glob: src/**
+      pattern: '(className=|style={|css`|styled\.)'
+      min: 3
+exit:
+  - exists: { path: docs/design/DESIGN_TOKENS.md }
+  - count_at_least:
+      path_glob: src/**
+      pattern: '(token\.|var\(--|colors\.|tokens\.|theme\.)'
+      min: 3
+drift_moment: coherence
+---
+
+# Loop: design-tokens (MVP)
+
+The discipline that **prevents the 47 blues** ([IDEA-010](../../ideas/IDEA-010-scalable-ai-design.md)).
+The most-common AI-generated-UI failure mode: each new screen Claude generates derives its own
+colors, spacing, components — and the codebase grows linearly with screens. This loop catches
+that early, JIT, *only when UI is actually accumulating.*
+
+`runner_type: hook` — the conscience hook evaluates this loop on every UserPromptSubmit. But the
+loop is structured so it **doesn't fire on fresh projects** (the entry predicate requires ≥3
+style declarations across `src/`; a brand-new repo has 0). It opens only when the founder has
+started accumulating UI — *the first UI commit inflection* (IDEA-010's "early-start JIT").
+
+When open, the conscience surfaces a `coherence` moment (new in v0.21.0 — a flavor of caution
+specific to system-vs-code drift): *"You're putting style into code without a token system. The
+AI doesn't have a reference, so each screen will reinvent colors and spacing — fast-forward to
+the 47 blues. Want me to run `/design-tokens-init` now?"*
+
+## Entry artifact
+
+`src/` contains ≥3 source files with inline style declarations (matched by a regex covering
+common patterns: Tailwind `className=`, inline `style={}`, css-in-js template literals, styled-
+components syntax). Threshold of 3 is the *"the first UI commit"* signal — one or two are an
+exploratory file; three is the founder starting to *build*. Stack-agnostic enough to catch most
+common React / Vue / Svelte / Solid projects today.
+
+For projects in stacks the regex misses, the founder can either:
+- Edit this loop spec's entry pattern to match their stack
+- Or simply run `/design-tokens-init` manually (the loop respects override)
+
+## Purpose
+
+Scaffold the minimum three-layer design token system *before* drift accumulates. Cohort-aware
+delivery (per `/design-tokens-init`): vibe-coder-newbie gets SHOWING; eng-builder gets OFFERING;
+vibe-virtuoso gets OVERRIDE-FRIENDLY; etc.
+
+## Exit artifact
+
+`docs/design/DESIGN_TOKENS.md` exists AND code references tokens (≥3 occurrences across `src/`
+of patterns like `token.`, `var(--`, `colors.` (when a tokens module is imported), `tokens.`,
+`theme.` — covers most token-consumption styles). The dual requirement matters: a tokens file
+without any code consuming it is theater, not discipline.
+
+## Drift
+
+Entry satisfied (≥3 style declarations) AND exit not satisfied (no tokens file OR no token refs)
+→ loop is open → conscience emits `coherence` moment. Confidence scales:
+- 3-5 style declarations: low confidence (might be exploratory)
+- 6-10: medium
+- 11+: high (real drift)
+
+The voice (cohort-aware via v0.20's framing): name the drift in one line, offer to scaffold,
+hand the decision back. Override is recorded in devlog per IDEA-008.
+
+## How to remix
+
+- **Skip:** legitimate when the project's UI is genuinely throwaway (an internal admin script,
+  a one-off demo). Override:
+  ```
+  - **OVERRIDE:** skipped `design-tokens-loop` — rationale: <UI is throwaway —
+    e.g., admin script for personal use; not user-facing; not maintained beyond
+    this build>.
+  ```
+- **Swap discipline:** Frost-Atomic-Design lineage vs. Curtis-tokens-layer-cake vs. a stack-
+  native pattern (e.g., Mantine's theme tokens; Chakra's theme; Tailwind's config). The loop's
+  exit predicate checks for token *consumption*, not a specific tool. Stack-aware adapters can
+  live in `library/practices/scalable-ai-design/<stack>.md` (v0.24+).
+- **Author your own:** a domain-specific scaling discipline (e.g., a `data-vocabulary-loop` for
+  a project where the load-bearing standardization is API field names, not visual style).
+
+## When this loop re-opens
+
+- Tokens file deleted or renamed without code update → exit predicate fails again
+- New UI added in a way that bypasses tokens (raw hex codes proliferate) → arguably should
+  re-open; today's predicate doesn't catch this (it just checks for *some* token consumption).
+  The v0.22 design-drift-loop will catch this case.
+- Stack migration (e.g., Mantine → Tailwind) → exit predicate may transiently fail; re-init
+  in the new stack

package/stages/L1-mvp/template/docs/loops/drift-loop.md

@@ -0,0 +1,149 @@
+---
+id: drift-loop
+type: loop
+stage: L1-mvp
+runner_type: hook
+attributed_to: [Ajesh Shah (PRINCIPLES — "build faster without fooling themselves")]
+also_relevant: [Eric Ries (validated learning), Ash Maurya (riskiest assumption first), Rob Fitzpatrick (talk to someone before you build)]
+entry:
+  - any_file_matches:
+      path_glob: docs/ideas/*-canvas.md
+      pattern: 'Riskiest assumption:\*\*\s+[^_].*[a-zA-Z0-9]{3,}'
+      related_idea_not_matching: '^status:\s+dropped'
+  - count_at_least:
+      path_glob: docs/devlog.md
+      pattern: '^## \d{4}-\d{2}-\d{2}'
+      min: 3
+exit:
+  - any_file_matches:
+      path_glob: docs/ideas/*-canvas.md
+      pattern: 'Experiment this week:\*\*\s+[^_].*[a-zA-Z0-9]{3,}'
+      related_idea_not_matching: '^status:\s+dropped'
+drift_moment: drift
+---
+
+# Loop: drift (MVP) — the work vs. the named risk
+
+> *"BOSS helps founders build faster without fooling themselves — compressing the loop from idea
+> to evidence while continuously checking the work against real pain, real workflows, real buyers,
+> real economics, and real distribution."* — PRINCIPLES.md, the why.
+
+This is the closest loop to the reason BOSS exists. The other moments catch *structural* gaps —
+no canvas, no budget, no failure-states. This one catches the gap PRINCIPLES.md names first and
+that no predicate can fully see: **you named the bet that could sink this, and then you spent your
+sessions building something else.**
+
+It fires in the gap *between* moment #1 (`caution` — no riskiest assumption named yet) and the
+graduation moment (`done` — the riskiest assumption has a validation plan). Caution covers "you
+haven't named the risk." This covers "you named it, you've been building for a few sessions, and
+nothing you've built tests it."
+
+## The judgment the predicate can't do (and the model can)
+
+The predicate gate is deliberately cheap and structural: *a riskiest assumption is filled in, work
+has accumulated (≥3 devlog entries), and no "Experiment this week" validation plan exists yet.*
+That's all regex can prove. It cannot read the five recent devlog entries and tell whether the work
+is **about** the named risk or **around** it. That semantic comparison — stated bet vs. actual
+work — is the model's job, and it's the whole value of this moment.
+
+So the loop **opens the door**; the model walks through it with judgment. When the door is open,
+the conscience hands the model a bounded instruction (read the riskiest-assumption line + the most
+recent ~5 devlog entries + the open FEAT/spec, nothing wider) and asks it to judge: is this work
+testing the risk, or building past it? If drifted, name the specific gap — *"you said X is the bet
+that could sink this; the last sessions built Y and Z; neither tests X"* — and ask what the smallest
+experiment on the risk would be. If the work **is** engaging the risk, stay silent. Silence is the
+correct output when the founder is on-aim.
+
+This is the same shape as `extraction-loop` / `/extract`: a cheap heuristic gate fronting a model
+judgment the regex can't make. The difference is host-binding — `/extract` is a skill the founder
+invokes; this fires *unprompted* through the hook, because a founder who has drifted from their own
+stated bet is precisely the founder who won't think to ask whether they've drifted.
+
+## Entry artifact
+
+Two predicates, both required:
+
+1. **A named risk** — at least one active (non-dropped) idea's canvas has a real riskiest-assumption
+   line (same predicate `canvas-loop` uses for its exit; the `[^_]` rejects `_(placeholder)_` fills).
+2. **Accumulated work** — `docs/devlog.md` has ≥3 dated entries (`^## YYYY-MM-DD`). Same threshold
+   and surface as `extraction-loop`: three sessions in is the inflection where "still building the
+   first thing" becomes "have I been building toward the bet?"
+
+Confidence scales with devlog overshoot (the runtime reads the count predicate): 3 entries → low,
+4–5 → medium, 6+ → high. More sessions deep without a validation plan = a louder signal.
+
+## Purpose
+
+Keep the work pointed at the riskiest assumption. The failure mode this prevents is the one
+PRINCIPLES.md opens with: a *pseudo app* — an impressive, polished build that never tested the
+thing most likely to kill it. AI makes that failure cheaper and more convincing every model
+generation; this loop is the counter-pressure.
+
+## Exit artifact
+
+The canvas's **Experiment this week** line is filled with a real validation plan (not the
+`_(the smallest test…)_` placeholder) — the same artifact the `done` graduation moment looks for.
+Recording how you'll test the risk closes the loop. The good outcome of a drift nudge is the
+founder writing (or running) that experiment.
+
+## Drift
+
+`entry: satisfied` (risk named AND ≥3 devlog entries) AND `exit: not satisfied` (no validation
+plan recorded) = loop is OPEN → conscience emits the `drift` moment.
+
+The model composes the voice (per `boss-voice`: seasoned hand, assume intelligence, never assume
+knowledge), reads only the bounded set named above, and judges before speaking. **Not** a
+"you've been productive!" reward and **not** a generic "you should validate" lecture — the value
+is the *specific* stated-vs-actual comparison. Cohort-aware: returning-founder gets the harder
+"is your conviction here where it needs to be for 12 months" cut; first-product gets "here's what
+'test your riskiest bet' actually means" taught plainly; domain-expert gets the who-could-be-harmed
+lens on the named risk.
+
+## Cost (BOSS eating its own dogfood)
+
+This moment reads more context than the cheap predicate moments, so it has to respect the same
+discipline `/ai-cost` preaches or BOSS becomes the expensive-AI-app it warns against:
+
+- The **predicate gate is the cost control.** The model only reads wider context when the cheap
+  Node predicate has already confirmed the precondition. On every other prompt the hook emits
+  nothing.
+- The read is **bounded** — riskiest-assumption line + ~5 recent devlog entries + the open FEAT.
+  Never "read the whole project." Bounded inputs are structured-output discipline applied to the
+  input side.
+- The model fires **at most once per session** and stays silent when on-aim.
+
+## How to remix
+
+- **Skip / override:** legitimate when the founder is *deliberately* de-risking in a different
+  order (e.g. building a thin slice first specifically to make the risk testable). Override grammar:
+  ```
+  - **OVERRIDE:** skipped `drift-loop` — rationale: <e.g. building the minimal slice this week
+    precisely so the riskiest-assumption experiment becomes runnable next week; risk is named and
+    sequenced, not forgotten>.
+  ```
+- **Swap discipline:** the "riskiest assumption + one experiment" heartbeat is one framing
+  (Maurya / Ries). A `jobs-to-be-done` validation plan, a `Mom Test` interview plan (Fitzpatrick),
+  or a `pretotype` demand test (Savoia) are all legitimate exits — note the framing in the canvas.
+- **Author your own:** a domain-specific drift loop (e.g. a `compliance-drift-loop` for a regulated
+  product, where the named risk is regulatory and the validation plan is a legal review).
+
+## When this loop re-opens
+
+- The riskiest assumption changes (a new bet is named) without a fresh experiment line.
+- An experiment ran and *disconfirmed* — the founder clears the validation plan to re-aim.
+
+## Known limitation (consistent with `canvas-loop`)
+
+`any_file_matches` is satisfied by *any* canvas, so a single graduated idea (risk + experiment
+both filled) closes the loop even if a second active idea has a named risk and no plan. This is the
+same `any`-semantics limitation `canvas-loop` carries; for the common single-active-idea case it's
+correct, and the model — reading the actual canvases when the loop *is* open — can catch the masked
+case anyway. A per-idea drift check would need cross-file pairing the predicate vocabulary doesn't
+have yet; deferred until there's evidence it matters.
+
+## Cite
+
+PRINCIPLES.md (the why) — *"build faster without fooling themselves… continuously checking the work
+against real pain, real workflows, real buyers."* Ries (validated learning), Maurya (riskiest
+assumption first), Fitzpatrick (talk to someone before you build). The loop is the *when*; the
+model's judgment + `/canvas` / `/pretotype` are the *how*.

package/stages/L1-mvp/template/docs/loops/extraction-loop.md

@@ -0,0 +1,128 @@
+---
+id: extraction-loop
+type: loop
+stage: L1-mvp
+runner_type: hook
+attributed_to: [Ajesh Shah (PRINCIPLE #1 — pause to extract patterns)]
+also_relevant: [Brad Frost (atomic design as extraction), Bret Victor (the principle of the principle), Don Norman (affordances emerge from use)]
+entry:
+  - count_at_least:
+      path_glob: docs/devlog.md
+      pattern: '^## \d{4}-\d{2}-\d{2}'
+      min: 3
+exit:
+  - count_at_least:
+      path_glob: docs/extractions/EXTR-*.md
+      pattern: '^- \*\*Route:\*\*'
+      min: 1
+drift_moment: capture
+---
+
+# Loop: extraction (MVP) — PRINCIPLE #1's own discipline
+
+> *"BOSS is always scaffolding, but scaffolding is the motion, not the goal. At every natural
+> breakpoint — a mode transition, a shipped feature, the third time the same work repeats —
+> **pause and sort the pattern two ways:** UP into BOSS as a reusable superset practice. DOWN
+> into the app as core functionality."* — PRINCIPLE #1.
+
+For 28 releases the conscience has surfaced caution / done / restraint / coherence / cost /
+failure-mode. **PRINCIPLE #1's own discipline had no moment.** Capture-the-reusable was named
+in PRINCIPLES.md but undetected by the system meant to encode the principles. v0.29 closes
+that — not perfectly (predicate-based heuristics can't see *reusability* — only the model can),
+but enough to nudge the founder toward `/extract` at the *breakpoint inflection*.
+
+The loop fires the `capture` moment when a founder has accumulated meaningful work
+(heuristic: ≥3 devlog entries) and hasn't yet recorded an extraction decision (an EXTR-NNN
+file). The skill `/extract` is the actual judgment — it reads recent work and proposes
+specific UP / DOWN routes; the loop just **opens the door** at the inflection.
+
+This is the first hook-runner loop whose entry is *time-of-work* rather than *predicate-of-
+file-state*. The heuristic is intentionally simple (devlog entry count); we lean on the model
+running `/extract` for the real judgment. The pattern sets a precedent for future moments that
+can't be detected by file regex alone.
+
+## Entry artifact
+
+`docs/devlog.md` contains ≥3 dated entries (regex: `^## \d{4}-\d{2}-\d{2}`). Threshold of 3
+mirrors PRINCIPLE #1's *"the third time the same work repeats"* signal. Fewer entries = not
+yet at a natural breakpoint; the founder is still in initial-build motion.
+
+The devlog is the right surface to gate on because the `/log` skill already produces dated
+entries, the `/close` skill nudges devlog discipline at session end, and the format is
+stable. Future versions may add complementary entry signals (`boss unlock` recently fired;
+FEAT-NNN status flipped to `shipped`; library/ recently grew); for v0.29 the devlog-count
+heuristic is enough to mark the inflection.
+
+## Purpose
+
+Surface PRINCIPLE #1 at the right time. Not too early (a founder mid-first-build doesn't have
+extractables yet); not too late (by the time copy-paste duplication is everywhere, extraction
+is a refactor cost, not a discipline). Three devlog entries is the *"you've shipped something,
+now look at what's worth keeping"* inflection.
+
+When the loop opens, the conscience emits a `capture` moment in its own voice: *"You've been
+in flow for a few sessions. Pause-extract time. Run `/extract` — it'll look at recent work and
+propose 1-3 candidates routed UP (into BOSS's library) or DOWN (into the app's core)."* Never
+blocks; the founder decides.
+
+## Exit artifact
+
+≥1 file in `docs/extractions/` matching `EXTR-*.md` with at least one `- **Route:**` line
+recorded. The skill `/extract` writes these. The presence of *any* extraction record closes
+the loop — the discipline IS the practice of pausing-and-routing, not the volume of
+extractions.
+
+To re-open the loop, the founder OR a future BOSS version refreshes the heuristic. v0.29
+ships the **first-inflection** version of this loop. Future versions may add recurring re-
+opening (e.g., 5+ devlog entries since the most recent extraction); for now, once the
+founder has practiced extraction once, the discipline is theirs.
+
+## Drift
+
+Entry satisfied (≥3 devlog entries) AND exit not satisfied (no EXTR-NNN files) → loop is
+open → conscience emits `capture` moment.
+
+Confidence is **medium by default** (the heuristic is broad; not every 3-devlog moment is a
+real breakpoint), but the skill /extract sharpens this at runtime — if /extract reads recent
+work and finds nothing extractable, it records that fact (`- **Route:** none-yet — nothing
+loadbearing-enough; check again in N entries`) and the loop closes. So the loop opens broadly,
+the judgment narrows.
+
+The voice (cohort-aware via v0.20's framing): name the inflection in one line, point at
+`/extract`, hand the decision back. Particularly important to **NOT** sound like a "you've
+been productive!" reward — that's the performative-warmth failure mode the voice work has
+been catching. Plain seasoned-hand: *"three sessions in — worth pausing to see what's worth
+keeping?"*
+
+## How to remix
+
+- **Skip:** legitimate when the founder is in pure-exploration mode and hasn't shipped
+  anything yet (the devlog entries are all *"tried X, didn't work"* — no extractables).
+  Override:
+  ```
+  - **OVERRIDE:** skipped `extraction-loop` — rationale: <e.g., devlog entries are all
+    exploration / dead-end notes; nothing has stuck enough to be extractable yet; revisit
+    after first shipped FEAT>.
+  ```
+- **Swap discipline:** Frost atomic-design lens (extract atoms → molecules → organisms) vs.
+  Ajesh's UP/DOWN router (extract to BOSS library OR to app core) vs. a stack-native pattern
+  (e.g., Ruby on Rails *"extract a concern"*). The loop's exit predicate checks for *any*
+  extraction record, not a specific framing.
+- **Author your own:** project-specific extraction discipline (e.g., a `prompt-extraction-
+  loop` for projects where the load-bearing reusable artifact is prompts, not code; or a
+  `schema-extraction-loop` for projects where structured-output schemas keep multiplying).
+
+## When this loop re-opens (today: not automatic)
+
+v0.29 ships the first-inflection version. The loop closes after one extraction record and
+stays closed. To re-open, the founder deletes/archives old extractions OR a future BOSS
+extends the predicate vocabulary with time-aware checks (*"N devlog entries since last
+extraction"*). The skill `/extract` is re-runnable anytime; the conscience just doesn't auto-
+nudge after the first time.
+
+## Cite
+
+PRINCIPLE #1 — the rule this loop encodes, finally. *"Pause to extract patterns. UP into BOSS
+as a reusable superset practice. DOWN into the app as core functionality. `/boss-learn` is
+therefore a two-destination router."* The loop is the *when*; `/extract` (and `/boss-learn`)
+are the *how*.

package/stages/L1-mvp/template/docs/loops/focus-loop.md

@@ -0,0 +1,106 @@
+---
+id: focus-loop
+type: loop
+stage: L1-mvp
+runner_type: hook
+attributed_to: [Ajesh Shah (PRINCIPLES — "compress the loop from idea to evidence")]
+also_relevant: [David J. Anderson (Kanban — limit work-in-progress), Jim Benson (Personal Kanban — "stop starting, start finishing"), Eric Ries (validated learning over motion)]
+entry:
+  - count_at_least:
+      path_glob: docs/ideas/FEAT-*.md
+      pattern: '^status:\s*(building|drafting|blocked)'
+      min: 4
+exit:
+  - count_at_least:
+      path_glob: docs/ideas/FEAT-*.md
+      pattern: '^status:\s*(shipped|done)'
+      min: 1
+drift_moment: focus
+---
+
+# Loop: focus (MVP) — the board's own drift signal
+
+The board (`boss board`) already projects the work. This loop reads the *shape* of that projection
+for the oldest startup failure there is: **a pile of things started, nothing finished.** Four or more
+FEATs sitting in Building and not one shipped is not productivity — it's motion. AI makes starting the
+next thing nearly free, so "stop starting, start finishing" (Benson) is exactly the discipline that
+erodes first.
+
+This is the board → conscience bridge (IDEA-034 Track D). The other MVP moments catch *structural*
+gaps (no budget, no failure-states, a named risk left untested). This one catches a *flow* problem the
+columns make visible: WIP accumulating with no graduation.
+
+## The judgment the predicate can't do (and the model can)
+
+The predicate gate is deliberately coarse: *≥4 FEATs are in flight and none has shipped.* Regex can
+count columns; it cannot tell whether those four are **scattered abandonment** (each started, then
+dropped for the next shiny thing — the real focus problem) or **four genuinely parallel tracks** a
+small team is legitimately carrying. That call is the model's, and it's the whole value of the moment.
+
+So the loop opens the door; the model walks through with judgment. When the door is open, the
+conscience hands the model a bounded instruction — read the board projection (`boss board`, or the
+in-flight FEATs' status + `building_since`), nothing wider — and asks: is this a founder spreading
+themselves thin, or honest parallel work? If it's the former, name the specific pile in one spare line
+and ask which *one* they'd finish first. If it's honest parallel work, stay silent. Silence is the
+correct output when the founder is actually shipping-minded.
+
+Same shape as `drift-loop` / `caution-loop`: a cheap structural gate fronting a judgment the regex
+can't make, fired *unprompted* through the hook — because a founder buried in WIP is precisely the one
+who won't stop to ask whether they've over-committed.
+
+## Entry artifact
+
+**Work-in-progress overload** — `docs/ideas/FEAT-*.md` has ≥4 files whose `status` is `building`,
+`drafting`, or `blocked` (the board's "Building" column). Four is the threshold where the V1 `/board`
+skill says cross-FEAT sequencing starts to matter; below it, the pile isn't yet a smell.
+
+Confidence scales with overshoot (the runtime reads the count): 4 in flight → low, ~5–7 → medium,
+8+ → high. The deeper the unfinished pile, the louder the signal.
+
+## Exit artifact
+
+**At least one shipped FEAT** (`status: shipped` or `done`). Shipping anything closes the loop — the
+founder has proven they can finish, and the never-graduated-pile smell no longer applies. The good
+outcome of a focus nudge is a FEAT crossing into Shipped.
+
+## Drift
+
+`entry: satisfied` (≥4 in flight) AND `exit: not satisfied` (nothing shipped yet) = loop OPEN →
+conscience emits the `focus` moment. The model composes the voice (per `boss-voice`: seasoned hand,
+assume intelligence), reads only the board, and judges before speaking — **not** a "you're so busy!"
+reward and **not** a generic "limit your WIP" lecture; the value is the specific *which one would you
+finish first* cut. Cohort-aware: returning-founder gets the blunt "you've started five things and
+shipped none — which one is real?"; first-product gets "finishing one beats starting three, here's
+why" taught plainly; indie-hacker gets the calm "small and done beats big and open" frame.
+
+## Cost (BOSS eating its own dogfood)
+
+- The **predicate gate is the cost control** — the model reads the board only after the cheap Node
+  count confirms the pile. Every other prompt the hook emits nothing.
+- The read is **bounded** — the board projection / in-flight FEAT statuses, never the whole project.
+- The model fires **at most once per session** and stays silent when the parallelism is honest.
+
+## Known limitation (documented, like drift-loop's)
+
+Exit is "≥1 shipped *ever*," so the moment targets the never-finished pile and goes quiet after the
+first ship — even if a large WIP pile rebuilds later. A "shipped *recently*" semantic would need a
+date-windowed count the predicate vocabulary doesn't have yet (the same gap `building_since` aging
+fills on the board side). Deferred until there's evidence the rebuilt-pile case matters; the board's
+own aging flag (`⌛ Nw in build`) already surfaces the stuck items visually in the meantime.
+
+## How to remix
+
+- **Skip / override:** legitimate when the four-in-flight is real parallel work (e.g. a designer, a
+  backend track, and an AI-eval track genuinely running at once). Override grammar:
+  ```
+  - **OVERRIDE:** skipped `focus-loop` — rationale: <e.g. three of these are blocked-on-review, not
+    abandoned; the one active build ships this week>.
+  ```
+- **Tune the threshold:** a solo founder might set `min: 3`; a small team carrying real parallel
+  tracks might set `min: 6`. The threshold is the team's honest WIP limit, not a universal number.
+
+## Cite
+
+PRINCIPLES.md (compress idea→evidence). Benson (*Personal Kanban* — stop starting, start finishing),
+Anderson (Kanban WIP limits), Ries (validated learning over motion). The loop is the *when*; the
+model's judgment + `boss board` + `/close` (ship one) are the *how*.

package/stages/L1-mvp/template/docs/loops/pretotype-loop.md

@@ -0,0 +1,88 @@
+---
+id: pretotype-loop
+type: loop
+stage: L1-mvp
+runner_type: skill
+attributed_to: [Alberto Savoia, Ash Maurya]
+also_relevant: [Eric Ries, Rob Fitzpatrick]
+entry:
+  - any_file_matches:
+      path_glob: docs/ideas/*-canvas.md
+      pattern: 'Riskiest assumption:\*\*\s+[^_].*[a-zA-Z0-9]{3,}'
+      related_idea_not_matching: '^status:\s+dropped'
+exit:
+  - count_at_least:
+      path_glob: docs/ideas/IDEA-*.md
+      pattern: '^## Pretotype log'
+      min: 1
+---
+
+# Loop: pretotype (MVP)
+
+The discipline that gates *build* on *demand-test*. Encodes Savoia's *"make sure you're building
+the right It, before you build It right."*
+
+`runner_type: skill` — the `/pretotype` skill is the detector + runner. The loop's purpose is
+*recording* the discipline as a project-level artifact + giving spec-loop a clean dependency to
+declare ("pretotype should have happened before spec," when the project wants to be that strict).
+
+This loop is **structural by default** — no `drift_moment` declared. The conscience doesn't nag
+about un-pretotyped ideas at every prompt; that's exactly the over-fires-on-fresh-project failure
+mode the v0.16 evals catch. Instead, the pretotype is *invited* by `/canvas`'s graduation moment
+("Done!") and by the founder's own initiative via `/pretotype`. The loop tracks that it happened.
+
+(Future v0.22+: a project could optionally add `drift_moment: caution` to this loop spec if they
+want the conscience to nudge on un-pretotyped ideas accumulating. JIT principle: don't make this
+the default ceremony.)
+
+## Entry artifact
+
+Canvas-loop has closed (a real riskiest assumption exists). Same entry as spec-loop — both are
+downstream of canvas-loop. Difference: spec-loop produces a FEAT; pretotype-loop produces *demand
+evidence about the FEAT before it's built.* The discipline of *running the pretotype between
+the canvas and the spec* is what this loop encourages.
+
+## Purpose
+
+Test demand for the bet via a fake-door / wizard-of-oz / Mechanical-Turk / Pinocchio / YouTube
+test / impresario pattern. Record what was tested, the threshold, the result, and the persevere/
+pivot/kill decision. YODA — Your Own Data > Anything (Savoia).
+
+The `/pretotype` skill is the runner.
+
+## Exit artifact
+
+The active idea's file (`docs/ideas/IDEA-NNN.md`) contains a `## Pretotype log` section with
+at least one dated entry recording: pattern, what was tested, threshold (set BEFORE running),
+result, decision. The `count_at_least` exit predicate looks for this section across all idea
+files.
+
+## How to remix
+
+- **Skip:** legitimate when the founder has external validation already (e.g., a customer
+  pre-paid; an existing audience said yes; a similar product validated in the past). Record:
+  ```
+  - **OVERRIDE:** skipped `pretotype-loop` for IDEA-NNN — rationale: <external
+    validation cited; what would re-open the loop if the validation turns out
+    weaker than thought>.
+  ```
+- **Swap discipline:** Savoia-pretotype vs. Ries-MVP-experiment vs. Maurya-riskiest-assumption-
+  test vs. Fitzpatrick-Mom-Test-conversation. Same loop shape; different practice. Note the
+  swap in the idea's pretotype log: `Pattern: mom-test (instead of pretotype)` + the Fitzpatrick
+  rationale.
+- **Author your own:** a domain-specific demand test (e.g., regulatory-precedent-check for a
+  legal-tech product). The shape stays: tangible/real-time/imminent metric, threshold-before-
+  running, decision-after.
+
+## When this loop re-opens
+
+- The active idea pivoted significantly (riskiest assumption changed) → re-pretotype
+- A previous pretotype result was ambiguous → re-design with a sharper test
+- An external signal contradicts the original pretotype result → re-pretotype
+
+## Cross-loop note
+
+Pretotype-loop and spec-loop are *parallel*, not strictly sequential. Both depend on canvas-loop.
+A project could pretotype-then-spec (the "test demand first" lineage) OR spec-then-pretotype
+(less common; sometimes you need the spec to *describe* what you're pretotyping). The discipline
+doesn't force order; just records that both happened before significant code lands.

package/stages/L1-mvp/template/docs/loops/spec-loop.md

@@ -0,0 +1,83 @@
+---
+id: spec-loop
+type: loop
+stage: L1-mvp
+runner_type: skill
+attributed_to: [Eric Ries, Marty Cagan]
+also_relevant: [Ash Maurya, Hamel Husain, Jason Liu]
+entry:
+  - any_file_matches:
+      path_glob: docs/ideas/*-canvas.md
+      pattern: 'Riskiest assumption:\*\*\s+[^_].*[a-zA-Z0-9]{3,}'
+      related_idea_not_matching: '^status:\s+dropped'
+exit:
+  - count_at_least:
+      path_glob: docs/ideas/FEAT-*.md
+      pattern: '^# '
+      min: 1
+drift_moment: restraint
+---
+
+# Loop: spec (MVP)
+
+The discipline that gates spec writing on canvas validation. Encodes **moment #4 — restraint
+(premature ceremony)** from IDEA-008's collapsed-moments architecture: when the founder reaches
+for `/spec` without canvas-loop having closed, the conscience surfaces a restraint nudge — name
+what's missing, offer to back up, hand the decision back. Never block.
+
+`runner_type: skill` because `/spec` itself is the detector (reads canvas-loop state at run time
+and surfaces restraint). The hook doesn't auto-fire restraint nudges on every prompt — that would
+nag any time the founder was in MVP mode with an unfinished canvas. The skill detection is
+cleaner: it fires *when the founder is attempting the downstream loop.*
+
+## Entry artifact
+
+Canvas-loop has closed for *some* active idea — i.e., at least one canvas exists with a real
+filled riskiest-assumption line, attached to a non-dropped idea. This is the literal Quickstart
+canvas-loop's exit predicate, reused as spec-loop's entry.
+
+## Purpose
+
+Turn validated ideas into buildable features. The FEAT spec captures: goal, acceptance criteria,
+smoke check, validated learning (Ries — v0.21.0+), evals (Husain — if AI-mediated), out-of-scope.
+A clean handoff to `coder-generalist`.
+
+## Exit artifact
+
+`docs/ideas/FEAT-NNN-<slug>.md` exists with all required sections. (The exit predicate is loose
+today — `any_file_matches` on `FEAT-*.md` — but the skill's expectation is the full template.
+Future tighter predicate could check for the validated-learning + smoke-check sections being
+filled.)
+
+## Drift
+
+`entry: not satisfied` (no canvas exists with a real riskiest assumption) AND `/spec is being
+invoked` → moment #4 restraint fires from the skill. The skill reads:
+- The cohort declaration in `.boss/config.json` (for cohort-aware voice composition)
+- The canvas-loop state for the active idea
+- Surfaces a Fitzpatrick-plain nudge: *"There's no canvas yet for this idea — want to pressure-
+  test it first? `/canvas IDEA-NNN`. Or, if you've thought it through deeply already, you can
+  proceed with the spec and record the override in the devlog."*
+
+## How to remix
+
+- **Skip:** legitimate — sometimes you've done the validation outside of `/canvas`. Override
+  grammar:
+  ```
+  - **OVERRIDE:** proceeded `spec-loop` without `canvas-loop` exit — rationale:
+    canvas-equivalent thinking done in <where>; riskiest assumption is <X>;
+    test plan is <Y>.
+  ```
+  The override is the contract; the conscience respects it.
+- **Swap discipline:** Maurya-style explicit canvas vs. Cagan-style "discovery-then-delivery"
+  vs. Christensen-JTBD framing. Same loop entry shape (some pressure-test artifact exists);
+  different practice inside.
+- **Author your own:** a domain-specific validation loop (e.g., a regulatory-canvas-loop for a
+  medical product) that satisfies spec-loop's entry differently. Author the loop spec.
+
+## When this loop re-opens
+
+- A new IDEA gets a canvas → spec-loop is openable for that idea
+- An existing FEAT is revised significantly → re-enter spec-loop for the new shape
+- Validated-learning section fails its experiment (Ries pivot) → re-open the canvas-loop
+  upstream first, then re-spec

package/stages/L2-v1/manifest.json

@@ -0,0 +1,12 @@
+{
+  "id": "L2-v1",
+  "name": "V1",
+  "summary": "Ready for a real, shippable v1. The design layer turns on (PRINCIPLES.md #3): three-layer design tokens enforced via design-drift-loop, ui-designer + ux-designer as visual+flow authorities, db-architect for real data shape. /board for cross-FEAT sequencing, /design-review before code, /ux-check after. Plus the next tier of mentors: business (model + pricing), fundraising (whether/when/how), pitch (story + deck), talent (first hires + cadence) — promoted from BOSS-local in v0.15.0 to scaffolded-project templates here.",
+  "requires": "L1-mvp",
+  "agents": ["ui-designer", "ux-designer", "db-architect", "mentor-business", "mentor-fundraising", "mentor-pitch", "mentor-talent"],
+  "skills": ["board", "design-review", "ux-check"],
+  "hooks": [],
+  "loops": ["design-drift-loop"],
+  "unlocksNext": "L3-scale",
+  "graduationHint": "When the team grows, the org gets real, and the product council needs to be a thing — boss unlock scale."
+}