cclaw-cli 0.51.30 → 0.55.2

package/dist/artifact-linter.js

@@ -1,1433 +1,19 @@
 import fs from "node:fs/promises";
-import { createHash } from "node:crypto";
-import path from "node:path";
 import { resolveArtifactPath as resolveStageArtifactPath } from "./artifact-paths.js";
 import { readConfig } from "./config.js";
-import { RUNTIME_ROOT, SHIP_FINALIZATION_MODES } from "./constants.js";
 import { exists } from "./fs-utils.js";
 import { stageSchema } from "./content/stage-schema.js";
-import { CONFIDENCE_FINDING_REGEX_SOURCE, FORBIDDEN_PLACEHOLDER_TOKENS } from "./content/skills.js";
-import { FLOW_STAGES } from "./types.js";
-async function resolveNamedArtifactPath(projectRoot, fileName) {
-    const relPath = path.join(RUNTIME_ROOT, "artifacts", fileName);
-    const absPath = path.join(projectRoot, relPath);
-    return { absPath, relPath };
-}
-function normalizeHeadingTitle(title) {
-    return title.trim().replace(/\s+/g, " ");
-}
-/**
- * Collect H2 sections and body content (`## Section Name`).
- *
- * - Ignores lines that live inside fenced code blocks (``` / ~~~) so a
- *   commented `## Approaches` inside an example doesn't open a phantom
- *   section and swallow real content.
- * - When the same heading appears more than once at the top level we
- *   concatenate the bodies rather than silently overwriting the earlier
- *   occurrence. This keeps lint rules honest when authors split a section
- *   into multiple passes.
- */
-function extractH2Sections(markdown) {
-    const sections = new Map();
-    const lines = markdown.split(/\r?\n/);
-    let currentHeading = null;
-    let buffer = [];
-    let fenced = null;
-    const flush = () => {
-        if (currentHeading === null)
-            return;
-        const existing = sections.get(currentHeading);
-        const body = buffer.join("\n");
-        sections.set(currentHeading, existing === undefined ? body : `${existing}\n${body}`);
-    };
-    for (const line of lines) {
-        const fenceMatch = /^(```|~~~)/u.exec(line);
-        if (fenceMatch) {
-            if (fenced === null) {
-                fenced = fenceMatch[1] ?? null;
-            }
-            else if (line.startsWith(fenced)) {
-                fenced = null;
-            }
-            if (currentHeading !== null)
-                buffer.push(line);
-            continue;
-        }
-        if (fenced === null) {
-            const match = /^##\s+(.+)$/u.exec(line);
-            if (match) {
-                flush();
-                currentHeading = normalizeHeadingTitle(match[1] ?? "");
-                buffer = [];
-                continue;
-            }
-        }
-        if (currentHeading !== null) {
-            buffer.push(line);
-        }
-    }
-    flush();
-    return sections;
-}
-function headingPresent(sections, section) {
-    const want = normalizeHeadingTitle(section).toLowerCase();
-    for (const h of sections.keys()) {
-        if (h.toLowerCase() === want) {
-            return true;
-        }
-    }
-    return false;
-}
-function sectionBodyByName(sections, section) {
-    const want = normalizeHeadingTitle(section).toLowerCase();
-    for (const [heading, body] of sections.entries()) {
-        if (heading.toLowerCase() === want) {
-            return body;
-        }
-    }
-    return null;
-}
-function sectionBodyByAnyName(sections, sectionNames) {
-    const bodies = sectionNames.flatMap((section) => {
-        const body = sectionBodyByName(sections, section);
-        return body === null ? [] : [`### ${section}\n${body}`];
-    });
-    if (bodies.length === 0)
-        return null;
-    return bodies.join("\n");
-}
-function sectionBodyByHeadingPrefix(sections, prefix) {
-    const want = normalizeHeadingTitle(prefix).toLowerCase();
-    for (const [heading, body] of sections.entries()) {
-        if (heading.toLowerCase().startsWith(want)) {
-            return body;
-        }
-    }
-    return null;
-}
-/**
- * Build a regex that matches `<field>: <value>` even when the field name
- * and/or value are wrapped in markdown emphasis (`*`, `**`, `_`, `__`).
- *
- * The shipped templates render fields as `- **Field name:** value`, so any
- * structural check that searches for `Field:\s*token` against the rendered
- * artifact must tolerate the closing `**` between the colon and the value.
- *
- * `field` is treated as literal text (regex meta-characters are escaped).
- * `value` is inserted verbatim so callers can pass alternation
- * (`STARTUP|BUILDER|...`). `flags` defaults to case-insensitive Unicode.
- */
-function markdownFieldRegex(field, value, flags = "iu") {
-    const escapedField = field.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-    const emph = "[*_]{0,2}";
-    const source = `(?:^|[\\s>])${emph}\\s*${escapedField}\\s*${emph}\\s*:\\s*${emph}\\s*(?:${value})\\b`;
-    return new RegExp(source, flags);
-}
-export function extractMarkdownSectionBody(markdown, section) {
-    return sectionBodyByName(extractH2Sections(markdown), section);
-}
-function headingLineIndex(markdown, section) {
-    const want = normalizeHeadingTitle(section).toLowerCase();
-    const lines = markdown.split(/\r?\n/);
-    let fenced = null;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const fence = /^\s*(```+|~~~+)\s*([A-Za-z0-9_-]+)?\s*$/u.exec(line);
-        if (fence) {
-            const marker = fence[1];
-            if (fenced === null) {
-                fenced = marker;
-            }
-            else if (fenced === marker) {
-                fenced = null;
-            }
-            continue;
-        }
-        if (fenced !== null)
-            continue;
-        const heading = /^##\s+(.+)$/u.exec(line);
-        if (!heading)
-            continue;
-        if (normalizeHeadingTitle(heading[1] ?? "").toLowerCase() === want) {
-            return i;
-        }
-    }
-    return -1;
-}
-function parseShortCircuitStatus(sectionBody) {
-    if (!sectionBody)
-        return "";
-    const lines = sectionBody.split(/\r?\n/u);
-    return lines
-        .map((line) => line.replace(/[*_`]/gu, "").trim())
-        .map((line) => /^[-*]?\s*status\s*:\s*(.+)$/iu.exec(line)?.[1] ?? "")
-        .find((value) => value.trim().length > 0)?.trim().toLowerCase() ?? "";
-}
-function isShortCircuitActivated(sectionBody) {
-    const statusValue = parseShortCircuitStatus(sectionBody);
-    return /^(?:activated|yes|true)$/u.test(statusValue) || /\bactivated\b/iu.test(statusValue);
-}
-const DESIGN_DIAGRAM_REQUIREMENTS = {
-    lightweight: [
-        {
-            section: "Architecture Diagram",
-            marker: "architecture",
-            note: "Architecture diagram is required for all tiers."
-        }
-    ],
-    standard: [
-        {
-            section: "Architecture Diagram",
-            marker: "architecture",
-            note: "Architecture diagram is required for all tiers."
-        },
-        {
-            section: "Data-Flow Shadow Paths",
-            marker: "data-flow-shadow-paths",
-            note: "Standard+ requires data-flow shadow path coverage."
-        },
-        {
-            section: "Error Flow Diagram",
-            marker: "error-flow",
-            note: "Standard+ requires explicit error-flow rescue mapping."
-        }
-    ],
-    deep: [
-        {
-            section: "Architecture Diagram",
-            marker: "architecture",
-            note: "Architecture diagram is required for all tiers."
-        },
-        {
-            section: "Data-Flow Shadow Paths",
-            marker: "data-flow-shadow-paths",
-            note: "Standard+ requires data-flow shadow path coverage."
-        },
-        {
-            section: "Error Flow Diagram",
-            marker: "error-flow",
-            note: "Standard+ requires explicit error-flow rescue mapping."
-        },
-        {
-            section: "State Machine Diagram",
-            marker: "state-machine",
-            note: "Deep tier requires state-machine coverage for lifecycle transitions."
-        },
-        {
-            section: "Rollback Flowchart",
-            marker: "rollback-flowchart",
-            note: "Deep tier requires rollback flowchart coverage."
-        },
-        {
-            section: "Deployment Sequence Diagram",
-            marker: "deployment-sequence",
-            note: "Deep tier requires deployment sequence coverage."
-        }
-    ]
-};
-function normalizeDesignDiagramTier(value) {
-    if (!value)
-        return null;
-    const normalized = value.trim().toLowerCase();
-    if (/^(?:lite|light|lightweight)$/u.test(normalized))
-        return "lightweight";
-    if (/^standard$/u.test(normalized))
-        return "standard";
-    if (/^deep$/u.test(normalized))
-        return "deep";
-    return null;
-}
-function parseApproachTierSection(sectionBody) {
-    if (!sectionBody)
-        return null;
-    for (const line of sectionBody.split(/\r?\n/u)) {
-        const cleaned = line.replace(/[*_`]/gu, "").trim();
-        const directMatch = /(?:^|\b)tier\s*:\s*(lite|lightweight|light|standard|deep)\b/iu.exec(cleaned);
-        if (directMatch) {
-            const captured = directMatch[1] ?? "";
-            const remainder = cleaned.slice(cleaned.toLowerCase().indexOf("tier") + 4);
-            const tierTokens = remainder.match(/\b(?:lite|lightweight|light|standard|deep)\b/giu) ?? [];
-            const distinct = new Set(tierTokens.map((token) => token.toLowerCase()));
-            if (distinct.size >= 2) {
-                // Multi-token line is the unfilled template placeholder
-                // (`Tier: lite | standard | deep`); treat as no decision.
-                continue;
-            }
-            return normalizeDesignDiagramTier(captured);
-        }
-    }
-    const token = /\b(lite|lightweight|light|standard|deep)\b/iu.exec(sectionBody)?.[1] ?? null;
-    return normalizeDesignDiagramTier(token);
-}
-async function resolveDesignDiagramTier(projectRoot, track, designRaw) {
-    const fromDesign = parseApproachTierSection(extractMarkdownSectionBody(designRaw, "Approach Tier"));
-    if (fromDesign) {
-        return { tier: fromDesign, source: "design-artifact:Approach Tier" };
-    }
-    try {
-        const brainstormArtifact = await resolveStageArtifactPath("brainstorm", {
-            projectRoot,
-            track,
-            intent: "read"
-        });
-        if (await exists(brainstormArtifact.absPath)) {
-            const brainstormRaw = await fs.readFile(brainstormArtifact.absPath, "utf8");
-            const fromBrainstorm = parseApproachTierSection(extractMarkdownSectionBody(brainstormRaw, "Approach Tier"));
-            if (fromBrainstorm) {
-                return { tier: fromBrainstorm, source: "brainstorm-artifact:Approach Tier" };
-            }
-        }
-    }
-    catch {
-        // Ignore read/resolve errors and fall back to default tier.
-    }
-    return { tier: "standard", source: "default:standard" };
-}
-function meaningfulLineCount(sectionBody) {
-    return sectionBody
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0)
-        .filter((line) => !line.startsWith("<!--"))
-        .filter((line) => !/^[-:| ]+$/u.test(line))
-        .filter((line) => /[\p{L}\p{N}]/u.test(line))
-        .length;
-}
-function lineHasToken(line, token) {
-    return new RegExp(`\\b${token}\\b`, "u").test(line);
-}
-function countListItems(sectionBody) {
-    const lines = sectionBody.split(/\r?\n/).map((line) => line.trim());
-    const bullets = lines.filter((line) => /^[-*]\s+\S+/u.test(line)).length;
-    const tableRows = lines.filter((line) => /^\|.*\|$/u.test(line) && !/^\|[-:| ]+\|$/u.test(line));
-    const tableDataRows = tableRows.length > 0 ? Math.max(0, tableRows.length - 1) : 0;
-    return Math.max(bullets, tableDataRows);
-}
-function parseMarkdownTableRow(line) {
-    return line
-        .trim()
-        .split("|")
-        .map((cell) => cell.trim())
-        .filter((cell) => cell.length > 0);
-}
-function tableHeaderCells(sectionBody) {
-    const lines = sectionBody.split(/\r?\n/).map((line) => line.trim());
-    const headerIndex = lines.findIndex((line) => /^\|.*\|$/u.test(line));
-    if (headerIndex < 0)
-        return null;
-    const separator = lines[headerIndex + 1];
-    if (!separator || !/^\|[-:| ]+\|$/u.test(separator)) {
-        return null;
-    }
-    return parseMarkdownTableRow(lines[headerIndex]);
-}
-function extractMinItemsFromRule(rule) {
-    const match = /at least\s+(\d+)/iu.exec(rule);
-    if (!match)
-        return null;
-    const parsed = Number.parseInt(match[1] ?? "", 10);
-    return Number.isFinite(parsed) ? parsed : null;
-}
-function tokensFromRule(rule) {
-    const allCaps = rule.match(/\b[A-Z][A-Z0-9_]{2,}\b/g) ?? [];
-    if (allCaps.length > 0) {
-        return [...new Set(allCaps)];
-    }
-    if (/finalization enum token/iu.test(rule)) {
-        return [...SHIP_FINALIZATION_MODES];
-    }
-    if (/final verdict/iu.test(rule)) {
-        return ["APPROVED", "APPROVED_WITH_CONCERNS", "BLOCKED"];
-    }
-    return [];
-}
-const VAGUE_AC_ADJECTIVES = [
-    "fast",
-    "quick",
-    "slow",
-    "fast enough",
-    "quickly",
-    "intuitive",
-    "robust",
-    "reliable",
-    "scalable",
-    "simple",
-    "easy",
-    "user-friendly",
-    "user friendly",
-    "nice",
-    "good",
-    "clean",
-    "secure enough",
-    "responsive",
-    "efficient",
-    "performant",
-    "smooth",
-    "seamless",
-    "modern"
-];
-function isSeparatorRow(line) {
-    return /^\|[-:| ]+\|$/u.test(line);
-}
-function getMarkdownTableRows(sectionBody) {
-    const lines = sectionBody.split(/\r?\n/).map((line) => line.trim());
-    const rows = [];
-    let sawSeparator = false;
-    for (const line of lines) {
-        if (!/^\|.*\|$/u.test(line))
-            continue;
-        if (isSeparatorRow(line)) {
-            sawSeparator = true;
-            continue;
-        }
-        if (!sawSeparator)
-            continue;
-        rows.push(parseMarkdownTableRow(line));
-    }
-    return rows;
-}
-function parseBinaryFlag(value) {
-    const normalized = value.trim().toLowerCase();
-    if (/^(?:y|yes|true|1)$/u.test(normalized))
-        return "yes";
-    if (/^(?:n|no|false|0|none)$/u.test(normalized))
-        return "no";
-    return "unknown";
-}
-function parseKeyedBinaryFlag(value, key) {
-    const match = new RegExp(`${key}\\s*=\\s*(y|yes|true|1|n|no|false|0)`, "iu").exec(value);
-    if (!match)
-        return "unknown";
-    return /^(?:y|yes|true|1)$/iu.test(match[1] ?? "") ? "yes" : "no";
-}
-function parseFailureModeRescueFlag(rescueCell) {
-    const keyed = parseKeyedBinaryFlag(rescueCell, "rescued");
-    if (keyed !== "unknown")
-        return keyed;
-    const direct = parseBinaryFlag(rescueCell);
-    if (direct !== "unknown")
-        return direct;
-    if (/\b(?:no rescue|without rescue|unrescued|no fallback|none|absent)\b/iu.test(rescueCell)) {
-        return "no";
-    }
-    if (/\b(?:fallback|retry|degrade|recover|rescue|mitigat)\b/iu.test(rescueCell)) {
-        return "yes";
-    }
-    return "unknown";
-}
-function parseFailureModeTestFlag(rowText) {
-    const keyed = parseKeyedBinaryFlag(rowText, "test");
-    if (keyed !== "unknown")
-        return keyed;
-    if (/\b(?:no tests?|untested|without tests?)\b/iu.test(rowText)) {
-        return "no";
-    }
-    if (/\b(?:tested|has tests?|with tests?|covered by tests?)\b/iu.test(rowText)) {
-        return "yes";
-    }
-    return "unknown";
-}
-function validateFailureModeTable(sectionBody) {
-    const header = tableHeaderCells(sectionBody);
-    if (!header) {
-        return {
-            ok: false,
-            details: "Failure Mode Table must include a markdown header row and separator."
-        };
-    }
-    const expectedHeader = ["Method", "Exception", "Rescue", "UserSees"];
-    const normalizedHeader = header.map((cell) => cell.toLowerCase());
-    const normalizedExpected = expectedHeader.map((cell) => cell.toLowerCase());
-    const headerMatches = normalizedHeader.length === normalizedExpected.length &&
-        normalizedHeader.every((cell, index) => cell === normalizedExpected[index]);
-    if (!headerMatches) {
-        return {
-            ok: false,
-            details: `Failure Mode Table header must be exactly: ${expectedHeader.join(" | ")}.`
-        };
-    }
-    const rows = getMarkdownTableRows(sectionBody);
-    if (rows.length === 0) {
-        return {
-            ok: false,
-            details: "Failure Mode Table must include at least one data row."
-        };
-    }
-    for (const [index, row] of rows.entries()) {
-        if (row.length < 4) {
-            return {
-                ok: false,
-                details: `Failure Mode Table row ${index + 1} must provide 4 columns (Method, Exception, Rescue, UserSees).`
-            };
-        }
-        const method = (row[0] ?? "").trim();
-        const exception = (row[1] ?? "").trim();
-        const rescue = (row[2] ?? "").trim();
-        const userSees = (row[3] ?? "").trim();
-        if (!method || !exception || !rescue || !userSees) {
-            return {
-                ok: false,
-                details: `Failure Mode Table row ${index + 1} must populate all columns (Method, Exception, Rescue, UserSees).`
-            };
-        }
-        const rescueFlag = parseFailureModeRescueFlag(rescue);
-        const testFlag = parseFailureModeTestFlag(`${method} ${exception} ${rescue} ${userSees}`);
-        const userSilent = /\bsilent\b/iu.test(userSees);
-        if (rescueFlag === "no" && testFlag === "no" && userSilent) {
-            return {
-                ok: false,
-                details: `Failure Mode Table CRITICAL row ${index + 1} (${method}): RESCUED=N + TEST=N + UserSees=Silent. Add rescue path, add test coverage, or make user impact explicit.`
-            };
-        }
-    }
-    return {
-        ok: true,
-        details: "Failure Mode Table header and critical-risk checks passed."
-    };
-}
-// Canonical scope mode tokens (gstack CEO review). The four mode names live in
-// the scope skill, the artifact template, and downstream traces. Requiring one
-// of them in Scope Summary is **structural** — not free-form English keyword
-// matching on user prose. Authors may also use the canonical short form on a
-// `Mode:` / `Selected mode:` line (e.g. `Selected mode: hold`) as a courtesy.
-const SCOPE_MODE_FULL_TOKENS = [
-    "SCOPE EXPANSION",
-    "SELECTIVE EXPANSION",
-    "HOLD SCOPE",
-    "SCOPE REDUCTION"
-];
-const SCOPE_MODE_FULL_REGEX = new RegExp("\\b(?:" +
-    SCOPE_MODE_FULL_TOKENS
-        .map((token) => token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\s+/g, "[\\s_-]+"))
-        .join("|") +
-    ")\\b", "iu");
-// Short-form synonyms accepted only when stamped on an explicit `Mode:` /
-// `Selected mode:` / `Scope mode:` line. Plain prose with the same word does
-// not count, so `strict` / `broad` / `narrow` / similar non-mode adjectives
-// remain rejected.
-const SCOPE_MODE_LINE_REGEX = /(?:^|\n)\s*[-*]?\s*\**\s*(?:Selected\s+|Scope\s+)?Mode\**\s*:\s*\**\s*([^\n]+)/iu;
-const SCOPE_MODE_SHORT_TOKEN_REGEX = /\b(?:hold(?:[\s_-]?scope)?|selective(?:[\s_-]?expansion)?|scope[\s_-]?expansion|expansion|scope[\s_-]?reduction|reduction|expand|reduce)\b/iu;
-// Next-stage handoff token. We only enforce the canonical machine-surface stage
-// IDs (`design`, `spec`) plus stable handoff phrases. The surrounding prose may
-// be written in any language — this guards the downstream cross-stage trace,
-// not the wording of the rationale.
-const NEXT_STAGE_HANDOFF_REGEX = /(?:`(?:design|spec)`|\bdesign\b|\bspec\b|next[-\s_]stage|next stage|handoff|hand[-\s]off)/iu;
-function hasCanonicalScopeMode(body) {
-    // Strict: a Mode: / Selected mode: line that picks exactly ONE canonical mode
-    // is the strongest signal. The template scaffolding contains all four mode
-    // tokens inside an instructional `(one of ...)` placeholder; we ignore that
-    // line so authors who never replace the scaffolding still fail validation.
-    for (const match of body.matchAll(new RegExp(SCOPE_MODE_LINE_REGEX, "giu"))) {
-        const raw = (match[1] ?? "").trim();
-        const sanitized = raw.replace(/\(.*?\)/gu, "").trim();
-        if (sanitized.length === 0)
-            continue;
-        if (countCanonicalModeMentions(sanitized) === 1)
-            return true;
-        if (countCanonicalModeMentions(sanitized) === 0 && SCOPE_MODE_SHORT_TOKEN_REGEX.test(sanitized))
-            return true;
-    }
-    // Fallback: any line outside an instructional `(one of ...)` placeholder
-    // names exactly one mode. Block lines that list multiple modes (the
-    // unfilled template) or are wrapped in an instructional parenthetical.
-    for (const rawLine of body.split(/\r?\n/u)) {
-        const line = rawLine.trim();
-        if (line.length === 0)
-            continue;
-        if (/\(\s*one\s+of\b/iu.test(line))
-            continue;
-        const sanitized = line.replace(/\(.*?\)/gu, "");
-        if (countCanonicalModeMentions(sanitized) === 1)
-            return true;
-    }
-    return false;
-}
-function countCanonicalModeMentions(text) {
-    const matches = text.match(new RegExp(SCOPE_MODE_FULL_REGEX, "giu"));
-    return matches ? matches.length : 0;
-}
-function validatePremiseChallenge(sectionBody) {
-    // gstack-style premise challenge requires a real Q/A structure (table or
-    // list), not free-form prose. The validation is *structural* only — we do
-    // NOT keyword-grep for English phrases like "right problem"; authors may
-    // write the questions in any language, and the answers carry the meaning.
-    // The template ships with canonical question labels as scaffolding, but
-    // the linter only enforces that the section actually compares premise
-    // questions to answers.
-    const tableRows = getMarkdownTableRows(sectionBody);
-    const bulletRows = sectionBody
-        .split(/\r?\n/u)
-        .map((line) => line.trim())
-        .filter((line) => /^(?:[-*]|\d+\.)\s+\S/u.test(line));
-    const rowCount = Math.max(tableRows.length, bulletRows.length);
-    if (rowCount < 3) {
-        return {
-            ok: false,
-            details: `Premise Challenge needs at least 3 substantive rows in a table or bullet list. Found ${rowCount}.`
-        };
-    }
-    // For tables, each data row must have at least 2 non-empty cells so the
-    // section is genuinely a premise/answer comparison, not a list of headlines.
-    // For bullet lists, each line must be substantive so we don't accept
-    // placeholders like `- a`; punctuation style and natural language do not
-    // matter.
-    if (tableRows.length >= 3) {
-        const sparseRows = tableRows.filter((row) => {
-            const filledCells = row.filter((cell) => cell.replace(/[\s|]/gu, "").length >= 2);
-            return filledCells.length < 2;
-        });
-        if (sparseRows.length > 0) {
-            return {
-                ok: false,
-                details: "Premise Challenge table rows must populate at least the question and answer columns (no empty answers)."
-            };
-        }
-    }
-    else if (bulletRows.length >= 3) {
-        const sparseBullets = bulletRows.filter((line) => {
-            const cleaned = line.replace(/^[-*\d.\s]+/u, "").replace(/[`*_]/gu, "").trim();
-            const meaningful = cleaned.match(/[\p{L}\p{N}]/gu)?.length ?? 0;
-            return meaningful < 12;
-        });
-        if (sparseBullets.length > 0) {
-            return {
-                ok: false,
-                details: "Premise Challenge bullet list must include at least 3 substantive rows, not placeholders."
-            };
-        }
-    }
-    return {
-        ok: true,
-        details: `Premise Challenge structures ${rowCount} Q/A rows.`
-    };
-}
-function validateScopeSummary(sectionBody) {
-    const meaningfulLines = sectionBody
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0 && /[\p{L}\p{N}]/u.test(line));
-    if (meaningfulLines.length < 2) {
-        return {
-            ok: false,
-            details: "Scope Summary must list at least 2 substantive lines covering the selected mode and the next-stage handoff."
-        };
-    }
-    if (!hasCanonicalScopeMode(sectionBody)) {
-        return {
-            ok: false,
-            details: "Scope Summary must name the selected mode using a canonical token (SCOPE EXPANSION, SELECTIVE EXPANSION, HOLD SCOPE, SCOPE REDUCTION) or a short form on a `Mode:` line (hold, selective, expansion, reduction)."
-        };
-    }
-    if (!NEXT_STAGE_HANDOFF_REGEX.test(sectionBody)) {
-        return {
-            ok: false,
-            details: "Scope Summary must record the track-aware next-stage handoff (mention `design` for standard, `spec` for medium, or include a `Next-stage handoff:` line)."
-        };
-    }
-    return {
-        ok: true,
-        details: "Scope Summary names the selected mode and the next-stage handoff."
-    };
-}
-const APPROACH_ROLE_VALUES = ["baseline", "challenger", "wild-card"];
-const APPROACH_UPSIDE_VALUES = ["low", "modest", "high", "higher"];
-const REQUIREMENT_PRIORITY_VALUES = ["P0", "P1", "P2", "P3", "DROPPED"];
-function normalizeTableToken(value) {
-    return value
-        .replace(/[`*_]/gu, "")
-        .trim()
-        .toLowerCase()
-        .replace(/\s+/gu, "-");
-}
-function columnIndex(header, expected) {
-    return header.findIndex((cell) => normalizeTableToken(cell) === expected);
-}
-function validateApproachesTaxonomy(sectionBody) {
-    const header = tableHeaderCells(sectionBody);
-    const rows = getMarkdownTableRows(sectionBody);
-    if (!header) {
-        return {
-            rowCount: 0,
-            roleUpsideOk: false,
-            challengerOk: false,
-            details: "Approaches must be a markdown table with canonical Role and Upside columns."
-        };
-    }
-    const roleIndex = columnIndex(header, "role");
-    const upsideIndex = columnIndex(header, "upside");
-    if (roleIndex < 0 || upsideIndex < 0) {
-        const firstColumnTokens = rows.map((row) => normalizeTableToken(row[0] ?? ""));
-        const appearsTransposed = firstColumnTokens.includes("role") || firstColumnTokens.includes("upside");
-        return {
-            rowCount: rows.length,
-            roleUpsideOk: false,
-            challengerOk: false,
-            details: appearsTransposed
-                ? "Approaches table appears transposed: `Role`/`Upside` are rows, but must be columns. Use `| Approach | Role | Upside | ... |` with one approach per row."
-                : "Approaches table must include canonical `Role` and `Upside` columns (Role: baseline | challenger | wild-card; Upside: low | modest | high | higher)."
-        };
-    }
-    let challengerRows = 0;
-    let challengerHasHighUpside = false;
-    for (const [index, row] of rows.entries()) {
-        const role = normalizeTableToken(row[roleIndex] ?? "");
-        const upside = normalizeTableToken(row[upsideIndex] ?? "");
-        if (!APPROACH_ROLE_VALUES.includes(role)) {
-            return {
-                rowCount: rows.length,
-                roleUpsideOk: false,
-                challengerOk: false,
-                details: `Approaches row ${index + 1} has invalid Role "${row[roleIndex] ?? ""}". Expected one of: ${APPROACH_ROLE_VALUES.join(", ")}.`
-            };
-        }
-        if (!APPROACH_UPSIDE_VALUES.includes(upside)) {
-            return {
-                rowCount: rows.length,
-                roleUpsideOk: false,
-                challengerOk: false,
-                details: `Approaches row ${index + 1} has invalid Upside "${row[upsideIndex] ?? ""}". Expected one of: ${APPROACH_UPSIDE_VALUES.join(", ")}.`
-            };
-        }
-        if (role === "challenger") {
-            challengerRows += 1;
-            if (upside === "high" || upside === "higher") {
-                challengerHasHighUpside = true;
-            }
-        }
-    }
-    const challengerOk = challengerRows === 1 && challengerHasHighUpside;
-    return {
-        rowCount: rows.length,
-        roleUpsideOk: true,
-        challengerOk,
-        details: challengerOk
-            ? "Approaches table uses canonical Role/Upside values and exactly one high/higher-upside challenger."
-            : `Approaches table must include exactly one challenger row with Upside high or higher. Found ${challengerRows} challenger row(s).`
-    };
-}
-function validateCalibratedSelfReview(sectionBody) {
-    const statusLineMatch = /^\s*-\s*Status:\s*(.*)$/imu.exec(sectionBody);
-    const statusValue = statusLineMatch ? statusLineMatch[1].trim() : "";
-    const mentionsApproved = /\bApproved\b/iu.test(statusValue);
-    const mentionsIssuesFound = /\bIssues Found\b/iu.test(statusValue);
-    const statusPickedExactlyOne = statusLineMatch !== null && (mentionsApproved !== mentionsIssuesFound);
-    const hasPatchesHeader = /^\s*-\s*Patches applied:/imu.test(sectionBody);
-    const hasConcernsHeader = /^\s*-\s*Remaining concerns:/imu.test(sectionBody);
-    if (statusPickedExactlyOne && hasPatchesHeader && hasConcernsHeader) {
-        return {
-            ok: true,
-            details: "Self-Review Notes use the calibrated review prompt format."
-        };
-    }
-    const problems = [];
-    if (!statusLineMatch) {
-        problems.push("missing `- Status:` line");
-    }
-    else if (!mentionsApproved && !mentionsIssuesFound) {
-        problems.push("`- Status:` must include `Approved` or `Issues Found`");
-    }
-    else if (mentionsApproved && mentionsIssuesFound) {
-        problems.push("`- Status:` must pick exactly one of `Approved` or `Issues Found` (the placeholder `Approved | Issues Found` is not a decision)");
-    }
-    if (!hasPatchesHeader)
-        problems.push("missing `- Patches applied:` line");
-    if (!hasConcernsHeader)
-        problems.push("missing `- Remaining concerns:` line");
-    return {
-        ok: false,
-        details: "Self-Review Notes must use the calibrated review prompt format: `- Status: Approved` (or `Issues Found`), `- Patches applied:` (inline note or sub-bullets), and `- Remaining concerns:` (inline note or sub-bullets). Issues: " +
-            problems.join("; ") +
-            "."
-    };
-}
-function validateRequirementsTaxonomy(sectionBody) {
-    const header = tableHeaderCells(sectionBody);
-    if (!header) {
-        return {
-            ok: false,
-            details: "Requirements must be a markdown table with a Priority column."
-        };
-    }
-    const priorityIndex = columnIndex(header, "priority");
-    if (priorityIndex < 0) {
-        return {
-            ok: false,
-            details: "Requirements table must include a canonical `Priority` column."
-        };
-    }
-    const rows = getMarkdownTableRows(sectionBody);
-    if (rows.length === 0) {
-        return {
-            ok: false,
-            details: "Requirements table must include at least one requirement row."
-        };
-    }
-    for (const [index, row] of rows.entries()) {
-        const rawPriority = (row[priorityIndex] ?? "").replace(/[`*_]/gu, "").trim().toUpperCase();
-        if (!REQUIREMENT_PRIORITY_VALUES.includes(rawPriority)) {
-            return {
-                ok: false,
-                details: `Requirements row ${index + 1} has invalid Priority "${row[priorityIndex] ?? ""}". Expected one of: ${REQUIREMENT_PRIORITY_VALUES.join(", ")}.`
-            };
-        }
-    }
-    return {
-        ok: true,
-        details: "Requirements table uses canonical Priority values."
-    };
-}
-function validateLockedDecisionAnchors(sectionBody) {
-    const rows = getMarkdownTableRows(sectionBody);
-    const lines = sectionBody
-        .split(/\r?\n/u)
-        .map((line) => line.trim())
-        .filter((line) => /^[-*]\s+\S/u.test(line));
-    const anchors = [];
-    const issues = [];
-    for (const [index, row] of rows.entries()) {
-        const anchor = (row[0] ?? "").trim().toLowerCase();
-        const decisionText = (row[1] ?? "").trim();
-        if (!/^ld#[0-9a-f]{8}$/u.test(anchor)) {
-            issues.push(`row ${index + 1} has invalid anchor "${row[0] ?? ""}"`);
-            continue;
-        }
-        anchors.push(anchor);
-        if (decisionText.length > 0) {
-            const expected = lockedDecisionHash(decisionText).toLowerCase();
-            if (anchor !== expected) {
-                issues.push(`row ${index + 1} anchor should be ${expected} for its Decision text`);
-            }
-        }
-    }
-    for (const [index, line] of lines.entries()) {
-        const anchor = /\bLD#[0-9a-f]{8}\b/iu.exec(line)?.[0]?.toLowerCase();
-        if (!anchor) {
-            issues.push(`bullet ${index + 1} is missing an LD#<sha8> anchor`);
-            continue;
-        }
-        anchors.push(anchor);
-    }
-    const duplicateAnchors = [...new Set(anchors.filter((anchor, index) => anchors.indexOf(anchor) !== index))];
-    if (duplicateAnchors.length > 0) {
-        issues.push(`duplicate anchors: ${duplicateAnchors.join(", ")}`);
-    }
-    if (anchors.length === 0 && (rows.length > 0 || lines.length > 0)) {
-        issues.push("no LD#<sha8> anchors found");
-    }
-    return {
-        ok: issues.length === 0,
-        anchors: [...new Set(anchors)],
-        details: issues.length === 0
-            ? `${anchors.length} LD#hash anchor(s) recorded with no duplicates.`
-            : issues.join("; ")
-    };
-}
-const INTERACTION_EDGE_CASE_REQUIREMENTS = [
-    { label: "double-click", pattern: /\bdouble[\s-]?click\b/iu },
-    {
-        label: "nav-away-mid-request",
-        pattern: /\b(?:nav(?:igate)?[\s-]?away(?:[\s-]?mid[\s-]?request)?|leave\s+(?:page|view|screen).*(?:request|save|submit)|close\s+tab.*(?:request|save|submit))\b/iu
-    },
-    {
-        label: "10K-result dataset",
-        pattern: /\b(?:10k(?:[\s-]?result)?|10,?000|large[\s-]?result(?:[\s-]?dataset)?)\b/iu
-    },
-    {
-        label: "background-job abandonment",
-        pattern: /\b(?:background[\s-]?job.*abandon(?:ed|ment)?|abandon(?:ed|ment)?.*background[\s-]?job)\b/iu
-    },
-    { label: "zombie connection", pattern: /\bzombie[\s-]?connection\b/iu }
-];
-function validateInteractionEdgeCaseMatrix(sectionBody) {
-    const rows = getMarkdownTableRows(sectionBody);
-    if (rows.length === 0) {
-        return {
-            ok: false,
-            details: "Data Flow must include an Interaction Edge Case matrix table with required rows."
-        };
-    }
-    const seen = new Map();
-    for (const [index, row] of rows.entries()) {
-        const labelCell = (row[0] ?? "").trim();
-        if (!labelCell)
-            continue;
-        const requirement = INTERACTION_EDGE_CASE_REQUIREMENTS.find((candidate) => candidate.pattern.test(labelCell));
-        if (!requirement)
-            continue;
-        if (row.length < 4) {
-            return {
-                ok: false,
-                details: `Interaction Edge Case row "${requirement.label}" must include 4 columns: Edge case | Handled? | Design response | Deferred item.`
-            };
-        }
-        const handled = parseBinaryFlag((row[1] ?? "").trim());
-        const response = (row[2] ?? "").trim();
-        const deferred = (row[3] ?? "").trim();
-        if (handled === "unknown") {
-            return {
-                ok: false,
-                details: `Interaction Edge Case row "${requirement.label}" must mark Handled? as yes/no.`
-            };
-        }
-        if (!response) {
-            return {
-                ok: false,
-                details: `Interaction Edge Case row "${requirement.label}" must describe the design response.`
-            };
-        }
-        if (handled === "no" && (!deferred || /\bnone\b/iu.test(deferred))) {
-            return {
-                ok: false,
-                details: `Interaction Edge Case row "${requirement.label}" is unhandled and must reference a deferred item id (for example D-12).`
-            };
-        }
-        seen.set(requirement.label, true);
-    }
-    const missing = INTERACTION_EDGE_CASE_REQUIREMENTS
-        .map((requirement) => requirement.label)
-        .filter((label) => !seen.has(label));
-    if (missing.length > 0) {
-        return {
-            ok: false,
-            details: `Interaction Edge Case matrix is missing required row(s): ${missing.join(", ")}.`
-        };
-    }
-    return {
-        ok: true,
-        details: "Interaction Edge Case matrix contains all required rows with handled/deferred status."
-    };
-}
-const PRE_SCOPE_AUDIT_SIGNALS = [
-    { label: "git log -30 --oneline", pattern: /\bgit\s+log\b[^\n]*-30[^\n]*\boneline\b/iu },
-    { label: "git diff --stat", pattern: /\bgit\s+diff\b[^\n]*--stat\b/iu },
-    { label: "git stash list", pattern: /\bgit\s+stash\s+list\b/iu },
-    {
-        label: "debt marker scan (TODO|FIXME|XXX|HACK)",
-        pattern: /\b(?:rg|ripgrep)\b[^\n]*(?:TODO|FIXME|XXX|HACK)|\bTODO\b|\bFIXME\b|\bXXX\b|\bHACK\b/iu
-    }
-];
-function validatePreScopeSystemAudit(sectionBody) {
-    const missing = PRE_SCOPE_AUDIT_SIGNALS
-        .filter((signal) => !signal.pattern.test(sectionBody))
-        .map((signal) => signal.label);
-    if (missing.length > 0) {
-        return {
-            ok: false,
-            details: `Pre-Scope System Audit is missing required signal(s): ${missing.join(", ")}.`
-        };
-    }
-    return {
-        ok: true,
-        details: "Pre-Scope System Audit captures git log/diff/stash/debt-marker checks."
-    };
-}
-function normalizeCodebaseInvestigationFileRef(value) {
-    const cleaned = value
-        .replace(/`/gu, "")
-        .replace(/^\s*[-*]\s*/u, "")
-        .trim();
-    if (!cleaned)
-        return null;
-    if (/^(?:file|n\/a|none|\(none\)|tbd|\?)$/iu.test(cleaned))
-        return null;
-    return cleaned;
-}
-function collectCodebaseInvestigationFiles(sectionBody) {
-    const refs = [];
-    for (const row of getMarkdownTableRows(sectionBody)) {
-        const fileCell = normalizeCodebaseInvestigationFileRef(row[0] ?? "");
-        if (fileCell)
-            refs.push(fileCell);
-    }
-    return [...new Set(refs)];
-}
-async function runStaleDiagramAudit(projectRoot, artifactPath, artifactRaw, codebaseInvestigationBody) {
-    const markerCount = (artifactRaw.match(/<!--\s*diagram:\s*[a-z0-9-]+\s*-->/giu) ?? []).length;
-    if (markerCount === 0) {
-        return {
-            ok: false,
-            details: "No diagram markers found in design artifact; stale-diagram baseline cannot be computed."
-        };
-    }
-    let artifactStat;
-    try {
-        artifactStat = await fs.stat(artifactPath);
-    }
-    catch {
-        return {
-            ok: false,
-            details: "Cannot stat design artifact to compute diagram marker baseline."
-        };
-    }
-    const refs = collectCodebaseInvestigationFiles(codebaseInvestigationBody);
-    if (refs.length === 0) {
-        return {
-            ok: false,
-            details: "Codebase Investigation must list at least one blast-radius file for stale-diagram audit."
-        };
-    }
-    const stale = [];
-    const missing = [];
-    let scanned = 0;
-    for (const ref of refs) {
-        const absPath = path.isAbsolute(ref) ? ref : path.join(projectRoot, ref);
-        if (!(await exists(absPath))) {
-            missing.push(ref);
-            continue;
-        }
-        let fileStat;
-        try {
-            fileStat = await fs.stat(absPath);
-        }
-        catch {
-            missing.push(ref);
-            continue;
-        }
-        if (!fileStat.isFile())
-            continue;
-        scanned += 1;
-        if (fileStat.mtimeMs > artifactStat.mtimeMs) {
-            stale.push(ref);
-        }
-    }
-    if (missing.length > 0) {
-        return {
-            ok: false,
-            details: `Stale Diagram Audit could not read blast-radius file(s): ${missing.join(", ")}.`
-        };
-    }
-    if (scanned === 0) {
-        return {
-            ok: false,
-            details: "Stale Diagram Audit found no readable blast-radius files in Codebase Investigation."
-        };
-    }
-    if (stale.length > 0) {
-        return {
-            ok: false,
-            details: `Stale Diagram Audit flagged stale file(s) newer than diagram baseline: ${stale.join(", ")}.`
-        };
-    }
-    return {
-        ok: true,
-        details: `Stale Diagram Audit clear: ${scanned} blast-radius file(s) are not newer than diagram baseline.`
-    };
-}
-const DIAGRAM_ARROW_PATTERN = /(?:<--?>|<?==?>|--?>|->>|=>|-\.->|→|⟶|↦)/u;
-const DIAGRAM_FAILURE_EDGE_PATTERN = /\b(fail(?:ed|ure)?|error|timeout|fallback|degrad(?:e|ed|ation)|retry|backoff|circuit|unavailable|recover(?:y)?|rescue|mitigat(?:e|ion)|rollback|exception|abort|dead[\s-]?letter|dlq)\b/iu;
-const DIAGRAM_GENERIC_NODE_PATTERN = /\b(service|component|module|system)\s*(?:[A-Z0-9])?\b/iu;
-const TEST_COMMAND_MARKER_PATTERN = /\b(?:npm|pnpm|yarn|bun|vitest|jest|pytest|go test|cargo test|mvn test|gradle test|dotnet test)\b/iu;
-const RED_FAILURE_MARKER_PATTERN = /\b(?:fail|failed|failing|assertionerror|cannot find|exception|error|exit code\s*[:=]?\s*[1-9])\b/iu;
-const GREEN_SUCCESS_MARKER_PATTERN = /\b(?:pass|passed|green|ok|0 failed|exit code\s*[:=]?\s*0)\b/iu;
-function diagramEdgeLines(sectionBody) {
-    return sectionBody
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0)
-        .filter((line) => !line.startsWith("```"))
-        .filter((line) => !line.startsWith("%%"))
-        .filter((line) => DIAGRAM_ARROW_PATTERN.test(line));
-}
-function hasFailureEdgeInDiagram(sectionBody) {
-    const lines = diagramEdgeLines(sectionBody);
-    for (const line of lines) {
-        if (DIAGRAM_ARROW_PATTERN.test(line) && DIAGRAM_FAILURE_EDGE_PATTERN.test(line)) {
-            return true;
-        }
-    }
-    return false;
-}
-function hasLabeledDiagramArrow(lines) {
-    return lines.some((line) => /\|[^|]+\|/u.test(line) || /:\s*[A-Za-z]/u.test(line));
-}
-function hasAsyncDiagramEdge(lines) {
-    return lines.some((line) => /-\.->|-->>|~~>|\basync\b/iu.test(line));
-}
-function hasSyncDiagramEdge(lines) {
-    return lines.some((line) => {
-        if (/\bsync\b/iu.test(line))
-            return true;
-        if (!/(-->|->|=>|→|⟶|↦)/u.test(line))
-            return false;
-        return !/-\.->|-->>|~~>/u.test(line);
-    });
-}
-function validateTddRedEvidence(sectionBody) {
-    const meaningful = meaningfulLineCount(sectionBody);
-    if (meaningful < 2) {
-        return {
-            ok: false,
-            details: "RED Evidence must include at least 2 meaningful lines (command plus failing output context)."
-        };
-    }
-    if (!TEST_COMMAND_MARKER_PATTERN.test(sectionBody)) {
-        return {
-            ok: false,
-            details: "RED Evidence must include the test command that produced the failure."
-        };
-    }
-    if (!RED_FAILURE_MARKER_PATTERN.test(sectionBody)) {
-        return {
-            ok: false,
-            details: "RED Evidence must include explicit failing output markers (FAIL/FAILED/AssertionError/exit code != 0)."
-        };
-    }
-    return {
-        ok: true,
-        details: "RED Evidence includes command + failing output markers."
-    };
-}
-function validateTddGreenEvidence(sectionBody) {
-    const meaningful = meaningfulLineCount(sectionBody);
-    if (meaningful < 2) {
-        return {
-            ok: false,
-            details: "GREEN Evidence must include at least 2 meaningful lines (command and passing result)."
-        };
-    }
-    if (!TEST_COMMAND_MARKER_PATTERN.test(sectionBody)) {
-        return {
-            ok: false,
-            details: "GREEN Evidence must include the full-suite test command."
-        };
-    }
-    if (!GREEN_SUCCESS_MARKER_PATTERN.test(sectionBody)) {
-        return {
-            ok: false,
-            details: "GREEN Evidence must include explicit passing markers (PASS/PASSED/OK/exit code 0)."
-        };
-    }
-    return {
-        ok: true,
-        details: "GREEN Evidence includes command + passing output markers."
-    };
-}
-function validateVerificationLadder(sectionBody) {
-    const hasTextLine = /highest tier reached/iu.test(sectionBody);
-    const hasCanonicalTable = hasVerificationLadderTableRow(sectionBody);
-    if (!hasTextLine && !hasCanonicalTable) {
-        return {
-            ok: false,
-            details: "Verification Ladder must include either a 'Highest tier reached' line or a canonical table row (Slice | Tier reached | Evidence) with non-empty tier and evidence."
-        };
-    }
-    if (!/\b(static|command|behavioral|human)\b/iu.test(sectionBody)) {
-        return {
-            ok: false,
-            details: "Verification Ladder must name a tier (static | command | behavioral | human)."
-        };
-    }
-    if (!/\b(evidence|command|sha|commit)\b/iu.test(sectionBody)) {
-        return {
-            ok: false,
-            details: "Verification Ladder must include evidence details (command output or commit SHA)."
-        };
-    }
-    return {
-        ok: true,
-        details: "Verification Ladder includes tier + evidence fields."
-    };
-}
-function hasVerificationLadderTableRow(sectionBody) {
-    const lines = sectionBody.split(/\r?\n/u);
-    let sawHeader = false;
-    let sawSeparator = false;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("|")) {
-            sawHeader = false;
-            sawSeparator = false;
-            continue;
-        }
-        const cells = trimmed
-            .replace(/^\|/u, "")
-            .replace(/\|$/u, "")
-            .split("|")
-            .map((cell) => cell.trim());
-        if (!sawHeader) {
-            const lowered = cells.map((cell) => cell.toLowerCase());
-            const hasTierColumn = lowered.some((cell) => /tier(?:\s+reached)?/u.test(cell));
-            const hasEvidenceColumn = lowered.some((cell) => cell.includes("evidence"));
-            if (hasTierColumn && hasEvidenceColumn) {
-                sawHeader = true;
-                continue;
-            }
-            continue;
-        }
-        if (!sawSeparator) {
-            if (cells.every((cell) => /^[:\-\s]+$/u.test(cell))) {
-                sawSeparator = true;
-                continue;
-            }
-            sawHeader = false;
-            continue;
-        }
-        if (cells.length >= 2 && cells.some((cell) => /\b(static|command|behavioral|human)\b/iu.test(cell))) {
-            const evidenceCellHasContent = cells.some((cell) => cell.length > 0 && !/^\s*$/u.test(cell) && !/^[:\-\s]+$/u.test(cell));
-            if (evidenceCellHasContent) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-const LEARNING_TYPE_SET = new Set(["rule", "pattern", "lesson", "compound"]);
-const LEARNING_CONFIDENCE_SET = new Set(["high", "medium", "low"]);
-const LEARNING_SEVERITY_SET = new Set(["critical", "important", "suggestion"]);
-const LEARNING_UNIVERSALITY_SET = new Set(["project", "personal", "universal"]);
-const LEARNING_MATURITY_SET = new Set(["raw", "lifted-to-rule", "lifted-to-enforcement"]);
-const LEARNING_SOURCE_SET = new Set([
-    "stage",
-    "retro",
-    "compound",
-    "ideate",
-    "manual"
-]);
-const FLOW_STAGE_SET = new Set(FLOW_STAGES);
-const LEARNING_ALLOWED_KEYS = new Set([
-    "type",
-    "trigger",
-    "action",
-    "confidence",
-    "severity",
-    "domain",
-    "stage",
-    "origin_stage",
-    "origin_run",
-    "origin_feature",
-    "frequency",
-    "universality",
-    "maturity",
-    "created",
-    "first_seen_ts",
-    "last_seen_ts",
-    "project",
-    "source",
-    "supersedes",
-    "superseded_by"
-]);
-function isIsoUtcTimestamp(value) {
-    return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/u.test(value);
-}
-function isNullableString(value) {
-    return value === null || typeof value === "string";
-}
-function isNullableStage(value) {
-    return value === null || (typeof value === "string" && FLOW_STAGE_SET.has(value));
-}
-function parseLearningSeedEntry(raw, index) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        return { ok: false, error: `Learnings bullet #${index} must be a JSON object.` };
-    }
-    const obj = raw;
-    for (const key of Object.keys(obj)) {
-        if (!LEARNING_ALLOWED_KEYS.has(key)) {
-            return {
-                ok: false,
-                error: `Learnings bullet #${index} includes unknown key "${key}" (allowed keys mirror knowledge JSONL fields).`
-            };
-        }
-    }
-    const type = typeof obj.type === "string" ? obj.type.toLowerCase() : "";
-    if (!LEARNING_TYPE_SET.has(type)) {
-        return {
-            ok: false,
-            error: `Learnings bullet #${index} must set type to one of: rule, pattern, lesson, compound.`
-        };
-    }
-    const trigger = typeof obj.trigger === "string" ? obj.trigger.trim() : "";
-    if (trigger.length === 0) {
-        return {
-            ok: false,
-            error: `Learnings bullet #${index} must include non-empty "trigger".`
-        };
-    }
-    const action = typeof obj.action === "string" ? obj.action.trim() : "";
-    if (action.length === 0) {
-        return {
-            ok: false,
-            error: `Learnings bullet #${index} must include non-empty "action".`
-        };
-    }
-    const confidence = typeof obj.confidence === "string" ? obj.confidence.toLowerCase() : "";
-    if (!LEARNING_CONFIDENCE_SET.has(confidence)) {
-        return {
-            ok: false,
-            error: `Learnings bullet #${index} must set confidence to high|medium|low.`
-        };
-    }
-    const severity = typeof obj.severity === "string" ? obj.severity.toLowerCase() : undefined;
-    if (severity !== undefined && !LEARNING_SEVERITY_SET.has(severity)) {
-        return {
-            ok: false,
-            error: `Learnings bullet #${index} field "severity" must be critical|important|suggestion.`
-        };
-    }
-    if (obj.domain !== undefined && !isNullableString(obj.domain)) {
-        return { ok: false, error: `Learnings bullet #${index} field "domain" must be string or null.` };
-    }
-    if (obj.stage !== undefined && !isNullableStage(obj.stage)) {
-        return {
-            ok: false,
-            error: `Learnings bullet #${index} field "stage" must be one of ${FLOW_STAGES.join(", ")} or null.`
-        };
-    }
-    if (obj.origin_stage !== undefined && !isNullableStage(obj.origin_stage)) {
-        return {
-            ok: false,
-            error: `Learnings bullet #${index} field "origin_stage" must be one of ${FLOW_STAGES.join(", ")} or null.`
-        };
-    }
-    if (obj.origin_run !== undefined && !isNullableString(obj.origin_run)) {
-        return { ok: false, error: `Learnings bullet #${index} field "origin_run" must be string or null.` };
-    }
-    if (obj.origin_feature !== undefined && !isNullableString(obj.origin_feature)) {
-        return { ok: false, error: `Learnings bullet #${index} field "origin_feature" must be string or null.` };
-    }
-    if (obj.project !== undefined && !isNullableString(obj.project)) {
-        return { ok: false, error: `Learnings bullet #${index} field "project" must be string or null.` };
-    }
-    if (obj.source !== undefined &&
-        obj.source !== null &&
-        (typeof obj.source !== "string" || !LEARNING_SOURCE_SET.has(obj.source))) {
-        return {
-            ok: false,
-            error: `Learnings bullet #${index} field "source" must be stage|retro|compound|ideate|manual or null.`
-        };
-    }
-    if (obj.frequency !== undefined &&
-        (typeof obj.frequency !== "number" || !Number.isInteger(obj.frequency) || obj.frequency < 1)) {
-        return { ok: false, error: `Learnings bullet #${index} field "frequency" must be an integer >= 1.` };
-    }
-    if (obj.universality !== undefined &&
-        (typeof obj.universality !== "string" ||
-            !LEARNING_UNIVERSALITY_SET.has(obj.universality))) {
-        return {
-            ok: false,
-            error: `Learnings bullet #${index} field "universality" must be project|personal|universal.`
-        };
-    }
-    if (obj.maturity !== undefined &&
-        (typeof obj.maturity !== "string" || !LEARNING_MATURITY_SET.has(obj.maturity))) {
-        return {
-            ok: false,
-            error: `Learnings bullet #${index} field "maturity" must be raw|lifted-to-rule|lifted-to-enforcement.`
-        };
-    }
-    for (const timestampField of ["created", "first_seen_ts", "last_seen_ts"]) {
-        const value = obj[timestampField];
-        if (value === undefined)
-            continue;
-        if (typeof value !== "string" || !isIsoUtcTimestamp(value)) {
-            return {
-                ok: false,
-                error: `Learnings bullet #${index} field "${timestampField}" must be ISO UTC (YYYY-MM-DDTHH:MM:SSZ).`
-            };
-        }
-    }
-    if (obj.supersedes !== undefined) {
-        if (!Array.isArray(obj.supersedes) ||
-            obj.supersedes.length === 0 ||
-            obj.supersedes.some((value) => typeof value !== "string" || value.trim().length === 0)) {
-            return { ok: false, error: `Learnings bullet #${index} field "supersedes" must be a non-empty array of strings.` };
-        }
-    }
-    if (obj.superseded_by !== undefined &&
-        (typeof obj.superseded_by !== "string" || obj.superseded_by.trim().length === 0)) {
-        return { ok: false, error: `Learnings bullet #${index} field "superseded_by" must be a non-empty string.` };
-    }
-    return {
-        ok: true,
-        entry: {
-            ...obj,
-            type: type,
-            trigger,
-            action,
-            confidence: confidence,
-            ...(severity ? { severity: severity } : {})
-        }
-    };
-}
-export function parseLearningsSection(sectionBody) {
-    const lines = sectionBody.split(/\r?\n/).map((line) => line.trim());
-    const nonEmpty = lines.filter((line) => line.length > 0);
-    const bullets = nonEmpty.filter((line) => /^-\s+\S+/u.test(line));
-    if (bullets.length === 0) {
-        return {
-            ok: false,
-            none: false,
-            entries: [],
-            errors: ["Learnings section must contain bullet entries."],
-            details: "Learnings section must contain bullet entries."
-        };
-    }
-    const nonBulletContent = nonEmpty.filter((line) => !/^-\s+\S+/u.test(line));
-    if (nonBulletContent.length > 0) {
-        return {
-            ok: false,
-            none: false,
-            entries: [],
-            errors: ["Learnings section must only contain bullet lines (one bullet per learning)."],
-            details: "Learnings section must only contain bullet lines (one bullet per learning)."
-        };
-    }
-    if (bullets.length === 1) {
-        const payload = bullets[0].replace(/^-\s+/u, "").trim();
-        if (/^none this stage\.?$/iu.test(payload)) {
-            return {
-                ok: true,
-                none: true,
-                entries: [],
-                errors: [],
-                details: "Learnings section explicitly marked as none."
-            };
-        }
-    }
-    const entries = [];
-    const errors = [];
-    for (let i = 0; i < bullets.length; i += 1) {
-        const payload = bullets[i].replace(/^-\s+/u, "").trim();
-        let parsed;
-        try {
-            parsed = JSON.parse(payload);
-        }
-        catch (err) {
-            errors.push(`Learnings bullet #${i + 1} must be valid JSON object or "None this stage.": ${err instanceof Error ? err.message : String(err)}`);
-            continue;
-        }
-        const parsedEntry = parseLearningSeedEntry(parsed, i + 1);
-        if (!parsedEntry.ok || !parsedEntry.entry) {
-            errors.push(parsedEntry.error ?? `Learnings bullet #${i + 1} is invalid.`);
-            continue;
-        }
-        entries.push(parsedEntry.entry);
-    }
-    if (errors.length > 0) {
-        return {
-            ok: false,
-            none: false,
-            entries: [],
-            errors,
-            details: errors.join(" | ")
-        };
-    }
-    return {
-        ok: true,
-        none: false,
-        entries,
-        errors: [],
-        details: `Parsed ${entries.length} learning bullet(s) as knowledge-compatible JSON entries.`
-    };
-}
-function lineContainsVagueAdjective(text) {
-    const lower = text.toLowerCase();
-    for (const adjective of VAGUE_AC_ADJECTIVES) {
-        const pattern = new RegExp(`(?:^|[^A-Za-z])${adjective.replace(/ /g, "\\s+")}(?:[^A-Za-z]|$)`, "iu");
-        if (pattern.test(lower))
-            return adjective;
-    }
-    return null;
-}
+import { extractH2Sections, extractLockedDecisionAnchors, extractRequirementIdsFromMarkdown, isShortCircuitActivated, normalizeHeadingTitle, parseFrontmatter, parseLearningsSection, sectionBodyByAnyName, sectionBodyByHeadingPrefix, sectionBodyByName, validateSectionBody } from "./artifact-linter/shared.js";
+import { lintBrainstormStage } from "./artifact-linter/brainstorm.js";
+import { lintDesignStage } from "./artifact-linter/design.js";
+import { lintPlanStage } from "./artifact-linter/plan.js";
+import { lintScopeStage } from "./artifact-linter/scope.js";
+import { lintSpecStage } from "./artifact-linter/spec.js";
+import { lintTddStage } from "./artifact-linter/tdd.js";
+import { lintReviewStage } from "./artifact-linter/review.js";
+import { lintShipStage } from "./artifact-linter/ship.js";
+export { validateReviewArmy, checkReviewVerdictConsistency, checkReviewSecurityNoChangeAttestation } from "./artifact-linter/review-army.js";
+export { extractMarkdownSectionBody, parseLearningsSection } from "./artifact-linter/shared.js";
 const FRONTMATTER_REQUIRED_KEYS = [
     "stage",
     "schema_version",
@@ -1435,244 +21,6 @@ const FRONTMATTER_REQUIRED_KEYS = [
     "locked_decisions",
     "inputs_hash"
 ];
-const PLACEHOLDER_PATTERNS = [
-    { label: "TODO", regex: /\bTODO\b/iu },
-    { label: "TBD", regex: /\bTBD\b/iu },
-    { label: "FIXME", regex: /\bFIXME\b/iu },
-    { label: "<fill-in>", regex: /<fill-in>/iu },
-    { label: "<your-*-here>", regex: /<your-[^>]*-here>/iu },
-    { label: "xxx", regex: /\bxxx\b/iu },
-    { label: "ellipsis", regex: /\.{3}/u }
-];
-const SCOPE_REDUCTION_PATTERNS = [
-    { label: "v1", regex: /\bv1\b/iu },
-    { label: "for now", regex: /\bfor now\b/iu },
-    { label: "later", regex: /\blater\b/iu },
-    { label: "temporary", regex: /\btemporary\b/iu },
-    { label: "placeholder", regex: /\bplaceholder\b/iu },
-    { label: "mock for now", regex: /\bmock for now\b/iu },
-    { label: "hardcoded for now", regex: /\bhardcoded for now\b/iu },
-    { label: "will improve later", regex: /\bwill improve later\b/iu }
-];
-function parseFrontmatter(markdown) {
-    const lines = markdown.split(/\r?\n/);
-    if (lines[0]?.trim() !== "---") {
-        return { hasFrontmatter: false, values: {} };
-    }
-    const endIndex = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
-    if (endIndex < 0) {
-        return { hasFrontmatter: false, values: {} };
-    }
-    const values = {};
-    for (const line of lines.slice(1, endIndex)) {
-        const match = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/u.exec(line.trim());
-        if (!match)
-            continue;
-        const key = match[1];
-        const value = match[2].trim();
-        values[key] = value;
-    }
-    return { hasFrontmatter: true, values };
-}
-function extractDecisionIds(text) {
-    const ids = text.match(/\bD-\d+\b/gu) ?? [];
-    return [...new Set(ids)];
-}
-function extractRequirementIdsFromMarkdown(text) {
-    const ids = text.match(/\bR\d+\b/gu) ?? [];
-    return [...new Set(ids)];
-}
-function extractLockedDecisionAnchors(text) {
-    const ids = text.match(/\bLD#[0-9a-f]{8}\b/giu) ?? [];
-    return [...new Set(ids.map((id) => id.replace(/^LD#/iu, "LD#").toLowerCase()))];
-}
-function lockedDecisionHash(value) {
-    const normalized = value.replace(/\s+/gu, " ").trim().toLowerCase();
-    return `LD#${createHash("sha256").update(normalized).digest("hex").slice(0, 8)}`;
-}
-function collectPatternHits(text, patterns) {
-    const hits = [];
-    for (const pattern of patterns) {
-        if (pattern.regex.test(text)) {
-            hits.push(pattern.label);
-        }
-    }
-    return hits;
-}
-function validateSectionBody(sectionBody, rule, sectionName) {
-    const bodyLines = sectionBody.split(/\r?\n/).map((line) => line.trim());
-    const meaningful = meaningfulLineCount(sectionBody);
-    if (meaningful === 0) {
-        return {
-            ok: false,
-            details: "Section exists but has no meaningful content yet."
-        };
-    }
-    const minItems = extractMinItemsFromRule(rule);
-    if (minItems !== null) {
-        const count = countListItems(sectionBody);
-        if (count < minItems) {
-            return {
-                ok: false,
-                details: `Rule expects at least ${minItems} item(s), found ${count}.`
-            };
-        }
-    }
-    if (/table must use 4 columns/iu.test(rule)) {
-        const header = tableHeaderCells(sectionBody);
-        if (!header) {
-            return {
-                ok: false,
-                details: "Rule expects a markdown table header with a separator row."
-            };
-        }
-        const expected = ["Category", "Question asked", "User answer", "Evidence note"];
-        const normalizedHeader = header.map((cell) => cell.toLowerCase());
-        const normalizedExpected = expected.map((cell) => cell.toLowerCase());
-        const matches = normalizedHeader.length === normalizedExpected.length &&
-            normalizedHeader.every((cell, index) => cell === normalizedExpected[index]);
-        if (!matches) {
-            return {
-                ok: false,
-                details: `Rule expects Clarification Log header: ${expected.join(" | ")}.`
-            };
-        }
-    }
-    if (/exactly one/iu.test(rule)) {
-        const tokens = tokensFromRule(rule);
-        if (tokens.length > 0) {
-            const selected = new Set();
-            const tokenLines = [];
-            for (const line of bodyLines) {
-                if (!line)
-                    continue;
-                for (const token of tokens) {
-                    if (!lineHasToken(line, token))
-                        continue;
-                    tokenLines.push({ line, token });
-                    if (/\[x\]/iu.test(line) || /selected|verdict|enum|execution result|status/iu.test(line)) {
-                        selected.add(token);
-                    }
-                }
-            }
-            if (selected.size === 0 && tokenLines.length === 1 && !tokenLines[0].line.includes("|")) {
-                selected.add(tokenLines[0].token);
-            }
-            if (selected.size !== 1) {
-                return {
-                    ok: false,
-                    details: `Rule expects exactly one selected token (${tokens.join(", ")}); found ${selected.size}.`
-                };
-            }
-            return { ok: true, details: "Exactly one token selected as expected." };
-        }
-    }
-    if (/Status:\s*pending\s+until/iu.test(rule)) {
-        const statusLine = bodyLines.find((l) => /^\s*-?\s*Status\s*:/iu.test(l));
-        if (!statusLine) {
-            return { ok: false, details: "WAIT_FOR_CONFIRM section must contain a 'Status:' line." };
-        }
-        const validStatuses = ["pending", "approved"];
-        const statusMatch = /Status\s*:\s*(\S+)/iu.exec(statusLine);
-        const statusValue = statusMatch?.[1]?.toLowerCase();
-        if (!statusValue || !validStatuses.includes(statusValue)) {
-            const foundLabel = statusValue || "(empty)";
-            return {
-                ok: false,
-                details: "WAIT_FOR_CONFIRM Status must be exactly one of: " + validStatuses.join(", ") + ". Found: " + foundLabel + "."
-            };
-        }
-    }
-    const sectionNameNormalized = normalizeHeadingTitle(sectionName).toLowerCase();
-    if (sectionNameNormalized === "red evidence") {
-        return validateTddRedEvidence(sectionBody);
-    }
-    if (sectionNameNormalized === "green evidence") {
-        return validateTddGreenEvidence(sectionBody);
-    }
-    if (sectionNameNormalized === "verification ladder") {
-        return validateVerificationLadder(sectionBody);
-    }
-    if (sectionNameNormalized === "failure mode table") {
-        return validateFailureModeTable(sectionBody);
-    }
-    if (sectionNameNormalized === "pre-scope system audit") {
-        return validatePreScopeSystemAudit(sectionBody);
-    }
-    if (sectionNameNormalized === "scope summary") {
-        return validateScopeSummary(sectionBody);
-    }
-    if (sectionNameNormalized === "premise challenge") {
-        return validatePremiseChallenge(sectionBody);
-    }
-    if (sectionNameNormalized.startsWith("requirements")) {
-        return validateRequirementsTaxonomy(sectionBody);
-    }
-    if (sectionNameNormalized === "data flow") {
-        return validateInteractionEdgeCaseMatrix(sectionBody);
-    }
-    if (sectionNameNormalized === "architecture diagram") {
-        const edgeLines = diagramEdgeLines(sectionBody);
-        if (edgeLines.length === 0) {
-            return {
-                ok: false,
-                details: "Architecture Diagram must include at least one directional edge line (for example `A -->|action| B`)."
-            };
-        }
-        if (!hasLabeledDiagramArrow(edgeLines)) {
-            return {
-                ok: false,
-                details: "Architecture Diagram must label each edge with an action/message (for example `A -->|sync: persist| B`)."
-            };
-        }
-        const genericLine = edgeLines.find((line) => DIAGRAM_GENERIC_NODE_PATTERN.test(line));
-        if (genericLine) {
-            return {
-                ok: false,
-                details: `Architecture Diagram uses a generic node label in edge "${genericLine}". Use concrete component names instead of placeholders like Service/Component.`
-            };
-        }
-        if (!hasAsyncDiagramEdge(edgeLines) || !hasSyncDiagramEdge(edgeLines)) {
-            return {
-                ok: false,
-                details: "Architecture Diagram must distinguish sync vs async edges (for example solid + dotted arrows, or `sync:` and `async:` labels)."
-            };
-        }
-        if (!hasFailureEdgeInDiagram(sectionBody)) {
-            return {
-                ok: false,
-                details: "Architecture Diagram must include at least one failure-edge arrow with a failure keyword (for example: timeout, error, fallback, degraded, retry)."
-            };
-        }
-    }
-    if (sectionNameNormalized === "acceptance criteria" &&
-        /observable[\s,]*measurable[\s,]+(and )?falsifiable/iu.test(rule)) {
-        const rows = getMarkdownTableRows(sectionBody);
-        for (const row of rows) {
-            const criterionText = row[1] ?? row[0] ?? "";
-            const adjective = lineContainsVagueAdjective(criterionText);
-            if (adjective) {
-                return {
-                    ok: false,
-                    details: `Acceptance criterion uses vague adjective "${adjective}" without a measurable predicate: "${criterionText.slice(0, 140)}". Rewrite with a numeric threshold or boolean outcome.`
-                };
-            }
-            const hasDigit = /\d/u.test(criterionText);
-            const hasMeasurableVerb = /\b(blocks?|rejects?|returns?|matches?|equals?|emits?|succeeds?|fails?|publishes?|logs?|persists?|reads?|writes?|creates?|deletes?|throws?|contains?|restores?|exceeds?|responds?|warns?|quarantines?|includes?|raises?|passes?|denies|refuses|exits|succeeds|completes|prevents|allows|maps|points|signals|surfaces|records|produces|accepts|requires)\b/iu.test(criterionText);
-            const hasMeaningfulText = /[A-Za-z]/u.test(criterionText) && criterionText.trim().length >= 12;
-            if (hasMeaningfulText && !hasDigit && !hasMeasurableVerb) {
-                return {
-                    ok: false,
-                    details: `Acceptance criterion lacks a measurable predicate (no numeric threshold, no observable verb like blocks/returns/publishes/matches): "${criterionText.slice(0, 140)}". Rewrite so the criterion is falsifiable by a single test.`
-                };
-            }
-        }
-    }
-    return {
-        ok: true,
-        details: "Section heading and content satisfy lint heuristics."
-    };
-}
 export async function lintArtifact(projectRoot, stage, track = "standard") {
     const schema = stageSchema(stage, track);
     const { absPath: absFile, relPath: relFile } = await resolveStageArtifactPath(stage, {
@@ -1741,10 +89,10 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
     const brainstormShortCircuitActivated = stage === "brainstorm" && isShortCircuitActivated(brainstormShortCircuitBody);
     const scopePreAuditEnabled = projectConfig.optInAudits?.scopePreAudit === true;
     const staleDiagramAuditEnabled = projectConfig.optInAudits?.staleDiagramAudit === true;
-    const isTrivialOverride = schema.trivialOverrideSections &&
+    const isTrivialOverride = Boolean(schema.trivialOverrideSections &&
         schema.trivialOverrideSections.length > 0 &&
         (/trivial.change|mini.design|escape.hatch/iu.test(raw) ||
-            brainstormShortCircuitActivated);
+            brainstormShortCircuitActivated));
     const overrideSet = isTrivialOverride
         ? new Set(schema.trivialOverrideSections.map((s) => normalizeHeadingTitle(s).toLowerCase()))
         : null;
@@ -1801,935 +149,49 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
             details: `${learnings.details}${meaningfulStageNoneWarning}`
         });
     }
-    if (stage === "brainstorm") {
-        // Brainstorm Iron Law: "NO ARTIFACT IS COMPLETE WITHOUT AN EXPLICITLY
-        // APPROVED DIRECTION — SILENCE IS NOT APPROVAL." Previously this was
-        // prose-only — nothing failed when the Selected Direction section
-        // omitted an approval marker, or when the Approaches table collapsed
-        // to a single row (defeating the "2-3 distinct approaches" gate).
-        const tierBody = sectionBodyByName(sections, "Approach Tier");
-        if (tierBody !== null) {
-            // Token vocabulary covers `lite`, `Lightweight`, `Standard`, and
-            // `Deep` (case-insensitive). A line that lists ≥2 distinct tokens is
-            // the unfilled template placeholder (`Tier: lite | standard | deep`)
-            // and must not silently pass; we look for at least one decision line
-            // with exactly one token, while ignoring placeholder lines.
-            const cleanedLines = tierBody
-                .split("\n")
-                .map((line) => line.replace(/[*_`]/gu, ""));
-            const lineTokenCounts = cleanedLines.map((line) => {
-                const tokens = line.match(/\b(?:lite|lightweight|light|standard|deep)\b/giu) ?? [];
-                return new Set(tokens.map((token) => token.toLowerCase())).size;
-            });
-            const hasDecisionLine = lineTokenCounts.some((count) => count === 1);
-            const hasPlaceholderLine = lineTokenCounts.some((count) => count >= 2);
-            const ok = hasDecisionLine;
-            findings.push({
-                section: "Approach Tier Classification",
-                required: true,
-                rule: "Approach Tier must explicitly classify depth as one of `lite` (a.k.a. `Lightweight`), `Standard`, or `Deep`.",
-                found: ok,
-                details: ok
-                    ? "Approach Tier includes a single recognized depth token."
-                    : hasPlaceholderLine
-                        ? "Approach Tier still lists multiple tier tokens (template placeholder); pick exactly one of `lite`/`Lightweight`, `Standard`, or `Deep`."
-                        : "Approach Tier is missing a recognized depth token (`lite`/`Lightweight`, `Standard`, or `Deep`)."
-            });
-        }
-        const approachesBody = sectionBodyByName(sections, "Approaches");
-        if (approachesBody !== null) {
-            const approachesTaxonomy = validateApproachesTaxonomy(approachesBody);
-            findings.push({
-                section: "Distinct Approaches Enforcement",
-                required: true,
-                rule: "Approaches section must document at least 2 distinct approaches so the Iron Law comparison is meaningful.",
-                found: approachesTaxonomy.rowCount >= 2,
-                details: approachesTaxonomy.rowCount >= 2
-                    ? `Detected ${approachesTaxonomy.rowCount} approach row(s).`
-                    : `Detected ${approachesTaxonomy.rowCount} approach row(s); at least 2 required.`
-            });
-            findings.push({
-                section: "Approaches Role/Upside Taxonomy",
-                required: true,
-                rule: "Approaches table must use canonical Role and Upside enum values.",
-                found: approachesTaxonomy.roleUpsideOk,
-                details: approachesTaxonomy.details
-            });
-            findings.push({
-                section: "Challenger Alternative Enforcement",
-                required: true,
-                rule: "Approaches must include one challenger option with explicit high/higher upside.",
-                found: approachesTaxonomy.challengerOk,
-                details: approachesTaxonomy.details
-            });
-        }
-        const reactionIndex = headingLineIndex(raw, "Approach Reaction");
-        const directionIndex = headingLineIndex(raw, "Selected Direction");
-        if (directionIndex >= 0 && !brainstormShortCircuitActivated) {
-            const orderOk = reactionIndex >= 0 && reactionIndex < directionIndex;
-            findings.push({
-                section: "Approach Reaction Ordering",
-                required: true,
-                rule: "Approach Reaction must appear before Selected Direction (propose -> react -> recommend).",
-                found: orderOk,
-                details: orderOk
-                    ? "Approach Reaction appears before Selected Direction."
-                    : "Approach Reaction must be present before Selected Direction."
-            });
-        }
-        const directionBody = sectionBodyByName(sections, "Selected Direction");
-        if (directionBody !== null) {
-            const approvalMarker = /\bapprov(?:ed|al)\b/iu.test(directionBody);
-            findings.push({
-                section: "Direction Approval Marker",
-                required: true,
-                rule: "Selected Direction section must state an explicit approval marker (for example `Approval: approved` or `Approved by: user`).",
-                found: approvalMarker,
-                details: approvalMarker
-                    ? "Approval marker present in Selected Direction."
-                    : "No explicit `approved`/`approval` marker found in Selected Direction."
-            });
-            if (!brainstormShortCircuitActivated) {
-                const reactionBody = sectionBodyByName(sections, "Approach Reaction");
-                const reactionTrace = /\b(?:reaction|feedback|concern(?:s)?)\b/iu.test(directionBody) ||
-                    (reactionIndex >= 0 && reactionIndex < directionIndex && meaningfulLineCount(reactionBody ?? "") > 0);
-                findings.push({
-                    section: "Direction Reaction Trace",
-                    required: true,
-                    rule: "Selected Direction must be traceable to a prior Approach Reaction section or explicitly reference user reaction/feedback/concerns.",
-                    found: reactionTrace,
-                    details: reactionTrace
-                        ? "Selected Direction is traceable to prior user reaction."
-                        : "Selected Direction is not traceable to user reaction. Add `## Approach Reaction` before it, or mention the user's reaction/concerns in the rationale."
-                });
-                // Track-aware handoff: standard track goes to `scope`; medium track
-                // goes directly to `spec`; the quick track skips brainstorm entirely.
-                // We accept either canonical successor token plus a generic
-                // `next-stage` / `handoff` phrase to preserve i18n flexibility.
-                const handoffTrace = /(?:`(?:scope|spec)`|\bscope\b|\bspec\b|next[-\s_]stage|next stage|\bhandoff\b|hand[-\s]off)/iu.test(directionBody);
-                findings.push({
-                    section: "Direction Next-Stage Handoff",
-                    required: true,
-                    rule: "Selected Direction must record the track-aware next-stage handoff (mention `scope` for standard, `spec` for medium, or include a `Next-stage handoff:` line).",
-                    found: handoffTrace,
-                    details: handoffTrace
-                        ? "Selected Direction names the next-stage handoff."
-                        : "Selected Direction is missing a next-stage handoff token. Mention `scope` (standard) or `spec` (medium), or add a `Next-stage handoff:` line so downstream stages can trace the contract."
-                });
-            }
-        }
-        const shortCircuitBody = brainstormShortCircuitBody;
-        if (shortCircuitBody !== null) {
-            const statusValue = parseShortCircuitStatus(shortCircuitBody);
-            const hasStatus = statusValue.length > 0;
-            findings.push({
-                section: "Short-Circuit Status",
-                required: true,
-                rule: "Short-Circuit Decision must include a `Status:` line (`activated` or `bypassed`).",
-                found: hasStatus,
-                details: hasStatus
-                    ? `Short-circuit status declared as "${statusValue}".`
-                    : "Short-Circuit Decision is missing a `Status:` line."
-            });
-            if (brainstormShortCircuitActivated) {
-                const artifactLines = meaningfulLineCount(raw);
-                const withinStubLimit = artifactLines <= 30;
-                const hasScopeHandoff = /\bscope\b/iu.test(shortCircuitBody);
-                findings.push({
-                    section: "Short-Circuit Stub Size",
-                    required: true,
-                    rule: "When short-circuit is activated, brainstorm artifact must remain a <=30 meaningful-line stub.",
-                    found: withinStubLimit,
-                    details: withinStubLimit
-                        ? `Short-circuit stub size within limit (${artifactLines} meaningful lines).`
-                        : `Short-circuit stub too large (${artifactLines} meaningful lines); expected <= 30.`
-                });
-                findings.push({
-                    section: "Short-Circuit Scope Handoff",
-                    required: true,
-                    rule: "When short-circuit is activated, the section must explicitly hand off to scope.",
-                    found: hasScopeHandoff,
-                    details: hasScopeHandoff
-                        ? "Short-circuit section includes explicit scope handoff."
-                        : "Short-circuit section is missing explicit scope handoff guidance."
-                });
-            }
-        }
-        const selfReviewBody = sectionBodyByName(sections, "Self-Review Notes");
-        if (selfReviewBody !== null) {
-            const selfReview = validateCalibratedSelfReview(selfReviewBody);
-            findings.push({
-                section: "Calibrated Self-Review Format",
-                required: true,
-                rule: "When Self-Review Notes are present, they must use the calibrated review prompt output shape.",
-                found: selfReview.ok,
-                details: selfReview.details
-            });
-        }
-        // Universal structural checks (Layer 2.1). Each fires only when the
-        // matching section is present so legacy fixtures keep their current
-        // shape, while artifacts emitted from the v3 template have to satisfy
-        // them. Content is never inspected — only the shape required by the
-        // reference patterns (gstack mode, forcing questions, premise list,
-        // approach detail cards, anti-sycophancy stamp).
-        const modeBody = sectionBodyByName(sections, "Mode Block");
-        if (modeBody !== null) {
-            const modeTokens = ["STARTUP", "BUILDER", "ENGINEERING", "OPS", "RESEARCH"];
-            const modeRegex = markdownFieldRegex("Mode", modeTokens.join("|"), "u");
-            const tokenMatches = new Set();
-            const lineRegex = new RegExp(modeRegex.source, "gu");
-            for (const match of modeBody.matchAll(lineRegex)) {
-                const token = (match[0].match(/STARTUP|BUILDER|ENGINEERING|OPS|RESEARCH/u) ?? [""])[0];
-                if (token)
-                    tokenMatches.add(token);
-            }
-            const placeholderLine = modeBody
-                .split("\n")
-                .find((line) => /\bMode\b\s*[*_]{0,2}\s*:/iu.test(line) && (line.match(/STARTUP|BUILDER|ENGINEERING|OPS|RESEARCH/giu) ?? []).length >= 2);
-            const isPlaceholder = Boolean(placeholderLine);
-            const ok = tokenMatches.size === 1 && !isPlaceholder;
-            findings.push({
-                section: "Mode Block Token",
-                required: true,
-                rule: "Mode Block must declare exactly one mode token: STARTUP, BUILDER, ENGINEERING, OPS, or RESEARCH.",
-                found: ok,
-                details: ok
-                    ? `Recognized mode token detected: ${[...tokenMatches][0] ?? ""}.`
-                    : isPlaceholder
-                        ? "Mode Block still lists multiple mode tokens (template placeholder); pick exactly one of STARTUP/BUILDER/ENGINEERING/OPS/RESEARCH."
-                        : "Mode Block is missing a recognized mode token (STARTUP/BUILDER/ENGINEERING/OPS/RESEARCH)."
-            });
-        }
-        const forcingBody = sectionBodyByName(sections, "Forcing Questions");
-        if (forcingBody !== null) {
-            const tableRows = forcingBody
-                .split("\n")
-                .filter((line) => /^\|\s*\d+\s*\|/u.test(line));
-            const enoughRows = tableRows.length >= 3;
-            findings.push({
-                section: "Forcing Questions Count",
-                required: true,
-                rule: "Forcing Questions must include at least 3 numbered rows.",
-                found: enoughRows,
-                details: enoughRows
-                    ? `Detected ${tableRows.length} forcing-question row(s).`
-                    : `Detected ${tableRows.length} forcing-question row(s); at least 3 required.`
-            });
-            // A "specific" answer is signalled by at least one of: numeric token,
-            // backticked path/identifier, http(s) link, @mention/role, or quoted
-            // verbatim string. We check structural shape, not content.
-            const specificTokenRegex = /(\d|`[^`]+`|https?:\/\/|@[A-Za-z][\w-]*|"[^"]+"|'[^']+')/u;
-            const allRowsSpecific = tableRows.every((row) => {
-                const cells = row.split("|").map((cell) => cell.trim());
-                // cells: ["", "#", "Question", "Answer", "Decision impact", "Q<n> decision", ""]
-                const answer = cells[3] ?? "";
-                return answer.length > 0 && specificTokenRegex.test(answer);
-            });
-            findings.push({
-                section: "Forcing Questions Specific Answers",
-                required: true,
-                rule: "Each Forcing Questions row must include a specific token in the answer column (number, backticked path, link, @mention, or quoted string).",
-                found: tableRows.length === 0 ? false : allRowsSpecific,
-                details: tableRows.length === 0
-                    ? "No rows to evaluate."
-                    : allRowsSpecific
-                        ? "All rows include a specific-answer token."
-                        : "At least one row's answer is missing a specific-answer token (number, `path`, https link, @mention, or quoted string)."
-            });
-            const decisionRows = (forcingBody.match(/decision\s*:/giu) ?? []).length;
-            findings.push({
-                section: "Forcing Questions STOP-per-issue",
-                required: true,
-                rule: "Each forcing-question row must record a `decision:` marker (STOP-per-issue protocol).",
-                found: decisionRows >= tableRows.length && tableRows.length > 0,
-                details: tableRows.length === 0
-                    ? "No rows to evaluate."
-                    : `Detected ${decisionRows} decision marker(s) for ${tableRows.length} forcing-question row(s).`
-            });
-        }
-        const premiseBody = sectionBodyByName(sections, "Premise List");
-        if (premiseBody !== null) {
-            const premiseRowRegex = /^[-*]\s*P\d+:\s+.+\s+—\s+(agreed|disagreed|revised)\b/imu;
-            const allRows = premiseBody
-                .split("\n")
-                .filter((line) => /^[-*]\s*P\d+:/u.test(line));
-            const validRows = allRows.filter((row) => premiseRowRegex.test(row.trim() + "\n"));
-            const enoughPremises = validRows.length >= 2;
-            findings.push({
-                section: "Premise List Shape",
-                required: true,
-                rule: "Premise List must contain at least 2 rows in the form `P<n>: <statement> — agreed|disagreed|revised`.",
-                found: enoughPremises,
-                details: enoughPremises
-                    ? `Detected ${validRows.length} valid premise row(s).`
-                    : `Detected ${validRows.length} valid premise row(s); at least 2 required (form: \`P<n>: ... — agreed|disagreed|revised\`).`
-            });
-        }
-        // Approach Detail Cards: structural sub-section under Approaches, one
-        // bullet block per approach with the canonical fields.
-        const approachCardsRegex = /####\s+APPROACH\s+[A-Z]\b[\s\S]*?(?:^-\s*Summary:[\s\S]*?^-\s*Effort:[\s\S]*?^-\s*Risk:[\s\S]*?^-\s*Pros:[\s\S]*?^-\s*Cons:[\s\S]*?^-\s*Reuses:)/gimu;
-        const matches = raw.match(approachCardsRegex);
-        const cardCount = matches ? matches.length : 0;
-        if (/####\s+APPROACH\s+[A-Z]\b/iu.test(raw) ||
-            /^RECOMMENDATION:/imu.test(raw)) {
-            findings.push({
-                section: "Approach Detail Cards",
-                required: true,
-                rule: "Approach Detail Cards must include ≥2 `#### APPROACH <letter>` blocks each with Summary/Effort/Risk/Pros/Cons/Reuses.",
-                found: cardCount >= 2,
-                details: cardCount >= 2
-                    ? `Detected ${cardCount} valid approach detail card(s).`
-                    : `Detected ${cardCount} valid approach detail card(s); at least 2 required with all fields present.`
-            });
-            const recommendationLine = raw.match(/^RECOMMENDATION:\s*(.+)$/imu);
-            const hasRecommendation = recommendationLine !== null && recommendationLine[1] !== undefined && recommendationLine[1].trim().length > 0;
-            findings.push({
-                section: "Approach Recommendation Marker",
-                required: true,
-                rule: "Approach Detail Cards must conclude with a single `RECOMMENDATION:` line citing the chosen letter and rationale.",
-                found: hasRecommendation,
-                details: hasRecommendation
-                    ? "Recommendation marker present."
-                    : "Missing or empty `RECOMMENDATION:` line after approach detail cards."
-            });
-        }
-        const stampBody = sectionBodyByName(sections, "Anti-Sycophancy Stamp");
-        if (stampBody !== null) {
-            const acknowledged = markdownFieldRegex("Forbidden response openers acknowledged", "yes|true|y").test(stampBody);
-            findings.push({
-                section: "Anti-Sycophancy Acknowledgement",
-                required: true,
-                rule: "Anti-Sycophancy Stamp must affirm `Forbidden response openers acknowledged: yes`.",
-                found: acknowledged,
-                details: acknowledged
-                    ? "Anti-sycophancy commitment is acknowledged."
-                    : "Anti-Sycophancy Stamp is missing the explicit `Forbidden response openers acknowledged: yes` marker."
-            });
-        }
-        const outsideVoiceBody = sectionBodyByName(sections, "Outside Voice");
-        if (outsideVoiceBody !== null) {
-            const required = ["source:", "prompt:", "tension:", "resolution:"];
-            const missing = required.filter((key) => !new RegExp(`(?:^|\\n)\\s*-?\\s*${key.replace(":", "\\s*:")}`, "iu").test(outsideVoiceBody));
-            const optedOut = /\bnot used\b|\bn\/a\b|\bnone\b/iu.test(outsideVoiceBody);
-            findings.push({
-                section: "Outside Voice Slot Shape",
-                required: true,
-                rule: "Outside Voice section must either declare opt-out (`not used`/`none`) or include `source:`, `prompt:`, `tension:`, `resolution:`.",
-                found: optedOut || missing.length === 0,
-                details: optedOut || missing.length === 0
-                    ? "Outside Voice slot is well-formed."
-                    : `Outside Voice section is missing field(s): ${missing.join(", ")}.`
-            });
-        }
-    }
-    if (stage === "design") {
-        const tierResolution = await resolveDesignDiagramTier(projectRoot, track, raw);
-        const diagramTier = isTrivialOverride
-            ? "lightweight"
-            : tierResolution.tier;
-        const tierSource = isTrivialOverride
-            ? `${tierResolution.source}; trivial override forced lightweight`
-            : tierResolution.source;
-        for (const requirement of DESIGN_DIAGRAM_REQUIREMENTS[diagramTier]) {
-            const sectionBody = sectionBodyByName(sections, requirement.section);
-            const hasSection = sectionBody !== null;
-            const escapedMarker = requirement.marker.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-            const markerRegex = new RegExp(`<!--\\s*diagram:\\s*${escapedMarker}\\s*-->`, "iu");
-            const hasMarker = sectionBody !== null && markerRegex.test(sectionBody);
-            const hasContent = sectionBody !== null && meaningfulLineCount(sectionBody) > 0;
-            const found = hasSection && hasMarker && hasContent;
-            findings.push({
-                section: `Diagram Requirement: ${requirement.section}`,
-                required: true,
-                rule: `Design tier "${diagramTier}" requires "${requirement.section}" with marker \`<!-- diagram: ${requirement.marker} -->\`. ${requirement.note}`,
-                found,
-                details: found
-                    ? `Satisfied (${tierSource}).`
-                    : !hasSection
-                        ? `Missing section "${requirement.section}" (${tierSource}).`
-                        : !hasMarker
-                            ? `Missing marker \`<!-- diagram: ${requirement.marker} -->\` in section "${requirement.section}" (${tierSource}).`
-                            : `Section "${requirement.section}" has marker but no meaningful content (${tierSource}).`
-            });
-        }
-        if (staleDiagramAuditEnabled) {
-            const codebaseInvestigation = sectionBodyByName(sections, "Codebase Investigation");
-            if (codebaseInvestigation === null) {
-                findings.push({
-                    section: "Stale Diagram Drift Check",
-                    required: true,
-                    rule: "When `.cclaw/config.yaml::optInAudits.staleDiagramAudit` is true, stale diagram audit requires Codebase Investigation blast-radius files.",
-                    found: false,
-                    details: "No ## heading matching required section \"Codebase Investigation\"."
-                });
-            }
-            else {
-                const staleAudit = await runStaleDiagramAudit(projectRoot, absFile, raw, codebaseInvestigation);
-                findings.push({
-                    section: "Stale Diagram Drift Check",
-                    required: true,
-                    rule: "When `.cclaw/config.yaml::optInAudits.staleDiagramAudit` is true, blast-radius files must not be newer than current design diagram baseline.",
-                    found: staleAudit.ok,
-                    details: staleAudit.details
-                });
-            }
-        }
-        // Universal Layer 2.3 structural checks (gstack plan-eng-review). All
-        // present-only. Validates ASCII coverage diagram tokens, regression iron
-        // rule acknowledgment, and confidence-calibrated finding format.
-        const coverageBody = sectionBodyByName(sections, "ASCII Coverage Diagram");
-        if (coverageBody !== null) {
-            const tokens = ["[★★★]", "[★★]", "[★]", "[GAP]", "[→E2E]", "[→EVAL]"];
-            const presentTokens = tokens.filter((token) => coverageBody.includes(token));
-            const ok = presentTokens.length >= 3;
-            findings.push({
-                section: "ASCII Coverage Diagram Tokens",
-                required: true,
-                rule: "ASCII Coverage Diagram must use the canonical marker tokens (at least 3 of `[★★★]` / `[★★]` / `[★]` / `[GAP]` / `[→E2E]` / `[→EVAL]`).",
-                found: ok,
-                details: ok
-                    ? `Detected ${presentTokens.length} canonical marker token(s).`
-                    : `Detected ${presentTokens.length} canonical marker token(s); at least 3 required.`
-            });
-        }
-        const regressionBody = sectionBodyByName(sections, "Regression Iron Rule");
-        if (regressionBody !== null) {
-            const ack = markdownFieldRegex("Iron rule acknowledged", "yes|true|y").test(regressionBody);
-            findings.push({
-                section: "Regression Iron Rule Acknowledgement",
-                required: true,
-                rule: "Regression Iron Rule section must affirm `Iron rule acknowledged: yes`.",
-                found: ack,
-                details: ack
-                    ? "Regression iron rule acknowledged."
-                    : "Regression Iron Rule is missing explicit `Iron rule acknowledged: yes`."
-            });
-        }
-        const findingsBody = sectionBodyByName(sections, "Calibrated Findings");
-        if (findingsBody !== null) {
-            const isEmpty = /(^|\n)\s*-\s*None this stage\b/iu.test(findingsBody);
-            const findingRegex = new RegExp(CONFIDENCE_FINDING_REGEX_SOURCE, "u");
-            const validRows = findingsBody
-                .split("\n")
-                .filter((line) => /^[-*]\s+\[/u.test(line.trim()))
-                .filter((line) => findingRegex.test(line));
-            const ok = isEmpty || validRows.length >= 1;
-            findings.push({
-                section: "Calibrated Finding Format",
-                required: true,
-                rule: "Calibrated Findings must either declare `None this stage` or contain at least one finding in the form `[P1|P2|P3] (confidence: <n>/10) <path>[:<line>] — <description>`.",
-                found: ok,
-                details: isEmpty
-                    ? "No findings recorded for this stage."
-                    : ok
-                        ? `Detected ${validRows.length} calibrated finding(s).`
-                        : "No calibrated findings detected. Use `[P1|P2|P3] (confidence: <n>/10) <repo-path>[:<line>] — <description>`."
-            });
-        }
-    }
-    if (stage === "plan") {
-        const strictPlanGuards = parsedFrontmatter.hasFrontmatter ||
-            headingPresent(sections, "No-Placeholder Scan") ||
-            headingPresent(sections, "No Scope Reduction Language Scan") ||
-            headingPresent(sections, "Locked Decision Coverage");
-        const taskListBody = sectionBodyByName(sections, "Task List") ?? raw;
-        const placeholderHits = collectPatternHits(taskListBody, PLACEHOLDER_PATTERNS);
-        findings.push({
-            section: "No Placeholder Enforcement",
-            required: strictPlanGuards,
-            rule: "Task List must not contain placeholders (TODO/TBD/FIXME/<fill-in>/<your-*-here>/xxx/ellipsis).",
-            found: placeholderHits.length === 0,
-            details: placeholderHits.length === 0
-                ? "No placeholder tokens detected in Task List."
-                : `Detected placeholder token(s) in Task List: ${placeholderHits.join(", ")}.`
-        });
-        const scopeArtifact = await resolveStageArtifactPath("scope", {
-            projectRoot,
-            track,
-            intent: "read"
-        });
-        const scopeRaw = (await exists(scopeArtifact.absPath))
-            ? await fs.readFile(scopeArtifact.absPath, "utf8")
-            : "";
-        const scopeDecisionIds = extractDecisionIds(scopeRaw);
-        const missingDecisionRefs = scopeDecisionIds.filter((id) => !raw.includes(id));
-        findings.push({
-            section: "Locked Decision Traceability",
-            required: strictPlanGuards && scopeDecisionIds.length > 0,
-            rule: "Every locked decision ID (D-XX) in scope must be referenced in plan.",
-            found: missingDecisionRefs.length === 0,
-            details: scopeDecisionIds.length === 0
-                ? "No D-XX IDs found in scope artifact; traceability check skipped."
-                : missingDecisionRefs.length === 0
-                    ? `All ${scopeDecisionIds.length} scope decision IDs are referenced in plan.`
-                    : `Missing scope decision reference(s) in plan: ${missingDecisionRefs.join(", ")}.`
-        });
-        const reductionHits = collectPatternHits(taskListBody, SCOPE_REDUCTION_PATTERNS);
-        findings.push({
-            section: "No Scope Reduction Language",
-            required: strictPlanGuards && scopeDecisionIds.length > 0,
-            rule: "Task List must not include scope-reduction language when locked decisions exist.",
-            found: reductionHits.length === 0,
-            details: scopeDecisionIds.length === 0
-                ? "No locked decisions found in scope artifact; scope-reduction scan is advisory."
-                : reductionHits.length === 0
-                    ? "No scope-reduction phrases detected in Task List."
-                    : `Detected scope-reduction phrase(s) in Task List: ${reductionHits.join(", ")}.`
-        });
-        // Universal Layer 2.5 structural checks (superpowers writing-plans + ce-plan).
-        // Plan-wide placeholder scan (broader than Task List) using the
-        // FORBIDDEN_PLACEHOLDER_TOKENS list shared with the cross-cutting block.
-        const planHeaderBody = sectionBodyByName(sections, "Plan Header");
-        if (planHeaderBody !== null) {
-            const required = ["Goal:", "Architecture:", "Tech Stack:"];
-            const missing = required.filter((token) => !new RegExp(token.replace(":", "\\s*:"), "iu").test(planHeaderBody));
-            findings.push({
-                section: "Plan Header Coverage",
-                required: true,
-                rule: "Plan Header must include Goal, Architecture, and Tech Stack lines.",
-                found: missing.length === 0,
-                details: missing.length === 0
-                    ? "Plan Header covers Goal/Architecture/Tech Stack."
-                    : `Plan Header is missing field(s): ${missing.join(", ")}.`
-            });
-        }
-        const unitBlocks = raw.match(/###\s+Implementation Unit\s+U-\d+/giu) ?? [];
-        if (unitBlocks.length > 0) {
-            const requiredKeys = ["Goal:", "Files", "Approach:", "Test scenarios:", "Verification:"];
-            const blockBodies = raw.split(/(?=###\s+Implementation Unit\s+U-\d+)/iu).slice(1);
-            const validBlocks = blockBodies.filter((block) => requiredKeys.every((key) => new RegExp(key.replace(":", "\\s*:"), "iu").test(block)));
-            findings.push({
-                section: "Implementation Unit Shape",
-                required: true,
-                rule: "Each `### Implementation Unit U-<n>` must include Goal, Files, Approach, Test scenarios, Verification.",
-                found: validBlocks.length === unitBlocks.length,
-                details: validBlocks.length === unitBlocks.length
-                    ? `All ${unitBlocks.length} implementation unit(s) include the required fields.`
-                    : `${unitBlocks.length - validBlocks.length} implementation unit(s) are missing required fields.`
-            });
-        }
-        const allPlaceholderTokens = FORBIDDEN_PLACEHOLDER_TOKENS.map((token) => token.toLowerCase());
-        const lowerRaw = raw.toLowerCase();
-        const planWidePlaceholderHits = allPlaceholderTokens.filter((token) => lowerRaw.includes(token));
-        // Strip the "## NO PLACEHOLDERS Rule" section (which lists tokens) and
-        // any acknowledgement text from the scan to avoid false positives where
-        // the plan deliberately references the rule by name.
-        const placeholderRuleSection = sectionBodyByName(sections, "NO PLACEHOLDERS Rule");
-        const ruleScanBody = (placeholderRuleSection ?? "").toLowerCase();
-        const ruleAcceptedHits = ruleScanBody.length > 0
-            ? allPlaceholderTokens.filter((token) => ruleScanBody.includes(token))
-            : [];
-        const filteredPlanHits = planWidePlaceholderHits.filter((token) => {
-            // If the only occurrence is in the rule section, ignore it.
-            if (!ruleAcceptedHits.includes(token))
-                return true;
-            const occurrencesElsewhere = lowerRaw.split(token).length - 1
-                - (ruleScanBody.split(token).length - 1);
-            return occurrencesElsewhere > 0;
-        });
-        findings.push({
-            section: "Plan-wide Placeholder Scan",
-            required: false,
-            rule: "Plan should not contain forbidden placeholder tokens outside the NO PLACEHOLDERS rule section.",
-            found: filteredPlanHits.length === 0,
-            details: filteredPlanHits.length === 0
-                ? "No forbidden placeholder tokens detected outside the rule section."
-                : `Detected forbidden token(s) elsewhere in plan: ${filteredPlanHits.join(", ")}.`
-        });
-        const handoffBody = sectionBodyByName(sections, "Execution Handoff");
-        if (handoffBody !== null) {
-            const ok = /(subagent-driven|inline executor)/iu.test(handoffBody);
-            findings.push({
-                section: "Execution Handoff Posture",
-                required: true,
-                rule: "Execution Handoff must declare a posture (Subagent-Driven or Inline executor).",
-                found: ok,
-                details: ok
-                    ? "Execution Handoff posture declared."
-                    : "Execution Handoff is missing a posture declaration (Subagent-Driven or Inline executor)."
-            });
-        }
-    }
-    if (stage === "scope") {
-        const lockedDecisionsBody = sectionBodyByHeadingPrefix(sections, "Locked Decisions") ?? "";
-        const strictScopeGuards = parsedFrontmatter.hasFrontmatter ||
-            sectionBodyByHeadingPrefix(sections, "Locked Decisions") !== null;
-        const scopeSections = [
-            sectionBodyByAnyName(sections, ["In Scope / Out of Scope", "In Scope", "Out of Scope"]) ?? "",
-            sectionBodyByName(sections, "Scope Summary") ?? "",
-            lockedDecisionsBody
-        ].join("\n");
-        const reductionHits = collectPatternHits(scopeSections, SCOPE_REDUCTION_PATTERNS);
-        findings.push({
-            section: "No Scope Reduction Language",
-            required: strictScopeGuards,
-            rule: "Scope boundary sections must not use reduction placeholders (`v1`, `for now`, `later`, `temporary`, `placeholder`).",
-            found: reductionHits.length === 0,
-            details: reductionHits.length === 0
-                ? "No scope-reduction phrases detected in scope boundary sections."
-                : `Detected scope-reduction phrase(s): ${reductionHits.join(", ")}.`
-        });
-        if (sectionBodyByHeadingPrefix(sections, "Locked Decisions") !== null) {
-            const anchorValidation = validateLockedDecisionAnchors(lockedDecisionsBody);
-            findings.push({
-                section: "Locked Decisions Hash Integrity",
-                required: true,
-                rule: "Locked Decisions section must list unique LD#<sha8> content-derived anchors.",
-                found: anchorValidation.ok,
-                details: anchorValidation.details
-            });
-            // Legacy D-XX rows remain advisory for older artifacts, but new templates
-            // use LD#hash anchors. This check keeps D-XX duplicates visible without
-            // making old artifacts the primary contract.
-            const listDecisionLines = lockedDecisionsBody
-                .split(/\r?\n/u)
-                .map((line) => line.trim())
-                .filter((line) => /^[-*]\s+\S/u.test(line));
-            const tableDecisionRows = getMarkdownTableRows(lockedDecisionsBody);
-            const tableDecisionLines = tableDecisionRows.map((row) => row.join(" | "));
-            const decisionLines = [...listDecisionLines, ...tableDecisionLines];
-            const orphanDecisionLines = decisionLines.filter((line) => !/\bD-\d+\b/u.test(line));
-            const rowDecisionIds = [
-                ...listDecisionLines.map((line) => /\bD-\d+\b/u.exec(line)?.[0]),
-                ...tableDecisionRows.map((row) => /\bD-\d+\b/u.exec(row[0] ?? "")?.[0])
-            ].filter((id) => typeof id === "string");
-            const duplicateIds = (() => {
-                const counts = new Map();
-                for (const id of rowDecisionIds)
-                    counts.set(id, (counts.get(id) ?? 0) + 1);
-                return [...counts.entries()].filter(([, n]) => n > 1).map(([id]) => id);
-            })();
-            const issues = [];
-            if (rowDecisionIds.length === 0 && decisionLines.length === 0) {
-                issues.push("section is empty");
-            }
-            if (orphanDecisionLines.length > 0) {
-                const examples = orphanDecisionLines
-                    .slice(0, 3)
-                    .map((line) => `\`${line.slice(0, 120)}\``)
-                    .join(", ");
-                issues.push(`${orphanDecisionLines.length} decision row(s) missing a D-XX ID${examples.length > 0 ? `: ${examples}` : ""}`);
-            }
-            if (duplicateIds.length > 0) {
-                issues.push(`duplicate IDs: ${duplicateIds.join(", ")}`);
-            }
-            findings.push({
-                section: "Locked Decisions ID Integrity",
-                required: false,
-                rule: "Locked Decisions section must list each decision with a unique stable D-XX ID.",
-                found: issues.length === 0,
-                details: issues.length === 0
-                    ? `${rowDecisionIds.length} decision ID(s) recorded with no duplicates.`
-                    : issues.join("; ")
-            });
-        }
-        // Universal Layer 2.2 structural checks (gstack plan-ceo-review). All
-        // present-only — they validate shape when the section exists.
-        const altsBody = sectionBodyByName(sections, "Implementation Alternatives");
-        if (altsBody !== null) {
-            const recommendation = /^RECOMMENDATION:\s*(.+)$/imu.test(altsBody);
-            findings.push({
-                section: "Implementation Alternatives Recommendation",
-                required: true,
-                rule: "Implementation Alternatives must conclude with a `RECOMMENDATION:` line citing the chosen option and rationale.",
-                found: recommendation,
-                details: recommendation
-                    ? "Recommendation marker present."
-                    : "Missing or empty `RECOMMENDATION:` line under Implementation Alternatives."
-            });
-        }
-        const failureModesBody = sectionBodyByName(sections, "Failure Modes Registry");
-        if (failureModesBody !== null) {
-            const required = ["Codepath", "Failure mode", "Rescued?", "Test?", "User sees?", "Logged?"];
-            const headerOk = required.every((column) => failureModesBody.includes(column));
-            const rows = failureModesBody.split("\n").filter((line) => /^\|/u.test(line));
-            const hasDataRow = rows.length >= 3 && rows.slice(2).some((row) => row
-                .split("|")
-                .slice(1, -1)
-                .some((cell) => cell.trim().length > 0));
-            findings.push({
-                section: "Failure Modes Registry Shape",
-                required: true,
-                rule: "Failure Modes Registry must include columns Codepath / Failure mode / Rescued? / Test? / User sees? / Logged? and at least one populated data row.",
-                found: headerOk && hasDataRow,
-                details: !headerOk
-                    ? "Failure Modes Registry header is missing one or more required columns."
-                    : hasDataRow
-                        ? "Failure Modes Registry header and at least one data row present."
-                        : "Failure Modes Registry has the canonical header but no populated data row."
-            });
-            const decisionMarkers = (failureModesBody.match(/decision\s*:/giu) ?? []).length;
-            findings.push({
-                section: "Failure Modes STOP-per-issue",
-                required: true,
-                rule: "Each Failure Modes Registry data row must record a `decision:` marker (STOP-per-issue protocol).",
-                found: decisionMarkers >= 1,
-                details: decisionMarkers >= 1
-                    ? `Detected ${decisionMarkers} decision marker(s).`
-                    : "Failure Modes Registry has no `decision:` markers; STOP-per-issue requires at least one."
-            });
-        }
-        const reversibilityBody = sectionBodyByName(sections, "Reversibility Rating");
-        if (reversibilityBody !== null) {
-            const scoreMatch = reversibilityBody.match(/score\s*\(.*?\)\s*:\s*([1-5])\b/iu);
-            const ok = scoreMatch !== null;
-            findings.push({
-                section: "Reversibility Rating Score",
-                required: true,
-                rule: "Reversibility Rating must declare a score in the range 1-5.",
-                found: ok,
-                details: ok
-                    ? `Reversibility score ${scoreMatch[1]} declared.`
-                    : "Reversibility Rating is missing a numeric score 1-5."
-            });
-        }
-    }
-    if (stage === "spec") {
-        // Universal Layer 2.4 structural checks (evanflow-prd + superpowers).
-        // All checks fire only when the matching section is present so legacy
-        // fixtures keep working while v3-template artifacts are validated.
-        const synthesisBody = sectionBodyByName(sections, "Synthesis Sources");
-        if (synthesisBody !== null) {
-            const tableRows = synthesisBody
-                .split("\n")
-                .filter((line) => /^\|/u.test(line));
-            const dataRows = tableRows.length >= 3 ? tableRows.slice(2) : [];
-            const populatedRows = dataRows.filter((row) => row
-                .split("|")
-                .slice(1, -1)
-                .some((cell) => cell.trim().length > 0));
-            const hasRow = populatedRows.length >= 1;
-            findings.push({
-                section: "Synthesis Sources Coverage",
-                required: true,
-                rule: "Synthesis Sources must cite at least one source artifact (synthesize-not-interview).",
-                found: hasRow,
-                details: hasRow
-                    ? `Detected ${populatedRows.length} populated source row(s).`
-                    : "Synthesis Sources is empty; spec must cite at least one upstream artifact or context file."
-            });
-        }
-        const behaviorBody = sectionBodyByName(sections, "Behavior Contract");
-        if (behaviorBody !== null) {
-            const optedOut = /(^|\n)\s*-\s*None\b/iu.test(behaviorBody);
-            const userStoryRegex = /(^|\n)\s*-\s*as\s+a\b[\s\S]*?,\s*i\s+can\b[\s\S]*?,\s*so that\b/imu;
-            const givenWhenThenRegex = /(^|\n)\s*-\s*given\b[\s\S]*?,\s*when\b[\s\S]*?,\s*then\b/imu;
-            const matches = [
-                ...behaviorBody.matchAll(/(^|\n)\s*-\s*as\s+a\b[\s\S]*?,\s*i\s+can\b[\s\S]*?,\s*so that\b/gimu),
-                ...behaviorBody.matchAll(/(^|\n)\s*-\s*given\b[\s\S]*?,\s*when\b[\s\S]*?,\s*then\b/gimu)
-            ];
-            const ok = optedOut || matches.length >= 3;
-            findings.push({
-                section: "Behavior Contract Shape",
-                required: true,
-                rule: "Behavior Contract must list ≥3 behaviors in user-story (As a/I can/so that) or Given/When/Then form, or declare `- None.` for single-step specs.",
-                found: ok,
-                details: optedOut
-                    ? "Single-step spec; behaviors opted out via `- None.`."
-                    : ok
-                        ? `Detected ${matches.length} behavior(s) in canonical form.`
-                        : `Detected ${matches.length} behavior(s) in canonical form; need ≥3 (or `
-                            + "`- None.`).",
-            });
-            // Bonus: detect if at least one user-story OR given/when/then form is present
-            // (mirrors existing helpers).
-            void userStoryRegex;
-            void givenWhenThenRegex;
-        }
-        const archModulesBody = sectionBodyByName(sections, "Architecture Modules");
-        if (archModulesBody !== null) {
-            const codeFenceCount = (archModulesBody.match(/```/gu) ?? []).length;
-            const fnSignatureRegex = /\b(function|class|def|fn|method)\b\s+[A-Za-z_]/u;
-            const noCode = codeFenceCount === 0 && !fnSignatureRegex.test(archModulesBody);
-            findings.push({
-                section: "Architecture Modules No-Code",
-                required: true,
-                rule: "Architecture Modules must not contain code blocks, function signatures, or class definitions — modules listed by responsibility only.",
-                found: noCode,
-                details: noCode
-                    ? "Architecture Modules is free of code blocks and function/class signatures."
-                    : "Architecture Modules contains a code fence or function/class signature; remove code-level details."
-            });
-        }
-        const selfReviewBody = sectionBodyByName(sections, "Spec Self-Review");
-        if (selfReviewBody !== null) {
-            const required = ["placeholder", "consistency", "scope", "ambiguity"];
-            const missing = required.filter((token) => !new RegExp(token, "iu").test(selfReviewBody));
-            findings.push({
-                section: "Spec Self-Review Coverage",
-                required: true,
-                rule: "Spec Self-Review must cover placeholder/consistency/scope/ambiguity checks.",
-                found: missing.length === 0,
-                details: missing.length === 0
-                    ? "Spec Self-Review covers all required checks."
-                    : `Spec Self-Review is missing check(s): ${missing.join(", ")}.`
-            });
-        }
-    }
-    if (stage === "tdd") {
-        // Universal Layer 2.6 structural checks (superpowers TDD + evanflow vertical slices).
-        const ironLawBody = sectionBodyByName(sections, "Iron Law Acknowledgement");
-        if (ironLawBody !== null) {
-            const ack = /acknowledged:\s*(yes|true|y)\b/iu.test(ironLawBody);
-            findings.push({
-                section: "TDD Iron Law Acknowledgement",
-                required: true,
-                rule: "Iron Law Acknowledgement must affirm `Acknowledged: yes`.",
-                found: ack,
-                details: ack
-                    ? "TDD Iron Law acknowledged."
-                    : "Iron Law Acknowledgement is missing explicit `Acknowledged: yes`."
-            });
-        }
-        const watchedRedBody = sectionBodyByName(sections, "Watched-RED Proof");
-        if (watchedRedBody !== null) {
-            const rows = watchedRedBody.split("\n").filter((line) => /^\|/u.test(line));
-            const dataRows = rows.length >= 3 ? rows.slice(2) : [];
-            const populatedRows = dataRows.filter((row) => row
-                .split("|")
-                .slice(1, -1)
-                .filter((_, idx) => idx !== 0) // skip slice column
-                .some((cell) => cell.trim().length > 0));
-            // Each populated row must include an ISO timestamp in column 3.
-            const isoRegex = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/u;
-            const validProofRows = populatedRows.filter((row) => isoRegex.test(row));
-            findings.push({
-                section: "Watched-RED Proof Shape",
-                required: true,
-                rule: "Watched-RED Proof rows must include an ISO timestamp showing when the test was observed failing.",
-                found: populatedRows.length === 0 || validProofRows.length === populatedRows.length,
-                details: populatedRows.length === 0
-                    ? "Watched-RED Proof has no populated rows."
-                    : validProofRows.length === populatedRows.length
-                        ? `All ${populatedRows.length} watched-RED proof row(s) include an ISO timestamp.`
-                        : `${populatedRows.length - validProofRows.length} watched-RED proof row(s) lack an ISO timestamp.`
-            });
-        }
-        const sliceCycleBody = sectionBodyByName(sections, "Vertical Slice Cycle");
-        if (sliceCycleBody !== null) {
-            const required = ["RED", "GREEN", "REFACTOR"];
-            const missing = required.filter((token) => !new RegExp(token, "u").test(sliceCycleBody));
-            findings.push({
-                section: "Vertical Slice Cycle Coverage",
-                required: true,
-                rule: "Vertical Slice Cycle must include RED, GREEN, and REFACTOR per slice (refactor may be deferred with rationale).",
-                found: missing.length === 0,
-                details: missing.length === 0
-                    ? "Vertical Slice Cycle references RED/GREEN/REFACTOR."
-                    : `Vertical Slice Cycle is missing phase token(s): ${missing.join(", ")}.`
-            });
-        }
-        const assertionBody = sectionBodyByName(sections, "Assertion Correctness Notes");
-        if (assertionBody !== null) {
-            const tableRows = assertionBody.split("\n").filter((line) => /^\|/u.test(line));
-            const dataRows = tableRows.length >= 3 ? tableRows.slice(2) : [];
-            const ok = dataRows.length === 0 || dataRows.some((row) => row
-                .split("|")
-                .slice(1, -1)
-                .some((cell) => cell.trim().length > 0));
-            findings.push({
-                section: "Assertion Correctness Notes Shape",
-                required: true,
-                rule: "Assertion Correctness Notes must include at least one populated row when the slice has new assertions.",
-                found: ok,
-                details: ok
-                    ? "Assertion Correctness Notes is populated or absent (single-step slice)."
-                    : "Assertion Correctness Notes table has no populated rows."
-            });
-        }
-    }
-    if (stage === "review") {
-        // Universal Layer 2.7 structural checks (superpowers requesting + receiving).
-        const frameBody = sectionBodyByName(sections, "Frame the Review Request");
-        if (frameBody !== null) {
-            const required = ["Goal:", "Approach:", "Risk areas:", "Verification done:", "Open questions"];
-            const missing = required.filter((token) => !new RegExp(token.replace(":", "\\s*:"), "iu").test(frameBody));
-            findings.push({
-                section: "Review Frame Coverage",
-                required: true,
-                rule: "Frame the Review Request must include Goal, Approach, Risk areas, Verification done, Open questions.",
-                found: missing.length === 0,
-                details: missing.length === 0
-                    ? "Review request frame covers all required fields."
-                    : `Frame is missing field(s): ${missing.join(", ")}.`
-            });
-        }
-        const criticBody = sectionBodyByName(sections, "Critic Subagent Dispatch");
-        if (criticBody !== null) {
-            const required = [
-                "Critic agent definition path",
-                "Dispatch surface",
-                "Frame sent",
-                "Critic returned"
-            ];
-            const missing = required.filter((token) => !criticBody.includes(token));
-            findings.push({
-                section: "Critic Subagent Dispatch Shape",
-                required: true,
-                rule: "Critic Subagent Dispatch must declare agent definition path, dispatch surface, frame sent, and critic-returned summary.",
-                found: missing.length === 0,
-                details: missing.length === 0
-                    ? "Critic dispatch metadata complete."
-                    : `Critic Subagent Dispatch is missing field(s): ${missing.join(", ")}.`
-            });
-        }
-        const receivingBody = sectionBodyByName(sections, "Receiving Posture");
-        if (receivingBody !== null) {
-            const ack = /no performative agreement/iu.test(receivingBody);
-            findings.push({
-                section: "Receiving Posture Anti-Sycophancy",
-                required: true,
-                rule: "Receiving Posture must affirm `No performative agreement (forbidden openers acknowledged)`.",
-                found: ack,
-                details: ack
-                    ? "Receiving posture acknowledged anti-sycophancy."
-                    : "Receiving Posture is missing the anti-sycophancy acknowledgement line."
-            });
-        }
-    }
-    if (stage === "ship") {
-        // Universal Layer 2.8 structural checks (superpowers finishing-a-development-branch).
-        const optionsBody = sectionBodyByName(sections, "Finalization Options");
-        if (optionsBody !== null) {
-            const required = ["MERGE_LOCAL", "OPEN_PR", "KEEP_BRANCH", "DISCARD"];
-            const missing = required.filter((token) => !optionsBody.includes(token));
-            findings.push({
-                section: "Finalization Options Coverage",
-                required: true,
-                rule: "Finalization Options must surface all four canonical options (MERGE_LOCAL, OPEN_PR, KEEP_BRANCH, DISCARD).",
-                found: missing.length === 0,
-                details: missing.length === 0
-                    ? "All four finalization options surfaced."
-                    : `Finalization Options is missing token(s): ${missing.join(", ")}.`
-            });
-        }
-        const prBody = sectionBodyByName(sections, "Structured PR Body");
-        if (prBody !== null) {
-            const required = ["## Summary", "## Test Plan", "## Commits Included"];
-            const missing = required.filter((token) => !prBody.includes(token));
-            findings.push({
-                section: "Structured PR Body Shape",
-                required: true,
-                rule: "Structured PR Body must include `## Summary`, `## Test Plan`, and `## Commits Included` subsections.",
-                found: missing.length === 0,
-                details: missing.length === 0
-                    ? "Structured PR Body covers all required subsections."
-                    : `Structured PR Body is missing subsection(s): ${missing.join(", ")}.`
-            });
-        }
-        const verifyBody = sectionBodyByName(sections, "Verify Tests Gate");
-        if (verifyBody !== null) {
-            const ok = /\bResult:\s*(PASS|FAIL)\b/iu.test(verifyBody);
-            findings.push({
-                section: "Verify Tests Gate Result",
-                required: true,
-                rule: "Verify Tests Gate must declare a Result of PASS or FAIL.",
-                found: ok,
-                details: ok
-                    ? "Verify Tests Gate result declared."
-                    : "Verify Tests Gate is missing a `Result: PASS|FAIL` line."
-            });
-        }
+    const stageContext = {
+        projectRoot,
+        stage,
+        track,
+        raw,
+        absFile,
+        sections,
+        findings,
+        parsedFrontmatter,
+        brainstormShortCircuitBody,
+        brainstormShortCircuitActivated,
+        scopePreAuditEnabled,
+        staleDiagramAuditEnabled,
+        isTrivialOverride,
+        overrideSet
+    };
+    switch (stage) {
+        case "brainstorm":
+            await lintBrainstormStage(stageContext);
+            break;
+        case "design":
+            await lintDesignStage(stageContext);
+            break;
+        case "plan":
+            await lintPlanStage(stageContext);
+            break;
+        case "scope":
+            await lintScopeStage(stageContext);
+            break;
+        case "spec":
+            await lintSpecStage(stageContext);
+            break;
+        case "tdd":
+            await lintTddStage(stageContext);
+            break;
+        case "review":
+            await lintReviewStage(stageContext);
+            break;
+        case "ship":
+            await lintShipStage(stageContext);
+            break;
+        default:
+            break;
     }
     if (["design", "spec", "plan", "review"].includes(stage)) {
         const scopeArtifact = await resolveStageArtifactPath("scope", {
@@ -2774,358 +236,3 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
     const passed = findings.every((f) => !f.required || f.found);
     return { stage, file: relFile, passed, findings };
 }
-function isNonEmptyString(v) {
-    return typeof v === "string" && v.length > 0;
-}
-function isFiniteNumber(v) {
-    return typeof v === "number" && Number.isFinite(v);
-}
-function isNonNegativeInteger(v) {
-    return Number.isInteger(v) && v >= 0;
-}
-function isStringArray(v) {
-    return Array.isArray(v) && v.every((item) => typeof item === "string");
-}
-export async function validateReviewArmy(projectRoot) {
-    const errors = [];
-    const { absPath, relPath } = await resolveNamedArtifactPath(projectRoot, "07-review-army.json");
-    if (!(await exists(absPath))) {
-        return { valid: false, errors: [`Missing file: ${relPath}`] };
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(await fs.readFile(absPath, "utf8"));
-    }
-    catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        return { valid: false, errors: [`Invalid JSON: ${msg}`] };
-    }
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-        return { valid: false, errors: ["Root value must be a JSON object."] };
-    }
-    const root = parsed;
-    if (!("version" in root) || !isFiniteNumber(root.version) || root.version < 1) {
-        errors.push('Field "version" must be a finite number >= 1.');
-    }
-    if (!isNonEmptyString(root.generatedAt)) {
-        errors.push('Field "generatedAt" must be a non-empty string.');
-    }
-    if (!("scope" in root) || root.scope === null || typeof root.scope !== "object" || Array.isArray(root.scope)) {
-        errors.push('Field "scope" must be an object.');
-    }
-    else {
-        const scope = root.scope;
-        if (!isNonEmptyString(scope.base)) {
-            errors.push("scope.base must be a non-empty string.");
-        }
-        if (!isNonEmptyString(scope.head)) {
-            errors.push("scope.head must be a non-empty string.");
-        }
-        if (!isStringArray(scope.files)) {
-            errors.push("scope.files must be an array of strings.");
-        }
-    }
-    const severitySet = new Set(["Critical", "Important", "Suggestion"]);
-    const statusSet = new Set(["open", "accepted", "resolved"]);
-    const sourceSet = new Set([
-        "spec",
-        "correctness",
-        "security",
-        "performance",
-        "architecture",
-        "external-safety"
-    ]);
-    const findingIds = new Set();
-    const openCriticalIds = new Set();
-    if (!Array.isArray(root.findings)) {
-        errors.push('Field "findings" must be an array.');
-    }
-    else {
-        root.findings.forEach((f, i) => {
-            if (f === null || typeof f !== "object" || Array.isArray(f)) {
-                errors.push(`findings[${i}] must be an object.`);
-                return;
-            }
-            const o = f;
-            if (!isNonEmptyString(o.id)) {
-                errors.push(`findings[${i}].id must be a non-empty string.`);
-            }
-            else if (findingIds.has(o.id)) {
-                errors.push(`findings[${i}].id must be unique.`);
-            }
-            else {
-                findingIds.add(o.id);
-            }
-            if (!isNonEmptyString(o.severity) || !severitySet.has(o.severity)) {
-                errors.push(`findings[${i}].severity must be one of: Critical, Important, Suggestion.`);
-            }
-            if (!isNonEmptyString(o.status) || !statusSet.has(o.status)) {
-                errors.push(`findings[${i}].status must be one of: open, accepted, resolved.`);
-            }
-            if (!isNonEmptyString(o.fingerprint)) {
-                errors.push(`findings[${i}].fingerprint must be a non-empty string.`);
-            }
-            if (!isFiniteNumber(o.confidence) || o.confidence < 1 || o.confidence > 10) {
-                errors.push(`findings[${i}].confidence must be a number in [1,10].`);
-            }
-            if (!isStringArray(o.reportedBy) || o.reportedBy.length === 0) {
-                errors.push(`findings[${i}].reportedBy must be a non-empty string array.`);
-            }
-            if (o.sources !== undefined) {
-                if (!isStringArray(o.sources) || o.sources.length === 0) {
-                    errors.push(`findings[${i}].sources must be a non-empty string array when present.`);
-                }
-                else {
-                    const invalidSources = o.sources.filter((source) => !sourceSet.has(source));
-                    if (invalidSources.length > 0) {
-                        errors.push(`findings[${i}].sources contains unknown values: ${invalidSources.join(", ")}.`);
-                    }
-                }
-            }
-            if (o.location === undefined || o.location === null) {
-                errors.push(`findings[${i}].location is required and must be an object with file + line.`);
-            }
-            else if (typeof o.location !== "object" || Array.isArray(o.location)) {
-                errors.push(`findings[${i}].location must be an object with file + line.`);
-            }
-            else {
-                const loc = o.location;
-                if (!isNonEmptyString(loc.file)) {
-                    errors.push(`findings[${i}].location.file must be a non-empty string.`);
-                }
-                if (!isFiniteNumber(loc.line) || loc.line < 1) {
-                    errors.push(`findings[${i}].location.line must be a positive number.`);
-                }
-            }
-            if (o.recommendation !== undefined && !isNonEmptyString(o.recommendation)) {
-                errors.push(`findings[${i}].recommendation must be a non-empty string when present.`);
-            }
-            if (o.severity === "Critical" && o.status === "open" && !isNonEmptyString(o.recommendation)) {
-                errors.push(`findings[${i}] open Critical finding must include recommendation.`);
-            }
-            if (o.id && o.severity === "Critical" && o.status === "open" && typeof o.id === "string") {
-                openCriticalIds.add(o.id);
-            }
-        });
-    }
-    if (!("reconciliation" in root) || root.reconciliation === null || typeof root.reconciliation !== "object") {
-        errors.push('Field "reconciliation" must be an object.');
-    }
-    else {
-        const rec = root.reconciliation;
-        if (!isNonNegativeInteger(rec.duplicatesCollapsed)) {
-            errors.push("reconciliation.duplicatesCollapsed must be a non-negative integer.");
-        }
-        if (!Array.isArray(rec.conflicts)) {
-            errors.push("reconciliation.conflicts must be an array.");
-        }
-        else {
-            rec.conflicts.forEach((c, ci) => {
-                if (c === null || typeof c !== "object" || Array.isArray(c)) {
-                    errors.push(`reconciliation.conflicts[${ci}] must be an object.`);
-                    return;
-                }
-                const co = c;
-                if (!isNonEmptyString(co.findingId)) {
-                    errors.push(`reconciliation.conflicts[${ci}].findingId must be a non-empty string.`);
-                }
-                else if (!findingIds.has(co.findingId)) {
-                    errors.push(`reconciliation.conflicts[${ci}].findingId references unknown finding "${co.findingId}".`);
-                }
-                if (!isNonEmptyString(co.description)) {
-                    errors.push(`reconciliation.conflicts[${ci}].description must be a non-empty string.`);
-                }
-            });
-        }
-        if (!isStringArray(rec.multiSpecialistConfirmed)) {
-            errors.push("reconciliation.multiSpecialistConfirmed must be an array of finding ids.");
-        }
-        else {
-            for (const msId of rec.multiSpecialistConfirmed) {
-                if (!findingIds.has(msId)) {
-                    errors.push(`reconciliation.multiSpecialistConfirmed references unknown finding id "${msId}".`);
-                    continue;
-                }
-                if (Array.isArray(root.findings)) {
-                    const finding = root.findings.find((f) => {
-                        return f && typeof f === "object" && !Array.isArray(f) && f.id === msId;
-                    });
-                    if (finding && typeof finding === "object" && !Array.isArray(finding)) {
-                        const reportedBy = finding.reportedBy;
-                        const count = Array.isArray(reportedBy)
-                            ? new Set(reportedBy.filter((v) => typeof v === "string")).size
-                            : 0;
-                        if (count < 2) {
-                            errors.push(`reconciliation.multiSpecialistConfirmed entry "${msId}" must be confirmed by at least 2 distinct reviewers (found ${count}).`);
-                        }
-                    }
-                }
-            }
-        }
-        if (!isStringArray(rec.shipBlockers)) {
-            errors.push("reconciliation.shipBlockers must be an array of finding ids.");
-        }
-        else {
-            const blockers = new Set(rec.shipBlockers);
-            for (const id of rec.shipBlockers) {
-                if (!findingIds.has(id)) {
-                    errors.push(`reconciliation.shipBlockers references unknown finding id "${id}".`);
-                }
-            }
-            for (const criticalId of openCriticalIds) {
-                if (!blockers.has(criticalId)) {
-                    errors.push(`reconciliation.shipBlockers must include open Critical finding "${criticalId}".`);
-                }
-            }
-        }
-        if (isStringArray(rec.multiSpecialistConfirmed)) {
-            for (const id of rec.multiSpecialistConfirmed) {
-                if (!findingIds.has(id)) {
-                    errors.push(`reconciliation.multiSpecialistConfirmed references unknown finding id "${id}".`);
-                }
-            }
-        }
-        if (rec.layerCoverage !== undefined) {
-            if (rec.layerCoverage === null || typeof rec.layerCoverage !== "object" || Array.isArray(rec.layerCoverage)) {
-                errors.push("reconciliation.layerCoverage must be an object when present.");
-            }
-            else {
-                const coverage = rec.layerCoverage;
-                for (const source of sourceSet) {
-                    if (coverage[source] !== undefined && typeof coverage[source] !== "boolean") {
-                        errors.push(`reconciliation.layerCoverage.${source} must be boolean when present.`);
-                    }
-                }
-            }
-        }
-    }
-    return { valid: errors.length === 0, errors };
-}
-/**
- * Ensure the narrative verdict in 07-review.md is consistent with the
- * structured review-army reconciliation. A review cannot declare
- * APPROVED while open Critical findings or shipBlockers remain.
- */
-export async function checkReviewVerdictConsistency(projectRoot) {
-    const errors = [];
-    const reviewMdPath = path.join(projectRoot, RUNTIME_ROOT, "artifacts", "07-review.md");
-    const armyJsonPath = path.join(projectRoot, RUNTIME_ROOT, "artifacts", "07-review-army.json");
-    let finalVerdict = "UNKNOWN";
-    if (await exists(reviewMdPath)) {
-        const raw = await fs.readFile(reviewMdPath, "utf8");
-        const sections = extractH2Sections(raw);
-        const verdictBody = sectionBodyByName(sections, "Final Verdict");
-        if (verdictBody) {
-            const chosen = [];
-            for (const token of ["APPROVED_WITH_CONCERNS", "APPROVED", "BLOCKED"]) {
-                const regex = new RegExp(`\\b${token}\\b`, "u");
-                if (regex.test(verdictBody)) {
-                    // APPROVED would match inside APPROVED_WITH_CONCERNS; prefer the longer match first.
-                    if (token === "APPROVED" && /\bAPPROVED_WITH_CONCERNS\b/u.test(verdictBody))
-                        continue;
-                    chosen.push(token);
-                }
-            }
-            if (chosen.length === 1) {
-                finalVerdict = chosen[0];
-            }
-            else if (chosen.length > 1) {
-                errors.push(`Final Verdict section lists multiple verdict tokens (${chosen.join(", ")}). Select exactly one.`);
-            }
-            else {
-                errors.push('Final Verdict section does not select APPROVED, APPROVED_WITH_CONCERNS, or BLOCKED.');
-            }
-        }
-        else {
-            errors.push('07-review.md is missing the "## Final Verdict" section.');
-        }
-    }
-    let openCriticalCount = 0;
-    let shipBlockerCount = 0;
-    if (await exists(armyJsonPath)) {
-        try {
-            const raw = await fs.readFile(armyJsonPath, "utf8");
-            const parsed = JSON.parse(raw);
-            const findings = Array.isArray(parsed.findings) ? parsed.findings : [];
-            for (const f of findings) {
-                if (!f || typeof f !== "object" || Array.isArray(f))
-                    continue;
-                const o = f;
-                if (o.severity === "Critical" && o.status === "open") {
-                    openCriticalCount++;
-                }
-            }
-            const rec = parsed.reconciliation && typeof parsed.reconciliation === "object" && !Array.isArray(parsed.reconciliation)
-                ? parsed.reconciliation
-                : null;
-            if (rec && Array.isArray(rec.shipBlockers)) {
-                shipBlockerCount = rec.shipBlockers.filter((v) => typeof v === "string").length;
-            }
-        }
-        catch {
-            // JSON validity is the concern of validateReviewArmy; skip silently here.
-        }
-    }
-    if (finalVerdict === "APPROVED" && (openCriticalCount > 0 || shipBlockerCount > 0)) {
-        errors.push(`Final Verdict is APPROVED but review-army has ${openCriticalCount} open Critical finding(s) and ${shipBlockerCount} shipBlocker(s). Use BLOCKED or APPROVED_WITH_CONCERNS.`);
-    }
-    // APPROVED_WITH_CONCERNS is intended for Important/Suggestion findings
-    // the author has accepted. An *open* Critical finding or an active
-    // shipBlocker must route through BLOCKED (review_verdict_blocked gate)
-    // rather than pass as a concession — previously this slipped through.
-    if (finalVerdict === "APPROVED_WITH_CONCERNS" &&
-        (openCriticalCount > 0 || shipBlockerCount > 0)) {
-        errors.push(`Final Verdict is APPROVED_WITH_CONCERNS but review-army has ${openCriticalCount} open Critical finding(s) and ${shipBlockerCount} shipBlocker(s). Resolve them or use BLOCKED.`);
-    }
-    return {
-        ok: errors.length === 0,
-        errors,
-        finalVerdict,
-        openCriticalCount,
-        shipBlockerCount
-    };
-}
-export async function checkReviewSecurityNoChangeAttestation(projectRoot) {
-    const reviewMdPath = path.join(projectRoot, RUNTIME_ROOT, "artifacts", "07-review.md");
-    if (!(await exists(reviewMdPath))) {
-        return {
-            ok: true,
-            errors: [],
-            hasSecurityFinding: false,
-            hasNoChangeAttestation: false
-        };
-    }
-    const errors = [];
-    const raw = await fs.readFile(reviewMdPath, "utf8");
-    const sections = extractH2Sections(raw);
-    const securityBody = sectionBodyByName(sections, "Layer 2 Security")
-        ?? sectionBodyByName(sections, "Layer 2b: Security")
-        ?? sectionBodyByName(sections, "Layer 2 Findings");
-    if (!securityBody) {
-        errors.push('07-review.md is missing a Layer 2 security section.');
-        return {
-            ok: false,
-            errors,
-            hasSecurityFinding: false,
-            hasNoChangeAttestation: false
-        };
-    }
-    const securityTableRowPattern = /^\|\s*[^|\n]+\|\s*[^|\n]+\|\s*security\s*\|\s*[^|\n]+\|\s*[^|\n]+\|/imu;
-    const securityBulletPattern = /^[*-]\s+.*\b(?:security|auth|injection|secret|credential|permission)\b/imu;
-    const hasSecurityFinding = securityTableRowPattern.test(securityBody) || securityBulletPattern.test(securityBody);
-    const attestationMatch = /\b(NO_CHANGE_ATTESTATION|NO_SECURITY_IMPACT)\b\s*:\s*(.*)/iu.exec(securityBody);
-    const attestationToken = attestationMatch?.[1] ?? "NO_CHANGE_ATTESTATION";
-    const hasNoChangeAttestation = Boolean(attestationMatch && attestationMatch[2]?.trim().length > 0);
-    if (attestationMatch && attestationMatch[2]?.trim().length === 0) {
-        errors.push(`${attestationToken} must include a non-empty rationale.`);
-    }
-    if (!hasSecurityFinding && !hasNoChangeAttestation) {
-        errors.push("Layer 2 security evidence missing: include at least one security finding or `NO_CHANGE_ATTESTATION: <reason>` / `NO_SECURITY_IMPACT: <reason>`.");
-    }
-    return {
-        ok: errors.length === 0,
-        errors,
-        hasSecurityFinding,
-        hasNoChangeAttestation
-    };
-}