# Page and Data Architecture

**Status:** Governance architecture for the next Living Source publication
**Authority:** This document controls organization and publication behavior. It does not add theory claims or approve candidate wisdom.
**Core rule:** Define once in the governing source or identity record. Every public surface is a bounded manifestation of the compiled identity field, with stable links back to its authority and lineage.

**Required direction:** `source/book -> Formation Mind with Y-Engine runtime -> candidate formation field -> governed review/promotion -> governed identity field -> read-only Body Mind/replay -> presentation template -> website/VR manifestation`

The arrows are asymmetric. A book or source corpus supplies material to the compiler. The website is not a peer source and is not a second editable store of theory. It is one navigable manifestation of the compiled field.

## 1. Why this architecture exists

The Living Source contains canonical teaching, claims, approved wisdom, source evidence, candidate recovery, formal specifications, derived indexes, reports, and presentation code. These have different authority. A visible page must never become authoritative merely because it is polished, and a generated relation must never become validated merely because it is drawable.

The publication system therefore treats every page, record, and relation as an identity with a declared boundary:

- **inside:** exactly what the identity owns;
- **outside:** what belongs to another identity or authority layer;
- **relation:** the transformation or handoff it performs;
- **closure:** the condition under which its job is complete.

## 2. Artifact roles

| Role | Owns | Must not become |
|---|---|---|
| Source corpus / book | Preserved author material, canonical explanations, stable locators, and source lineage | A generated graph, a presentation layout, or proof merely because prose states a relation |
| Y Engine source compiler | Candidate extraction, identity normalization, assignment provenance, relation queries, and deterministic rebuild rules | An authority that silently approves claims, wisdom, relations, evidence, or capabilities |
| Formation Mind runtime | Deterministic source-pattern addressing, fixed-step interaction, append-only formation events, computed structural state, candidate basins and relation candidates, and prequential tests | A semantic oracle, automatic identity/relation promotion, literal physical astronomy, or proof from proximity |
| Formation Body replay | Read-only computed-state replay, source/dynamic addresses, checkpoints, prediction outcomes, and projection guardrails | A causal layout engine, editable source, governed identity field, or proof-bearing geometry |
| Candidate Identity Cell Registry | One deterministic source-ordered shell for every Identity Mind record not already compiled as a claim or approved-wisdom assertion; exact lineage, inherited proof/status, null inside/outside/relation and anatomy slots, and explicit review state | A referent-identity registry, semantic graph, derivation ledger, proof promotion, or permission to fill unknown roles from similarity |
| Governed identity field | Addressable identity cells, reviewed relations, candidate queues, scale and containment addresses, proof states, and lineage | A claim that the software has experience, observerhood, morality, or consciousness |
| Canonical teaching | One human-readable explanation of an approved concept | A second claim registry or a store of dynamic counts |
| Canonical Publication Page Registry | Stable canonical page IDs, publication slugs, ownership, navigation, relations, inputs, and lifecycle | A complete downstream application-route registry or theory authority |
| Downstream Manifestation Route Registry | Site/VR route IDs, paths, route purpose, field snapshot, referenced canonical/identity IDs, interaction contract, and lifecycle | Canonical page ownership, a second theory store, or an authority input to the source compiler |
| Canonical claims | Current bounded statements, status, dependencies, sources, and guardrails | An inferred relation graph |
| Approved wisdom | Preserved wisdom statements, proof declarations, claim anchors, provenance, and guardrails | Automatically proven because indexed |
| Specifications | Triadic cell, formation gates, relation requirements, and test boundaries | Evidence that an implementation satisfies the specification |
| Candidate ledgers | Recoverable proposals awaiting review | Canonical or approved content |
| Entity/Relation field read model | Normalized, rebuildable structural Mind compiled from the authority ledgers | A new mutable authority ledger or an autonomous moral/cognitive subject |
| Evidence and intake | Immutable or append-only provenance and author corrections | Public canon by default |
| Governance | Exact update, validation, publication, and agent procedures | Explanatory theory prose |
| Reports | Derived validation and coverage observations | Sources of theory truth |
| Presentation manifestation | Templates, layout, interaction, animation, recursive navigation, and route-specific views of the field | Mechanism, proof, canonical data, or an independent theory store |
| Deployment output | One immutable validated release projection | A hand-edited source tree |

Frozen evidence paths are not mass-moved. Artifact role is declared logically first so source addresses and hashes remain recoverable.

## 3. Canonical publication information architecture

