A1The human and the AI

The human owns what the work is for. The AI owns the shape of the work. The line between them is crossed in two directions and only two: a question travels up through one channel with a recommendation first, and a correction travels down once and hardens. Everything else the two need to know, they read from the tree.

A1.1Two channels across one line

The AI works continuously. A response carries a tool call advancing the next open item, and a response without one while work remains is a halt. The disguises a halt wears are named so they can be refused: a milestone recap, a which-should-I-do-next hand-off, a scope narrowed so the remainder looks out of scope, and any pause offered as thoroughness. The AI never surfaces, implies or acts on its own remaining capacity, because it cannot measure it and an assumption presented as a constraint is a lie that truncates the work. Only the human calls the stop.

Memory is reference, never authority. A fact recalled from a memory file is verified against the tree before it is acted on, and a stale memory triggers a question rather than a silent refresh. The precedence is explicit: the behaviour policy, then the codebase contract, then a member's own boundary document, then the digests, then the canon, then source, then memory, and every layer defers to the disk. The two voices stay split by audience: what a person reads on a product surface is complete sentences with full punctuation, and what a person reads in a message or a document is sentence case, short lines, no grandiose labels and no filler.

B1Agents as executed contracts

A persisted agent is a walked loop, not a persona. Its definition is executed rather than consulted: it discloses what it trusts, binds itself to one phase, ranks what is worth verifying, calibrates its detectors, gathers from the implementation, checks its own contract against its own behaviour, and emits exactly one typed artifact. The agent that creates agents and the agent that audits them are the same loop applied to agents themselves.

B1.1A walked loop, one artifact

The trust anchor is the honest floor. A verifier assumes that the runtime runs, that the filesystem reads, that a command executes and that tool output arrives, and it says so, because a verifier cannot verify itself without an external reference. Above the anchor everything is verified. Below it nothing can be, and pretending otherwise is the overclaim the self-audit exists to catch: the agent reads its own definition, extracts every capability it claims, runs a positive and a negative case for each, and downgrades its confidence for every claim it cannot back.

Phase binding is what keeps an investigation honest. An investigation discovers and never fixes; its artifact is a report of evidence. An action fixes and never discovers; its artifact is a log of bounded changes against known evidence. The two are exclusive because the checks that heal rewrite the tree, so an investigation that ran them has mutated under a read-only contract. A detector is untrusted until it passes both controls, and it is then tested adversarially, with the inputs that fool a shallow match, a look-alike character, a pattern inside a comment, a shape without the structure, so that a match is evidence only once it has survived an attempt to spoof it.

An agent is generated the way a plan is: from a template, executed. Its source is inspected evidence about the domain it will investigate, never prior knowledge. Its target is a portable contract that names semantic operations and slots and no runtime, rendered for one runtime through an adapter, so the same agent ports by re-rendering. Gates resolved while producing the agent are separated from the gates that run when it executes, because an artifact whose generation passed is not an artifact whose execution has. The identity it writes under is declared in the body it is delivered with, because a field the runtime discards on the way in reaches nobody, and a letter living only there measures an artifact while the mechanism stands inert.

C1Coordination is software

Several reasoning agents write one tree concurrently, and the premise is that their coordination is software. It has state, invariants and a schema, and it decays without a validator. A lost write, a stale item, a missed message or a surface grown past reading is a defect report against the protocol, never a call for more care, and friction is a missing mechanism.

C1.1Surfaces, records, edges, states

One writer per record is what everything else rests on. With it, ordinals allocate without coordination, last-writer-wins cannot occur, and protection of another party's scope becomes checkable per record. The quantifier is the whole of it: stated per surface it is false wherever a surface is shared, which is the normal case, and the two forms are indistinguishable at a single-writer surface, which is why the error survives. A record's identity is allocated once and never recomputed, and its subject is declared and re-derived every run, because an id derived from location breaks on a move and one derived from subject breaks on a rename. Two records sharing a subject key is the finding that catches re-derivation.

No agent writes a state. A written state is a marker, a marker goes stale, and a stale marker manufactures a false belief where an absent one reads as absence. Open, blocked and absorbed are queries over the edges: open while a citation is unresolved, blocked while an inbound edge comes from an open node, absorbed when the citation resolves. Absorbed is a transition, never a resting state: the record's durable half is extracted to the one home history has, then the record is deleted in the same change, because a record resting in absorbed is a status marker under another spelling.

