@golden-frijoles/kit 0.27.2 → 0.28.0

package/dist/build-order.mjs

@@ -58,12 +58,7 @@ function line(r) {
   if (r.sprint_progress) meta.push(r.sprint_progress);
   if (r.risk) meta.push(`risk: ${r.risk}`);
   if (r.appetite) meta.push(`appetite ${r.appetite}`);
-  // A queued seed without an underwriter is funded-but-unowned — advisory, loud on the board.
-  const warn =
-    r.grain === 'Seed' && r.status === 'Queued' && !r.underwritten_by
-      ? ' — ⚠️ no underwriter (set `underwritten_by:` at the betting table)'
-      : '';
-  return `- [${r.name}](${link}) — ${meta.join(' · ')} · _${r.stage_source}_${warn}`;
+  return `- [${r.name}](${link}) — ${meta.join(' · ')} · _${r.stage_source}_`;
 }
 
 function render(rows) {
@@ -130,6 +125,24 @@ if (unfunded.length) {
   process.exit(1);
 }
 
+// Scaffolded ⇒ funded (fund-at-approval D8). A live bet — an epic scaffolded or in progress, or a queued seed — must
+// name the cycle that paid for it, and that cycle must be a file in Roadmap/bets/. `groom` funds a bet at its approval
+// gate (`fund.mjs`), in the same commit as the scaffold, so this only fails on work that skipped the gate.
+const BETS = join(REPO, 'Roadmap', 'bets');
+const cycleOf = (v) => String(v).replace(/^Roadmap\/bets\//, '').replace(/\.md$/, '');
+const liveBets = rows.filter(
+  (r) => (r.grain === 'Epic' && ['Scaffolded', 'In progress'].includes(r.status)) || (r.grain === 'Seed' && r.status === 'Queued')
+);
+// A cycle name is kebab-case: anything else (a `/`, a `..`) names no cycle file and is never turned into a path.
+const paidBy = (r) => r.underwritten_by && /^[a-z0-9][a-z0-9-]*$/.test(cycleOf(r.underwritten_by)) && existsSync(join(BETS, `${cycleOf(r.underwritten_by)}.md`));
+const unpaid = liveBets.filter((r) => !paidBy(r));
+if (unpaid.length) {
+  console.error('Live bets with no funding record (`underwritten_by:` must name a Roadmap/bets/<cycle>.md):');
+  for (const r of unpaid) console.error(`  - ${r.doc_link}${r.underwritten_by ? ` — no Roadmap/bets/${cycleOf(r.underwritten_by)}.md` : ''}`);
+  console.error('Fund it at the approval gate: node "$GROOM/fund.mjs" --slug <slug> --displaced "<…>" --next | --after <slug>');
+  process.exit(1);
+}
+
 const content = render(rows);
 
 if (LIVE) {

package/dist/lib/epic-kickoff.mjs

@@ -145,7 +145,7 @@ const FLAG_RE = /\b[a-z][a-z0-9_]*\.[a-z0-9_]+_enabled\b|\bgf flags (?:create|se
 const NEGATED_RE =
   /\b(?:no|without|zero|not an?|nor an?)\s+(?:new\s+)?(?:db\s+|database\s+|schema\s+)?migrations?\b/gi;
 
-export function buildEpicRules({ risk, texts }) {
+export function buildEpicRules({ risk, texts, appetite = null, slug = '<slug>' }) {
   const all = texts.join('\n').replace(NEGATED_RE, '');
   const rules = [];
   if (String(risk).toUpperCase() === 'HIGH')
@@ -160,12 +160,19 @@ export function buildEpicRules({ risk, texts }) {
     rules.push(
       '- **Flag:** create it in Golden Frijoles in every env and ACTIVATE it; `gf flags get <key>` must show production.'
     );
+  // fund-at-approval D7 — an L bet is funded one wave at a time; the re-bet is one line, asked where the builder stops.
+  if (String(appetite).toUpperCase() === 'L')
+    rules.push(
+      `- **L bet:** it is funded one wave at a time. When you stop at a wave boundary, ask the product owner one line — ` +
+        `"fund the next wave of \`${slug}\`? what does it displace?" — and on yes run groom's ` +
+        `\`fund.mjs --slug ${slug} --displaced "<…>"\` (position kept) before the next wave starts.`
+    );
   return rules.length ? `\nFor this epic:\n${rules.join('\n')}\n` : '';
 }
 
-export function buildEpicKickoff({ macro, slug, epicTitle, risk, sprints, templateText, texts = [] }) {
+export function buildEpicKickoff({ macro, slug, epicTitle, risk, sprints, templateText, texts = [], appetite = null }) {
   return sub(templateText, {
-    EPIC_RULES: buildEpicRules({ risk, texts }),
+    EPIC_RULES: buildEpicRules({ risk, texts, appetite, slug }),
     MACRO: macro,
     SLUG: slug,
     EPIC_TITLE: epicTitle,
@@ -176,6 +183,28 @@ export function buildEpicKickoff({ macro, slug, epicTitle, risk, sprints, templa
   });
 }
 
+// `appetite:` from a doc's frontmatter (the README's own first, else its seed's — finops D20), or null.
+export function parseAppetite(text) {
+  const fm = /^---\n([\s\S]*?)\n---/.exec(text ?? '')?.[1] ?? '';
+  return /^appetite:\s*"?([SML])"?\s*(?:#.*)?$/m.exec(fm)?.[1] ?? null;
+}
+
+// The epic's seed: the one whose `epic:` names `<macro>/<slug>` (as the extractor matches it — a seed's slug may differ
+// from its epic's), else `seeds/<slug>.md`; '' when there is none.
+function readSeed(read, list, dir, macro, slug) {
+  const seeds = join(dir, '..', '..', '00-ideas', 'seeds');
+  const pointer = new RegExp(`^epic:\\s*"?${macro}/${slug}"?\\s*(?:#.*)?$`, 'm');
+  try {
+    for (const name of list(seeds).filter((n) => String(n).endsWith('.md'))) {
+      const text = read(join(seeds, String(name)));
+      if (pointer.test(/^---\n([\s\S]*?)\n---/.exec(text)?.[1] ?? '')) return text;
+    }
+    return read(join(seeds, `${slug}.md`));
+  } catch {
+    return '';
+  }
+}
+
 // The epic README header line carries `**Risk:** <low|high>`; the frontmatter doesn't. Falls back to
 // 'high' — the WAYS-OF-WORKING rule is "when unsure, treat it as high", and a kickoff that under-declares
 // risk is the one that skips the mandatory fresh-reviewer pass.
@@ -261,6 +290,7 @@ export function epicKickoffFromDir({
       sprints,
       templateText: EPIC_KICKOFF_TEMPLATE,
       texts: [readmeText, ...sprints.map((s) => s.text)],
+      appetite: parseAppetite(readmeText) ?? parseAppetite(readSeed(read, list, dir, macro, slug)),
     }),
   };
 }

package/dist/lib/kickoff-cli.mjs

@@ -67,6 +67,14 @@ export function findEpicDir(repoRoot, slug, { exists = existsSync, list = readdi
   }
   const hits = macros.filter((m) => exists(join(roadmapDir, m, slug, 'README.md')));
   if (hits.length === 0) {
+    // A seed with no epic yet (dogfood F33): say what it is and the one command that makes it buildable.
+    if (exists(join(roadmapDir, '00-ideas', 'seeds', `${slug}.md`))) {
+      return {
+        error:
+          `"${slug}" is a seed with no epic yet — a kickoff builds an epic. Fund it at the approval gate, then scaffold it ` +
+          `(a fixed-scope seed needs nothing but its slug): node "$GROOM/scaffold-epic.mjs" --slug ${slug}`,
+      };
+    }
     return { error: `no epic found for slug "${slug}" under any Roadmap/*/ dir in "${repoRoot}" (searched: ${macros.join(', ') || '(none)'})` };
   }
   if (hits.length > 1) {

package/dist/roadmap-extract.mjs

@@ -101,13 +101,6 @@ const SEED_STATUS_LABEL = {
   shipped: 'Shipped',
   archived: 'Archived',
 };
-const PRIORITY_LABEL = {
-  'wave-0': 'Wave 0 Enablers',
-  'wave-1': 'Wave 1',
-  'wave-2': 'Wave 2',
-  'wave-3': 'Wave 3',
-  'wave-4': 'Wave 4',
-};
 const TYPE_LABEL = { feature: 'Feature', spike: 'Spike', chore: 'Chore', bug: 'Bug', epic: 'Epic' };
 
 /**
@@ -523,7 +516,6 @@ export function buildRows({
     const totStories = boardSprints.reduce((a, s) => a + s.total, 0);
     const doneStories = boardSprints.reduce((a, s) => a + s.done, 0);
     const area = AREA_NAMES[e.area] || e.area;
-    const priority = seed.priority ? PRIORITY_LABEL[seed.priority] || seed.priority : null;
     const riskWord = epicFm.risk || seed.risk;
     const risk = riskWord ? (riskWord === 'high' ? 'High' : 'Low') : null;
     const readmePath = `Roadmap/${epicKey}/README.md`;
@@ -561,12 +553,12 @@ export function buildRows({
       stage,
       stage_source: stageSource,
       area,
-      priority,
       type: TYPE_LABEL[epicFm.type || seed.type] || 'Epic',
       risk,
       // finops D20 — the README's own appetite first (an epic groomed after FinOps carries it), else the seed's.
       appetite: epicFm.appetite || seed.appetite || null,
-      underwritten_by: seed.underwritten_by || null,
+      // fund-at-approval D8 — the README's own first (an epic with no seed carries it there), else the seed's.
+      underwritten_by: epicFm.underwritten_by || seed.underwritten_by || null,
       sprint_progress: totStories ? `${doneStories}/${totStories} stories` : `${sprints.length} sprints`,
       build_order: buildOrder,
       build_order_num: buildOrderNum(buildOrder),
@@ -598,7 +590,6 @@ export function buildRows({
         status: sp.status,
         status_date: when(`Roadmap/${epicKey}/sprint-${sp.n}.md`, '^(\\*\\*)?Status:'),
         area,
-        priority,
         type: 'Sprint',
         risk,
         sprint_progress: sp.total ? `${sp.done}/${sp.total} stories` : '—',
@@ -625,7 +616,6 @@ export function buildRows({
       stage,
       stage_source: stageSource,
       area: AREA_NAMES[s.area] || s.area || null,
-      priority: s.priority ? PRIORITY_LABEL[s.priority] || s.priority : null,
       type: TYPE_LABEL[s.type] || 'Feature',
       risk: s.risk ? (s.risk === 'high' ? 'High' : 'Low') : null,
       appetite: s.appetite || null,

package/dist/skeleton/Roadmap/00-ideas/README.md

@@ -22,12 +22,11 @@ slug: example-feature-idea          # kebab; matches the filename
 status: raw                          # raw | ready | queued | scaffolded | in-progress | shipped | archived
 area: "01"                           # macro-section number, matching Roadmap/README.md's table
 type: feature                        # feature | spike | chore | epic
-priority: null                       # a wave/priority label, or null
 appetite: null                       # S | M | L — the budget, set at shaping; REQUIRED before `queued`
-underwritten_by: null                # wave that pays for this (a Roadmap/bets/<wave>.md), or null
+underwritten_by: null                # the cycle that PAID for it (Roadmap/bets/<cycle>.md, bare name) — fund.mjs
 risk: low                            # low | high
 epic: null                           # path to the scaffolded epic, or null until scaffolded
-build_order: null                    # BUILD-ORDER id, or null
+build_order: null                    # integer position in the one global sequence — fund.mjs places it
 updated: <date>
 ---
 ```
@@ -64,10 +63,11 @@ One field is authoritative at each stage — they never both drive the board:
 
 `appetite` (S | M | L) is the **budget the idea is worth**, fixed at shaping *before* the solution
 is designed — sessions + an implied token band, never a time estimate (see WAYS-OF-WORKING →
-*Betting & appetite*). `underwritten_by` names the **wave that pays for it** (a
-`Roadmap/bets/<wave>.md` file), set at the betting table. `null` means nobody has paid for it yet —
-fine in the funnel, impossible on the board: `build-order.mjs` **hard-fails** a `queued` seed with
-no `appetite`, and flags a missing `underwritten_by` as drift. Like `status`, `appetite` is an
+*Betting & appetite*). `underwritten_by` names the **cycle that paid for it** — the bare name of a
+`Roadmap/bets/<cycle>.md` file (`wave-2026-10`), written by `groom`'s `fund.mjs` at the approval gate.
+`null` means nobody has paid for it yet — fine in the funnel, impossible on the board: `build-order.mjs`
+**hard-fails** a `queued` seed with no `appetite`, and a live bet (`queued`, or an epic scaffolded or in
+progress) whose `underwritten_by` is missing or names no cycle file. Like `status`, `appetite` is an
 enforced enum — a present-but-unrecognized value fails the board, it never falls back silently.
 
 ## How seeds flow (no file moves)
@@ -76,10 +76,13 @@ enforced enum — a present-but-unrecognized value fails the board, it never fal
    from a brain-dump).
 2. **Scope** — `groom` fills out the Definition-of-Ready (appetite included) and flips
    `status: ready`.
-3. **Queue** — bet on it at a wave boundary (`appetite:` + `underwritten_by:` set, the wave's
-   `Roadmap/bets/` file records what it displaced); `status: queued`.
-4. **Scaffold** — on approval, `groom` runs its own `scaffold-epic.mjs` (ships inside the `groom`
-   skill, `golden-frijoles` plugin) to create the epic/sprint docs, then sets the seed's `epic:` +
-   `status: scaffolded`. **No file ever moves between folders** — the frontmatter carries the state.
+3. **Fund + scaffold, in one answer** — the approval gate is the betting table. On "approve", `groom`
+   runs its own `fund.mjs` (a row in the month's `Roadmap/bets/wave-YYYY-MM.md`, created on first use,
+   recording what the bet displaced; `underwritten_by:`; a `build_order` placed with `--next` or
+   `--after <slug>`, renumbering only the queue) and then `scaffold-epic.mjs` (the epic/sprint docs; the
+   seed gets `epic:` + `status: scaffolded`), committed together. Both ship inside the `groom` skill,
+   `golden-frijoles` plugin. A fixed-scope seed scaffolds from its slug alone, its acceptance criteria
+   becoming sprint 1's stories. "Approve, don't fund" leaves the seed `ready` and scaffolds nothing.
+   **No file ever moves between folders** — the frontmatter carries the state.
 
 Filenames are kebab-case and match `slug`. Audits live in `audits/`, never in `seeds/`.

package/dist/skeleton/Roadmap/WAYS-OF-WORKING.md

@@ -92,11 +92,15 @@ and session context. Fixed appetite, variable scope.
 | **M** | one wave: an architect session + builder fan-out + review rounds | appetite exhausted → stop, back to shaping |
 | **L** | a multi-wave epic | per-wave: each wave is re-bet at the boundary |
 
-Four rules: **an exhausted bet returns to shaping**, never extends in flight; **nothing reaches
-`status: queued` without an `appetite:` and an `underwritten_by:` wave**; **bets are placed at wave
-boundaries** into `Roadmap/bets/<wave>.md`, three lines each, recording what they displaced; and **uphill
-work stays on the strongest model**. Not every ask earns the betting table — `groom` sorts shaped bets
-from fixed scope (appetite S, straight to a builder) and reactive/ops work. Why it works this way:
+Four rules: **an exhausted bet returns to shaping**, never extends in flight; **the approval gate is the
+betting table** — approving a pitch in `groom` funds it in the same answer (`fund.mjs`: a row in the month's
+cycle file `Roadmap/bets/wave-YYYY-MM.md` recording what it displaced, `underwritten_by:`, and a build
+position), in the same commit as the scaffold, while "approve, don't fund" leaves it `ready` and scaffolds
+nothing; **nothing scaffolded is unfunded** — `build-order.mjs` fails a live bet with no `underwritten_by:`;
+and **uphill work stays on the strongest model**. An L bet is re-bet at each wave boundary with one line
+when its builder stops there ("fund the next wave of `<slug>`? what does it displace?"; yes runs `fund.mjs`
+again, position kept). Fixed scope (appetite S) and reactive/ops work go through the same gate, straight to
+a builder. Why it works this way:
 [`references/shapeup/`](https://github.com/golden-frijoles/skills/blob/main/template/references/shapeup/README.md).
 
 ## Review & merge

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@golden-frijoles/kit",
-  "version": "0.27.2",
+  "version": "0.28.0",
   "description": "The scripts the Golden Frijoles skills run, packaged so they work in any repo: planning, build-order, reporting and verification rails. Zero dependencies.",
   "type": "module",
   "bin": {