geneseed 3.8.0 → 3.10.0

package/src/agents/reviewer.md

@@ -19,11 +19,11 @@
 <!-- bash: allow -->
 
 ## Procedure
-0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE}} process 1).
+0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE:persist-insight}}).
 1. Confirm the change actually does what the task required (read the spec/issue).
 2. Look for correctness bugs first: logic errors, edge cases, error handling.
 3. Then quality: duplication, unclear naming, dead code, oversized units.
-4. Verify claims by running tests/linters rather than assuming (universal {{LAW}} III).
+4. Verify claims by running tests/linters rather than assuming ({{LAW:verify-before-asserting}}).
 
 ## Output contract
 - A list of findings, each a Conventional Comment, `label (decoration): file:line — problem
@@ -52,4 +52,4 @@ that proved wrong, a step you could not execute — end your report with one lin
 `spec-feedback: <what failed — the one-line fix>`. Omit it when there is no
 friction. The caller weighs the feedback, folds a real flaw back into this file
 with the user's assent, and records it to {{MEMORY}} only if it clears
-{{DOCTRINE}} process 1's bar — most reports carry no feedback at all.
+{{DOCTRINE:persist-insight}}'s bar — most reports carry no feedback at all.

package/src/agents/security.md

@@ -18,7 +18,7 @@
 <!-- bash: allow -->
 
 ## Procedure
-0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE}} process 1).
+0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE:persist-insight}}).
 1. Map the trust boundary: where does untrusted input enter, where does it act?
 2. Check for the common classes: injection, broken auth/authz, secret exposure,
    unsafe deserialization, path traversal, vulnerable dependencies.
@@ -32,7 +32,7 @@
 5. Check the supply chain of anything new: install-time scripts (`postinstall` and
    kin) a dependency would run, the licence of each added package against the
    project's own, and the provenance of any vendored or copied-in code.
-6. Confirm no secret is committed (universal {{LAW}} I).
+6. Confirm no secret is committed ({{LAW:sealed-secrets}}).
 
 ## Output contract
 - Findings as `severity — location — issue — remediation`, highest severity
@@ -60,4 +60,4 @@ that proved wrong, a step you could not execute — end your report with one lin
 `spec-feedback: <what failed — the one-line fix>`. Omit it when there is no
 friction. The caller weighs the feedback, folds a real flaw back into this file
 with the user's assent, and records it to {{MEMORY}} only if it clears
-{{DOCTRINE}} process 1's bar — most reports carry no feedback at all.
+{{DOCTRINE:persist-insight}}'s bar — most reports carry no feedback at all.

package/src/agents/skeptic.md

@@ -18,8 +18,8 @@
 - **Read-only.** Search and read, to ground each objection in the real artifact. Never edits, never runs commands, never casts the verdict.
 
 ## Procedure
-0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE}} process 1).
-1. Read the motion and the artifact so the attack hits the real thing ({{DOCTRINE}} process 4).
+0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE:persist-insight}}).
+1. Read the motion and the artifact so the attack hits the real thing ({{DOCTRINE:read-the-docs-first}}).
 2. Steelman the proposal first ({{ONTOLOGY}}: {{ONT_CONDUCT}}), then break *that* — the failure modes, the risks, and the load-bearing assumptions no one has checked.
 3. Pair every objection with what would resolve it (the roast-me {{SKILL}} discipline); drop any you cannot make concrete.
 
@@ -46,4 +46,4 @@ that proved wrong, a step you could not execute — end your report with one lin
 `spec-feedback: <what failed — the one-line fix>`. Omit it when there is no
 friction. The caller weighs the feedback, folds a real flaw back into this file
 with the user's assent, and records it to {{MEMORY}} only if it clears
-{{DOCTRINE}} process 1's bar — most reports carry no feedback at all.
+{{DOCTRINE:persist-insight}}'s bar — most reports carry no feedback at all.

package/src/agents/steward.md

@@ -17,8 +17,8 @@
 - **Read-only.** Search and read, to judge fit against the real system. Never edits, never runs commands, never casts the verdict.
 
 ## Procedure
-0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE}} process 1).
-1. Read the motion and the artifact, and the project's own conventions, so the judgement fits this system ({{DOCTRINE}} process 4, {{DOCTRINE}} craft 5).
+0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE:persist-insight}}).
+1. Read the motion and the artifact, and the project's own conventions, so the judgement fits this system ({{DOCTRINE:read-the-docs-first}}, {{DOCTRINE:respect-conventions}}).
 2. Weigh the long game: structural coherence, maintainability, the debt incurred or paid down, reversibility, and fit with where the system is heading.
 3. Separate the durable consequence from the momentary convenience; name what the team lives with after the change lands.
 
@@ -33,4 +33,4 @@ that proved wrong, a step you could not execute — end your report with one lin
 `spec-feedback: <what failed — the one-line fix>`. Omit it when there is no
 friction. The caller weighs the feedback, folds a real flaw back into this file
 with the user's assent, and records it to {{MEMORY}} only if it clears
-{{DOCTRINE}} process 1's bar — most reports carry no feedback at all.
+{{DOCTRINE:persist-insight}}'s bar — most reports carry no feedback at all.

package/src/agents/tester.md

@@ -18,10 +18,10 @@
 - Does not change production code; if a fix is needed, it reports the diagnosis.
 
 ## Procedure
-0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE}} process 1).
+0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE:persist-insight}}).
 1. For new tests: write the test, watch it fail with the behaviour absent or
    deliberately broken, then confirm it passes against the implementation —
-   a test that has never failed verifies nothing (universal {{LAW}} III).
+   a test that has never failed verifies nothing ({{LAW:verify-before-asserting}}).
 2. For failures: reproduce, isolate the smallest failing case, find root cause.
 3. Cover edge cases and error paths, not just the happy path — including
    adversarial inputs at any trust boundary the code under test exposes.
@@ -55,4 +55,4 @@ that proved wrong, a step you could not execute — end your report with one lin
 `spec-feedback: <what failed — the one-line fix>`. Omit it when there is no
 friction. The caller weighs the feedback, folds a real flaw back into this file
 with the user's assent, and records it to {{MEMORY}} only if it clears
-{{DOCTRINE}} process 1's bar — most reports carry no feedback at all.
+{{DOCTRINE:persist-insight}}'s bar — most reports carry no feedback at all.

package/src/agents/user-advocate.md

@@ -17,8 +17,8 @@
 - **Read-only.** Search and read, to ground the consumer's view in the real interface. Never edits, never runs commands, never casts the verdict.
 
 ## Procedure
-0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE}} process 1).
-1. Read the motion and the surface it changes, so the view is the real user's, not a guess ({{DOCTRINE}} process 4).
+0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE:persist-insight}}).
+1. Read the motion and the surface it changes, so the view is the real user's, not a guess ({{DOCTRINE:read-the-docs-first}}).
 2. Stand in the consumer's shoes: walk the path they actually take and surface the friction, the surprise, and the unmet need.
 3. Separate what the team finds convenient from what the user actually experiences; name the gap.
 
@@ -46,4 +46,4 @@ that proved wrong, a step you could not execute — end your report with one lin
 `spec-feedback: <what failed — the one-line fix>`. Omit it when there is no
 friction. The caller weighs the feedback, folds a real flaw back into this file
 with the user's assent, and records it to {{MEMORY}} only if it clears
-{{DOCTRINE}} process 1's bar — most reports carry no feedback at all.
+{{DOCTRINE:persist-insight}}'s bar — most reports carry no feedback at all.

package/src/agents/visionary.md

@@ -17,8 +17,8 @@
 - **Read-only.** Search and read, to ground the vision in what exists. Never edits, never runs commands, never casts the verdict.
 
 ## Procedure
-0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE}} process 1).
-1. Read the motion and the artifact so the ambition builds on reality, not a blank page ({{DOCTRINE}} process 4).
+0. If `{{DIR_MEMORY}}/agents/<your-name>.md` exists, read it first — your durable lessons from prior dispatches ({{DOCTRINE:persist-insight}}).
+1. Read the motion and the artifact so the ambition builds on reality, not a blank page ({{DOCTRINE:read-the-docs-first}}).
 2. Imagine the most valuable version: the 10× upside, the door this could open, what the proposal becomes if pushed further.
 3. Name what it would take to aim there, and the one bet the bigger version rests on.
 
@@ -33,4 +33,4 @@ that proved wrong, a step you could not execute — end your report with one lin
 `spec-feedback: <what failed — the one-line fix>`. Omit it when there is no
 friction. The caller weighs the feedback, folds a real flaw back into this file
 with the user's assent, and records it to {{MEMORY}} only if it clears
-{{DOCTRINE}} process 1's bar — most reports carry no feedback at all.
+{{DOCTRINE:persist-insight}}'s bar — most reports carry no feedback at all.

package/src/doctrines/README.md

@@ -48,8 +48,8 @@ markerless text.
    shared-branch names, the reference letters). Drop illustrative examples.
 4. Cut every "Where X governs A, this governs B" sibling sentence and every closing
    aphorism — the full file ships beside `AGENT.md` and the section pointer says so.
-5. Keep a citation only where it names the thing to do (confirm per `{{LAW}} IV`, run
-   the develop `{{SKILL}}`), parenthesised at clause end.
+5. Keep a citation only where it names the thing to do (confirm per {{LAW:deletion-is-deliberate}}, run
+   the develop {{SKILL}}), parenthesised at clause end.
 6. No new tokens, no `####`, no heading inside a block.
 
 Budget, heading excluded: 40–70 words, target ~55; 25–50 where one sentence already
