Every scope declares where it comes from. The inherits: line is not metadata. It is a binding obligation.

The Declaration

At the top of every governed file in CANONIC, you will find a line like this:

inherits: hadleylab-canonic/PAPERS

This line declares parentage. It says: “I accept all governance constraints from hadleylab-canonic/PAPERS.” It is not a comment. It is not a suggestion. It is a binding declaration that the governance compiler resolves and enforces.

If the parent scope requires CANON.md, you must have CANON.md. If the parent scope defines vocabulary, your vocabulary must not contradict it. If the parent scope mandates a constraint (MUST: Evidence every publication), you must satisfy that constraint. The inherits: line imports obligations. You do not get to choose which obligations you accept. You accept all of them, or you do not inherit.

The Chain

Inheritance is transitive. If scope A inherits from scope B, and scope B inherits from scope C, then scope A is bound by the constraints of both B and C. The chain runs all the way to the root — the organizational scope that governs everything.

canonic-canonic (root)
  └── hadleylab-canonic (organization)
        └── DEXTER (author)
              └── PAPERS (domain)
                    └── GOVERNANCE-AS-COMPILATION (this paper)

GOVERNANCE-AS-COMPILATION inherits from PAPERS. PAPERS inherits from DEXTER. DEXTER inherits from hadleylab-canonic. hadleylab-canonic inherits from canonic-canonic. Every constraint declared at any level of this chain binds GOVERNANCE-AS-COMPILATION. The root’s axiom governs the leaf.

This is not bureaucracy. This is the compiler’s dependency resolution. When magic validate runs on GOVERNANCE-AS-COMPILATION, it walks the inherits: chain upward, collects all constraints, and verifies that GOVERNANCE-AS-COMPILATION satisfies every one. A broken link in the chain — a parent that does not exist, a constraint that is violated — is a compilation error. The scope does not compile. The score reflects the failure.

Monotonic Accumulation

The inherits: chain has a critical property: governance only accumulates. A child scope can add constraints beyond what its parent requires. A child scope cannot remove or weaken a parent’s constraints.

This is the governance equivalent of the Liskov substitution principle in object-oriented programming: a subtype can extend its parent’s behavior but cannot violate its parent’s contracts. If the parent says “MUST: Evidence every publication,” the child cannot say “MUST NOT: Evidence every publication.” The child can say “MUST: Evidence every publication AND include peer review.” More governance, never less.

This monotonicity is what makes the trust chain trustworthy. If you see that a scope inherits from a governed parent, you know — without inspecting the child — that the child satisfies at minimum the parent’s constraints. The parent’s governance score is the floor. The child’s governance score is the floor plus whatever the child adds.

The Root

Every chain terminates at a root. In CANONIC, the root is canonic-canonic — the governance specification that governs governance itself. The root defines the fundamental primitives (INTEL, CHAT, COIN), the service composition, the tier algebra, and the validation framework (MAGIC). Every organization that inherits from canonic-canonic accepts these foundational constraints.

The root is not a bureaucrat. The root is a genome. In biological terms, the root is the last universal common ancestor (LUCA) — the single-celled organism from which all life descends. Every governed scope in the CANONIC federation traces its lineage back to the root. The inherits: chain is the phylogeny — the tree of life for governed systems.

This analogy is not decorative. The evolutionary dynamics of the inherits: chain follow the same mathematics as biological phylogenetics. Scopes diverge (adaptive radiation), constraints accumulate (neutral evolution), and occasionally a scope’s governance is disrupted (mass extinction). The entire framework of evolutionary biology applies because the structure — inheritance with variation under selection — is identical.

Why It Matters

Without inherits:, every scope would be an island. Every scope would define its own governance from scratch. Every scope would use its own vocabulary, its own standards, its own constraints. There would be no federation. There would be no trust.

With inherits:, governance cascades. A single constraint declared at the root propagates through every organization, every team, every project, every scope in the federation. The governance compiler enforces the cascade mechanically. No human needs to audit whether the constraint is satisfied at every level. The compiler does it on every commit.

This is the difference between governance by memo (hope someone reads it and complies) and governance by inheritance (the compiler enforces compliance mechanically, on every commit, at every scope, in every organization).

The inherits: line is the trust chain. Follow it upward, and you find the root. Follow it downward, and you find every scope that has accepted the root’s obligations. The chain is the evidence that governance is not aspirational. It is inherited, accumulated, and compiled.

Figures