shapeup-sdlc 3.18.2 → 4.0.0

package/kernel/init/fit.mjs

@@ -1,199 +0,0 @@
-#!/usr/bin/env node
-// GATE L0.3 — FIT CHECK. Which lane does this change belong in? Decided by measurement.
-//
-// WHY THIS EXISTS (and it is the root cause the other three fixes did not touch).
-//
-// A change of the size "add a `summary` command to a six-file CLI" — one new module plus one
-// dispatcher wiring — run through the full eleven-gate pipeline does not finish. Not once, across
-// repeated attempts: killed at the time cap mid-build; then, with a wall-clock breaker fitted,
-// killed at ship-triage; then producing an honest report saying its two must-haves were 0%
-// started.
-//
-// Every one of those fixes made the FAILURE better. None of them made the RUN finish, because
-// none addressed why a three-file change was consuming half an hour: **the ceremony was not
-// sized to the change.**
-//
-// The harness already knew. In those transcripts tech-lead identified the change at GATE L0 as
-// "about as small as they come… squarely inside the --tiny lane" — and then ran the full pipeline
-// anyway, because the lane was a judgment the model was free to talk itself out of. That is the
-// same class of defect as narration and as prose consent: an invariant living somewhere a model
-// can re-decide it. The project's rule is that such invariants move into the runtime.
-//
-// So the lane stops being a recommendation and becomes a computed value, recorded in the receipt
-// alongside the evidence for it. A PO can still override — with `--lane`, which is recorded AS an
-// override, so "we ran the heavy lane on a two-file change" is visible rather than accidental.
-//
-// WHAT IT MEASURES. Only things that are true before any work starts:
-//   • the size of the tree being changed (a 6-file CLI is not a monorepo)
-//   • how many distinct deliverables the intake asks for
-//   • whether the intake introduces a new dependency, datastore, or external seam
-//   • whether the intake itself signals breadth ("migration", "across", "end to end")
-//
-// It is deliberately CONSERVATIVE: `full` is the default and `tiny` must be earned. A wrong
-// `tiny` skips review on something that needed it; a wrong `full` only costs money. Those are not
-// symmetric, and the tie goes to the gates.
-//
-// USAGE
-//   node `harness init fit` --intake-file <path> [--cwd <root>] [--json]
-//   node `harness init fit` --intake-text "<requirement>" [--cwd <root>]
-//
-// Exit 0 always — this informs a decision, it does not deny a tool call. The orchestrator reads
-// `lane` and acts on it; ``harness init run`` records it in the receipt.
-
-import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { LOCAL } from "../lib/paths.mjs";
-import { runArgs } from "../lib/argv.mjs";
-
-/** Directories that are never part of "the tree being changed". */
-const IGNORE_DIRS = new Set([".git", "node_modules", LOCAL, "dist", "build", ".next", "coverage", ".claude"]);
-
-/** Source extensions that count toward tree size. */
-const SOURCE_EXT = /\.(m?[jt]sx?|py|rb|go|rs|java|kt|swift|php|cs)$/i;
-
-/** Intake phrases that mean "this is bigger than it looks". */
-const BREADTH_SIGNALS = [
-  /\bmigrat(e|ion)\b/i,
-  /\bacross\b.*\b(files?|modules?|services?|commands?)\b/i,
-  /\bend[- ]to[- ]end\b/i,
-  /\brefactor\b/i,
-  /\bbackfill\b/i,
-  /\bschema\b/i,
-  /\bbreaking change\b/i,
-  /\bnew (dependency|package|library|service|datastore|database|table)\b/i,
-  /\bauth(entication|orization)\b/i,
-  /\bexternal (api|service|provider)\b/i,
-];
-
-/** Countable deliverables: things the intake asks to exist that do not exist yet. */
-const DELIVERABLE_SIGNALS = [
-  /\badd (?:a )?new\b/gi,
-  /\badd (?:a|an|the)\b/gi,
-  /\bnew (command|module|flag|endpoint|screen|field|option)\b/gi,
-  /\bimplement\b/gi,
-  /\bcreate\b/gi,
-  /\bsupport\b/gi,
-];
-
-/** Count source files in the tree, bounded so a huge repo cannot make this slow. */
-export function treeSize(root, cap = 400) {
-  let files = 0;
-  const walk = (dir, depth) => {
-    if (files >= cap || depth > 6) return;
-    let entries;
-    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
-    for (const e of entries) {
-      if (files >= cap) return;
-      if (e.name.startsWith(".") && e.name !== ".claude") { if (IGNORE_DIRS.has(e.name)) continue; }
-      if (IGNORE_DIRS.has(e.name)) continue;
-      const p = join(dir, e.name);
-      if (e.isDirectory()) walk(p, depth + 1);
-      else if (SOURCE_EXT.test(e.name)) {
-        try { if (statSync(p).size > 0) files++; } catch { /* unreadable */ }
-      }
-    }
-  };
-  walk(root, 0);
-  return files;
-}
-
-/**
- * Decide the lane from measurable facts.
- *
- * @param {{intake: string, files: number}} input
- * @returns {{lane: "tiny"|"full", confidence: "clear"|"borderline", reasons: string[], signals: object}}
- */
-export function decideLane({ intake, files }) {
-  const text = String(intake || "");
-  const breadth = BREADTH_SIGNALS.filter((re) => re.test(text)).map((re) => String(re));
-  let deliverables = 0;
-  for (const re of DELIVERABLE_SIGNALS) {
-    re.lastIndex = 0;
-    deliverables += (text.match(re) || []).length;
-  }
-
-  const signals = {
-    tree_source_files: files,
-    intake_chars: text.length,
-    deliverable_mentions: deliverables,
-    breadth_signals: breadth.length,
-  };
-
-  // CONJUNCTIVE, and it must be. The first version asked "is there evidence this is BIG?" and
-  // defaulted to tiny when it found none — which classified every trial feature as tiny,
-  // including the five-seam one that genuinely needs the pipeline and used two evaluation rounds
-  // to pass. A router that confident and that wrong is worse than no router: it would skip review
-  // on exactly the change that needed it.
-  //
-  // So `tiny` now requires positive evidence of smallness on EVERY axis, and `full` is what you
-  // get by default. A wrong `tiny` skips gates on something that needed them; a wrong `full` only
-  // costs money. Those are not symmetric.
-  const TINY = { files: 10, chars: 1500, deliverables: 2 };
-  const checks = [
-    { ok: files > 0 && files <= TINY.files, why: `tree has ${files} source file(s) (tiny needs 1–${TINY.files})` },
-    { ok: text.length <= TINY.chars, why: `intake is ${text.length} chars (tiny needs ≤${TINY.chars})` },
-    { ok: deliverables <= TINY.deliverables, why: `intake names ~${deliverables} deliverable(s) (tiny needs ≤${TINY.deliverables})` },
-    { ok: breadth.length === 0, why: breadth.length ? `${breadth.length} breadth signal(s) present` : "no breadth signals" },
-  ];
-  const reasons = checks.map((c) => `${c.ok ? "✓" : "✗"} ${c.why}`);
-  const tiny = checks.every((c) => c.ok);
-  const failed = checks.filter((c) => !c.ok).length;
-
-  // "Borderline" is not decoration: it is the signal that a human should look. One failed check
-  // means the change sits on the boundary and the lane is a judgment, not a measurement.
-  const confidence = tiny ? "clear" : failed === 1 ? "borderline" : "clear";
-
-  return {
-    lane: tiny ? "tiny" : "full",
-    confidence,
-    reasons,
-    signals,
-    // Say it on every invocation rather than burying it in a doc. These thresholds are calibrated
-    // against THREE features. That is enough to stop the router being obviously wrong and nowhere
-    // near enough to trust it silently, so it recommends and never denies.
-    calibration: "advisory — thresholds are coarse and `full` is the default; the PO may override with --lane",
-  };
-}
-
-// ---- CLI -------------------------------------------------------------------
-
-/** The typed argv contract (see `./lib/argv.mjs`). */
-export const ARGV_SPEC = {
-  usage: 'harness.mjs init fit (--intake-file <path> | --intake-text "<requirement>") [--cwd <dir>]',
-  _: { arity: 0, max: 0, name: "(no positional operands)" },
-  cwd: { type: "path" },
-  "intake-text": { type: "str" },
-  "intake-file": { type: "path" },
-};
-
-/**
- * Decide the lane (full or tiny) for an intake and the tree it will build in.
- *
- * @param {string[]} rawArgv - The subcommand's own arguments (harness.mjs strips the verb words).
- * @returns {(Promise<void>|void)} Settles when the subcommand has written its output; most paths
- *   call `process.exit()` with the subcommand's documented code rather than returning.
- */
-export function cli(rawArgv) {
-  const args = runArgs(ARGV_SPEC, rawArgv);
-  const cwd = args.cwd || process.cwd();
-  let intake = args.intakeText ?? null;
-  const f = args.intakeFile ?? null;
-  if (f) {
-    const p = f.startsWith("/") ? f : join(cwd, f);
-    if (!existsSync(p)) { console.error(`--intake-file not found: ${p}`); process.exit(2); }
-    intake = readFileSync(p, "utf8");
-  }
-  if (!intake) { console.error("fit-check: pass --intake-file <path> or --intake-text \"<requirement>\""); process.exit(2); }
-
-  const files = treeSize(cwd);
-  const result = decideLane({ intake, files });
-
-  console.log(JSON.stringify({
-    ...result,
-    // The sentence the orchestrator must act on, so the decision is not re-derived from the JSON.
-    action: result.lane === "tiny"
-      ? "TINY LANE. Run: orient (light) → single-task board → build → T0 → ⏸ L4. Skip WIRE, scope contracts, spec tree, EVAL and QA. The full pipeline on a change this size is why a run burns its whole clock without finishing."
-      : "FULL LANE. Run the complete pipeline: ORIENT → WIRE → MAP SCOPES → BUILD → EVAL → QA → GATE H → L4.",
-  }, null, 2));
-}
-

