geneseed 3.12.0 → 3.14.0

package/js/inspect/checks-authoring.mjs

@@ -1,7 +1,8 @@
 /**
- * The AUTHORING gates — whether the sources agree with themselves. Law and doctrine
- * metadata, the constitution's numbering, the counts the README and the web UI quote back,
- * and `authoringProblems`, which aggregates them and compiles the OpenCode plugins.
+ * The AUTHORING gates — whether the sources agree with themselves. `authoringProblems`
+ * aggregates them: the spec purpose lines and the plugins here, the constitution in
+ * `checks-constitution.mjs`, the counts in `checks-counts.mjs`, the repo records in
+ * `checks-repo.mjs`.
  *
  * Over half of the old `doctor.mjs` was this group, and it is the one with the most reasons
  * to be read: adding a law, a doctrine or a skill moves numbers in files nobody edits by
@@ -12,830 +13,26 @@
  * `node --check` over every OpenCode plugin. See `doctor.mjs` for what that allow-list costs.
  */
 import path from 'node:path';
-import {
-  CONFIG, DOCS, DOC_FOLDERS, PACK_ORDER, PLUGIN_SRC, RETIRED_RULE_IDS, ROOT, RULE_ID_RE, SRC, THEMES, canonFiles,
-  knownRuleIds, ruleCanon, titleKey,
-} from '../build/source.mjs';
-import { themeFiles } from '../hosts/installs.mjs';
+import { PLUGIN_SRC, SRC } from '../build/source.mjs';
 import { descBlockProblem, firstBlockquote } from '../hosts/native.mjs';
 import { readText } from '../lib/fs.mjs';
-import { parseJson, formatRepr } from '../lib/json.mjs';
 import { which } from '../lib/paths.mjs';
 import { NO_WINDOW } from '../lib/proc.mjs';
 import {
   folderSkillProblems, registryProblems, secretProblems, vendorPinProblems,
 } from './checks-repo.mjs';
+import { constitutionProblems, leanBlockProblems } from './checks-constitution.mjs';
+import { countTableProblems } from './checks-counts.mjs';
 import { catalogProblems } from '../loop/catalog.mjs';
-import { LAW_CLASS, LAW_CLASSES, SKILL_CLASS } from './inventory.mjs';
-import { NOTE, globSorted, has, isDir, isFile, rglob, srcStems } from './scan.mjs';
+import { globSorted, isDir } from './scan.mjs';
 import { spawnSync } from 'node:child_process';
