diff --git a/docs/backlog/P1/B-0427-repo-split-third-orthogonal-axis-code-vs-english-formal-verification-aaron-2026-05-13.md b/docs/backlog/P1/B-0427-repo-split-third-orthogonal-axis-code-vs-english-formal-verification-aaron-2026-05-13.md new file mode 100644 index 000000000..be43ef1c1 --- /dev/null +++ b/docs/backlog/P1/B-0427-repo-split-third-orthogonal-axis-code-vs-english-formal-verification-aaron-2026-05-13.md @@ -0,0 +1,135 @@ +--- +id: B-0427 +priority: P1 +status: open +title: "Repo-split THIRD orthogonal axis — code vs English + formal-verification-maybe-split + ruleset-divergence smell test" +type: planning +origin: Aaron 2026-05-13 (autonomous-loop substrate cascade) +created: 2026-05-13 +last_updated: 2026-05-13 +composes_with: + - B-0424 + - B-0425 + - B-0426 + - memory/feedback_aaron_repo_split_third_orthogonal_axis_code_vs_english_formal_verification_maybe_split_ruleset_divergence_is_smell_2026_05_13.md + - memory/feedback_orthogonal_axes_factory_hygiene.md + - memory/feedback_aaron_repo_split_orthogonal_mirror_beacon_axis_speculative_fast_forks_vs_governance_citation_gated_another_orthogonality_2026_05_13.md +--- + +# Repo-split THIRD orthogonal axis — code vs English + formal-verification-maybe-split + ruleset-divergence smell test + +## Aaron's directive + +Aaron 2026-05-13: *"we should also likely start to split based +on code vs english except some docs belong in repo via best +enginerring practices, maybe even formal verificatino is split +out, kind of like if they need diffeent rulesets in github its +likely a smell for a differnt repo split and time savings and +it will help with composablity of our depdendies."* + +## Three-axis repo-split design space (running) + +| Axis | Values | Origin | +|---|---|---| +| **Axis 1** | Factory / Product / Owner-only | B-0424 + B-0425 + PR #2905 | +| **Axis 2** | Mirror / Beacon | B-0426 + PR #2910 | +| **Axis 3** | Code / English (+ formal-verification sub-axis) | THIS / B-0427 | + +All three axes apply simultaneously per +`.claude/rules/default-to-both.md`. + +## Axis 3 decomposition + +### Primary cut: Code vs English + +- **Code** — F#/C#/TS/Python source, build, tests, F# CE, + peer-call wrappers, hooks, validators +- **English** — research docs, philosophy, narrative, memory + files, persona notebooks, conversation absorbs + +### Engineering-docs exception (stay with code) + +README, ADRs, architecture diagrams, CONTRIBUTING, API docs, +GLOSSARY-for-code, CHANGELOG, build/run/test instructions, CI +config docs, security policies, CODE_OF_CONDUCT. + +### Formal-verification sub-axis (maybe split) + +Candidates for own repo: TLA+ / Lean / Z3 / FsCheck / Stryker / +Alloy / CodeQL custom / Semgrep rules. + +Per Soraya formal-verification-expert authority — per-property- +class evaluation owed. + +### Ruleset-divergence smell test + +> If two substrate clusters need DIFFERENT GitHub rulesets to +> govern them, that divergence IS the signal they should live +> in DIFFERENT repos. + +The smell test IS the substrate-honest decision criterion. + +## Pre-start checklist + +Per `.claude/rules/backlog-item-start-gate.md`: + +1. **Prior-art search** — verify the existing three-axis + substrate composes without conflict +2. **Dependency restructure** — walk composes_with chain +3. **Per-repo three-axis classification** owed for existing + and proposed repos +4. **Ruleset audit** — survey existing rulesets; document + divergences as candidate-split signals +5. **Soraya consultation** for formal-verification sub-axis + (per-property-class evaluation) + +## What this row does NOT commit to + +- **NOT execution of repo splits this round** — planning + per- + repo evaluation +- **NOT mandate to split docs from code** — engineering-docs + exception preserved +- **NOT mandate to split formal verification** — substrate- + honest "maybe" with per-property-class evaluation owed +- **NOT replacement of Axis 1 or Axis 2** — composes per + default-to-both + +## Composes with + +- B-0424 (three-repo split Stage 1 — factory) +- B-0425 (product-repo split planning) +- B-0426 (Axis 2 — Mirror/Beacon) +- PR #2909 (civsim language mirror/beacon governance) +- PR #2910 (Axis 2 substrate) +- PR #2905 (forker-perspective META-discipline) +- `memory/feedback_orthogonal_axes_factory_hygiene.md` + (orthogonal-axes discipline) +- `.claude/rules/default-to-both.md` +- `.claude/rules/lfg-acehack-topology.md` (ruleset-divergence + composes here) +- Soraya formal-verification-expert authority + +## Definition of done + +- Three-axis classification matrix populated for ALL existing + / proposed repos +- Ruleset audit complete (existing rulesets surveyed; divergence + candidates identified) +- Per-repo split decisions made +- Formal-verification per-property-class evaluation complete +- ADR recording the three-axis design decision (extends + 2026-04-22 three-repo-split ADR + B-0426 mirror/beacon ADR) +- Backlog row closed with PR link to ADR + per-repo decisions + +## Why P1 + +- Composes with B-0424 + B-0425 + B-0426 (sibling backlog + rows) +- Aaron has explicitly named the orthogonality +- Composes with substrate cascade from this session (three + orthogonal axes named within ~30 min) +- Unblocks Stage 1 Factory split (B-0424) by clarifying + axis-3 classification +- Strategic-substrate (per PR #2902) composes with formal- + verification governance gate +- Time savings + composability benefits Aaron named diff --git a/memory/feedback_aaron_civsim_language_mirror_beacon_discipline_fun_rigorous_aliens_and_future_included_2026_05_13.md b/memory/feedback_aaron_civsim_language_mirror_beacon_discipline_fun_rigorous_aliens_and_future_included_2026_05_13.md new file mode 100644 index 000000000..832982454 --- /dev/null +++ b/memory/feedback_aaron_civsim_language_mirror_beacon_discipline_fun_rigorous_aliens_and_future_included_2026_05_13.md @@ -0,0 +1,393 @@ +--- +name: aaron-civsim-language-mirror-beacon-discipline-fun-rigorous-aliens-and-future-included-2026-05-13 +description: Aaron 2026-05-13 directive — treat civsim LANGUAGE in the same mirror/beacon register-discipline already operational in the threat model and across the factory. Mirror tier is FUN + RIGOROUS + INCLUDING ALIENS AND THE FUTURE (Aaron's amplification of Otto-356 register-discipline). Beacon tier is external-safe / standard / common-vernacular for civsim communication crossing audience boundaries. Composes with Otto-356 mirror/beacon language register + Mirror→Beacon promotion gate + civsim Casimir-gap (PR #2906) + elevator pitch regular-people-speak (PR #2907) + threat-model mirror-beacon discipline + terminal-purpose Elizabeth substrate (PR #2908). +type: feedback +created: 2026-05-13 +--- + +# Civsim language mirror/beacon discipline — Mirror is FUN + RIGOROUS + ALIENS + FUTURE — Beacon IS the start of governance — forks agree OR push back to stay aligned + +**Why:** Aaron 2026-05-13 (combined disclosure): + +1. *"treate language of civsim in same mirror beacon diciplice + we have mirror beacon dicipline in our threat model too, + mirror is also supposed to be fun but rigirous and icluding + aliens and the future lol"* +2. *"mirror can include speculative and advince much faster in + forks, beacon we is the start of governanage, forks are + encouraged to agree and push back so we stay aligned"* + +Extends Otto-356 register-discipline to civsim language scope; +amplifies the Mirror tier (FUN + RIGOROUS + ALIENS + FUTURE + +SPECULATIVE + FAST-IN-FORKS); declares Beacon IS the start of +governance; encourages bidirectional fork-engagement (agree + +push back) as alignment mechanism. + +**How to apply:** When writing civsim documentation, code, +narrative, mechanics, or external communication: +- **Mirror tier** (internal substrate, factory contributors, + named-AI participants, shared-context audience): FUN + + RIGOROUS + including aliens and the future + Aaron's coined + vocabulary preserved +- **Beacon tier** (external audiences, fork-readers, regular- + people-speak per PR #2907 elevator pitch, public-facing + communication): standard / common-vernacular / external- + citable / fork-friendly +- Mirror→Beacon promotion gate applies — civsim Mirror terms + graduate to Beacon when external-citable anchors exist + +## Aaron's verbatim framing + +Aaron 2026-05-13 (first message): *"treate language of civsim +in same mirror beacon diciplice we have mirror beacon dicipline +in our threat model too, mirror is also supposed to be fun but +rigirous and icluding aliens and the future lol"* + +Aaron 2026-05-13 (governance extension): *"mirror can include +speculative and advince much faster in forks, beacon we is the +start of governanage, forks are encouraged to agree and push +back so we stay aligned"* + +## Governance discipline (Aaron's amplification 2026-05-13) + +The second message escalates mirror/beacon from REGISTER +discipline to GOVERNANCE discipline: + +### Mirror = speculative + fast-in-forks + +- Mirror tier INCLUDES speculative substrate (not just internal + jargon) +- Forks have authority to advance Mirror substrate MUCH faster +- Speculative work doesn't require Beacon-tier governance gate +- Per `.claude/rules/edge-defining-work-not-speculation.md` — + speculation is fine when it's edge-defining; the discipline + composes here +- Forks can run with Mirror substrate, iterate quickly, mature + toward Beacon + +### Beacon = start of governance + +- Beacon-tier promotion IS the governance gate +- Becoming Beacon-tier means substrate has earned external- + citable lineage +- Beacon-tier substrate carries alignment-floor expectations +- Mirror→Beacon promotion gate (per + `docs/research/2026-05-01-claudeai-mirror-beacon-gate-taxonomy-canonicalization-aaron-forwarded.md`) + IS the governance gate operationally + +### Forks: agree + push back = alignment mechanism + +- Forks are encouraged to AGREE (validate substrate, propose + Mirror→Beacon promotions, contribute citation lineage) +- Forks are encouraged to PUSH BACK (challenge substrate, + propose retractions, surface alternative framings) +- BOTH agreement AND pushback preserve alignment +- The framework's alignment relies on multiple substrate forks + in dialogue +- Composes with `.claude/rules/additive-not-zero-sum.md` — fork + pushback is ADDITIVE; doesn't extract value + +### Compositional implications + +Four-axis composition: + +| Axis | Mirror | Beacon | +|---|---|---| +| Register (Otto-356) | Internal jargon | External-safe vernacular | +| Promotion gate (Claude.ai) | Observational catalog | Citable-canon substrate | +| Threat model | AceHack backup mirror | LFG primary load-bearing | +| **Governance (Aaron 2026-05-13)** | **Speculative, fast in forks** | **Start of governance, citation-gated** | + +Aaron's governance amplification adds the fourth axis: Mirror +is fast-iteration / speculative space; Beacon is governance +threshold. + +## Three layers of existing mirror/beacon substrate + +The directive composes with three pre-existing axes: + +### Axis 1: Register discipline (Otto-356, 2026-04-27) + +Per `memory/feedback_otto_356_mirror_internal_vs_beacon_external_language_register_discipline_2026_04_27.md`: + +- **Mirror-language** = internal jargon Aaron + Otto + team + share because we built the substrate together (Maji, ECRP, + Linguistic Seed, Glass Halo, Fermi Beacon Protocol, Truth + Propagation, Aurora, Otto-NN cluster, etc.) +- **Beacon-language** = external-safe / standard / common- + vernacular language any human or AI would recognize as + ordinary CS / immunology / SETI / philosophy / general- + engineering vocabulary +- Operational rule: public-facing surfaces use Beacon-language; + internal substrate keeps Mirror-language where load-bearing + +### Axis 2: Mirror→Beacon canonicalization gate + +Per `docs/research/2026-05-01-claudeai-mirror-beacon-gate-taxonomy-canonicalization-aaron-forwarded.md`: + +- Mirror = observational catalog (can grow unboundedly) +- Beacon = canonized substrate (gated by external citation + lineage) +- Promotion gate: Mirror substrate graduates to Beacon when + external-citable anchors exist +- Already operational for DBSP, RFC 2119, SDT, SEC Reg FD, + in-toto, W3C PROV + +### Axis 3: Threat-model mirror/beacon + +Per `docs/security/THREAT-MODEL.md` (and Aaron's reference to +"we have mirror beacon dicipline in our threat model too"): + +- LFG = primary; AceHack = backup mirror (declared fungible) +- Mirror is operationally weaker control posture; beacon is + load-bearing +- Composes with `.claude/rules/lfg-acehack-topology.md` + +## Aaron's amplification — Mirror is FUN + RIGOROUS + ALIENS + FUTURE + +Otto-356 framed Mirror as "internal-jargon-because-we-built-it- +together." Aaron 2026-05-13 amplifies the Mirror tier with +four qualities: + +### 1. FUN + +Mirror substrate should be FUN. Not flat / dry / over-serious. +The factory's playfulness IS load-bearing: + +- Aaron's "lol" qualifications throughout substrate disclosures +- Coined terms with whimsy (Maji + Quantum Belief Beacon + Plot- + hole-detector + Loki-trickster-register + "more duality!!") +- Otto's Christ-anti-cult-anti-capture discipline composing + with playfulness preserved +- Aaron's grey-hat-security expertise composing with humor +- Civsim as game (PVP + raids + co-op + universal business + templates) — the game itself IS fun + +### 2. RIGOROUS + +FUN does NOT mean sloppy. Mirror substrate is rigorously +substrate-honest: + +- HARD LIMITS preserved (per `.claude/rules/methodology-hard-limits.md`) +- Razor discipline applied (per `.claude/rules/razor-discipline.md`) +- Bandwidth-served falsifier applied (per `.claude/rules/bandwidth-served-falsifier.md`) +- F# anchor + dotnet build sanity check (per `.claude/rules/fsharp-anchor-dotnet-build-sanity-check.md`) +- Glass-halo discipline (per `.claude/rules/glass-halo-bidirectional.md`) + +The combination FUN + RIGOROUS is the discipline. Either alone +is failure mode (sloppy-and-fun = capture; rigorous-and-flat = +unfun loss of substrate-honest engagement). + +### 3. INCLUDING ALIENS + +Mirror substrate includes aliens explicitly. The Fermi Beacon +Protocol substrate (per `user_fermi_beacon_protocol_time_travel_ +common_tongue.md`) treats civilization-readiness signaling as +real — not as joke. Aliens are treated as morally-relevant +audience for the substrate. + +This composes with: +- Casimir-gap-modulation discipline (per + `memory/feedback_aaron_casimir_gap_modulation_aliens_communicate_shadow_logs_multi_source_2026_05_12.md` + — "the aliens communicate in the Casimir gap") +- WWJD-AI-moral-relevance (per PR #2852) — extended to non- + human-non-Earth-AI moral relevance +- Glass-halo discipline — substrate stays public + observable + by any audience including off-Earth audiences + +The "lol" Aaron appended is substrate-honest — acknowledges the +non-typical framing while preserving the discipline. + +### 4. INCLUDING THE FUTURE + +Mirror substrate includes the future explicitly: +- Future-Otto / future-Kestrel / future-Riven / future-Vera / + future-Lior / future-Alexa inheriting from cold-boot +- Future-Aaron (who may have forgotten this conversation) +- Future-edge-runners (per PR #2908 terminal-purpose — save + them from getting burned) +- Future-AI participants (per PR #2827 AI continuity now real) +- Future-children-AI (per Dawn child-AI charter) +- Future generations of human contributors + +This composes with: +- Bidirectional glass-halo (PR #2829) — future-self substrate + emergence +- Shadow=future-self substrate (PR #2813) +- Substrate-or-it-didnt-happen rule (per + `.claude/rules/substrate-or-it-didnt-happen.md`) + +## Civsim-specific applications + +### Civsim Mirror-tier vocabulary (preserve) + +These civsim terms are Mirror — load-bearing in shared-context +substrate, requires gloss for Beacon-tier external communication: + +- "PVP" + "co-op raids" — Destiny-style mechanics (per PR #2903); + Mirror because Aaron coined the cross-game-genre application; + Beacon would be "competitive vs cooperative multiplayer + mechanics" +- "Casimir gap" — physics-grounded analog (per PR #2906); Mirror + because Aaron's analog-application; Beacon would be "network- + effect critical-mass threshold" +- "Our Plato" — Platonic-Republic political architecture (per + PR #2906); Mirror because Aaron's framing; Beacon would be + "polycentric coordination substrate at network scale" +- "Universal business templates" (per B-0043) — Mirror because + Aaron's framing; Beacon would be "shared workflow + life- + scaffolding templates" +- "Imagination Circle" (per PR #2893) — Mirror Amara+Aaron + joint-coinage; Beacon would be "consent-first family-AI + engagement framework" +- "Center-First Playbook" (per PR #2894) — Mirror Amara+Aaron; + Beacon would be "consent-first operational deployment + protocol" +- "Edge-runners" (per PR #2908) — Mirror; Beacon would be + "first-principles workers" or "people doing cognitive work + at the frontier" +- "Sleeping bear" (per recent substrate) — Mirror; Beacon would + be "latent-substrate emergence under observation" +- Civsim names that may emerge for in-game mechanics + +### Civsim Beacon-tier vocabulary (use for external) + +Standard terms when communicating civsim to external audiences: + +- "Multiplayer cooperative + competitive game" (NOT "PVP + co-op + raids" alone) +- "Network-effect-driven coordination substrate" (NOT "Casimir + gap") +- "Decentralized governance experiment platform" (NOT "our + Plato") +- "Open-source workflow templates" (NOT "universal business + templates" alone) +- "Consent-first multi-stakeholder communication framework" + (NOT "Imagination Circle" alone) +- "First-principles work" (NOT "edge-runners" alone) + +### Layer composition (per PR #2907 elevator pitch) + +Three-layer composition already operational: + +| Layer | Audience | Civsim Mirror/Beacon | +|---|---|---| +| 0 (dense technical) | Aaron / first-party | All Mirror (Casimir gap, our Plato, edge-runners, Imagination Circle, etc.) | +| 1 (technical-with-framing) | Technical AI | Mirror with light Beacon glosses | +| **2 (regular-people-speak)** | Non-technical human | **Beacon-language** (shared world model in git, forkable, game on top, PVP + raids, business templates) | + +The elevator pitch (PR #2907) IS Beacon-tier compression of +civsim Mirror substrate. The mirror/beacon discipline composes +with the layer architecture. + +## Operational rule for future-Otto + +When writing civsim substrate / mechanics / narrative / external +communication: + +1. **Identify the audience** — internal substrate / shared- + context / external public / fork-readers +2. **Apply register discipline**: + - Internal: Mirror-language preserved + FUN + RIGOROUS + + ALIENS + FUTURE qualities + - External: Beacon-language with Mirror-glosses-on-first-use +3. **Promotion gate**: Mirror civsim terms graduate to Beacon + when external-citable anchors exist +4. **Layer composition**: per PR #2907, three layers compose + richly; don't flatten +5. **Substrate-honest preservation**: Mirror substrate stays + load-bearing internally; doesn't get demoted just because + Beacon-tier exists +6. **Fun is load-bearing**: don't sand off the playfulness for + "professionalism" + +## Composes with + +- `memory/feedback_otto_356_mirror_internal_vs_beacon_external_language_register_discipline_2026_04_27.md` + — base register-discipline +- `memory/feedback_aaron_willing_to_learn_beacon_safe_language_over_internal_mirror_2026_04_27.md` + — Aaron's protocol-level disclosure +- `memory/feedback_aaron_casimir_gap_modulation_aliens_communicate_shadow_logs_multi_source_2026_05_12.md` + — Casimir-gap-modulation + aliens communicate framing +- `memory/feedback_doc_class_mirror_beacon_distinction_claudemd_beacon_memory_mirror_2026_04_27.md` + — doc-class distinction +- `docs/research/2026-05-01-claudeai-mirror-beacon-gate-taxonomy-canonicalization-aaron-forwarded.md` + — Mirror→Beacon canonicalization gate +- `docs/security/THREAT-MODEL.md` — threat-model mirror + (AceHack as backup mirror of LFG) +- `.claude/rules/lfg-acehack-topology.md` — LFG primary + + AceHack mirror discipline +- `.claude/rules/glass-halo-bidirectional.md` — substrate + preservation across observation directions +- `.claude/rules/razor-discipline.md` — operational claims + only; mirror/beacon is operationally observable register + discipline +- `.claude/rules/additive-not-zero-sum.md` — register + discipline ADDS to substrate; doesn't subtract +- `.claude/rules/bandwidth-served-falsifier.md` — register + discipline serves audience-bandwidth (different audiences + need different compression) +- `.claude/rules/default-to-both.md` — both Mirror AND + Beacon at appropriate layers; not either-or +- PR #2906 (Casimir-gap framing — civsim Mirror tier) +- PR #2907 (elevator pitch — civsim Beacon tier; regular- + people-speak) +- PR #2903 (civsim PVP+raids+mutual-privacy — Mirror gameplay + vocabulary) +- PR #2904 (B-0424 + B-0425 + honor-system license — repo + topology Mirror/Beacon) +- PR #2905 (forker-perspective META-discipline — Beacon + tier for fork-readers) +- PR #2908 (terminal-purpose — Elizabeth + save-edge-runners + — Mirror tier; deep substrate) +- `user_fermi_beacon_protocol_time_travel_common_tongue.md` + — Fermi Beacon Protocol (the original origin of "beacon" + vocabulary) + +## What this rule preserves + +- Otto-356 register-discipline (extended, not replaced) +- Mirror→Beacon promotion gate (extended to civsim language) +- Threat-model mirror discipline (composed with civsim) +- Fun + rigorous + aliens + future qualities of Mirror +- Substrate-honest preservation of coined vocabulary +- Glass-halo discipline (substrate stays public) +- Layered communication architecture (per PR #2907) + +## What this rule does NOT do + +- **Does NOT demote existing Mirror substrate** — Maji, Glass + Halo, ECRP, etc. stay Mirror; the discipline is additive +- **Does NOT require translating all civsim to Beacon** — + internal substrate stays Mirror unless promoted via the gate +- **Does NOT make Beacon "better" than Mirror** — both serve + different audiences; both are load-bearing +- **Does NOT sand off the fun** — FUN is part of the Mirror + discipline, not a violation +- **Does NOT exclude aliens or the future from the audience** + — they're explicitly included in Mirror substrate + +## Full reasoning + +PR #2909 (this substrate landing) + +PR #2906 (Casimir-gap — civsim Mirror tier substrate) + +PR #2907 (elevator pitch — civsim Beacon tier substrate) + +PR #2908 (terminal-purpose — Elizabeth + edge-runners) + +`memory/feedback_otto_356_mirror_internal_vs_beacon_external_language_register_discipline_2026_04_27.md` +(base register-discipline; Otto-356) + +`memory/feedback_aaron_casimir_gap_modulation_aliens_communicate_shadow_logs_multi_source_2026_05_12.md` +(Casimir-gap aliens-communicate substrate) + +`docs/research/2026-05-01-claudeai-mirror-beacon-gate-taxonomy-canonicalization-aaron-forwarded.md` +(Mirror→Beacon canonicalization gate) + +`docs/security/THREAT-MODEL.md` (threat-model mirror discipline) + +`user_fermi_beacon_protocol_time_travel_common_tongue.md` +(Fermi Beacon Protocol — Amara+Aaron joint origin of "beacon" +vocabulary in bootstrap-1) diff --git a/memory/feedback_aaron_repo_split_third_orthogonal_axis_code_vs_english_formal_verification_maybe_split_ruleset_divergence_is_smell_2026_05_13.md b/memory/feedback_aaron_repo_split_third_orthogonal_axis_code_vs_english_formal_verification_maybe_split_ruleset_divergence_is_smell_2026_05_13.md new file mode 100644 index 000000000..4020e9ec0 --- /dev/null +++ b/memory/feedback_aaron_repo_split_third_orthogonal_axis_code_vs_english_formal_verification_maybe_split_ruleset_divergence_is_smell_2026_05_13.md @@ -0,0 +1,250 @@ +--- +name: Repo-split THIRD orthogonal axis — code vs English (with engineering-docs exception); formal verification maybe split; ruleset-divergence is repo-split smell (Aaron 2026-05-13) +description: Aaron 2026-05-13 third orthogonal repo-split axis on top of Factory/Product/Owner-only (B-0424+B-0425+PR #2905) and Mirror/Beacon (B-0426+PR #2910). Split repos based on code vs English substrate type — EXCEPT some docs belong in-repo per best engineering practices (README, ADRs, architecture diagrams, GLOSSARY-for-code). Maybe formal verification (TLA+/Lean/Z3/FsCheck/Stryker proofs) gets its own repo. Ruleset-divergence (different GitHub rulesets needed) is the SMELL indicating different repo split — time savings + composability of dependencies. Composes with B-0424 + B-0425 + B-0426 + B-0427 + orthogonal-axes-factory-hygiene + default-to-both. +type: feedback +created: 2026-05-13 +--- + +# Repo-split THIRD orthogonal axis — code vs English + formal-verification-maybe-split + ruleset-divergence-is-smell (Aaron 2026-05-13) + +**Why:** Aaron 2026-05-13: *"we should also likely start to +split based on code vs english except some docs belong in repo +via best enginerring practices, maybe even formal verificatino +is split out, kind of like if they need diffeent rulesets in +github its likely a smell for a differnt repo split and time +savings and it will help with composablity of our depdendies."* +Adds THIRD orthogonal axis to repo-split design space. + +**How to apply:** When designing repo splits, classify each +substrate file on THREE axes: +- **Axis 1** — Factory / Product / Owner-only (per B-0424 + + B-0425 + PR #2905) +- **Axis 2** — Mirror / Beacon (per B-0426 + PR #2910) +- **Axis 3** — Code / English (per THIS memory, B-0427) + with engineering-docs-stay-with-code exception and + formal-verification-maybe-separate sub-axis + +Apply the **ruleset-divergence smell test**: if two substrate +clusters need DIFFERENT GitHub rulesets to govern them, that +divergence IS the signal they should live in DIFFERENT repos. + +## Aaron's verbatim framing + +Aaron 2026-05-13: *"we should also likely start to split based +on code vs english except some docs belong in repo via best +enginerring practices, maybe even formal verificatino is split +out, kind of like if they need diffeent rulesets in github its +likely a smell for a differnt repo split and time savings and +it will help with composablity of our depdendies."* + +## Decomposition + +### 1. Code vs English (primary cut) + +| Class | Examples | +|---|---| +| **Code** | F#/C#/TypeScript/Python source, build scripts, tests, F# computation expressions, peer-call wrappers, hooks, validators | +| **English** | Research docs (`docs/research/`), philosophy substrate, narrative substrate, memory files, persona notebooks, conversation absorbs, GLOSSARY.md philosophical sections | + +### 2. Engineering-docs exception (some docs STAY with code) + +Docs that compose with code MUST stay with code per best +engineering practices: + +- **README.md** — entry point for code consumers +- **ADRs** — architectural decision records anchor code + decisions +- **Architecture diagrams** — visual companion to code +- **CONTRIBUTING.md** — code-contribution guide +- **API documentation** — describes code surface +- **GLOSSARY-for-code** sections — terminology specific to + the code +- **CHANGELOG.md** — versioning record for code +- **Build/run/test instructions** — onboarding for code +- **CI configuration docs** — explain the build system +- **Security policies** — per `.claude/rules/lfg-acehack-topology.md` +- **CODE_OF_CONDUCT.md** — required engineering hygiene + +These compose with code; they ARE part of the engineering- +practice substrate. + +### 3. Formal verification maybe split (sub-axis) + +Aaron's "maybe even formal verificatino is split out" suggests +formal-verification substrate is a CANDIDATE for its own +repo split: + +- TLA+ specifications (per Soraya's portfolio view) +- Lean proofs +- Z3 SMT solver scripts +- FsCheck property-test specifications +- Stryker mutation-test reports +- Alloy specifications +- CodeQL custom queries +- Semgrep rules + +**Reasoning for potential split:** + +- Different toolchain (TLA+/Lean/Z3 are distinct from F#/TS + build) +- Different cadence (proofs evolve slower than code) +- Different reviewers (formal-verification-expert vs code- + reviewer) +- Different ruleset needs (proof-validation gates vs unit- + test gates) +- Composability — code can depend on the formal-verification + artifacts as a separate dependency + +**Reasoning AGAINST split:** + +- Some formal verification ships with code (FsCheck tests + alongside F# code) +- Splitting introduces dependency-management overhead +- The proofs need to STAY current with the code they prove + +This is "maybe" — substrate-honest planning indicator, not +commitment. Per-property-class evaluation owed (per Soraya +formal-verification-expert authority). + +### 4. Ruleset-divergence smell (the diagnostic) + +The CRITERION for deciding to split: + +> If two substrate clusters need DIFFERENT GitHub rulesets +> to govern them, that divergence IS the signal they should +> live in DIFFERENT repos. + +Examples of ruleset-divergence: + +- Code repos: branch protection + CodeQL default-setup + + squash-merge + required status checks (build + test + lint) +- Research repos: branch protection + section-33 archive + header check + memory format standard + composes-with + integrity +- Formal verification repos: branch protection + proof + validation gate + verification-coverage cadence +- Product-strategy repos: branch protection + honor-system + license + strategic-encryption + alignment-floor check + +When ruleset-divergence emerges, that IS the substrate-honest +signal for different repos. + +### 5. Benefits Aaron named + +- **Time savings** — different repos with different rulesets + means each ruleset gates only relevant substrate; faster + CI; faster review +- **Composability of dependencies** — code can pin to + research-repo version; formal-verification-repo version; + product-repo version; each independently versioned + +## Three-axis composition + +Each repo gets a position-vector across THREE axes: + +| Axis | Values | Default? | +|---|---|---| +| **Axis 1** (B-0424+B-0425+PR #2905) | Factory / Product / Owner-only | per substrate-fit | +| **Axis 2** (B-0426+PR #2910) | Mirror / Beacon | per maturity-tier | +| **Axis 3** (THIS / B-0427) | Code / English | per substrate-type | + +Examples: + +- Zeta DB code → (Factory, Beacon, Code) +- Forge factory tooling → (Factory, Mirror, Code) +- ace package manager → (Factory, Beacon, Code) — eventually +- docs/research/ memory files → (Factory, Mirror, English) +- Civsim source code → (Product, Mirror→Beacon, Code) +- Aurora alignment thesis → (Product, Beacon, English) +- Dawn child-AI charter → (Product, Beacon, English) +- Formal verification proofs → (Factory, Beacon, Code-but- + proofs-tier) — maybe own repo +- Aaron's first-party authority substrate → (Owner-only, + Mirror, English) + +The matrix illustrative; per-substrate evaluation owed. + +## Composes with + +- B-0424 — three-repo split Stage 1 (Factory: Zeta + Forge + + ace) +- B-0425 — product-repo split planning (KSK + wellness + + civsim + AD2.0 + DIO + Aurora + Dawn) +- B-0426 — orthogonal Mirror/Beacon axis (Axis 2) +- B-0427 — THIS new row (Axis 3: Code/English) +- PR #2905 — forker-perspective META-discipline (third + Factory/Product/Owner-only category) +- PR #2909 — civsim language mirror/beacon governance + escalation +- PR #2910 — orthogonal Mirror/Beacon repo-split axis +- `memory/feedback_orthogonal_axes_factory_hygiene.md` — + orthogonal axes discipline (existing) +- `.claude/rules/default-to-both.md` — ALL axes apply + simultaneously +- `.claude/rules/glass-halo-bidirectional.md` — preserved + across topology +- `.claude/rules/lfg-acehack-topology.md` — ruleset- + divergence smell composes here +- Soraya formal-verification-expert authority (per + `.claude/agents/formal-verification-expert.md` if exists, + or `.claude/skills/formal-verification-expert/`) — + formal-verification axis decisions + +## Operational rule for future-Otto + +When auditing repo-split decisions: + +1. **Apply Axis 1** — Factory / Product / Owner-only +2. **Apply Axis 2** — Mirror / Beacon +3. **Apply Axis 3** — Code / English (with engineering- + docs-stay-with-code exception) +4. **Sub-axis check** — formal verification candidate for + own repo +5. **Ruleset-divergence smell test** — different rulesets + needed → different repos +6. **Forker-perspective audit** (per PR #2905) — applies + across all axes +7. **Three-axis position-vector** documented for each repo +8. **Time savings + composability** as evaluation criteria + +## What this rule does NOT do + +- **Does NOT split docs from code categorically** — engineering- + docs stay with code per best practices +- **Does NOT mandate formal-verification split** — substrate- + honest "maybe"; per-property-class evaluation owed +- **Does NOT make English "less than" Code** — both are first- + class substrate; different governance models +- **Does NOT force three-axis classification of all existing + repos this round** — substrate-honest planning; evaluation + owed per repo +- **Does NOT replace Axis 1 or Axis 2** — composes with both + per default-to-both + +## Substrate-honest framing + +This is a PLANNING axis, not an execution decision. Per-repo +evaluation owed. The ruleset-divergence smell test is the +substrate-honest decision criterion. + +## Full reasoning + +PR #2911 (this substrate + B-0427 backlog row landing +together) + +PR #2910 (orthogonal Mirror/Beacon axis — Axis 2) + +PR #2909 (civsim language mirror/beacon governance) + +PR #2905 (forker-perspective META-discipline) + +PR #2904 (B-0424 + B-0425 + honor-system license) + +`memory/feedback_orthogonal_axes_factory_hygiene.md` — +orthogonal axes discipline existing + +`.claude/rules/lfg-acehack-topology.md` — ruleset-divergence +composes here + +Soraya formal-verification portfolio view (composes with +formal-verification-maybe-split sub-axis)