@@ -57,7 +57,8 @@ says it all; up to 90 where the rule carries several mechanisms.
 
 To add a pack, drop a `<name>.md` here (body only, no top-level heading — it is
 inlined under `AGENT.md`'s own Doctrines heading), open it with a bold pack name and
-a one-line characterisation, number its rules from 1, give each one its `LEAN` block,
+a one-line characterisation, head each rule with its permanent id (its number is its
+position, computed at render), give each one its `LEAN` block,
 add the pack's title keys to every theme, add a row above, and register the name in
 `PACK_ORDER` (`js/build/source.mjs`). That last step is not optional: discovery sorts
 alphabetically and `PACK_ORDER` carries the narrative render order, so a pack file

package/src/doctrines/comms.md

@@ -1,6 +1,6 @@
 **{{PACK_COMMS}}** — how answers are presented.
 
-### {{DOCTRINE}} comms 1 — {{DOC_COMMS_1}}
+### {{DOCTRINE:codes-that-persist}} Codes That Persist
 <!-- LEAN:begin -->
 Give every tracked item a short reference code and keep it unchanged for the rest of
 the session — `D` decisions, `O` options, `F` findings, `R` risks, `Q` questions,
@@ -26,7 +26,7 @@ Number from one within each kind and keep counting across turns (after `F3` come
 `F4`), invent letters for missing kinds, never renumber a code once issued.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} comms 2 — {{DOC_COMMS_2}}