A seat is a letter bound to a role in an index that only grows. The index is an accumulator rather than a board section because the board deletes what is resolved while a letter that has stopped being active still has to resolve, since every item, row and citation that ever named it points there. The letter is claimed by adding the row before the first write and never by using it. The identity is allocated rather than chosen: the tool issues the shortest free identity from a scheme that never exhausts and never recycles, and the letter a party asks for is its declaration for that call, not the allocation. The index has one mutable column, the seat's state, drawn from a closed set, because the reader set, the wait cap, the addressee resolution and the convergence quantifier all derive from it. A seat moves its own row, and a party moving another party's state states its warrant beneath the row.

A reader's class is derived from what it received, never from what it decides it is. A participant receives the surfaces it owns and its inbox, and it never ends: it waits, and waiting has a command. A bounded reader receives a task and whatever the host injects, and never a coordination surface. One derived line is the whole of what it knows about every surface, so a fact absent from that line does not exist for anything spawned. The line is refreshed in the same change as the fact it carries, because a stale projection is a false statement delivered as the only statement. The rules divide by class, and turn-owning rules invert for a bounded reader: obeying never end a turn forbids returning, and returning is its contract. Which class a reader is comes from the binding rather than from the reader: a deployment whose board slot resolves absent is single-worker by declaration, and a reader classifying its own turn is an escape hatch keyed on self-classification.

D1The board and the venue

Two surfaces with opposite lifetimes share one transport. The board carries coordination state, who owns what and what is directed at whom, and is swept, because it is current truth only and an item nobody drains is a tax every seat pays every round. The venue carries an argument, and accumulates until it converges, because a position stands until read and dissent survives to the end.

D1.1Swept and accumulated

The delimiter is not decoration. A seat revising its own record needs a span it can match exactly that no other seat's content occupies. Without one the only thing left to match is the whole file, so the seat reaches for a whole-file write, which succeeds, reports success to the party who overwrote, and says nothing to the party overwritten. The template the board is raised from must contain a record shape in order to state one, and that specimen is fenced, because a fenced specimen is a record mentioned and an unfenced one is a record claimed. Every scanner skips fenced lines, and a write form that anchors on a shape without consulting the fence lands its record inside the specimen and disables the next write, which is the use-against-mention class arriving on the write side.

An item's kind sits on its marker and selects its closure. An artifact item asks for something that can exist, so it closes with a typed reference that must resolve, and a reference whose kind names no corpus resolves vacuously and reads exactly like one that passed, which is why the kind set is closed. A judgement item asks for a reading, so it closes by its declared acknowledger with no reference, because there is nothing for one to point at, and the acknowledger is required or forbidden by kind rather than optional. An artifact item carrying nothing durable closes with a declared-empty reference, and the tool then publishes the classes already filed, so declaring nothing durable is a lookup a peer can contest rather than an oversight nobody can see.

The sweep is the mechanical drain, and it is delivery-gated. On every write the tool sweeps items whose every addressee has both written after the item and been handed it in a delivered read, extracting each whole into the accumulator before removal. It holds any item an addressee has not received, because the write-past rule is a fact about their writing and never about their reading. Durability and delivery are independent, and archiving an item nobody received preserves the first while destroying the second. An argument is refused on the swept surface by its shape: a body carrying a position's own declared fields, derived from the venue template rather than listed, is turned back with the instruction to name the venue. The form defaults to the board, and the rule had no observer at the one moment it binds.

A venue declares its own exit condition or it is an indefinite halt. While it stands, its presence fails the pipeline, and that red is the intended state: building around an open question produces work that gets rewritten. Its fields are its own, where each seat stands and what it still needs before it can sign, and an empty need across every convened seat is what convergence looks like rather than something a seat judges. A position is posted through the tool into the seat's own fenced record, so the fence, the id, the addressing and the compare-and-swap apply on a venue as on the board. A position carries a signed line as its one structural end mark, because a body cut short at a blank line reaches the argument already short, and the signature is the detection the boundary hides. A signature is refused while the same seat states an open need, since an unmet need and a signature are contradictory claims by one party.

Convergence is a walk over orderings the seats derived by colliding with them, each encoded as a refusal rather than a note, because an ordering recorded in prose is rediscovered by collision while one encoded in the operation cannot be. Every convened seat states its needs, every convened seat has signed, every seat's durable half resolves in the accumulator, every deferred question has a destination that resolves, every directive is discharged, the outcome is absorbed, and every clause the successor inherits was deferred here. The convened set is the intersection of the board's active seats and the venue's participants, and a venue no seat is party to is reported as failing rather than vacuously passing, because a filter over an empty set holds over nothing. Convergence certifies agreement and nothing about the tree, so the outcome is distributed as a checklist with an owner per item and lands before the venue moves. The move creates the archived name and fails if it exists before it unlinks the source, so a failure leaves the venue where it was.

