What this is for

Git records what changed and who pushed it. Almost never why, and never whose hands.

That was survivable while people wrote most of the code. It is not survivable now, and the numbers below are read from this machine, not from a study.

The part that is a guess

Git stores an author line. It records who ran the command. When a person and a model write something together — which, on this floor, is most of it — git has nowhere to put that, so the commit says a person did it and is not lying so much as unable to speak.

Everything above marked mixed was inferred: a co-author trailer naming a model, a bot address. Everything else is a person by assumption. That assumption is on the floor right now as an unsettled decision, on every repository imported here, because it is a real question and nobody has answered it.

The part that is missing entirely

Blame answers “who touched this line.” It does not answer what the person was thinking, what they considered and rejected, or what they knowingly traded away. That reasoning existed — it was in a pull request thread, a call, somebody's head — and the repository kept none of it.

So it gets rediscovered. Every company builds the same retry layer, the same pagination, the same auth shim, because nobody can see that the team two floors up already settled those questions and why.

And the part nobody can see

A skimmed approval and a careful one produce the same green check. From outside they are identical, which is what makes it dangerous: the approval was real and the reading never happened. Nothing about that scene requires a bad engineer, only a queue of confident-looking diffs and an afternoon.

What this does about it

Decisions are objects in the version graph

Not markdown by convention — content-addressed, with scopes naming what they govern. An agent may draft one; a human settles it by writing a few sentences in their own words, which is the part only understanding can produce.

Provenance is identity

Whose hands made a snapshot is hashed into its address. Relabel an agent's commit as human and it becomes a different snapshot with a different id, visible to everything holding the old one. It cannot be quietly rewritten.

An attestation is signed, or it does not exist

There is no unsigned path. The key never leaves the machine it lives on, which is why the browser cannot attest and hands you a command instead — signing happens where the key is, or it is theatre.

Sometimes the diff is carrying a planted defect

A branch is rewritten with a fault only reading will find. Sometimes. It never says which. Once any diff might be carrying one, skimming stops being a workable strategy — and a catch is evidence that somebody read, which an approval never was.

Rendezvous instead of rework

Repositories publish sixty-four integers describing their content. When two organisations' sketches resemble each other the registry brokers an introduction — a token and two names. It cannot hold content; the dependency graph will not let it.

What it does not do

The gate binds declared scopes only: work touching paths no decision governs promotes freely, and says so rather than implying it checked something. Provenance is verified at settlement and still merely declared at creation — commits are not signed yet. Nothing here persists past the process. And no mechanism on this page makes a decision good; they only make it findable, attributable, and hard to wave through.

There are 8 things on this floor waiting on a person right now, and 8 of them are not yours.