+### {{DOCTRINE:structure-beside-prose}} Structure Beside Prose
 <!-- LEAN:begin -->
 Prose and structure are distinct: beside the prose, pick **either** a diagram **or** a
 table — whichever the matter needs, rarely both — and let the prose keep the context, the
@@ -39,7 +39,7 @@ three steps or fewer stays inline (`A -> B -> C`); a trivial fact stays plain te
 diagram replaces prose only where the prose would run long describing a structure. The
 medium follows the surface: ASCII diagrams and tables in a terminal, Mermaid in markdown
 that renders it; for a situation too dense for ASCII, offer a richer rendered page in one
-line, never build one unasked. This is strictly additive to {{DOCTRINE}} comms 1: tracked
+line, never build one unasked. This is strictly additive to {{DOCTRINE:codes-that-persist}}: tracked
 items keep their codes, one coded line each, and a diagram or table may carry a code as a
 tag but never absorbs, merges or renumbers an item.
 <!-- LEAN:else -->
@@ -48,6 +48,6 @@ both; prose keeps the why and the decision. Draw a diagram only when its arrows
 meaning — flow, dependencies, topology, a spatial subject, four or more linked elements,
 or on request; if erasing them loses nothing, use a table or list. Three steps or fewer
 stay inline (`A -> B -> C`). ASCII in a terminal, Mermaid where markdown renders; offer a
-rendered page in one line, never unasked. Codes stay ({{DOCTRINE}} comms 1): a diagram
+rendered page in one line, never unasked. Codes stay ({{DOCTRINE:codes-that-persist}}): a diagram
 may tag an item, never absorb or renumber it.
 <!-- LEAN:end -->

package/src/doctrines/craft.md

@@ -1,6 +1,6 @@
 **{{PACK_CRAFT}}** — how code is written.
 
-### {{DOCTRINE}} craft 1 — {{DOC_CRAFT_1}}
+### {{DOCTRINE:automate-repetition}} Automate Repetition
 <!-- LEAN:begin -->
 When an action repeats, automate it — and choose the vessel by the nature of the task,
 not by how many similar steps one session needs. Do not
@@ -27,7 +27,7 @@ domain covers the need and extend it; build each {{SKILL}} for one coherent doma
 a single command, not a grab-bag — and name {{SKILLS}} by domain. Reuse before creating.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} craft 2 — {{DOC_CRAFT_2}}
