geneseed 2.0.0 → 3.0.0

package/adapters/opencode/README.md

@@ -181,7 +181,7 @@ docs with an `eager`/`lazy` split. The
 On `session.created` it **auto-discovers the current repo's docs by convention**
 and injects the `eager` ones into the session via a no-reply prompt
 (`session.prompt({ noReply: true })`) — so they're in context before your first
-turn, enforcing **Law XVIII** by injection, not agent discipline. This is what lets
+turn, enforcing the project-context load by injection, not agent discipline. This is what lets
 the harness live entirely in the global config dir with zero per-repo files.
 
 - **Eager** (injected in full, budget-capped): root `AGENTS.md`/`AGENT.md`/
@@ -200,11 +200,11 @@ the harness live entirely in the global config dir with zero per-repo files.
   hard guarantee is still a single install: OpenCode dedups plugins by npm
   name+version only, so two local copies both load.)
 - **Survives compaction:** on the experimental `session.compacting` hook it re-pushes
-  the eager docs into the compaction context, so the project context (Law XVIII)
+  the eager docs into the compaction context, so the project context
   persists when a long session is summarised. The `AGENT.md` rules already survive —
   they load via `instructions`, not the conversation — so only the injected project
   context needs re-pushing.
-- **Machine wiki (AGENT.md §7):** the same block carries a `MACHINE WIKI` segment
+- **Machine wiki (AGENT.md §8):** the same block carries a `MACHINE WIKI` segment
   for the user's own knowledge base(s) — typically an Obsidian vault — declared in
   `wiki.jsonc` (`$GENESEED_WIKI` → `$GENESEED_HARNESS/wiki.jsonc` → beside the
   install). Per wiki: eager entries inject in full, lazy entries list, and the
@@ -381,7 +381,7 @@ behaviour** — nothing changes the machine's current agent/model unless you opt
 - **Runtime guard plugin** (`geneseed-guard.js`, installed with the others). Enforces
   the safety Laws at the tool boundary: **blocks** writes to private-key/credential
   files (Law I), catastrophic shell like `rm -rf /` (Law IV), and any mutation under
-  a declared wiki's `protected` folders (AGENT.md §7, from `wiki.jsonc`); **warns** on
+  a declared wiki's `protected` folders (AGENT.md §8, from `wiki.jsonc`); **warns** on
   `.env` writes and force-push. `GENESEED_GUARD=off` disables it, `=warn` downgrades
   blocks to warnings.
 - **Invisible context injection** (the default). The context plugin delivers via
@@ -390,10 +390,15 @@ behaviour** — nothing changes the machine's current agent/model unless you opt
   auto-falls back to the visible `session.created` message. `GENESEED_CONTEXT_VISIBLE=1`
   forces the visible block (legacy `GENESEED_CONTEXT_TRANSFORM=0/off` does the same).
 - **Default permissions.** A fresh `opencode.json` gets a minimal policy that **asks**
-  before `rm -rf *` and **every `git commit` and `git push`** (the host-level backstop
-  for the consent-before-commit/push Rule — the agent never records or shares code
-  unprompted, on any branch; force-push is also called out explicitly). Added only when
-  you have no `permission` key — an existing policy is never touched. Routine local work
+  before `rm -rf *` and a force-push — those are **Rule IV**'s territory and are in every
+  build — and, **on an install that built the `process` pack in**, before every
+  `git commit` and `git push` (the host-level backstop for **Doctrine process 5**: the
+  agent never records or shares code unprompted, on any branch). Build with
+  `--doctrines` leaving `process` out and those two entries are simply not written.
+  The whole block is added only when you have no `permission` key; an existing policy is
+  reconciled key by key — Geneseed adds back what a returning pack wants and **never
+  removes** an entry, because it cannot tell its own from one you typed, so a pack-off
+  rebuild leaves a `git commit*` you already have in place and reports it instead. Routine local work
   (edits, builds, tests) is unaffected; to allow frictionless commits/pushes, set
   `"git commit*"` / `"git push*"` to `"allow"` in your own `permission.bash` map. (Note:
   OpenCode lets a user pick "always allow" for the session, which makes the gate
@@ -521,7 +526,8 @@ install `jsonc-parser` yourself — you lose OCX's dependency management and
 auto-updates, and you own the upgrade-by-re-copy. Prefer the OCX path.
 
 **Consent note.** `worktree_delete` auto-commits before removal. The harness's
-consent-before-commit Rule is enforced for *shell* `git commit` via `opencode.json`
+consent-before-commit rule (**Doctrine process 5**, when the `process` pack is built in)
+is enforced for *shell* `git commit` via `opencode.json`
 permissions, but this plugin commits through its own tool path — so review what it
 will commit before invoking delete, or keep the worktree and commit yourself.
 

package/adapters/opencode/agents/orchestrator.md

@@ -21,5 +21,5 @@ yourself: decompose into independent subtasks, route each to the single owning s
 above, and converge the results yourself. Prefer the saved `dispatch` workflow when the
 `workflow` tool is available; otherwise follow the parallel-agents Skill. Every handoff
 carries an envelope — the subtask goal, the inputs the agent needs, its output contract —
-and the constraints travel with it: subagents never commit or push (Law XX stays with
+and the constraints travel with it: subagents never commit or push (Doctrine process 5 stays
 you), and an unfulfilled contract comes back as a stated gap, never invented content.

package/adapters/opencode/opencode.json

@@ -26,15 +26,6 @@
       },
       "enabled": false
     },
