Event

An event is the WHEN-it-happened primitive: one occurrence, published by a source, delivered to whoever subscribed. It is the only one of the four that does not come from Git, and it is there for a reason Git cannot supply.

Two clocks, and neither substitutes for the other

The substrate already had a WHEN, and it is a different one. A branch answers in which history something is true — version time, owned by Git, materialized as a place’s timelines. An event answers at what moment the world moved — wall-clock time, owned by nothing that versions.

You can replay a timeline forever and never learn that the hour struck.

Pub/sub, and nothing more at this altitude

Sources publish; consumers subscribe; the platform carries the delivery. Which machinery does the carrying — a multiplexer, a socket, the host OS’s own facilities — is the kernel’s chapter and changes nothing above it.

Sources are heterogeneous by construction: the clock, a file that changed, an entity that committed, a push landing from another participant, a webhook arriving, a device of some subsystem, another application entirely. And the list is open — any application publishes. Restricting emission to sources we ship would confine reactive composition to our own catalogue, exactly as restricting entities to our own applications would have confined state.

Subscribing is arming: a command line plugged at a coordinate, run when the occurrence lands.

$ entity on acme.note:n1 write.landed -- /usr/local/bin/reindex
r1
$ entity listeners acme.note:n1
r1	n1	write.landed	always	/usr/local/bin/reindex

An arming is a row: its handle, the instance, the occurrence it answers, when it applies, and the command line to run.

The body of an act runs in the act’s own private area rather than in the directory you typed from, and a reaction’s body runs in the root of the place — so an armed command is named by absolute path. A relative one is resolved against the place and not against where you typed it, which is rarely what the hand that typed it meant.

The subscriber is transient, and that is not a limitation. It waits on nothing and holds nothing: it is born by the occurrence, turns the moment into a byte stream, and dies — so everything downstream is ordinary composition, a pipeline, a state machine, a chat turn, an agent loop. A standing process that wants to be told is not a second kind of subscriber but an actor with a body of its own: it arms an ordinary transient reaction that signals it, and its liveness is its own logic. The floor never learns that a subscriber can be alive.

An entity publishes exactly one kind of occurrence

Its own acts, qualified by phase. The act is the thing; the event is the moment of that thing, in the past tense, because an event is a fact and never an intention.

<payload>.attempted   the act is formed and not yet true
<payload>.landed      it is true, and published
<payload>.refused     it did not pass — the trace remains, the effect does not

The name is the noun and never the verb — prompt.landed, not say.landed — because the noun is what the act deposited, and the noun is all the substrate can read: enough to match a subscription, never enough to interpret.

There is no vocabulary to declare, and no verb for publishing. The set of events is the payloads an entity’s ontology names, multiplied by the three phases. An occurrence without a commit would be neither durable, attributable nor federated, so nothing publishes anything else. What arrives from outside — a timer, a webhook, a file that appeared — enters as an act of whoever brought it, which is what makes every chain root in somebody having done something rather than in an ambient event.

The three-phase vocabulary is enforced: an unknown phase is refused by name. landed is the phase wired end to end runs; the other two are below.

The two phases are the two halves of the model

.attempted is not before the act — it is before the act becomes true. The commit object already exists and only the ref has not moved, so a refusal leaves no residue, and rewriting is not on offer: what would have landed is hashed before any listener sees it. A listener that wants different content refuses and lets the actor redo it, or lands a compensating act of its own. Which makes a validator not a special mechanism but an ordinary armed reaction that happens to answer the attempted phase — and, being the entity’s own gate rather than any actor’s, one armed when the entity is installed.

The refusing power is declared in the substrate and is not yet wired end to end designed.

.refused knows that it did not pass, not why. The substrate aborts a transaction whole and names no culprit; the cause has to come from whoever refused.

The commit is the whole of the event

The event’s identity is the commit, so the commit’s metadata is everything the event carries: the actor, the instant, the declared noun, the two tips, the diff — readable at all three phases, since even a refused object exists, orphaned.

Two consequences fall out. Filtering by actor is not a dimension somebody has to invent; it is a field already arriving. And reading an instance’s events in sequence is reading its log under another name, so an actor’s context comes free with the medium.

The phases are where authority lives: refusing a tool, barring by policy, requiring that a person say yes. They are not where a pipeline lives — work that must happen between two acts is a state of the machine and an actor that answers it, never a hook-ordering trick. And they are how a stranger extends an entity it did not write: arm on its events, act in your own.

Why this is a primitive and not a convenience

The programs here are transient by design — born from disk, run, emit, exit. A world of transient processes needs a universal way to be woken, or transience is impotence. Occurrence is the coupling that starts the other two, which is what makes it floor rather than library, and it is why a component is free to not exist between events.

What an event is not

Not IPC. A pipe joins counterparts that know each other and carries data. An event announces an occurrence to subscribers the publisher has never heard of, and that decoupling is the entire point.

Not a message queue, and not an RPC channel. It delivers occurrence, not work.

Not Git hooks. Those are one source’s emission mechanism, on either bank of a federation. Mistaking the mechanism for the primitive is how a substrate detail gets promoted into an ontology.

Not a trigger. Trigger is a Process’s name for the subscription it roots on — a word from one floor up, borrowed downward.