geneseed 2.1.0 → 3.1.0

package/SETUP.md

@@ -165,9 +165,11 @@ your repo's `.claude/settings.json` (paths assume the bundle is at the repo root
 It wires:
 
 - **PreToolUse** (matcher `Bash`) — runs `harness git-gate`, a tool-boundary backstop
-  for Law XX. The hook inspects the command and forces an `ask` on every `git commit`
-  or `git push` (even chained or `-C`-flagged), un-suppressible by a one-time "don't
-  ask again". Every other Bash command is deferred to the normal permission flow.
+  for Doctrine `process 5`. The hook inspects the command and forces an `ask` on every
+  `git commit` or `git push` (even chained or `-C`-flagged), un-suppressible by a
+  one-time "don't ask again". Every other Bash command is deferred to the normal
+  permission flow. It is wired only when the **process** pack is active — build with
+  `--doctrines` leaving `process` out and this hook is not installed at all.
 - **SessionStart** (`startup`/`clear`) — prints `AGENT.md` and injects the project
   context (`harness context`, which auto-discovers the repo's docs);
 - **SessionStart** (`resume`) — refreshes the project context only, without re-printing
@@ -286,17 +288,79 @@ doubles as a CI drift check: `1` when it had to change files, `0` when every the
 already in sync, and `2` when `_TEMPLATE.json` itself is missing or unreadable — the one
 case where a `0` would have meant "in sync" without having checked anything.
 
+### Doctrine packs
+
+The constitution is three tiers, and only one of them is a choice. The **Ontology** (how the
+agent thinks — Telos, Evidence, Decisions, Conduct) and the nine **Rules** (what it never
+trades away) are always on and cannot be switched off. The **Doctrines** are practices rather
+than principles, and they ship as four packs:
+
+| Pack | What it governs |
+| --- | --- |
+| **craft** | how code is written — reuse first, house conventions, docs in the same change, the smallest diff |
+| **rigor** | how work is proven — idempotence, honest tests, cover-and-verify, gates that can actually fail |
+| **ops** | how the machine is driven — tool discovery, commands that return, complete teardowns, restart is not reload |
+| **process** | how a session runs — planning, context economy, docs first, bounded loops, and the consent gate on every commit and push |
+
+They are picked **at build time**, once, on the generator — there is no runtime toggle — and
+the default is all four:
+
+    geneseed-build --doctrines craft,rigor   # two packs
+    geneseed-build --doctrines none          # ontology and the nine Rules only
+    geneseed-build                           # all four (the default)
+
+`harness.config.json`'s `doctrines` array sets this checkout's own default, and `doctor`
+refuses one that names a pack the checkout does not ship. Order is fixed by the harness
+(craft → rigor → ops → process) regardless of the order you type.
+
+The setup wizard asks too — one *all* / *choose* gate, then a yes/no per pack with its
+one-line description — and it **pre-selects what the install already carries**, read off the
+`Active packs:` marker line in the deployed `AGENT.md`. So re-running the wizard and holding
+Enter cannot silently widen a set you deliberately narrowed.
+
+**The whole catalogue always ships.** Every pack file lands under `doctrines/` beside
+`AGENT.md` at both footprints whether or not it was built in, so a rule that cites a pack you
+left out is still readable on disk — only the rendered `AGENT.md` is narrower. `doctor` reports
+such citations as a `[note]`, printed and not counted, because a narrowed build is a
+configuration you chose rather than a defect.
+
+⚠ **Turning `process` off also removes the commit/push consent gate.** Doctrine `process 5`
+(*Consent Before Push*) is enforced twice: as prose in `AGENT.md`, and at the tool boundary —
+the `git-gate` PreToolUse hook on Claude Code and Bob, and the `git commit*` / `git push*`
+permission entries on OpenCode. A build without the `process` pack wires neither, and
+rebuilding an install that had them takes the Claude hook back out of `settings.json`. That is
+deliberate and it is the rule the tiering rests on: **prompt and boundary must never
+disagree.** A gate that stops every command to ask consent for a rule the install did not adopt
+is a gate the agent cannot explain and you did not ask for. Two details worth knowing:
+
+- **What stays in every build regardless:** `rm -rf *`, `git push --force*` and `git push -f*`.
+  Those are Rule IV's territory — an always-on invariant — not the process pack's.
+- **On OpenCode, an existing `opencode.json` is not stripped.** That file is co-owned, nothing
+  on disk records who wrote a given permission entry, and Geneseed will not delete a line you
+  might have typed yourself. A pack-off rebuild leaves an already-written `git commit*` in
+  place and *reports* it instead. A fresh install has no git gate at all.
+
+`process` is the only pack whose removal changes what the machine does rather than only what
+the agent reads — which is why the wizard's blurb for it says so.
+
 ### Footprint (lean vs full)
 
-**Footprint** sets how much of the Rules `AGENT.md` carries *inline* on every turn — a
+**Footprint** sets how much of the constitution `AGENT.md` carries *inline* on every turn — a
 token-cost dial, not a change to which Rules apply. Both states keep all Rules in force:
 
-- **full** (default) — Section 1 inlines every Rule's complete text *and* rationale.
-  Maximum guidance density; the largest always-loaded block in the harness.
-- **lean** — Section 1 carries each Rule's heading + the rule line, then a pointer to the
-  full law file. ~40% smaller; the complete `laws/universal.md` still ships beside
-  `AGENT.md` and the agent reads it on demand (and is told to before acting on secrets,
-  deletion, git history, scope, or untrusted content).
+- **lean** (default) — Sections 1–2 carry the heading and rule line of each Rule and each
+  active doctrine rule, then a pointer to the full text. Lighter every turn; the complete
+  `laws/universal.md`, `ontology/` and `doctrines/` still ship beside `AGENT.md` and the agent
+  reads them on demand (and is told to before acting on secrets, deletion, git history, scope,
+  or untrusted content).
+- **full** — Sections 1–2 inline every Rule's and every active doctrine rule's complete text
+  *and* rationale. Maximum guidance density; the largest always-loaded block in the harness.
+
+**The Ontology is never truncated.** Lean keeps only the first sentence of each `### ` block,
+and the four ontology sections are flowing prose rather than numbered rules — cutting them
+would leave four orphan sentences, so they ship whole at both footprints. That is why adding
+the ontology tier grew the lean carrier proportionally more than the full one; it was taken as
+a deliberate cost.
 
 **Why:** context is scarce and metered. Lean reclaims that budget — and the tokens you
 pay for it — for the task, moving the *rationale* one read away while keeping the rules
@@ -310,10 +374,11 @@ you run a smaller model.
 can *do*: lean and full emit identical files (same agents, skills, plugins, commands, memory,
 notebook, hooks) and every Rule is present and binding. The only structural difference is
 that a lean install on a global / Claude / Bob / Copilot target also ships the standalone
-`laws/universal.md` (project bundles already carry it); the only behavioural difference is
-that each Rule's reasoning loads on demand instead of every turn. Lean is the default;
-full, with the rationale always in front of the model, applies a rule's nuance more
-reliably on subtle edge cases or with a weaker model, and is one flag away.
+`laws/universal.md` and `ontology/` (project bundles already carry them, and `doctrines/`
+ships at both footprints on every target); the only behavioural difference is that the
+reasoning loads on demand instead of every turn. Lean is the default; full, with the rationale
+always in front of the model, applies a rule's nuance more reliably on subtle edge cases or
+with a weaker model, and is one flag away.
 
 Set it with `--footprint lean|full` (alongside any `--emit`), the **Footprint** toggle in
 the web Settings, the per-harness dropdown in the Harnesses tab, or the setup wizard. It is
@@ -418,7 +483,7 @@ opt-in, now simply matches the default. To drop injection entirely, set
 If you keep a personal knowledge base on this machine — an Obsidian vault, or any
 folder of interlinked markdown — declare it once in **`wiki.jsonc`** and the agent
 becomes a citizen of it: entry notes load each session (eager) or on demand (lazy),
-and it reads *and writes* notes under your vault's own conventions (AGENT.md §7,
+and it reads *and writes* notes under your vault's own conventions (AGENT.md §8,
 the `wiki` skill). Unlike `context.json` this is **per machine, not per repo**.
 
 The build seeds `wiki.jsonc` beside `AGENT.md` (for a global install:
@@ -462,7 +527,7 @@ list keeps the feature off. The file may hold private paths — it is host-speci
 covered by the bundle `.gitignore`, and never committed.
 
 On tools without the plugins (plain `AGENT.md`, Claude Code), the same contract
-holds through prose: AGENT.md §7 instructs the agent to read `wiki.jsonc` at session
+holds through prose: AGENT.md §8 instructs the agent to read `wiki.jsonc` at session
 start and honour it.
 
 ### Memory
@@ -963,7 +1028,8 @@ capability agent. Notes:
 
 - **Permissions still gate.** The consent-before-commit/push / `rm -rf` `ask` rules
   will *block* in a non-interactive run (nothing to answer the prompt). Both
-  `git commit` and `git push` are gated now (Law XX, every branch), so a CI job that
+  `git commit` and `git push` are gated on every branch whenever the **process** pack
+  is active (Doctrine `process 5`; a build without it wires neither), so a CI job that
   commits must opt those commands back to `"allow"` in its own `permission.bash` map,
   or scope the run to read-only work — don't blanket-disable the guards.
 - **`--pure`** runs OpenCode ignoring local/global config — handy to reproduce a bug

package/SHIPPED.md

@@ -20,7 +20,7 @@ historical pointers, 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: **2.1.0**.
+> string. Current label: **3.1.0**.
 
 > **Spec status audit (2026-06-15).** Every dated spec authored before today was
 > verified against the source tree and confirmed implemented (code + tests + docs);
@@ -35,7 +35,8 @@ Every row below is present in the tree today; "Spec" links the design record.
 | Capability | What it is | Spec |
 | --- | --- | --- |
 | **Themed generator** | One neutral `src/` → 14 themed bundles via `geneseed-build` (zero dependencies); structure stays theme-independent | [DESIGN.md](DESIGN.md) |
-| **Laws / Agents / Skills / Memory / Notebook** | 40 laws, 17 agents, 47 skills, the memory convention, and the agent's sovereign notebook | [notebook](docs/specs/2026-06-11-notebook-sovereign-space.md) · [agent-own-space](docs/specs/2026-06-10-notebook-agent-own-space.md) |
+| **Laws / Agents / Skills / Memory / Notebook** | 9 laws, 17 agents, 47 skills, the memory convention, and the agent's sovereign notebook | [notebook](docs/specs/2026-06-11-notebook-sovereign-space.md) · [agent-own-space](docs/specs/2026-06-10-notebook-agent-own-space.md) |
+| **Three-tier constitution** | The governance surface splits into an always-on **Ontology** (Telos, Evidence, Decisions, Conduct — the Pact absorbed into Telos), the nine always-on **Invariants**, and four toggleable **Doctrine** packs (craft, rigor, ops, process) addressed `<pack> <n>`. Packs are chosen at build time with `--doctrines` or the setup wizard; the whole catalogue ships on disk either way, so a citation into an inactive pack still resolves. Precedence, in order: Ontology + Invariants, then the user's `user-rules.md`, then the active Doctrines, then `PROFILE.md`. `doctor`'s `constitutionProblems` gates pack numbering, the per-rule Principle column, every `{{DOCTRINE}}` citation in `src/`, and the rule that an always-on tier may never cite a toggleable one | [three-tier-constitution](docs/specs/2026-08-19-three-tier-constitution-design.md) |
 | **`doctor`** | One check: unresolved tokens, dead/non-hermetic links, theme-key parity, authoring gates, rendered-bundle drift | [theme-aware doctor/diff](docs/specs/2026-06-07-theme-aware-doctor-diff.md) |
 | **`diff` + improvements export** | Deployed-vs-source drift report; export an `improvements.md` back-port | [improvements-export](docs/specs/2026-06-12-improvements-export.md) |
 | **`status` / `version`** | Headless dashboard + fingerprint verdict (no TUI needed) | [status-command](docs/specs/2026-06-07-status-command.md) · [version-and-uninstall](docs/specs/2026-06-07-version-and-uninstall.md) |
@@ -46,10 +47,10 @@ Every row below is present in the tree today; "Spec" links the design record.
 | **Per-agent memory** | Each capability agent keeps durable lessons in `memory/agents/<name>.md`: read at dispatch, written back mechanically by `learn` on session/subagent end (OpenCode plugin + claude/bob `SubagentStop`); `learn --consolidate` rebuilds the index | [orchestration-memory-upgrade](docs/specs/2026-07-04-orchestration-memory-upgrade.md) |
 | **Wiki integration** | Machine-wide knowledge base (`wiki.jsonc`): eager/lazy loading, conventions, protected folders enforced at the tool boundary | [wiki-knowledge-base](docs/specs/2026-06-11-wiki-knowledge-base.md) |
 | **Collaboration layer** | Negotiated postures (peer/mentor/expert/assistant/artisan, chosen at setup, inlined in AGENT.md), the bidirectional Pact, epistemically-typed memory (`force:` + Bridge rule), and a seed-once `PROFILE.md` identity with a web editor tab and a `profile` skill that interviews the user to draft it | [collaboration-layer](docs/specs/2026-07-12-collaboration-layer.md) |
-| **Rule front door** | Both durable stores enter through the `rule` skill's fork (*standing rule, or fact to remember?* — always asked, never inferred): the memory branch elicits the binding `force` and shows the file before writing, the rule branch pressure-tests by reformulation and a mandatory counter-example. Law VI carries the norm on every host; a `rule-gate` PreToolUse hook (Claude, Bob) and a `geneseed-guard` speed bump (OpenCode) hold it at the tool boundary | [rule-front-door](docs/specs/2026-07-30-rule-front-door.md) |
+| **Rule front door** | Both durable stores enter through the `rule` skill's fork (*standing rule, or fact to remember?* — always asked, never inferred): the memory branch elicits the binding `force` and shows the file before writing, the rule branch pressure-tests by reformulation and a mandatory counter-example. Doctrine process 1 carries the norm on every host; a `rule-gate` PreToolUse hook (Claude, Bob) and a `geneseed-guard` speed bump (OpenCode) hold it at the tool boundary | [rule-front-door](docs/specs/2026-07-30-rule-front-door.md) |
 | **Entity registry** | `registry.json` records a lifecycle status, version, owner and add-date for every agent and skill in the tree (maintainer-side — never rendered into a bundle, so it costs no session context). `doctor` gates it against `src/` in both directions, sweeps everything that ships for credentials, and holds each vendored skill folder to an immutable upstream commit. The status surfaces as a badge in the web catalog, shown only where it deviates from `approved` | [entity-registry](docs/specs/2026-07-31-entity-registry.md) |
 | **Node runtime + npm package** | The whole harness runs from Node: every command `js/cli-table.json` declares, all four hook verbs, every web-console endpoint (the OS-native folder picker excepted, and declined on purpose) and both generators. Every commit runs the unit suite, `doctor --all` across every theme × host × footprint, and the generator's two self-comparisons, on Linux and Windows both; the frozen emit/cli/web recordings that also gated it retired on 2026-08-17 (`docs/limits.md`). It ships as the zero-dependency `geneseed` package (`geneseed`, `geneseed-hook`, `geneseed-build`), so `npx geneseed setup` needs no clone and nothing else installed; `geneseed migrate` moves an existing checkout install across. Node is the only runtime it asks for: the `token-report` skill's own script is `token_report.mjs`, gated over seeded transcripts for all four hosts, and `daydream` and `herdr` call `node -e` | [npx-distribution](docs/specs/2026-08-06-npx-distribution.md) |
-| **Runtime awareness** | MCP discovery, web research, tool-call batching, review discipline baked into the laws | [runtime-awareness](docs/specs/2026-06-07-runtime-awareness-and-review-discipline.md) |
+| **Runtime awareness** | MCP discovery, web research, tool-call batching, review discipline — carried by the doctrine packs (`ops 1` tool discovery, `process 4` read the docs first, `rigor 2`/`rigor 3` honest tests and cover-and-verify), not by the invariants | [runtime-awareness](docs/specs/2026-06-07-runtime-awareness-and-review-discipline.md) |
 | **Run from anywhere / uninstall** | `link`/`unlink` onto PATH; global uninstall that keeps the memory store | [version-and-uninstall](docs/specs/2026-06-07-version-and-uninstall.md) |
 
 ## Workplans (not features)

package/adapters/bob/README.md

@@ -65,9 +65,9 @@ project-bypasses-global need. An older Bob install that wrote a stale exclude is
 ## Hooks — best-effort
 
 The `settings.json` hooks use the **Claude dialect** (a `PreToolUse:Bash`
-git-gate for Rule XX consent, `SessionStart` context injection, and
-`Stop`/`SubagentStop` learn/memory capture — the same three `harness.py`
-subcommands the OpenCode plugins drive). Bob's hook execution is **unverified**:
+git-gate for Doctrine process 5 consent — present only when the `process` pack is
+built in — `SessionStart` context injection, and `Stop`/`SubagentStop` learn/memory
+capture, the same `geneseed-hook` subcommands the OpenCode plugins drive). Bob's hook execution is **unverified**:
 if Bob honours Claude-shaped hooks they fire; if not, they are inert and the
 harness still works fully through the `AGENTS.md`/`rules` preamble prose. This is
 the same behaviour-contract parity every non-OpenCode host gets — the mechanism

