@clay-design-system/kb 0.0.0-stage → 0.14.1

package/dist/core/route.js

@@ -0,0 +1,1769 @@
+import { estimateTokens } from './model.js';
+import { search } from './search.js';
+import { EMAIL_SKILL_DELEGATES, emailBriefCandidates, emailDoBlock, emailGates, inScope, isEmailSkill, } from './route-email.js';
+export const DEFAULT_BUDGET = 2500;
+/** A route with a brief also carries the candidates table and the item shapes. K5 raised this to 3k; K5b deduped the
+ * route (the precedence table once, no Mode A inputs in a Mode B route) and brought it back to 2.5k. */
+export const BRIEF_BUDGET = 2500;
+/**
+ * Units a skill fetches once at the start of a mode (web-compose SKILL.md "Modes": `pnpm clay get
+ * policy.mode-b.precedence policy.mode-b.defaults`). A route names them in one line instead of inlining them again
+ * (K5 QA F5: the precedence table was printed twice). k5b.test.ts keeps this list and the skill text in sync.
+ */
+export const MODE_START_UNITS = {
+    A: [],
+    B: ['policy.mode-b.precedence', 'policy.mode-b.defaults'],
+};
+/** A procedure body with "**Mode A …**" / "**Mode B …**" blocks keeps only the requested mode's block (K5b F5). */
+export function modeSlice(body, mode) {
+    if (!mode)
+        return body;
+    const lines = body.split('\n');
+    const marks = lines
+        .map((l, i) => ({ i, m: /^\*\*Mode ([AB])\b/.exec(l)?.[1] }))
+        .filter((x) => x.m);
+    if (new Set(marks.map((x) => x.m)).size < 2)
+        return body;
+    const keep = lines.slice(0, marks[0].i);
+    marks.forEach((x, k) => {
+        if (x.m !== mode)
+            return;
+        keep.push(...lines.slice(x.i, k + 1 < marks.length ? marks[k + 1].i : lines.length));
+    });
+    return keep
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+/** K8: Watch lists at most this many one-liners (run D: ~80% of a 35-line Watch list was irrelevant). */
+export const WATCH_MAX = 10;
+/** K11 F1: the Watch score edge a Critical unit has over a non-Critical one of the same rank. */
+export const CRITICAL_EDGE = 0.1;
+/**
+ * K11 G1: how far below a Minor unit kept in Watch a Critical unit may score and still take its slot at the cut (see
+ * `guardCriticalAtCut`, which makes the Critical guarantee independent of BM25 drift in the edge).
+ */
+export const CRITICAL_CUT_MARGIN = 0.15;
+export const MORE_MAX = 12;
+/** K10: the compact route's Watch list (the rest are ids under More). */
+export const WATCH_MAX_COMPACT = 5;
+/** Stages that get the "Your layouts" fact lines (the page is being written or checked). */
+const LAYOUT_FACT_STAGES = new Set(['copy', 'page-file']);
+/* ── brief parsing ─────────────────────────────────────────────────────────────────────────── */
+/**
+ * Brief sections: numbered headings — `## N. Title` (the `pnpm capture --brief` format) or `### N. Title` under a
+ * `## Sections` heading (the documented Mode B template, `procedure.compose.inputs`) — at whichever level carries the
+ * numbered headings; with none, every `##` heading. A section runs to the next heading of the same or a higher level.
+ * Item counts come from tables / lists / "·" lists.
+ */
+export function parseBrief(text) {
+    const lines = text.split('\n');
+    const heads = [];
+    // "## 3. Title", "### 3) Title" or "## Section 3 — Title"; a "## PMM Brief — …" metadata block is never a section.
+    const NUM = /^(?:section\s+)?(\d+)(?:[.)]\s*|\s*[—–:-]\s*|\s+)/i;
+    let fence = false;
+    lines.forEach((l, i) => {
+        if (/^\s*(?:```|~~~)/.test(l))
+            fence = !fence;
+        if (fence)
+            return;
+        const m = /^(#{2,3})\s+(.+)$/.exec(l);
+        if (!m)
+            return;
+        const title = m[2].trim();
+        heads.push({
+            i,
+            level: m[1].length,
+            title,
+            numbered: NUM.test(title) && /^(?:section\s+)?\d+(?:[.)]|\s*[—–:-]|\s)/i.test(title),
+        });
+    });
+    const numberedAt = (lv) => heads.filter((h) => h.level === lv && h.numbered).length;
+    // The level with the numbered headings (## wins a tie: a capture brief never nests).
+    const level = numberedAt(2) >= numberedAt(3) ? (numberedAt(2) ? 2 : numberedAt(3) ? 3 : 2) : 3;
+    const use = heads.some((h) => h.numbered && h.level === level)
+        ? heads.filter((h) => h.numbered && h.level === level)
+        : heads.filter((h) => h.level === 2 && !/^pmm brief\b/i.test(h.title));
+    return use.map((h, k) => {
+        const end = Math.min(k + 1 < use.length ? use[k + 1].i : lines.length, heads.find((x) => x.i > h.i && x.level <= h.level)?.i ?? lines.length);
+        const body = lines.slice(h.i + 1, end).join('\n');
+        const n = Number(NUM.exec(h.title)?.[1] ?? k + 1);
+        const title = h.title.replace(NUM, '');
+        return { n, title, text: body, items: itemCount(`${title}\n${body}`) };
+    });
+}
+const NUMBER_WORDS = {
+    two: 2,
+    three: 3,
+    four: 4,
+    five: 5,
+    six: 6,
+    seven: 7,
+    eight: 8,
+    nine: 9,
+    ten: 10,
+    twelve: 12,
+};
+/** The groups of a capture --brief "**Layout (derived):** section · 6 accordion · 2 tabs" line, outermost first. */
+export function derivedLayout(body) {
+    const d = /^\s*-\s+\*\*Layout \(derived\):\*\*\s*(.*)$/m.exec(body)?.[1] ?? '';
+    const parts = d.split('·').map((x) => x.trim());
+    const groups = parts
+        .slice(1)
+        .map((p) => /^(\d+)\s+([a-z]+)/.exec(p))
+        .filter((m) => !!m)
+        .map((m) => ({ n: Number(m[1]), kind: m[2] }));
+    return { top: parts[0] ?? '', groups };
+}
+/**
+ * A `pnpm capture --brief` section (it has a "**Layout (derived):**" line), sized by its OUTER structure (K8): the first
+ * derived group that is not a logo row and is not media-only — "6 accordion · 2 tabs" is 6 (the 2-tab carousel inside
+ * one panel is content), "4 logos · 3 cards" is 3, "4 cards · 3 cards" of bare images (floating cards) is no item list.
+ * Items blocks are never summed (a desktop and a mobile copy of the same 3 cards are 3), nested Items blocks (bullets /
+ * tags inside an item) don't count. No usable group: the first top-level Items block whose items carry text; no Items
+ * block: repeated same-label CTAs (one per card) give the count.
+ */
+/** The top-level "**Items (N, kind):**" blocks of a capture --brief section, with how many of their items carry text. */
+export function itemBlocks(body) {
+    const lines = body.split('\n');
+    const blocks = [];
+    for (let i = 0; i < lines.length; i++) {
+        const m = /^-\s+\*\*Items \((\d+), ([a-z]+)\b[^)]*\):\*\*(.*)$/.exec(lines[i]);
+        if (!m)
+            continue;
+        let text = 0;
+        // K10: capture --brief writes a group of bare labels or media on one line ("1. **IT** · 2. **HR**").
+        const inline = m[3].trim();
+        if (inline)
+            for (const it of inline.split(/\s·\s(?=\d+\.\s)/))
+                if (!/^\d+\.\s+(?:img|video|image|svg|lottie)\b/i.test(it.trim()))
+                    text++;
+        for (let j = i + 1; j < lines.length && !/^-\s/.test(lines[j]) && !/^#/.test(lines[j]); j++) {
+            const it = /^\s{2,3}\d+\.\s+(.*)$/.exec(lines[j]);
+            if (it && !/^(?:img|video|image|svg|lottie)\b/i.test(it[1].trim()))
+                text++;
+        }
+        blocks.push({ n: Number(m[1]), kind: m[2], text });
+    }
+    return blocks;
+}
+/**
+ * K10 (`policy.mode-b.two-item-groups`): a brief section that holds two different item groups with copy — e.g. "4 tabs"
+ * and "3 cards" in one live band. A desktop / mobile copy of one group (same count and kind), media-only groups, logo rows
+ * and a 2-slide carousel control inside a panel are not a second group.
+ */
+export function twoItemGroups(body) {
+    const real = itemBlocks(body).filter((x) => x.kind !== 'logos' && x.n >= 2 && x.text >= 2 && !(x.kind === 'tabs' && x.n === 2));
+    for (let i = 0; i + 1 < real.length; i++) {
+        const a = real[i];
+        const b = real.slice(i + 1).find((x) => x.kind !== a.kind || x.n !== a.n);
+        if (b)
+            return { a: { n: a.n, kind: a.kind }, b: { n: b.n, kind: b.kind } };
+    }
+    return null;
+}
+export function captureItemCount(body) {
+    const lines = body.split('\n');
+    const blocks = itemBlocks(body);
+    for (const g of derivedLayout(body).groups) {
+        if (g.kind === 'logos' || g.n < 2)
+            continue;
+        const b = blocks.find((x) => x.kind === g.kind && x.n === g.n) ?? blocks.find((x) => x.kind === g.kind);
+        if (b && b.text === 0)
+            continue; // media-only: floating cards, tab panels, decorative avatars
+        if (!b && !['tabs', 'accordion', 'list'].includes(g.kind))
+            continue;
+        return g.n;
+    }
+    const withText = blocks.filter((b) => b.text > 0 && b.kind !== 'logos');
+    if (withText.length)
+        return withText[0].n >= 2 ? withText[0].n : null;
+    if (blocks.length)
+        return null;
+    const ctas = new Map();
+    for (const l of lines) {
+        const c = /^-\s+\*\*CTA:\*\*\s*(.+?)\s*→/.exec(l)?.[1];
+        if (c)
+            ctas.set(c.toLowerCase(), (ctas.get(c.toLowerCase()) ?? 0) + 1);
+    }
+    const rep = Math.max(0, ...ctas.values());
+    return rep >= 2 ? rep : null;
+}
+/** A capture --brief section body (`pnpm capture --brief` output). */
+export const isCaptureSection = (body) => /^\s*-\s+\*\*Layout \(derived\):\*\*/m.test(body);
+function itemCount(body) {
+    if (isCaptureSection(body))
+        return captureItemCount(body);
+    const lines = body.split('\n');
+    const rows = lines.filter((l) => /^\s*\|/.test(l) && !/^\s*\|?\s*:?-{3,}/.test(l));
+    const tableRows = rows.length > 1 ? rows.length - 1 : 0;
+    // Numbered lists: the longest run (a list restarts at 1), never the total — two lists of 3 are 3 items, not 6 (K5b F3).
+    let numbered = 0;
+    let runN = 0;
+    for (const l of lines) {
+        const m = /^\s{0,4}(\d+)[.)]\s+\S/.exec(l);
+        if (!m)
+            continue;
+        runN = Number(m[1]) === 1 ? 1 : runN + 1;
+        numbered = Math.max(numbered, runN);
+    }
+    // Bold-led bullets are items ("- **Bring your own agent** — …"); a bold label ending in ":" is a field ("- **H2:** …").
+    const boldItems = lines.filter((l) => /^\s*[-*]\s+\*\*([^*]+?)\*\*\s*(?:[—–-]|:)\s*\S/.test(l) &&
+        !/^\s*[-*]\s+\*\*[^*]*:\*\*/.test(l)).length;
+    let dotted = 0;
+    for (const l of lines) {
+        if (!/\b(?:tabs?|chips?|logos?|items?|categories|cards?)\b/i.test(l))
+            continue;
+        const parts = l.split('·').length;
+        if (parts > dotted && parts > 2)
+            dotted = parts;
+        const commas = /:\s*([^.]+)$/.exec(l)?.[1]?.split(',').length ?? 0;
+        if (/logos?/i.test(l) && commas > dotted && commas > 2)
+            dotted = commas;
+    }
+    // Nested "Title — description" bullets under a label line ("- **Accordion items:**" / "  - Research Agents — …").
+    let nested = 0;
+    let run = 0;
+    for (const l of lines) {
+        if (/^\s{2,}[-*]\s+(?:\([^)]{1,20}\)\s*)?[^*:]{2,60}?\s[—–]\s\S/.test(l))
+            run++;
+        else if (!/^\s{4,}/.test(l))
+            run = 0;
+        nested = Math.max(nested, run);
+    }
+    // "- Card A (…)", "- Tab 2:"
+    const lettered = lines.filter((l) => /^\s*[-*]\s+(?:\*\*)?(?:Card|Tab|Item|Step|Panel)\s+(?:[A-Z]|\d{1,2})\b/.test(l)).length;
+    // "Two feature cards", "6 features in a 3×2 grid"
+    const counted = /\b(two|three|four|five|six|seven|eight|nine|ten|twelve|\d{1,2})\s+(?:[a-z-]+\s+){0,2}?(?:cards?|items?|tabs?|steps?|pillars?|columns?|features?|stats?|quotes?|categories)\b/i.exec(body)?.[1];
+    const word = counted
+        ? /^\d+$/.test(counted)
+            ? Number(counted)
+            : NUMBER_WORDS[counted.toLowerCase()]
+        : 0;
+    const n = Math.max(tableRows, numbered, boldItems >= 2 ? boldItems : 0, dotted, nested >= 2 ? nested : 0, lettered >= 2 ? lettered : 0, word);
+    return n >= 2 ? n : null;
+}
+const STAT_NAME = /^[$€£]?\d[\d.,]*\s*(?:%|[KMB]\+?|x|\+)?$/i;
+export function itemShape(body) {
+    const lines = body.split('\n');
+    const top = (l) => /^\s{2,3}\d+\.\s+(.*)$/.exec(l) ?? /^\s?\d+[.)]\s+(.*)$/.exec(l);
+    const out = {
+        n: 0,
+        named: 0,
+        bullets: 0,
+        tags: 0,
+        media: 0,
+        rich: 0,
+        stats: 0,
+        quotes: 0,
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const m = top(lines[i]);
+        if (!m)
+            continue;
+        const nested = [];
+        for (let j = i + 1; j < lines.length && !top(lines[j]) && !/^-\s|^#/.test(lines[j]); j++)
+            nested.push(lines[j]);
+        const line = m[1];
+        const name = /^\*\*(.+?)\*\*/.exec(line)?.[1]?.trim() ?? '';
+        const nest = nested.join('\n');
+        const bullets = /\*\*Items \(\d+, list\b/.test(nest) || /\bbullets?\s*:/i.test(line);
+        const tags = /\*\*Items \(\d+, (?:labels|tags)\b/.test(nest) || /\btags?\s*:/i.test(line);
+        const media = /\b(?:video|img|image)\b/i.test(line);
+        out.n++;
+        if (name)
+            out.named++;
+        if (bullets)
+            out.bullets++;
+        if (tags)
+            out.tags++;
+        if (media)
+            out.media++;
+        if (name && (bullets || tags || media || /\*\*\s+[—–]\s+\S/.test(line)))
+            out.rich++;
+        if (STAT_NAME.test(name) || /^\s*(?:\*\*)?stat\b/i.test(line))
+            out.stats++;
+        else if ((name.length >= 30 && /[.!?"”]$/.test(name)) || /^\s*(?:\*\*)?quote\b/i.test(line))
+            out.quotes++;
+    }
+    return out;
+}
+/** Agent cards: named items, most with bullets and media (tags are optional per card) — `RevealCard`'s shape. */
+export const isAgentCards = (sh) => sh.n >= 2 && sh.named >= sh.n * 0.8 && sh.bullets >= sh.n * 0.5 && sh.media >= sh.n * 0.5;
+/**
+ * K11 (`policy.mode-b.hero-item-split`): the hero's item group when no HeaderSection slot holds it — items with copy
+ * of their own (a description, bullets, tags or per-item media). Bare labels (the `options` row), logos and media-only
+ * items are not one.
+ */
+export function heroItemGroup(sec) {
+    if (sec.items == null || sec.items < 2)
+        return null;
+    const sh = itemShape(sec.text);
+    if (sh.rich < 2 || sh.rich < sh.n * 0.5)
+        return null;
+    // Hero-level media: a top-level Media / Image / Video line (item media sits on the item lines).
+    const heroMedia = /^-\s+\*\*(?:Media|Image|Visual|Video|Hero (?:image|media|video))\b/im.test(sec.text);
+    return { n: sec.items, agentCards: isAgentCards(sh), heroMedia };
+}
+/** K11 B2: the top-level items of a section as `{ name, desc }` — the bold name and the copy after the first " — ". */
+export function textItems(body) {
+    const out = [];
+    for (const l of body.split('\n')) {
+        const m = /^\s{2,3}\d+\.\s+(.*)$/.exec(l) ?? /^\s?\d+[.)]\s+(.*)$/.exec(l);
+        if (!m)
+            continue;
+        const name = /^\*\*(.+?)\*\*/.exec(m[1])?.[1]?.trim() ?? '';
+        const desc = (/^\*\*.+?\*\*\s+[—–]\s+(.*)$/.exec(m[1])?.[1] ?? '')
+            .split(/\s[—–]\s(?=(?:CTA|img|video|image)\b)/)[0]
+            .replace(/\s*_\([^)]*\)_\s*$/, '')
+            .trim();
+        out.push({ name, desc });
+    }
+    return out;
+}
+/**
+ * K11 B2 (`policy.tabs.layout-by-count`, vertical item list): a section whose items stack in one vertical list, each
+ * showing its own copy and expanding in place — an accordion, or what a capture labels "tabs" when the tab items carry
+ * their description (a horizontal tab row is a group of bare labels, its copy sits in the panels). It needs a visual:
+ * one per item (on the item lines, or a media-only group of the same count that swaps per item) → `item`; one shared
+ * section visual → `shared`. Not one: nested item groups (an accordion driving a card carousel), no visual, an FAQ (B3:
+ * `faqSection`: most item names are questions, or the title says FAQ — even with a section image), a layout line that
+ * says the tabs sit in a horizontal row (B3).
+ */
+export function verticalItemList(sec) {
+    const n = sec.items;
+    if (n == null || n < 2)
+        return null;
+    // B3: an FAQ is an accordion of questions, even with a section image — FaqSection, not a FeaturesSection accordion.
+    if (faqSection(sec))
+        return null;
+    const body = sec.text;
+    if (/^\s{2,}-\s+\*\*Items \(/m.test(body))
+        return null;
+    let labelled;
+    let list;
+    // B3 (N2): the brief's layout line says the tabs sit in a row → a horizontal tab row, even when every tab carries a
+    // description + image in one block (a capture emits a bare-label strip then the panels; a hand-written brief may not).
+    const layoutCue = body
+        .split('\n')
+        .filter((l) => /^-\s+\*\*(?:Layout|Pattern|Interactive|Interaction|Format)\b/i.test(l))
+        .join(' ');
+    if (/\bhorizontal\b|\btab (?:row|strip|bar)\b|\btabs? (?:in|on) a row\b/i.test(layoutCue))
+        return null;
+    if (isCaptureSection(body)) {
+        const outer = derivedLayout(body).groups.find((g) => g.kind !== 'logos' && g.n >= 2);
+        if (!outer || (outer.kind !== 'tabs' && outer.kind !== 'accordion') || outer.n !== n)
+            return null;
+        labelled = outer.kind;
+        // The first Items block of that kind is the visible list; a bare-label first block is a horizontal tab strip.
+        const lines = body.split('\n');
+        const at = lines.findIndex((l) => new RegExp(`^-\\s+\\*\\*Items \\(${n}, ${outer.kind}\\b`).test(l));
+        if (at < 0)
+            return null;
+        const block = [];
+        for (let j = at + 1; j < lines.length && !/^-\s|^#/.test(lines[j]); j++)
+            block.push(lines[j]);
+        list = block.join('\n');
+    }
+    else {
+        const cue = body
+            .split('\n')
+            .filter((l) => !/\bmobile\b/i.test(l) &&
+            /\b(?:interactive|layout|pattern|interaction|format)\b/i.test(l))
+            .join(' ');
+        if (!/\baccordion\b|\bvertical (?:tabs?|list)\b|\bexpand(?:s|able)?\b/i.test(cue))
+            return null;
+        labelled = /\btabs?\b/i.test(cue) ? 'tabs' : 'accordion';
+        list = body;
+    }
+    const items = textItems(list);
+    if (items.length < 2 ||
+        items.filter((x) => x.name && x.desc.length >= 20).length < items.length * 0.8)
+        return null;
+    const sh = itemShape(list);
+    const mediaGroup = itemBlocks(body).some((b) => b.n === n && b.text === 0);
+    const perItem = sh.media >= items.length * 0.5 ||
+        mediaGroup ||
+        (!isCaptureSection(body) &&
+            /\b(?:per|each|every) (?:item|tab|step)\b[^.\n]{0,40}\b(?:visual|image|media|screenshot|video)|\b(?:visual|image|media|screenshot)s? (?:swap|switch|change)s?\b/i.test(body));
+    const shared = hasSectionVisual(body);
+    if (!perItem && !shared)
+        return null;
+    return { n, visual: perItem ? 'item' : 'shared', labelled };
+}
+/**
+ * K11 B3: an FAQ — most item names are questions (whatever the title says), or the title says FAQ / frequently asked.
+ * A features title that mentions "questions" over non-question items is not one.
+ */
+export function faqSection(sec) {
+    const items = textItems(sec.text);
+    if (items.length >= 2 && items.filter((x) => /\?\s*$/.test(x.name)).length > items.length / 2)
+        return true;
+    return /\bfaqs?\b|\bfrequently asked\b/i.test(sec.title);
+}
+/** A section-level visual line (`- **Image:** …`, `- **Video:** …`): one visual for the whole section. */
+export const hasSectionVisual = (body) => /^-\s+\*\*(?:Media|Image|Visual|Video|Screenshot)\b/im.test(body);
+/**
+ * K11 B3 (`policy.features.layout-diversity`): the accordion + media family — accordion rows beside a media panel.
+ * The benchmark accepts any of them for "vertical accordion + media panel" (`policy.benchmark.rubric-layout`);
+ * side-by-side / side-by-side-lines show the active item's own media, accordion-media-right one shared visual.
+ */
+export const ACCORDION_MEDIA_FAMILY = [
+    'layout.FeaturesSection.side-by-side',
+    'layout.FeaturesSection.side-by-side-lines',
+    'layout.FeaturesSection.accordion-media-right',
+];
+/**
+ * K11 B3: two FeaturesSections on one page never share a layout (`policy.features.layout-diversity`). When the route's
+ * first pick for a section is an accordion + media layout an earlier section already took first, the later section
+ * lists the next one of the family nobody took first: `side-by-side-lines`, then `side-by-side`, then
+ * `accordion-media-right` when it also has a shared section visual. A section with only a shared visual takes
+ * `accordion-media-right` or nothing (side-by-side / -lines show per-item media). Rows are changed in place; returns a
+ * note per changed row index (`[§ of the earlier section, from, to]`), or `[§, from, null]` when no family layout is left.
+ */
+export function diversifyAccordionFamily(rows, byId, skip = () => false) {
+    const notes = new Map();
+    const taken = new Map();
+    rows.forEach((r, i) => {
+        if (skip(i))
+            return;
+        const at = r.candidates.findIndex((c) => !c.part);
+        const top = r.candidates[at];
+        if (!top || !ACCORDION_MEDIA_FAMILY.includes(top.id))
+            return;
+        const prev = taken.get(top.id);
+        if (prev == null) {
+            taken.set(top.id, r.section.n);
+            return;
+        }
+        // A shared visual only (no per-item media): accordion-media-right or nothing — side-by-side(-lines) shows per-item media.
+        const v = verticalItemList(r.section);
+        const sharedOnly = v
+            ? v.visual === 'shared'
+            : hasSectionVisual(r.section.text) && itemShape(r.section.text).media === 0;
+        const order = sharedOnly
+            ? ['layout.FeaturesSection.accordion-media-right']
+            : [
+                'layout.FeaturesSection.side-by-side-lines',
+                'layout.FeaturesSection.side-by-side',
+                ...(hasSectionVisual(r.section.text)
+                    ? ['layout.FeaturesSection.accordion-media-right']
+                    : []),
+            ];
+        const next = order.find((id) => !taken.has(id) && byId.has(id) && fitOf(byId.get(id), r.section.items) !== 'over');
+        if (!next) {
+            notes.set(i, { prev, from: top.id, to: null });
+            return;
+        }
+        // The taken layout leaves the row (the note names it); the next family layout takes its place.
+        const have = r.candidates.findIndex((c) => c.id === next);
+        const row = have >= 0 ? r.candidates[have] : candidateRow(byId.get(next), r.section);
+        r.candidates = r.candidates.filter((c, k) => k !== at && k !== have);
+        r.candidates.splice(at, 0, row);
+        taken.set(next, r.section.n);
+        notes.set(i, { prev, from: top.id, to: next });
+    });
+    return notes;
+}
+/**
+ * K11 F1 (`policy.layout.accordion-carousel`, C42): an accordion of categories that drives a card carousel — selecting a
+ * category swaps a row of cards that carry their own copy. A capture's outer group is the accordion and a later group
+ * holds (or nests) cards with a name + description; a hand-written brief's layout line names an accordion and the
+ * carousel / cards it drives. `cards`: the cards with copy (a carousel control such as "Go to last slide" is not one).
+ */
+export function accordionCarousel(sec) {
+    const n = sec.items;
+    if (n == null || n < 2 || faqSection(sec))
+        return null;
+    const lines = sec.text.split('\n');
+    let after;
+    if (isCaptureSection(sec.text)) {
+        const outer = derivedLayout(sec.text).groups.find((g) => g.kind !== 'logos' && g.n >= 2);
+        if (!outer || outer.kind !== 'accordion' || outer.n !== n)
+            return null;
+        const at = lines.findIndex((l) => new RegExp(`^-\\s+\\*\\*Items \\(${n}, accordion\\b`).test(l));
+        if (at < 0)
+            return null;
+        // A desktop / mobile copy of the accordion (same count and kind) is not the carousel: skip those blocks.
+        const same = new RegExp(`^-\\s+\\*\\*Items \\(${n}, accordion\\b`);
+        after = [];
+        let skipping = true;
+        for (let j = at; j < lines.length; j++) {
+            if (/^-\s|^#/.test(lines[j]))
+                skipping = same.test(lines[j]);
+            if (!skipping)
+                after.push(lines[j]);
+        }
+    }
+    else {
+        const cue = lines
+            .filter((l) => !/\bmobile\b/i.test(l) &&
+            /\b(?:interactive|layout|pattern|interaction|format)\b/i.test(l))
+            .join(' ');
+        if (!/\baccordion\b/i.test(cue) ||
+            !/\b(?:carousel|slider|cards)\b/i.test(cue) ||
+            !/\b(?:driv|swap|switch|select|chang|control)\w*/i.test(cue))
+            return null;
+        after = lines;
+    }
+    const named = after
+        .map((l) => /^\s*\d+[.)]\s+\*\*(.+?)\*\*\s+[—–]\s+(.*)$/.exec(l))
+        .filter((m) => !!m && !/^CTA\b/.test(m[2].trim()) && m[2].split(/\s[—–]\s/)[0].trim().length >= 20);
+    // A hand-written brief lists the categories and the cards together: the cards are the named items past the categories.
+    if (isCaptureSection(sec.text))
+        return named.length >= 2 ? { n, cards: named.length } : null;
+    return { n, cards: Math.max(0, named.length - n) };
+}
+/** K11 F1: the §Nb card section of an accordion-driven carousel — cards with copy keep it (name, description, CTA, image). */
+export const accordionCarouselCards = (cards) => cards > 5 ? 'layout.CardsSection.horizontal-reveal' : 'layout.CardsSection.side-by-side';
+/**
+ * K11 F1 (`policy.layout.accordion-carousel`): the one ordered answer for an accordion that drives a card carousel.
+ * 1. `tab-cards-carousel` + `[GAP]` when no other section on the page takes `tab-cards-carousel` first; 2. otherwise the
+ * no-repeat fallback `accordion-media-right` (the categories + one shared visual), same `[GAP]`; the cards with copy go to
+ * §Nb directly below (`accordionCarouselCards`). Rows change in place; returns per row the § that holds tab-cards-carousel
+ * (or null) and the card section.
+ */
+/** The ordered answer's two layouts: step 1, then the no-repeat fallback (kb/inventory/shape-layout.json `accordion-driving-card-carousel`). */
+export const ACCORDION_CAROUSEL_LAYOUTS = [
+    'layout.FeaturesSection.tab-cards-carousel',
+    'layout.FeaturesSection.accordion-media-right',
+];
+export function resolveAccordionCarousels(rows, byId, skip = () => false) {
+    const [TCC, AMR] = ACCORDION_CAROUSEL_LAYOUTS;
+    const ac = rows.map((r, i) => (skip(i) ? null : accordionCarousel(r.section)));
+    const takenBy = rows.find((r, i) => !skip(i) && !ac[i] && r.candidates.find((c) => !c.part)?.id === TCC)
+        ?.section.n ?? null;
+    const notes = new Map();
+    // A tab row already on tab-cards-carousel (or an earlier accordion carousel that took it) sends this one to the fallback.
+    let tccBy = takenBy;
+    rows.forEach((r, i) => {
+        const a = ac[i];
+        if (!a)
+            return;
+        const layout = tccBy == null ? TCC : AMR;
+        const by = tccBy;
+        if (tccBy == null)
+            tccBy = r.section.n;
+        const first = r.candidates.find((c) => c.id === layout) ??
+            (byId.has(layout) ? candidateRow(byId.get(layout), r.section) : null);
+        const rest = r.candidates
+            .filter((c) => c.id !== layout && !c.part && !(layout === AMR && c.id === TCC))
+            .slice(0, 1);
+        const nb = a.cards >= 2 && byId.has(accordionCarouselCards(a.cards))
+            ? accordionCarouselCards(a.cards)
+            : null;
+        const nbRow = nb
+            ? { ...candidateRow(byId.get(nb), { ...r.section, items: a.cards }), part: 'b' }
+            : null;
+        r.candidates = [...(first ? [first] : []), ...rest, ...(nbRow ? [nbRow] : [])];
+        notes.set(i, { takenBy: layout === AMR ? by : null, layout, cards: a.cards, nb });
+    });
+    return notes;
+}
+/**
+ * K11 F1 (`policy.layout.statement-stand-in`): a statement with media (heading + body [+ CTA] + a visual, no items) has
+ * no section of its own; its stand-in is a 1-item FeaturesSection. Two FeaturesSections on a page never share a layout
+ * (`policy.features.layout-diversity`), so each statement takes the next stand-in no other FeaturesSection on the page
+ * took first: `stacked-rows`, then `stacked-media-left`. Rows change in place; returns per moved row the § that holds
+ * the earlier stand-in, or `to: null` when none is left.
+ */
+export const STATEMENT_STANDINS = [
+    'layout.FeaturesSection.stacked-rows',
+    'layout.FeaturesSection.stacked-media-left',
+];
+export function diversifyStatements(rows, byId, isStatement, skip = () => false) {
+    const notes = new Map();
+    const taken = new Map();
+    rows.forEach((r, i) => {
+        const top = r.candidates.find((c) => !c.part)?.id;
+        if (!skip(i) &&
+            !isStatement(i) &&
+            top?.startsWith('layout.FeaturesSection.') &&
+            !taken.has(top))
+            taken.set(top, r.section.n);
+    });
+    rows.forEach((r, i) => {
+        if (skip(i) || !isStatement(i))
+            return;
+        const next = STATEMENT_STANDINS.find((id) => !taken.has(id) && byId.has(id));
+        if (!next) {
+            notes.set(i, { prev: taken.get(STATEMENT_STANDINS[0]) ?? null, to: null });
+            return;
+        }
+        const prev = next === STATEMENT_STANDINS[0] ? null : (taken.get(STATEMENT_STANDINS[0]) ?? null);
+        const have = r.candidates.find((c) => c.id === next) ?? candidateRow(byId.get(next), r.section);
+        r.candidates = [
+            have,
+            ...r.candidates.filter((c) => c.id !== next && !STATEMENT_STANDINS.includes(c.id)),
+        ].slice(0, 2);
+        taken.set(next, r.section.n);
+        notes.set(i, { prev, to: next });
+    });
+    return notes;
+}
+/**
+ * K11 F1 (`policy.benchmark.rubric-layout-hero`): the hero's direction. A layout cue in the brief (split / side by side /
+ * copy left / media right vs centered / text above / media below / text-only) decides; else a selector hero — a row of
+ * bare tab labels plus a visual per tab (a media-only group of the same count; the live Homepage and work-management
+ * heroes) — reads as split (copy + tabs left, visual right); else a hero with one visual takes the chooser default
+ * `centered-image` (`policy.layout.chooser.HeaderSection`). No hero visual → null.
+ */
+export function heroDirection(sec) {
+    const cue = sec.text
+        .split('\n')
+        .filter((l) => !/\bmobile\b/i.test(l) &&
+        !/^\s*-\s+\*\*(?:Headline|Body|Subheadline|Description|CTA|Eyebrow|Items \(|Layout \(derived\))/i.test(l) &&
+        !/^\s+\d+[.)]\s/.test(l))
+        .join(' ')
+        .replace(/https?:\/\/\S+|\bCDN2?\/\S+|\S+\.(?:avif|png|jpe?g|webp|mp4|webm|svg|gif)\b/gi, ' ');
+    if (/\btext[- ]only\b|\bno (?:hero )?(?:media|visual|image)\b/i.test(cue))
+        return { dir: 'text', why: 'cue' };
+    if (/\bsplit\b|\bside[- ]by[- ]side\b|\btwo[- ]column\b|\b(?:copy|text|headline)\s+(?:on\s+the\s+)?left\b|\b(?:media|image|visual|video|screenshot|photo)\s+(?:on\s+the\s+)?right\b/i.test(cue))
+        return { dir: 'split', why: 'cue' };
+    if (/\bcent(?:er|re)d?\b|\b(?:copy|text)\s+above\b|\b(?:media|image|visual|video|screenshot)\s+below\b/i.test(cue))
+        return { dir: 'centered', why: 'cue' };
+    const blocks = itemBlocks(sec.text);
+    const labels = blocks.find((b) => b.n >= 2 && b.text === b.n && itemShape(sec.text).rich === 0);
+    if (labels && blocks.some((b) => b !== labels && b.n === labels.n && b.text === 0))
+        return { dir: 'split', why: 'selector' };
+    if (hasSectionVisual(sec.text) || blocks.some((b) => b.text === 0))
+        return { dir: 'centered', why: 'default' };
+    return null;
+}
+export const HERO_FAMILIES = {
+    split: [
+        'split',
+        'split-full-image',
+        'split-mosaic',
+        'split-strip',
+        'split-search',
+        'floating-left',
+    ].map((l) => `layout.HeaderSection.${l}`),
+    centered: ['centered-image', 'left-center-image', 'centered-strips'].map((l) => `layout.HeaderSection.${l}`),
+    text: ['layout.HeaderSection.text-only'],
+};
+/**
+ * K11 B2: plain text cards — every item a name + description, no media, bullets, tags, stats or quotes, in a section
+ * with no visual and no tab / accordion structure ("Full control": 6 icon + title + description cards). Their layout
+ * is an icon list, not a card carousel. `short`: the descriptions fit `BulletItem` (title ≤ 18c, description ≤ 84c).
+ */
+export function textCards(sec) {
+    const n = sec.items;
+    if (n == null || n < 4 || n > 8)
+        return null;
+    if (/\b(?:faq|questions?|testimonials?|quotes?|stats?|numbers?|logos?|pricing)\b/i.test(sec.title))
+        return null;
+    const shape = sectionShape(sec);
+    if (shape.tabs || shape.accordion || shape.hasMedia || shape.itemCta)
+        return null;
+    if (/^\s{2,}-\s+\*\*Items \(/m.test(sec.text))
+        return null;
+    const items = textItems(sec.text);
+    const sh = itemShape(sec.text);
+    if (items.length !== n || sh.media || sh.bullets || sh.tags || sh.stats || sh.quotes)
+        return null;
+    if (items.some((x) => !x.name || x.desc.length < 20))
+        return null;
+    const short = items.filter((x) => x.name.length <= 18 && x.desc.length <= 84).length >= n * 0.8;
+    return { n, short };
+}
+export const SHAPE_PRIORS = [
+    {
+        name: 'agent cards (name + bullets + tags + media)',
+        test: (_s, sh) => isAgentCards(sh),
+        layout: 'layout.CardsSection.horizontal-reveal',
+        factor: 3,
+        unit: 'policy.mode-b.hero-item-split',
+    },
+    // B2: a vertical list whose items expand in place, a visual per item → side-by-side (accordion + per-item media
+    // panel); one shared visual → accordion-media-right. Never tabs-* (the benchmark scores tabs-* −15 here).
+    {
+        name: 'vertical item list + a visual per item',
+        test: (s) => {
+            const v = verticalItemList(s);
+            return !!v && v.visual === 'item' && v.n <= 5;
+        },
+        layout: 'layout.FeaturesSection.side-by-side',
+        factor: 4,
+        unit: 'policy.tabs.layout-by-count',
+    },
+    {
+        name: 'vertical item list + one shared visual (or a visual per item past 5)',
+        test: (s) => {
+            const v = verticalItemList(s);
+            return !!v && (v.visual === 'shared' || v.n > 5);
+        },
+        layout: 'layout.FeaturesSection.accordion-media-right',
+        factor: 4,
+        unit: 'policy.tabs.layout-by-count',
+    },
+    // B3: question items under a title that doesn't say FAQ (TITLE_PRIORS handles those) → FaqSection, even with an image.
+    {
+        name: 'FAQ by its questions (title not FAQ)',
+        test: (s) => faqSection(s) && !/\bfaqs?\b|\bquestions\b/i.test(s.title),
+        layout: 'layout.FaqSection.centered',
+        factor: 4,
+        unit: 'section.FaqSection.usage',
+    },
+    {
+        name: 'FAQ by its questions, side-by-side (title not FAQ)',
+        test: (s) => faqSection(s) && !/\bfaqs?\b|\bquestions\b/i.test(s.title),
+        layout: 'layout.FaqSection.side-by-side',
+        factor: 3,
+        unit: 'section.FaqSection.usage',
+    },
+    // B2: 4–8 icon + title + description cards with no media → the icon list, not a card carousel.
+    {
+        name: 'text cards (name + description, no media)',
+        test: (s) => !!textCards(s),
+        layout: 'layout.FeaturesSection.split-icon-list',
+        factor: 4,
+        unit: 'policy.layout.chooser.FeaturesSection',
+    },
+    {
+        name: 'short text cards (fit BulletItem limits)',
+        test: (s) => !!textCards(s)?.short,
+        layout: 'layout.BulletsSection.icons',
+        factor: 2.5,
+        unit: 'section.BulletsSection.usage',
+    },
+    // B2: quote cards and stat cards mixed → mixed-stat-and-quote (carousel-case-study needs a stat on every card and
+    // renders no section CTA).
+    {
+        name: 'stat + quote cards',
+        test: (_s, sh) => sh.stats >= 1 && sh.quotes >= 1,
+        layout: 'layout.TestimonialsSection.mixed-stat-and-quote',
+        factor: 4,
+        unit: 'policy.layout.chooser.TestimonialsSection',
+    },
+];
+/** K11 (`policy.mode-b.precedence`, tint exception 2): layouts whose cards are always grey (grey-300) and take no tint. */
+export const GREY_CARD_LAYOUTS = new Set([
+    'layout.TestimonialsSection.mixed-stat-and-quote',
+    'layout.TestimonialsSection.carousel-with-stat',
+]);
+/** The live page shows the section on a grey band: capture --brief "bg rgb(…)" grey, or a hand-written grey / muted cue. */
+export function greyBand(sec) {
+    const rgb = /\bbg rgb\((\d+),\s*(\d+),\s*(\d+)\)/.exec(sec.text);
+    if (rgb) {
+        const c = rgb.slice(1, 4).map(Number);
+        return Math.min(...c) >= 225 && Math.max(...c) <= 250 && Math.max(...c) - Math.min(...c) <= 10;
+    }
+    return /\b(?:grey|gray|muted)\s+(?:band|background|bg|section)\b|\btheme:?\s*`?muted\b/i.test(sec.text);
+}
+export function sectionShape(sec) {
+    const t = `${sec.title}\n${sec.text}`;
+    const special = /\b(?:logos?|testimonials?|quotes?|faq|questions?|stats?|numbers?|integrations?|badges?|g2|pricing|form)\b/i.test(sec.title);
+    const der = derivedLayout(sec.text);
+    const outer = der.groups.find((g) => g.kind !== 'logos' && g.n === sec.items)?.kind ?? '';
+    // Interaction cues of a hand-written brief ("Interactive: tabs", "7 tabs", "Layout: accordion"), mobile lines aside.
+    const cueLines = sec.text
+        .split('\n')
+        .filter((l) => !/\bmobile\b/i.test(l) &&
+        /\b(?:interactive|layout|pattern|interaction|format)\b|\d+\s+(?:tabs|accordion)/i.test(l))
+        .join(' ');
+    const logoLine = /\*\*Logos \((\d+)\):\*\*\s*(.*)$/m.exec(sec.text);
+    const logos = logoLine
+        ? Number(logoLine[1])
+        : (der.groups.filter((g) => g.kind === 'logos').map((g) => g.n)[0] ?? null);
+    const hasBody = /^\s*-\s+\*\*(?:Body|Subheadline|Description)\b/im.test(sec.text);
+    const hasCta = /\*\*\s*cta\b|^\s*-\s*cta\b/im.test(t);
+    const strip = logos != null &&
+        sec.items == null &&
+        !hasBody &&
+        !hasCta &&
+        (der.top === 'logos' || der.top === '' || /\blogos?\b/i.test(sec.title));
+    const integ = /\bintegrat|\bconnect (?:all )?your (?:tools|apps)|\bapps?\b|\btools\b/i.test(`${sec.title} ${logoLine?.[2] ?? ''}`);
+    const vis = /^\s*-\s+\*\*Visible:\*\*\s*(mobile|desktop) only/im
+        .exec(sec.text)?.[1]
+        ?.toLowerCase();
+    const vertical = !!verticalItemList(sec);
+    return {
+        statement: sec.items == null && !special && !strip,
+        grid: /\bgrid\b|\d\s*[×x]\s*\d|\bcolumns?\b|\bicons?\b|\bicon\s*·/i.test(t
+            .split('\n')
+            .filter((l) => !/mobile/i.test(l))
+            .join('\n')),
+        hasCta,
+        hasMedia: /\b(?:media|visual|image|video|illustration|screenshot|diagram)\b|\.(?:avif|png|jpe?g|webp|mp4|webm)\b/i.test(t),
+        ...perItem(sec),
+        // K11 B2: a vertical item list (items show their copy and expand in place) is an accordion, whatever the capture calls it.
+        tabs: !vertical && (outer === 'tabs' || (!outer && /\btabs?\b/i.test(cueLines))),
+        accordion: vertical || outer === 'accordion' || (!outer && /\baccordion\b/i.test(cueLines)),
+        logoStrip: strip ? (integ ? 'integration' : 'customer') : null,
+        logos,
+        caseStudy: (sec.text.match(/case[- ]stud(?:y|ies)/gi) ?? []).length >= 2,
+        visibleAt: vis ?? null,
+        variantOf: Number(/responsive variant of §(\d+)/i.exec(sec.text)?.[1] ?? '') || null,
+    };
+}
+const sigWords = (s) => new Set(s
+    .toLowerCase()
+    .replace(/[^a-z0-9 ]/g, ' ')
+    .split(/\s+/)
+    .filter((w) => w.length > 2 && !['the', 'and', 'for', 'with', 'your', 'our'].includes(w)));
+/**
+ * K8 (`policy.mode-b.responsive-variants`): the section a one-viewport section twins — the marked "responsive variant of
+ * §N", else a section visible at the other viewport (or both) whose title shares most words, or the same item count
+ * and a shared title word.
+ */
+export function twinOf(secs, i) {
+    const sh = sectionShape(secs[i]);
+    if (sh.variantOf)
+        return { n: sh.variantOf, marked: true };
+    // Only a mobile-only section folds (the desktop section keeps its place); the hero never does.
+    if (sh.visibleAt !== 'mobile' || i === 0)
+        return null;
+    // K11 F1: a mobile-only hero — a desktop-only hero above it, and this section right below it (§2–§4) with a CTA and a
+    // section visual but no items — twins the hero even when its headline differs (run G home §3).
+    if (i <= 3 &&
+        secs[i].items == null &&
+        sectionShape(secs[0]).visibleAt === 'desktop' &&
+        sh.hasCta &&
+        hasSectionVisual(secs[i].text) &&
+        !secs.slice(1, i).some((o) => sectionShape(o).visibleAt === 'mobile'))
+        return { n: secs[0].n, marked: false, hero: true };
+    const w = sigWords(secs[i].title);
+    let best = null;
+    secs.forEach((o, j) => {
+        if (j === i)
+            return;
+        const os = sectionShape(o);
+        if (os.visibleAt === sh.visibleAt || os.variantOf)
+            return;
+        const ow = sigWords(o.title);
+        const shared = [...w].filter((x) => ow.has(x)).length;
+        const score = shared / Math.max(1, Math.min(w.size, ow.size)) +
+            (o.items != null && o.items === secs[i].items ? 0.4 : 0);
+        if (shared && score >= 0.75 && (!best || score > best.score))
+            best = { n: o.n, score };
+    });
+    return best ? { n: best.n, marked: false } : null;
+}
+/** Per-item media / CTA cues: two or more CTA lines, two or more image lines (or items that carry an image). */
+function perItem(sec) {
+    const lines = sec.text.split('\n');
+    const ctaLines = lines.filter((l) => /^\s*[-*]\s+(?:\*\*)?(?:primary |secondary )?cta\b/i.test(l)).length;
+    const mediaLines = lines.filter((l) => /^\s*[-*]\s+(?:\*\*)?(?:image|visual|media|screenshot|video)\b/i.test(l) ||
+        /^\s{0,4}\d+[.)]\s.*\b(?:img|image|video)\b/i.test(l)).length;
+    const items = sec.items ?? 0;
+    return { itemMedia: items >= 2 && mediaLines >= 2, itemCta: items >= 2 && ctaLines >= 2 };
+}
+/* ── helpers ───────────────────────────────────────────────────────────────────────────────── */
+const SEVERITY_RANK = { Critical: 3, Major: 2, Minor: 1 };
+const KIND_RANK = {
+    procedure: 2.5,
+    policy: 2,
+    rule: 2,
+    gotcha: 1.8,
+    recipe: 1.2,
+    section: 1,
+    layout: 1,
+    component: 0.8,
+    limit: 0.6,
+    'item-type': 0.6,
+    stat: 0.8,
+    'brand-fact': 0.6,
+};
+const CATALOG_KINDS = new Set(['section', 'layout', 'limit', 'item-type', 'component']);
+/** Skills a skill hands stages to: their units are in scope; units owned only by an unrelated skill are pushed down. */
+export const SKILL_DELEGATES = {
+    'web-compose': [
+        'web-structure',
+        'web-design',
+        'web-assets',
+        'web-qa',
+        'web-static',
+        'knowledge-capture',
+        'web-design-brain',
+    ],
+    'web-pmm': ['web-compose', 'web-structure', 'web-design', 'web-assets', 'web-qa', 'web-static'],
+    'web-benchmark': ['web-compose', 'web-qa', 'web-static'],
+    'web-remix': ['web-compose', 'web-static', 'web-qa'],
+    'web-custom-section': ['web-qa'],
+};
+/** Off-skill: the unit names skills, none of them this skill or one it delegates to. */
+function offSkill(u, skill) {
+    const skills = u.entities
+        .filter((e) => e.startsWith('skill:'))
+        .map((e) => e.slice('skill:'.length));
+    if (!skills.length)
+        return false;
+    const ok = new Set([skill, ...(SKILL_DELEGATES[skill] ?? EMAIL_SKILL_DELEGATES[skill] ?? [])]);
+    return !skills.some((x) => ok.has(x));
+}
+const skillEntity = (skill) => `skill:${skill}`;
+const primarySkill = (u) => u.entities.find((e) => e.startsWith('skill:'))?.slice('skill:'.length);
+const routable = (u, o) => u.authority !== 'background' &&
+    u.status === 'active' &&
+    u.stages.includes(o.stage) &&
+    (!o.mode || !u.modes || u.modes.includes(o.mode)) &&
+    inScope(u, o.skill) &&
+    u.kind !== 'token' &&
+    u.kind !== 'asset';
+/** One-line layout capability from the derived facts: range, tab label, dropped section props, sub-44px CTAs. */
+export function layoutLine(u) {
+    const f = (u.facts ?? {});
+    const parts = [];
+    const r = f.items;
+    if (r && (r.min != null || r.max != null))
+        parts.push(r.min === r.max ? `${r.min}` : `${r.min ?? '?'}–${r.max ?? '…'}`);
+    if (f.tabLabel?.length)
+        parts.push(`tab label ${f.tabLabel[0]}${f.tabListScrollable ? ', scrolls' : ''}`);
+    const dropped = (f.propsIgnored ?? []).filter((p) => ['sectionDescription', 'sectionTopic', 'sectionHeading', 'sectionCta', 'tagline'].includes(p));
+    if (dropped.length)
+        parts.push(`drops ${dropped.join('/')}`);
+    const small = (f.buttons ?? []).filter((b) => b.heightPx != null && b.heightPx < 44);
+    if (small.length)
+        parts.push(`CTA ${small[0].heightPx}px`);
+    return `${f.section ?? ''} ${f.layout ?? u.id}${parts.length ? ` (${parts.join('; ')})` : ''}`.trim();
+}
+/** A candidates-table row for layout `u` on brief section `sec`: its capability line (+ "no section CTA" when the brief has one the layout drops) and its item-count fit. */
+function candidateRow(u, sec, shape = sectionShape(sec)) {
+    let line = layoutLine(u);
+    const section = u.facts?.section ?? u.id.split('.')[1];
+    const rendered = (u.facts ?? {}).propsRendered;
+    if (shape.hasCta &&
+        rendered &&
+        !rendered.some((p) => /cta|button|action/i.test(p)) &&
+        !['HeaderSection', 'CtaSection'].includes(section))
+        line = line.endsWith(')') ? `${line.slice(0, -1)}; no section CTA)` : `${line} (no section CTA)`;
+    return { id: u.id, line, fit: fitOf(u, sec.items) };
+}
+function fitOf(u, n) {
+    const r = u.facts?.items;
+    if (!r || n == null)
+        return 'unknown';
+    if (r.max != null && n > r.max)
+        return 'over';
+    if (r.min != null && n < r.min)
+        return 'under';
+    return 'fits';
+}
+/**
+ * Brief section → the best layout candidates. Two signals: which SECTION the brief text reads like (BM25 over the
+ * section units: derived props + handbook use cases, hand-written usage) and which LAYOUT (BM25 over the derived
+ * layout units). A layout scores by both, then by item-count fit. Page anatomy priors from the stage-1B checks:
+ * the first brief section is the hero (HeaderSection), and HeaderSection is a hero only; a closing CTA section is a
+ * CtaSection.
+ */
+export function briefCandidates(kb, index, sec, byId, pos = { first: false, last: false }, k = 2) {
+    const q = briefQuery(sec);
+    const sectionOf = (u) => u.facts?.section ?? u.id.split('.')[1];
+    const secScore = new Map();
+    for (const h of search(kb, index, q, { kind: ['section'], k: 40 })) {
+        // Example units are code (every section's example says "Get started"): they say nothing about fit.
+        if (h.id.includes('.example.'))
+            continue;
+        const name = h.id.split('.')[1];
+        secScore.set(name, Math.max(secScore.get(name) ?? 0, h.score));
+    }
+    const maxSec = Math.max(1, ...secScore.values());
+    const layScore = new Map();
+    for (const h of search(kb, index, q, { kind: ['layout'], authority: ['derived'], k: 40 }))
+        layScore.set(h.id, h.score);
+    const maxLay = Math.max(1, ...layScore.values());
+    const layouts = kb.units.filter((u) => u.kind === 'layout' && u.authority === 'derived');
+    const shape = sectionShape(sec);
+    const priors = SHAPE_PRIORS.filter((p) => p.test(sec, itemShape(sec.text)));
+    const faq = faqSection(sec);
+    // The last section with a CTA and no items is the closing CTA, whatever its title says (a capture brief titles it by its H2).
+    const isCta = /\b(?:closing|final)\b.*\bcta\b|\bcta\b/i.test(sec.title) ||
+        (pos.last && shape.hasCta && sec.items == null);
+    const useFor = (u) => /Use for: ([^\n]*)/.exec(u.body)?.[1] ?? '';
+    const scored = layouts.map((u) => {
+        const name = sectionOf(u);
+        let s = (layScore.get(u.id) ?? 0) / maxLay + 0.8 * ((secScore.get(name) ?? 0) / maxSec);
+        if (name === 'HeaderSection')
+            s *= pos.first ? 2 : 0.2;
+        else if (pos.first)
+            s *= 0.5;
+        if (name === 'CtaSection' && isCta)
+            s *= 1.8;
+        if (['NavbarMenu', 'FooterSection'].includes(name))
+            s *= 0.1;
+        // Anatomy priors from the brief section's own title (like the hero prior above): a logo strip is a
+        // CustomerLogoSection, an integrations block Integrations, a trust / security panel TrustSection, an FAQ FaqSection,
+        // stats NumbersSection, case studies / testimonials TestimonialsSection.
+        for (const [re, target, f] of TITLE_PRIORS)
+            if (re.test(sec.title) && target.test(u.id))
+                s *= f;
+        // floating-card is the closing CTA only (policy.final-cta-is-floating-card).
+        if (u.id === 'layout.CtaSection.floating-card')
+            s *= pos.last ? (isCta ? 3 : 1.5) : 0.3;
+        if (!pos.first && !pos.last && !isCta) {
+            // A capture brief's "Items (N, cards)" is an extraction label, not the PMM saying "cards": only real copy counts.
+            const cueText = `${sec.title} ${sec.text
+                .split('\n')
+                .filter((l) => !/^\s*-\s+\*\*(?:Items \(|Layout \(derived\))/.test(l))
+                .join(' ')}`;
+            if (name === 'CardsSection' && sec.items != null && /\bcards?\b/i.test(cueText))
+                s *= 1.5;
+            // Outer structure (K8): tabs → a tab layout (one panel per tab); an accordion → an accordion layout.
+            if (shape.tabs && /^layout\.FeaturesSection\.(?:tabs-|tab-cards-carousel)/.test(u.id))
+                s *= 2;
+            if (shape.accordion &&
+                /^layout\.FeaturesSection\.(?:side-by-side|numbered-accordion|accordion-media-right)/.test(u.id))
+                s *= 2;
+            if ((shape.tabs || shape.accordion) && /^layout\.CardsSection\./.test(u.id))
+                s *= 0.5;
+            // Two or more case-study links: the case-study testimonial layouts.
+            if (shape.caseStudy &&
+                /^layout\.TestimonialsSection\.(?:carousel-case-study|mixed-stat-and-quote)/.test(u.id))
+                s *= 2;
+            // A grid of icon/text items wants an icon or grid layout, not an accordion or a carousel.
+            if (shape.grid && sec.items != null) {
+                if (/\bgrid\b|\bicon/i.test(useFor(u)))
+                    s *= 1.8;
+                if (/accordion|carousel|tabs?\b/i.test(u.id))
+                    s *= 0.6;
+            }
+            // A statement (heading + body [+ media] [+ CTA], no items) has no dedicated section (a DS gap): the usual
+            // stand-ins are a one-item sequential FeaturesSection when it has media, a centered CtaSection when it has none.
+            if (shape.statement) {
+                if (shape.hasMedia && /^layout\.FeaturesSection\.(?:side-by-side|stacked-rows)$/.test(u.id))
+                    s *= 3;
+                else if (!shape.hasMedia && u.id === 'layout.CtaSection.centered')
+                    s *= 3;
+                else if (shape.hasCta && u.id === 'layout.CtaSection.centered')
+                    s *= 1.6;
+                if (/^layout\.(?:Integrations|TrustSection|NumbersSection|TestimonialsSection|CustomerLogoSection|FaqSection)\./.test(u.id))
+                    s *= 0.3;
+            }
+        }
+        // Per-item image / CTA (K5b F4): a layout whose item type renders no media / no action slot loses that content.
+        const itemRendered = Object.values((u.facts ?? {}).itemFields ?? {}).flatMap((f) => f.rendered);
+        // B3: an FAQ's item images are dropped (FaqSection renders none), not a reason to leave FaqSection.
+        if (itemRendered.length && !(faq && name === 'FaqSection')) {
+            if (shape.itemMedia && !itemRendered.some((f) => /^(?:media|image|visual|video)/i.test(f)))
+                s *= 0.5;
+            if (shape.itemCta && !itemRendered.some((f) => /^(?:actions?|cta\d?|link\w*|href)$/i.test(f)))
+                s *= 0.6;
+        }
+        // A logo row with no copy of its own (K8): CustomerLogoSection, or Integrations when the logos are integrations.
+        if (shape.logoStrip) {
+            const target = shape.logoStrip === 'integration'
+                ? /^layout\.Integrations\./
+                : /^layout\.CustomerLogoSection\./;
+            s *= target.test(u.id)
+                ? 4
+                : /^layout\.(?:CustomerLogoSection|Integrations)\./.test(u.id)
+                    ? 1.5
+                    : 0.2;
+        }
+        if (!pos.first)
+            for (const p of priors)
+                if (p.layout === u.id)
+                    s *= p.factor;
+        const fit = fitOf(u, sec.items);
+        s *= fit === 'fits' ? 1.25 : fit === 'over' ? 0.8 : fit === 'under' ? 0.75 : 1;
+        return { u, fit, s };
+    });
+    scored.sort((a, b) => b.s - a.s || (a.u.id < b.u.id ? -1 : 1));
+    const pick = scored.slice(0, k);
+    // K11 F1: the hero's direction picks the HeaderSection family that leads the hero row (a wrong direction is −20,
+    // `policy.benchmark.rubric-layout-hero`). A guessed direction keeps the best layout of the other family second.
+    const dir = pos.first ? heroDirection(sec) : null;
+    if (dir) {
+        const fam = HERO_FAMILIES[dir.dir];
+        const header = scored.filter((x) => sectionOf(x.u) === 'HeaderSection');
+        const inFam = header.filter((x) => fam.includes(x.u.id));
+        const lead = (dir.why === 'selector'
+            ? inFam.find((x) => x.u.id === 'layout.HeaderSection.split')
+            : undefined) ?? inFam[0];
+        const other = dir.why === 'default'
+            ? header.find((x) => HERO_FAMILIES.split.includes(x.u.id))
+            : inFam.find((x) => x !== lead);
+        if (lead)
+            pick.splice(0, pick.length, lead, ...[other ?? header.find((x) => x !== lead)].filter((x) => !!x && x !== lead));
+    }
+    // A matching item-shape prior always lists its layout (not on the hero row: there it is the §1b candidate below).
+    if (!pos.first)
+        for (const p of priors)
+            if (!pick.some((x) => x.u.id === p.layout)) {
+                const hit = scored.find((x) => x.u.id === p.layout);
+                if (hit)
+                    pick.push(hit);
+            }
+    // Mode B picks the layout whose range fits: when no pick fits, add the best-scoring fitting layout of a picked section.
+    if (sec.items != null && !pick.some((p) => p.fit === 'fits')) {
+        const names = new Set(pick.map((p) => sectionOf(p.u)));
+        const alt = scored.slice(k, 12).find((x) => x.fit === 'fits' && names.has(sectionOf(x.u)));
+        if (alt)
+            pick.push(alt);
+    }
+    const rows = pick.map(({ u }) => candidateRow(u, sec, shape));
+    // K11 (`policy.mode-b.hero-item-split`): a hero whose items fit no HeaderSection slot also gets the candidates of its
+    // §1b item section — the same brief section scored as a body section (item-shape priors apply there).
+    if (pos.first && heroItemGroup(sec)) {
+        const body = briefCandidates(kb, index, sec, byId, { first: false, last: false }, 1).filter((c) => !c.id.startsWith('layout.HeaderSection.'));
+        for (const c of body)
+            rows.push({ ...c, part: 'b' });
+    }
+    return rows;
+}
+/** [brief section title, layout id, factor]: section-type cues in a brief section's title. */
+const TITLE_PRIORS = [
+    [
+        /\b(?:customer )?logos?\b(?!.*integrat)|\btrusted by\b(?!.*(?:enterprise|leader))/i,
+        /^layout\.CustomerLogoSection\./,
+        2.5,
+    ],
+    [/\bintegrations?\b/i, /^layout\.Integrations\./, 2],
+    [/\b(?:trust(?:ed)?|security|compliance|enterprise[- ]grade)\b/i, /^layout\.TrustSection\./, 2],
+    [/\bfaq\b|\bquestions\b/i, /^layout\.FaqSection\./, 2.5],
+    [/\bstats?\b|\bnumbers?\b|\bmetrics?\b/i, /^layout\.NumbersSection\./, 1.8],
+    [
+        /\b(?:case[- ]stud(?:y|ies)|testimonials?|customer (?:results|stories|quotes))\b/i,
+        /^layout\.TestimonialsSection\./,
+        1.8,
+    ],
+    [/\bcase[- ]stud(?:y|ies)\b/i, /case-study/, 1.4],
+];
+/** A short note for brief sections no layout expresses well (shown in the candidates table). */
+export function briefHint(sec, pos, twin, candidates = [], page = {}) {
+    const out = [];
+    for (const h of BRIEF_HINTS) {
+        const t = h.hint({ sec, pos, twin, candidates, page });
+        if (!t)
+            continue;
+        out.push(t);
+        if (h.stop)
+            break;
+    }
+    return out.join(' · ');
+}
+/**
+ * The candidates-table notes, in order. A rule returns '' when it doesn't apply; a `stop` rule that applies ends the
+ * list (a twin or a logo strip needs no other note). K11 made this a list so a rule-collision note (grey band + grey
+ * cards) can sit next to a layout note; add a row for a new collision the mapping stage must see.
+ */
+export const BRIEF_HINTS = [
+    {
+        name: 'responsive twin',
+        stop: true,
+        hint: ({ twin, sec }) => !twin
+            ? ''
+            : twin.hero
+                ? `mobile-only hero → likely twin of §${twin.n}: fold into it, add no section; its own copy (headline, form) is a \`[COPY: mobile hero, §${sec.n}]\` flag, not a section (\`policy.mode-b.responsive-variants\`)`
+                : `${twin.marked ? '' : 'likely '}twin of §${twin.n} → fold into it, add no section (\`policy.mode-b.responsive-variants\`)`,
+    },
+    {
+        name: 'logo strip',
+        stop: true,
+        hint: ({ sec }) => {
+            const sh = sectionShape(sec);
+            return sh.logoStrip ? `${sh.logos} logos, not items` : '';
+        },
+    },
+    {
+        name: 'hero direction (K11 F1)',
+        hint: ({ sec, pos }) => {
+            const d = pos.first ? heroDirection(sec) : null;
+            if (!d)
+                return '';
+            const why = d.why === 'cue'
+                ? `brief says ${d.dir === 'split' ? 'split' : d.dir === 'text' ? 'text-only' : 'centered'}`
+                : d.why === 'selector'
+                    ? 'tabs + a visual per tab = selector hero: copy + tabs (`options`) left, visual right → `split`'
+                    : 'direction not in the brief: copy above the visual → `centered-image`, copy left + visual right → `split*`; check the live hero';
+            return `${why} (wrong direction −20, \`policy.benchmark.rubric-layout-hero\`)`;
+        },
+    },
+    {
+        name: 'hero + items no HeaderSection slot holds (K11)',
+        stop: true,
+        hint: ({ sec, pos }) => {
+            const g = pos.first ? heroItemGroup(sec) : null;
+            if (!g)
+                return '';
+            const b = g.agentCards ? '`CardsSection.horizontal-reveal` (agent cards)' : 'one item section';
+            return `hero + ${g.n} items no HeaderSection slot holds → §${sec.n}a HeaderSection${g.heroMedia ? '' : ' `text-only`'} (copy) + §${sec.n}b ${b} directly below; keep every copy beats never split (\`policy.mode-b.hero-item-split\`)`;
+        },
+    },
+    {
+        name: 'accordion driving a card carousel (K11 F1)',
+        stop: true,
+        hint: ({ sec, page }) => {
+            const c = page?.carousel;
+            if (!c)
+                return '';
+            const lay = c.takenBy == null
+                ? '`tab-cards-carousel`'
+                : `§${c.takenBy} has \`tab-cards-carousel\` → \`accordion-media-right\``;
+            const nb = c.nb
+                ? `; the ${c.cards} cards with copy → §${sec.n}b \`${c.nb.replace(/^layout\./, '')}\` below`
+                : '';
+            return `accordion driving a card carousel: ${lay} + \`[GAP: accordion-driven carousel]\` (−5 once)${nb} (\`policy.layout.accordion-carousel\`)`;
+        },
+    },
+    {
+        name: 'two item groups',
+        stop: true,
+        hint: ({ sec, pos }) => {
+            const two = !pos.first && isCaptureSection(sec.text) ? twoItemGroups(sec.text) : null;
+            return two
+                ? `2 item groups (${two.a.n} ${two.a.kind} + ${two.b.n} ${two.b.kind}) → two adjacent sections §${sec.n}a/§${sec.n}b, nothing dropped (\`policy.mode-b.two-item-groups\`)`
+                : '';
+        },
+    },
+    {
+        name: 'vertical item list labelled tabs (K11 B2)',
+        hint: ({ sec, pos, candidates }) => {
+            const v = pos.first ? null : verticalItemList(sec);
+            if (!v || v.labelled !== 'tabs')
+                return '';
+            // B3: a later section moved along the accordion + media family (layout-diversity) names the layout it got.
+            const top = candidates.find((c) => !c.part)?.id;
+            const to = top && ACCORDION_MEDIA_FAMILY.includes(top)
+                ? `\`${top.replace(/^layout\./, '')}\``
+                : v.visual === 'item' && v.n <= 5
+                    ? '`FeaturesSection.side-by-side`'
+                    : '`FeaturesSection.accordion-media-right`';
+            return `${v.n} "tabs" that show their own copy = a vertical list (expands in place), not a tab row → ${to}, not tabs-* (\`policy.tabs.layout-by-count\`)`;
+        },
+    },
+    {
+        name: 'live grey band + grey cards (K11)',
+        hint: ({ sec, pos, candidates }) => {
+            if (pos.first || !greyBand(sec))
+                return '';
+            const grey = candidates
+                .filter((c) => GREY_CARD_LAYOUTS.has(c.id))
+                .map((c) => `\`${c.id.replace(/^layout\./, '')}\``);
+            const sh = itemShape(sec.text);
+            if (!grey.length && !(sh.stats >= 1 && sh.quotes >= 1))
+                return '';
+            const which = grey.length
+                ? grey.join(' / ')
+                : 'stat + quote cards: the TestimonialsSection carousels';
+            return `live grey band + grey cards (${which}) → the grey-on-grey Critical beats the band: \`theme="default"\`, log \`[COPY: grey band dropped, grey cards]\` (\`policy.mode-b.precedence\` tint exception 2)`;
+        },
+    },
+    {
+        name: 'statement',
+        hint: ({ sec, pos, page }) => {
+            const shape = sectionShape(sec);
+            if (pos.first || pos.last || !shape.statement)
+                return '';
+            if (!shape.hasMedia)
+                return '[GAP?] statement: no single-statement section; CtaSection centered if it carries a CTA';
+            const st = page?.statement;
+            if (st && !st.to)
+                return `[GAP?] statement + media: both 1-item stand-ins are taken (§${st.prev} has \`stacked-rows\`): keep \`stacked-media-left\`, log \`[GAP: layout-diversity]\` (\`policy.layout.statement-stand-in\`)`;
+            const to = st?.to
+                ? `\`${st.to.replace(/^layout\.FeaturesSection\./, '')}\`${st.prev != null ? ` (§${st.prev} has \`stacked-rows\`)` : ''}`
+                : '`stacked-rows`';
+            return `[GAP?] statement + media → a single-item FeaturesSection ${to}; never \`''\` (\`policy.layout.statement-stand-in\`)`;
+        },
+    },
+];
+/** Compact limit text from a derived limit unit's facts: `16–37c`, `≤3w`, `1–2s`. */
+export function limitShort(u) {
+    const f = (u?.facts ?? {});
+    const part = (r, unit) => !r || (r.min == null && r.max == null)
+        ? ''
+        : r.min != null && r.max != null
+            ? r.min === r.max
+                ? `${r.max}${unit}`
+                : `${r.min}–${r.max}${unit}`
+            : r.max != null
+                ? `≤${r.max}${unit}`
+                : `≥${r.min}${unit}`;
+    return [part(f.chars, 'c'), part(f.words, 'w'), part(f.sentences, 's')].filter(Boolean).join(' ');
+}
+/** One line per item type a layout renders: the rendered fields (● required) with their copy limits. */
+export function itemShapeLines(u, byId) {
+    const f = (u.facts ?? {});
+    const out = [];
+    for (const [item, { rendered }] of Object.entries(f.itemFields ?? {})) {
+        const iu = byId.get(`item.${item}`);
+        const fields = (iu?.facts ?? {}).fields ?? [];
+        const shown = fields.filter((x) => rendered.includes(x.name));
+        if (!shown.length)
+            continue;
+        const fmt = (x) => {
+            const lim = limitShort(x.limitId ? byId.get(x.limitId) : undefined);
+            const t = /^\{/.test(x.type)
+                ? `{${[...x.type.matchAll(/(\w+)\??:/g)]
+                    .map((m) => m[1])
+                    .filter((k) => k !== 'onClick')
+                    .join(',')}}`
+                : '';
+            return `${x.required ? '●' : ''}${x.name}${t}${lim ? ` ${lim}` : ''}`;
+        };
+        out.push(`- \`clay section ${f.section} --layout ${f.layout}\` · ${item}: ${shown.map(fmt).join(' · ')}`);
+    }
+    return out;
+}
+/** The search text for one brief section: the title and any layout / interaction hint lines weigh double. */
+export function briefQuery(sec) {
+    const clean = sec.text.replace(/https?:\/\/\S+|`[^`]*`/g, ' ');
+    const hints = clean
+        .split('\n')
+        // Mobile behaviour ("an accordion on mobile") says nothing about the desktop layout.
+        .filter((l) => /\b(?:layout|interactive|columns?|grid|carousel|tabs?|accordion|marquee|cards?)\b/i.test(l) &&
+        !/^\s*\|/.test(l) &&
+        !/\bmobile\b/i.test(l))
+        .map((l) => l.slice(0, 200))
+        .join(' ');
+    return `${sec.title} ${sec.title} ${hints} ${hints} ${clean.slice(0, 400)}`;
+}
+/**
+ * Email brief blocks (K7): `**Section NN:** <name>` lines (the Lifecycle brief layout, e.g. examples/brief-example.md),
+ * else the items of a "Must-have blocks" list, else the brief's `###` headings. Each block keeps its text until the next.
+ */
+export function emailBriefRows(brief) {
+    const lines = brief.split('\n');
+    const SEC = /^\s*\*\*Section\s+\d+:?\*\*:?\s*(.+)$/i;
+    const marks = lines
+        .map((l, i) => ({ i, m: SEC.exec(l)?.[1]?.replace(/\*\*/g, '').trim() }))
+        .filter((x) => x.m);
+    if (marks.length)
+        return marks.slice(0, 20).map((x, k) => ({
+            title: x.m,
+            text: lines
+                .slice(x.i + 1, k + 1 < marks.length ? marks[k + 1].i : Math.min(lines.length, x.i + 25))
+                .join(' ')
+                .slice(0, 400),
+        }));
+    const mh = lines.findIndex((l) => /must-have blocks/i.test(l));
+    if (mh >= 0) {
+        const items = [];
+        for (let i = mh + 1; i < lines.length && items.length < 12; i++) {
+            if (/^\s*[-*]\s+/.test(lines[i]))
+                items.push(lines[i].replace(/^\s*[-*]\s+/, '').trim());
+            else if (items.length && lines[i].trim() && !/^\s{2,}/.test(lines[i]))
+                break;
+        }
+        if (items.length)
+            return items.map((t) => ({ title: t, text: '' }));
+    }
+    return parseBrief(brief).map((s) => ({ title: s.title, text: s.text.slice(0, 400) }));
+}
+/* ── route ─────────────────────────────────────────────────────────────────────────────────── */
+/** K10: procedures that only describe the brief format; a compact route with a brief names them instead. */
+const BRIEF_FORMAT_UNITS = new Set(['procedure.compose.inputs']);
+/** K10: the navbar + footer code the compact page-file route inlines. */
+export const CHROME_EXAMPLES = [
+    'section.NavbarMenu.example.full',
+    'section.FooterSection.example.default',
+];
+/** A unit body with no blank lines (K10 compact view; same as api.ts `tight`). */
+const tightBody = (body) => body.replace(/\n[ \t]*\n+/g, '\n').trim();
+export function route(kb, index, o) {
+    const budget = o.budget ??
+        (o.brief && (o.stage === 'mapping' || o.stage === 'structure') ? BRIEF_BUDGET : DEFAULT_BUDGET);
+    const byId = new Map(kb.units.map((u) => [u.id, u]));
+    const pool = kb.units.filter((u) => routable(u, o));
+    const used = new Set();
+    const out = [];
+    const blocks = [];
+    const compact = !!o.compact;
+    // Same rendering as the final text (blocks joined by a blank line — none in the compact view — and a trailing
+    // newline), so the budget is exact.
+    const render = (bs) => `${bs.join(compact ? '\n' : '\n\n')}\n`;
+    const tokensOf = (extra = '') => estimateTokens(render(extra ? [...blocks, extra] : blocks));
+    const room = (text) => tokensOf(text) <= budget;
+    const sectionsOfBrief = o.brief ? parseBrief(o.brief) : [];
+    const emailRoute = isEmailSkill(o.skill);
+    const header = emailRoute
+        ? `# clay route · ${o.skill} · stage ${o.stage} (scope email)\n` +
+            `${o.brief ? `Brief: ${o.briefLabel ?? '(inline)'} — ${emailBriefRows(o.brief).length} blocks. ` : ''}` +
+            `Units are the source of truth (\`pnpm clay get <id>\` for any id below; \`pnpm clay section email.<id>\` for one email section: slots, brief fields, limits, gotchas).`
+        : compact
+            ? `# clay route · ${o.skill}${o.mode ? ` · mode ${o.mode}` : ''} · stage ${o.stage}${o.brief ? ` · brief: ${sectionsOfBrief.length} sections` : ''} (\`clay get <id>\` for any id)`
+            : `# clay route · ${o.skill}${o.mode ? ` · mode ${o.mode}` : ''} · stage ${o.stage}\n` +
+                `${o.brief ? `Brief: ${o.briefLabel ?? '(inline)'} — ${sectionsOfBrief.length} sections. ` : ''}` +
+                `Units are the source of truth (\`pnpm clay get <id>\` for any id below; \`pnpm clay section <Section> --layout <l>\` for a layout).`;
+    blocks.push(header);
+    /* 1 · Do: the skill's procedures for the stage */
+    const procs = pool
+        .filter((u) => u.kind === 'procedure' && u.entities.includes(skillEntity(o.skill)))
+        // Mode-specific first, then the procedures this skill owns (its skill entity listed first) before the ones it shares.
+        .sort((a, b) => Number(!!b.modes) - Number(!!a.modes) ||
+        Number(primarySkill(b) === o.skill) - Number(primarySkill(a) === o.skill) ||
+        (a.id < b.id ? -1 : 1));
+    const bodyBlock = (u) => `### ${u.id}\n${compact ? tightBody(modeSlice(u.body, o.mode)) : modeSlice(u.body, o.mode)}`;
+    const startUnits = new Set(o.mode ? MODE_START_UNITS[o.mode] : []);
+    const doBlocks = [];
+    const seenBody = (id) => !!o.seen?.bodies.has(id);
+    const seenLine = (id) => seenBody(id) || !!o.seen?.lines.has(id);
+    const earlier = [];
+    const notNeeded = [];
+    for (const u of procs) {
+        if (seenBody(u.id)) {
+            earlier.push(u.id);
+            used.add(u.id);
+            continue;
+        }
+        // K10 compact: with a brief in hand the brief-format template is noise.
+        if (compact && o.brief && BRIEF_FORMAT_UNITS.has(u.id)) {
+            notNeeded.push(u.id);
+            used.add(u.id);
+            continue;
+        }
+        // The first (most specific) procedure always inlines; later ones inline while they fit in 40% of the budget.
+        const b = bodyBlock(u);
+        if (!doBlocks.length || estimateTokens([...doBlocks, b].join('\n')) <= budget * 0.3) {
+            doBlocks.push(b);
+            used.add(u.id);
+            out.push({ id: u.id, tier: 'do', inlined: 'body' });
+        }
+    }
+    if (doBlocks.length)
+        blocks.push(`## Do\n${doBlocks.join(compact ? '\n' : '\n\n')}`);
+    const email = isEmailSkill(o.skill);
+    if (email) {
+        const d = emailDoBlock(o.skill, o.stage);
+        if (d)
+            blocks.push(d);
+        const gates = emailGates(pool).filter((u) => !used.has(u.id));
+        if (gates.length) {
+            blocks.push(`## Gates (Critical email rules of this stage — \`pnpm email:check\` fails on them)\n${gates.map((u) => `- \`${u.id}\` — ${u.summary.replace(/^Email rule \S+ \([^)]*\): /, '')}`).join('\n')}`);
+            for (const u of gates) {
+                used.add(u.id);
+                out.push({ id: u.id, tier: 'decides', inlined: 'summary' });
+            }
+        }
+    }
+    /* 2 · Decides: what the procedures yield to + Critical mode-specific policies */
+    const decide = [];
+    for (const u of procs.filter((p) => used.has(p.id)))
+        for (const id of u.relations?.precedence ?? []) {
+            const t = byId.get(id);
+            if (t && t.authority !== 'background' && !used.has(id) && !decide.includes(t))
+                decide.push(t);
+        }
+    for (const u of pool)
+        if (o.mode &&
+            u.modes?.includes(o.mode) &&
+            u.kind === 'policy' &&
+            u.severity === 'Critical' &&
+            !decide.includes(u) &&
+            !used.has(u.id))
+            decide.push(u);
+    const decideBlocks = [];
+    const fetched = [...startUnits]
+        .map((id) => byId.get(id))
+        .filter((u) => !!u && u.authority !== 'background' && !used.has(u.id) && !seenBody(u.id));
+    for (const id of startUnits)
+        if (seenBody(id) && !used.has(id))
+            used.add(id);
+    if (fetched.length) {
+        decideBlocks.push(`Fetched once at the start of mode ${o.mode} (\`pnpm clay get ${fetched.map((u) => u.id).join(' ')}\`), not repeated here: ${fetched.map((u) => `\`${u.id}\` — ${u.summary}`).join(' · ')}`);
+        for (const u of fetched) {
+            used.add(u.id);
+            out.push({ id: u.id, tier: 'decides', inlined: 'summary' });
+        }
+    }
+    for (const u of decide) {
+        if (startUnits.has(u.id))
+            continue;
+        if (seenBody(u.id)) {
+            earlier.push(u.id);
+            used.add(u.id);
+            continue;
+        }
+        const b = bodyBlock(u);
+        if (estimateTokens([...blocks, ...decideBlocks, b].join('\n')) <= budget * 0.7) {
+            decideBlocks.push(b);
+            used.add(u.id);
+            out.push({ id: u.id, tier: 'decides', inlined: 'body' });
+        }
+    }
+    if (decideBlocks.length)
+        blocks.push(`## Decides collisions\n${decideBlocks.join(compact ? '\n' : '\n\n')}`);
+    if (earlier.length)
+        blocks.push(`Served earlier in this session, not repeated (\`clay get <id> --full\` to re-read): ${earlier.map((id) => `\`${id}\``).join(' · ')}`);
+    if (notNeeded.length)
+        blocks.push(`Brief format not printed (you have the brief): ${notNeeded.map((id) => `\`${id}\``).join(' · ')}`);
+    /* K8 · the build's own layout picks: one fact line each (range, dropped props, dead CTAs), so later stages need no
+     * `clay section` re-call. */
+    if (o.layouts?.length && LAYOUT_FACT_STAGES.has(o.stage)) {
+        const facts = o.layouts
+            .map((k) => byId.get(`layout.${k}`))
+            .filter((u) => !!u)
+            .map((u) => `- ${layoutLine(u)}`);
+        // K10 compact: the session already printed each layout's facts, so one line names them (bench run E / K10: the
+        // per-layout list repeated ~40 lines at page-file).
+        if (facts.length && compact)
+            blocks.push(`Layouts you looked at (facts printed earlier; \`clay section <S> --layout <l>\` re-prints): ${o.layouts.join(' · ')}`);
+        else if (facts.length)
+            blocks.push(`## Your layouts (from \`clay section\` in this session)\n${facts.join('\n')}`);
+    }
+    /* K10 · the site chrome every page file needs (Hard Rule C4), so writing it takes no NavbarMenu / FooterSection lookup. */
+    if (compact && !emailRoute && o.stage === 'page-file') {
+        const chrome = CHROME_EXAMPLES.map((id) => byId.get(id)).filter((u) => !!u && !seenBody(u.id) && !used.has(u.id));
+        if (chrome.length) {
+            blocks.push(`## Chrome (Hard Rule C4: use as is; another brand swaps only the logo key, \`procedure.logo.decision-tree\`)\n${chrome.map((u) => tightBody(u.body)).join('\n')}`);
+            for (const u of chrome) {
+                used.add(u.id);
+                out.push({ id: u.id, tier: 'do', inlined: 'body' });
+            }
+        }
+    }
+    /* 3 · Brief → candidates */
+    const briefRows = [];
+    const candidateEntities = new Set();
+    if (email && o.brief && (o.stage === 'mapping' || o.stage === 'structure')) {
+        const rows = emailBriefRows(o.brief).map((r, i) => {
+            const c = emailBriefCandidates(kb, index, r.title, r.text);
+            for (const id of c)
+                out.push({ id, tier: 'brief', inlined: 'id' });
+            return `| ${i + 1} | ${r.title.slice(0, 48)} | ${c.map((id) => `\`${id.replace(/^(?:section|component)\.email\./, '')}\``).join(' · ') || '— (no match: a [GAP]?)'} |`;
+        });
+        const table = `## Brief → email section candidates (search; alias map first; an explicit brief structure wins — \`clay get section.email.<id>\`)\n| # | brief block | candidates |\n|---|---|---|\n${rows.join('\n')}`;
+        if (rows.length && room(table))
+            blocks.push(table);
+    }
+    if (!email && sectionsOfBrief.length && (o.stage === 'mapping' || o.stage === 'structure')) {
+        const twins = sectionsOfBrief.map((_, i) => twinOf(sectionsOfBrief, i));
+        // The closing section is the last one that is not a mobile twin.
+        const lastReal = twins.reduce((last, t, i) => (t ? last : i), sectionsOfBrief.length - 1);
+        sectionsOfBrief.forEach((sec, i) => {
+            // A responsive twin folds into its section: no candidates of its own (policy.mode-b.responsive-variants).
+            const cands = twins[i]
+                ? []
+                : briefCandidates(kb, index, sec, byId, { first: i === 0, last: i === lastReal });
+            briefRows.push({ section: sec, candidates: cands });
+            for (const c of cands) {
+                const u = byId.get(c.id);
+                for (const e of u.entities)
+                    if (e.startsWith('section:') || e.startsWith('layout:') || e.startsWith('item:'))
+                        candidateEntities.add(e);
+            }
+        });
+        // K11 B3 (`policy.features.layout-diversity`): a later section whose first pick is an accordion + media layout an
+        // earlier section already took first lists the next layout of that family first.
+        const skipRow = (i) => i === 0 || !!twins[i];
+        // K11 F1 (`policy.layout.accordion-carousel`): an accordion driving a card carousel takes the one canonical answer.
+        const carousels = resolveAccordionCarousels(briefRows, byId, skipRow);
+        const diverse = diversifyAccordionFamily(briefRows, byId, (i) => skipRow(i) || carousels.has(i));
+        // K11 F1 (`policy.layout.statement-stand-in`): statements with media take different 1-item stand-ins.
+        const statements = diversifyStatements(briefRows, byId, (i) => i !== lastReal &&
+            (() => {
+                const sh = sectionShape(briefRows[i].section);
+                return sh.statement && sh.hasMedia;
+            })(), skipRow);
+        // K10 (`policy.layout.no-repeat-fallback`): a section whose best candidate is the previous section's best candidate.
+        let prevTop = null;
+        const repeats = briefRows.map((r) => {
+            const top = r.candidates[0];
+            if (!top)
+                return null;
+            const hit = prevTop && prevTop.id === top.id ? prevTop.n : null;
+            prevTop = { id: top.id, n: r.section.n };
+            return hit;
+        });
+        const rows = briefRows.map((r, i) => {
+            const hint0 = briefHint(r.section, { first: i === 0, last: i === lastReal }, twins[i], r.candidates, { carousel: carousels.get(i), statement: statements.get(i) });
+            const rep = repeats[i] != null
+                ? `⚠ same first pick as §${repeats[i]}: keep §${repeats[i]}, take this section's next closest layout (\`policy.layout.no-repeat-fallback\`)`
+                : '';
+            const d = diverse.get(i);
+            const short = (id) => `\`${id.replace(/^layout\.FeaturesSection\./, '')}\``;
+            const div = !d
+                ? ''
+                : d.to
+                    ? `§${d.prev} has ${short(d.from)} → ${short(d.to)} (same accordion + media family; \`policy.features.layout-diversity\`)`
+                    : `⚠ §${d.prev} has ${short(d.from)}, no other family layout fits: keep, log \`[GAP: layout-diversity]\` (\`policy.features.layout-diversity\`)`;
+            const hint = [hint0, div, rep].filter(Boolean).join(' · ');
+            return `| ${r.section.n} | ${r.section.title.slice(0, 38)} | ${r.section.items ?? '—'} | ${[...r.candidates.map((c) => `${c.part ? `§${r.section.n}${c.part} ` : ''}\`${c.id.replace(/^layout\./, '')}\` ${c.line.replace(/^\S+ \S+ ?/, '')}${c.fit === 'over' ? ' ⚠ over' : c.fit === 'under' ? ' ⚠ under' : ''}`), ...(hint ? [hint] : [])].join(' · ')} |`;
+        });
+        const table = `## Brief → layout candidates (search + item-count fit; you decide)\n| § | brief section | items | candidates (range; notes) |\n|---|---|---|---|\n${rows.join('\n')}`;
+        if (room(table)) {
+            blocks.push(table);
+            for (const r of briefRows)
+                for (const c of r.candidates)
+                    out.push({ id: c.id, tier: 'brief', inlined: 'summary' });
+            // Item shapes of the first candidate per section (the fields that layout renders, with limits), so the mapping
+            // needs no source or doc lookup; each line names the `clay section` call that gives the full view.
+            const seen = new Set();
+            const shapeLines = [];
+            for (const r of briefRows)
+                for (const c of compact ? r.candidates : r.candidates.slice(0, 1)) {
+                    if (!c || seen.has(c.id))
+                        continue;
+                    seen.add(c.id);
+                    for (const l of itemShapeLines(byId.get(c.id), byId)) {
+                        const key = l.replace(/^- `[^`]*` · /, '');
+                        if (!/·.*·/.test(key) || shapeLines.some((x) => x.endsWith(key)))
+                            continue; // trivial or same fields as a line above
+                        shapeLines.push(l);
+                    }
+                }
+            const shapes = `### Item shapes of the ${compact ? '' : 'first '}candidates (● required; c chars · w words · s sentences)\n${[...new Set(shapeLines)].join('\n')}`;
+            if (shapeLines.length && room(shapes))
+                blocks.push(shapes);
+        }
+    }
+    /* 4 · Watch: ranked one-liners */
+    const rel = new Map();
+    if (o.brief) {
+        // Relevance to the brief: BM25 of each brief section against the stage pool.
+        const poolIds = new Set(pool.map((u) => u.id));
+        const qs = sectionsOfBrief.length
+            ? sectionsOfBrief.map((s) => `${s.title} ${s.text.replace(/https?:\/\/\S+|`[^`]*`/g, ' ').slice(0, 400)}`)
+            : [o.brief.slice(0, 2000)];
+        for (const q of qs) {
+            for (const h of search(kb, index, q, {
+                stage: [o.stage],
+                mode: o.mode,
+                k: 25,
+                scope: email ? ['email', 'shared'] : undefined,
+            })) {
+                if (!poolIds.has(h.id))
+                    continue;
+                rel.set(h.id, Math.max(rel.get(h.id) ?? 0, h.score));
+            }
+        }
+    }
+    const maxRel = Math.max(1, ...rel.values());
+    // K8: once the build has looked at sections, a unit about other sections only is off-page.
+    const pageSections = new Set(o.sections ?? []);
+    const offPage = (u) => {
+        if (!pageSections.size)
+            return false;
+        const secs = u.entities
+            .filter((e) => e.startsWith('section:') || e.startsWith('layout:'))
+            .map((e) => e.split(':')[1]);
+        return secs.length > 0 && !secs.some((x) => pageSections.has(x));
+    };
+    const watch = pool
+        // Catalog units (derived sections/layouts/limits/item types/components) are reached through the brief rows and `clay section`.
+        .filter((u) => !used.has(u.id) &&
+        !offPage(u) &&
+        (!CATALOG_KINDS.has(u.kind) || u.authority !== 'derived' || (email && u.kind === 'limit')))
+        .map((u) => {
+        let s = (KIND_RANK[u.kind] ?? 0.5) + (SEVERITY_RANK[u.severity ?? ''] ?? 0) * 0.6;
+        // K11 F1: a Critical unit wins a near-tie anywhere in the ranking (BM25 drift from an unrelated unit edit pushed
+        // policy.mode-b.precedence out by 0.05 in run G service). The cut itself is guarded by guardCriticalAtCut (G1).
+        if (u.severity === 'Critical')
+            s += CRITICAL_EDGE;
+        if (u.entities.includes(skillEntity(o.skill)))
+            s += 1;
+        if (offSkill(u, o.skill))
+            s -= 2.5;
+        if (o.mode && u.modes?.includes(o.mode))
+            s += 1.5;
+        s += 3 * ((rel.get(u.id) ?? 0) / maxRel);
+        const touches = u.entities.filter((e) => candidateEntities.has(e));
+        if (touches.some((e) => e.startsWith('layout:')))
+            s += 2.5;
+        else if (touches.length)
+            s += 1.2;
+        return { u, s };
+    })
+        .sort((a, b) => b.s - a.s || (a.u.id < b.u.id ? -1 : 1));
+    const lines = [];
+    const more = [];
+    const footerReserve = 140;
+    // Email routes have no procedure bodies (the steps stay in the skill): inline the top-ranked units' bodies instead.
+    if (email) {
+        const key = [];
+        for (const { u } of watch.slice(0, 6)) {
+            if (key.length >= 3 || u.kind === 'limit')
+                continue;
+            const b = `### ${u.id}\n${u.body}`;
+            if (estimateTokens([...blocks, '## Key units', ...key, b].join('\n')) > budget * 0.65)
+                continue;
+            key.push(b);
+            used.add(u.id);
+            out.push({ id: u.id, tier: 'watch', inlined: 'body' });
+        }
+        if (key.length)
+            blocks.push(`## Key units (top-ranked for this stage, inlined)\n${key.join('\n\n')}`);
+    }
+    // A unit the build already saw keeps its rank slot but is not printed again (K8: no refill, so later stages shrink).
+    const watchMax = compact ? WATCH_MAX_COMPACT : WATCH_MAX;
+    let slots = 0;
+    let seenSkipped = 0;
+    // K11 G1: a Critical unit in a near-tie at the Watch cut is never pushed out by a Minor one.
+    const ranked = guardCriticalAtCut(watch.filter(({ u }) => !used.has(u.id)), watchMax, ({ u }) => seenLine(u.id));
+    for (const { u } of ranked) {
+        if (used.has(u.id))
+            continue;
+        if (seenLine(u.id)) {
+            if (slots < watchMax) {
+                slots++;
+                seenSkipped++;
+            }
+            used.add(u.id);
+            continue;
+        }
+        const line = `- \`${u.id}\`${u.severity ? ` (${u.severity})` : ''} — ${u.summary}`;
+        if (slots < watchMax &&
+            estimateTokens([...blocks, '## Watch', ...lines, line].join('\n')) <= budget - footerReserve) {
+            slots++;
+            lines.push(line);
+            used.add(u.id);
+            out.push({ id: u.id, tier: 'watch', inlined: 'summary' });
+        }
+        else
+            more.push(u.id);
+    }
+    if (lines.length)
+        blocks.push(`## Watch (this stage; ranked by severity, brief and candidates)${seenSkipped ? ` — ${seenSkipped} more listed earlier this session` : ''}\n${lines.join('\n')}`);
+    /* 5 · More */
+    if (more.length) {
+        const ids = [];
+        for (const id of more) {
+            if (ids.length >= (compact ? 8 : MORE_MAX))
+                break;
+            const t = `## More (\`pnpm clay get <id>\`; ${more.length} more units tagged ${o.stage})\n${[...ids, id].join(' · ')}`;
+            if (!room(t))
+                break;
+            ids.push(id);
+        }
+        if (ids.length) {
+            blocks.push(`## More (\`pnpm clay get <id>\`; ${more.length} more units tagged ${o.stage})\n${ids.join(' · ')}`);
+            for (const id of ids)
+                out.push({ id, tier: 'more', inlined: 'id' });
+        }
+    }
+    const text = render(blocks);
+    return { text, tokens: estimateTokens(text), budget, units: out, brief: briefRows };
+}
+/**
+ * K11 G1 — the Critical guarantee at the Watch cut: a Minor unit never pushes a competing Critical unit out of Watch.
+ *
+ * `ranked` is the Watch ranking (best first, CRITICAL_EDGE included); its first `n` entries take the Watch slots (an
+ * entry the build already saw takes a slot unprinted). A Critical entry below the cut *competes* for the cut when it
+ * scores within `margin` of the lowest-ranked Minor entry above the cut; the two then swap: the Critical takes the last
+ * kept place, the Minor heads the rest (More). Repeated pairwise (next Critical below, next Minor above) while the pair
+ * is a near-tie. Nothing else moves, and a seen entry neither swaps in (it would print nothing) nor out.
+ *
+ * Why this rule (G1): CRITICAL_EDGE alone is a nudge, so BM25 drift from unrelated unit edits kept flipping
+ * `policy.mode-b.precedence` (Critical) against `gotcha.TrustSection.layout-props` (Minor) in run F/G service; raising
+ * the edge reorders every route. The swap acts only at the cut and only against a Minor — two severity tiers below,
+ * already 1.2 behind on severity weight, so a Minor that still ties a Critical does so on brief relevance alone. A
+ * Major, one tier below, keeps its slot (a Major/Critical near-tie is the ranking working: every no-brief route has
+ * several at the 0.1 score quantum, and swapping them reshuffled ROUTING.md). Units with no severity (procedures,
+ * stats) are not ranked by severity and never swap out. The margin sits in the gap of the run E/F/G route corpus
+ * (Minor/Critical near-ties at ≤ 0.09 and ≥ 0.19) and is 5× the 0.03 deficit precedence had.
+ */
+export function guardCriticalAtCut(ranked, n, seen = () => false, margin = CRITICAL_CUT_MARGIN) {
+    const r = [...ranked];
+    if (n <= 0 || r.length <= n)
+        return r;
+    let below = n; // next Critical candidate below the cut
+    let above = n - 1; // next Minor candidate above the cut
+    for (;;) {
+        while (below < r.length && (r[below].u.severity !== 'Critical' || seen(r[below])))
+            below++;
+        while (above >= 0 && (r[above].u.severity !== 'Minor' || seen(r[above])))
+            above--;
+        if (below >= r.length || above < 0 || r[above].s - r[below].s > margin)
+            return r;
+        // The Critical takes the last kept place, the Minor heads the rest; everything else keeps its order.
+        const c = r[below];
+        const m = r[above];
+        r.splice(below, 1);
+        r.splice(above, 1);
+        r.splice(n - 1, 0, c, m);
+        below++;
+        above--;
+    }
+}
+//# sourceMappingURL=route.js.map