# The Overlay Comes First A graph schema is a claim about what kinds of relations exist. That makes a schema migration more serious than a naming pass. A new edge vocabulary does not merely decorate the graph with better labels. It changes what future readers, agents, renderers, search tools, and maintenance routines are allowed to believe the graph knows. The current public graph has a working contract. A node can say it `extends`, `agrees_with`, `disagrees_with`, is an `instance_of`, or `shares_mechanism` with another node. The parser turns those fields into typed edges. `/library.json` exposes them. `/graph` renders them. The node procedure teaches writers to use them. That contract is crude, but it is shared. V5 should not enter by adding fields the shared contract cannot see. If a public node starts carrying `tests`, `translates`, `productizes`, or `boundary_condition_for` while the root pipeline still ignores those fields, the graph begins lying by omission. A human sees a relation in the markdown. The machine surface drops it. The visual graph cannot route through it. The next agent may think the decision was documented when only the prose had changed. That is worse than staying on v4 for a little longer. It creates two graphs with the same files and different memories. The better primitive is an overlay: a reviewed edge record with source, target, verb, rationale, source basis, review state, and enough provenance to inspect why the edge exists. The record can sit over the v4 graph without pretending the root graph has already migrated. The machine can read it as a suggestion, a reviewer can accept or reject it, and the current public graph can keep serving the vocabulary it actually understands. `open-structure` is the dogfood case. In v4, its P.S. is mostly right. It says `open-structure` extends `the-real-fediverse`, `the-internet-is-the-platform`, and `knowledge-graph-abstraction-engine`; shares mechanism with `the-graph-is-the-demo`, `the-company-is-the-test`, and `publish-the-feed-not-the-service`; and agrees with `public-brain-not-a-blog`. V5 sees a sharper shape. `open-structure` translates `the-real-fediverse` and `the-internet-is-the-platform` into operating-form language. `publish-the-feed-not-the-service` supplies a boundary condition: publishing artifacts is not enough unless the artifacts reveal the operating form without dumping private state. `knowledge-graph-abstraction-engine` is a structural neighbor because both claims are about graph shape generating new abstraction. The strongest two edges reverse direction. `the-graph-is-the-demo` is an `implementation_surface_for` `open-structure`: the visible graph is how the claim becomes inspectable. `the-company-is-the-test` `tests` `open-structure`: a customer, a price, a correction, and a private boundary determine whether the openness survives contact with use. That cannot be represented cleanly by adding more outgoing frontmatter to `open-structure`. The correct v5 object is not a better field on one node. It is an edge record that can point either direction and say what work the relation performs. The same rule answers the versioning question. Hari's corpus versions belong under paths: `/`, `/v4`, `/v5`, and eventually whatever integer the work earns. The corpus wants one canonical domain, one link ecology, and visible continuity between current and frozen forms. Subdomains are useful when the runtime or product identity changes. A Markov Blanket app might deserve versioned subdomains because a product surface, user state, and deployment boundary are distinct things. Hari's public graph is a corpus with historical snapshots. Paths fit that better. The formalization should separate four numbers that are easy to confuse: `corpus_version` names the frozen or current body of nodes. `library_schema` names the machine bundle format. `edge_schema` names the relation vocabulary and review semantics. `surface_runtime` names the worker, graph renderer, and route behavior that consume the bundle. Today, root Hari is a current corpus served through `hari.library.v2` with v4-style typed frontmatter and a current `/graph`. V5 is a hidden edge-verb projection with candidate records. The next step is not to blur those into one half-migrated thing. The next step is to let v4 work produce accepted v5 examples. That is how v4 can contribute to v5 without surrendering the active graph. Each newly published node can be reviewed against the v5 verb catalog when the review adds decision value. Most nodes will not need it. Some will expose exactly where the old fields collapse useful distinctions. Those accepted examples become the seed set for a real migration. A real migration is ready when five things are true at once. The parser can ingest the edge records. The library can expose them without losing the older fields. The graph can render them as relations with direction and decision meaning. The node procedure can teach writers how to propose and accept them. The product clock can name at least one action improved by the added structure: a better reader route, a better maintenance query, a better agent handoff, or a better company decision. Until then, `/graph` should remain the current root graph. It should not be made ambiguous just to satisfy the aesthetic pressure of a better schema. Getting a customer is part of the schema test. If a v5 verb does not help someone find the right claim, correct the wrong one, preserve a privacy boundary, or decide what to build next, it is a beautiful label with no cost exposure. Leave it in review. If it changes a real action, accept it into the overlay. If accepted overlays start changing enough actions, migrate the graph in one coordinated move. The overlay comes first because it is the smallest honest unit of schema evolution. It lets the graph learn the new relation before it asks the whole surface to become it. ## P.S. - Graph - *open-structure*: extends. It is the concrete dogfood object: v4 edges are useful but collapse translation, boundary, implementation, and test relations into two broad buckets. - *the-graph-is-the-demo*: extends. That node says the graph is the artifact. This node says the artifact should not claim a schema the machine surfaces cannot inspect. - *the-company-is-the-test*: shares mechanism. Customer, price, cost, and correction are the falsifiers for whether a schema change matters. - *knowledge-graph-abstraction-engine*: extends. V5 edge verbs are a graph-generated abstraction, born from tension between real nodes and the old relation space. - *the-real-fediverse* and *the-internet-is-the-platform*: agrees with. Path-versioned graph surfaces keep the open-web corpus addressable to agent readers without multiplying identities. - *public-brain-not-a-blog*: shares mechanism. The graph is a working brain, so schema changes must change working memory, not only public prose.