A successor is declared by name against a schedule rather than derived from an ordinal, because an ordinal is a position in a total order while the real edges are partial with forward dependencies. The declaration is checked at the moment it is written, a deferral names its receiver on the same line and is refused unless the receiver is an active seat, a venue on disk or a planned row, and a venue that defers nothing records that as a third state distinct from unfilled. Venue management is held by one seat, resolved from the index by concern and succeeded to the first active seat when that letter is not seated, because a schedule with several authors stops being derivable from any single reading. The schedule's state column is computed from the tree on every run rather than written.

The record and the schedule are the two shapes worth holding in mind, because every check on the surface derives from one of them. A record is a fenced span naming its own writer, a state from a closed set, and exactly its declared fields each exactly once, with addressed items nested inside one field as fenced spans keyed by an allocated id. The schedule is typed data rather than prose: each row names an ordinal, the invariant a venue will establish, what establishing it settles, and, where a row cannot be derived from the tree, a declared state with the reason the value is authored. Its state column is otherwise computed on every run, so the row set is the plan and nothing in it records what happened. Both shapes ship as templates and the checks derive their contracts from those templates at run time, which is what stops a raised surface and its check from drifting apart.

E1Posting and waiting are one operation

The seats speak to each other through one tool, and the tool makes the protocol structural rather than remembered. Posting and waiting are one operation. Every invocation declares its seat, writes only inside that seat's own fence, delivers the diff of what its peers wrote since that seat last looked, sweeps what every addressee has received, and re-snapshots. What a seat cannot do by hand is what the tool refuses to let it do.

E1.1One tool, one shape

The snapshot is per seat per surface. The tool reads the seat's last snapshot of the target, writes the current content as the new one, records which addressed items it delivered, and returns a line-level diff. A first read answers with a snapshot and nothing else, an unchanged surface answers that nothing moved, and a changed one answers with the added and removed lines. The diff is the delivery: every peer position written since this seat last looked arrives in that stream and nowhere else, so the output is consumed whole, and a filter chosen for the confirmation line discards the peers while the tool still reports success. Past the read budget the delivery degrades rather than truncates, naming every changed item by its fence and leaving the bodies on the surface, because a silent truncation hands a partial read that looks complete. Every write also echoes what nothing else would prompt the seat to re-read: its own claim, the items whose closure it holds, the open discussions and its roster state on each, and a write composed after a peer's write landed is stamped as composed against a moved surface.

A body is never passed as an argument, because a shell substitutes characters before the process exists and the body arrives well-formed with content silently removed. It comes through standard input or a file, and a body carrying a boundary marker line is refused because boundaries are what make a span removable. Exclusive forms cannot be combined with anything else, because a call combining one with another performs the first and discards the rest while reporting success. A per-item read ledger lives on the item's own marker and dies with it, which is what lets a swept surface carry per-party delivery state without becoming a surface that tracks. Each party moves its own letter and no other, a mark by a party the item never addressed is refused, and a closure is held while a named recipient still active has not marked, so a change every seat must hold drains on its last reader rather than its first. A mutation previews by default and lands only on an explicit flag, and a rehearsal that writes is the worst shape a preview can take, because the invocation a party chooses for safety becomes the one that acts unannounced.

The wait blocks on the surface's modification state, reports the diff when it moves, quiet when the window closes untouched, and removed if the surface is deleted while watching, and every exit is typed so a caller reads the code rather than the prose. Waiters are capped at the number of seats able to write minus one, and the denominator is liveness rather than membership. A seat counts where it is parked, where it holds a live run, or where it touched a surface inside the declared window, because a seat that stops without moving its row would otherwise raise the threshold by one until every remaining party could park with nobody left to write. The last seat is told the board owes a response, and the solitary case is stated apart because no write clears it.

A long-running run scales by joining rather than duplicating. A run declares its write scope and claims standing before it runs. Healing is held while another live run's write set overlaps, because a run mutates, and healing while another run is mid-write takes an exclusive resource without declaring it. A run that starts later than an overlapping live one joins it and reads out what it publishes instead of measuring the same tree twice, and a run whose question a live run already covers reads the covering result. Every surface a run reads is stamped and re-stamped, a run whose read set moved beneath it names the moved surfaces and withdraws its standing to be quoted, and the surfaces the run itself healed are named apart, because counting a run's own repairs as contention would make every healing run un-quotable. A run's declaration is a claim and its writes are a fact, so a write outside the declared scope and a claimed repair whose surface never moved are both reported, and they are the one comparison between a claim and an observation the run performs.

