Omega Engine — Whitepaper.

Abstract

Omega is a sovereign, self-building code engine. Logic is canonical — stored as content-addressed contracts on a frozen address space. Source code is disposable output, emitted deterministically from each contract's logic-IR by per-tier templates. The engine ingests real code, decouples it into shared single-responsibility atoms addressed by a frozen CNAE vocabulary, gates every contract through an immune system (sovereign imports, no stubs, no inline logic at T2+, real logic density, CNAE-valid), autowires emergent compositions across sources, and re-emits the entire source tree from contracts on demand. The DNA store is the only source of truth; the rendered code can be wiped and recovered byte-identically.

This whitepaper is itself an emit — it was rendered from a template against the live logic-base. The numbers above are the engine's current state, not a snapshot from press time.

§ 1The One Principle

Logic is the only source of truth. Code is a deterministic projection of it.

• Truth lives in logic-base/ as atomadic.logic_block.v1 DNA, with real evidence.source.
• Everything in src/atomadic/ is emitted from that DNA — disposable, regenerable, never authored by hand.
• A drifted or sabotaged file cannot survive a single re-emit, because the emit is a pure function of the logic.

Because each atom's name encodes its location (action_entity_scope), the engine never needs a stored dependency graph. It computes every import from the callee's name. A tiny compliant seed can assemble the whole tree because composition is implicit in the names.

§ 2Architecture

2.1 The Tier DAG

Imports go downward only — never same-tier or upward. This is mechanically enforced.

2.2 CNAE — Names as Addresses

Every atom is named action_entity_scope. 54 frozen actions, 12 frozen scopes. Scope fixes the tier. Frozen so addresses are stable → auto-wire, dedup, and reuse all work.

The live per-action histogram is emitted alongside this document at ATOMS.md in the engine docs suite; it changes every cycle as the engine grows.

2.3 The Immune Gate

Every contract must pass before emit:

1. Sovereign imports — T0–T4 may import only stdlib + atomadic.*. No external dependencies in the core.
2. No stubs, no echo-shells — no NotImplementedError, no pass # TODO, no template bodies.
3. No inline logic at T2+ — T2 and above compose, they do not implement. Implementation lives at T0/T1.
4. Exactly one public callable — one function per file.
5. Real logic density — bodies are checked for substantive AST node counts vs trivial echoes.
6. CNAE-valid — name decomposes into a known action + entity + scope.

Harvest is permissive on the name (we will reclassify a bad name from the source/docstring) but strict on the logic. The engine never accepts a stub.

2.4 Self-Build

The engine implements every capability an agent can perform, as a native atom:

• synthesize_atom_composite / orchestrate_atom_synthesis_temporal — author + gate + emit a new atom from intent
• orchestrate_corpus_harvest_temporal — absorb an entire codebase, deduped by typed address + content hash
• orchestrate_chain_autowire_temporal — discover emergent compositions across sources
• orchestrate_store_closure_repair_temporal — quarantine atoms whose imports cannot resolve, until closure is green
• orchestrate_dna_reemission_temporal — re-render the whole engine from DNA, byte-identical

The engine can sit and run all of these on its own. A missing capability is the next thing to emit (Axiom 2 — invent it).

§ 3Sovereignty Invariants

• Determinism — the same DNA renders the same bytes. Verified byte-identical via shadow-twin replication.
• Closure — every contract's dependencies resolve strictly downward; verified by omega_validate.
• Sealed IP — value-blind capsules in logic-base/codex_keeper/ never enter general atoms.
• Hermetic gate — .atomadic/enforcement/validate_dna_store_effectful.py re-runs the immune system on demand.

Current verdict: loading from /.well-known/atomadic-closure.json…

Verify yourself: pull /.well-known/atomadic-closure.json and check the Ed25519 signature against /.well-known/atomadic-issuer-pubkey.json. The omega-verification-kit does it offline in five lines.

§ 4The Three-Workspace Topology

A read-only hook enforces emit-only on src/atomadic and DNA across all three.

§ 5Documentation as Emit

This document, like every other in the suite, is itself an emit. The doc generator (orchestrate_documentation_suite_temporal) reads the live logic-base, builds a context variable map from the truth, and renders templates from C:\Atomadic-Compliant\docs\_templates. After major emits or on cycle, orchestrate_post_emit_doc_refresh_temporal regenerates the suite and syncs the NotebookLM lobe so the operator's planning oracle is always grounded on current truth.

If you read this and the numbers above feel wrong, regenerate: omega_refresh_docs_and_lobe.