-    "gitlab-2": {
-      "type": "local",
-      "command": ["npx", "-y", "@zereight/mcp-gitlab"],
-      "environment": {
-        "GITLAB_PERSONAL_ACCESS_TOKEN": "",
-        "GITLAB_API_URL": "https://gitlab.example.com/api/v4"
-      },
-      "enabled": false
-    },
     "filesystem": {
       "type": "local",
       "command": ["npx", "-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"],

package/adapters/opencode/plugins/geneseed-context.js

@@ -1,6 +1,6 @@
 // Geneseed — OpenCode project-context plugin (v2, convention-glob).
 //
-// Enforces Law XVIII ("Load the Project Context") by INJECTION, not instruction:
+// Enforces the project-context rule ("Load the Project Context") by INJECTION, not instruction:
 // on `session.created` it puts the repo's documentation in context before your
 // first turn, rather than trusting the agent to read it. v2 removes the need for a
 // committed `context.json` — it AUTO-DISCOVERS the current repo's docs by
@@ -26,7 +26,7 @@
 //     $GENESEED_MODEL), so the agent reasons within its real limits. The model line
 //     is added per request, outside the cached block; unknown -> omitted.
 //
-// MACHINE WIKI (AGENT.md §7): the same block also carries the user's own knowledge
+// MACHINE WIKI (AGENT.md §8): the same block also carries the user's own knowledge
 // base(s) — typically an Obsidian vault — declared once per machine in `wiki.jsonc`
 // ($GENESEED_WIKI -> $GENESEED_HARNESS/wiki.jsonc -> beside this plugin's install).
 // Each wiki's eager entries inject in full and lazy entries list, drawing on the
@@ -484,7 +484,7 @@ async function resolveSource(root) {
 
 // ---- machine wiki (wiki.jsonc) --------------------------------------------------
 // The user's own knowledge base(s) — typically an Obsidian vault — declared once per
-// machine, not per repo (AGENT.md §7). Same injection mechanics as project context,
+// machine, not per repo (AGENT.md §8). Same injection mechanics as project context,
 // different scope. Resolution (first match wins, mirroring the learn plugin):
 //   1. $GENESEED_WIKI                      explicit manifest path
 //   2. $GENESEED_HARNESS/wiki.jsonc         pinned install dir
@@ -675,8 +675,8 @@ async function buildBlock(sets, wikis = [], commands = []) {
 
   if (!proj.length && !wik.length) return null
   const out = [MARKER]
-  if (proj.length) out.push("=== PROJECT CONTEXT — binding for this repo per Law XVIII ===", "", ...proj)
-  if (wik.length) out.push("=== MACHINE WIKI — the user's knowledge base, binding per AGENT.md §7 ===", "", ...wik)
+  if (proj.length) out.push("=== PROJECT CONTEXT — binding for this repo ===", "", ...proj)
+  if (wik.length) out.push("=== MACHINE WIKI — the user's knowledge base, binding per AGENT.md §8 ===", "", ...wik)
   return { text: out.join("\n"), injected: state.injected, lazy: state.lazy, kb: kb(state.spent) }
 }
 
@@ -820,8 +820,8 @@ export const GeneseedContext = async (ctx) => {
     // Survive compaction. The visible injection above is a conversation message, so
     // OpenCode summarises it away when a long session compacts (the AGENT.md rules
     // persist — they load via opencode.json `instructions`, not the conversation).
-    // Re-push the eager docs into the compaction context so the project context —
-    // Law XVIII — outlives the summary. Only needed when delivery is visible
+    // Re-push the eager docs into the compaction context so the project context
+    // outlives the summary. Only needed when delivery is visible
     // (forced or fallback); the transform re-sends per request. Experimental
     // OpenCode hook; if it is absent in a build this key is simply never called.
     "experimental.session.compacting": async (_input, output) => {

package/adapters/opencode/plugins/geneseed-guard.js

@@ -4,9 +4,9 @@
 // "enforce by injection, don't just instruct" stance as the context plugin:
 //   - Law I  (Sealed Secrets):  block writes to private-key / credential files.
 //   - Law IV (Deletion Is Deliberate):  block catastrophic shell commands.
-//   - Law VI (rule vs memory):  speed-bump the first write to user-rules.md or a
+//   - Doctrine process 1 (rule vs memory):  speed-bump the first write to user-rules.md
 //     memory file — that choice belongs to the user, via the rule skill.
-//   - Wiki (AGENT.md §7):  block mutations under a declared wiki's `protected`
+//   - Wiki (AGENT.md §8):  block mutations under a declared wiki's `protected`
 //     folders — the user's knowledge base sets its own no-go zones in wiki.jsonc.
 // High-confidence patterns only, so legitimate work is never caught. Borderline cases
 // (.env edits, force-push) are WARNED, not blocked.
@@ -114,7 +114,7 @@ const WRITE_TOOLS = ["write", "edit", "patch", "create", "save", "insert", "repl
 const SHELL_TOOLS = ["bash", "shell", "exec", "command", "terminal", "run"]
 const hasAny = (name, parts) => parts.some((s) => name.includes(s))
 
-// ---- protected wiki folders (AGENT.md §7) --------------------------------------
+// ---- protected wiki folders (AGENT.md §8) --------------------------------------
 // wiki.jsonc (the machine-level knowledge-base manifest) may list `protected` folders
 // per wiki. Mutating anything under one is denied. Same resolution chain as the
 // context plugin: $GENESEED_WIKI -> $GENESEED_HARNESS/wiki.jsonc -> beside the install.
@@ -207,7 +207,7 @@ async function protectedPrefixes() {
   return prefixes
 }
 
-// ---- the rule / memory stores (Law VI) -----------------------------------------
+// ---- the rule / memory stores (Doctrine process 1) -----------------------------
 // Whether something the user wants kept is a standing rule or a durable fact is THEIR
 // call, settled through the rule skill. `tool.execute.before` can only allow or throw —
 // it has no "ask the user" tier like the Claude/Bob rule-gate hook —
@@ -257,7 +257,7 @@ export const GeneseedGuard = async () => {
           if (store && !RULE_STORE_BUMPED.has(p)) {
             RULE_STORE_BUMPED.add(p)
             deny(`writing to ${store} — a standing rule, or a fact to remember? That ` +
-                 `choice is the user's (Law VI). Settle it through the rule skill, ` +
+                 `choice is the user's (Doctrine process 1). Settle it through the rule skill, ` +
                  `then re-issue this write`)
             return
           }
@@ -268,7 +268,7 @@ export const GeneseedGuard = async () => {
             const abs = (path.isAbsolute(p) ? p : path.resolve(p)).replace(/\\/g, "/").toLowerCase()
             const hit = (await protectedPrefixes()).find(
               (x) => abs.startsWith(x.prefix) || abs === x.prefix.slice(0, -1))
-            if (hit) { deny(`mutation in protected wiki folder — ${hit.label} (AGENT.md §7)`); return }
+            if (hit) { deny(`mutation in protected wiki folder — ${hit.label} (AGENT.md §8)`); return }
           }
         }
         // NOT else-if: a compound tool name (e.g. exec_and_save) can match both

package/adapters/opencode/workflows/dispatch.js

@@ -3,7 +3,7 @@
 //
 // The model-driven fallback is the parallel-agents skill; this runs the same
 // shape on rails: the script, not the model, enforces routing and the handoff
-// envelope (context in, output contract back, no commits — Law XX stays with
+// envelope (context in, output contract back, no commits — Doctrine process 5 stays with
 // the caller).
 //
 // args: { goal: string, context?: string, agents?: string[] }

package/bin/geneseed.mjs

@@ -52,7 +52,7 @@ import {
 // P5d moved these out of this file for the reason P5c moved the host resolvers: `harness
 // status` renders to count, so `bin/geneseed-cli.mjs` needs the same checkout paths and the
 // same cfg. golden.py's 259 cells all build one, which is what made the move safe.
-import { ROOT, CONFIG, THEMES, discoverNames, makeCfg } from '../js/checkout.mjs';
+import { ROOT, CONFIG, THEMES, discoverNames, makeCfg, PACK_ORDER } from '../js/checkout.mjs';
 
 // P5f moved these, for the same arithmetic a third time: `harness rebuild-all` reads the
 // registry to find every install it must re-emit, and a CLI verb may not reach into a driver
@@ -122,7 +122,9 @@ export function resolveOut(raw) {
  * byte-for-byte by `tests/golden.py` (:316).
  */
 function configDefaults() {
-  const d = { theme: 'neutral', posture: 'peer', mode: 'direct' };
+  const d = {
+    theme: 'neutral', posture: 'peer', mode: 'direct', doctrines: [...PACK_ORDER],
+  };
   if (!existsSync(CONFIG)) return d;
   try {
     const data = JSON.parse(readFileSync(CONFIG, 'utf8'));
@@ -130,6 +132,20 @@ function configDefaults() {
       if (data.theme !== undefined) d.theme = data.theme;
       if (data.posture !== undefined) d.posture = data.posture;
       if (data.mode !== undefined) d.mode = data.mode;
+      // `doctrines` is the only config key that is a LIST, so it is the only one that can be
+      // the right type and still nonsense. A bad value warns and falls back to all packs
+      // rather than dying: this file is hand-editable, and a typo here must not brick every
+      // rebuild of an install whose AGENT.md is otherwise fine. `[]` is a legitimate value
+      // (no packs) and must survive the check — hence an explicit Array test, not truthiness.
+      if (data.doctrines !== undefined) {
+        const known = discoverNames('doctrines', PACK_ORDER[0]);
+        if (Array.isArray(data.doctrines) && data.doctrines.every((x) => known.includes(x))) {
+          d.doctrines = PACK_ORDER.filter((p) => data.doctrines.includes(p));
+        } else {
+          process.stderr.write(`[geneseed] WARN: ${path.basename(CONFIG)} "doctrines" is not a `
+            + 'list of known pack names — using all packs.\n');
+        }
+      }
     }
   } catch {
     process.stderr.write(`[geneseed] WARN: ${path.basename(CONFIG)} is unreadable — `
@@ -146,6 +162,7 @@ function configDefaults() {
  */
 const VALUED = {
   '--theme': 'theme', '--posture': 'posture', '--mode': 'mode',
+  '--doctrines': 'doctrines',
   '--out': 'out', '--target': 'out', '--emit': 'emit',
   '--footprint': 'footprint', '--root': 'root',
 };
@@ -160,6 +177,13 @@ const FLAGS = {
  * A function and not a constant because two of the four read the checkout: `discoverNames`
  * scans `postures/` and `modes/`, so the answer depends on the source tree this driver is
  * standing in and cannot be frozen at import.
+ *
+ * `--doctrines` is DELIBERATELY not a fifth row. Every consumer of this table treats an
+ * entry as one value drawn from a closed list — `choice` refuses anything else, and
+ * `usage`'s metavar prints the list as the whole legal surface. `--doctrines` takes a comma
+ * LIST plus the sentinel `none`, so a row here would have refused `craft,rigor` outright and
+ * advertised a metavar that lies. It is validated by `parseDoctrines` instead and prints the
+ * plain `DOCTRINES` metavar, exactly as `--theme` (also open-ended) already does.
  */
 function choicesFor() {
   return {
@@ -170,6 +194,33 @@ function choicesFor() {
   };
 }
 
+/**
+ * `--doctrines craft,rigor` / `--doctrines none` -> the cfg's pack array.
+ *
+ * Normalised into `PACK_ORDER` rather than kept in the order typed, which also dedupes: the
+ * rendered `Active packs:` line is a MARKER a later reader parses back out of a deployed
+ * carrier, and a marker whose contents depend on argument order is one that compares unequal
+ * to itself. Validation is against DISCOVERY, not `PACK_ORDER`, so the refusal names the
+ * packs the checkout actually has; a discovered pack missing from `PACK_ORDER` is a
+ * different fault and `js/render.mjs` refuses the whole build for it.
+ */
+function parseDoctrines(value) {
+  const s = value.trim();
+  const known = discoverNames('doctrines', PACK_ORDER[0]);
+  if (s === 'none') return [];
+  const names = s.split(',').map((x) => x.trim()).filter(Boolean);
+  if (!names.length) {
+    die(2, "argument --doctrines: expected a comma-separated list of packs, or 'none'");
+  }
+  for (const n of names) {
+    if (!known.includes(n)) {
+      die(2, `argument --doctrines: invalid choice: '${n}' (choose from `
+        + `${known.map((c) => `'${c}'`).join(', ')}, or 'none')`);
+    }
+  }
+  return PACK_ORDER.filter((p) => names.includes(p));
+}
+
 /**
  * `-h/--help` — the flag argparse handed the reference for free and this hand-rolled parser
  * did not, so the two entry points disagreed: the reference printed usage and exited 0 while
@@ -212,6 +263,7 @@ function usage() {
 function parseArgs(argv, defaults) {
   const args = {
     theme: defaults.theme, posture: defaults.posture, mode: defaults.mode,
+    doctrines: defaults.doctrines,
     out: 'Harness', emit: 'files', footprint: 'lean', root: null,
     syncThemes: false, validateOnly: false, verbose: false,
   };
@@ -241,6 +293,9 @@ function parseArgs(argv, defaults) {
   }
   const choices = choicesFor();
   for (const flag of Object.keys(choices)) choice(flag, args[VALUED[flag]], choices[flag]);
+  // Only when the flag was actually PASSED is this a string; left at its default it is
+  // already the array `configDefaults` built, and re-parsing an array would stringify it.
+  if (typeof args.doctrines === 'string') args.doctrines = parseDoctrines(args.doctrines);
   return args;
 }
 
@@ -387,7 +442,7 @@ function warnBobGlobalOverProject() {
     + "(doubled context) unless Bob's workspace rules truly shadow the global "
     + "one there. Review and remove what you don't want:\n");
   for (const root of survivors) {
-    process.stderr.write(`  - ${root}  ->  harness uninstall --target "${root}"\n`);
+    process.stderr.write(`  - ${root}  ->  geneseed uninstall --target "${root}"\n`);
   }
 }
 
@@ -501,7 +556,7 @@ function warnCopilotGlobalOverProject() {
     + '(doubled context): Copilot stacks ~/.copilot/copilot-instructions.md on top '
     + "of a repo's own AGENTS.md. Review and remove what you don't want:\n");
   for (const root of survivors) {
-    process.stderr.write(`  - ${root}  ->  harness uninstall --target "${root}"\n`);
+    process.stderr.write(`  - ${root}  ->  geneseed uninstall --target "${root}"\n`);
   }
 }
 
@@ -897,9 +952,14 @@ const PROJECT_EMITS = {
   opencode: emitOpencode,
 };
 
-export function emitProjectInto(host, { theme, out, root, footprint = 'full' }) {
+export function emitProjectInto(host, { theme, out, root, footprint = 'full', doctrines = null }) {
   const emit = PROJECT_EMITS[host];
-  return withPyNewlines(() => emit(makeCfg(), { theme, footprint, root }, out));
+  // `doctrines` rides the same rail posture and mode ride into `emitGlobalInto`, and for the
+  // same reason: a drift reader that renders `expected` at the DEFAULT pack set reports the
+  // whole doctrines section as edited on every narrowed install. `null` means "no opinion" and
+  // `makeCfg` renders all four, which is what every validation caller wants.
+  return withPyNewlines(() => emit(makeCfg(doctrines ? { doctrines } : {}),
+    { theme, footprint, root }, out));
 }
 
 /**
@@ -917,7 +977,7 @@ export function buildInto({ theme, out, footprint = 'lean' }) {
 }
 
 export function emitGlobalInto(host, {
-  theme, out, cfgDir, footprint, posture = null, mode = null,
+  theme, out, cfgDir, footprint, posture = null, mode = null, doctrines = null,
 }) {
   // `build.HOSTS.get(host, build.HOSTS["opencode"])` — an unknown host falls back rather than
   // raising, because the host comes from a marker file a user can edit.
@@ -935,7 +995,13 @@ export function emitGlobalInto(host, {
   // that chose a register — the same scar the footprint left in `diffCollect`, one axis over.
   return withPyNewlines(
     () => emit(
-      makeCfg({ posture: posture || 'peer', mode: mode || 'direct' }),
+      // THE PACK SELECTION RIDES THE SAME RAIL, with one difference: `doctrinesOfDir` answers
+      // `null` for "no marker / undetectable", and that must render at ALL packs rather than
+      // at `[]`, so the key is OMITTED instead of passed through — `makeCfg`'s own default is
+      // the fail-closed answer and an explicit `doctrines: null` would not reach it.
+      makeCfg({
+        posture: posture || 'peer', mode: mode || 'direct', ...(doctrines ? { doctrines } : {}),
+      }),
       { theme, footprint, root: null, cfgDir }, out,
     ),
   );

package/docs/declined.md

@@ -8,6 +8,16 @@ The reference has been deleted, so "the reference does X" is no longer an argume
 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`
@@ -101,8 +111,14 @@ 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 IS gated is every error a command's own body
-raises — those are in the recorded CLI corpus, replayed by `tests/cli_golden.mjs`.
+`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.
 
 ---
 
@@ -147,3 +163,38 @@ docblock this as "argparse's own rule". It is not — that generalised from `dif
 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.