-import { existsSync, readdirSync } from 'node:fs';
-
-const ROMAN_VALUES = { I: 1, V: 5, X: 10, L: 50, C: 100, D: 500, M: 1000 };
-
-/**
- * `_harness_build._roman_to_int`. Law headings number in Roman and the web ledger keys its
- * per-rule copy by the Arabic equivalent, so the gate has to bridge the two. 0 on an
- * unparseable numeral, which surfaces as a gate problem rather than a crash.
- */
-export function romanToInt(num) {
-  let total = 0;
-  let prev = 0;
-  for (const ch of [...num.toUpperCase()].reverse()) {
-    const v = ROMAN_VALUES[ch];
-    if (v === undefined) return 0;
-    total += v < prev ? -v : v;
-    prev = Math.max(prev, v);
-  }
-  return total;
-}
-
-/**
- * `_harness_build._LAW_META_ROW` — `<arabic>: ['<class>', '<principle>', '<id>'],` in the web page.
- *
- * The third field PINS the row to a rule id. The key is the number the catalogue renders, and a
- * number is only a position: remove a law and every later row describes its predecessor's
- * neighbour, with every class still plausible. The pin is what makes that a doctor failure.
- *
- * Either quote style, because a principle carrying an apostrophe is double-quoted. Every
- * `\s*` spans newlines and the trailing comma before `]` is optional, so a row a prettier has
- * reflowed across several lines still matches — a gate that only understood the one-line form
- * silently lost it and left the law's Principle unguarded.
- *
- * `(?m)` is the `m` flag; JS has no inline form. The `.` inside the captures must NOT match a
- * newline (Python has no `re.S` here), which is JS's default.
- */
-const LAW_META_ROW =
-  /^[^\S\n]*(\d+):\s*\[\s*(['"])(.*?)\2\s*,\s*(['"])(.*?)\4\s*(?:,\s*(['"])(.*?)\6\s*)?,?\s*\]\s*,?[^\S\n]*$/gm;
-
-/**
- * `_harness_build._law_meta_problems` — the web Laws ledger's per-rule copy stays complete.
- *
- * `LAW_META` holds each law's one-line Principle, copy that exists nowhere else in the tree,
- * and a law with no row falls back to `['craft', '']`: the rule renders with a blank
- * description and the wrong class chip, while everything upstream is fine. That is exactly
- * how two laws shipped description-less.
- */
-export function lawMetaProblems(lawNums, lawClass, lawClasses, lawIds = null) {
-  const page = path.join(ROOT, 'web', 'src', 'pages', 'Laws.jsx');
-  let text;
-  try { text = readText(page); } catch (e) {
-    return [`[authoring] web/src/pages/Laws.jsx unreadable: ${e.message}`];
-  }
-  const block = /^const LAW_META = \{$([\s\S]*?)^\}$/m.exec(text);
-  if (!block) {
-    return ['[authoring] LAW_META literal not found in web/src/pages/Laws.jsx — the web '
-      + 'Laws ledger\'s Principle column would have no gate'];
-  }
-  const meta = new Map();
-  for (const m of block[1].matchAll(LAW_META_ROW)) {
-    meta.set(Number(m[1]), [m[3], m[5], m[7]]);
-  }
-  const problems = [];
-  const seen = new Set();
-  for (const [i, roman] of lawNums.entries()) {
-    const n = romanToInt(roman);
-    seen.add(n);
-    if (!meta.has(n)) {
-      problems.push(`[authoring] laws/universal.md rule ${roman} (${n}) has no row in `
-        + 'LAW_META (web/src/pages/Laws.jsx) — the web Laws ledger would '
-        + 'render it with a blank Principle');
-      continue;
-    }
-    const [klass, principle, pin] = meta.get(n);
-    if (lawIds && pin !== lawIds[i]) {
-      problems.push(`[authoring] LAW_META[${n}] is pinned to '${pin ?? '(no id)'}' but rule ${roman} is `
-        + `'${lawIds[i]}' — the rows no longer follow the canon's order, so this principle `
-        + 'describes a different law');
-    }
-    if (!principle.trim()) {
-      problems.push(`[authoring] LAW_META[${n}] has an empty principle line — rule `
-        + `${roman} would render with a blank description`);
-    }
-    if (!lawClasses.includes(klass)) {
-      problems.push(`[authoring] LAW_META[${n}] class '${klass}' is not a known class `
-        + `${formatRepr(lawClasses)}`);
-    } else if (lawClass[roman] && klass !== lawClass[roman]) {
-      problems.push(`[authoring] LAW_META[${n}] classes rule ${roman} as '${klass}' but `
-        + `LAW_CLASS says '${lawClass[roman]}'`);
-    }
-  }
-  for (const n of [...meta.keys()].filter((k) => !seen.has(k)).sort((a, b) => a - b)) {
-    problems.push(`[authoring] LAW_META lists rule ${n} but laws/universal.md has no such rule`);
-  }
-  return problems;
-}
-
-/** `LAW_META_ROW`'s twin for a STRING key — `'<pack>.<n>': ['<pack>', '<principle>', '<id>'],`. */
-const DOCTRINE_META_ROW =
-  /^[^\S\n]*(['"])([a-z]+\.\d+)\1:\s*\[\s*(['"])(.*?)\3\s*,\s*(['"])(.*?)\5\s*(?:,\s*(['"])(.*?)\7\s*)?,?\s*\]\s*,?[^\S\n]*$/gm;
-
-/**
- * `lawMetaProblems`' doctrine half — the console's per-rule Principle column stays complete.
- *
- * SAME DEFECT, ONE TIER OVER. `DOCTRINE_META` holds copy that exists nowhere else in the tree,
- * and a rule with no row falls back to an empty principle: it renders with a blank description
- * while every count upstream reads correct. Two invariants shipped exactly that way before
- * `lawMetaProblems` existed, and 23 new rules is a much larger surface to lose one in.
- *
- * ⚠ THE CLASS ARM IS DIFFERENT FROM THE INVARIANTS'. An invariant's class is checked against
- * `LAW_CLASSES`, a vocabulary of six; a doctrine rule has no second taxonomy — its class IS its
- * pack — so the check is an EQUALITY against the pack in its own key. That catches the copy
- * error a six-way vocabulary cannot: a row pasted from the pack above it, keeping the class of
- * the pack it came from, which would colour the row and label its chip with the wrong pack.
- */
-export function doctrineMetaProblems(addrs, ids = null) {
-  const page = path.join(ROOT, 'web', 'src', 'pages', 'Laws.jsx');
-  let text;
-  try { text = readText(page); } catch (e) {
-    return [`[authoring] web/src/pages/Laws.jsx unreadable: ${e.message}`];
-  }
-  const block = /^const DOCTRINE_META = \{$([\s\S]*?)^\}$/m.exec(text);
-  if (!block) {
-    return ['[authoring] DOCTRINE_META literal not found in web/src/pages/Laws.jsx — the '
-      + "console's doctrine rows would have no gate on their Principle column"];
-  }
-  const meta = new Map();
-  for (const m of block[1].matchAll(DOCTRINE_META_ROW)) meta.set(m[2], [m[4], m[6], m[8]]);
-  const problems = [];
-  const seen = new Set();
-  for (const [i, addr] of addrs.entries()) {
-    seen.add(addr);
-    if (!meta.has(addr)) {
-      problems.push(`[authoring] doctrine rule ${addr} has no row in DOCTRINE_META `
-        + '(web/src/pages/Laws.jsx) — the console would render it with a blank Principle');
-      continue;
-    }
-    const [klass, principle, pin] = meta.get(addr);
-    if (ids && pin !== ids[i]) {
-      problems.push(`[authoring] DOCTRINE_META['${addr}'] is pinned to '${pin ?? '(no id)'}' but `
-        + `that address is '${ids[i]}' now — the row describes a different rule`);
-    }
-    if (!principle.trim()) {
-      problems.push(`[authoring] DOCTRINE_META['${addr}'] has an empty principle line — that `
-        + 'rule would render with a blank description');
-    }
-    const pack = addr.split('.')[0];
-    if (klass !== pack) {
-      problems.push(`[authoring] DOCTRINE_META['${addr}'] carries pack '${klass}' — a doctrine `
-        + `rule's class IS its pack, so this must read '${pack}'`);
-    }
-  }
-  for (const addr of [...meta.keys()].filter((k) => !seen.has(k)).sort()) {
-    problems.push(`[authoring] DOCTRINE_META lists ${addr} but no pack file defines it`);
-  }
-  return problems;
-}
-
-/**
- * `_harness_build._prose_mirror_problems` — the human-readable count mirrors, the ones the
- * badge regex never sees.
- *
- * The README "What you get" table and the web onboarding copy each restate the law / agent /
- * skill counts in prose, and the README enumerates the skills by name. Nothing renders these,
- * so they drift silently — they already had. Pure over its inputs, so the corpus can feed it
- * crafted drift without touching the tree.
- */
-export function proseMirrorProblems(readme, web, counts, skillStems, shipped = '') {
-  const problems = [];
-  const { laws, agents, skills, plugins } = counts;
-
-  for (const m of readme.matchAll(/(\d+) universal laws/g)) {
-    if (Number(m[1]) !== laws) {
-      problems.push(`[authoring] README prose says '${m[1]} universal laws' but src has ${laws}`);
-    }
-  }
-  // The README plugin count. It had drifted — the overview sentence said six while seven
-  // shipped — because the project's other plugin count ({N_PLUGINS} in the web docs) reads
-  // a DEPLOYED plugins dir that a markdown file in this repository never has. `plugins` is
-  // optional in `counts` (Python's `.get`, undefined here) because the corpus predates it.
-  if (plugins !== undefined) {
-    for (const m of readme.matchAll(/(\d+) \*{0,2}plugins/g)) {
-      if (Number(m[1]) !== plugins) {
-        problems.push(`[authoring] README prose says '${m[1]} plugins' but `
-          + `adapters/opencode/plugins has ${plugins}`);
-      }
-    }
-  }
-  for (const [label, want] of [['Agents', agents], ['Skills', skills]]) {
-    const m = new RegExp(`${label}\\*\\*\\s*\\((\\d+)\\)`).exec(readme);
-    if (m && Number(m[1]) !== want) {
-      problems.push(`[authoring] README '${label} (${m[1]})' but src has ${want}`);
-    }
-  }
-  // The README Skills row must enumerate EXACTLY the source skills — a dropped name is
-  // invisible to the (N) count alone, which is the off-by-one this gate forbids.
-  const row = readme.split('\n').find((ln) => ln.includes('🛠') && ln.includes('Skills')) ?? '';
-  if (row.includes('workflows:')) {
-    const listed = new Set(row.split('workflows:').slice(1).join('workflows:').split('·')
-      .map((seg) => seg.replace(/[^a-z0-9-]/g, '')));
-    listed.delete('');
-    for (const missing of [...skillStems].filter((s) => !listed.has(s)).sort()) {
-      problems.push(`[authoring] README skills list omits '${missing}'`);
-    }
-    for (const orphan of [...listed].filter((s) => !skillStems.has(s)).sort()) {
-      problems.push(`[authoring] README skills list names '${orphan}' but no `
-        + `skills/${orphan}.md exists`);
-    }
-  }
-
-  for (const m of web.matchAll(/(\d+) universal (?:laws|Rules)/g)) {
-    if (Number(m[1]) !== laws) {
-      problems.push(`[authoring] _web_core prose says '${m[1]} universal laws/Rules' but `
-        + `src has ${laws}`);
-    }
-  }
-  for (const m of web.matchAll(/(\d+) capability specialists/g)) {
-    if (Number(m[1]) !== agents) {
-      problems.push(`[authoring] _web_core prose says '${m[1]} capability specialists' but `
-        + `src has ${agents}`);
-    }
-  }
-  // N is a curated-subset size, not the total, so it is gated against the wikilinks it
-  // introduces rather than against the skill count. `[\s\S]` is Python's `re.S` dot.
-  const m = /(\d+) repeatable workflows the agent can invoke by name([\s\S]*?)playbook under/
-    .exec(web);
-  if (m) {
-    const listedN = (m[2].match(/\[\[[^\]]+\]\]/g) ?? []).length;
-    if (Number(m[1]) !== listedN) {
-      problems.push(`[authoring] _web_core says '${m[1]} repeatable workflows' `
-        + `but its wikilink list has ${listedN}`);
-    }
-  }
-
-  // ⚠ THE ABSENCE OF THIS TRIPLE IS CHECKED BY THE CALLER, NOT HERE, AND THAT IS FORCED RATHER
-  // THAN CHOSEN. This arm is satisfiable by DELETING THE SENTENCE — no match, no problem, green
-  // — which is a gate failing open. The obvious fix is an `else` right here, and it cannot go
-  // here: `prose_mirror_problems` is one of the pure functions recorded in
-  // `tests/__snapshots__/primitives/`, the recording holds a case that passes an EMPTY `shipped`
-  // and expects `[]`, and there is no recorder left to re-bless it. So the presence check lives
-  // in `countTableProblems`, which is not recorded — beside the read that already knows whether
-  // the file could be opened at all, which is where it reads better anyway.
-  const s = /(\d+) laws, (\d+) agents, (\d+) skills/.exec(shipped);
-  if (s) {
-    for (const [got, want, label] of [[s[1], laws, 'laws'], [s[2], agents, 'agents'],
-      [s[3], skills, 'skills']]) {
-      if (Number(got) !== want) {
-        problems.push(`[authoring] SHIPPED.md says '${got} ${label}' but src has ${want}`);
-      }
-    }
-  }
-  return problems;
-}
-
-/** `_build_render._TMPL_SPEC_RE`, as the count gate spells it. */
-const TMPL_SPEC_RE = /\{\{DIR_(AGENTS|SKILLS)\}\}\/([A-Za-z0-9_-]+)\.md/g;
-// A rule is DECLARED by its heading and CITED by its id — see `ruleCanon` in
-// `js/build/source.mjs`. The gates below read the RAW source, because the render resolves ids and
-// a bad one would already be gone from what it hands back.
-const DECL_LINE_RE = /^### \{\{(LAW|DOCTRINE):([^}]*)\}\}[ \t]+\S/;
-const ID_CITE_RE = /\{\{(LAW|DOCTRINE):([^}]*)\}\}/g;
-// The pre-id spellings. Either one in src/ is a citation that names a POSITION, which is exactly
-// what stops being true the next time the canon moves.
-const BARE_CITE_RE = /\{\{LAW\}\}\s+[IVXLCDM]+\b|\{\{DOCTRINE\}\}\s+[a-z]+\s+\d+\b/g;
-// `{{DOCTRINE}}` or `{{DOCTRINE:` and not `DOCTRINE`: `{{DOCTRINES}}` is the SECTION noun and is
-// legal everywhere, including in an invariant that points at the tier as a whole.
-const DOCTRINE_TOKEN_RE = /\{\{DOCTRINE(?:\}\}|:)/;
-
-/**
- * The rules the hooks enforce at the tool boundary, and the address each is bound to there. The
- * hook path cannot afford to read the canon on every tool call, so its gate-ledger keys
- * (`law-1`, `law-4`, `process-1`, `process-5` in `js/hosts/hooks.mjs` and the OpenCode guard
- * plugin), `CONSENT_RULE` in `js/hosts/settings.mjs` and the console's `HOOK_GATED` stay
- * number-keyed — and this pin is what turns a renumber that moves one of these rules into a
- * doctor failure instead of a gate silently guarding its neighbour.
- */
-export const HOOK_PINNED = {
-  'sealed-secrets': 'I', 'deletion-is-deliberate': 'IV',
-  'persist-insight': 'process 1', 'consent-before-push': 'process 5',
-};
-
-/**
- * The LEAN block grammar, and the heading split, both duplicated from `js/build/render.mjs`.
- *
- * Deliberately duplicated rather than imported: both are module-private
- * there, and exporting them so one gate could borrow them would widen the renderer's surface
- * for a reader that only needs to know the shape. Two literals, one paragraph apart from the
- * rule they encode, is cheaper than a seam.
- */
-const LEAN_BLOCK_RE =
-  /[ \t]*<!-- LEAN:begin -->\n([\s\S]*?)[ \t]*<!-- LEAN:else -->\n([\s\S]*?)[ \t]*<!-- LEAN:end -->\n/g;
-
-/** `### ` at line start — the same cut `splitAtLawHeadings` makes, and for the same addresses. */
-function leanRuleBlocks(text) {
-  const out = [];
-  let start = 0;
-  for (let i = 0; i < text.length; i++) {
-    if ((i === 0 || text[i - 1] === '\n') && text.startsWith('### ', i)) {
-      out.push(text.slice(start, i));
-      start = i;
-    }
-  }
-  out.push(text.slice(start));
-  return out.slice(1);                        // drop the lead chunk: the file's preamble
-}
-
-/**
- * Every authored rule carries exactly one LEAN block, and both halves say something.
- *
- * ⚠ `resolveLean` IS A REPLACE OVER A MARKER PAIR, WHICH MAKES IT A NO-OP ON MARKERLESS TEXT.
- * A rule whose block was never written, or lost to an edit, therefore ships its FULL body at
- * the default footprint — silently, in every install, with every other gate in the tree green.
- * That is the failure this arm exists for, and before it there was no LEAN gate anywhere in
- * `js/inspect/`: not for the doctrine packs, and not for the invariants either.
- *
- * The other two shapes are cheaper to state than to debug. An empty lean half renders a
- * heading over nothing at the footprint most installs use. Two blocks in one rule are
- * ambiguous by construction — `LEAN_BLOCK_RE` is global, so both would resolve, and which
- * text the reader gets would be a fact about the order they were written in.
- *
- * The ontology is exempt on purpose: it carries ONE file-wide block whose halves each repeat
- * the four `####` section headings, which is a different shape with its own gate in
- * `tests/unit/emit_smoke.test.mjs` (four distinct names, eight occurrences).
- */
-export function leanBlockProblems() {
-  const problems = [];
-  const files = [['laws', path.join(SRC, 'laws', 'universal.md')]];
-  for (const pack of PACK_ORDER) files.push(['doctrines', path.join(SRC, 'doctrines', `${pack}.md`)]);
-
-  for (const [dir, file] of files) {
-    const rel = `${dir}/${path.basename(file)}`;
-    let text;
-    try { text = readText(file); } catch (e) {
-      problems.push(`[authoring] ${rel} unreadable: ${e.message} — every rule in it would ship `
-        + 'its full body at the lean footprint, unannounced');
-      continue;
-    }
-    for (const block of leanRuleBlocks(text)) {
-      // The address as the SOURCE spells it — `{{LAW}} II`, `{{DOCTRINE}} craft 1` — because
-      // that is the string an author greps for, and the rendered spelling is fourteen strings.
-      const heading = block.slice(0, block.indexOf('\n') === -1 ? undefined : block.indexOf('\n'));
-      const addr = heading.replace(/^###\s+/, '').split(/\s+[—-]\s+/)[0].trim();
-      const found = [...block.matchAll(LEAN_BLOCK_RE)];
-      if (found.length === 0) {
-        problems.push(`[authoring] ${rel}: ${addr} has no LEAN block — resolveLean is a no-op on `
-          + 'markerless text, so the rule would inline its FULL body at the default footprint');
-        continue;
-      }
-      if (found.length > 1) {
-        problems.push(`[authoring] ${rel}: ${addr} has ${found.length} LEAN blocks — both resolve, `
-          + 'so which text a reader is handed is a fact about the order they were written in');
-      }
-      const [, full, lean] = found[0];
-      if (!full.trim()) {
-        problems.push(`[authoring] ${rel}: ${addr} has an empty full half — the rule would vanish `
-          + 'from a full build and from its own on-disk file');
-      }
-      if (!lean.trim()) {
-        problems.push(`[authoring] ${rel}: ${addr} has an empty lean half — the rule would render `
-          + 'as a heading over nothing at the footprint most installs use');
-      }
-    }
-  }
-  return problems;
-}
-
-/**
- * The three-tier constitution's own authoring gates — the doctrine twin of the `LAW_CLASS` /
- * `LAW_META` family, plus the two purity rules the tiering rests on.
- *
- * IT LIVES BESIDE `countTableProblems` RATHER THAN INSIDE IT, and is called from
- * `authoringProblems` beside `registry`/`secret`/`vendorPin`. `countTableProblems` opens by
- * reading `AGENT.md.tmpl` and HARD-RETURNS if that read fails, so an arm placed inside it
- * would go quiet on exactly the tree that is most broken. Nothing here needs the template's
- * tables, and `proseMirrorProblems` — the frozen recording — is untouched either way.
- *
- * ⚠ THE VOCABULARY GATES ARE HERE BECAUSE `themeParityProblems` CANNOT SEE THEM. That check is
- * presence-only and SYMMETRIC over the union of every theme's keys: a key missing from all
- * fourteen is in parity, and a key whose VALUE breaks a parser is not its business at all. So
- * `DOC_*` coverage, the `LEX_*` equality and the single-word tier noun each need a gate
- * that reads the SOURCE and asks what the source requires.
- */
-export function constitutionProblems() {
-  const problems = [];
-
-  // ---- every rule declares an id, every id is well-formed and unique, none is retired.
-  //
-  // Numbers are positional now (`ruleCanon`), so contiguity and filing cannot go wrong; what can
-  // is the declaration itself. A `### ` line in a canon file that is not `{{KIND:id}} Name`
-  // renders nowhere as a rule — no number, no title — and a duplicated id makes every citation
-  // of it ambiguous.
-  for (const [kind, pack, file] of canonFiles(SRC)) {
-    const rel = path.relative(SRC, file).split(path.sep).join('/');
-    let text;
-    try { text = readText(file); } catch (e) {
-      problems.push(`[authoring] ${rel} is ${pack ? 'named in PACK_ORDER' : 'the canon'} but `
-        + `unreadable: ${e.message} — every citation into it breaks`);
-      continue;
-    }
-    let count = 0;
-    for (const line of text.split('\n').filter((l) => l.startsWith('### '))) {
-      const m = DECL_LINE_RE.exec(line);
-      if (!m || m[1] !== kind) {
-        problems.push(`[authoring] ${rel}: '${line}' is not a rule declaration — a rule heading `
-          + `here reads '### {{${kind}:<id>}} <Principle Name>'; without an id it has no number, `
-          + 'no title and no way to be cited');
-        continue;
-      }
-      count += 1;
-      if (!RULE_ID_RE.test(m[2])) {
-        problems.push(`[authoring] ${rel}: rule id '${m[2]}' is not kebab-case (a-z, 0-9, '-')`);
-      }
-    }
-    if (!count) {
-      const why = pack ? 'the pack would render as an empty section' : 'there would be no invariants';
-      problems.push(`[authoring] ${rel} declares no rule — ${why}`);
-    }
-  }
-  const canon = ruleCanon(SRC);
-  const seenIds = new Map();
-  const seenNames = new Map();
-  for (const r of canon.rules) {
-    const where = r.kind === 'LAW' ? `law ${r.label}` : `doctrine ${r.label}`;
-    if (seenIds.has(r.id)) {
-      problems.push(`[authoring] rule id '${r.id}' is declared twice (${seenIds.get(r.id)} and `
-        + `${where}) — ids are unique across laws and doctrines, or a citation names two rules`);
-    } else seenIds.set(r.id, where);
-    const lower = r.name.toLowerCase();
-    if (seenNames.has(lower)) {
-      problems.push(`[authoring] principle name '${r.name}' is declared twice (${seenNames.get(lower)} `
-        + `and ${where}) — a citation renders as the name, so two rules would read as one`);
-    } else seenNames.set(lower, where);
-    const retiredAs = RETIRED_RULE_IDS[r.id];
-    if (retiredAs && retiredAs.liveAs !== r.kind) {
-      problems.push(`[authoring] ${where} reuses the retired id '${r.id}' (${retiredAs.was}, `
-        + `${retiredAs.note}) — an id that meant one rule in someone's notes must never come back `
-        + 'meaning another; pick a new one');
-    }
-  }
-  const rules = new Map(canon.rules.filter((r) => r.kind === 'DOCTRINE')
-    .map((r) => [`${r.pack}.${r.n}`, r]));
-
-  // ---- the hook-gated rules are still at the address the hooks key them by.
-  for (const [id, label] of Object.entries(HOOK_PINNED)) {
-    const r = canon.byId.get(id);
-    if (!r || r.label !== label) {
-      problems.push(`[authoring] the hooks gate '${id}' as ${label} (js/hosts/hooks.mjs ledger keys, `
-        + `settings.mjs CONSENT_RULE, the console's HOOK_GATED), but the canon ${r ? `numbers it ${r.label}`
-          : 'no longer declares it'} — move those keys with it, or the tool boundary guards a `
-        + 'different rule than the prompt names');
-    }
-  }
-
-  // The console's Principle column, keyed off the rules just parsed — so the gate is driven by
-  // the SOURCE and a rule added to a pack file is caught the same day, not when someone
-  // notices a blank description in the browser.
-  problems.push(...doctrineMetaProblems([...rules.keys()], [...rules.values()].map((r) => r.id)));
-
-  // ---- `--exclude-rules` closes against the SAME rules this walk just found.
-  //
-  // `knownRuleIds` is what the CLI flag, the console's trust boundary and every wizard prompt
-  // validate an address against; the walk above is what the constitution actually renders.
-  // Two readers of one directory is the shape that lets a rule be authored, rendered, cited —
-  // and rejected by the only flag that can switch it off, with `invalid choice` naming a set
-  // that visibly contains it. An equality, not containment: a stale id in the enumerator is a
-  // rule the console offers a switch for and the build cannot drop.
-  const enumerated = knownRuleIds();
-  const walked = [...rules.keys()];
-  for (const id of enumerated.filter((i) => !walked.includes(i))) {
-    problems.push(`[authoring] knownRuleIds() offers '${id.replace('.', ' ')}', which no pack `
-      + 'file defines — --exclude-rules accepts an address the build cannot drop');
-  }
-  for (const id of walked.filter((i) => !enumerated.includes(i))) {
-    problems.push(`[authoring] doctrine ${id.replace('.', ' ')} is defined but knownRuleIds() `
-      + 'does not offer it — --exclude-rules refuses a rule that exists, and the console has '
-      + 'no switch for it');
-  }
-
-  // ---- every citation in src/ is by id, and every id resolves.
-  //
-  // The whole tree, not the template: a skill footer citing a rule that does not exist is as
-  // broken as a template one, and it renders into every bundle.
-  const cited = new Map();                                    // 'process.5' -> [rel, …]
-  for (const p of rglob(SRC)) {
-    if (!isFile(p) || !(p.endsWith('.md') || p.endsWith('.tmpl'))) continue;
-    let text;
-    try { text = readText(p); } catch { continue; }
-    const rel = path.relative(SRC, p).split(path.sep).join('/');
-    // ⚠ AN ALWAYS-ON TIER MAY NEVER CITE A TOGGLEABLE ONE (D2). A `--doctrines craft` build
-    // ships invariants that point at rules its AGENT.md does not contain; the ontology is
-    // worse still, being the tier that states the order the others sit in. Doctrine->doctrine
-    // citations are fine and stay: the full catalogue ships in every bundle.
-    if ((rel.startsWith('ontology/') || rel.startsWith('laws/')) && DOCTRINE_TOKEN_RE.test(text)) {
-      problems.push(`[authoring] ${rel} cites {{DOCTRINE}} — an always-on tier may never `
-        + 'reference a toggleable one, or a pack-off build ships a rule pointing at text '
-        + 'that is not there. State the point directly instead');
-    }
-    for (const [bare] of text.matchAll(BARE_CITE_RE)) {
-      problems.push(`[authoring] ${rel} cites '${bare.replace(/\s+/g, ' ')}' by number — numbers are `
-        + 'positional and move when the canon does; cite {{LAW:<id>}} / {{DOCTRINE:<id>}}');
-    }
-    for (const [whole, kind, id] of text.matchAll(ID_CITE_RE)) {
-      const r = canon.byId.get(id);
-      if (r && r.kind === kind) {
-        if (kind === 'DOCTRINE') {
-          const key = `${r.pack}.${r.n}`;
-          if (!cited.has(key)) cited.set(key, []);
-          cited.get(key).push(rel);
-        }
-        continue;
-      }
-      const retiredAs = RETIRED_RULE_IDS[id];
-      let why = 'which no law or doctrine declares — it would render as the raw token';
-      if (r) why = `but '${id}' is a ${r.kind === 'LAW' ? 'law' : 'doctrine rule'} — use {{${r.kind}:${id}}}`;
-      else if (retiredAs) {
-        why = `a retired id (${retiredAs.was}, ${retiredAs.note}) — cite the rule its text now lives in`;
-      }
-      problems.push(`[authoring] ${rel} cites ${whole}, ${why}`);
-    }
-  }
-
-  // ---- the vocabulary every theme owes the source: one title per declared rule, keyed by id.
-  const wanted = new Set(canon.rules.filter((r) => r.kind === 'DOCTRINE').map((r) => titleKey(r.kind, r.id)));
-  const lexWant = canon.rules.filter((r) => r.kind === 'LAW').map((r) => titleKey(r.kind, r.id));
-  // `_TEMPLATE.json` is included — it is the file `--sync-themes` seeds a new theme from, so a
-  // stale key there propagates into every voice added afterwards. `themeFiles()` excludes it.
-  const files = [...themeFiles(), path.join(THEMES, '_TEMPLATE.json')];
-  for (const f of files) {
-    const name = path.basename(f);
-    let theme;
-    try { theme = parseJson(readText(f)); } catch (e) {
-      problems.push(`[authoring] ${name} unreadable: ${e.message}`);
-      continue;
-    }
-    if (!theme || typeof theme !== 'object' || Array.isArray(theme)) continue;
-    const keys = Object.keys(theme);
-    for (const key of [...wanted].sort()) {
-      if (!Object.hasOwn(theme, key)) {
-        problems.push(`[authoring] ${name} has no {${key}} — a doctrine rule declares it, and `
-          + 'theme parity cannot see a key that is missing from every theme at once');
-      }
-    }
-    for (const key of keys.filter((k) => k.startsWith('DOC_')).sort()) {
-      if (!wanted.has(key)) {
-        problems.push(`[authoring] ${name} defines {${key}}, which no doctrine rule declares — a `
-          + 'dead voice key ships a title for a rule that does not exist');
-      }
-    }
-    // I1 — an EQUALITY, not a presence check. The renumber left `LEX_XXII`, `LEX_XXIII`,
-    // `LEX_XXIV` and `LEX_XXXVI` behind in all fifteen files, and parity was silent because
-    // they were absent from nowhere.
-    const lex = keys.filter((k) => k.startsWith('LEX_')).sort();
-    const stale = lex.filter((k) => !lexWant.includes(k));
-    const missing = lexWant.filter((k) => !lex.includes(k));
-    for (const k of stale) {
-      problems.push(`[authoring] ${name} still defines {${k}} — no law declares this id and `
-        + 'nothing renders this key, so it is a title for a rule that no longer exists');
-    }
-    for (const k of missing) {
-      problems.push(`[authoring] ${name} has no {${k}} — one of the invariants would `
-        + 'render with an empty title');
-    }
-    // M10 — ⚠ BOTH HEADING PARSERS MATCH THE TIER NOUN WITH `\S+`. A two-word value does not
-    // error; the heading stops matching and the tier silently parses to nothing. `_TEMPLATE`'s
-    // values are descriptive placeholders, so only real voices are held to this.
-    if (name === '_TEMPLATE.json') continue;
-    for (const key of ['LAW', 'DOCTRINE']) {
-      const v = theme[key];
-      if (typeof v === 'string' && /\s/.test(v)) {
-        problems.push(`[authoring] ${name} spells {${key}} as ${formatRepr(v)} — the heading `
-          + 'parsers match the tier noun with \\S+, so a value with a space makes every '
-          + `${key === 'LAW' ? 'invariant' : 'doctrine rule'} parse to nothing, in silence`);
-      }
-    }
-  }
 
-  // ---- every `§N` in src/ addresses a section the template actually declares.
-  //
-  // ⚠ THIS GATE IS NARROW AND SAYS SO. Inserting `## 2. Doctrines` pushed every later section
-  // down one, and the sweep that fixed the template's own cross-references stopped at the
-  // template — four satellites under `src/skills/` and `src/agents/` kept pointing at the
-  // section that used to be there, and they RENDER INTO EVERY BUNDLE. A range check would not
-  // have caught those: §7 still existed, it had just stopped being the Wiki.
-  //
-  // What it does catch is the other half of a renumber — a pointer past the end, which is what
-  // REMOVING a section leaves behind — and it is nearly free. The half it cannot catch is a
-  // judgement about intent, and `docs/extending.md` carries the manual sweep for it. Naming
-  // that limit here is the point: a reader who assumes this gate is total will skip the sweep.
-  const declared = new Set();
-  // Read here rather than borrowing `countTableProblems`' copy: that function hard-returns when
-  // the template is unreadable, and this gate must not inherit a silence it did not choose.
-  let tmpl = '';
-  try { tmpl = readText(path.join(SRC, 'AGENT.md.tmpl')); } catch { tmpl = ''; }
-  for (const [, n] of tmpl.matchAll(/^## (\d+)\.\s/gm)) declared.add(Number(n));
-  if (declared.size) {
-    for (const p of rglob(SRC)) {
-      if (!isFile(p) || !(p.endsWith('.md') || p.endsWith('.tmpl'))) continue;
-      let text;
-      try { text = readText(p); } catch { continue; }
-      const rel = path.relative(SRC, p).split(path.sep).join('/');
-      for (const [, n] of text.matchAll(/§(\d+)/g)) {
-        if (declared.has(Number(n))) continue;
-        problems.push(`[authoring] ${rel} cites AGENT.md §${n}, and the template declares no `
-          + `such section ${formatRepr([...declared].sort((a, b) => a - b).map(String))} — a `
-          + 'renumber moved it, and this pointer renders into every bundle');
-      }
-    }
-  }
-
-  // ---- the build default names packs that exist.
-  let cfgDoctrines = null;
-  try {
-    const cfg = parseJson(readText(CONFIG));
-    if (cfg && typeof cfg === 'object' && Array.isArray(cfg.doctrines)) cfgDoctrines = cfg.doctrines;
-  } catch { /* no config, or unreadable — `configDefaults()` is forgiving here too */ }
-  if (cfgDoctrines) {
-    for (const pack of cfgDoctrines) {
-      if (!PACK_ORDER.includes(pack)) {
-        problems.push(`[authoring] harness.config.json names doctrine pack ${formatRepr(pack)}, `
-          + `which this checkout does not ship ${formatRepr([...PACK_ORDER])} — every build reading `
-          + 'that default would fail');
-      }
-    }
-  }
-
-  // ---- D5, a NOTE and not a problem: what a narrowed default leaves pointing at the shelf.
-  const on = cfgDoctrines ?? [...PACK_ORDER];
-  const dangling = [...cited].filter(([k]) => rules.has(k) && !on.includes(k.split('.')[0]));
-  if (dangling.length) {
-    const packs = [...new Set(dangling.map(([k]) => k.split('.')[0]))].sort();
-    problems.push(`${NOTE}harness.config.json builds ${formatRepr(on)}, and ${dangling.length} `
-      + `citation(s) in src/ point into ${packs.join(', ')}. Those rules still SHIP — every `
-      + 'pack file is in the bundle — so the reference resolves on disk; it is the rendered '
-      + 'AGENT.md that will not contain them. Legal, and recorded here so it is not silent');
-  }
-  return problems;
-}
-
-/**
- * `_harness_build._count_table_problems` — the hand-authored AGENT.md tables and the README
- * badges, against `src/`.
- *
- * The tables must list EXACTLY the spec files (no dead row, no orphaned spec) and each
- * `agents`/`skills`/`laws`/`themes` badge must equal the real count. This is the
- * authoring-time guarantee that lets tables, badges and prose stay hand-written without
- * silently drifting from the source tree.
- */
-export function countTableProblems() {
-  const problems = [];
-  let ttext;
-  try { ttext = readText(path.join(SRC, 'AGENT.md.tmpl')); } catch (e) {
-    return [`[authoring] AGENT.md.tmpl unreadable: ${e.message}`];
-  }
-
-  const linked = { agents: new Set(), skills: new Set() };
-  for (const m of ttext.matchAll(TMPL_SPEC_RE)) {
-    if (m[2] !== '_template') linked[m[1] === 'AGENTS' ? 'agents' : 'skills'].add(m[2]);
-  }
-  for (const folder of ['agents', 'skills']) {
-    const files = srcStems(folder);
-    for (const missing of [...linked[folder]].filter((x) => !files.has(x)).sort()) {
-      problems.push(`[authoring] AGENT.md links ${folder}/${missing}.md but no such spec exists`);
-    }
-    for (const orphan of [...files].filter((x) => !linked[folder].has(x)).sort()) {
-      problems.push(`[authoring] ${folder}/${orphan}.md exists but the AGENT.md table omits it`);
-    }
-  }
-
-  const skillFiles = srcStems('skills');
-  for (const missing of [...skillFiles].filter((s) => !has(SKILL_CLASS, s)).sort()) {
-    problems.push(`[authoring] skills/${missing}.md has no category in SKILL_CLASS`);
-  }
-  for (const stale of Object.keys(SKILL_CLASS).filter((s) => !skillFiles.has(s)).sort()) {
-    problems.push(`[authoring] SKILL_CLASS lists '${stale}' but no skills/${stale}.md exists`);
-  }
-
-  // The numerals the laws RENDER with — positional, off the canon — because LAW_CLASS and the
-  // console's LAW_META are keyed the way the rendered catalogue numbers them.
-  const lawRules = ruleCanon(SRC).rules.filter((r) => r.kind === 'LAW');
-  const lawNums = lawRules.map((r) => r.label);
-  for (const num of lawNums) {
-    if (!has(LAW_CLASS, num)) {
-      problems.push(`[authoring] laws/universal.md rule ${num} has no class in LAW_CLASS`);
-    }
-  }
-  // `sorted(LAW_CLASS.items())` — by the Roman numeral as a STRING, which is what Python
-  // sorts here; the messages are re-sorted by `doctorCollect` anyway, so only the set travels.
-  for (const num of Object.keys(LAW_CLASS).sort()) {
-    if (!LAW_CLASSES.includes(LAW_CLASS[num])) {
-      problems.push(`[authoring] LAW_CLASS['${num}'] = '${LAW_CLASS[num]}' is not a known `
-        + `class ${formatRepr(LAW_CLASSES)}`);
-    }
-  }
-  problems.push(...lawMetaProblems(lawNums, LAW_CLASS, LAW_CLASSES, lawRules.map((r) => r.id)));
-
-  // WHAT SHIPS, NOT WHAT IS FLAT. A folder skill (`src/skills/<name>/SKILL.md`, vendored with
-  // its scripts or references) ships exactly like a flat one, so the badge, the README list and
-  // the SHIPPED.md triple count it. It is added HERE rather than in `srcStems`, whose other
-  // readers above — the AGENT.md table links and SKILL_CLASS — are about flat specs only.
-  const skillsDir = path.join(SRC, 'skills');
-  const shippedSkills = new Set([...skillFiles, ...(isDir(skillsDir) ? readdirSync(skillsDir) : [])
-    .filter((d) => !d.startsWith('_') && isFile(path.join(skillsDir, d, 'SKILL.md')))]);
-
-  const counts = {
-    agents: srcStems('agents').size,
-    skills: shippedSkills.size,
-    laws: lawNums.length,
-    themes: themeFiles().length,
-    // Last on purpose: the badge loop below walks this object in insertion order and the
-    // message sequence is compared byte for byte against the Python implementation.
-    plugins: existsSync(PLUGIN_SRC)
-      ? readdirSync(PLUGIN_SRC).filter((f) => f.startsWith('geneseed-') && f.endsWith('.js')).length
-      : 0,
-  };
-  let readme;
-  try { readme = readText(path.join(ROOT, 'README.md')); } catch { return problems; }
-  // ⚠ PRESENCE FIRST, THEN THE VALUE — the same absence arm the SHIPPED triple needed, for the
-  // same reason: `if (m && …)` is green when there is no badge, so deleting a badge silences its
-  // own gate. The `continue` keeps the loop's MESSAGE ORDER intact, which is load-bearing (see
-  // the `plugins`-is-last comment above): a missing badge reports in its own slot rather than
-  // reordering the ones after it.
-  for (const [key, n] of Object.entries(counts)) {
-    const m = new RegExp(`badge/${key}-(\\d+)`).exec(readme);
-    if (!m) {
-      problems.push(`[authoring] README has no ${key} badge — deleting one is how this gate `
-        + 'goes green while the reader is told nothing');
-      continue;
-    }
-    if (Number(m[1]) !== n) {
-      problems.push(`[authoring] README ${key} badge says ${m[1]} but src has ${n}`);
-    }
-  }
-
-  // WHERE THE ONBOARDING COPY LIVES, AND WHY THIS READ MOVED. It used to open the one module
-  // that held the web console's onboarding prose. That prose has since moved into
-  // `docs/<folder>/*.md`, and the counts in it render from `{N_LAWS}` / `{N_AGENTS}` / `{N_SKILLS}`
-  // — so the read was still succeeding against a file the sentences had left, all three arms
-  // below scored zero, and the check looked healthy while gating nothing. A templated count
-  // cannot drift; what these arms still catch is a maintainer typing the NUMBER into a page
-  // instead of the token, which is the drift that reaches a reader.
-  //
-  // MEASURED BEFORE AND AFTER: zero problems either way on the shipped tree, so no recorded
-  // byte moves. `web` stays fail-soft — a missing docs tree is not an authoring fault.
-  let web = '';
-  try {
-    web = DOC_FOLDERS
-      .flatMap((f) => (isDir(path.join(DOCS, f))
-        ? globSorted(path.join(DOCS, f), (n) => n.endsWith('.md')) : []))
-      .map(readText).join('\n');
-  } catch { web = ''; }
-  // ⚠ NOT FAIL-SOFT, UNLIKE `web` ABOVE, AND THE ASYMMETRY IS THE POINT. A missing `docs/web`
-  // tree is not an authoring fault — a checkout can legitimately lack it. SHIPPED.md is a
-  // tracked, shipped file that this function asserts the CONTENT of, so an unreadable one is
-  // indistinguishable from a deleted claim: swallowing it into `''` used to hand the triple arm
-  // an empty string and turn a hard read failure into a silent pass.
-  // ⚠ NOT FAIL-SOFT, UNLIKE `web` ABOVE, AND THE ASYMMETRY IS THE POINT. A missing `docs/web`
-  // tree is not an authoring fault — a checkout can legitimately lack it. SHIPPED.md is a
-  // tracked, shipped file whose CONTENT this function asserts, so an unreadable one was
-  // indistinguishable from a deleted claim: swallowing it into `''` handed the triple arm an
-  // empty string and turned a hard read failure into a silent pass.
-  //
-  // AND THE PRESENCE OF THE TRIPLE IS CHECKED HERE rather than inside `proseMirrorProblems`,
-  // which is where it belongs by subject and cannot go by construction — that function is
-  // recorded in `tests/__snapshots__/primitives/` with a case that passes an empty `shipped` and
-  // expects `[]`, and nothing can re-bless a recording whose recorder is deleted. This is the
-  // caller, it is not recorded, and it already owns the question "could the file be read".
-  let shipped;
-  try {
-    shipped = readText(path.join(ROOT, 'SHIPPED.md'));
-  } catch (e) {
-    problems.push(`[authoring] SHIPPED.md is unreadable (${e.message}) — the counts it carries `
-      + 'cannot be checked, and a gate that cannot read its subject must say so');
-    shipped = '';
-  }
-  if (shipped && !/(\d+) laws, (\d+) agents, (\d+) skills/.test(shipped)) {
-    problems.push('[authoring] SHIPPED.md carries no \'N laws, N agents, N skills\' line — '
-      + 'deleting it is how that gate goes green while the count drifts');
-  }
-  problems.push(...proseMirrorProblems(readme, web, counts, shippedSkills, shipped));
-  return problems;
-}
-
-/** `_harness_core.LEARN_PROMPT_HEAD`'s extraction regex — one owner, two readers. */
-const LEARN_PROMPT_RE = /const LEARN_PROMPT_HEAD = `([\s\S]*?)`/;
-
-/**
- * `_harness_core._load_learn_prompt_head` — the distil instructions, read out of the plugin.
- *
- * The single source of truth is the OpenCode plugin, the artifact that ships to the primary
- * runtime, so the CLI extracts it at load time rather than carrying a copy. Reproduced here
- * rather than imported from `js/hosts/hooks.mjs`, which this entry may not reach: `learn` spawns the
- * model CLI, and the allow-list below names ONE call site.
- *
- * The fallback matters as much as the extraction. It is what makes the drift arm of
- * `_authoring_problems` unreachable — both the loaded copy and the checked literal come from
- * one file through one regex, so a reference can never disagree with itself. A port that
- * hardcoded the prompt WOULD disagree, which is what
- * `doctor/the-loaded-copy-follows-the-plugin-rather-than-a-constant` exists to catch.
- */
-function loadLearnPromptHead() {
-  try {
-    const m = LEARN_PROMPT_RE.exec(readText(path.join(PLUGIN_SRC, 'geneseed-learn.js')));
-    if (m) return m[1];
-  } catch { /* OSError — fall through */ }
-  return 'Distil at most one durable, reusable memory from the notes below. '
-    + 'When in doubt, output exactly: NOTHING.';
-}
+// Moved to the two sibling modules; re-exported so callers that import the authoring group as
+// one module keep working.
+export {
+  HOOK_PINNED, constitutionProblems, doctrineMetaProblems, lawMetaProblems, leanBlockProblems,
+} from './checks-constitution.mjs';
+export { countTableProblems, proseMirrorProblems } from './checks-counts.mjs';
 
 /**
  * The shipped loop catalogue parses and every shipped template passes the engine's own graph
@@ -879,25 +76,21 @@ export function authoringProblems() {
       }
     }
   }
-  const plugin = path.join(PLUGIN_SRC, 'geneseed-learn.js');
-  let m = null;
-  try { m = LEARN_PROMPT_RE.exec(readText(plugin)); } catch { m = null; }
-  if (!m) {
-    // "the harness", not `harness.py`: both implementations load this literal, and the file
-    // the old wording named is the one this migration deletes. Moved on both sides at once —
-    // these two strings are byte-compared by the live doctor comparison.
+  // The learn plugin is the single source of the distil prompt: `js/hosts/hooks.mjs` extracts
+  // it at load time rather than carrying a copy, and falls back to a stub when it cannot — so
+  // the literal must stay extractable.
+  let learn = '';
+  try { learn = readText(path.join(PLUGIN_SRC, 'geneseed-learn.js')); } catch { learn = ''; }
+  if (!/const LEARN_PROMPT_HEAD = `[\s\S]*?`/.test(learn)) {
     problems.push('[authoring] LEARN_PROMPT_HEAD literal not found in '
       + 'geneseed-learn.js — the harness would fall back (single source broken)');
-  } else if (m[1] !== loadLearnPromptHead()) {
-    problems.push('[authoring] LEARN_PROMPT_HEAD drifted between geneseed-learn.js '
-      + "and the harness's loaded copy");
   }
   const node = which('node');
   if (node) {
     for (const js of globSorted(PLUGIN_SRC, (n) => n.endsWith('.js'))) {
       // THE ONE SPAWN. `node --check` and nothing else — see the module header, and
       // the `inspect/checks-authoring.mjs` row of the spawn allow-list in
-// `tests/unit/hook_cli.test.mjs`, which names this argv literally.
+      // `tests/unit/hook_cli.test.mjs`, which names this argv literally.
       // `NO_WINDOW` because the reference's `run()` folds `CREATE_NO_WINDOW` into every
       // CAPTURING spawn and this is one — and because this loop is the burst a user sees:
       // one console window per plugin, every time the web daemon runs the doctor.