geneseed 4.18.1 → 4.19.0

package/CHANGELOG.md

@@ -8,6 +8,22 @@ label. For the capability ↔ spec map, see [SHIPPED.md](SHIPPED.md).
 
 ## [Unreleased]
 
+## [4.19.0] — 2026-10-24
+
+Minor: shared console building blocks, rule summaries kept next to their rules, and `global` as a documented rule scope.
+
+### Added
+- **Shared console building blocks.** `PageHeader` (one primary action), `EmptyState`, `DataTable`, `Stat`, `Bar`/`StackBar`, `Ring` and `Popover`, on a 7-step type scale, an 8-step spacing scale and named z-index layers. Pages adopt them in the next release.
+- **`global` is a documented rule scope.** The `rule` skill names `project`, `global` and `user`, and the console's scope select offers `global`. A scope it does not list is still kept as written.
+
+### Changed
+- **Rule summaries live next to their rules.** The one-line summary the Constitution page prints for each law and doctrine rule is now a `<!-- note: summary: … -->` line under the rule's heading in `src/`, served by the catalog; the page's own copy of the 40 summaries is gone. The text moved word for word, and installs are byte-identical. `doctor` checks one summary per rule, none orphaned.
+- **Destructive confirmations look destructive.** Forget, Retire, Restore, Stop server and discarding an unsaved edit use a danger button and put focus on Cancel. An error toast stays until you dismiss it.
+
+### Fixed
+- The danger button's text now meets WCAG AA on dark backgrounds in every flavour.
+- The Overview lenses' readiness ring follows the fleet verdict (capped at 65% when the fleet needs a look, 40% when it is in trouble), and the Constitution map and KPI strip use the voice's own tier names.
+
 ## [4.18.1] — 2026-10-24
 
 Patch: the web console's light mode meets WCAG AA, and console installs default to lean.

package/DESIGN.md

@@ -150,9 +150,9 @@ vault or a specific tool's hooks.
    | body | `### {{LAW:<id>}} <Principle>` in `src/laws/universal.md`; citations resolve by id, so no position rewires one | `### {{DOCTRINE:<id>}} <Principle>` in `src/doctrines/<pack>.md`; the number is its position | a new `src/doctrines/<pack>.md` with its `**Name** — lead line` |
    | themed title | `LEX_<ID>` in all 15 theme files | `DOC_<ID>` in all 15 theme files | `PACK_<NAME>` in all 15, plus each rule's `DOC_*` |
    | class | `LAW_CLASS` in `js/inspect/inventory.mjs`, one of the six in `LAW_CLASSES` | **none** — a doctrine rule's class *is* its pack, and there is no second taxonomy over it | — |
-   | console copy | a `LAW_META` row in `web/src/pages/Laws.jsx` (keyed by arabic number) | a `DOCTRINE_META` row in the same file (keyed `<pack>.<n>`) | one `DOCTRINE_META` row per rule |
+   | console copy | a `<!-- note: summary: … -->` line under the rule's heading | the same line under each rule's heading | one summary line per rule |
    | registration | the numeral is the registration | the number is the registration | the pack name in `PACK_ORDER`, `js/build/source.mjs` |
-   | renumber risk | none for citations (by id); `LAW_META`/`LAW_CLASS` are number-keyed and doctor-pinned, so append by preference | none for citations; `DOCTRINE_META`, exclusions and hook ledger keys are `<pack>.<n>` — append by preference | none |
+   | renumber risk | none for citations (by id); `LAW_CLASS` is number-keyed and doctor-pinned, so append by preference | none for citations; exclusions and hook ledger keys are `<pack>.<n>` — append by preference | none |
    | counts | README badge + the `N universal laws` prose, `SHIPPED.md`'s triple, the web onboarding copy | **none** — the console spends the `N_PACKS` / `N_PACKS_ACTIVE` / `N_DOCTRINE_RULES` count tokens, all computed at request time | none, same reason |
    | changelog | `CHANGELOG.md` | `CHANGELOG.md` | `CHANGELOG.md` |
 
@@ -163,9 +163,9 @@ vault or a specific tool's hooks.
    synonym. `--sync-themes` writes the template's placeholder and only *prints* which keys
    to restyle; a shipped placeholder passes every gate.
 