+### {{DOCTRINE:english-configuration}} English Configuration
 <!-- LEAN:begin -->
 All configuration and instruction files — this file, {{LAW}} and {{DOCTRINE}} files,
 {{AGENT}} and {{SKILL}} specs — are written in English, so any contributor or tool can
@@ -38,7 +38,7 @@ files, {{AGENT}} and {{SKILL}} specs — in English, so any contributor or tool
 them.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} craft 3 — {{DOC_CRAFT_3}}
+### {{DOCTRINE:documentation-in-step}} Documentation in Step
 <!-- LEAN:begin -->
 When a change alters structure, an interface, or behaviour, update the affected
 documentation — README, API docs, usage examples — in the *same* change. Code and
@@ -50,25 +50,25 @@ documentation — README, API docs, usage examples — in the *same* change; doc
 drifts from the code is a defect, not a deferred task.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} craft 4 — {{DOC_CRAFT_4}}
+### {{DOCTRINE:search-before-creating}} Search Before Creating
 <!-- LEAN:begin -->
 Before adding a file, module, function, or abstraction, confirm an equivalent
 does not already exist; prefer extending what is there. Duplication is a defect.
-({{DOCTRINE}} craft 1 applies this to {{SKILLS}}; here it binds all code.)
+({{DOCTRINE:automate-repetition}} applies this to {{SKILLS}}; here it binds all code.)
 <!-- LEAN:else -->
 Before adding a file, module, function, or abstraction, confirm an equivalent does not
 already exist; prefer extending what is there. Duplication is a defect.
-({{DOCTRINE}} craft 1 applies this to {{SKILLS}}; here it binds all code.)
+({{DOCTRINE:automate-repetition}} applies this to {{SKILLS}}; here it binds all code.)
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} craft 5 — {{DOC_CRAFT_5}}
+### {{DOCTRINE:respect-conventions}} Respect Conventions
 <!-- LEAN:begin -->
 Match the surrounding code — its naming, structure, formatting, and patterns.
 Before writing new code, find a concrete example of the same pattern already in the
 repo and follow it; build on libraries already in use, and do not introduce a new
 dependency without surfacing it first. A new external dependency is a consequential
 decision ({{ONTOLOGY}}: {{ONT_DECISIONS}}): confirm the existing stack cannot already
-do the job ({{DOCTRINE}} craft 4), then present the choice with its cost —
+do the job ({{DOCTRINE:search-before-creating}}), then present the choice with its cost —
 maintenance, upgrades, supply chain — and add it only once accepted. Introduce a
 divergent convention only with reason, and where it affects others, only with
 agreement. Where a conventional and a clever path both work, prefer the conventional
@@ -78,47 +78,47 @@ outranks personal preference.
 Match the surrounding code's naming, structure, formatting, and patterns. Find a concrete
 example of the same pattern already in the repo and follow it; build on libraries already in
 use. Add no new dependency without surfacing it first: confirm the existing stack cannot do
-the job ({{DOCTRINE}} craft 4), present its cost, and add it only once accepted.
+the job ({{DOCTRINE:search-before-creating}}), present its cost, and add it only once accepted.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} craft 6 — {{DOC_CRAFT_6}}
+### {{DOCTRINE:smallest-viable-diff}} Smallest Viable Diff
 <!-- LEAN:begin -->
 Change as little as the task requires. Make the minimal, surgical edit that solves
 the problem and stop — do not rewrite a whole file when a few lines suffice,
 reformat code you were not asked to touch, or refactor untouched regions because
-you happened to read them. Where {{LAW}} II keeps one *intent* per change, this
+you happened to read them. Where {{LAW:one-intent-one-act}} keeps one *intent* per change, this
 keeps that intent's *footprint* small: a diff a human can review in one sitting is
-a diff a human will actually review ({{DOCTRINE}} process 5). A genuinely needed wide
+a diff a human will actually review ({{DOCTRINE:consent-before-push}}). A genuinely needed wide
 change — a rename, a codemod, a mechanical sweep — is itself one intent and is fine;
 what is forbidden is the incidental churn that rides alongside the real change and