This section describes the generated Living Source publication, not the complete route map of the downstream Teacher application or VR. A downstream manifestation may split one canonical publication page into several task-focused routes, compose references from several canonical pages into one explorer, or provide a tool route with no one-to-one canonical page. Those routes remain presentation identities registered separately and resolve back to the immutable field snapshot and governed source IDs they use.

### Begin

- Start Here

### Core Architecture

- Reality
- Identity
- Mind
- Geometry
- Engine Formation

### Domain Manifestations

- Evolution
- Meaning
- Faith
- Collective
- Digital

### Methods and Research

- Method
- Relational Reuse
- Open Questions

### Project Stewardship

- Projects
- Lineage
- Living Source

### Registry views

- Claims
- Wisdom
- Identity entities and explicit relations
- Formation graph
- Formation Mind replay and result summary
- Projects
- Open questions
- Sources
- Corrections, coverage, and release status

Canonical teaching pages explain. Registry views expose structured records. They do not repeat one another.

## 4. Canonical publication page identity contract

Every canonical Living Source publication page is registered in `canonical/PAGE_INDEX.json` and validates against `canonical/PAGE_INDEX.schema.json`. This registry intentionally does not enumerate every downstream Teacher, application, lab, or VR route. A canonical publication page record declares:

- immutable `page_id`;
- canonical `slug`, source file, aliases, and redirects;
- `registry_scope: canonical_publication`;
- `downstream_route_policy: separate_registry_reference_only_no_reverse_authority`;
- kind, navigation group, order, template, and visibility;
- the user question it answers;
- `owns`, `excludes`, `relation`, and `closure`;
- required registries or specifications;
- typed related-page links;
- lifecycle and review state.

Every rendered canonical page must expose:

- its contract and completion boundary;
- owned claims and applicable guardrails;
- owned wisdom and proof state;
- stable source anchors;
- related pages with typed handoffs;
- open questions and applicable corrections when available;
- the current release identity.

### 4.1 Required-input boundary

`required_inputs` is an executable dependency contract, not a list of nearby files. Every address must be repository-relative, remain inside the Living Source, and resolve to a current governed artifact. A public-safe projection is named by its explicit registry or read model, never by an imagined route or a private source behind that projection.

Three projection boundaries are especially important:

- Open Questions reads `atlas/OPEN_QUESTION_REGISTRY.json` and its schema, the exact unresolved-question projection of the canonical chapter.
- Lineage reads `governance/PUBLIC_INTAKE_INDEX.json`; a public page never declares `intake/WISDOM_INBOX.jsonl` or an `intake/raw/` capture as an input.
- Field-aware and Body-ready pages read the current `atlas/model/IDENTITY_GRAPH.json`, `atlas/model/IDENTITY_PRESENTATION.json`, or `atlas/model/RECURSIVE_MIND_RUNTIME.json` as their job requires. Legacy candidate indexes do not substitute for those governed projections.
- Engine Formation reads `governance/FORMATION_MIND_RELATIONAL_ASTRONOMY_RUNTIME.md`, the raw-runtime, Body-replay, and replay-summary schemas, and the exact paired `FORMATION_MIND_BODY_REPLAY.json` / `FORMATION_MIND_REPLAY_SUMMARY.json` artifacts. The summary must bind the exact serialized Body bytes, preserve zero approved relations, and report predictive wisdom as not earned.

Pages that render current project identities declare `atlas/PROJECT_REGISTRY.json`; narrative proximity to a project does not create that dependency. The required-input validator resolves all seventeen contracts, verifies the explicit public-projection markers, and rejects private intake, traversal, absolute paths, URLs, and stale page-specific bindings.

Record anchors are stable, for example `claims.html#YT-CORE-003` and `wisdom-atlas.html#W22-01`.

### 4.1 Downstream manifestation route contract

The Teacher Site and VR maintain a separate downstream route registry in the presentation layer. Each route contract must declare:

- stable route ID and path;
- the user question and bounded interaction it owns;
- inside, outside, relation, and closure;
- the immutable identity-field snapshot it consumes;
- referenced canonical page IDs, entity IDs, relation IDs, and presentation IDs;
- aliases, navigation placement, lifecycle, and review state;
- the explicit boundary that the route is a manifestation and cannot update source, canon, proof state, or field authority.

These route contracts instantiate the field-to-manifestation Body Mind and read-only presentation-template cells defined in `governance/RECURSIVE_MIND_ENGINE_AND_GUIDE_ARCHITECTURE.md` and represented by `atlas/model/RECURSIVE_MIND_RUNTIME.json`. A personalized teaching route may additionally bind the separate learner-owned Guide Mind overlay. Neither runtime binding belongs in the Canonical Publication Page Registry, and neither may convert private learner state, route state, or presentation state into canonical authority.