-   Almost all of it is gated, across six named checks in `js/inspect/checks-build.mjs` —
-   `themeParityProblems` (key parity across the voices), `lawMetaProblems` and
-   `doctrineMetaProblems` (the console's Principle column, in both directions),
+   Almost all of it is gated, across five named checks in `js/inspect/checks-build.mjs` —
+   `themeParityProblems` (key parity across the voices), `ruleSummaryProblems`
+   (one console summary per rule, none orphaned),
    `constitutionProblems` (rule ids declared, unique and never retired, `LEX_*` as an *equality*,
    the `DOC_*` vocabulary, the hook-gated addresses, and every `{{LAW:…}}`/`{{DOCTRINE:…}}`
    citation in `src/` — a citation by number is refused), and

package/SHIPPED.md

@@ -20,7 +20,7 @@ historical references, not files distributed with the repo.
 > **On version numbers.** [`harness.config.json`](harness.config.json)'s `version` is a
 > human-readable label only. The canonical identity of an installed harness is the
 > **source fingerprint** stamped in `.geneseed-version` (see `geneseed version`), not the
-> string. Current label: **4.18.1**.
+> string. Current label: **4.19.0**.
 
 ## Capabilities
 

package/docs/extending.md

@@ -179,7 +179,7 @@ not.
 
 ### 2a — Adding a DOCTRINE RULE (the common case)
 
-Five files, plus the written-out rule totals in four test files. This is the slot most new
+Four files, plus the written-out rule totals in four test files. This is the slot most new
 material belongs in, and it is cheap on purpose so that the invariant slot stays scarce.
 
 1. `src/doctrines/<pack>.md` — add `### {{DOCTRINE:<new-id>}} <Principle Name>` plus the body,
@@ -188,8 +188,11 @@ material belongs in, and it is cheap on purpose so that the invariant slot stays
    (the style rule is in `src/doctrines/README.md`, and `leanBlockProblems` refuses a rule with no
    block or an empty half). The id is kebab-case, unique across laws **and** doctrines, and never
    one listed in `RETIRED_RULE_IDS` (`js/build/source.mjs`). Where it goes in the file decides its
-   number; appending is still the kind move, because `excludeRules`, `DOCTRINE_META` and the
-   hook-gated addresses are keyed `<pack>.<n>` (see §2e).
+   number; appending is still the kind move, because `excludeRules` and the hook-gated addresses
+   are keyed `<pack>.<n>` (see §2e). On the line directly under the heading, above `LEAN:begin`,
+   add `<!-- note: summary: <one line> -->` — the one-line Principle the console prints under the
+   rule's name. **That copy exists nowhere else**, and `ruleSummaryProblems` refuses a rule with
+   none, two, an empty one or one off its line. Being an author note, it never reaches an emit.
 2. `themes/_TEMPLATE.json` — add `DOC_<ID>` (`consent-before-push` → `DOC_CONSENT_BEFORE_PUSH`).
    ⚠ **This file *is* gated for this key family.**
    `themeFiles()` filters `_`-prefixed names and theme parity never sees the template, but
@@ -206,15 +209,7 @@ material belongs in, and it is cheap on purpose so that the invariant slot stays
    is one of the two. See §7.2 before you copy a command from anywhere else. Then restyle all
    fourteen by hand: `--sync-themes` writes the template's placeholder and only *prints*
    `RESTYLE these`; a shipped placeholder passes every gate.
-4. `web/src/pages/Laws.jsx` — a `DOCTRINE_META` row keyed `'<pack>.<n>'`, whose third field is the
-   rule's id — `doctrineMetaProblems` holds that pin to the canon, so a row left behind by a
-   renumber is a failure rather than a description of the neighbour. Its first field is the
-   **pack**, not one of `LAW_CLASSES`' six; `doctrineMetaProblems` requires an *equality* between
-   that field and the key's own pack, which catches the copy error a six-way vocabulary cannot — a
-   row pasted from the pack above it, keeping the wrong pack. Its second field is the one-line
-   Principle, and **that copy exists nowhere else**; a rule absent here renders with a blank
-   description.
-5. `CHANGELOG.md`, then rebuild and commit `web/dist` (step 4 touched `web/src`).
+4. `CHANGELOG.md`.
 
 **What a doctrine rule does *not* cost**, and each of these is a deliberate asymmetry:
 
@@ -243,7 +238,7 @@ a defect.
 
 ### 2b — Amending an INVARIANT
 
-Steps 1 and 9 of §2c, plus `LAW_META` if the Principle line moved. Two cautions:
+Steps 1 and 8 of §2c, plus the rule's `<!-- note: summary: … -->` line if the Principle moved. Two cautions:
 
 - `--footprint` defaults to **lean**, and a law's lean text is the authored `LEAN:else` half of
   its block in `src/laws/universal.md` (`resolveLean` in `js/build/render.mjs`). Amend **both**
@@ -253,12 +248,14 @@ Steps 1 and 9 of §2c, plus `LAW_META` if the Principle line moved. Two cautions
 
 ### 2c — Adding an INVARIANT
 
-Nine steps, and only the first is the rule itself. This is the expensive one, and it should be:
+Eight steps, and only the first is the rule itself. This is the expensive one, and it should be:
 the bar is in `DESIGN.md` Decision 7, and most candidates belong in a doctrine pack instead.
 
 1. `src/laws/universal.md` — add `### {{LAW:<new-id>}} <Principle Name>` plus the body. Citations
    are by id and resolve against the canon, so position is safe to choose — but append unless the
-   order is the point: `LAW_CLASS` and `LAW_META` are keyed by the rendered number (see §2e).
+   order is the point: `LAW_CLASS` is keyed by the rendered number (see §2e). On the line directly
+   under the heading, add the rule's `<!-- note: summary: <one line> -->`, as in §2a step 1 — the
+   console's one-line Principle, gated by `ruleSummaryProblems`.
 2. `themes/_TEMPLATE.json` — add `LEX_<ID>` in template order. Gated, as in §2a step 2:
    `constitutionProblems` holds the `LEX_*` keys as an **equality** with the declared law ids across
    all fifteen files (the fourteen voices and the template), so both a missing key *and* a leftover
@@ -266,16 +263,12 @@ the bar is in `DESIGN.md` Decision 7, and most candidates belong in a doctrine p
    `LEX_XXIV` and `LEX_XXXVI` behind in every file and parity was silent.
 3. `--sync-themes`, then restyle all fourteen by hand (§2a step 3).
 4. `LAW_CLASS` in `js/inspect/inventory.mjs` — one of the six in `LAW_CLASSES` beside it.
-5. `LAW_META` in `web/src/pages/Laws.jsx` — same class, the one-line Principle, and the rule's id
-   as the pin. Note the map is keyed by **arabic** number where the heading renders a Roman numeral. **This copy
-   exists nowhere else**; a rule absent here renders with a blank description. It is why that one
-   React file ships alone out of `web/src` in `package.json` — `doctor` regex-parses its literal.
-6. `README.md` — badge `badge/laws-N` and the `N universal laws` sentence.
-7. `SHIPPED.md` — the `N laws, N agents, N skills` triple.
-8. `tests/unit/harness.test.mjs` — the negative fixture for the `LAW_CLASS` gate appends a law and
-   expects the next numeral (`X` while there are nine), and `ROMANS` there and in `emit_smoke`
-   lists the numerals written out. Bump both.
-9. `CHANGELOG.md`, then rebuild and commit `web/dist` (step 5 touched `web/src`).
+5. `README.md` — badge `badge/laws-N` and the `N universal laws` sentence.
+6. `SHIPPED.md` — the `N laws, N agents, N skills` triple.
+7. `tests/unit/harness.test.mjs` — the negative fixture for the `LAW_CLASS` gate appends a law and
+   expects the next numeral (`X` while there are nine), and `ROMANS` in `emit_smoke` lists the
+   numerals written out. Bump both.
+8. `CHANGELOG.md`.
 
 ⚠ While restyling, `{{LAW}}` must stay a **single word** in every theme (and so must
 `{{DOCTRINE}}`). Both heading parsers match the tier noun with `\S+`, so a two-word value does not
@@ -341,8 +334,7 @@ render — no citation moves, because none names a number. Then:
    carries the text.
 3. Its `LEX_<ID>`/`DOC_<ID>` key in all fifteen theme files (the equality arm names each).
 4. The number-keyed tables, which the doctor checks against the canon: `LAW_CLASS`
-   (`js/inspect/inventory.mjs`), `LAW_META`/`DOCTRINE_META` (their id pins fail on every shifted
-   row), and — only if a hook-gated rule moved — `HOOK_PINNED` in `checks-constitution.mjs` names the
+   (`js/inspect/inventory.mjs`), and — only if a hook-gated rule moved — `HOOK_PINNED` in `checks-constitution.mjs` names the
    ledger keys, `CONSENT_RULE` and `HOOK_GATED` to move with it. `--exclude-rules` addresses are
    `<pack>.<n>` too, and an install that excluded a shifted doctrine rule excludes its neighbour
    after a re-emit: prefer appending in a pack, and say so in the CHANGELOG when you cannot.
@@ -422,8 +414,8 @@ Two traps worth knowing before you write the spec:
   re-opens bash on all three hosts (OpenCode gates it to `ask`), and `<!-- webfetch: allow -->`
   re-opens web fetch — the researcher is the one spec that carries it.
 - **The console has a fourth, ungated copy of the skill taxonomy.** `SKILL_CATS` in
-  `web/src/lib/lawCats.js` mirrors `SKILL_CLASS` with nothing comparing them (contrast
-  `LAW_META`, which *is* cross-checked). Inventing a new *category* means editing that file —
+  `web/src/lib/lawCats.js` mirrors `SKILL_CLASS` with nothing comparing them (contrast the
+  rules' classes, which the server sends from `LAW_CLASS`). Inventing a new *category* means editing that file —
   which drags in the `web/dist` rebuild — and an unknown category lands under Personal in the
   Library (`splitSkills` in `web/src/pages/Library.jsx`) with no warning.
 
@@ -769,7 +761,7 @@ only, at best, on its presence.
 | What | Where | Gated on |
 |---|---|---|
 | `§N` cross-references into `AGENT.md`'s anatomy | `src/skills/*`, `src/agents/*`, `adapters/**` | **range only.** `constitutionProblems` refuses a `§N` the template declares no section for — which catches a pointer past the end, the shape *removing* a section leaves. It cannot catch one that still resolves and now means something else, which is the shape *inserting* a section leaves, and is what actually happened when `## 2. Doctrines` pushed every later section down one. **Renumbering the anatomy means `grep -rn '§' src/ adapters/` and reading every hit.** Four satellites and a live OpenCode deny message shipped stale because the sweep stopped at `AGENT.md.tmpl` |
-| Per-law Principle lines | `web/src/pages/Laws.jsx` | presence and class only, never accuracy |
+| Per-rule Principle lines | the `<!-- note: summary: … -->` line under each rule heading in `src/laws/universal.md` and `src/doctrines/*.md` | presence and placement only (`ruleSummaryProblems`), never accuracy |
 | 588 themed constitution titles (42 keys × 14 voices) — `LEX_<ID>` (one per law), `DOC_<ID>` (one per doctrine rule), `PACK_<NAME>` | `themes/*.json` | key presence only — a shipped placeholder is green. `LEX_*` and `DOC_*` are held across the template too, and in both directions; `PACK_*` only across the voices |
 | The README keyword enumerations | `README.md`, `docs/concepts/rules.md` | nothing |
 | The per-host map of what lands on a machine | `docs/understand/machine-opencode.md`, `docs/understand/machine-claude.md` | table shape only, never accuracy |

package/docs/web-ui.md

@@ -101,7 +101,7 @@ streams the output of background jobs and keeps their history across reloads.
 
 - **Rules** (`#/rules`) — your own standing rules, read from and written to the
   `user-rules.md` beside the deployed AGENT.md (the seed-once file no update ever
-  touches). List with scope (user/project, or any other scope written by hand, which a
+  touches). List with scope (project/user/global, or any other scope written by hand, which a
   save keeps as written) and trial chips, add/edit/retire forms (a body line starting
   `## ` is refused: the file would read it as a new rule heading), a
   **Graduate** action that adopts a trial rule for good, and a budget meter that turns

package/harness.config.json

@@ -2,5 +2,5 @@
   "_comment": "version is a human-readable release label only; the canonical identity of an installed harness is the source fingerprint stamped in .geneseed-version (see `harness version`), not this string.",
   "theme": "neutral",
   "product": "Geneseed",
-  "version": "4.18.1"
+  "version": "4.19.0"
 }

package/js/README.md

@@ -125,7 +125,7 @@ Everything that inspects an already-built or already-deployed harness and report
 | `checks-repo.mjs` | Gates over the repo's own records: `registry.json`, committed secrets, the hook shim, vendored pins and folder skills, skill aliases and side files, this module map, the host tables, the scorecard ratchet |
 | `checks-authoring.mjs` | `authoringProblems`, the aggregate self-consistency gate: spec purpose lines, the learn-prompt literal, `node --check` over the plugins (the doctor's one default spawn), then the groups below |
 | `checks-probe.mjs` | `doctor --probe` (opt-in): runs each live install's own gate command through the host's shell on a must-refuse and a must-pass payload — the doctor's second spawn; the OpenCode guard plugin is imported and called in-process instead, through both plugin APIs |
-| `checks-constitution.mjs` | The constitution: rule declarations and citations, LEAN blocks, `HOOK_PINNED`, theme vocabulary, the console's `LAW_META`/`DOCTRINE_META` |
+| `checks-constitution.mjs` | The constitution: rule declarations and citations, LEAN blocks, `HOOK_PINNED`, theme vocabulary, the per-rule summaries (`ruleSummaryProblems`) |
 | `checks-counts.mjs` | The hand-written counts: AGENT.md tables, README badges and prose, `SHIPPED.md`, held against `src/` |
 | `scan.mjs` | The shared walk/sort/strip/test primitives every `checks-*` uses. Owns no judgement itself |
 | `validate.mjs` | The `validate` verb (the generator's old `--validate-only`): renders a sandbox, scans it for tokens and dead links, own exit contract |

package/js/build/source.mjs

@@ -145,6 +145,33 @@ export function ruleCanon(src = SRC) {
   return canon;
 }
 
+/**
+ * RULE SUMMARIES — the one-line Principle the web console prints under each rule's name. It lives
+ * on the line directly under the rule's heading as `<!-- note: summary: <text> -->`, so the copy
+ * sits beside the rule it describes and moves with it; being an author note, `stripAuthorNotes`
+ * removes the whole line before any render, and no emit carries it. Read from the RAW text, apart
+ * from `ruleCanon`, so the render path pays nothing for it. `ruleSummaryProblems`
+ * (`js/inspect/checks-constitution.mjs`) is the gate: one summary per rule, in that place.
+ */
+export const SUMMARY_LINE_RE = /^<!--[ \t]*note:[ \t]*summary:[ \t]*(.*?)[ \t]*-->[ \t]*$/;
+/** Anything that LOOKS like a summary — the gate's net, wider than `SUMMARY_LINE_RE` on purpose. */
+export const SUMMARY_MARK_RE = /<!--[ \t]*note:[ \t]*summary:/;
+export function ruleSummaries(src = SRC) {
+  const out = new Map();
+  for (const [kind, , file] of canonFiles(src)) {
+    let text;
+    try { text = readRawText(file); } catch { continue; }
+    for (const m of text.matchAll(DECL_RE)) {
+      if (m[1] !== kind) continue;
+      const start = m.index + m[0].length + 1;
+      const end = text.indexOf('\n', start);
+      const s = SUMMARY_LINE_RE.exec(text.slice(start, end === -1 ? undefined : end));
+      if (s && !out.has(m[2])) out.set(m[2], s[1]);
+    }
+  }
+  return out;
+}
+
 /**
  * AUTHOR NOTES — `<!-- note: ... -->`, single or multi-line, is maintainer-only prose and must
  * never reach an agent (user decision 2026-10-11). Stripped here because `resolveRuleIds` is the

package/js/inspect/checks-authoring.mjs

@@ -113,7 +113,7 @@ export function authorNoteProblems(src = SRC) {
 // 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,
+  HOOK_PINNED, constitutionProblems, leanBlockProblems, ruleSummaryProblems,
 } from './checks-constitution.mjs';
 export { countTableProblems, kitProblems, proseMirrorProblems } from './checks-counts.mjs';
 

package/js/inspect/checks-constitution.mjs

@@ -1,7 +1,7 @@
 /**
  * The CONSTITUTION gates — whether the laws and doctrine packs agree with themselves and with
  * everything keyed off them: rule declarations and citations, the LEAN blocks, the hook-pinned
- * addresses, the theme vocabulary, and the web console's per-rule Principle copy.
+ * addresses, the theme vocabulary, and the per-rule summary the web console prints.
  *
  * Split out of `checks-authoring.mjs`, which still aggregates these (and re-exports them for
  * its existing importers). Same contract as every check module here: an array of problem
@@ -9,7 +9,8 @@
  */
 import path from 'node:path';
 import {
-  CONFIG, PACK_ORDER, RETIRED_RULE_IDS, ROOT, RULE_ID_RE, SRC, THEMES, canonFiles, ruleCanon, titleKey,
+  CONFIG, PACK_ORDER, RETIRED_RULE_IDS, RULE_ID_RE, SRC, SUMMARY_LINE_RE, SUMMARY_MARK_RE, THEMES, canonFiles, ruleCanon,
+  titleKey, toRoman,
 } from '../build/source.mjs';
 import { LEAN_BLOCK_RE, splitAtLawHeadings } from '../build/render.mjs';
 import { themeFiles } from '../hosts/installs.mjs';
@@ -18,138 +19,68 @@ import { parseJson, formatRepr } from '../lib/json.mjs';
 import { NOTE, isFile, rglob } from './scan.mjs';
 
 /**
- * The body of `const <name> = { … }` in the web Laws page — the one file out of `web/src` the
- * doctor reads. Answers `[body, null]`, or `[null, problem]` when the page is unreadable or the
- * literal is gone (`missing` is that problem's text).
- */
-function lawsPageLiteral(name, missing) {
-  let text;
-  try { text = readText(path.join(ROOT, 'web', 'src', 'pages', 'Laws.jsx')); } catch (e) {
-    return [null, `[authoring] web/src/pages/Laws.jsx unreadable: ${e.message}`];
-  }
-  const block = new RegExp(`^const ${name} = \\{$([\\s\\S]*?)^\\}$`, 'm').exec(text);
-  return block ? [block[1], null] : [null, missing];
-}
-
-/**
- * `_harness_build._LAW_META_ROW` — `<arabic>: ['<class>', '<principle>', '<id>'],` in the web page.
+ * Every rule carries exactly one one-line summary, on the line directly under its heading —
+ * `<!-- note: summary: <text> -->` — the Principle the web console prints under the rule's name.
  *
- * 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.
+ * The copy exists nowhere else, and a rule without it renders with a blank description while
+ * every count upstream reads correct: two laws shipped exactly that way when the copy lived in a
+ * table in `web/src/pages/Laws.jsx`. Beside the heading, a removed or reordered rule takes its
+ * summary with it, so no positional key or id pin is left to drift.
  *
- * 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.
+ * PLACEMENT IS PART OF THE CONTRACT because `ruleSummaries` (`js/build/source.mjs`) reads only
+ * the line under the heading: a summary one line lower is stripped from every render all the
+ * same, and the console would show nothing. A summary above the first rule, or under any heading
+ * that declares no rule, describes no rule at all.
  *
- * `(?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.
+ * ONE DEFINITION OF A SUMMARY LINE: `SUMMARY_LINE_RE`, the reader's own, applied to the line as
+ * written. A line `SUMMARY_MARK_RE` catches but that regex refuses — indented, or wrapped over two
+ * lines — is malformed here, because the reader would hand the console nothing for it.
  */
-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(lawRules, lawClass, lawClasses) {
-  const [block, refusal] = lawsPageLiteral('LAW_META', '[authoring] LAW_META literal not found '
-    + "in web/src/pages/Laws.jsx — the web Laws ledger's Principle column would have no gate");
-  if (refusal) return [refusal];
-  const meta = new Map();
-  for (const m of block.matchAll(LAW_META_ROW)) {
-    meta.set(Number(m[1]), [m[3], m[5], m[7]]);
-  }
+export function ruleSummaryProblems(src = SRC) {
   const problems = [];
-  const seen = new Set();
-  for (const { n, label: roman, id } of lawRules) {
-    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 (pin !== id) {
-      problems.push(`[authoring] LAW_META[${n}] is pinned to '${pin ?? '(no id)'}' but rule ${roman} is `
-        + `'${id}' — 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 [block, refusal] = lawsPageLiteral('DOCTRINE_META', '[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');
-  if (refusal) return [refusal];
-  const meta = new Map();
-  for (const m of block.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`);
+  for (const [kind, pack, file] of canonFiles(src)) {
+    const rel = path.relative(src, file).split(path.sep).join('/');
+    let lines;
+    try { lines = readText(file).replace(/\r\n?/g, '\n').split('\n'); } catch { continue; }  // constitutionProblems names it
+    const rules = [];
+    let current = null;
+    lines.forEach((line, i) => {
+      if (/^#{1,6} /.test(line)) {
+        const m = line.startsWith('### ') ? DECL_LINE_RE.exec(line) : null;
+        const id = m && m[1] === kind ? m[2] : null;
+        current = id ? { id, at: i, found: [] } : null;
+        if (current) rules.push(current);
+        return;
+      }
+      if (!SUMMARY_MARK_RE.test(line)) return;
+      if (current) current.found.push([i, SUMMARY_LINE_RE.exec(line)?.[1] ?? null]);
+      else {
+        problems.push(`[authoring] ${rel}: a summary line sits outside any rule declaration — it `
+          + 'describes no rule');
+      }
+    });
+    rules.forEach(({ id, at, found }, k) => {
+      const where = `[authoring] ${rel}: rule ${kind === 'LAW' ? toRoman(k + 1) : `${pack} ${k + 1}`} '${id}'`;
+      if (!found.length) {
+        problems.push(`${where} has no summary — the console would render it with a blank `
+          + "Principle; add '<!-- note: summary: <one line> -->' on the line directly under its heading");
+        return;
+      }
+      if (found.length > 1) {
+        problems.push(`${where} has ${found.length} summary lines — the console shows one; keep `
+          + 'exactly one');
+      }
+      if (found[0][0] !== at + 1) {
+        problems.push(`${where} summary is not directly under its heading — ruleSummaries reads `
+          + 'only that line, so the console would show none');
+      }
+      if (found[0][1] === null) {
+        problems.push(`${where} has a malformed summary line — it must be one unindented line, `
+          + "'<!-- note: summary: <text> -->', the only shape ruleSummaries reads");
+      } else if (!found[0][1].trim()) {
+        problems.push(`${where} has an empty summary — the console would render a blank Principle`);
+      }
+    });
   }
   return problems;
 }
@@ -242,8 +173,8 @@ export function leanBlockProblems() {
 }
 
 /**
- * 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.
+ * The three-tier constitution's own authoring gates — the doctrine twin of the `LAW_CLASS`
+ * family, the per-rule summaries, 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
@@ -328,10 +259,10 @@ export function constitutionProblems() {
     }
   }
 
-  // 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)));
+  // The console's Principle column, read off the same files — so a rule added to the canon
+  // without its summary is caught the same day, not when someone notices a blank description
+  // in the browser.
+  problems.push(...ruleSummaryProblems());
 
   // ---- every citation in src/ is by id, and every id resolves.
   //

package/js/inspect/checks-counts.mjs

@@ -14,7 +14,6 @@ import { effectiveTheme, renderFile } from '../build/render.mjs';
 import { themeFiles } from '../hosts/installs.mjs';
 import { readText } from '../lib/fs.mjs';
 import { formatRepr } from '../lib/json.mjs';
-import { lawMetaProblems } from './checks-constitution.mjs';
 import { LAW_CLASS, LAW_CLASSES, SKILL_CLASS } from './inventory.mjs';
 import { globSorted, has, isDir, isFile, srcStems } from './scan.mjs';
 import { existsSync, readdirSync } from 'node:fs';
@@ -183,11 +182,10 @@ export function countTableProblems() {
     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.
+  // The numerals the laws RENDER with — positional, off the canon — because LAW_CLASS is keyed
+  // the way the rendered catalogue numbers them.
   const canonRules = ruleCanon(SRC).rules;
-  const lawRules = canonRules.filter((r) => r.kind === 'LAW');
-  const lawNums = lawRules.map((r) => r.label);
+  const lawNums = canonRules.filter((r) => r.kind === 'LAW').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`);
@@ -200,7 +198,6 @@ export function countTableProblems() {
         + `class ${formatRepr(LAW_CLASSES)}`);
     }
   }
-  problems.push(...lawMetaProblems(lawRules, LAW_CLASS, LAW_CLASSES));
 
   // 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

package/js/web/catalog.mjs

@@ -24,7 +24,7 @@ import { readText, withDiscardableStderr, isDir, isFile } from '../lib/fs.mjs';
 import { comparePaths, normcase, within } from '../lib/paths.mjs';
 import { stripWhitespace } from '../lib/text.mjs';
 import { readJsonc } from '../hosts/settings.mjs';
-import { loadKits, makeCfg } from '../build/source.mjs';
+import { SRC, loadKits, makeCfg, ruleCanon, ruleSummaries } from '../build/source.mjs';
 import { loadTheme } from '../build/render.mjs';
 
 /** A requested catalog section or item that does not exist. */
@@ -427,8 +427,7 @@ function configManifest(name, p) {
  *
  * ⚠ `laws` STAYS ONE SECTION FOR ALL THREE TIERS, and that is a decision rather than an
  * oversight. The console has ONE Constitution entry, not three, so a reader keeps the "read it
- * top to bottom" property; the id stays `laws` because `tests/helpers/cli_golden.mjs`
- * hard-requires `web/src/pages/Laws.jsx` and because a route rename buys nothing and costs a
+ * top to bottom" property; the id stays `laws` because a route rename buys nothing and costs a
  * redirect. The tier lives on the ITEM (`tier: 'ontology' | 'invariant' | 'doctrine'`), which
  * is where a consumer can act on it.
  */
@@ -445,17 +444,25 @@ export const SECTIONS = ['agents', 'skills', 'laws', 'memory', 'notebook', 'wiki
  * Names are ADDRESSES and the three shapes cannot collide: `ont:<slug>` carries a colon no
  * numeral has, an invariant is `[IVXLCDM]+`, a doctrine rule is `<pack>.<n>`. `apiItem`
  * resolves all three off the same list.
+ *
+ * `summary` is the rule's one-line Principle, read from this checkout's `src/` and joined by the
+ * address the canon renders now (`ruleSummaries`, `js/build/source.mjs`). `desc` stays empty:
+ * the search index reads `desc`, and the summary is display copy, not a description to match.
  */
 function constitutionItems(inv) {
+  const said = ruleSummaries(SRC);
+  const summary = new Map(ruleCanon(SRC).rules.map((r) => [
+    r.kind === 'LAW' ? r.label : `${r.pack}.${r.n}`, said.get(r.id) ?? '']));
   return [
     ...(inv.ontology ?? []).map((e) => ({ name: `ont:${e.id}`, title: e.title, desc: '',
       tier: 'ontology' })),
     ...inv.laws.map((e) => ({ name: e.num, title: `Rule ${e.num} — ${e.title}`, desc: '',
-      klass: e.klass ?? 'craft', tier: 'invariant' })),
+      summary: summary.get(e.num) ?? '', klass: e.klass ?? 'craft', tier: 'invariant' })),
     ...(inv.doctrines ?? []).flatMap((p) => p.rules.map((r) => ({
       name: `${r.pack}.${r.n}`,
       title: `Doctrine ${r.pack} ${r.n} — ${r.title}`,
       desc: '',
+      summary: summary.get(`${r.pack}.${r.n}`) ?? '',
       klass: r.klass ?? p.pack,
       tier: 'doctrine',
       pack: p.pack,

package/js/web/user-files.mjs

@@ -195,7 +195,7 @@ function ruleBlock(rid, title, scope, source, trialUntil, body) {
  *
  * REFUSED, NEVER REWRITTEN: a body line that `isRuleEdge` reads would truncate this rule and
  * could forge another rule's id, and a `|` in the scope or source would forge a metadata field. An
- * unknown scope (`global`, written by hand) is kept as written — coercing it to `project` made
+ * unknown scope (one written by hand, such as `team`) is kept as written — coercing it to `project` made
  * every Edit or Graduate silently change the user's rule.
  */
 function ruleFields(body) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "Every field here is argued and gated in tests/unit/package_manifest.test.mjs. `files`, `bin` and `engines` each have a test that fails when reality drifts from this file; `version` mirrors harness.config.json and is gated too. Read that docblock before editing this one.",
   "name": "geneseed",
-  "version": "4.18.1",
+  "version": "4.19.0",
   "description": "A portable, theme-able harness you implant once and use everywhere to grow a disciplined AI coding agent.",
   "keywords": [
     "ai",
@@ -44,7 +44,6 @@
     "docs/concepts/",
     "docs/reference/",
     "web/dist/",
-    "web/src/pages/Laws.jsx",
     "harness.config.json",
     "registry.json",
     "geneseed",