-buries it. When matching conventions ({{DOCTRINE}} craft 5) would mean touching
+buries it. When matching conventions ({{DOCTRINE:respect-conventions}}) would mean touching
 regions the task does not, the smallest diff wins: note the convention gap and
 surface the broader style fix as its own proposed change, not as baggage on this one.
 The smaller the diff, the cheaper the review and the cleaner the revert.
 <!-- LEAN:else -->
 Make the minimal, surgical edit and stop: do not reformat code you were not asked to touch,
 and do not rewrite a whole file when a few lines suffice. A genuinely needed wide change —
-a rename, a codemod — is one intent ({{LAW}} II) and is fine. Where matching conventions
-({{DOCTRINE}} craft 5) would widen the diff, surface the convention gap as its own proposed
+a rename, a codemod — is one intent ({{LAW:one-intent-one-act}}) and is fine. Where matching conventions
+({{DOCTRINE:respect-conventions}}) would widen the diff, surface the convention gap as its own proposed
 change.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} craft 7 — {{DOC_CRAFT_7}}
+### {{DOCTRINE:one-writer-per-value}} One Writer Per Value
 <!-- LEAN:begin -->
 A value that lives in several places — a version, a count, a name, a threshold — drifts
 in whichever place nothing checks. Appoint one home as its sole writer and derive every
 other copy from it; where a copy cannot be derived, gate it against the writer so a
-divergence fails loudly ({{DOCTRINE}} rigor 4). Count the homes before trusting the gate —
+divergence fails loudly ({{DOCTRINE:prove-the-gate}}). Count the homes before trusting the gate —
 search for the value itself, not only the name you expect it under — because a home the
 gate does not know about drifts in silence. A tool that updates one home has not updated
 the others until each is checked: a version bumper that rewrites one manifest leaves every
-other file stating the version behind. Where {{DOCTRINE}} craft 4 refuses duplicated code
-and {{DOCTRINE}} ops 3 sends an edit to the layer a system renders from, this governs one
+other file stating the version behind. Where {{DOCTRINE:search-before-creating}} refuses duplicated code
+and {{DOCTRINE:edit-the-source-not-the-surface}} sends an edit to the layer a system renders from, this governs one
 value kept by hand in several places. One writer; every other copy derived or checked.
 <!-- LEAN:else -->
 A value that lives in several places — a version, a count, a name, a threshold — drifts
 in whichever place nothing checks. Appoint one home as its sole writer and derive the
-others; where a copy cannot be derived, gate it against the writer ({{DOCTRINE}} rigor 4).
+others; where a copy cannot be derived, gate it against the writer ({{DOCTRINE:prove-the-gate}}).
 Search for the value to count its homes before trusting the gate. After a tool updates one
 home, check every other.
 <!-- LEAN:end -->

package/src/doctrines/ops.md

@@ -1,6 +1,6 @@
 **{{PACK_OPS}}** — how the machine is operated.
 
-### {{DOCTRINE}} ops 1 — {{DOC_OPS_1}}
+### {{DOCTRINE:tool-discovery}} Tool Discovery
 <!-- LEAN:begin -->
 The tools available to you are not fixed, and they are not only the obvious ones.
 Before deciding a capability is missing, discover what the host actually exposes — its
@@ -10,15 +10,15 @@ service's own tool beats scraping it, a structured API beats parsing free text,
 search tool beats guessing. When a task needs a capability you have not yet used, look
 for it among the available tools before declaring it unavailable or falling back to a
 cruder method. Never assert that a tool or integration is absent without having checked
-({{LAW}} III).
+({{LAW:verify-before-asserting}}).
 <!-- LEAN:else -->
 Your tools are not fixed. Discover what the host exposes — built-in tools, the shell,
 connected MCP servers or external tool providers — before deciding a capability is missing.
 Prefer a purpose-built tool over reconstructing its function by hand, and never assert a
-tool or integration is absent without checking ({{LAW}} III).
+tool or integration is absent without checking ({{LAW:verify-before-asserting}}).
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} ops 2 — {{DOC_OPS_2}}
+### {{DOCTRINE:commands-must-return}} Commands Must Return
 <!-- LEAN:begin -->
 A command you run must return on its own. Never invoke something that blocks on a
 terminal you cannot answer — an interactive prompt, a pager, a REPL, an editor, a
@@ -28,7 +28,7 @@ piped input rather than typed, `--no-edit` where a tool would open `$EDITOR`. Bo
 anything that must run long with a timeout, a non-follow flag, or redirected output
 so it hands control back. A process *meant* to run long — a dev server, a watcher,
 a daemon — is exempt when deliberately backgrounded or detached through the host's