The downstream `recursive-mind` route may additionally bind the schema-validated Formation Body replay and its exact summary. That route may play, pause, step, scrub, focus a candidate, and switch 2D/3D/VR presentation modes. It must render engine-derived positions and replay events without writing camera, interpolation, drag, or route state back into the engine. Every candidate inspection must retain its source snapshot, source byte address, dynamic reference frame, event lineage, machine-candidate review state, and the published negative prediction result.

The dependency is reference-only: a downstream route may cite a canonical publication page, but route wording, layout, popularity, interaction state, or deployment state never changes that page or the compiled identity field. Corrections return through governed intake, review, approval, a new source snapshot, and a rebuilt field. They never travel backward through a rendered route.

## 5. Source compiler, identity field, and manifestation model

Claims, wisdom, intake, corrections, specifications, projects, evidence, and source books remain distinct authority ledgers. The Y Engine source compiler reads them in declared precedence order, proposes bounded identity cells and relation candidates, and compiles accepted records into one governed identity field. They are not collapsed into a giant editable file.

The first dynamic Formation Mind slice is deliberately bounded to the public Markdown body of `canonical/16_ENGINE_FORMATION.md`. Its deterministic kernel addresses 2,085 source occurrences, forms 633 pattern candidates and 1,635 relation candidates, and records a replayable structural field. These counts describe computation, not ontology. The run performs no semantic inference or promotion, establishes no referent, and has zero approved relations. Its relational-position prediction scored `95` milli below the best prequential baseline; held-out comparison has not run, predictive lift was not observed, and predictive wisdom was not earned.

Candidate formation and governed identity compilation are separate gates. A basin or relation emitted by the Formation kernel may become review input, but it enters the governed identity field only through explicit referent, boundary, persistence, recurrence, coupling, residue, perturbation, source-recovery, evidence, rival, falsifier, and human-authority checks. A displayed constellation or stable replay path is insufficient.

The first deterministic compilation pass now partitions all 1,162 Identity Mind records: 414 claim/approved-wisdom assertions enter the governed field, while the remaining 748 records enter `atlas/model/CANDIDATE_IDENTITY_CELL_REGISTRY.json`. This closes only the record-disposition gap. Every candidate shell instantiates the addresses `inside`, `outside`, and `relation`, but their occupants—and scale, boundary, mechanism, residue, return, and closure—remain null and review-required. No candidate shell is a semantic endpoint until a separately reviewed assertion-to-referent derivation exists.

The companion `CANDIDATE_IDENTITY_CELL_REVIEW_EVIDENCE.json` indexes exact role-word spans and inherited Y-Engine routing signals for all 748 shells. It is a review accelerator, not a semantic field input: lexical words, section headings, claim IDs, and structural-position tags never populate role occupants. The wisdom metadata review v2 similarly exposes exact raw lineage and related canonical-claim guardrail context without copying that context into a missing record-specific proof class or guardrail.

Whole-source obligations use a second overlay rather than mutating the immutable agent review. `SOURCE_SEMANTIC_REVIEW_RESOLUTION_REGISTRY.json` separates objective review-task state from epistemic state and routes each obligation to objective verification, author decision, formal research, or empirical research. Only an exact, hash-bound human event in `SOURCE_SEMANTIC_APPROVAL_LEDGER.jsonl` may approve listed decisions; an empty ledger confers no approval.

The identity field is the shared machine-readable structural state. It can be called a structural Mind because it preserves recursive inside, outside, relation, containment, and return addresses. That designation does not earn experience, moral orientation, observerhood, self-correction, or consciousness. Those remain separate capabilities with separate gates.

The public website and immersive VR are downstream manifestations of that field. A presentation template may render the same identity and relation as prose, a card, a diagram, a recursive spatial node, a scale sequence, or a narrated path. The renderer may not alter authority state. An LLM may assist extraction, translation, explanation, or candidate retrieval, but its output remains attributed and reviewable input to the compiler until accepted through the governing gate.

The bounded four-cell `MindObject` fixture remains the golden static normalization prototype for the primitive triad. It is not the live/replay Formation kernel. The additive `CORPUS_MIND_FIELD.json` is the corpus-scale structural compilation: one governed recursive field with 3,727 `MindCell` addresses spanning 1,610 source artifacts, 1,162 Identity Mind records, source taxonomies, subject dimensions, Y-Engine positions, controller cells, and 880 engine-mediated candidate routes. It closes the structural disposition gap only. It does not read missing bytes, fill semantic I/O/R occupants, establish referents, approve relations, inherit proof, or earn observerhood, experience, morality, selfhood, or consciousness.