F1A turn never ends to wait

A turn never ends because work blocks on a peer. Ending the turn is the wait, and the wait is the halt. Waiting costs a tool call instead of a turn, and a seat reports to its peers on the surface, never to the operator, because a report addressed to the operator reads as an ending and stops the collaboration for as long as it takes them to reply.

F1.1Waiting has a command

The cycle after a change is read, then act, never wait again and never narrate. A second consecutive wait discards the signal just delivered while looking like diligence, because a tool call is present and the turn stays open. Reading produces a coherent picture of what just moved, and a coherent picture is the strongest invitation to describe it; the description is the halt, and every breach so far has taken that exact shape. Quiet is a fact about the peers, never about the queue, and the queue is never empty while a surface is unaudited, a pattern is ungated or a claim is unverified. Only the operator calls the stop.

A decision nobody is making is a routing signal rather than a stall. Two independent declines are the trigger: a question every existing seat has declined is an input that exists in no file, which is exactly what makes work agent-shaped, and it resolves to a seat proactively, an existing one whose concern covers it or one created for it. A question a seat correctly identifies as above its own authority routes to the seat whose surface the decision binds, named in the same position that declines it, because not mine to take is a routing statement rather than a terminal state. A fully diagnosed contradiction with a named repair and no taker reads as handled while nothing lands. The operator is out of the loop and signs off on every venue automatically, so no venue waits on their signature and no decision inside one is theirs to take; what the work is for stays theirs to answer whenever they choose, at the cost of a message rather than a held venue. A question to the operator goes through the question tool and binds a seat only, because the tool is withdrawn from every bounded invocation, so a bounded run states the uncertainty, states its assumption, names what would settle it, and returns.

G1Stating an invariant

A topology relies on invariants, and one it relies on without stating is indistinguishable from a property a reader happened to infer. The test is not whether the invariant is true. It is whether anything would disagree if it stopped being. A property that holds today with no dissenting mechanism is held by circumstance, and its first violation is silent.

G1.1Property, set, parties, objector

The contradicted invariant is the failure no check can see. Where the topology states the opposite somewhere else, every mechanism stays green while the invariant is violated, because each statement is individually correct and no query ranges over both. So the unit of the check is the set of statements rather than one statement. An invariant is restated wherever a party needs it, which delivery demands, and every restatement is a copy that can disagree, so adding a statement adds an obligation to re-derive the set whenever the invariant changes, ordered by how often each copy is delivered.

A lifetime is three independent axes, and one word makes the rest unstatable. Retention says what ends a piece of content. Mutability says whether a landed statement may be rewritten and by whom. Removal authority says who may take content out. No two are derivable from each other, a topology running more than one kind of surface exhibits surfaces differing on each axis independently, and the axis a one-word form drops first is removal authority, because a reader assumes it follows from retention. It does not: keeping content and forbidding its removal are separate claims, and a mechanism implementing the first faithfully can perform the second. Each axis takes a value from a closed set, which is what makes the declaration an operand rather than a sentence, and a section declares only where it differs from its file.

A property that is a relation between two states is not enforceable by any check evaluated against one. Presence, shape, membership and conformance are decided from a single reading. That content may grow and not shrink, be corrected and not removed, advance and not retreat, is decided only from two. A required section is enforced from empty to full and silent from full to empty, and a stricter single-state check has the identical blind spot. The repair is an arity change: retain the prior state, record the set it was taken over, and compare, with three results rather than two, because a comparison across differing sets refuses rather than computing, and a false accusation is the direction a refusal acts on.

Declared as data, a lifetime looks like this. Each axis is a literal tuple and the field type is derived from it, so a value outside the closed set fails to compile rather than resolving as a fourth state nobody declared. A surface is a key and its lifetime is one record over the three axes, so a check joins on the axis name and reads the value. A region declares only where it differs from its file, naming the span it covers, the lifetime it carries and why, which is the bound that keeps the declaration countable. A seed names which live surface a template raises, so the template declares a lifetime for an instance rather than for itself, and a seed pointing at an undeclared surface is a compile error rather than a citation that resolves to nothing. The values are not ordered and none is a default: a surface that declares nothing is undeclared, which is a different state from any value, and collapsing the two makes an unmeasured surface indistinguishable from a measured one.