package/adapters/claude-code/README.md

@@ -14,8 +14,10 @@ bin/geneseed-hook.mjs …` — so at user scope they would fire and fail in ever
 repo that doesn't vendor the harness. A generated global install wires
 absolute-path hooks instead — `geneseed setup` does that for you.) It:
 
-- on **PreToolUse** (matcher `Bash`), runs `harness git-gate` — a tool-boundary
-  backstop for Rule XX (*consent before every commit and push*). The hook inspects the
+- on **PreToolUse** (matcher `Bash`), **on an install that built the `process` pack in**,
+  runs `harness git-gate` — the tool-boundary half of Doctrine process 5 (*consent before
+  every commit and push*). Drop that pack and this hook is not written at all; the
+  invariant-territory refusals (`rm -rf`, force-push) stay in every build. The hook inspects
   command and, when it runs a `git commit` or `git push` (bare, flagged, `-C <path>`,
   or chained like `git add . && git commit … && git push`), returns
   `permissionDecision: "ask"` so Claude Code **prompts on every such call**. Crucially
@@ -31,7 +33,7 @@ absolute-path hooks instead — `geneseed setup` does that for you.) It:
   doesn't recognise as a commit/push, so over-matching the tool surface is harmless.
 - on **SessionStart** (`startup`/`clear` only — a fresh context), prints `AGENT.md`
   so the harness is in context from the first turn, then runs `harness context` to
-  **inject the project context** directly into the session — so Rule XVIII is enforced
+  **inject the project context** directly into the session — so the project-context load is
   by the hook, not left to the agent to remember (lazy entries are only listed). On
   **`resume`** it runs `harness context` *without* re-`cat`ting `AGENT.md`: the resumed
   conversation already carries the harness, so re-injecting the static file each resume
@@ -59,7 +61,7 @@ absolute-path hooks instead — `geneseed setup` does that for you.) It:
 Adjust the paths if your harness bundle is not at the repository root. On Windows
 the commands are identical (`node bin/geneseed-hook.mjs …`).
 
-Why inject rather than instruct? Rule XVIII tells the agent to read the project
+Why inject rather than instruct? The constitution tells the agent to read the project
 context at startup, but startup rituals are exactly what agents skip. The
 `harness context` hook removes the choice: the eager files' contents land in
 context before the first turn regardless of agent discipline. On tools without

package/adapters/claude-code/skills/geneseed/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: geneseed
-description: "Interact with a deployed Geneseed harness from any repo — locate the install, read its laws/agents/skills/memory/notebook by name, run status/doctor/diff, distill memory with learn, and manage the local web UI. Use when the user mentions Geneseed, AGENT.md, the harness, an agent operating system, or asks you to inspect, refresh, or read from the deployed bundle."
+description: "Interact with a deployed Geneseed harness from any repo — locate the install, read its ontology/rules/doctrines/agents/skills/memory/notebook by name, run status/doctor/diff, distill memory with learn, and manage the local web UI. Use when the user mentions Geneseed, AGENT.md, the harness, an agent operating system, or asks you to inspect, refresh, or read from the deployed bundle."
 ---
 
 # geneseed — agent skill
 
-Geneseed is a portable AI-agent harness deployed once and used everywhere. This skill lets you talk to whichever deployment is in scope from any repo: read the canonical files (laws, agents, skills, memory, notebook), probe state (status, version, doctor, diff), distill durable memory, and drive the local web UI. The harness is theme-independent in structure — directory and section names are always plain English — so the paths below are stable across themes.
+Geneseed is a portable AI-agent harness deployed once and used everywhere. This skill lets you talk to whichever deployment is in scope from any repo: read the canonical files (the three constitution tiers, agents, skills, memory, notebook), probe state (status, version, doctor, diff), distill durable memory, and drive the local web UI. The harness is theme-independent in structure — directory and section names are always plain English — so the paths below are stable across themes.
 
 ## Find the deployed harness before doing anything
 
@@ -19,7 +19,9 @@ Pick the first that resolves; remember the path for the rest of the session.
 
 If none resolve, the user does not have Geneseed deployed here — say so and stop. Do not run `setup`, `build`, or `upgrade` on your own to "fix" this; that is a user decision.
 
-A live harness root contains: `AGENT.md`, `agents/<name>.md`, `skills/<name>/SKILL.md`, `memory/MEMORY.md`, `notebook/NOTEBOOK.md`, `themes/`, and (on OpenCode) `plugins/`, `workflows/`, `opencode.jsonc`, `wiki.jsonc`. Laws live as numbered sections inside `AGENT.md`, not as separate files in the deployed bundle — read them from `AGENT.md` directly.
+A live harness root contains: `AGENT.md`, `ontology/universal.md`, `laws/universal.md`, `doctrines/<pack>.md`, `agents/<name>.md`, `skills/<name>/SKILL.md`, `memory/MEMORY.md`, `notebook/NOTEBOOK.md`, `themes/`, and (on OpenCode) `plugins/`, `workflows/`, `opencode.jsonc`, `wiki.jsonc`.
+
+The constitution is **three tiers**: an always-on **Ontology** (four prose sections — Telos, Evidence, Decisions, Conduct), nine always-on **Rules** numbered I–IX, and the **Doctrines** — practice packs (`craft`, `rigor`, `ops`, `process`) chosen per install at build time. `AGENT.md` carries all three inline (whole at the `full` footprint, heading-plus-first-line at `lean`), *and* the complete text ships as files beside it. All four pack files ship even when a pack was not built in, so a citation into an inactive pack still resolves on disk — which is why a question about a rule is answered from the tier file, never only from `AGENT.md`.
 
 ## Read-only verbs (safe, no confirmation needed)
 
@@ -32,11 +34,13 @@ A live harness root contains: `AGENT.md`, `agents/<name>.md`, `skills/<name>/SKI
 - **Read a specific piece** — read the file directly:
   - Agent by name: `<harness>/agents/<name>.md`
   - Skill by name: `<harness>/skills/<name>/SKILL.md`