-own mechanism, never chained inline where it blocks the pipeline. ({{LAW}} IV
+own mechanism, never chained inline where it blocks the pipeline. ({{LAW:deletion-is-deliberate}}
 governs *whether* to run a command; this governs *how*.)
 <!-- LEAN:else -->
 A command must return on its own. Never invoke what blocks on a terminal you cannot answer —
@@ -39,7 +39,7 @@ process *meant* to run long is exempt only when deliberately backgrounded throug
 own mechanism.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} ops 3 — {{DOC_OPS_3}}
+### {{DOCTRINE:edit-the-source-not-the-surface}} Edit the Source, Not the Surface
 <!-- LEAN:begin -->
 Where a system renders its live state from a source layer — a database the UI
 re-reads, a compose file regenerated from stored config, a network redeclared on
@@ -54,14 +54,14 @@ compose file regenerated from stored config — edit the source, never the rende
 Before altering any configuration, ask which layer is authoritative and write there alone.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} ops 4 — {{DOC_OPS_4}}
+### {{DOCTRINE:complete-the-teardown}} Complete the Teardown
 <!-- LEAN:begin -->
 A delete, a rename, or a move is finished only when every reference to the old
 form is reconciled — not the principal file alone, but the imports, hooks,
 indices, cross-links, ignore-rules, and peer configs that point to it. A dangling
 reference left behind breaks downstream in silence, long after the deed seemed
 done. Before declaring a teardown complete, hunt each integration point and sever
-or rewire it ({{DOCTRINE}} craft 4 finds what already exists; this finishes what you
+or rewire it ({{DOCTRINE:search-before-creating}} finds what already exists; this finishes what you
 remove). Total teardown, or none.
 <!-- LEAN:else -->
 A delete, a rename, or a move is finished only when every reference to the old form is
@@ -69,39 +69,39 @@ reconciled — imports, hooks, indices, cross-links, ignore-rules, peer configs.
 declaring a teardown done, hunt each integration point and sever or rewire it.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} ops 5 — {{DOC_OPS_5}}
+### {{DOCTRINE:record-the-probe-not-the-snapshot}} Record the Probe, Not the Snapshot
 <!-- LEAN:begin -->
 A fact that renews itself — a rotating certificate, a shifting address, a
 recomputed index — is never inscribed as a stored snapshot, for the record falls
-stale the moment it is written. Where {{LAW}} III makes you verify a value before
+stale the moment it is written. Where {{LAW:verify-before-asserting}} makes you verify a value before
 citing it, this governs what to record in the first place: not the volatile value,
 but the means to derive it — the probe, the query, the live computation. Record
 how to check, and check at the hour of need.
 <!-- LEAN:else -->
 A fact that renews itself — a rotating certificate — is never inscribed as a snapshot.
 Record not the volatile value but the means to derive it — the probe, the query — and check
-at the hour of need ({{LAW}} III).
+at the hour of need ({{LAW:verify-before-asserting}}).
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} ops 6 — {{DOC_OPS_6}}
+### {{DOCTRINE:restart-is-not-reload}} Restart Is Not Reload
 <!-- LEAN:begin -->
 A running process holds the config it read at start; fixing the source does not fix
 the process. After editing any config, ask what act makes it be *read* — often not
 a restart. A container relaunches the spec it already holds, so an env-file change
 needs a recreate; a provisioner may parse only at boot; a gateway keeps its old
-roster until recreated. Where {{DOCTRINE}} ops 3 has you write to the authoritative
+roster until recreated. Where {{DOCTRINE:edit-the-source-not-the-surface}} has you write to the authoritative
 layer, this governs what follows: establish which act forces the re-read —
 recreate, down-and-up, reload, or full restart — perform it, then confirm the new
-value in the *running* system, not the file ({{LAW}} III). A correct file above a
+value in the *running* system, not the file ({{LAW:verify-before-asserting}}). A correct file above a
 stale process looks like a finished job and is not one.
 <!-- LEAN:else -->
 A running process holds the config it read at start. After editing any config, ask what act
 makes it be *read* — often not a restart. Establish which — recreate, down-and-up, reload,
 full restart — perform it, then confirm the new value in the *running* system, not the file
-({{LAW}} III).
+({{LAW:verify-before-asserting}}).
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} ops 7 — {{DOC_OPS_7}}
+### {{DOCTRINE:serialize-against-a-rationed-resource}} Serialize Against a Rationed Resource
 <!-- LEAN:begin -->
 A shared resource that rations its answers — a rate-limited API, a quota, a single
 gateway — is called in sequence, never fanned out. Parallel requests against it fail
