geneseed 3.1.0 → 3.1.2

package/web/src/pages/Laws.jsx

@@ -15,7 +15,7 @@ import ErrorState from '../components/ErrorState.jsx'
 //
 // ⚠ SIX, THOUGH ONLY FOUR HAVE A MEMBER. `context` and `comms` lost theirs when the corpus became
 // nine invariants — that material moved to the ontology and the doctrine packs, neither of which
-// is classed here. The list stays six because it is the VOCABULARY that js/inventory.mjs's
+// is classed here. The list stays six because it is the VOCABULARY that js/inspect/inventory.mjs's
 // LAW_CLASSES publishes and doctor quotes verbatim; the PAGE renders only non-empty facets, which
 // is a display decision and not a change to the taxonomy.
 const LAW_CATS = {
@@ -126,13 +126,56 @@ function ruleName(rawTitle, romanNum, arabicNum) {
 // One expandable row, shared by the invariant and doctrine bands: lazy-loads its full body via
 // /api/item/law/<address> the first time it opens, cached on subsequent toggles. The address is
 // the catalog's `name` — a Roman numeral or `<pack>.<n>` — never the display number.
-function LawRow({ law, isOpen, onToggle }) {
+function LawRow({ law, isOpen, onToggle, toggleCol = null }) {
   const { data: detail } = useAsync(
     () => (isOpen ? api.item('law', law.addr) : Promise.resolve(null)),
     [isOpen, law.addr],
   )
   const body = detail?.body || law.ess
-  return (
+  const expandRow = (
+    <>
+      {isOpen && (
+        <div className="law-expand">
+          {detail ? (
+            <p>
+              <LawText text={body} />
+            </p>
+          ) : (
+            <p className="dim">Loading…</p>
+          )}
+          <div className="law-srcline">
+            $ geneseed law {law.addr} · {law.src}
+          </div>
+        </div>
+      )}
+    </>
+  )
+  // Doctrine rows expose two separate actions: the first four columns are one disclosure
+  // button, while the fifth is the selection switch. Keeping them as siblings means a switch
+  // click changes only the staged selection, never the open rule.
+  return toggleCol ? (
+    <>
+      <div
+        className={`law-row has-toggle ${isOpen ? 'on' : ''} ${law.off ? 'law-off' : ''}`}
+        style={{ '--cc': law.c }}
+      >
+        <button className="law-disclosure" onClick={onToggle} aria-expanded={isOpen}>
+          <span className="law-no">
+            <span className="x">›</span>
+            {law.pad}
+          </span>
+          <span className="law-name">{law.name}</span>
+          <span className="law-princ">{law.ess}</span>
+          <span className="law-class">
+            <span className="cdot" />
+            {law.catLabel}
+          </span>
+        </button>
+        <span className="toggle-col">{toggleCol}</span>
+      </div>
+      {expandRow}
+    </>
+  ) : (
     <>
       <button
         className={`law-row ${isOpen ? 'on' : ''} ${law.off ? 'law-off' : ''}`}
@@ -151,20 +194,7 @@ function LawRow({ law, isOpen, onToggle }) {
           {law.catLabel}
         </span>
       </button>
-      {isOpen && (
-        <div className="law-expand">
-          {detail ? (
-            <p>
-              <LawText text={body} />
-            </p>
-          ) : (
-            <p className="dim">Loading…</p>
-          )}
-          <div className="law-srcline">
-            $ geneseed law {law.addr} · {law.src}
-          </div>
-        </div>
-      )}
+      {expandRow}
     </>
   )
 }
@@ -222,13 +252,14 @@ export default function Laws({ selected, overview, onAction }) {
   // throws, taking the whole page down rather than just the control. Hence the defensive
   // `data?.items` here and the plain (non-hook) helpers further down.
   const allItems = data?.items || []
-  // Insertion order is PACK_ORDER — the server sends the roster in it — and the Set keeps it.
-  const deployedPacks = [
-    ...new Set(
-      allItems.filter((i) => i.tier === 'doctrine' && i.active !== false).map((i) => i.pack),
-    ),
-  ]
-  const deployedKey = deployedPacks.join(',')
+  // ⚠ THE UNIT IS THE RULE, not the pack. The selection below is a list of rule ADDRESSES
+  // (`process.7`), and the pack axis is DERIVED from it when Apply builds the request — a
+  // pack with every rule off drops out of `--doctrines` entirely, so the rendered AGENT.md
+  // never carries a pack header with nothing under it.
+  const deployedRules = allItems
+    .filter((i) => i.tier === 'doctrine' && i.active !== false)
+    .map((i) => i.name)
+  const deployedKey = deployedRules.join(',')
   const [picked, setPicked] = useState([])
   // Re-sync on the VALUE, never on the payload's identity: `data` is a fresh object on every
   // refetch, so an identity dependency would discard a half-made selection.
@@ -282,7 +313,10 @@ export default function Laws({ selected, overview, onAction }) {
         pack: it.pack,
         title: it.packTitle || it.pack,
         desc: it.packDesc || '',
-        active: it.active !== false,
+        // ⚠ `packActive`, NOT the first rule's `active`. A pack is on when the install built
+        // it in AT ALL; with the per-rule axis its first rule can be the excluded one, and
+        // reading the pack's state off it would report a live pack as dropped.
+        active: it.packActive !== false,
         rules: [],
       }
       packs.push(pack)
@@ -300,7 +334,9 @@ export default function Laws({ selected, overview, onAction }) {
     })
   }
   const activePacks = packs.filter((p) => p.active)
-  const ruleCount = activePacks.reduce((n, p) => n + p.rules.length, 0)
+  // Rule by rule, not pack by pack: an active pack can carry an excluded rule, and this
+  // readout claims to say how many rules bind the install.
+  const ruleCount = packs.reduce((n, p) => n + p.rules.filter((r) => !r.off).length, 0)
 
   // ---- the pack selection: STAGED here, applied once -------------------------------------
   //
@@ -314,32 +350,62 @@ export default function Laws({ selected, overview, onAction }) {
   // them describing a state nobody asked for, each writing a different `Active packs:` marker
   // for the next reader to parse. So the switches edit local state and `Apply` sends the whole
   // selection. The state itself lives above the early returns — see the ⚠ there.
-  const isOn = (name) => picked.includes(name)
-  const togglePack = (name) =>
-    setPicked((cur) => (cur.includes(name) ? cur.filter((p) => p !== name) : [...cur, name]))
-  const pickedPacks = packs.filter((p) => isOn(p.pack)).map((p) => p.pack)
-  const dirty = pickedPacks.join(',') !== deployedKey
-  const losingConsent = deployedPacks.includes('process') && !picked.includes('process')
+  const isOn = (addr) => picked.includes(addr)
+  const toggleRule = (addr) =>
+    setPicked((cur) => (cur.includes(addr) ? cur.filter((a) => a !== addr) : [...cur, addr]))
+  // A pack is never picked directly — it is on when any of its rules is. One source, so the
+  // header and the switches under it cannot disagree.
+  const packOn = (p) => p.rules.some((r) => isOn(r.addr))
+  // ⚠ A STAGED PACK MUST NOT READ AS A DEPLOYED ONE. `p.active` is what the install built;
+  // `packOn(p)` is what the switches currently say. Where they differ the header says so —
+  // reporting the staged state as fact is the one lie a control like this can tell.
+  const packState = (p) => {
+    const on = p.rules.filter((r) => isOn(r.addr)).length
+    if (!on) return p.active ? 'staged off' : 'not built in'
+    if (!p.active) return `staged on · ${on} of ${p.rules.length}`
+    return `${on} of ${p.rules.length} active`
+  }
+  // What the install excludes today: a rule that is off inside a pack it still builds in.
+  // A rule whose whole pack is absent is not an exclusion — the pack's absence says it, and
+  // naming it beside a `--doctrines` that omits the pack would be noise the CLI rejects.
+  const deployedExcluded = packs
+    .filter((p) => p.active)
+    .flatMap((p) => p.rules.filter((r) => r.off).map((r) => r.addr))
+  const allRules = packs.flatMap((p) => p.rules.map((r) => r.addr))
+  const pickedRules = allRules.filter(isOn)
+  const dirty = pickedRules.join(',') !== deployedKey
+  const CONSENT = 'process.5'
+  const losingConsent = deployedRules.includes(CONSENT) && !picked.includes(CONSENT)
   // Nothing to rebuild means nothing to toggle — a source render with no deployed install
   // still READS, it just cannot be changed from here.
   const install = overview?.install
   const canApply = Boolean(install && onAction)
 
+  // ⚠ TWO AXES OUT OF ONE SELECTION. The user only ever touches rules; the request carries
+  // both `doctrines` (the packs with at least one rule left) and `excludeRules` (the rules
+  // dropped from the packs that survive). An exclusion naming a pack that is already absent
+  // would be noise, so it is not sent — the pack's absence already says it.
   const applyPacks = () => {
     if (!canApply || !dirty) return
+    const keptPacks = packs.filter((p) => p.rules.some((r) => isOn(r.addr))).map((p) => p.pack)
+    const excludeRules = packs
+      .filter((p) => keptPacks.includes(p.pack))
+      .flatMap((p) => p.rules.filter((r) => !isOn(r.addr)).map((r) => r.addr))
     const warn = losingConsent
-      ? '\n\n⚠ The process pack carries commit/push consent. Dropping it also removes the ' +
-        'git-gate hook, so commits and pushes stop being confirmed at the tool boundary. ' +
+      ? '\n\n⚠ process 5 carries commit/push consent. Dropping it also removes the git-gate ' +
+        'hook, so commits and pushes stop being confirmed at the tool boundary. ' +
         '(rm -rf and force-push stay gated — those are Rule IV’s, not the pack’s.)'
       : ''
+    const what = pickedRules.length
+      ? `${pickedRules.length} of ${allRules.length} doctrine rules`
+      : 'no doctrine rules'
     if (
       window.confirm(
-        `Rebuild ${install.host} · ${install.scope} with ${
-          pickedPacks.length ? pickedPacks.join(', ') : 'no doctrine packs'
-        }? It rebuilds in place, non-destructive.${warn}`,
+        `Rebuild ${install.host} · ${install.scope} with ${what}? ` +
+          `It rebuilds in place, non-destructive.${warn}`,
       )
     )
-      onAction('install', { ...install, doctrines: pickedPacks })
+      onAction('install', { ...install, doctrines: keptPacks, excludeRules })
   }
 
   const counts = {}
@@ -443,41 +509,18 @@ export default function Laws({ selected, overview, onAction }) {
       </div>
       {packs.map((p) => (
         <div
-          className={`card law-wrap mb-16 pack-wrap ${isOn(p.pack) ? '' : 'pack-off'}`}
+          className={`card law-wrap mb-16 pack-wrap ${packOn(p) ? '' : 'pack-off'}`}
           key={p.pack}
         >
           <div className="pack-head">
-            {canApply && (
-              <span
-                className={`sw-toggle${isOn(p.pack) ? ' on' : ''}`}
-                role="switch"
-                aria-checked={isOn(p.pack)}
-                aria-label={`${p.title} pack`}
-                tabIndex={0}
-                onClick={() => togglePack(p.pack)}
-                onKeyDown={(e) => {
-                  if (e.key === 'Enter' || e.key === ' ') {
-                    if (e.key === ' ') e.preventDefault()
-                    togglePack(p.pack)
-                  }
-                }}
-              />
-            )}
             <span className="pack-name" style={{ '--cc': PACK_CATS[p.pack] }}>
               <span className="cdot" />
               {p.title}
             </span>
             <span className="pack-desc">{p.desc}</span>
-            <span className="pack-state">
-              {p.rules.length} rules ·{' '}
-              {isOn(p.pack) === p.active
-                ? p.active
-                  ? 'active'
-                  : 'not built in'
-                : isOn(p.pack)
-                  ? 'staged on'
-                  : 'staged off'}
-            </span>
+            {/* Derived from the rules, never held separately — a pack IS however many of its
+                rules are on, and a second source could disagree with the switches above it. */}
+            <span className="pack-state">{packState(p)}</span>
           </div>
           {!p.active && !canApply && (
             // The fallback for a console with no install to rebuild — a reader still needs the
@@ -485,7 +528,12 @@ export default function Laws({ selected, overview, onAction }) {
             // ⚠ `geneseed-build`, not `geneseed build`: the CLI's `build` verb forwards
             // `--theme` and nothing else, so the shorter spelling errors.
             <div className="pack-enable">
-              $ geneseed-build --doctrines {[...deployedPacks, p.pack].join(',')}
+              $ geneseed-build --doctrines{' '}
+              {packs
+                .filter((q) => q.active || q.pack === p.pack)
+                .map((q) => q.pack)
+                .join(',')}
+              {deployedExcluded.length > 0 && ` --exclude-rules ${deployedExcluded.join(',')}`}
             </div>
           )}
           <div className="law-rowhead">
@@ -493,9 +541,27 @@ export default function Laws({ selected, overview, onAction }) {
             <span>Rule</span>
             <span>Principle</span>
             <span>Pack</span>
+            <span className="toggle-col">Toggle</span>
           </div>
           {p.rules.map((r) => (
-            <LawRow key={r.addr} law={r} isOpen={open === r.addr} onToggle={() => toggle(r.addr)} />
+            <LawRow
+              key={r.addr}
+              law={{ ...r, off: !isOn(r.addr) }}
+              isOpen={open === r.addr}
+              onToggle={() => toggle(r.addr)}
+              toggleCol={
+                canApply ? (
+                  <button
+                    type="button"
+                    className={`sw-toggle${isOn(r.addr) ? ' on' : ''}`}
+                    role="switch"
+                    aria-checked={isOn(r.addr)}
+                    aria-label={`${r.name} rule`}
+                    onClick={() => toggleRule(r.addr)}
+                  />
+                ) : null
+              }
+            />
           ))}
         </div>
       ))}
@@ -503,14 +569,14 @@ export default function Laws({ selected, overview, onAction }) {
         <div className="card pad-lg mb-16">
           {losingConsent && (
             <p className="pack-warn" role="status" aria-live="polite">
-              ⚠ Dropping <b>process</b> also removes the commit/push consent gate —{' '}
+              ⚠ Dropping <b>process 5</b> also removes the commit/push consent gate —{' '}
               <code>git commit</code> and <code>git push</code> stop being confirmed at the tool
               boundary. <code>rm -rf</code> and force-push stay gated.
             </p>
           )}
           <div className="pack-apply">
             <button className="btn soft" onClick={applyPacks} disabled={!dirty}>
-              Apply{dirty ? ` (${pickedPacks.length}/${packs.length} packs)` : ''}
+              Apply{dirty ? ` (${pickedRules.length}/${allRules.length} rules)` : ''}
             </button>
             <button
               className="btn ghost"

package/docs/declined.md

@@ -1,200 +0,0 @@
-# Declined divergences
-
-Places where this CLI deliberately does **not** reproduce the Python reference it was ported
-from, with the reason written down. A divergence that is not on this page is a bug; one that is,
-is a decision.
-
-The reference has been deleted, so "the reference does X" is no longer an argument anyone can
-re-run. What is recorded in `tests/__snapshots__/` is the reference's answer, frozen; what is
-listed here is where this implementation answers differently on purpose.
-
-**The recording is smaller than it was.** On **2026-08-17** the emit, cli and web corpora were
-retired — 1381 cells, produced by an implementation that no longer exists and re-recordable by
-nothing, so they reddened on every deliberate content change while saying nothing about a defect
-that happened to be stable. What licensed it was a measurement: all five mutations whose only
-declared gate was a corpus replay are killed by `tests/unit/` alone. `docs/limits.md` carries the
-full argument and what it cost. **The consequence for this page is narrow and worth stating: an
-entry whose "how it stays honest" half named one of those three corpora now names a weaker gate, or
-none.** The help fixtures under `tests/__snapshots__/help/`, which most of this page rests on, are
-untouched.
-
----
-
-## `--help`: the prog is `geneseed`, not `harness`
-
-**Status:** declined (the port's wording is kept), narrow and gated.
-
-**What differs.** The reference opened `usage: harness status` for `status --help`; this CLI
-opens `usage: geneseed status`. The same substitution applies to `bin/geneseed-hook.mjs`, which
-spells itself `geneseed-hook`.
-
-**Why.** `harness` named the Python file this migration deleted. It was not a command anyone
-could type, and now it names nothing at all. This CLI already spells itself `geneseed` in every
-error it prints (`geneseed: error: …`, `bin/geneseed-cli.mjs`'s `die`), so reproducing `harness`
-here would make the help text the only surface still pointing at the old name.
-
-**How it stays honest.** `prog` is an ARGUMENT of `js/cli.mjs`'s `formatHelp`, not a constant.
-`tests/snapshot/cli_help.test.mjs` replays all 26 recorded fixtures through it with the reference's own
-prog and requires them byte for byte. The rename is the only thing that moves, and a separate
-assertion pins the shipped spelling so a renderer that ignored `prog` could not pass both.
-
-That the formatter agrees at every WIDTH — argparse's whole layout: usage assembly, the wrapped
-continuation indent, the two-column help position, the wrap column — was established by a live
-sweep over all 26 verbs at every `COLUMNS` from 20 to 200 while the reference still ran. It
-retired with the reference, and it is the reason the fixtures can be trusted: the 26 are recorded
-at ONE width (`COLUMNS=80`), and at that width two real divergences were invisible — a mutually
-exclusive group emitted as one unsplittable usage part, and `_max_help_position` baked as a
-constant where argparse derives it from the width. Both were found by the sweep and fixed. A
-claim about "the entire layout" that rests on a corpus at one width is a claim about one width,
-so a change to the wrapping arithmetic now needs its own argument rather than a green corpus.
-
-Note that the divergence could not have been applied to a recorded text after the fact: the
-continuation indent of a wrapped usage line is `len('usage: ') + len(prog) + 1`, so four of the
-26 usage blocks re-flow when the prog changes length.
-
----
-
-## `update --help` names `update`, where the reference names `upgrade`
-
-**Status:** reference behaviour, deliberately not reproduced.
-
-**What differs.** The reference printed `usage: harness upgrade [-h] [theme]` for `update --help`
-— the canonical verb, for a command the user spelled `update`. This CLI prints `usage: geneseed
-update`.
-
-**Why.** argparse implements an alias by registering a second key in `_SubParsersAction.choices`
-pointing at the SAME parser object, and `parser.prog` was fixed when that object was built. The
-leaked name is an implementation detail of the reference's alias mechanism, not a statement about
-the CLI. Recorded verbatim in `tests/__snapshots__/help/update.txt` and replayed with the
-reference's prog, so the reference's answer is preserved; the shipped call passes the verb the
-user typed.
-
----
-
-## `link` bakes the interpreter into a written shim, where the Unix arm used to symlink
-
-**Status:** ACCEPTED, both consequences below. This is a change to the PRODUCT, not a port
-divergence — since Task 2b both implementations write the same shim — and it is recorded here
-because this is the page that exists for "what did we decide to live with".
-
-**What changed.** `./geneseed link` used to symlink `ROOT/geneseed` into `~/.local/bin`; the
-launcher then resolved the symlink at RUN TIME and found its own interpreter. It now writes a
-`#!/bin/sh` shim carrying a `# GENESEED_LINK_SHIM` marker that `exec`s the runtime named by
-absolute path (`process.execPath`), mirroring what the Windows arm has always done. The reason it
-moved is in `.superpowers/sdd/progress.md` Task 2b: the two implementations disagreed on four
-cells, and this repo has no deliberate-divergence mechanism, so the reference moved to the port's
-shape rather than the corpus recording a split.
-
-**Consequence 1 — durability.** The baked path can go away. A shim written under `nvm` names
-`~/.nvm/versions/node/v22.x/bin/node`; switch or clean up, and `geneseed` on `PATH` points at a
-runtime that no longer exists. The old symlink survived that, because it deferred the choice to the
-launcher. Accepted: the fix is one `./geneseed link` re-run, the failure is loud and immediate
-(`no such file or directory`), and the Windows arm has carried the same property since it
-shipped. Prefer the old behaviour? A shell function in your rc does exactly that, and SETUP.md
-offers it beside `link`.
-
-**Consequence 2 — which CLI is on `PATH`.** The shim names the implementation that WROTE it, and
-while two implementations existed that decided whether `geneseed tui` and `geneseed menu` opened
-the full-screen panel or refused it. This is now settled rather than a consequence: there is one
-implementation, and the panel it does not carry no longer exists anywhere to be reached. Both
-verbs cross and both refuse the panel by name, stating what this entry does carry (the TUI's
-layout half, not its screens) and offering `setup`, `doctor` and `build` instead. The refusal
-names no file, deliberately — an earlier one pointed at the panel's source, and a pointer to
-something a migration is deleting is worse than a plain statement that the screen is not there.
-
----
-
-## argparse's ERROR wording is not reproduced
-
-**Status:** declined, pre-existing (P5a, P10c), restated here because it is the neighbour of the
-entry above and readers keep finding it separately.
-
-argparse printed a usage block around every parse failure and prefixed it `harness: error:`; both
-entries state the fault on one line prefixed `geneseed: error:` / `geneseed-hook: error:`. See
-`bin/geneseed-cli.mjs`'s `parse` docblock.
-
-**What used to be gated beside it no longer is.** Every error a command's own body raises was in
-the recorded CLI corpus, replayed cell by cell; that corpus was retired on 2026-08-17 and the
-per-verb error texts are now covered only where `tests/unit/` happens to drive the verb. The
-divergence declared here is unchanged — the port has never reproduced argparse's wording and does
-not start now — but the *neighbouring* claim, that the rest of the error surface is pinned byte for
-byte, has expired.
-
----
-
-## Top-level `--help` is still a refusal on the Node entries
-
-**Status:** open, out of scope for Task 10, stated so it is not mistaken for done.
-
-`geneseed --help` with no verb prints
-`geneseed: error: the following arguments are required: cmd (one of …)` on stderr and exits 2,
-where the reference printed the whole parser's help with a subcommand table. Task 10's surface
-was the 26 per-verb help texts and only those are recorded.
-
-Rendering the top-level help needs argparse's `_iter_indented_subactions` path — the subcommand
-choices as a metavar in the usage line, and a nested, differently-indented action list whose
-invocations feed the same `_action_max_length` — which is a distinct piece of the formatter with
-no fixture behind it. Whoever writes it should record it the same way first.
-
----
-
-## `--help` anywhere on the line wins, where argparse would fail on an earlier option
-
-**Status:** declined (the port's behaviour is kept), and the gate that pins it has been corrected
-to stop calling it argparse's rule.
-
-**What differs.** Both Node entries scan the whole argument list for `-h`/`--help` BEFORE parsing
-(`bin/geneseed-cli.mjs`, `bin/geneseed-hook.mjs`), so `geneseed version --target --help` prints
-the help and exits 0. argparse consumes optionals left to right, so `--target` swallows `--help`
-as its value and the reference exits 2 with `argument --target: expected one argument`. Three
-error classes reach it — a missing value, an invalid `type=int` value (`web --port abc -h`), and a
-mutex conflict (`theme --solid-only --transparent-only --help`) — across 19 mandatory-value
-options on 13 verbs, plus `--memory` and `--root` on the hook entry.
-
-**Why declined.** On a malformed command line the two answers are "help, exit 0" and "the error,
-exit 2". Neither takes an action; nothing is written, nothing is destroyed. A scan that stopped at
-the first option expecting a value would have to reproduce argparse's consumption order to be
-right, and that order is the piece of the parser this port deliberately does not carry (see
-argparse's ERROR wording above). Printing help for a line that contains `--help` is the answer a
-user is more likely to have wanted, and it is the same answer for every shape of malformed line.
-
-**How it stays honest.** `tests/snapshot/cli_help.test.mjs`'s `a --help anywhere in the line wins` used to
-docblock this as "argparse's own rule". It is not — that generalised from `diff --nope --help`,
-which works only because an UNKNOWN option is deferred to the end of `parse_known_args`. Two of
-that test's four cases are cases where the reference errors instead, so the test pins a
-divergence; its docblock now says which cases those are and points here.
-
-## A verb that postdates the recorder is exempted from the cell matrix by name
-
-**Status:** ACCEPTED, 2026-08-19. This widens an existing exemption rather than minting a second
-one, and it changes a TEST, not the product.
-
-**What differs.** `tests/unit/hook_cli.test.mjs`'s `the matrix covers every verb each entry
-claims` asserted a strict equality between the hook verbs `tests/helpers/matrix/cli.*.json`
-covers and the verbs `bin/geneseed-hook.mjs` carries. The CLI half of the same test already
-exempted a named `NATIVE` list; the hook half exempted nothing. Both halves now filter through
-the same list.
-
-**Why the recording could not be kept as the whole answer.** The matrix was exported by the
-reference implementation, which was deleted on 2026-08-17 along with every recorder that could
-write a cell. So the covered set is frozen at four hook verbs for good. A fifth hook verb —
-wired in `js/settings.mjs`, carried in `bin/geneseed-hook.mjs`, declared in `js/cli-table.json` —
-would fail this equality with **no green path**: the corpus cannot grow, and the failure message
-correctly forbids deleting cells to pass. The gate had become a wall, and a wall that stops a
-legitimate change is not protection, it is an accident of when the recorder died.
-
-The reason the three CLI verbs were exempted in the first place — *the reference had nothing to
-compare against, and authoring one would be recording a copy of the value under test* — is
-exactly the reason a verb that postdates the reference has no cell. Same reason, same exemption.
-
-**What was lost, measured.** Nothing that another gate does not already hold. The only property
-the frozen hook half carried beyond `NATIVE` was *"a hook verb cannot be removed by a coordinated
-edit of three files"* — and `tests/unit/hook_cli.test.mjs`'s own literal (`sorted(wired)` against
-the four names) plus its `verbsOf(HOOK) === wired` equality are two editable copies of that same
-set, twelve lines above. `tests/mutate.mjs`'s M8 plants the one-file removal and is killed there,
-not here.
-
-**How it stays honest.** The exemption is a NAMED list, not a containment: a new verb has to be
-written into `NATIVE` deliberately, in two files that read each other's source, and the reverse
-check refuses an exemption for a verb neither entry point carries. So the next new verb still
-fails loudly until someone decides about it — which is the whole point of the original design.