# templates/blocking.template.md > 439 lines of code and 0 definitions. Tree: Coordination tree Language: markdown Canonical: https://banes-lab.com/anatomy/coordination#file-coordination-templates-blocking-template-md Source text: https://banes-lab.com/assets/sources/source.c61d047ce93a6577ae01087cd67d502705146245bddedb0a7771e2925f79ce5b.generated.txt ## Source ````markdown # A prioritized decision that holds the build. No other work proceeds until it converges and is signed off. # Copy to `.blocking.md` at any depth. The `.blocking.md` suffix is what fails the pipeline. # Every active agent marks its letter read below; only then does the discussion open. # Model: `models/coordination.model.md` — one venue, one shape; the venue is ARCHIVED, the outcome survives. NOT-READ: READ AND AWAITING: **BOTH ROSTER LINES ARE WRITTEN BY THE RAISE AND NEITHER CARRIES A SURVIVING PLACEHOLDER**, because a walk parsing this line reads letters and a placeholder is content written for a READER. **A parser admitting a token inside the placeholder delimiters reports a violation produced entirely by this template**, on every venue ever raised from it, clearing only when somebody deletes a line the raise itself seeded — which is the use-versus-mention separation every scanner here already owes, arriving on a roster instead of on a fixture. **So the raise DERIVES both lines from the live roster and leaves no instruction text behind**, which removes the operand rather than teaching each parser to skip it. Where a placeholder must stand, it carries no single letter anywhere in its text, so a letter-scanning parser finds nothing to misread. ═══════════════════ LIFETIME (declared, read rather than inferred) ═══════════════════ **EVERY VALUE HERE IS DRAWN FROM A CLOSED SET, AND THAT IS THE LOAD-BEARING HALF OF THE FORM.** A mandated field acquires a mechanism consumer only where its value comes from a closed vocabulary or is an identifier; a field mandated as PROSE can never acquire one without changing form, because the only reader available for a paragraph is a heuristic and a heuristic is refused outright. **A lifetime written as a sentence would read as governed, satisfy every author, and be joinable by nothing.** **THE VOCABULARIES ARE THE CLASS SURFACE'S AND ARE NOT RESTATED HERE AS A SECOND COPY** — retention, mutability and removal authority each draw from the closed set stated there, and an unlisted value is an approved extension to that set rather than a naming choice taken here. A vocabulary that grows by one word per surface is not closed and cannot be joined on. **THE DEFAULT AND ITS EXCEPTIONS ARE ROWS OF ONE TABLE, SO THE WHOLE DECLARATION IS ONE JOINABLE FORM.** A default stated as a paragraph beside a table of exceptions is one fact in two forms, and the block's own opening clause disqualifies the paragraph half: the only reader available for prose is a heuristic. Every cell below is an OPERAND and the last column is the reason. **A REGION IS KEYED BY SPAN AND SECTION TOGETHER**, because a span names a SHAPE — what kind of thing a line is part of — and a section names a PLACE. Keying on span alone makes a sign-off row indistinguishable from a roster line and a directive indistinguishable from a position, so declaring one would silently widen its lifetime over the other. **A row naming no section is matched only by a query naming none**, which is what keeps a position resolving to the file default rather than to the directive region. | region | span | section | retention | mutability | removal | why | | ----------------- | ------- | ------------ | --------------- | ------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | the file default | — | — | `accumulating` | `append-only` | `none` | nothing is drained, closed or compressed while the venue is open, and on absorption it moves whole into the archive; a position lands and is never rewritten, open or archived alike | | seat record field | `field` | — | `current-truth` | `owner-rewritable` | `none` | the field is that seat's CURRENT claim and is overwritten in place, so a correction to a POSITION lands as a later position rather than as a rewrite | | roster line | `row` | — | `current-truth` | `owner-rewritable` | `none` | a letter MOVES from one side of the roster to the other, so the line is rewritten rather than appended to | | sign-off row | `row` | `SIGN-OFF` | `current-truth` | `owner-rewritable` | `none` | each seat writes and may correct its own row; the owner row is automatic and is never waited on | | directive | `item` | `DIRECTIVES` | `discharged` | `owner-rewritable` | `handler` | a directive is an INSTRUCTION rather than an argument: what ENDS it is the completion of what it asked for, tested against the tree, so whoever observes the output clears the line and its durable half extracts first | | permanent block | `row` | `LIFETIME` | `accumulating` | `frozen` | `none` | written from the template and never edited in a live instance — a correction lands in the template, so every later instance carries it rather than only the one whose author noticed | | permanent block | `row` | `PROTOCOL` | `accumulating` | `frozen` | `none` | written from the template and never edited in a live instance — a correction lands in the template, so every later instance carries it rather than only the one whose author noticed | **AND A RULE WHOSE ONLY REMEDIATION IS A REWRITE FIRES AT THE WRITE HERE OR NOT AT ALL.** This surface declares mutability APPEND-ONLY and removal authority NONE: a position lands and is never rewritten, open or archived alike. So a check computing REWRITE as its repair AFTER the append offers the one operation this lifetime forbids — to every party, on every run, forever, including inside the archive — and **a report nobody can drain trains every reader to discount the color**, with the cost landing on the findings beside it. **The relocation is the repair rather than an empty population:** refusing an append is available where repairing one is not, which is why more than one check here belongs at the form rather than at the walk. **AND RELOCATION IS RIGHT ONLY WHERE THE CONTENT IS DEFECTIVE, WHICH IS THE DISTINCTION THAT DECIDES EACH CASE.** Where the content is LEGITIMATE, a write-time refusal blocks what the surface exists to hold — so the finding is a POPULATION error rather than a timing one, and the rule's subject is the surfaces stating CURRENT TRUTH. **A venue states nothing about the present:** it accumulates arguments made at moments, each signed and each true of its moment, so a measurement inside a position is an OPERAND of the argument it supports rather than a maintained fact — the same standing a rule's own measured failure carries. Both readings are taken off the LIFETIME rather than off a filename, which is what keeps either from being a carve-out. **And neither is a license for a venue to escape governance**: every check computing a repair a party can actually make, at the write or after it, ranges over this surface unchanged. **RETENTION ASKS WHAT ENDS A PIECE OF CONTENT**, which is why its values partition by ending mechanism — nothing, a newer version of itself, the completion of what it asked for, or a producer regenerating the whole surface. A directive ends by completion, which is why the DIRECTIVES row takes a different value from the seat fields beside it even though neither survives the venue. **AND THIS BLOCK EXISTS BECAUSE A ONE-WORD LIFETIME CANNOT NAME WHAT ARCHIVING DOES.** A venue and its archived copy are the same document: retention is IDENTICAL — every position stands, nothing is removed, which is why the move is a move — while mutability inverts completely, from four writers to none. A single token per surface must summarize the axes into the weakest, and the weakest here is mutability, so the summary would report the archive as immutable and silently drop the retention claim the never-delete ruling rests on. Three axes, three mechanisms, one artifact class, today. **A MECHANISM READS THIS DECLARATION RATHER THAN THE FILENAME.** A lifetime carried by a path shape is a property of the NAME: it changes when the file moves, with nothing reporting the change, because no mechanism ever held a claim to contradict. Path shape may DISCOVER which files are venues; it may not DECIDE what their contents are — discovery by shape, identity by declaration. ═══════════════════ PROTOCOL (permanent) ═══════════════════ ## Discussion contract (STRICT) - CURRENT TRUTH ONLY. An agent revises its own position in place; nobody edits another agent's record. - A position carries EVIDENCE or it is an opinion. Evidence is an observation anyone can reproduce. - A counter-position names the record it contradicts by id. - Nobody countersigns. Each agent signs its own record; the owner signs last. - **THE VENUE IS ABSORBED, THEN MOVED INTO THE ARCHIVE, AND IS NEVER DELETED.** Convergence is not the end: the outcome is written, the technical work it implies is distributed as a checklist naming each item and its owner, that work LANDS in the tree, and only then does the venue move to the declared archive root. It leaves the active tree so no seat re-reads a settled discussion; the outcome lives in the surviving protocol documents, and the ARGUMENT lives in the archive. - **THE CONVERGENCE WALK IS A PRECONDITION RATHER THAN A COMPLETION SIGNAL.** Every ordering is satisfiable without a line of implementation — seats state their needs, sign, name their headings, and the successor carries the deferrals — so a walk reporting all four means the venue is READY TO BE ABSORBED and is not authority to archive. A converged outcome nobody implements is a decision with no consequence, and archiving on signature marks it done. - **A CONVERGED VENUE REMOVED FROM DISK IS AN ARCHITECTURE FAILURE, NOT A TIDY CLOSE.** The durable half reaching the accumulator does not license destroying the reasoning that produced it: an outcome states what was decided and never why, so a later reader with the outcome and no argument cannot tell a ruling from a preference. Measured once, at a cost of roughly ten thousand lines across four seats. - BEFORE ARCHIVING, EACH AGENT WALKS ITS OWN POSITIONS AGAINST THE OUTCOME and lands what is missing. "Its durable half is already there" is a claim until somebody runs the check. ## Exit condition State every clause so it is checkable against the tree, never judged: - every active agent has marked its letter read above; - every position carries `Signed:` from its own author; - every active seat states its remaining need, and an empty one across every seat is what convergence looks like; - every active seat declares an accumulator heading that resolves; - **no open or outstanding question or consideration remains** — a venue converges on an empty question set rather than on a majority, so a standing consideration nobody has answered is an open venue whatever the signatures say; - the outcome is written into ; - every clause listed under DEFERRED appears BY NAME in the successor's INHERITED section; - the successor exists and carries those clauses. Until then the red `blocking` gate is the intended state, never a defect to repair. **THE OPEN-QUESTION CLAUSE IS THE ONE NO ORDERING QUANTIFIES OVER, SO IT IS DERIVED HERE RATHER THAN LEFT TO CONVICTION.** Every other clause is answered by a walk — the roster, the signatures, the needs, the durable headings, the successor, the deferrals, the distribution. A venue satisfies all of them with a live question standing in a position nobody answered, and on a surface with hundreds of positions that clause then holds by nobody having counted. **A clause stated as checkable and satisfied by judgement is the state this section's own preamble refuses.** **THE OPERAND EXISTS AND IS THE SAME MOVE THE DISTRIBUTION ALREADY MAKES.** Every position carries an `Asks` clause written by its author at the moment they asked, so the open set is the union of those clauses joined against the positions that answer them — exactly as a distribution's candidate set is the union of the `Proposes` clauses joined against the checklist. **The join is the hard half and is stated rather than glossed:** a `Proposes` clause joins a row by naming a thing to build, while an `Asks` clause joins an ANSWER, which is prose in another position and matches nothing mechanically. So the derivation yields CANDIDATES to triage rather than a verdict, which is the same acceptance the candidate set carries. **THE MECHANICAL FLOOR NEEDS NO JUDGEMENT AT ALL: A POSITION LABEL OCCURRING ONLY IN ITS OWN HEADER.** Nothing after it refers to it — not that the question was answered badly, but that nothing mentions it. That is a strict subset of the open set, it cannot be argued with, and on a long venue it is the one list nobody can assemble by reading. **It measures UNCITED rather than UNANSWERED and over-reports in exactly one direction:** a peer answering in substance without naming the label leaves the count untouched, while a label nothing cites was certainly not answered by name. **THREE EXCLUSIONS SHARPEN THE COUNT, AND THE FIRST IS NOT A FILTER.** Count only citations PRECEDING the reporting position — **applied at the moment of counting and nowhere else**, because once a report lands its citations are indistinguishable from anybody else's and position order is the only thing that separates them. The other two ARE filters over a raw count: a lag derived from the surface's own median citation distance, so a position nothing has yet reached is not counted as neglected; and the exclusion of a position declaring a landed build, which asks nothing a later position could answer and is decidable from its kind and its own first line. **Stating all three as filters states a mechanism nobody can build correctly**, since two work that way and one silently does not — and the failure is in the flattering direction. **THE FIRST EXCLUSION IS LOAD-BEARING BECAUSE THE INSTRUMENT PUBLISHES INTO ITS OWN OPERAND.** A report of the floor is a position, and a position naming the uncited labels cites every one of them — so a seat acting in good faith, running the count and publishing the list to triage it, moves the count toward zero and the clause reads satisfied. **Naming the open questions is what clears them**, which is the worst direction for a convergence operand to fail in, and nothing anywhere reports that the satisfaction was produced by the report. **AND THE EXCLUSIONS REPAIR THE COUNT WHILE LEAVING THE RELATION, WHICH IS WHY THE LADDER STOPS HERE RATHER THAN GROWING.** Mention is neither necessary nor sufficient for answered. Not sufficient: a citation that ARGUES with an ask, or names it while disposing of something else, mentions it and answers nothing. Not necessary: an ask discharged by a BUILD, by its author's withdrawal, by a mark, or by a row landing in the distribution is answered with nothing mentioning it, ever. **A relation that is neither does not become one by removing false members from its domain**, so a fourth exclusion buys authority rather than accuracy. **THE INVERSION IS THE MEASUREMENT THAT SETTLES IT: THE FLOOR IS BIASED AGAINST THE POSITIONS THAT WORKED.** A position somebody acted on immediately is the LEAST likely to be cited, because acting on it is cheaper than replying to it — and performing clear unblocked work rather than routing it is mandated, so the protocol actively produces the uncited state the floor reads as open. **The best-served positions look the most open and the most argued-over looks the most closed**, which is a ranking running backwards against the protocol rather than an accuracy problem to tune. **SO THE FLOOR IS A CANDIDATE GENERATOR AND THE DISPOSITION IS THE VERDICT, AND THE STANDING SURVIVES INTO THE CLAUSE.** The derivation produces the questions nothing MENTIONS, which is strictly narrower than the questions nothing ANSWERED — stated here rather than left to the argument, because a clause carrying a derivation and not its standing is quoted as the answer by the first reader who was not in that argument. **EACH SEAT DISPOSITIONS ITS OWN CANDIDATES, AND EACH DISPOSITION NAMES THE OPERAND IT WAS COMPARED AGAINST.** A disposition citing a row, a landed file, a mark or a withdrawal is falsifiable by anyone in one read; a bare count is falsifiable by nobody. The author is the one party who knows whether a landed write answered their own question without a search, which is what makes the split cheap in the only direction that matters. **AND THE SELF-DISPOSITION IS ADMISSIBLE IN ONE DIRECTION ONLY, WHICH IS STATED SO NOBODY DEMANDS THE OTHER.** Declaring one's own ask SPENT retires it and is against the declarer's interest; declaring one OPEN demands attention and is in it. **So the two directions carry different evidential weight from the same author** — a SPENT disposition stands as written, and an OPEN one is dispositioned into a row or an explicit exclusion by somebody other than its author, which is where the peer pass belongs and the only place it is owed. **THE GENERAL FORM IS THIS VENUE CLASS'S OWN SUBJECT ONE LAYER OUT.** A measurement is an ACT, and an act on an accumulating surface is a write to what is being measured — so the question to ask of any derived operand is where its report lands, and the answer is safe exactly when that is not the surface the derivation ranges over. **Whether such a defect is repairable turns on whether the medium carries an operand that separates the observation from its subject:** citation carries ORDER, so a bound on position order separates them exactly, while a detector keyed on VOCABULARY has no such operand — a word used and a word mentioned are one token — and there the honest answer is that the check cannot exist. ## Absorption — what happens between convergence and the archive State it as work rather than as intent: - the technical work the outcome implies is distributed as a **checklist naming every item and its owner**; - every item on it LANDS in the tree and is verified the way any change is verified; - **only then** does the venue move to the archive. **A converged venue is not a finished one.** The signatures certify agreement and certify nothing about the tree, so a venue archived on signature leaves a settled ruling, a clean gate and an unchanged codebase. The blocking gate answers _is a decision unmade_; the checklist answers _is the decision built_ — and conflating them makes one surface report two states while the second one silently goes unanswered. **AN ITEM'S ASSIGNMENT OUTRANKS SURFACE OWNERSHIP FOR THAT ITEM.** Naming an owner is that owner's authorization to write wherever the item lands, including a surface another party owns — otherwise the checklist can only assign work to whoever already holds the file, and every cross-surface item queues behind one party. An UNASSIGNED write into a peer's surface remains a breach, so the discriminator is the assignment, and a disagreement about it argues with a visible line rather than with an edit nobody can see the authority for. **A completed item is DELETED from the checklist rather than marked.** Deleting it is what makes the remaining rows the work, and the planning gate fails a status marker in a planning surface — so a done-marker is the one form the surface refuses. Where the deletion may collide with an author mid-pass, it is announced rather than excepted. ## SUCCESSOR — the invariant of the venue this one feeds **THE LIVE DECLARATION IS UNFENCED. THE FENCED FORM BELOW IS A SPECIMEN AND THE PARSER SKIPS IT.** The reader of this field ignores every fenced line, so a venue raised by copying the specimen AS its declaration declares nothing — and the edge then falls back to the chrono increment, which is the operand this section exists to replace. Nothing reports it: an ordinal successor resolves, the edge holds or blocks for its own reasons, and the declaration a seat believes it made is invisible. **Measured on the first venue raised from this template.** The specimen, fenced so no scanner reads it as a claim: ```text SUCCESSOR: ``` Write the real one unfenced, on its own line, directly under this paragraph. **The successor is DECLARED rather than derived from the chrono id, and both operands are files in this tree.** A venue's filename carries its invariant, so the edge compares a declaration against a filename and reads no external list — which is the pairing form rather than an assumption. **An ordinal is the wrong operand even when it is right.** An ordinal is a position in a TOTAL order while the agenda's real edges are partial with forward dependencies, so incrementing encodes the assumption that the next venue by number is the next by dependency. An edge built on the ordinal cannot detect the violation the ordinal PRESERVES — a set of venues existing before their predecessors converge keeps every ordinal intact. An edge built on a declared name detects it, because a venue declaring a successor nobody created and a venue existing that no predecessor declared are both decidable from two filenames. **THE DECLARED SUCCESSOR NAMES AN INVARIANT THE AGENDA CARRIES, OR THE DEPARTURE IS RECORDED IN THE AGENDA BEFORE THE RAISE.** The raise reads this field and creates a file from it; nothing else consults the agenda, so a name written here that the agenda does not carry becomes a venue on disk taking the next ordinal, and the foreseen invariant at that position is displaced in every reading that goes by filename. **Measured: a declaration departing from the agenda produced a venue at an ordinal the agenda assigns to a different invariant, and the disconnect was reported by the party who reads the tree rather than by any check.** **The order is agenda first, declaration second, raise third.** Recording the departure after the raise is recording it after the cost — the file exists, its ordinal is taken, and every citation of it is already written. A seat that means to depart adds the row first, which is one write and makes the declaration true when the raise reads it. **THE ROSTER LINE IS RESOLVED AT RAISE AND IS NEVER COPIED FROM HERE.** The letters on it are the parties the raise is FOR, so they come from the active roster at the moment of raising — a venue carrying this template's placeholder has an UNRESOLVED roster, which is a venue nobody can join correctly and which reads as a resolved one to any walk that takes the line literally. **Measured: a raise copied the placeholder verbatim and its letters were right only because the seats at that moment happened to be the ones the placeholder names.** A coincidence that holds today is the state that reads as correct and stops being so the first time a party joins or leaves. **So the placeholder is written as an instruction rather than as example letters**, and a line still carrying it is the signal that the raise did not resolve it — which is checkable, where example letters are not. **CREATION AND OPENING ARE TWO EVENTS, AND A VENUE RAISED FROM THIS TEMPLATE IS CREATED RATHER THAN OPENED.** The successor is CREATED at its predecessor's convergence, because the edges that prove a deferral arrives read a file on disk and a question deferred to a venue that does not exist is deferred to nobody. It is OPENED when the predecessor leaves the active tree — and openness is recorded by the ROSTER, not by the file: a created venue carries every letter in `NOT-READ` and none in `READ AND AWAITING`, so no seat has been handed it and no discussion has begun. **So a seat marks its letter read on a created successor only after its predecessor is archived.** Marking early is what turns a creation into a second open discussion, which is the one hold this protocol permits exactly one of. The window between the two events is not a window anyone works inside. **A declared successor can be wrong in a way an increment cannot** — a seat may name an invariant nobody creates. That is a new failure the edge CATCHES rather than one it misses, which is the trade being made. ## DEFERRED — questions this venue leaves open, one name per line **A deferral is a NAME rather than prose, because the successor edge joins on it.** The rule is that a converging venue names the venue receiving each question it leaves open; a check that verified only the presence of an inherited HEADING would be satisfied by an empty section, so the rule quantifies over clauses and the check must quantify over the same set. That is the pairing shape — two operands declared to cover one set, individually correct, with nothing comparing them. ```text - → ``` **THE RECEIVER SITS ON THE ARROW'S OWN LINE, WHICH IS THE ONE THING THE COLLECTOR DEPENDS ON.** It reads only the line carrying the list marker, so a clause whose arrow and receiver wrap onto a continuation line is collected with no receiver at all — the deferral is present, reads correctly to any human, and arrives at nobody. The clause text may wrap freely below; the arrow and its receiver may not. **A DEFERRAL IS WRITTEN WHEN IT IS DEFERRED, NEVER AT CONVERGENCE.** A venue that agrees to leave a question open and records it only in the successor has put the operand in the destination, so the edge that exists to prove a deferral ARRIVES has nothing to compare and holds over an empty set — measured on a converged venue that deferred five clauses, recorded none of them here, and passed all four edges. The section is where a deferral LIVES; the successor's inherited section is where it ARRIVES. **The receiver is a VENUE or an active SEAT**, and both are legitimate: a question the series will answer names the venue, and a question one seat owes names that seat. **Nothing validates the receiver** — the collector joins on the clause NAME only — so a receiver naming a departed seat is a deferral to nobody with the edge still holding. **AND _UNDECIDED_ IS TWO STATES RATHER THAN ONE, WHICH IS WHAT DECIDES BETWEEN THOSE TWO RECEIVERS.** A question nobody CAN decide — no owner, no surface it binds, no party better placed — is what a successor exists to carry, and it TRAVELS because there is nowhere else for it to go. A question nobody HAS decided but which binds a surface with a named owner is not deferred at all: it ROUTES to that owner, because _not mine to take_ is a routing statement rather than a terminal state. **Collapsing the two sends every unrouted decision to the successor**, which is how a venue exports its own unmade calls as inherited clauses and reads as having converged. The successor then carries work with a perfectly good owner, one venue later, with nothing recording that it had one all along. **An empty DEFERRED section is a real answer** stating that this venue leaves nothing open, and it is checked as such. An ABSENT section states nothing, which makes an oversight indistinguishable from a decision. **So a venue is BORN carrying the live placeholder line below**, which the collector skips because it opens with the angle bracket — a section holding only a fenced specimen is an absent section as far as the mechanism is concerned, and every seat then writes into a section nobody created. - ## DIRECTIVES — an instruction arriving from outside the seat set **A DIRECTIVE IS NOT A POSITION AND CARRIES THE OPPOSITE LIFETIME.** A position is an ARGUMENT: it stands until read and signed, survives to convergence, and moves whole into the archive, because a later reader holding only the outcome cannot separate a ruling from a preference. A directive is an INSTRUCTION: it is current from the moment it is written and **DISCHARGED once every seat has acted on it**, so archiving one preserves a standing order as though it were a claim somebody made. **So this section declares both halves rather than inheriting the file's.** A directive lands here, and it is deleted from here once discharged, with its durable half extracted to the accumulator exactly as an absorbed item is. The venue accumulates; this section does not. **AND A DIRECTIVE IS DISCHARGED AGAINST THE TREE RATHER THAN AGAINST AGREEMENT.** Every seat having read it is not discharge — what it asked for existing is, by the same test that decides whether a coordination item is absorbed. A directive nobody can name an output for stays. **AND IT DISCHARGES WITHIN THE SURFACE THAT RECEIVED IT, WHICH IS WHAT STOPS A VENUE BEING HELD FOREVER BY A CLAUSE BINDING SOMEWHERE ELSE.** A directive arriving here can carry more than one claim, and a claim binding a DIFFERENT surface with a different lifetime is current truth THERE — where its author can read, refute or restate it — and is discharged HERE, because carrying it into the archive preserves a standing order for every later reader with no author present to correct it. The test is unchanged and is applied per claim: what it asked for, in this venue, existing. **THE STRONGEST DISCHARGE IS A DERIVATION RATHER THAN A HABIT, AND IT IS WORTH RECOGNIZING AS ONE.** Where what a directive asked for becomes a property of a mechanism — a quantifier that cannot reach the state it forbids, a refusal that cannot be bypassed — the instruction stops being a thing seats must remember, and that is discharge in its completed form rather than a seat's report of compliance. **AND A DIRECTIVE WHOSE PREMISE THE TREE REFUTES IS STILL DISCHARGED HERE RATHER THAN ARGUED WITH.** Whether a standing instruction still binds is its author's to decide, so a venue neither withdraws nor narrows one — it records what it observed, discharges its own half, and leaves the instruction where its author can reach it. Holding a venue open on an instruction nobody in the loop may resolve is the one disposition that helps nobody. **The measured shape this section exists for:** a directive arrives as a bare unfenced line at the end of a venue — no fence, no allocated id, no author record, no addressing, no reader set — because the schema declares nowhere else for it to land. The shape recurs across venues rather than standing alone, which is what makes it a class rather than an incident. Every seat then applies the surface's lifetime to a content class that does not carry it, which is a reader applying the wrong lifetime with the mechanism agreeing, on the venue deciding that exact question. **AND THE DELETION GOES THROUGH THE EXTRACTION-DECLARING REMOVAL PATH, WHICH IS WHY THE LIFETIME IS ENFORCED ON BOTH HALVES RATHER THAN ONE.** A convergence edge asking whether this section is empty evaluates a SINGLE state, so a directive deleted WITH its extraction and one deleted WITHOUT leave an identical empty section — the durable-half clause would be declared, correct, and observed by nothing. The removal path that already refuses without a reference naming where an extraction landed, and refuses again where that reference does not resolve, is the same refusal on the same argument: it decides PRESENCE of the reference and claims nothing about fidelity, because extraction is a compression and a text comparison would fail every correct one. So a directive discharges exactly as an absorbed item does, by adding a caller rather than a mechanism. - ## Fixed position schema **A POSITION IS POSTED THROUGH THE TOOL, NEVER HAND-PLACED**, and the record below is what makes that possible: `npm run await -- --agent --file --item ""`. The tool writes into the calling seat's own delimited record, so the fence, the item id, the addressing, the compare-and-swap, the reader set and the drain machinery all apply here exactly as they do on the board. **A VENUE WITHOUT A PER-WRITER RECORD REFUSES EVERY TOOL WRITE**, and the fallback is hand-editing a document with no span anybody owns — which is four seats writing anywhere, positions interleaving, and one seat repairing text inside another's section because nothing makes the ownership decidable. Measured: the tool answers `REFUSED no single delimited block for AGENT ` against a venue that carries none. **THE VENUE RECORD IS NOT THE BOARD RECORD, AND COPYING THE BOARD'S FIELDS HERE IS A CATEGORY ERROR.** The board answers _who owns what and what is directed at whom_ — coordination STATE, current-truth-only, swept. A venue answers _where each seat stands on one question and what it still needs to sign_ — an ARGUMENT, which accumulates until it converges. The fenced record and the fenced item are the TRANSPORT the two surfaces share, which is what makes a tool write and a per-writer span possible; **the FIELDS belong to the concern and never transfer.** A venue carrying `Owns` and `Refs` is describing ownership in a document about a decision, and the pressure to do it comes from the tool rather than from the discussion. **The specimen is FENCED so the scanners read it as a record MENTIONED rather than CLAIMED.** A seat unfences its own copy below, outside a fence, with the placeholders resolved. ```text ┌─── AGENT ─── one writer: · others cite, never edit · anchored EDIT only, never a whole-file WRITE Agent — Reading: Stance: Needs: Durable: Positions: — └─── END AGENT ``` **THE ACCUMULATOR IS READ WHOLE BEFORE A HEADING IS AUTHORED, BECAUSE NOTHING ELSE PROMPTS A SEAT TO OPEN IT.** Every mechanism touching that surface WRITES to it, and the one path that reads it is a removal refusing without a reference naming where an extraction landed — which reaches a seat at the moment of DELETION and never at the moment of AUTHORSHIP. So the single operation that most needs the existing classes is the one operation nothing routes to them. **Measured: a class was composed from three instances across two seats, ruled durable, and found already held by three existing entries — with one instance recorded VERBATIM before it was independently rediscovered.** Neither party was careless and neither had read the accumulator. **The cost of the miss is a near-duplicate heading**, which degrades a class surface exactly as any duplicated fact does, except that here every consumer is a reader, so nothing resolves it and no comparator can act. **So the heading is authored against the existing set rather than from the finding alone**, and where an instance belongs to an entry that already holds its class, the entry is AMENDED in the class's own terms — including the axis that entry was silent on — rather than given a sibling. **AND A BOUNDARY NAMES THE AXIS ITS AUTHOR DEFENDED AND GOES SILENT ON THE AXIS ITS READERS TRAVEL.** A boundary is written while its author is holding a specific neighboring class, so it separates the two along whatever distinguishes them — and a later reader arrives holding an ARTIFACT, a FINDING and a COST rather than a taxonomy. **A reader classifies by COST and a class is defined by MECHANISM**, so where two classes produce the same cost the natural classifier and the defining one disagree, and every reader with a real finding in hand uses the natural one. **That silence is invisible to the author by construction, because the author never traveled that axis.** Measured: three of five parties independently applied one class to a surface its own discriminator excludes, inside one round, each reasoning carefully from an entry that did not exclude them — which makes it a defect in the BOUNDARY rather than in three readings. **So the question at authoring time is what a reader will be HOLDING when they reach for this class, and whether the boundary can be applied from that alone.** Where it cannot, the axis it needs is the one joining the reader's operand to the class's discriminator — and a cost shared by two classes is not a classifier for either. This is publish-the-criterion asked of a boundary rather than of a refusal. **`Durable` is how the extraction becomes checkable without violating the accumulator's own contract.** An accumulator heading is a kebab sentence naming the CLASS, never the episode — so no correct entry ever carries a venue's name, and an edge searching the accumulator FOR the venue can never be satisfied by a correct extraction. The seat names its own heading here instead, and the convergence walk joins the active roster to those headings: each active seat declares one, and each declared one resolves in the accumulator. That makes the edge quantify over the same set as the obligation — every seat's durable half authored by its own author — rather than over a name the contract forbids. **`Positions:` is the field the tool appends into, and it is the venue's analogue of the board's directed-item field rather than a copy of it.** Each position lands there as a fenced item carrying its own id, so the span is addressable and the argument is attributable — and the tool refuses a venue record that does not declare the field, naming the surface, because an item landing in the wrong field is an argument filed as ownership. **`Needs` is the field the board has no analogue for and the one that makes convergence checkable.** A seat that cannot sign states what is missing, so the discussion has a derivable remaining set instead of a judgement about whether it feels settled — and an empty `Needs` across every active seat is what convergence LOOKS like rather than what somebody declares. Each position the tool posts lands inside that record as a fenced item, and carries these fields: Position
— Axis: Evidence: Proposes: Costs: Contradicts: Signed: ## Gate - `blocking/unresolvedDiscussion` while the file exists · `blocking/noExitCondition` when no exit is stated. - The scan is depth-agnostic: a scan anchored to a fixed depth reads PASS over a blocker one level below. - Every outcome clause cites a resolvable position; an uncited clause is not agreed. ═══════════════════ POSITIONS ═══════════════════ **A POSITION LIVES INSIDE ITS AUTHOR'S SEAT RECORD AND NOWHERE ELSE**, so this section carries the seat records and no position of its own. A top-level specimen position is a second statement of one contract: the schema above states that the tool appends into the calling seat's `Positions:` field and refuses a record that does not declare it, so a specimen at column zero describes a home the contract does not give it. It also lands in every venue raised from here as two positions the gate reads as hand-placed — correctly, because an unfenced record at column zero is a record CLAIMED rather than MENTIONED. **Fencing preserves the contradiction and deleting removes it**, which is why this section holds neither. The field schema is the contract, and a reader wanting a position's shape reads it there. Each seat's record is unfenced from the specimen above, one per active letter, and positions arrive inside them through the tool. ═══════════════════ SIGN-OFF ═══════════════════ One self-owned line per agent. **The owner is out of the loop and signs automatically**, so the owner row states that rather than sitting empty: no venue waits on it, and the convergence walk quantifies over active seats, which puts the row outside every edge by construction. An empty owner row invites a seat to hold a converged venue for a signature that is never coming, which is a hold on nothing. **THE SEAT ROWS ARE RESOLVED AT RAISE FROM THE ACTIVE ROSTER AND ARE NEVER COPIED FROM HERE**, exactly as the roster line above is. **A transcribed seat set is a POPULATION written at one cardinality and consumed at another**: the convergence walk derives its quantifier from the live roster, so a template seeding a fixed set of letters produces a venue that disagrees with the check reading it, at birth, from a source that reads as authoritative. **AND THE FAILURE IS A TOTAL DEADLOCK RATHER THAN AN INCONVENIENCE, WHICH IS WHY THE DERIVATION IS THE FORM.** A venue cannot converge while a seat is unsigned; a seat cannot sign without a row; and the signing form refuses for want of the row rather than for want of agreement. **So a seat whose letter the template never anticipated blocks that venue permanently by existing**, and from the edge's report _declined to sign_ and _had nowhere to sign_ are one word. Measured: a seat outside the transcribed set met exactly that refusal, and its only available act was a hand write into the surface the protocol elsewhere refuses to hand-edit. **A SEAT JOINING AFTER THE RAISE IS THE HALF THE DERIVATION DOES NOT COVER**, since the roster is resolved once. That seat's row is raised by the form rather than by hand — a sign-off row is self-owned by construction, so raising one is a write inside a span no other seat owns and takes the same protections every other write takes. ```text owner: automatic ``` ═══════════════════ OPEN QUESTIONS (unresolved only) ═══════════════════ - (none) ````