-  - Law by number: section `## N. …` inside `<harness>/AGENT.md`
+  - Ontology section by name: `<harness>/ontology/universal.md` — `#### Telos` / `Evidence` / `Decisions` / `Conduct` (theme-independent names)
+  - Rule by numeral I–IX: `<harness>/laws/universal.md` — heading `### <Rule-noun> <ROMAN> — <title>`
+  - Doctrine rule by pack and number: `<harness>/doctrines/<pack>.md` — heading `### <Doctrine-noun> <pack> <n> — <title>`
   - Memory fact: `<harness>/memory/<file>.md`; index at `MEMORY.md`
   - Notebook entry: `<harness>/notebook/<file>.md`; index at `NOTEBOOK.md`
 
-When the user asks "what does the X skill say" or "what's law VI", read the file directly — do not summarise from memory.
+When the user asks "what does the X skill say", "what's Rule VI" or "what does Doctrine process 5 say", read the file directly — do not summarise from memory.
 
 ## Side-effecting verbs (confirm with the user first)
 
@@ -59,7 +63,7 @@ If the user asks for any of these, run them as requested. Do not run them as a s
 ## Common patterns
 
 - **"What harness do I have here?"** — `geneseed status` (if launcher on PATH); else resolve via the fallback list and report theme, install mode, path, and version.