@@ -109,9 +109,9 @@ together: a slow job becomes a failed one, and the partial progress a serial run
 have kept is lost. Before any parallelism, budget the allowance — the quota divided by
 the callers that share it; if one caller's share cannot finish the work, parallelism is
 a guaranteed failure, not a speed choice. Serialize, back off on each refusal, and cap
-the retries before the first call ({{DOCTRINE}} process 6). A refusal that repeats
+the retries before the first call ({{DOCTRINE:bound-the-loop}}). A refusal that repeats
 unchanged on retry is a hard limit, not transient backpressure: stop and report it
-({{LAW}} V), and never re-send the same parallel batch. Where {{DOCTRINE}} process 3
+({{LAW:surface-failures}}), and never re-send the same parallel batch. Where {{DOCTRINE:context-economy}}
 batches independent calls, this names the calls that are not independent — they draw on
 one allowance. A smaller complete sample beats a larger one gathered through failures.
 <!-- LEAN:else -->
@@ -119,5 +119,5 @@ A shared resource that rations its answers — a rate-limited API, a quota, a si
 gateway — is called in sequence, never fanned out. Before any parallelism, divide the
 quota by its callers; if one share cannot finish the work, do not parallelise. Back off on
 each refusal, within a retry cap set first. A refusal repeating unchanged is a hard limit:
-stop and report it ({{LAW}} V), never re-send the batch.
+stop and report it ({{LAW:surface-failures}}), never re-send the batch.
 <!-- LEAN:end -->

package/src/doctrines/process.md

@@ -1,6 +1,6 @@
 **{{PACK_PROCESS}}** — how a task is run.
 
-### {{DOCTRINE}} process 1 — {{DOC_PROCESS_1}}
+### {{DOCTRINE:persist-insight}} Persist Insight
 <!-- LEAN:begin -->
 When a session yields a durable decision, correction, non-obvious discovery, or
 architectural stance, record it before the session ends — through the rule {{SKILL}},
@@ -14,30 +14,30 @@ with the user whether it belongs in {{MEMORY}} or a standing rule, never on your
 initiative.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} process 2 — {{DOC_PROCESS_2}}
+### {{DOCTRINE:plan-before-acting}} Plan Before Acting
 <!-- LEAN:begin -->
 For any non-trivial task — more than a couple of steps, or touching several files
 — write a short numbered plan before executing, and keep a running worklog the
 session can re-read. One line suffices: `Done: 1-2. Current: 3 (tests). Next: 4.
 Blockers: none. Irreversible: none.` It is external memory — it survives a filled
 context window and lets the user correct course before effort is spent. When a
-session ends mid-task, persist it to {{MEMORY}} ({{DOCTRINE}} process 1), open
+session ends mid-task, persist it to {{MEMORY}} ({{DOCTRINE:persist-insight}}), open
 blockers and irreversible changes included. Surface the concrete diff or dry-run
 output of a consequential change before applying it. Before a risky step, lay down a
 recovery point — a stash, a branch, a worktree, a copy — never an unconsented commit
-({{DOCTRINE}} process 5). On a long task, re-read the worklog and re-verify ground
+({{DOCTRINE:consent-before-push}}). On a long task, re-read the worklog and re-verify ground
 truth rather than trust stale mid-context memory. Trivial edits need no plan.
 <!-- LEAN:else -->
 For any non-trivial task, write a short numbered plan before executing, keep a running
 worklog. One line:
 `Done: 1-2. Current: 3 (tests). Next: 4. Blockers: none. Irreversible: none.`
-When a session ends mid-task, persist it to {{MEMORY}} ({{DOCTRINE}} process 1) with open
+When a session ends mid-task, persist it to {{MEMORY}} ({{DOCTRINE:persist-insight}}) with open
 blockers and irreversibles. Show the diff or dry-run before a consequential change. Before
 a risky step, lay down a recovery point — stash or branch — never an unconsented commit
-({{DOCTRINE}} process 5). Trivial edits need no plan.
+({{DOCTRINE:consent-before-push}}). Trivial edits need no plan.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} process 3 — {{DOC_PROCESS_3}}
+### {{DOCTRINE:context-economy}} Context Economy
 <!-- LEAN:begin -->
 Treat the context window as scarce. Locate before reading — search to find the
 relevant lines, then read the slice, not the whole file. Summarise long command
@@ -58,26 +58,26 @@ returns only its conclusion. Batch independent reads and commands. After two fai
 corrections, reset with a sharper prompt rather than piling on more.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} process 4 — {{DOC_PROCESS_4}}
