@sdd-method/author-cli 0.0.0-stage → 0.1.0

package/dist/lib/catalogue/archetype/wireframe.js

@@ -0,0 +1,418 @@
+// Deterministic structural-wireframe renderer (ADR 0169 §4.4).
+//
+// Lowers a screen's openui-lang block to an SVG wireframe: parse the block into
+// a composition tree, resolve each node to a visual archetype, and lay it out
+// driven by the archetype's render hints — orientation, shape (bar / chips /
+// grid / card / floating / paged / leaf shapes), slots, overlay, active_first,
+// header_row. Each node is drawn as its archetype's visual SHAPE (an app-bar is
+// a band, a tab-strip is a row of chips, a paged-panes shows the active pane and
+// collapses the rest, a table has a header row, a modal floats), labelled with
+// the component name + resolved archetype and shaded by resolution provenance so
+// low-confidence inferences stay visible. A structural wireframe, not a pixel
+// design; parameterised entirely by the archetype map (adopter-agnostic — no
+// component vocabulary, no adopter knowledge).
+//
+// Deterministic companion to the LLM-driven render-screen-wireframe skill.
+import { buildCompositionTree, stripBlockComments } from "../builders/screen-tree.js";
+import { archetypeInfo, isKnownPlatform, mapStripPrefixes, resolveArchetype, } from "./resolver.js";
+// --- geometry constants ----------------------------------------------------
+const PAD = 8;
+const GAP = 6;
+const LABEL_H = 16; // container label strip
+const TITLE_H = 26;
+const TABLE_HDR_H = 20;
+const COLLAPSE_H = 22; // collapsed (inactive) paged pane row
+const SHADOW = 4; // floating/card drop-shadow offset
+const GRID_COLS = 2;
+/** Render an openui-lang block to a structural wireframe SVG string. */
+export function renderWireframe(input) {
+    const tree = buildCompositionTree(stripBlockComments(input.block));
+    if (tree === null) {
+        return emptySvg(input.title, "empty composition — no statements");
+    }
+    const platform = isKnownPlatform(input.platform) ? input.platform : undefined;
+    const prefixes = [...(input.overlay?.strip_prefixes ?? []), ...mapStripPrefixes(platform)];
+    const root = measure(shape(tree, platform, input.overlay, prefixes));
+    const titleOffset = input.title ? TITLE_H : 0;
+    const width = root.w + PAD * 2;
+    const height = root.h + PAD * 2 + titleOffset;
+    const body = [];
+    if (input.title)
+        body.push(text(PAD, 17, escapeXml(input.title), "title"));
+    emit(root, PAD, PAD + titleOffset, body);
+    return svg(width, height, body.join("\n"));
+}
+// --- shape: resolve archetype + classify a render mode per node ------------
+const LEAF_SHAPES = new Set(["button", "chip", "text", "image", "circle", "row"]);
+function shape(node, platform, overlay, prefixes) {
+    const children = node.children.map((c) => shape(c, platform, overlay, prefixes));
+    const isContainer = children.length > 0;
+    linkPagedTabs(children, prefixes);
+    if (node.component === "" || platform === undefined) {
+        return base("", "none", isContainer ? "stack" : "leaf", "box");
+    }
+    const { archetype, provenance } = resolveArchetype(node.component, platform, overlay);
+    const r = archetypeInfo(archetype).render;
+    const sh = r.shape ?? "";
+    if (!isContainer) {
+        const leafShape = LEAF_SHAPES.has(sh) ? sh : "box";
+        return base(archetype, provenance, "leaf", leafShape);
+    }
+    let mode;
+    if (sh === "bar")
+        mode = "bar";
+    else if (sh === "chips")
+        mode = "chips";
+    else if (sh === "grid")
+        mode = r.header_row ? "table" : "grid";
+    else if (sh === "paged")
+        mode = "paged";
+    else if (sh === "card")
+        mode = "card";
+    else if (sh === "floating")
+        mode = "floating";
+    else
+        mode = r.orientation === "horizontal" ? "row" : "stack";
+    return base(archetype, provenance, mode, "box");
+    function base(archetype, provenance, mode, leafShape) {
+        return { node, archetype, provenance, mode, leafShape, children, stripPrefixes: prefixes, derivedLabel: "", w: 0, h: 0 };
+    }
+}
+/**
+ * Derive tab labels from windowed content (deterministic, spec-faithful): when a
+ * sibling group holds a tab-strip and a paged-panes with the SAME pane count, and
+ * the tabs carry no authored label, label each tab from its corresponding pane's
+ * content component name. Reads only names already in the spec — no fabrication.
+ */
+function linkPagedTabs(siblings, prefixes) {
+    const strip = siblings.find((s) => s.archetype === "tab-strip");
+    const paged = siblings.find((s) => s.archetype === "paged-panes");
+    if (!strip || !paged)
+        return;
+    if (strip.children.length === 0 || strip.children.length !== paged.children.length)
+        return;
+    strip.children.forEach((tab, i) => {
+        if (tab.node.args.length > 0 || tab.derivedLabel)
+            return; // authored label wins
+        const pane = paged.children[i];
+        const contentName = pane.children[0]?.node.component || pane.node.component;
+        if (contentName)
+            tab.derivedLabel = humaniseName(contentName, prefixes);
+    });
+}
+// --- measure: size every node bottom-up ------------------------------------
+function leafSize(shapeName, lbl) {
+    switch (shapeName) {
+        case "button": return { w: Math.max(84, lbl.length * 6 + 16), h: 26 };
+        case "chip": return { w: Math.max(56, lbl.length * 6 + 14), h: 22 };
+        case "text": return { w: Math.max(120, lbl.length * 6 + 12), h: 28 };
+        case "image": return { w: 72, h: 54 };
+        case "circle": return { w: 44, h: 44 };
+        case "row": return { w: Math.max(200, lbl.length * 6 + 24), h: 26 };
+        default: return { w: Math.max(120, lbl.length * 6.2 + 12), h: 40 };
+    }
+}
+function measure(s) {
+    if (s.mode === "leaf") {
+        const { w, h } = leafSize(s.leafShape, labelPlain(s));
+        s.w = w;
+        s.h = h;
+        return s;
+    }
+    s.children.forEach(measure);
+    const cs = s.children;
+    let innerW;
+    let innerH;
+    switch (s.mode) {
+        case "row":
+        case "bar":
+        case "chips": {
+            innerW = cs.reduce((a, c) => a + c.w, 0) + GAP * (cs.length - 1);
+            innerH = Math.max(...cs.map((c) => c.h));
+            break;
+        }
+        case "grid": {
+            const colW = Math.max(...cs.map((c) => c.w));
+            const rowH = Math.max(...cs.map((c) => c.h));
+            const rows = Math.ceil(cs.length / GRID_COLS);
+            const cols = Math.min(GRID_COLS, cs.length);
+            innerW = cols * colW + GAP * (cols - 1);
+            innerH = rows * rowH + GAP * (rows - 1);
+            break;
+        }
+        case "table": {
+            innerW = Math.max(180, ...cs.map((c) => c.w));
+            innerH = TABLE_HDR_H + GAP + cs.reduce((a, c) => a + c.h, 0) + GAP * (cs.length - 1);
+            break;
+        }
+        case "paged": {
+            const active = cs[0];
+            const restN = cs.length - 1;
+            innerW = Math.max(160, active.w);
+            innerH = active.h + (restN > 0 ? GAP + restN * COLLAPSE_H + GAP * (restN - 1) : 0);
+            break;
+        }
+        default: {
+            // stack / card / floating
+            innerW = Math.max(...cs.map((c) => c.w));
+            innerH = cs.reduce((a, c) => a + c.h, 0) + GAP * (cs.length - 1);
+        }
+    }
+    s.w = innerW + PAD * 2;
+    s.h = LABEL_H + innerH + PAD * 2;
+    return s;
+}
+// --- emit: place + draw top-down -------------------------------------------
+function emit(s, x, y, out) {
+    if (s.mode === "leaf") {
+        drawLeaf(s, x, y, out);
+        return;
+    }
+    drawContainer(s, x, y, out);
+    const cx0 = x + PAD;
+    const cy0 = y + LABEL_H + PAD;
+    const cs = s.children;
+    switch (s.mode) {
+        case "row":
+        case "bar":
+        case "chips": {
+            const rowH = Math.max(...cs.map((c) => c.h));
+            let cx = cx0;
+            for (const c of cs) {
+                emit(c, cx, cy0 + (rowH - c.h) / 2, out);
+                cx += c.w + GAP;
+            }
+            break;
+        }
+        case "grid": {
+            const colW = Math.max(...cs.map((c) => c.w));
+            const rowH = Math.max(...cs.map((c) => c.h));
+            cs.forEach((c, i) => {
+                const col = i % GRID_COLS;
+                const row = Math.floor(i / GRID_COLS);
+                emit(c, cx0 + col * (colW + GAP), cy0 + row * (rowH + GAP), out);
+            });
+            break;
+        }
+        case "table": {
+            const innerW = s.w - PAD * 2;
+            out.push(rect(cx0, cy0, innerW, TABLE_HDR_H, "none", true, "#e2e8f0"));
+            for (let i = 1; i < 4; i++) {
+                const lx = cx0 + (innerW * i) / 4;
+                out.push(line(lx, cy0, lx, cy0 + TABLE_HDR_H));
+            }
+            let ry = cy0 + TABLE_HDR_H + GAP;
+            for (const c of cs) {
+                emit(c, cx0, ry, out);
+                ry += c.h + GAP;
+            }
+            break;
+        }
+        case "paged": {
+            const active = cs[0];
+            emit(active, cx0, cy0, out);
+            let ry = cy0 + active.h + GAP;
+            for (const c of cs.slice(1)) {
+                out.push(rect(cx0, ry, s.w - PAD * 2, COLLAPSE_H, c.provenance, false, "#f1f5f9"));
+                out.push(text(cx0 + 6, ry + 15, "▸ " + collapsedPaneLabel(c), "dim"));
+                ry += COLLAPSE_H + GAP;
+            }
+            break;
+        }
+        default: {
+            let cy = cy0;
+            for (const c of cs) {
+                emit(c, cx0, cy, out);
+                cy += c.h + GAP;
+            }
+        }
+    }
+}
+// --- drawing primitives ----------------------------------------------------
+const DARK_BARS = new Set(["app-bar", "nav-bar"]);
+function drawContainer(s, x, y, out) {
+    const dark = DARK_BARS.has(s.archetype);
+    let fill = "#f8fafc";
+    if (s.archetype === "banner")
+        fill = "#fef3c7";
+    else if (s.archetype === "tab-bar")
+        fill = "#eef2ff";
+    else if (s.mode === "card" || s.mode === "floating")
+        fill = "#ffffff";
+    else if (dark)
+        fill = "#1f2937";
+    if (s.mode === "floating" || s.mode === "card") {
+        out.push(`<rect x="${x + SHADOW}" y="${y + SHADOW}" width="${s.w}" height="${s.h}" rx="4" fill="#0f172a" opacity="0.12"/>`);
+    }
+    out.push(rect(x, y, s.w, s.h, s.provenance, true, fill));
+    out.push(text(x + PAD, y + 12, labelMarkup(s), dark ? "lblw" : "lbl"));
+}
+function drawLeaf(s, x, y, out) {
+    const lbl = labelMarkup(s);
+    switch (s.leafShape) {
+        case "button":
+            out.push(`<rect x="${x}" y="${y}" width="${s.w}" height="${s.h}" rx="13" fill="#dbeafe" stroke="#3b82f6"${dash(s.provenance)}/>`);
+            out.push(text(x + 10, y + s.h / 2 + 4, lbl, "btn"));
+            break;
+        case "chip":
+            out.push(`<rect x="${x}" y="${y}" width="${s.w}" height="${s.h}" rx="11" fill="#e2e8f0" stroke="#94a3b8"${dash(s.provenance)}/>`);
+            out.push(text(x + 9, y + s.h / 2 + 4, lbl, "lbl"));
+            break;
+        case "circle": {
+            const r = s.w / 2;
+            out.push(`<circle cx="${x + r}" cy="${y + r}" r="${r}" fill="#dbeafe" stroke="#3b82f6"${dash(s.provenance)}/>`);
+            out.push(text(x + 6, y + r + 4, lbl, "dim"));
+            break;
+        }
+        case "image":
+            out.push(rect(x, y, s.w, s.h, s.provenance, false, "#f1f5f9"));
+            out.push(line(x, y, x + s.w, y + s.h));
+            out.push(line(x + s.w, y, x, y + s.h));
+            out.push(text(x + 4, y + s.h - 4, lbl, "dim"));
+            break;
+        case "text":
+            out.push(text(x, y + 12, lbl, "lbl"));
+            out.push(`<rect x="${x}" y="${y + 16}" width="${s.w}" height="5" rx="2" fill="#cbd5e1"/>`);
+            out.push(`<rect x="${x}" y="${y + 24}" width="${s.w * 0.66}" height="5" rx="2" fill="#e2e8f0"/>`);
+            break;
+        case "row":
+            out.push(rect(x, y, s.w, s.h, s.provenance, false, "#ffffff"));
+            out.push(`<circle cx="${x + 11}" cy="${y + s.h / 2}" r="5" fill="#cbd5e1"/>`);
+            out.push(text(x + 24, y + s.h / 2 + 4, lbl, "lbl"));
+            break;
+        default:
+            out.push(rect(x, y, s.w, s.h, s.provenance, false, "#fdfdfe"));
+            out.push(text(x + 6, y + s.h / 2 + 4, lbl, "lbl"));
+    }
+}
+// --- label derivation ------------------------------------------------------
+/** The primary human label for a node, derived only from tokens in the spec. */
+function primaryLabel(s) {
+    if (s.node.args.length > 0)
+        return s.node.args[0]; // authored positional label
+    if (s.mode === "leaf" && s.node.actions.length > 0 && (s.archetype === "button" || s.archetype === "fab"))
+        return humaniseAction(s.node.actions[0]); // CTA from action=
+    if (s.derivedLabel)
+        return s.derivedLabel; // windowed-pane tab label
+    const comp = s.node.component;
+    if (!comp)
+        return s.node.id;
+    // A `default` resolution is a recognised standard widget — its short vendor name
+    // reads fine as-is; bespoke names (override / heuristic / fallback) humanise better.
+    return s.provenance === "default" || s.provenance === "none" ? comp : humaniseName(comp, s.stripPrefixes);
+}
+function archMark(prov) {
+    return prov === "fallback" ? "?" : prov === "heuristic" ? "~" : "";
+}
+/** Plain text label (for width measurement): primary + archetype annotation. */
+function labelPlain(s) {
+    const primary = primaryLabel(s);
+    if (s.archetype === "" || s.provenance === "none")
+        return primary;
+    return `${primary} :${s.archetype}${archMark(s.provenance)}`;
+}
+/**
+ * Collapsed paged-pane label: a wrapper pane often has a generic name (its
+ * content carries the identity), so prefer the content component's label when
+ * the pane itself has no authored label of its own. Spec-faithful — the content
+ * name is already in the block.
+ */
+function collapsedPaneLabel(s) {
+    const content = s.children[0];
+    if (s.node.args.length === 0 && !s.derivedLabel && content && content.node.component) {
+        const lbl = escapeXml(primaryLabel(content));
+        return s.archetype === "" ? lbl : `${lbl} <tspan class="arch">:${escapeXml(s.archetype)}</tspan>`;
+    }
+    return labelMarkup(s);
+}
+/** SVG markup label (for emission): primary text + a small dim `:archetype` tspan. */
+function labelMarkup(s) {
+    const primary = escapeXml(primaryLabel(s));
+    if (s.archetype === "" || s.provenance === "none")
+        return primary;
+    return `${primary} <tspan class="arch">:${escapeXml(s.archetype)}${archMark(s.provenance)}</tspan>`;
+}
+// --- humanisation (deterministic, adopter-agnostic) ------------------------
+const HUMANISE_SUFFIXES = [
+    "Component", "Container", "Controller", "Activity", "Fragment", "Section",
+    "Layout", "Panel", "Popup", "Dialog", "Modal", "Widget", "View", "Screen",
+    "Page", "Table", "List", "Card", "Item",
+];
+/** Strip a vendor prefix + a trailing archetype-ish suffix, split camelCase, Title Case. */
+function humaniseName(name, prefixes) {
+    let s = name;
+    for (const p of prefixes) {
+        // Strip only at a PascalCase boundary (next char uppercase) so a short prefix
+        // like "St" peels "StLayout" → "Layout" but never "Status" → "atus".
+        if (s.length > p.length && s.startsWith(p) && /[A-Z]/.test(s.charAt(p.length))) {
+            s = s.slice(p.length);
+            break;
+        }
+    }
+    for (const suf of HUMANISE_SUFFIXES) {
+        if (s.length > suf.length && s.endsWith(suf)) {
+            s = s.slice(0, -suf.length);
+            break;
+        }
+    }
+    const words = splitWords(s);
+    if (words.length === 0)
+        return titleCaseWords(splitWords(name)); // prefix/suffix ate the whole name
+    return titleCaseWords(words);
+}
+/** Humanise an action token, prefixing create/add/new verbs with "+ ". */
+function humaniseAction(action) {
+    const human = titleCaseWords(splitWords(action));
+    return /^(new|add|create)([^a-z]|$)/i.test(action) ? `+ ${human}` : human;
+}
+function splitWords(s) {
+    return s
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+        .replace(/[_\-.]+/g, " ")
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean);
+}
+function titleCaseWords(words) {
+    return words.map((w) => (w === w.toUpperCase() ? w : w.charAt(0).toUpperCase() + w.slice(1))).join(" ");
+}
+function dash(prov) {
+    return prov === "heuristic" ? ' stroke-dasharray="5 3"' : prov === "fallback" ? ' stroke-dasharray="1 4"' : "";
+}
+function rect(x, y, w, h, prov, container, fill) {
+    const f = fill ?? (container ? "#f4f6f8" : "#fdfdfe");
+    return `<rect x="${x}" y="${y}" width="${w}" height="${h}" rx="3" fill="${f}" stroke="#64748b" stroke-width="1"${dash(prov)}/>`;
+}
+function line(x1, y1, x2, y2) {
+    return `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="#cbd5e1" stroke-width="1"/>`;
+}
+function text(x, y, content, cls) {
+    return `<text x="${x}" y="${y}" class="${cls}">${content}</text>`;
+}
+function svg(width, height, body) {
+    return [
+        `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">`,
+        `<style>text{font-family:ui-monospace,monospace;font-size:11px;fill:#334155}.title{font-size:13px;font-weight:600;fill:#0f172a}.lbl{fill:#334155}.lblw{fill:#f8fafc}.dim{fill:#94a3b8}.btn{fill:#1e40af;font-weight:600}.arch{font-size:9px;fill:#a8b3c2}</style>`,
+        `<rect width="${width}" height="${height}" fill="#fff"/>`,
+        body,
+        `</svg>`,
+    ].join("\n");
+}
+function emptySvg(title, message) {
+    const body = [
+        title ? text(PAD, 16, escapeXml(title), "title") : "",
+        text(PAD, title ? 36 : 16, escapeXml(message), "lbl"),
+    ]
+        .filter(Boolean)
+        .join("\n");
+    return svg(240, title ? 48 : 28, body);
+}
+function escapeXml(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+//# sourceMappingURL=wireframe.js.map

package/dist/lib/catalogue/baseline-check.js

@@ -0,0 +1,151 @@
+/**
+ * `catalogue baseline-check` — compares emitted findings against a repo's
+ * findings baseline BY IDENTITY (M-ADR 0132 §9), and reports the four outcomes
+ * a re-take needs to be reviewable: unbaselined, reworded, closed, unchanged.
+ *
+ * WHY THIS IS A COMMAND AND NOT A DISCIPLINE. The comparison was previously
+ * described in prose and performed per repo, which is why the rewording class
+ * (§9.1) went undetected twice on the same finding family: every repo
+ * implemented "is this line in the file" independently and correctly, and the
+ * defect was in the question, not the implementations.
+ *
+ * It reads findings rather than producing them, so it composes with whatever
+ * produced them and cannot disagree with a separate run of the builder:
+ *
+ *   sdd-cli catalogue validate --coverage > findings.txt
+ *   sdd-cli catalogue baseline-check --findings findings.txt
+ *
+ * ONLY GATE-ACTING CATEGORIES ARE COMPARED (`orphan`, `divergence` — M-ADR 0132
+ * §4.3). Filtering happens here, visibly, and the count of what was filtered is
+ * printed: a comparator that silently dropped categories would make an empty
+ * result ambiguous between "nothing gate-acting" and "nothing at all".
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { compareToBaseline } from "./finding-identity.js";
+/** The categories a baseline governs, per M-ADR 0132 §4.3. */
+const GATE_ACTING = new Set(["orphan", "divergence"]);
+export const DEFAULT_BASELINE_REL = join("orchestration", "catalogue-findings-baseline.txt");
+const FINDING_LINE = /^\[finding\] (\w+)(?: \[error\])?[ (:]/;
+/**
+ * Findings from a stream of mixed output. Non-finding lines (metrics, headers,
+ * blank lines, a baseline file's `#` provenance) are not findings and are
+ * dropped without comment; a `[finding]` line of a non-gate-acting category is
+ * dropped and COUNTED, because that number is the difference between "nothing
+ * to compare" and "nothing was comparable".
+ */
+export function extractGateActing(text) {
+    const lines = [];
+    let nonGateActing = 0;
+    for (const raw of text.split("\n")) {
+        const line = raw.trimEnd();
+        const m = FINDING_LINE.exec(line);
+        if (!m)
+            continue;
+        if (GATE_ACTING.has(m[1]))
+            lines.push(line);
+        else
+            nonGateActing++;
+    }
+    return { lines, nonGateActing };
+}
+export async function runBaselineCheck(options, write) {
+    const root = options.sddPath ?? process.cwd();
+    const baselinePath = options.baseline ?? join(root, DEFAULT_BASELINE_REL);
+    let findingsText;
+    if (options.findings !== undefined) {
+        findingsText = await readFile(options.findings, "utf-8");
+    }
+    else if (options.stdin) {
+        findingsText = await options.stdin();
+    }
+    else {
+        write("[error] baseline-check: no findings source (--findings <path>, or pipe them in)\n");
+        return { exitCode: 2 };
+    }
+    // An input with no lines at all is not "zero findings": every real findings
+    // stream (build, coverage, validate output) carries at least its own metric
+    // and verdict lines. The default source is stdin, so an empty pipe arrives
+    // here as nothing — refused, never compared (empty-set sweep, R2).
+    if (findingsText.trim() === "") {
+        write(`[error] baseline-check: the findings stream is EMPTY — no lines of any kind. ` +
+            `This is not zero findings; it is no measurement (an empty pipe, or the wrong ` +
+            `file). Pass --findings <path> to the captured stream\n`);
+        return { exitCode: 2 };
+    }
+    let baselineText;
+    try {
+        baselineText = await readFile(baselinePath, "utf-8");
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+        // A MISSING baseline is not an empty one. Under §9.3 the canonical zero is
+        // an empty-but-present file, precisely so that "measured, and there were
+        // none" is distinguishable from "never measured" — so this reports rather
+        // than treating every live finding as unbaselined.
+        write(`[error] baseline-check: no baseline at ${baselinePath} — a missing file is not a ` +
+            `recorded zero (M-ADR 0132 §9.3); create it empty, with its provenance header, ` +
+            `to record that findings were measured and there were none\n`);
+        return { exitCode: 2 };
+    }
+    const live = extractGateActing(findingsText);
+    const base = extractGateActing(baselineText);
+    const cmp = compareToBaseline(live.lines, base.lines);
+    write(`[metric] baseline_check: ${live.lines.length} gate-acting finding(s) against ` +
+        `${base.lines.length} baseline entr(ies) — ${cmp.unchanged} unchanged, ` +
+        `${cmp.reworded.length} reworded, ${cmp.unbaselined.length} unbaselined, ` +
+        `${cmp.stale.length} closed; ${live.nonGateActing} non-gate-acting finding(s) not compared\n`);
+    // ⚠ THE WHOLE-BASELINE-CLOSED GUARD. An all-closed result against a non-empty
+    // baseline is far more likely to mean the comparison read the WRONG STREAM than
+    // that an estate fixed everything at once, and until now it rendered as a clean
+    // green number: "0 gate-acting findings, 215 closed" reads as success and is
+    // indistinguishable from a gate comparing against nothing.
+    //
+    // Raised by an adopter estate that hit it on a 215-entry baseline: its
+    // baseline had been captured from one stream/tier and was being compared
+    // against another, so every entry reported closed and the regression gate
+    // passed unconditionally. The `--findings` default is stdin, so an empty pipe
+    // reaches here as legitimately-zero findings — the same estate had already
+    // been caught once by a bare invocation reporting 832 closed.
+    //
+    // The condition is deliberately narrow: live gate-acting findings ZERO, baseline
+    // non-empty, and EVERY entry closed. That triple cannot arise from ordinary
+    // remediation without also being worth a human look.
+    const allClosed = live.lines.length === 0 && base.lines.length > 0 && cmp.stale.length === base.lines.length;
+    if (allClosed) {
+        write(`[finding] divergence: baseline_check compared ZERO live gate-acting findings ` +
+            `against ${base.lines.length} baseline entr(ies) and reported ALL of them closed. ` +
+            `This is reported as a DEFECT rather than a pass: an all-closed baseline is far ` +
+            `more likely to mean the findings stream was empty or was the wrong one than that ` +
+            `every finding was fixed at once. Check that --findings received the stream the ` +
+            `baseline was CAPTURED from (note the default is stdin, so an empty pipe arrives ` +
+            `here as zero findings), and that --tier matches. Re-taking the baseline against ` +
+            `this comparison would bake the empty stream in as the new truth and destroy the ` +
+            `${base.lines.length}-entry record.\n`);
+    }
+    // Reported even at zero. While it is above zero those entries are matched on
+    // whole text and remain exposed to the rewording class; silence here would
+    // imply a protection the repo has not got.
+    write(`[metric] baseline_check.legacy_keyed: ${cmp.legacyKeyed} baseline entr(ies) carry no ` +
+        `identity and are matched on their whole line — re-take them as their emission ` +
+        `sites migrate (M-ADR 0132 §9.2)\n`);
+    for (const r of cmp.reworded) {
+        // Named, not counted only: a re-take must be able to show which line
+        // replaced which, and "N reworded" is not reviewable evidence.
+        write(`[reworded] ${r.baseline}\n[reworded]   -> ${r.live}\n`);
+    }
+    for (const s of cmp.stale)
+        write(`[closed] ${s}\n`);
+    for (const u of cmp.unbaselined)
+        write(`[unbaselined] ${u}\n`);
+    // Only genuinely unbaselined findings fail. A reworded finding is the case
+    // this whole mechanism exists to stop failing, and a closed one is good news
+    // that a re-take tidies — neither is a regression.
+    // The all-closed guard FAILS the gate (empty-set sweep, R2, ruled 2026-09-29):
+    // it used to print "a DEFECT rather than a pass" and exit 0, so the regression
+    // gate still passed on exactly the empty/wrong stream it was written to catch.
+    // A genuinely all-fixed estate re-takes its baseline once, deliberately.
+    return { exitCode: cmp.unbaselined.length > 0 || allClosed ? 1 : 0 };
+}
+//# sourceMappingURL=baseline-check.js.map