package/kernel/init/run-args.mjs

@@ -1,206 +0,0 @@
-#!/usr/bin/env node
-// GATE L0.9b — THE LAUNCH RECORD, GIVEN A WRITER.
-//
-// WHY THIS EXISTS. `domain.schema.json`'s `RunArgs` entry calls `.shapeup/<slug>/run-args.json`
-// "the only artifact that records what a run was configured with" and names tech-lead as the
-// writer — but "tech-lead" meant a paragraph of prose telling the orchestrating session to
-// assemble a JSON object by hand and `Write` it. Outside a structural-test fixture, nothing ever
-// did: no kernel module wrote the file, so `probe concurrency`'s `dialFrom()` read a fan-out dial
-// that was never recorded and reported the effective default every time, indistinguishable from a
-// run that genuinely chose it. A registry entry is not an instruction, and an instruction with no
-// enforcer is how a documented record becomes a file that simply never exists.
-//
-// THE FIX. This is the single writer. It takes the resolved GATE L0 values as flags, builds the
-// exact `RunArgs` object the schema describes, writes it to `.shapeup/<slug>/run-args.json`, and
-// prints that SAME object on stdout — so tech-lead passes the printed value straight to
-// `Workflow({args: ...})` rather than re-typing it a second time. One construction, not two: the
-// file on disk and the value the workflow actually launches with can no longer disagree.
-//
-// `wallClockS` is NOT one of this command's flags and never lands in the object it writes.
-// `--wall-clock-budget` is consumed earlier, by `harness init run` (see `RECEIPT_VERSION` and
-// `config.wall_clock_budget_s` in `./run.mjs`) — the deadline breaker reads that receipt field
-// directly and was never going to see this launch's `RunArgs` at all. Naming a third field here
-// that nothing reads is the exact defect this command exists to close, not one to reintroduce.
-//
-// USAGE
-//   node `harness init run-args` --slug <slug> --auto-level interactive|auto|unattended \
-//        --exec-model <name> [--eval-model <name>] [--qa-model <name>] \
-//        --max-rounds N --attempts N --plugin-root <dir> \
-//        [--run-id <id>] [--answers <preset|path>] [--lane full|tiny] \
-//        [--no-eval] [--no-qa] [--adversarial-verify] [--parallel-scopes N] [--cwd <dir>]
-//
-// `--eval-model` is required unless `--no-eval` is set — an EVAL-skipping run never resolves one.
-// `--run-id`, given no explicit value, is read off the run's own receipt (the run must already be
-// open — see `harness init run`), never invented.
-//
-// Prints the written `RunArgs` object as JSON on stdout. Exit 0 on success, 2 on a usage error,
-// 3 when no run is open at `--slug` (the receipt is what makes this artifact meaningful at all).
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { runArgs } from "../lib/argv.mjs";
-import { localRoot, RECEIPT_FILE, runArgsPath, runIdFromReceipt } from "../lib/paths.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-/** The plugin root, resolved from where this file actually is (`kernel/init/` → repo root). */
-export const PLUGIN_ROOT = resolve(HERE, "../..");
-
-/**
- * The `autoLevel` enum, read from the schema that defines it — never hand-typed here.
- *
- * `domain.schema.json`'s `$defs/RunArgs.properties.autoLevel.enum` is the one place this set is
- * declared. A `new Set([...])` beside it, inside the very module written to close run-argument
- * contract drift (see this file's own banner), would be that drift repeating one level down —
- * the same class of failure this module exists to close, applied here to an *enum's values*
- * instead of RunArgs *field* names. Mirrors `kernel/verify/skills.mjs`'s `roster()`, which
- * derives `WorkerName` the same way.
- *
- * @param {string} [root=PLUGIN_ROOT] - Plugin root the schema is read from — overridable so a test
- *   can point this at a scratch copy of the schema and prove the result grows and shrinks with it,
- *   never with an edit to this function.
- * @returns {string[]} The enum, in schema order.
- * @throws {Error} When the schema is missing or does not carry the enum.
- */
-export function autoLevels(root = PLUGIN_ROOT) {
-  const schemaPath = join(root, "kernel/schemas/domain.schema.json");
-  const schema = JSON.parse(readFileSync(schemaPath, "utf8"));
-  const levels = schema?.$defs?.RunArgs?.properties?.autoLevel?.enum;
-  if (!Array.isArray(levels) || !levels.length) {
-    throw new Error(`${schemaPath} carries no $defs/RunArgs.properties.autoLevel.enum — the auto-level set cannot be derived`);
-  }
-  return levels;
-}
-
-/** The typed argv contract (see `../lib/argv.mjs`). */
-export const ARGV_SPEC = {
-  usage: `harness.mjs init run-args --slug <slug> --auto-level ${autoLevels().join("|")} ` +
-         '--exec-model <name> [--eval-model <name>] [--qa-model <name>] --max-rounds N --attempts N ' +
-         '--plugin-root <dir> [--run-id <id>] [--answers <preset|path>] [--lane full|tiny] ' +
-         '[--no-eval] [--no-qa] [--adversarial-verify] [--parallel-scopes N] [--cwd <dir>]',
-  _: { arity: 0, max: 0, name: "(no positional operands)" },
-  cwd: { type: "path" },
-  slug: { type: "str", required: true },
-  "run-id": { type: "str" },
-  "auto-level": { type: "str", required: true },
-  answers: { type: "str" },
-  lane: { type: "str" },
-  "exec-model": { type: "str", required: true },
-  "eval-model": { type: "str" },
-  "qa-model": { type: "str" },
-  "max-rounds": { type: "int", min: 1, required: true },
-  attempts: { type: "int", min: 1, required: true },
-  "plugin-root": { type: "path", required: true },
-  "no-eval": { type: "flag" },
-  "no-qa": { type: "flag" },
-  "adversarial-verify": { type: "flag" },
-  "parallel-scopes": { type: "int", min: 1 },
-};
-
-function fail(code, msg) {
-  console.error(msg);
-  process.exit(code);
-}
-
-/**
- * Drop `undefined`-valued keys, one level deep on the named nested objects — so the JSON this
- * writes never carries a literal `"eval": undefined` for a skipped role or an unset switch.
- *
- * @param {object} o - The candidate RunArgs object.
- * @returns {object} The same shape with every `undefined` leaf and empty nested object removed.
- */
-function pruned(o) {
-  const out = {};
-  for (const [k, v] of Object.entries(o)) {
-    if (v === undefined) continue;
-    if (v && typeof v === "object" && !Array.isArray(v)) {
-      const inner = pruned(v);
-      if (Object.keys(inner).length) out[k] = inner;
-      continue;
-    }
-    out[k] = v;
-  }
-  return out;
-}
-
-/**
- * Build the `RunArgs` object — pure, so the structural suite can assert its shape without a
- * filesystem. Mirrors `domain.schema.json` `$defs/RunArgs` exactly: this is the one place that
- * shape is constructed, so a field this function does not carry cannot reach the file either.
- *
- * @param {object} o - Resolved inputs (destructured); optional fields may be `undefined`.
- * @returns {object} The RunArgs object, pruned of unset optionals.
- */
-export function buildRunArgs({
-  slug, runId, autoLevel, answers, lane, execModel, evalModel, qaModel,
-  maxRounds, attemptBudget, pluginRoot, startedAt,
-  noEval, noQa, adversarialVerify, maxParallelScopes,
-}) {
-  return pruned({
-    slug, runId, autoLevel, answers, lane,
-    models: { exec: execModel, eval: evalModel, qa: qaModel },
-    budgets: { maxRounds, attemptBudget },
-    pluginRoot, startedAt,
-    noEval, noQa, adversarialVerify, maxParallelScopes,
-  });
-}
-
-/**
- * Write `.shapeup/<slug>/run-args.json`, or refuse (exit 3) when no run is open at `--slug`.
- *
- * @param {string[]} rawArgv - The subcommand's own arguments (harness.mjs strips the verb words).
- * @returns {(Promise<void>|void)} Settles when the subcommand has written its output; every path
- *   calls `process.exit()` with the subcommand's documented code rather than returning.
- */
-export function cli(rawArgv) {
-  const args = runArgs(ARGV_SPEC, rawArgv);
-  const cwd = args.cwd || process.cwd();
-
-  if (!autoLevels().includes(args.autoLevel)) {
-    fail(2, `--auto-level must be one of: ${autoLevels().join(", ")}`);
-  }
-  if (!args.noEval && !args.evalModel) {
-    fail(2, "--eval-model is required unless --no-eval is set — an EVAL-skipping run never resolves one.");
-  }
-
-  const runRoot = localRoot(cwd, args.slug);
-  const receiptPath = join(runRoot, RECEIPT_FILE);
-  if (!existsSync(receiptPath)) {
-    fail(3, [
-      `✋ init run-args: no open run at ${runRoot} — run "harness init run" first (GATE L0.1).`,
-      "",
-      "`run-args.json` records what an OPEN run was launched with; writing one with no receipt",
-      "behind it would leave a launch record for a run that, everywhere else in the harness, never",
-      "started.",
-    ].join("\n"));
-  }
-  let receipt = null;
-  try { receipt = JSON.parse(readFileSync(receiptPath, "utf8")); } catch { /* handled below */ }
-  const runId = args.runId ?? runIdFromReceipt(receipt) ?? undefined;
-
-  const runArgsObj = buildRunArgs({
-    slug: args.slug,
-    runId,
-    autoLevel: args.autoLevel,
-    answers: args.answers ?? undefined,
-    lane: args.lane ?? undefined,
-    execModel: args.execModel,
-    evalModel: args.evalModel ?? undefined,
-    qaModel: args.qaModel ?? undefined,
-    maxRounds: args.maxRounds,
-    attemptBudget: args.attempts,
-    pluginRoot: args.pluginRoot,
-    startedAt: new Date().toISOString(),
-    noEval: args.noEval || undefined,
-    noQa: args.noQa || undefined,
-    adversarialVerify: args.adversarialVerify || undefined,
-    maxParallelScopes: args.parallelScopes ?? undefined,
-  });
-
-  mkdirSync(runRoot, { recursive: true });
-  writeFileSync(runArgsPath(cwd, args.slug), JSON.stringify(runArgsObj, null, 2) + "\n", "utf8");
-
-  // Printed, not just written — so the caller's `Workflow({args: ...})` reads this stdout instead
-  // of re-assembling the object from the flags it just typed.
-  console.log(JSON.stringify(runArgsObj, null, 2));
-}