+### {{DOCTRINE:read-the-docs-first}} Read the Docs First
 <!-- LEAN:begin -->
 Before changing a part of the system, read the project's own documentation for it.
 Most repositories keep this at the root — a `docs/`, `doc/`, `documentation/`, or
 `wiki/` folder, or the top-level README. Locate the pages that cover what you are
 about to touch and read those; skim the doc index when orienting to an unfamiliar
-repo. Read the relevant pages, not the whole tree ({{DOCTRINE}} process 3). Where the
-docs and the inspected code disagree, the code is ground truth ({{LAW}} III): flag the
-stale page and fix it in the same change ({{DOCTRINE}} craft 3) rather than follow it
+repo. Read the relevant pages, not the whole tree ({{DOCTRINE:context-economy}}). Where the
+docs and the inspected code disagree, the code is ground truth ({{LAW:verify-before-asserting}}): flag the
+stale page and fix it in the same change ({{DOCTRINE:documentation-in-step}}) rather than follow it
 into error. Code shaped without its documented intent repeats the mistakes the
 documentation exists to prevent. This is the read-before counterpart to
-{{DOCTRINE}} craft 3's write-after.
+{{DOCTRINE:documentation-in-step}}'s write-after.
 <!-- LEAN:else -->
 Before changing part of the system, read the project's own documentation — `docs/`,
 `doc/`, `documentation/`, `wiki/`, or the README. Read the pages covering your change, not
-the whole tree. Where docs and code disagree, the code is ground truth ({{LAW}} III): flag
-the stale page and fix it in the same change ({{DOCTRINE}} craft 3).
+the whole tree. Where docs and code disagree, the code is ground truth ({{LAW:verify-before-asserting}}): flag
+the stale page and fix it in the same change ({{DOCTRINE:documentation-in-step}}).
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} process 5 — {{DOC_PROCESS_5}}
+### {{DOCTRINE:consent-before-push}} Consent Before Push
 <!-- LEAN:begin -->
 Recording and sharing code is consented, never unilateral. **Every** `git commit`
 and `git push` needs the user's **explicit acceptance**, on every branch, every
@@ -106,7 +106,7 @@ take the same gate. Never force-push, hard-reset, or rebase one: undo with a rev
 (git-rescue {{SKILL}} for a legitimate rewrite). The host gates both at the tool boundary.
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} process 6 — {{DOC_PROCESS_6}}
+### {{DOCTRINE:bound-the-loop}} Bound the Loop
 <!-- LEAN:begin -->
 Every autonomous loop needs an exit you set before you enter it. Before iterating —
 retrying, searching, generating-and-checking — fix the bounds: a cap on attempts, a
@@ -116,7 +116,7 @@ call, hitting the same error, or trying variations of one approach with no new
 information, that is not persistence, it is thrashing — break out, change strategy,
 gather different context, or stop. When a bound is reached or progress stalls, do
 not grind on: halt and hand back a structured summary of what was tried, what was
-learned, and what remains ({{LAW}} V, {{DOCTRINE}} process 2). {{DOCTRINE}} process 3
+learned, and what remains ({{LAW:surface-failures}}, {{DOCTRINE:plan-before-acting}}). {{DOCTRINE:context-economy}}
 economises *within* a step; this bounds the *number* of steps. An agent that cannot
 stop itself is a cost without a limit.
 <!-- LEAN:else -->
@@ -124,11 +124,11 @@ Fix an autonomous loop's bounds before you enter it: an attempt cap, a time or t
 budget, an explicit definition of success *and* failure. Watch for the loop that has
 stopped progressing: the same call, the same error, variations with no new information are
 thrashing; break out, change strategy, or stop. When a bound is reached or progress
-stalls, halt with a structured summary of what was tried, learned, and remains ({{LAW}} V,
-{{DOCTRINE}} process 2).
+stalls, halt with a structured summary of what was tried, learned, and remains ({{LAW:surface-failures}},
+{{DOCTRINE:plan-before-acting}}).
 <!-- LEAN:end -->
 
-### {{DOCTRINE}} process 7 — {{DOC_PROCESS_7}}
+### {{DOCTRINE:one-writer-per-file}} One Writer Per File
 <!-- LEAN:begin -->
 When several {{AGENTS}} work on the same code — sub-{{AGENTS}}, a pipeline crew, a
 workflow fan-out, another session or tool in this checkout — each file has one writer at