geneseed 2.1.0 → 3.0.0

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.0.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[] }

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;
 }
 
@@ -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,
     ),
   );