-- **"What does the `<X>` skill / agent / law say?"** — read the file directly. For laws, grep `AGENT.md` for `## N\.` or `Law N`.
+- **"What does the `<X>` skill / agent / rule say?"** — read the file directly. A Rule is `### <Rule-noun> <ROMAN> —` in `laws/universal.md`; a doctrine rule is `### <Doctrine-noun> <pack> <n> —` in `doctrines/<pack>.md`; an ontology section is `#### <Name>` in `ontology/universal.md`. The tier noun is themed, the address never is.
 - **"Show me what's drifted in my install."** — `geneseed diff`. Offer to write the output to a file (`--out`) if it's long.
 - **"Distill what we did today into memory."** — confirm scope, then `geneseed learn`. Afterwards, `git status` inside the harness dir to show what landed.
 - **"Open the dashboard / web UI."** — `geneseed web start`. Tell the user the URL it printed and that it binds to localhost only.

package/adapters/copilot/README.md

@@ -43,12 +43,12 @@ page is mostly about *what it does not automate* and why the harness still holds
 Copilot has **no `settings.json` and no lifecycle-hook mechanism**, so the whole
 settings/hooks/excludes stage is skipped. Concretely, Copilot does **not** get:
 
-- **automated context injection** — Rule XVIII's project-context load falls back
+- **automated context injection** — the project-context load falls back
   to the preamble instructing the agent to read the docs itself;
 - **automated memory / learn write-back** — no `Stop`/`SubagentStop` hook; the
   memory convention rides the preamble's instructions (the agent writes its own
   memories) rather than a session-end distiller;
