File Genesis Protocol

A file is not born governed. It is hash-stamped at birth, compared against everything that came before it, and earns canonical status only through a three-verifier gate.

Agents create files constantly. Left alone, that is how a system rots: near-duplicates nobody reconciles, scripts nobody owns, documents that quietly contradict each other. The File Genesis Protocol is Q-En-S-Ai's answer, and it starts from one rule:

No file is treated as developed — and nothing it touches counts — until it carries a hash stamp and a metadata record.

No stamp, no entry into promotion pipelines, no place on a governed surface. The filesystem itself is a governed boundary.

A file declares itself at birth

The creating agent — human or machine — must declare six things before the file is anything more than bytes: what it is, what scope it belongs to, what it is for, what role it plays in the architecture, where it registers in the system's tables, and its stance toward what already exists.

That last one has a fixed vocabulary. A file is a new origin, a variant of an existing lineage, a successor to a canonical predecessor, or a mirror. There is no "just a copy I made."

The hash stamp is a SHA-256 fingerprint computed over all six declarations plus the file's initial content — identity and intent, sealed together, recorded in the file registry with who created it and when.

The comparison keeps the lineage honest

The moment the stamp exists, it is compared against the registry. No match — the file really is a new origin. Close match — it gets reclassified as a variant or successor, whatever the agent believed when it started. Byte-identical — it is a mirror, and is recorded as one.

And one case is treated as an alarm: the same hash carrying a different declared purpose. That is flagged as high hallucination risk and queued for investigation — because an agent that produces identical content while believing it is doing something new has told you something important about itself. The filesystem is one of the places this system catches its own agents drifting.

Existing is not the same as being canonical

A stamped file with unfinished logic is a stub, and it stays one. Elevation to canonical status has its own gate: three independent verifiers — the handoff validator, governance, and security — must each mark it in-scope and approve. One approver is an opinion; three lanes agreeing is a decision.

And when a file is elevated, nothing it replaces is edited. The predecessor's entries stay immutable; the new file takes a new row that names its predecessor. The lineage reads forward forever.

No silent moves

Files move. Projects reorganize. The protocol's Rule 0: no file may be moved, renamed, demoted, archived, or superseded without leaving a searchable artifact at the old path — a tombstone that teaches whoever arrives there where the object went, what superseded it, or why access is denied. When a working draft is promoted into the production canon, the original stays put and gains a marker saying so — so no one ever edits a stale copy believing it is the real one.

The dirty desk

Governance is only real if you can say what is not yet governed. Every object is evaluable through a completion chain — it exists, it is indexed, it carries an identity header, it has a registry identity, and its table obligations are met or explicitly exempted. Any missing link makes the object dirty desk: classified, weighted by how close it sits to a runtime or authority boundary, and converted into queued governance work.

The rule that gives the whole chain teeth is four words long: no silent exemption is valid.

The Constant

This is not a policy document — it runs. Scanners sweep nine projects, flag missing headers and identities, check tombstones, and merge everything into a master array cross-referenced against the Function Registry: 11,131 files, one stable reference frame the system's other instruments measure against. It has a name inside the system: The Constant.

A system that wants to prove what it did has to know what it is made of. File genesis is where that knowing starts.

The system pieces in this story

Each links to its entry in the live Governance Glossary (sign-in required).

Hash stamp — the SHA-256 fingerprint sealed over a file's six birth declarations plus its initial content: identity and intent in one record, computed before the file may touch anything governed.

Relationship stance — a file's declared position toward what already exists: new origin, variant, successor, or mirror — corrected by the registry comparison, never left approximate.

Tombstone — the searchable artifact left at a file's old path when it moves: where it went, what superseded it, or why access is denied. Rule 0: no silent moves.

Dirty desk — the classification for any object whose completion chain is broken: unindexed, unheadered, unregistered, or carrying obligations neither met nor explicitly exempted. Dirty desk is not a judgment; it is a work queue.

The Constant — the master array merged from every project scan and cross-referenced against the registry: the stable frame the system's other instruments measure against.

Function Registry — the governed catalog of callable capability; the scanner cross-references every file against it, and a registered identity is one link in the completion chain.

Provenance — the recorded origin of every artifact and change: who produced it, under what authority, from what inputs. The hash stamp is provenance applied at the moment of birth.