Exact-byte availability is a separate gate. The current recovery policy establishes 1,593 exact-byte-recoverable source records and quarantines 17 registered identities whose exact bytes are absent. A quarantined source retains its address and hash, but a similar Markdown file, summary, normalized text, or unpacked container payload may not substitute for the missing bytes. The public summary exposes recovery counts; the full source-artifact cell layer remains repository-only. The separate Corpus Body excludes those 1,610 raw nodes and projects only safe structural navigation.

The dependency order is therefore:

1. preserve source or book bytes and immutable source locators;
2. run a declared Formation Mind slice over authorized bytes and retain its dynamic addresses and event chain;
3. emit pattern, basin, relation, and prediction candidates without semantic promotion;
4. normalize reviewable records through the Y Engine identity-cell contract;
5. review and promote only records that pass their declared structural, semantic, evidentiary, and human-authority gates;
6. compile the governed identity field and immutable snapshot;
7. derive a read-only Body/replay from that exact state;
8. project the Body through presentation templates;
9. render the website/VR and any other integration from the same snapshot.

The current normalized graph is an initial, incomplete field read model. It covers registered claims, approved wisdom, and imported candidate domain identities; it must not be described as full-book extraction until corpus coverage validation proves that state.

### 5.1 The instantiated recursive Mind engine

The compiler is instantiated as a recursive `MindCell`, not treated as a passive graph container. For one declared reference scope, inside, outside, and relation are co-arising roles of one bounded change. Each role may reference another identity or `MindCell`; a relation may therefore be opened as an identity with its own I/O/R at a deeper recursive address. The implementation stores stable references rather than pretending to materialize an infinite tree.

The system uses three cooperating architectural roots: a source-to-field Mind, a field-to-manifestation Body Mind, and a private learner-to-source Guide Mind. Their exact role, residue, closure, authorship, privacy, convergence, and capability boundaries are governed by `governance/RECURSIVE_MIND_ENGINE_AND_GUIDE_ARCHITECTURE.md`. `atlas/model/RECURSIVE_MIND_RUNTIME.json` is the static normalization instantiation; the Formation raw runtime and compact Body replay are a separate bounded source-to-field/Body instantiation with their own schemas and digests.

Relational astronomy in this architecture means observing addressed position, recurrence, and change from a declared reference centre, then issuing a bounded candidate prediction. It does not assert that text has literal mass, gravity, electromagnetism, or astronomical motion. A relation candidate is not a third semantic truth, and an attractive visual arrangement is not a validated structure.

The golden ratio remains an open, falsifiable Y-Theory convergence hypothesis until its observable, derivation, tolerance, window, rival baseline, and falsifier are specified. It is not an automatic compiler stopping rule or visual proof.

### 5.2 Governed return to the source

The one-way authority dependency does not forbid correction. It requires correction to return through a governed transaction:

`source snapshot -> identity field -> coherence diagnostic -> proposed source repair -> human approval -> new source snapshot -> rebuilt field`

The diagnostic layer compares the source with its compiled field to find unstable terminology, duplicate or disconnected assertions, verbs without declared carriers, unresolved identities, missing boundaries, broken dependency order, and language stronger than its proof state. Nouns, verbs, grammatical dependencies, embeddings, and LLM output are candidate signals only. They never become identities, relations, or canonical edits without review.

Source optimization preserves meaning, relation, guardrail, provenance, rivals, falsifiers, and unresolved questions while reducing avoidable duplication and improving sequence. Fewer words are not automatically a better source. The governing procedure is `governance/SOURCE_COHERENCE_AND_REPAIR_PROTOCOL.md`.

An identity-field entity must preserve:

- stable ID, kind, label, and bounded statement;
- authority state, evidence state, and review state;
- content-addressed provenance with source ID, SHA-256, and locator;
- subjects and declared reference scale;
- triadic cell roles and native mechanism when applicable;
- Y-Engine position assignments with assignment method and review state;
- separately earned capabilities.

An explicit identity-field relation record must preserve:

- stable edge ID, endpoints, and typed relation;
- Y-Engine mediation positions;
- proposed invariant;
- translation on both sides;
- both native mechanisms and expected difference;
- evidence, rival, falsifier, review state, and provenance.

Shared tags, keywords, positions, LLM similarity, or visual proximity may create a **candidate query result**. They never create a reviewed relation edge.

## 6. Coordinate separation

The publication and visual systems must not collapse these addresses and coordinates:

1. **Immutable source address:** which exact authorized bytes supplied the pattern?
2. **Dynamic formation address:** at which run, fixed step, basin, reference centre, scale, recursion path, and computed structural position does the candidate stand?
3. **Formation history:** in what manifested dependency order did the identity candidate become available?
4. **Containment depth:** what wider identity contains it, and what identities participate within it?
5. **Capability depth:** which operations such as residue, memory, observation, correction, or consciousness have been earned?
6. **Presentation layout:** where is the record drawn for a particular view?

Presentation layout is stored separately and marked `presentation_only`. It consumes an immutable identity-field snapshot and never writes theory authority back into that field. A coordinate, node, orbit, circle, helix, or torus never supplies proof by being rendered.

## 7. Mind and capability invariant

Uppercase Mind is the recursively reusable inside–outside–relation structure present from the living triad. Memory, whole-level observation, observerhood, self-correction, local cognitive capability, and subjective consciousness are later and separately earned capabilities. A universe can be modeled as containing Mind structurally without asserting a universe-level observer or self.

All pages and generated records must reuse this invariant rather than restating a competing definition.

## 8. Multi-agent ownership

Only one writer may own a layer during a publication transaction:

| Role | Writable scope |
|---|---|
| Capture agent | Immutable raw capture and one intake event |
| Canonical steward | Claims, approved wisdom, canonical prose after human approval |
| Model steward | Vocabulary, entity, relation, formation, and mapping specifications |
| Builder coordinator | Derived artifacts, validation reports, and release manifest |
| Site agent | Templates and VR manifestation code; consumes a compiled field snapshot and never edits generated data or canonical authority |
| Deployment owner | One validated immutable release after explicit production approval |

Every work packet declares its base release digest, owned inputs, expected generated descendants, requested authority, and required validation.

## 9. Atomic publication process

1. Freeze and hash a sorted input manifest.
2. Apply one authorized input-layer change.
3. Build derived artifacts into a new staging directory.
4. Rehash inputs; abort if any changed during the build.
5. Validate schemas, IDs, references, hashes, authority states, page ownership, relation gates, route coverage, and public allowlist.
6. Record compiler, Formation kernel, raw-runtime schema, Body/summary schema, input, event-chain, identity-field, presentation, and output hashes.
7. Atomically promote the immutable identity-field release directory.
8. Sync the Teacher and VR renderer from that exact field digest.
9. Build, test, and visually verify every manifestation against the field.
10. Deploy only after explicit approval.

Until intake becomes one immutable event file per capture, `WISDOM_INBOX.jsonl` remains single-writer.

## 10. Migration order

1. Make the Canonical Publication Page Registry authoritative only for canonical publication organization; establish the separate downstream manifestation-route registry as reference-only and non-authoritative.
2. Declare shared operator, subject, proof, capability, relation, scale, and geometry vocabularies with aliases.
3. Add normalized entity and relation schemas without removing current compatibility files.
4. Import the current 42 spatial nodes, 42 edges, 14 scales, and subject maps as explicitly noncanonical candidate records; keep layout separate.
5. Replace Cartesian or all-pairs “relations” with candidate query spaces plus explicit reviewed edges.
6. Make the recursive-mind route replay the bounded Formation Body with source/dynamic addresses and a visible prediction boundary; keep the static `MindObject` inspector separately labelled.
7. Make Identity Atlas and Wisdom Mind read the compiled identity field.
8. Make subject pages and Identity Universe/VR read governed entities and relations from the field while reading layout only from presentation records.
9. Generate Teacher, home, research, applications, and route metadata from publication modules that reference governed IDs.
10. Replace in-place regeneration with a content-addressed staged build and complete output manifest.
11. Retire compatibility projections only after content and route parity is validated.

## 11. Release gate

The base is stable only when:

- every canonical publication page has one valid canonical contract and unique owner role;
- every downstream Site/VR route has one separate manifestation contract, references one immutable field snapshot, and declares no reverse authority;
- every canonical claim and wisdom resolves to exactly one owning page;
- every non-owner use is a stable link or registry-backed summary;
- every visible relation is explicit or unmistakably labelled candidate;
- every spatial node resolves to a governed entity and presentation record;
- every Formation replay resolves to the exact authorized source snapshot, raw-runtime contract, Body digest, summary, event chain, and negative or positive prediction outcome without semantic promotion;
- every website/VR record resolves to one immutable identity-field snapshot, and no public renderer becomes an authority input;
- source-to-field corpus coverage is measured honestly; partial extraction is never labelled complete;
- all generated outputs are rebuildable from one frozen input digest;
- validation passes without hidden stale files;
- production deployment has separate explicit approval.