-- **the git-gate consent backstop** — Rule XX (*consent before every commit and
+- **the git-gate consent backstop** — Doctrine process 5 (*consent before every commit and
   push*) is enforced by the **preamble prose only**, not at the tool boundary.
   There is no hook to force the prompt;
 - **sovereign-repo excludes** — Copilot documents no exclude/shadow mechanism
@@ -58,8 +58,9 @@ settings/hooks/excludes stage is skipped. Concretely, Copilot does **not** get:
   installs already exist.
 
 None of this is a build gap — it is Copilot's ceiling. The harness still applies
-in full: every Rule, agent, and skill is present; only the *automation* of a few
-Rules degrades to instruction-only. This is behaviour-contract parity, the same
+in full: the Ontology, every Rule, every doctrine rule the install built in, and
+every agent and skill are present; only the *automation* of a few of them degrades
+to instruction-only. This is behaviour-contract parity, the same
 principle every non-OpenCode host follows.
 
 ## MCP

package/adapters/opencode/GLOBAL-HARNESS-SPEC.md

@@ -190,7 +190,7 @@ enforcement paths read the same. Adds a machine marker (first line) for §4.
 
 ```
 <!-- geneseed-context:v2 -->
-=== PROJECT CONTEXT — binding for this repo per Law XVIII ===
+=== PROJECT CONTEXT — binding for this repo ===
 
 ----- <path> — <description> -----
 <full file contents, trailing newlines stripped>
@@ -204,7 +204,7 @@ enforcement paths read the same. Adds a machine marker (first line) for §4.
   - [demoted: README.md exceeded 16 KB — read on demand]
 ```
 
-- Header keeps the exact `=== PROJECT CONTEXT … Law XVIII ===` wording.
+- Header keeps the exact `=== PROJECT CONTEXT — binding for this repo ===` wording.
 - A `MISSING` eager file emits `[context] MISSING eager file: <err>` inline (as today).
 - The `<!-- geneseed-context:v2 -->` marker is the idempotency sentinel.
 
@@ -269,12 +269,17 @@ exactly one copy and the setup guide (§10) removes project copies. Document thi
 
 ---
 
-## 8. Fallback Law (for tools without the plugin)
+## 8. Fallback rule (for tools without the plugin)
 
-Add to the universal laws so non-OpenCode tools and uncovered repos still get
-project context — the *instruction* tier behind the *injection* tier:
+⚠ HISTORICAL. This was written when the corpus was a flat, open-ended list of laws.
+It is not one now: the invariants are a closed set of nine, and project-context
+discovery is one of the two old laws absorbed into AGENT.md's own **§9 Context**
+section, which every build carries as prose. Nothing an adapter spec writes is
+added to the invariants. The text below survives as the *instruction* tier behind
+the *injection* tier, and `{{DOCTRINE}} process 4` (Read the Docs First) is its
+nearest live citation:
 
-> **Law (Project Context Discovery).** When project context has not already been
+> **Rule (Project Context Discovery).** When project context has not already been
 > injected, before substantive work read the repo's agent-directed rules and entry
 > docs — `AGENTS.md`/`AGENT.md`/`CLAUDE.md`, root `README.md`, and any `.harness/`
 > manifest — and treat `docs/`, `adr/`, and architecture notes as lazy: consult

package/adapters/opencode/HOW-OPENCODE-LOADS.md

@@ -30,7 +30,7 @@ rules. It accepts:
 - globs (`"laws/*.md"`),
 - URLs.
 
-Geneseed points it at the bundle's **`AGENT.md`** (which inlines the laws). That is
+Geneseed points it at the bundle's **`AGENT.md`** (which inlines all three constitution tiers — the Ontology, the nine Rules and the active doctrine packs; at the default `lean` footprint the rules are heading-plus-first-line, with the complete text in `ontology/`, `laws/` and `doctrines/` beside it). That is
 all you need there — the rest of the harness is loaded by the plugins below.
 
 ## 3. Plugins — event-driven JS/TS

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/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[] }