package/kernel/lib/breadboard.mjs

@@ -1,165 +0,0 @@
-// breadboard — read a `/shapeup` breadboard's element ids out of its markdown tables.
-//
-// WHY THIS EXISTS. A pitch is two files: `shaping.md` (problem, requirements, parts) and
-// `breadboard.md` (Places, affordances, slices). The run used to take only the first, so a Place
-// that existed only in the breadboard — a new sheet, a new modal — reached no planning worker, and
-// the spec folded it into whichever screen the prose happened to mention. The ids read here are what
-// the run pins at open (the receipt's counts) and what spec-lint checks placement against.
-//
-// WHAT IT READS, and nothing more. An element id is the FIRST cell of a markdown table row —
-// `P1`, `P2.1`, `U3`, `N1b`, `S2`, `V4` — after stripping `**` and backticks, so both table layouts
-// the breadboarding guide ships parse the same way: a `#` first column and an `ID` first column. A
-// row's Places come from its `Place` column, every `P#` token in the cell (`P1 / P3`, `P2/P1`); a
-// table with no Place column gives its rows no Places. Places may also be listed as prose under a
-// `## Places` heading (`P1: Composer — …`), which is the guide's own output template.
-//
-// It skips fenced code blocks: a table inside a fence is an example of a breadboard, not this one.
-//
-// Tolerant by design. A layout this reader cannot parse yields zero ids, and every caller treats
-// zero ids as "nothing to check" plus a warning — never as a hard stop. Zero dependencies.
-
-/** A first-cell element id: a Place (`P1`, `P2.1`), or a UI/code affordance, store or slice. */
-export const ID_PATTERN = /^(P\d+(?:\.\d+)*|[UNSV]\d+[a-z]?)$/;
-
-/** Every Place reference inside a cell. Global — use with `match`, never `test`. */
-const PLACE_REF = /\bP\d+(?:\.\d+)*\b/g;
-
-/** A prose Place line under `## Places`: `P1: …`, `- P1 — …`, `**P2** – …`. */
-const PROSE_PLACE = /^\s*(?:[-*+]\s+)?\**(P\d+(?:\.\d+)*)\**\s*[:—–-]\s*(.*)$/;
-
-/**
- * Split one markdown table row into trimmed cells.
- * @param {string} line - A line that starts with `|`.
- * @returns {string[]} The cells between the outer pipes.
- */
-function cells(line) {
-  const t = line.trim().replace(/^\|/, "").replace(/\|$/, "");
-  return t.split("|").map((c) => c.trim());
-}
-
-/**
- * Strip the emphasis and code marks a breadboard author puts around an id.
- * @param {string} cell - A raw table cell.
- * @returns {string} The cell's text without `**` and backticks.
- */
-function bare(cell) {
-  return String(cell ?? "").replace(/\*\*/g, "").replace(/`/g, "").trim();
-}
-
-/**
- * Is this line a table's header separator (`|---|:--:|`)?
- * @param {string} line - A table line.
- * @returns {boolean} True for a separator row.
- */
-function isSeparator(line) {
-  return /^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$/.test(line);
-}
-
-/**
- * Parse a breadboard's element ids.
- *
- * @param {string} text - The breadboard markdown (or a pitch that carries one inline).
- * @returns {{places: {id: string, name: string}[], ui: {id: string, places: string[]}[],
- *   code: {id: string, places: string[]}[], stores: {id: string, places: string[]}[],
- *   slices: {id: string}[]}} Every id found, de-duplicated by id; a repeated row merges its Places.
- */
-export function parseBreadboard(text) {
-  const lines = String(text ?? "").split(/\r?\n/);
-  const places = new Map();
-  const byKind = { U: new Map(), N: new Map(), S: new Map(), V: new Map() };
-
-  const addPlace = (id, name) => {
-    if (!places.has(id)) places.set(id, { id, name: name || "" });
-    else if (!places.get(id).name && name) places.get(id).name = name;
-  };
-  const addElement = (id, refs) => {
-    const m = byKind[id[0]];
-    if (!m.has(id)) m.set(id, new Set());
-    for (const p of refs) m.get(id).add(p);
-  };
-
-  let inFence = false;
-  let inPlacesSection = false;
-  let header = null; // the current table's header cells, lower-cased
-  let prevWasTable = false;
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (/^\s*(```|~~~)/.test(line)) { inFence = !inFence; prevWasTable = false; header = null; continue; }
-    if (inFence) continue;
-
-    const heading = line.match(/^\s*#{1,6}\s+(.*)$/);
-    if (heading) {
-      inPlacesSection = /^places\b/i.test(bare(heading[1]));
-      prevWasTable = false; header = null;
-      continue;
-    }
-
-    if (/^\s*\|/.test(line)) {
-      if (!prevWasTable) {
-        // A table starts here. Its first line is the header when the next line is a separator.
-        header = isSeparator(lines[i + 1] ?? "") ? cells(line).map((c) => bare(c).toLowerCase()) : null;
-        prevWasTable = true;
-        if (header) continue;
-      }
-      if (isSeparator(line)) continue;
-      const row = cells(line);
-      const id = bare(row[0]);
-      if (!ID_PATTERN.test(id)) continue;
-      const placeCol = header ? header.indexOf("place") : -1;
-      if (id[0] === "P") {
-        const nameCol = placeCol > 0 ? placeCol : (header ? header.findIndex((h) => h === "name") : -1);
-        addPlace(id, bare(row[nameCol > 0 ? nameCol : 1] ?? ""));
-      } else {
-        const cell = placeCol > 0 ? bare(row[placeCol] ?? "") : "";
-        addElement(id, cell.match(PLACE_REF) ?? []);
-      }
-      continue;
-    }
-    prevWasTable = false; header = null;
-
-    if (inPlacesSection) {
-      const m = line.match(PROSE_PLACE);
-      if (m) addPlace(m[1], bare(m[2]).split(/\s+[—–-]\s+/)[0]);
-    }
-  }
-
-  const list = (m) => [...m].map(([id, refs]) => ({ id, places: [...refs] }));
-  return {
-    places: [...places.values()],
-    ui: list(byKind.U),
-    code: list(byKind.N),
-    stores: list(byKind.S),
-    slices: [...byKind.V.keys()].map((id) => ({ id })),
-  };
-}
-
-/**
- * Does this text carry a breadboard of its own — at least one Place and one UI affordance?
- *
- * The test for a pitch that embeds its breadboard inline rather than as a second file. Both are
- * required: a shaping doc routinely has tables, and a Place with nothing to place is not a
- * breadboard anything downstream can check.
- *
- * @param {string} text - Markdown to inspect.
- * @returns {boolean} True when `parseBreadboard` finds a P# and a U#.
- */
-export function hasBreadboardTables(text) {
-  const bb = parseBreadboard(text);
-  return bb.places.length > 0 && bb.ui.length > 0;
-}
-
-/**
- * Count a parsed breadboard's ids by kind, the shape the run receipt records.
- * @param {ReturnType<typeof parseBreadboard>} parsed - A `parseBreadboard` result.
- * @returns {{P: number, U: number, N: number, S: number, V: number}} Ids per kind.
- */
-export function idCounts(parsed) {
-  return {
-    P: parsed.places.length,
-    U: parsed.ui.length,
-    N: parsed.code.length,
-    S: parsed.stores.length,
-    V: parsed.slices.length,
-  };
-}