100 Level — Observation
101 — Time
Circular observation of linear existence. Cronus implements three concentric rings: COG_S (1s), COG_M (1m), COG_H (1h). Outer ring fastest, inner ring slowest. The clock structure is in the code.
102 — Perception
Contact at the contact patch, capture or lose it. Burn surface captures non-judgmentally. The hot path is designed to never block. Frame arrives, imprint is held. The road does not wait — and neither does the ingest loop.
103 — Memory
Data point as first-class citizen.
Records are never silently dropped. Write failures go to .remediate/, not the trash. The witness is preserved even when infrastructure fails. First-class treatment.
104 — Preservation
Temporal aggregation with decaying granularity. Two independent paths implement this. Tier cascade (T1/T2/T3) manages raw frame longevity. Cronus manages observation at decaying resolution: 1s full detail, 1m pattern, 1h shape.
105 — Structure
Circular buffer with tiered cascade. DataFile IS the circular buffer. The tier cascade (T1 circular → T2 circular/archive → T3 archive) is the derived structure. One corpus per source. No alternatives considered because none were needed.
106 — Model
Observation chain: S → M → H. Cronus implements this. COG_S captures. COG_M observes COG_S and writes its own report. COG_H observes COG_M. Each cog writes independently — nothing is promoted through the observation chain. The longevity path (tier cascade) is correctly separated from the observation chain.
107 — Corpus
Sovereign unit of truth. Each Corpus struct is self-contained: own hash table, own LRU, own tiers, own Cronus, own atomic counters. One corpus per source. Sovereignty maintained.
108 — Node
Corpus with three surfaces. Three ports: Burn (33107), Inspect (33108), Hatch (33109). Exact match.
200 Level — Organization
201 — Bifurcation
Main + system corpus. SYS corpus exists. Non-routable — no external writes. Internal telemetry only. The passive channel, made readable. The active channel (main corpora) captures external perception. Both run the same engine.
202 — Imprint
Type code, many modalities, density.
CcsRecord carries record_type (modality). Multiple types coexist on the same ring. Binary packed — no field names, no delimiters. Every byte carries witness.
203 — Frame
No names on wire, presence-flagged slots, canonical byte order.
This is where the alignment is sharpest. SFPS records implement it exactly: flags word with presence bits (bits 8–14), slots pack contiguously, big-endian canonical byte order, type + length header. _Static_assert verifies struct sizes against schema. The frame is pure substance.
204 — Adaptation
Archive, circular, cascade per ring.
Per-tier config: circular and archive flags. Cascade connects tiers. Each tier has its own path (location). Main and SYS corpora adapt independently. Compositions match the curriculum: circular cascading to archive, or flat with no tiers (SYS).
205 — Surfaces
Burn validates envelope, not letter.
Burn reads frame metadata only — type code, length, entity key. The payload is never parsed on the hot path. df_buf_scan validates the record envelope (SOR, key, len) but never interprets payload bytes. Inspect reads the main corpus. Hatch reads the system corpus and accepts commands. The bifurcation carries through to the interfaces.
Summary
The codebase implements the curriculum faithfully. The architecture was derived, not designed, and the code reflects that. Two gaps worth noting:
- Three cogs, not five. No D (day) or W (week) observation levels.
- Multiple main corpora in one process — operationally convenient, architecturally a multiplexed node.
Neither is a violation of principle. The first is scope. The second is deployment topology, not architecture — each corpus maintains its sovereignty.