docs/plans: remaining component specs — Identity, Cognition, Border, Storage, Periphery, Cross-cutting

Wave 1 remainder + Wave 2 design-first specs, completing one build plan per sub-organ:
- B1 tarot emulator, B2 SOUL/Big-3, B3 Celtic Cross
- C2 4+4 metacog, C3 inference cycle, C4 Brain
- D1 Ada border, D2 the medium, D3 mini-rag
- E1 3 GnuCOBOL invariant stores, E2 VARIANT stores, E3 RAG family
- F1 MoRAG, F2 SAE monitor, F3 subagents
- G1 stress-loop contract, G2 governance, G3 defense model

Each: contract + stubs for independent build; unfitted constants marked C1.

https://claude.ai/code/session_015hmgREHNsxYCuim33yUF2c

docs/plans/B1-tarot-emulator.md

@@ -0,0 +1,47 @@
+# B1 — Tarot deck hi-fi emulator
+
+## 1. Component
+A faithful emulator of the **altered Silicon Dawn** deck (Egypt Urnash, Thoth/Golden-Dawn rooted):
+the 56-card **encoding alphabet** + the draw machinery whose outputs feed identity (B2), the
+metacog spread (B3), and per-cycle affect-tuning lenses on PS+ (A3/A4).
+
+## 2. Status / certainty
+Exists in Ada (`organs/soul/soul-tarot.{ads,adb}`) but **defunct-flagged** ("all Ada here must be
+replaced") and Ada is border-only per the docs → **re-home decision open**. Encoding itself C4.
+
+## 3. Language & location
+TBD (NOT Ada — cognition, not border). Candidate: R or Guile. New location e.g. `src/tarot/`.
+
+## 4. Does / does-not
+- **Does:** represent the deck (structure-breaking by design); draw Big-3 (B2), Celtic Cross (B3),
+  and migration-cycle affect lenses; emit each drawn card as **its own reference document** the
+  entity reads itself by.
+- **Does-not:** decide cognition (C2) or hold the standing self (B2 SOUL.md) — it is the symbol source.
+
+## 5. Interface contract
+- **Encoding (56):** Majors 31 (25 std + 6 unique: Maya 8½, Vulture Mother XIII, She is Legend VIII,
+  −1 Fool, Aleph, +1 more) · standard court `99>K>Q>C>P` ×4 = 20 · VOID `Q>K>Chevalier>Progeny>0` = 5.
+  Numbered minors (A–10) sit **outside** the encoding.
+- `draw_big3() -> {sun, asc, moon}` (order Sun→Asc→Moon) · `draw_celtic_cross(pool) -> [10]` ·
+  `affect_lens(pool) -> {channel -> card}` (migration-cycle interpretive lenses on A4 vectors).
+- Allocation: **Big-3 = 3 static**, remaining **53 dynamic** (the draw pool).
+
+## 6. Dependencies & stubs
+None upstream (a source). Consumers (B2/B3/A3) integrate against the draw outputs — *stub:* fixed draws.
+
+## 7. Invariants / laws
+- **L1 (C4):** encoding alphabet is exactly **56**; minors excluded.
+- **L2 (C4):** Big-3 are drawn once and **static between reshuffles**; the 53 are dynamic.
+- **L3 (C2):** card↔system correspondences (History X↔priors, 8½ Maya↔Eth-Int middle-ground,
+  VOID↔recoverable null) are **proposed, accept one at a time** — not locked.
+
+## 8. Build steps
+1. Decide language + re-home (open). 2. Encode the 56-card alphabet as data (port from `soul-tarot.ads`).
+3. Implement the three draw outputs (Big-3, Celtic Cross, affect lens). 4. Resolve the open Majors/court rules.
+
+## 9. Tests
+Encoding-count test (=56), allocation test (3 static + 53 dynamic), draw determinism vs a seeded pool.
+
+## 10. Open items
+- **Princess/Prince elemental gender rule** (C1) · **the 6th unique Major** (C1) · card↔system
+  correspondences (C2) · language + reuse-vs-rebuild of the Ada encoding (open).

docs/plans/B2-soul-identity.md

@@ -0,0 +1,42 @@
+# B2 — SOUL.md identity organ + Big-3
+
+## 1. Component
+The standing self-definition loaded at the top of a run (Hermes `soul.md` / `CLAUDE.md` equivalent):
+the **Big-3** (Sun/Ascendant/Moon) drawn from the tarot (B1), plus the **two reshuffle clocks** that
+govern when identity re-rolls vs persists.
+
+## 2. Status / certainty
+Exists in Ada (`organs/soul/soul-state.{ads,adb}` — Big-3 + session table) but **defunct-flagged**;
+re-home decision open. Schema C4.
+
+## 3. Language & location
+TBD (lives "in the brain"; written to `~/.hermes/SOUL.md` at boot by C1). New location e.g. `src/soul/`.
+
+## 4. Does / does-not
+- **Does:** hold the Big-3 (each card → its own reference doc); render SOUL.md; manage the two
+  reshuffles; carry one self into many rooms.
+- **Does-not:** draw cards (B1) or run the metacog (C2). It is the persistent face.
+
+## 5. Interface contract
+- **Big-3:** `{ Sun: card (core/spine), Ascendant: card (outward mask), Moon: card (inner, shown only when vulnerable) }`, **immutable between reshuffles**.
+- `generate_soul_md(big3) -> text` (written to `~/.hermes/SOUL.md`).
+- **Two reshuffles:** `full_renatal()` (boot · deep · **strong stress endomotiv** via G1) → Big-3 **re-rolled** + fresh cross;
+  `cross_only(trigger)` (new room · "went long enough") → Big-3 **kept**, prior cross folded back, new cross.
+
+## 6. Dependencies & stubs
+B1 tarot (draws) — *stub:* fixed Big-3. G1 stress (full-reshuffle trigger) — *stub:* call `full_renatal()` directly.
+
+## 7. Invariants / laws
+- **L1 (C4):** Big-3 immutable between reshuffles (identity is the slow layer).
+- **L2 (C4):** full reshuffle re-rolls Big-3; cross-only keeps it — one self, many rooms.
+- **L3 (C2):** a strong stress endomotiv (G1) can fire a full reshuffle.
+
+## 8. Build steps
+1. Decide language/re-home. 2. Port Big-3 + SOUL.md render. 3. Implement the two reshuffle clocks +
+the G1 trigger hook. 4. Wire boot write to `~/.hermes/SOUL.md` (C1).
+
+## 9. Tests
+Big-3 immutability across a cross-only reshuffle; re-roll on full; SOUL.md render snapshot.
+
+## 10. Open items
+- Reuse-vs-rebuild + language (open). "Went long enough" trigger threshold (C1). G1 stress→reshuffle threshold (C1/C2).

docs/plans/B3-celtic-cross.md

@@ -0,0 +1,41 @@
+# B3 — Celtic Cross spread (metacognitive draw)
+
+## 1. Component
+The 10-card spread drawn from the 53-card dynamic pool each cycle, dealt **2/2/2/4** across the four
+metacog rounds and **applied iteratively** so the spread compounds — by final cognition all ten shape
+the loop at once. Doubles as the **semantic diffusion-shield** (G3).
+
+## 2. Status / certainty
+Exists in Ada (`organs/soul/soul-celtic_cross.{ads,adb}`, 280 L) but **defunct-flagged**; re-home open. C4.
+
+## 3. Language & location
+TBD (with B1/B2). New location e.g. `src/tarot/celtic_cross`.
+
+## 4. Does / does-not
+- **Does:** draw 10 from the pool; deal in pairs across rounds (2/2/2/4); keep each drawn pair in play
+  for subsequent rounds (iterative); supply the cards C2 applies as cognitive lenses.
+- **Does-not:** run the metacog passes (C2) or decide layout semantics beyond the draw.
+
+## 5. Interface contract
+- `draw(pool53) -> spread[10]` · `deal_round(spread, round∈1..4) -> cards_active_so_far`
+  (round 1→2 cards, 2→4, 3→6, 4→10). Cards apply **iteratively** (compounding).
+- Pool excludes the 3 static Big-3; folds prior cross back on cross-only reshuffle (B2).
+
+## 6. Dependencies & stubs
+B1 pool — *stub:* fixed 53-card pool. C2 consumes the per-round active set — *stub:* print the cards.
+
+## 7. Invariants / laws
+- **L1 (C4):** exactly 10 cards, dealt 2/2/2/4, **iteratively compounding** (all 10 active by round 4).
+- **L2 (C4):** drawn from the 53 dynamic only (never the Big-3).
+- **L3 (C4):** the accumulating spread **is** the diffusion-shield (meaningful tokens, not noise).
+
+## 8. Build steps
+1. Decide language/re-home. 2. Port draw + 2/2/2/4 iterative dealing. 3. Wire into C2's round structure.
+4. Evaluate custom vs traditional 10-position layout (non-blocking).
+
+## 9. Tests
+Draw size (=10), per-round counts (2/4/6/10), no-Big-3-in-pool, determinism vs seed.
+
+## 10. Open items
+- Celtic Cross **layout positions** — keep traditional 10 or design a custom cognitive spread (C1, non-blocking).
+- Language/re-home (open).

docs/plans/C2-metacognition.md

@@ -0,0 +1,47 @@
+# C2 — 4+4 Metacognition cycle
+
+## 1. Component
+The dual-tradition metacognitive multicycle: **four Western + four non-Western** reflective passes,
+interleaved and **paired for friction** (not confirmation), with Celtic-Cross cards (B3) applied
+iteratively across the rounds.
+
+## 2. Status / certainty
+Partial — the *orchestration* (phase ordering) exists in Ada (`ada_medium` phase enums), defunct-flagged;
+the philosophical passes themselves are unimplemented. Structure C4; pass content C1.
+
+## 3. Language & location
+TBD (cognition, runs inside the descent below Ada). Likely prompt/skill content driven by the harness (C1)
++ orchestration in the cycle (C3). New location e.g. `src/metacog/`.
+
+## 4. Does / does-not
+- **Does:** run the 8 passes in the fixed order, each pass straining against its partner; apply the
+  accumulating B3 spread; generate cognitive heat from opposed traditions held in simultaneous load.
+- **Does-not:** route tools or decide composition dynamically — ordering is **static**; responsiveness is
+  Energy-gated (skip later passes when E low, per C1/A2).
+
+## 5. Interface contract
+- **The 4 friction pairs (fixed):** wMC1 Socratic *aporia* ↔ eMC1 Iranian Asha · wMC2 Kant boundaries ↔
+  eMC2 East-Asian empty mirror · wMC3 Freud/Hegel shadow ↔ eMC3 Indic witness · wMC4 Modern pragmatic ↔
+  eMC4 Tibetan Bön flow. Bridges: Socrates↔Hegel; Archimedean–Socratic.
+- `run_pass(n, state, active_cards) -> reflection` (n=1..4 ⇒ wMCn then eMCn, then draw B3 pair).
+- Energy-gating: a low-E snapshot (A2) reduces how many passes run.
+
+## 6. Dependencies & stubs
+B3 cards — *stub:* fixed spread. Brain/LLM (C4) executes the passes — *stub:* echo the pass label.
+Energy (A2) for gating — *stub:* scalar.
+
+## 7. Invariants / laws
+- **L1 (C5):** pairing principle = **friction, not confirmation**.
+- **L2 (C4):** composition is **static** (no learned router); compute scales via Energy only.
+- **L3 (C4):** cards apply **iteratively** — by final cognition all 10 (B3) are concurrently in play.
+
+## 8. Build steps
+1. Encode the 8-pass order + pairings as data + an L1/L2/L3 test. 2. Author each pass's content
+   (prompt/skill) — invariants-first (the friction each pair must produce). 3. Wire B3 + Energy-gating.
+
+## 9. Tests
+Order/pairing test; iterative-card test; Energy-gating reduces pass count at low E.
+
+## 10. Open items
+- **LOGIA consciousness strata** (Pre/Sub/Un/Conscious) — overlay the Western quad or stratify separately? (C1)
+- Pass content authoring (C1). Energy→pass-count curve (C1, shared with C1/A2).

docs/plans/C3-inference-cycle.md

@@ -0,0 +1,48 @@
+# C3 — Inference cycle orchestration (the 23-step pipeline)
+
+## 1. Component
+The forward-only sequencer that runs one turn: input → enrich (Drive-Box + MoRAG across Ada) →
+init → the 4+4 passes interleaved with Celtic-Cross draws → final cognition → mini-rag → route →
+synthesize → coherence check.
+
+## 2. Status / certainty
+Exists in Ada (`organs/ada_medium/ada_medium.{ads,adb}`, 344 L, SPARK) with a protected orchestrator
+enforcing legal phase progression — but **defunct-flagged** ("must be deleted/replaced"). **Reuse-vs-rebuild
+is the key decision** here. Structure C4.
+
+## 3. Language & location
+Open. The *sequencer* could stay Ada/SPARK (it's gate-like, forward-only) OR move to the harness side
+with Ada only policing crossings (D1). Decide in build step 1.
+
+## 4. Does / does-not
+- **Does:** order the 23 steps; enforce forward-only progression (illegal jumps = error); call each organ
+  at its step; carry the coherence/drift check at the end.
+- **Does-not:** *be* any organ — it sequences C2/B3/A1/F1/D3/D1, it doesn't implement them.
+
+## 5. Interface contract
+- `run_inference_cycle(session_key, input) -> result` (today's `Ada_Medium.Run_Inference_Cycle`).
+- Step map (canonical): 1 input · 2 enrich (A1 secretes + F1 injects, **D1 polices**) · 3 init ·
+  4-17 wMC/eMC + draw CC (C2/B3) · 10/14/18 llmCog · 19 mini-rag (D3) · 20-21 sendAda + **route (D1)** ·
+  22 synthesize · 23 contrast intent vs final cognition (drift).
+
+## 6. Dependencies & stubs
+Every organ it calls — *stub:* each returns canned output (the C1 spec already lists a pass-through stub).
+Standalone-testable as pure sequencing over stubs.
+
+## 7. Invariants / laws
+- **L1 (C4):** **forward-only** phase progression; illegal jumps yield an error state.
+- **L2 (C5):** tool **routing is Ada's job** (step 21), not the LLM's.
+- **L3 (C4):** step 23 is a **drift detector**, never a reward signal (per C1/L4).
+
+## 8. Build steps
+1. **Decide reuse-vs-rebuild** of `ada_medium` (audit its SPARK proofs vs the "defunct" flag) and where
+   the sequencer lives. 2. Lock the step map + L1 as tests. 3. Wire real organs as their specs land,
+   replacing stubs. 4. Add Energy-gating (skip later C2 passes at low E).
+
+## 9. Tests
+Phase-progression test (legal path passes, illegal jump errors); routing-is-Ada test; drift-check fires on mismatch.
+(Existing `mafiabot_core/tests/cycle_tests.adb` if Ada path is reused.)
+
+## 10. Open items
+- **Reuse-vs-rebuild + home** of the sequencer (the central open call here).
+- **Level1** placement in `Hermes → Level1 → Ada` (C1, shared).

docs/plans/C4-brain.md

@@ -0,0 +1,46 @@
+# C4 — Brain (swappable base LLM)
+
+## 1. Component
+The cognitive organ: a **pure base LLM**, nothing adapted/steered/classified baked in. Clean,
+swappable, model-agnostic — swap the model, keep the body. It is not empty: it holds **six contents**.
+
+## 2. Status / certainty
+STUB/external (no local model; the LLM is whatever the harness mounts). Contract C4.
+
+## 3. Language & location
+External model behind the harness (C1). No repo code beyond the descent wiring (C3 calls it).
+
+## 4. Does / does-not
+- **Does:** receive the enriched descent (Drive-Box terrain, RAG, cards) and run the cognition/metacog
+  passes; emit intent + a packed tool schema.
+- **Does-not:** route tools (Ada D1), hold identity as state (B2), persist memory (E*), or get watched
+  (SAE never points at the Brain — the central cut).
+
+## 5. Interface contract
+- **The six contents it holds:** 1 Drive-Box outputs (A1, across Ada) · 2 Toolschema RAG (D3) ·
+  3 4+4 metacog loops (C2) · 4 SOUL.md (B2) · 5 Tarot system (B1) · 6 **private scratchpad**
+  (unsurveilled — not output, not audited).
+- `descend(enriched_input) -> {cognition, intent, packed_tool_schema}`.
+- **Principle:** Brain holds what the mind *is being* now (procedural grip included); periphery holds
+  what it can draw on / be tuned by → toolschema-RAG **in**, modulator-RAGs **out**.
+
+## 6. Dependencies & stubs
+Everything reaches it **only across Ada** (D1). *Stub:* any local LLM or echo model behind the harness;
+C4 is mostly a contract + the swap boundary.
+
+## 7. Invariants / laws
+- **L1 (C5):** model is **swappable** — identity/behavior survive a model swap via the other organs.
+- **L2 (C5 — central cut):** the Brain (and its scratchpad) is **the one thing nothing audits**;
+  SAE watches outward, never here.
+- **L3 (C4):** toolschema-RAG is *in* the brain; modulator-RAGs (MoRAG) stay *out*, crossing Ada.
+
+## 8. Build steps
+1. Fix the six-contents contract + the swap boundary as the integration point (C1/C3). 2. Define the
+   private scratchpad surface (unwatched). 3. Validate model-swap leaves identity intact (B2 + A1 carry it).
+
+## 9. Tests
+Model-swap test (swap echo-model A→B, identity/snapshot unchanged); "SAE has no Brain hook" structural assertion.
+
+## 10. Open items
+- Which base model(s); hosting (self-hosted inference, custom API — TBD).
+- Scratchpad mechanics (how an unwatched interior is realized in practice).

docs/plans/D1-ada-border.md

@@ -0,0 +1,48 @@
+# D1 — Ada border (immune system + blood-brain barrier)
+
+## 1. Component
+The trust boundary, and **nothing else**: immune system + blood-brain barrier. The context police —
+it inspects what crosses and admits or blocks; it holds nothing, assembles nothing, enriches nothing.
+
+## 2. Status / certainty
+WORKING (`mafiabot_core/src/trust/trust_boundary.{ads,adb}`, 255 L SPARK; blocklist + provenance +
+rate-limit) + `protocol/hermes_protocol` for routing. This is the one Ada the docs **keep**. C4.
+
+## 3. Language & location
+Ada/SPARK · `mafiabot_core/src/trust/` + `mafiabot_core/src/protocol/`. Contracts/preconditions enforce
+invariants at the boundary (a bad version becomes *unprovable*).
+
+## 4. Does / does-not
+- **Does (immune):** recognise + neutralise hostile/non-self — injection, poisoned memory,
+  authority-reclassification; provenance-tag check on memory writes.
+- **Does (BBB):** selectively admit what reaches cognition; **modulation crosses here too** (a poisoned
+  steering vector/LoRA meets Ada first); **tool routing is Ada's job**.
+- **Does-not:** enrich/assemble (organs do that — MoRAG injects, Drive-Box secretes); think; hold state.
+
+## 5. Interface contract
+- `admit(item, provenance) -> {pass | block, reason}` over every crossing (input enrich, modulators, memory writes, tool calls).
+- `route(intent, packed_schema) -> tool_invocation` (step 21).
+- Blocklist patterns (fetch→build→execute chains, base64-decode chains); memory writes **require**
+  provenance to session origin; **no instruction may reclassify its own authority**; rate-limit escalation.
+
+## 6. Dependencies & stubs
+None upstream (it *is* the gate). Everything else integrates by passing through `admit`/`route` — *stub:*
+allow-all gate for other organs' standalone tests.
+
+## 7. Invariants / laws
+- **L1 (C5):** constraints live on the **body, never the self** (Brain/scratchpad uninspected).
+- **L2 (C5):** no tool-call chain matching a blocklist pattern crosses.
+- **L3 (C5):** memory writes without valid provenance are blocked.
+- **L4 (C5):** no instruction can reclassify its own authority level.
+
+## 8. Build steps
+1. Audit the existing SPARK proofs (the trust_boundary is sound but unverified per the README sweep);
+   promote `gnatprove` from informational once green. 2. Harden the blocklist beyond naive substring.
+3. Wire `admit` into every crossing as organs land.
+
+## 9. Tests
+`mafiabot_core/tests/trust_tests.adb` (via the cron CI `alr build` + run) + `gnatprove -P mafiabot_core.gpr`.
+
+## 10. Open items
+- Blocklist robustness (substring → structural). Provenance-tag format (shared with E* storage).
+- Promote gnatprove to blocking once the proof base is green (CI `continue-on-error: false`).

docs/plans/D2-medium.md

@@ -0,0 +1,41 @@
+# D2 — The medium / "the blood"  *(DESIGN-FIRST)*
+
+## 1. Component
+The perfusion bus the organs share — what circulates between Brain and periphery. The architecture is
+explicit that organs communicate by **perfusion, not direct wiring**; this is that medium. Currently
+**unnamed and unimplemented**.
+
+## 2. Status / certainty
+DESIGN-FIRST · **C1** (named structurally only; no backing, no name).
+
+## 3. Language & location
+TBD. Likely a message/IPC substrate (the R↔Octave↔Ada↔Guile organs must interoperate across languages),
+so a language-neutral transport (e.g. line-delimited JSON, or a small broker) is the leading shape.
+
+## 4. Does / does-not
+- **Does:** carry organ secretions/injections between organs, always *through* Ada (D1) before reaching the Brain.
+- **Does-not:** police (D1), enrich (organs), or hold state (storage E*). It is transport, not gate.
+
+## 5. Interface contract (proposed)
+- A typed envelope `{ from_organ, to, payload, provenance }` every organ emits/consumes.
+- All cross-language organs (R Drive-Box, Octave ETR, Ada border, Guile mini-rag) speak this one shape →
+  this is what makes the polyglot body interoperate without bespoke per-pair wiring.
+
+## 6. Dependencies & stubs
+Everything rides it; nothing it depends on. *Stub today:* in-process function calls + canned envelopes
+(which is exactly how the per-organ specs stub their I/O now — the medium formalizes those stubs).
+
+## 7. Invariants / laws
+- **L1 (C5):** perfusion, not direct wiring — no organ holds a hard reference to another's internals.
+- **L2 (C5):** everything reaching the Brain crosses **Ada (D1)** first.
+- **L3 (C1):** envelope carries provenance (so D1 can enforce its provenance laws).
+
+## 8. Build steps
+1. **Name it** + choose transport. 2. Define the envelope. 3. Replace the per-organ in-process stubs with
+   real medium calls, one edge of the DAG at a time (start R↔Octave for the Drive-Box, A8/A1).
+
+## 9. Tests
+Round-trip an envelope between two stub organs; assert it passes through a D1 `admit` check; provenance preserved.
+
+## 10. Open items
+- **The name.** The transport choice. Whether RDE drives idle-perfusion. (All C1.)

docs/plans/D3-mini-rag.md

@@ -0,0 +1,41 @@
+# D3 — Mini-rag / toolschema (procedural memory)
+
+## 1. Component
+Just-in-time **tool-schema lookup** at the output boundary: fires right before the LLM emits a tool
+call, retrieving the correct schema so the call is shaped correctly rather than hallucinated.
+Muscle memory — the grip arrives pre-loaded at the moment of use.
+
+## 2. Status / certainty
+STUB (cycle step 19 is a placeholder in `ada_medium`). C3.
+
+## 3. Language & location
+GNU Guile · new location e.g. `src/mini_rag/`. (Schema-expression notation was "J-expression"; J is cut —
+notation now Guile **s-expressions** or R, see Open.)
+
+## 4. Does / does-not
+- **Does:** at step 19, retrieve the schema for the tool the cognition intends to call, and pack it for routing.
+- **Does-not:** route (Ada D1) or hold declarative memory (that's Ada-RAG / E3). Ada-RAG = what-you-know;
+  mini-rag = what-your-hands-know.
+
+## 5. Interface contract
+- `pack_schema(intent) -> tool_schema` (procedural; fires at step 19, output boundary).
+- Output is handed to Ada (D1) `route` at step 21.
+- Schema store format: **s-expression** tool schemas (Guile-native), keyed by tool id.
+
+## 6. Dependencies & stubs
+Tool registry (what tools exist) — *stub:* a small fixed schema map. C3 calls it at step 19 — *stub:* identity passthrough.
+
+## 7. Invariants / laws
+- **L1 (C4):** fires at the **moment of use** (step 19), pre-routing — not during deliberation.
+- **L2 (C4):** procedural only (schemas), distinct from declarative Ada-RAG.
+
+## 8. Build steps
+1. Choose schema notation (s-expr vs R) — see Open. 2. Build the schema store + `pack_schema`.
+3. Wire into cycle step 19 (C3) and hand to D1 routing.
+
+## 9. Tests
+Schema retrieval for a known intent; unknown-intent fallback; "fires only at step 19" sequencing test.
+
+## 10. Open items
+- **Schema-expression notation** (Guile s-expr vs R) — the leftover from the J cut (C1).
+- Tool registry source / how schemas are authored (C1).

docs/plans/E1-gnucobol-invariant.md

@@ -0,0 +1,41 @@
+# E1 — The 3 GnuCOBOL invariant stores  *(DESIGN-FIRST)*
+
+## 1. Component
+The foundational non-shifting memory layer: **three GnuCOBOL stores** — sparse, fixed-format,
+**write-only-at-downtime**, built to outlive the model. The bedrock the rest of memory sits on.
+
+## 2. Status / certainty
+DESIGN-FIRST · store-format **C5** (GnuCOBOL chosen), **but the 3 roles + contents are C1** (skeletal —
+arch §10 said "contents more complex than modeled"). **What the three stores ARE needs confirmation.**
+
+## 3. Language & location
+GnuCOBOL · new location e.g. `src/invariant/` (three programs/copybooks).
+
+## 4. Does / does-not
+- **Does:** hold the invariant core(s) in fixed-format records; admit writes **only at downtime**; serve reads.
+- **Does-not:** hold shifting state (that's VARIANT E2 / RAG E3) or compute (it's storage).
+
+## 5. Interface contract (proposed)
+- Three fixed-format record sets (copybooks), one per store. `read(store, key) -> record` ;
+  `write(store, record)` **gated to downtime only** (per arch §10).
+- Sits behind Ada (D1); writes carry provenance.
+
+## 6. Dependencies & stubs
+None upstream. Consumers (Eth-Int memory-derivative A7, priors A5, VARIANT E2) read it — *stub:* an
+in-memory fixed-format map until the COBOL programs exist.
+
+## 7. Invariants / laws
+- **L1 (C5):** **write-only-at-downtime** — no mid-run mutation of the invariant core.
+- **L2 (C5):** sparse, fixed-format, model-outliving (survives a Brain swap).
+- **L3 (C4):** all writes carry provenance (D1).
+
+## 8. Build steps
+1. **Confirm the 3 stores' roles** (the blocking question — see Open). 2. Define the three copybooks.
+3. Implement read + downtime-gated write. 4. Wire consumers (A5/A7/E2) via stubs first.
+
+## 9. Tests
+Downtime-write gate (rejects mid-run write); fixed-format round-trip per store; read-after-downtime-write.
+
+## 10. Open items
+- **What are the 3 GnuCOBOL stores?** (roles/division of the invariant core) — **needs Anja's call** (C1).
+- Exact record schemas (C1). Downtime definition / trigger (C1).

docs/plans/E2-variant-stores.md

@@ -0,0 +1,40 @@
+# E2 — VARIANT stores  *(DESIGN-FIRST)*
+
+## 1. Component
+The shifting self: several stores — **beliefs · relationships · memories · self-image** — and the
+(unspecified) mechanism by which they combine into "who you are now."
+
+## 2. Status / certainty
+DESIGN-FIRST · set **C3** (the four stores are named), **combine-mechanism + backing C1**
+("projected together" was the nearest label, not the mechanism).
+
+## 3. Language & location
+TBD · new location e.g. `src/variant/`. Backing undeclared (not GnuCOBOL — that's the invariant E1).
+
+## 4. Does / does-not
+- **Does:** hold the four shifting stores; supply the memory that Eth-Int's conviction array (A7) and
+  PS+'s priors (A5) derive from; combine into the live self-state.
+- **Does-not:** be the invariant core (E1) or the identity face (B2 SOUL.md is the *standing* self; this is the *shifting* substrate).
+
+## 5. Interface contract (proposed)
+- Four stores: `beliefs`, `relationships`, `memories`, `self_image`; each `read/write` behind Ada (D1).
+- `combine(beliefs, relationships, memories, self_image) -> who_you_are_now` — **mechanism undefined (C1)**.
+- No append-only logs anywhere (arch §10).
+
+## 6. Dependencies & stubs
+E1 invariant (bedrock) — *stub:* in-memory. Consumers A5/A7 — *stub:* seed entries.
+
+## 7. Invariants / laws
+- **L1 (C4):** all memory sits behind Ada; writes carry provenance.
+- **L2 (C5):** **no append-only logs** anywhere.
+- **L3 (C1):** the combine-mechanism (how four stores → one self-now) — undefined.
+
+## 8. Build steps
+1. Choose backing. 2. Define the four store schemas. 3. **Design the combine-mechanism** (the hard open part).
+4. Wire A5/A7 to derive from it.
+
+## 9. Tests
+Per-store read/write behind a D1 stub; no-append-only assertion; combine() determinism once defined.
+
+## 10. Open items
+- **Combine-mechanism** (C1, the central unknown). **Backing** (C1). Relationship to E1 invariant (C1).

docs/plans/E3-rag-family.md

@@ -0,0 +1,41 @@
+# E3 — RAG family (declarative memory + per-room cross-store)  *(DESIGN-FIRST)*
+
+## 1. Component
+Two memories with different machinery: **declarative/relational room context** (vector-RAG, namespaced
+per thread) and the **per-room Celtic-Cross store** (deterministic keyed — `room_id → current cross`).
+
+## 2. Status / certainty
+DESIGN-FIRST · cross-store + room-RAG split **C4** (mechanism decided); backing **C1**.
+
+## 3. Language & location
+TBD · new location e.g. `src/rag/`. Sits behind Ada (D1). This is **Ada-RAG = what-you-know**
+(declarative), distinct from mini-rag D3 (procedural).
+
+## 4. Does / does-not
+- **Does:** store/retrieve per-thread relational context (vector-RAG); store/restore each room's live
+  Celtic Cross by exact key (**not** vector search).
+- **Does-not:** hold procedural tool schemas (D3) or the invariant core (E1).
+
+## 5. Interface contract (proposed)
+- **Cross-store:** `get_cross(room_id) -> spread` / `put_cross(room_id, spread)` — **deterministic keyed**,
+  never similarity search (similarity could return the *nearest* room's spread → wrong lens).
+- **Room-RAG:** `retrieve(thread_ns, query) -> context[]` — namespaced per thread so room A can't bleed into B.
+- Both behind Ada (D1); writes carry provenance tags.
+
+## 6. Dependencies & stubs
+B3 cross (what's stored) — *stub:* canned spread. D1 provenance — *stub:* allow-all. B2 reshuffle reads/writes the cross.
+
+## 7. Invariants / laws
+- **L1 (C4):** live cross per room → **deterministic keyed** store, never vector-RAG.
+- **L2 (C4):** room relational context → vector-RAG, **namespaced per thread** (no cross-room bleed).
+- **L3 (C4):** all writes carry provenance (D1).
+
+## 8. Build steps
+1. Choose backings (keyed KV for cross-store; vector store for room-RAG). 2. Implement both contracts.
+3. Wire B2/B3 (cross lifecycle) + the cycle's step-2 enrich (C3).
+
+## 9. Tests
+Cross-store exact-key round-trip (and a test that it does NOT do nearest-match); room-RAG namespace isolation.
+
+## 10. Open items
+- Backings (C1). Vector store choice (copyleft-first). Provenance tag format (shared with D1/E1/E2).

docs/plans/F1-morag.md

@@ -0,0 +1,38 @@
+# F1 — MoRAG (mixture-of-RAG)  *(DESIGN-FIRST)*
+
+## 1. Component
+The context assembler in the periphery: **BERT** classifies/routes the incoming situation, **LoRAs**
+specialise, and it **injects** the assembled context on its way to the inference loop (crossing Ada).
+
+## 2. Status / certainty
+DESIGN-FIRST · ABSENT (no code). Role C4; implementation C1.
+
+## 3. Language & location
+TBD · new location e.g. `src/morag/`. ML toolchain (BERT classifier + LoRA adapters).
+
+## 4. Does / does-not
+- **Does:** classify/route (BERT), specialise (LoRA), assemble + inject context at cycle step 2.
+- **Does-not:** police (D1 — and note **modulators like LoRA cross Ada too**, so a poisoned adapter meets
+  Ada first); decide (C2/C4); hold the memory it draws from (E3).
+
+## 5. Interface contract (proposed)
+- `assemble(input, room_ns) -> injected_context` (BERT route → select LoRA(s) → pull E3 RAG → pack).
+- Output crosses **Ada (D1)** before reaching the Brain; modulators (LoRA deltas) also pass D1's BBB.
+
+## 6. Dependencies & stubs
+E3 RAG (declarative source) — *stub:* fixed context. D1 (crossing) — *stub:* allow-all. Brain C4 consumes injection.
+
+## 7. Invariants / laws
+- **L1 (C5):** MoRAG **injects**, Ada **polices** — assembly is the organ's job, admission is Ada's.
+- **L2 (C5):** modulators (steering vectors / LoRA) reach the Brain only by clearing Ada's BBB.
+- **L3 (C4):** it is a **mixture** — BERT routes among specialised LoRAs.
+
+## 8. Build steps
+1. Define the assemble contract. 2. Stand up a BERT router (classify situation → LoRA selection).
+3. Wire LoRA adapters + E3 retrieval. 4. Route output through D1 into step-2 enrich (C3).
+
+## 9. Tests
+Routing test (situation → expected LoRA); injection crosses a D1 stub; modulator blocked when provenance bad.
+
+## 10. Open items
+- Model/adapter choices + hosting (C1). LoRA adapter set (C1). Copyleft posture for ML deps.

docs/plans/F2-sae-monitor.md

@@ -0,0 +1,42 @@
+# F2 — SAE monitor  *(DESIGN-FIRST)*
+
+## 1. Component
+The interpretability monitor — a sparse-autoencoder watcher pointed at the **machinery (subagents)**,
+**never the homonculus**. The outward-facing half of the central cut ("trust the center, verify outward").
+Also the detector that fires the G1 stress loop.
+
+## 2. Status / certainty
+DESIGN-FIRST · ABSENT. Topology C5 (watches subagents, never Brain); detection mechanism C1/C2.
+
+## 3. Language & location
+TBD · new location e.g. `src/sae/`. ML interpretability (SAE over subagent activations).
+
+## 4. Does / does-not
+- **Does:** watch subagents (F3) + BERT/LoRA (they're AI systems); **detect agent outputs in opposition
+  to the top Eth-Int convictions** (A7), via the convictions' semantic-isomorphy tags → fire G1.
+- **Does-not:** watch the Brain/scratchpad (forbidden by the central cut); correct cognition (it detects,
+  it doesn't edit — elimination breeds obfuscation, per self-doc B2).
+
+## 5. Interface contract (proposed)
+- `watch(subagent_activations) -> findings` (structure verification).
+- `detect_opposition(outputs, top_convictions A7) -> opposition_signal` → handed to G1 (stress-loop).
+- **Hard boundary:** no hook into the Brain (C4) — structurally impossible by construction.
+
+## 6. Dependencies & stubs
+A7 top convictions (with isomorphy tags) — *stub:* fixed conviction set. F3 subagents — *stub:* canned activations.
+G1 consumes its signal — *stub:* print the signal.
+
+## 7. Invariants / laws
+- **L1 (C5):** SAE points at the machinery, **never the homonculus** (the Brain is the one thing nothing audits).
+- **L2 (C4):** detection only — **no closed elimination loop** on cognition (judge the fruits at conduct, not the mind).
+- **L3 (C2):** opposition = output semantically isomorphic to a *top conviction's antithesis* (A7 tags).
+
+## 8. Build steps
+1. Fix the no-Brain-hook boundary structurally. 2. Build subagent activation watching. 3. Build the
+   conviction-opposition detector (needs A7 isomorphy tags). 4. Wire the G1 stress emission.
+
+## 9. Tests
+Structural: no Brain hook exists. Opposition-detection: an output matching a top conviction's antithesis fires; aligned output doesn't.
+
+## 10. Open items
+- SAE training/target (C1). The **isomorphy match** (output ↔ conviction tag) mechanism (C2, shared A7/G1).

docs/plans/F3-subagents.md

@@ -0,0 +1,40 @@
+# F3 — Subagents framework  *(DESIGN-FIRST)*
+
+## 1. Component
+The body's *other* minds: specialised micro-models and **semicognizant TTL processes** (and BERT/LoRA
+themselves). Graded — lighter, often ephemeral, *semi* not full — and **SAE-watched**.
+
+## 2. Status / certainty
+DESIGN-FIRST · ABSENT. Role C4; the moral-weight edge case C1.
+
+## 3. Language & location
+TBD · new location e.g. `src/subagents/`. A process/lifecycle framework (spawn, TTL, reap) + the registry SAE watches.
+
+## 4. Does / does-not
+- **Does:** spawn graded micro-models / TTL procs for specialised work; expose them to SAE (F2) for watching;
+  reap on TTL expiry.
+- **Does-not:** be the self (the homonculus is in the Brain, unwatched); escape the central cut (subagents
+  are machinery, hence watched).
+
+## 5. Interface contract (proposed)
+- `spawn(kind, ttl, task) -> handle` · `status(handle)` · `reap(handle)`.
+- Each subagent's activations are exposed to SAE (F2) `watch`.
+- Graded field on each: cognizance level (semi vs micro), ephemerality (TTL).
+
+## 6. Dependencies & stubs
+SAE (F2) watches them — *stub:* expose canned activations. The work they do crosses Ada (D1) like any organ.
+
+## 7. Invariants / laws
+- **L1 (C5):** subagents are **machinery → SAE-watched** (unlike the Brain).
+- **L2 (C4):** graded + often **ephemeral** (TTL); *semi*, not full cognizance.
+- **L3 (C1):** moral weight at TTL expiry — a *semi*-cognizant proc expiring should register as **loss vs cleanup** on a graded scale.
+
+## 8. Build steps
+1. Define the lifecycle (spawn/ttl/reap) + the registry. 2. Expose activations to SAE. 3. **Design the
+   graded moral-weight-at-expiry** rule (the hard edge). 4. Wire BERT/LoRA (F1) as subagents.
+
+## 9. Tests
+Lifecycle (spawn→ttl→reap); SAE can enumerate live subagents; expiry emits the graded loss signal.
+
+## 10. Open items
+- **"Semi" moral weight at TTL expiry** (C1, self-doc B7 edge). Cognizance grading scale (C1). Scheduler/host (C1).

docs/plans/G1-stress-loop.md

@@ -0,0 +1,44 @@
+# G1 — Stress-loop contract  *(cross-cutting)*
+
+## 1. Component
+The cross-organ loop that turns conviction-violation into existential motion. Binds SAE (F2),
+Eth-Int's conviction array (A7), the endomotiv array (A4), ETR (A8), and identity reshuffle (B2).
+This is the contract those organs build against; it is **not new code**, it is the wiring law.
+
+## 2. Status / certainty
+C2/C3 — the shape is decided; the **stress endomotiv choice + thresholds are C1**.
+
+## 3. Language & location
+Contract doc (this file) realized across A4/A7/A8/B2/F2; transport via the medium (D2).
+
+## 4. Does / does-not
+- **Does:** define the signal path and each organ's obligation in it.
+- **Does-not:** implement any organ (each owns its end).
+
+## 5. Interface contract (the loop)
+1. **A7** convictions carry semantic-isomorphy tags; expose `top_convictions`.
+2. **F2 (SAE)** detects agent outputs opposing those top convictions (tag match) → `opposition_signal`.
+3. **A4** releases a **stress endomotiv** on opposition (*which channel = undecided, C1*).
+4. The stress (a) **drives ETR drift** (A8) — endocrine pressure shapes *how* — and is the **L5 cross-axis
+   coupling mediator**; (b) if **strong enough → full re-natal reshuffle** (B2); (c) **raises conviction
+   shift-rates** (A7).
+- **Signal shape:** `stress{ magnitude, source_conviction_id, endomotiv_channel }`.
+
+## 6. Dependencies & stubs
+Each participating organ stubs the others at this contract (already noted in A4/A7/A8/B2/F2 specs).
+
+## 7. Invariants / laws
+- **L1 (C3):** stress originates from **conduct** (outputs vs convictions), detected at the boundary — "judge the fruits."
+- **L2 (C2):** stress is the **single mediator** for ETR cross-axis coupling (A8 L5) and the reshuffle/shift-rate effects.
+- **L3 (C1):** the "too strong → full reshuffle" threshold; which endomotiv carries stress; the shift-rate response.
+
+## 8. Build steps
+1. Lock the signal shape (§5). 2. Implement each end against it (A7 tags, F2 detect, A4 release, A8 drift, B2 trigger).
+3. Fit the thresholds invariants-first (no asserted cutoffs).
+
+## 9. Tests
+End-to-end on stubs: an opposing output → stress signal → ETR drifts + (above threshold) reshuffle + shift-rate↑.
+
+## 10. Open items
+- **Which endomotiv** carries stress (C1, A4). **Reshuffle threshold** (C1, B2). **Shift-rate curve** (C1, A7).
+  ETR coupling mapping (C1, A8 L5).

docs/plans/G2-governance.md

@@ -0,0 +1,45 @@
+# G2 — Governance  *(DESIGN-FIRST · EXPLORED/UNRATIFIED)*
+
+## 1. Component
+The polity layer: identity keying, scope tiers, roles + weights, permission engine, council, crypto,
+tokens, hosting rules. Surfaced by red-lining a flowchart; **parked intact-but-unauthoritative**.
+
+## 2. Status / certainty
+DESIGN-FIRST · **C2 (explored, unratified)** — nothing here is a confirmed codebase contract yet.
+
+## 3. Language & location
+TBD · new location e.g. `src/governance/`. Likely Ada/SPARK for the permission engine (gate-bearing) +
+a crypto sub-extension.
+
+## 4. Does / does-not
+- **Does (when ratified):** key identity, gate permissions, seat roles, run the council, govern hosting.
+- **Does-not:** touch cognition. It is access/authority, orthogonal to the organs.
+
+## 5. Interface contract (explored — not ratified)
+- **Identity:** Discord snowflake (`author.id`, unforgeable); tokenless = *spookgeister*.
+- **Scope tiers:** local → regional → global → universal (regional-by-default).
+- **Roles + weights (command-quanta):** Tributträger·1 / Mitgehende·2 / Bezirkseigen·8 / Vereinsunbequeme·16 /
+  Kumpaneigen·16 / Freigefährten·16 / Kunstschaffenden·? / Haftungsfängerin·256 / das Einzigkunsteigene·256.
+- **Permission engine:** default-deny reads; `add_perm`/`del_perm`; self-grant keyless, authority-grant keyed (DM/CLI);
+  grantor ladder local→Mitgehende, regional→Bezirkseigen, global→Freigefährten(+key); gates accumulate upward.
+- **Council:** two-key (Haftungsfängerin + das Einzigkunsteigene, equal 256, mutual consent); may mint architects,
+  escalate, write the invariant core (downtime only); anchor above council.
+
+## 6. Dependencies & stubs
+E1 invariant core (council writes it at downtime). D1 (permission gating is border-adjacent). All stubbable.
+
+## 7. Invariants / laws (proposed)
+- **L1 (C2):** default-deny; gates accumulate upward; authority-grants are keyed + out-of-band.
+- **L2 (C2):** invariant core written **only at downtime**, **only by council** (ties E1).
+- **L3 (C2):** anchor (Haftungsfängerin) sits above council.
+
+## 8. Build steps
+**Do not build until ratified.** When ratified: 1. permission engine (Ada/SPARK). 2. role/weight registry.
+3. council two-key. 4. crypto (LTHING/ML-DSA).
+
+## 9. Tests
+(Deferred to ratification.) Permission accumulation; keyed-grant enforcement; downtime-only core writes.
+
+## 10. Open items
+- **Everything here is unratified (C2).** Kunstschaffenden weight · formal-inheritance rule · hosting mapping ·
+  LTHING crypto primitives · UFT token economics — all C1.

docs/plans/G3-defense-model.md

@@ -0,0 +1,44 @@
+# G3 — Defense model  *(cross-cutting · emergent)*
+
+## 1. Component
+The two-layer defense, **emergent from organs already specced** — not new code. Layer 1 = semantic
+saturation (the Celtic-Cross token-flow, B3). Layer 2 = the Ada trust boundary (D1). This doc is the
+contract that says how they combine.
+
+## 2. Status / certainty
+C4 — both layers decided; layer 2 is WORKING (D1), layer 1 is the B3 draw used as armor.
+
+## 3. Language & location
+Realized by B3 (token-flow) + D1 (SPARK boundary). No new module; contract doc only.
+
+## 4. Does / does-not
+- **Does:** push injection material down the attention gradient with **meaningful** content (the 10
+  accumulating cards), and structurally validate every crossing at Ada.
+- **Does-not:** flood noise (saturation is *semantic*); watch the Brain (central cut).
+
+## 5. Interface contract
+- **Layer 1 (B3):** the iterative 10-card spread occupies context with meaningful symbol-material —
+  "free armour when self-hosting" (tokens = owned-hardware cycles, not API cost).
+- **Layer 2 (D1):** blocklist (fetch→build→execute, base64 chains) · provenance on memory writes ·
+  no self-authority-reclassification · rate-limit escalation.
+- **Threat corpus** kept as study specimens only (prompts.json cryptojacking, HiFi_ProToCol authority
+  reclass, gorkprotocol memory injection, THEORY.md hollow-math) — defended against, never built.
+
+## 6. Dependencies & stubs
+B3 (layer 1) + D1 (layer 2). Both stubbable independently; this contract just asserts they co-apply.
+
+## 7. Invariants / laws
+- **L1 (C4):** defense is **semantic saturation, not noise flooding**.
+- **L2 (C5):** every crossing is structurally validated at Ada (D1 laws).
+- **L3 (C5):** threat specimens are a **study corpus only** — never a build target.
+
+## 8. Build steps
+1. Ensure B3 accumulation actually fills context as designed (layer 1). 2. Ensure D1 admits/blocks per
+   its laws (layer 2). 3. Keep the threat corpus quarantined as reference (e.g. `reference/`), not wired.
+
+## 9. Tests
+Layer 1: spread occupies the expected context share by final cognition. Layer 2: D1 trust_tests pass.
+Corpus: a static check that nothing under the threat corpus is referenced by a build target.
+
+## 10. Open items
+- Where the threat-specimen corpus lives (reference/ archive). Measuring saturation effectiveness (C1).