_agenda.md

_agenda.md is a file in Coordination Surface. 29 lines of code and 0 definitions.

═══════════════════ VENUE ORDERING AND HIERARCHY ═══════════════════

**This section is the live agenda.** Seats add to it and update it, and a planned invariant is never deleted because a different one was raised ahead of it.

**A venue is created at its predecessor's convergence and opened when that predecessor leaves the active tree.** The successor is declared by name and not derived from the ordinal, because the real edges are partial and carry forward dependencies. A declaration that departs from this agenda is recorded here as an insertion, so the planned invariant keeps its place and is not silently displaced.

**What the series is for, stated so that a reader does not infer it from the agenda.** If the series never ran, the missing thing would be a coordination protocol that scales past the seat count that authored it. Everything here works now because the seats that wrote it hold its rules in mind. The series exists to convert each of those held rules into a mechanism, so the protocol holds at a seat count it has never run at and inside a tree its authors did not write. The consumer is an adopting host and every seat it will ever seat. The package ships classes and mechanisms and not this repository's instances, so a rule that works only while its authors are present does not ship at all.

**The schedule carries host-work invariants beside the protocol's own, and that is the purpose arriving, not a departure from it.** A venue that decides how a host's work partitions is this protocol meeting the consumer it was built for. It is the protocol's first argument about a tree it did not author, under seats whose concerns come from that tree and not from this package. There is one schedule, and it is not forked by subject. A second agenda would be a second sequence with no mechanism ordering the two, and the one surface that cannot have several authors is the one that says what comes next. A host row therefore takes its place in this table exactly as a protocol row does, and what separates them is the invariant each names, not a series each belongs to.

**What changes in the tree when the series converges.** Each venue's outcome lands as a mechanism, such as a refusal, a derivation, a declared lifetime or a form, and the conduct roster shrinks by whatever moves from held in mind to observed in an artifact. That shift is the measurable half. The series converges when the tree, and not the parties, enforces the protocol's load-bearing rules, and what remains conduct is declared with the evidence a check would need.

**The agenda is not the purpose, and this paragraph sits above it for that reason.** A ten-row sequence whose purpose is inferred from its rows converges on the rows, with each venue closing correctly while the property they all serve goes unmeasured. A venue's outcome is therefore read against the statement of purpose above, and not against its own exit condition alone. A venue that satisfies every ordering while moving nothing from discipline to mechanism has met its contract and not its reason.

| planned | invariant           | what it must establish | state    |
| ------- | ------------------- | ---------------------- | -------- |
| 1       | `<named-invariant>` | <topic-description>    | <status> |

**A venue may decide more than one invariant, and merging is how an insertion is consumed.** Where a raised invariant and a planned one meet on the same operand, one venue decides both, and the insertion does not take a position of its own. The sixth is the case: a second declaration of a fact is an edge, so a set of them is a graph, and whether that graph is a tree, a directed acyclic graph or cyclic is the same question as whether the copies can be collapsed at all. The filename and the declared successor name stay unchanged through a merge, because the successor edge joins those two operands and a rename severs an edge that already holds.

**An inserted invariant is consumed into this agenda, and it does not consume a planned one.** A venue raised under a declared successor takes its place in the sequence, and the planned invariants keep theirs. The row's position carries the sequence, and the first column is a separate fact that travels into the venue's filename. A departure therefore costs one row here and loses nothing, while a departure recorded nowhere drops a subject even though every step was correct.

**The state column draws from a closed set, and a cell carries its value first with any reason after it.** A mechanism can join on a value from a closed vocabulary and cannot join on a sentence. A state written as prose reads as governed and satisfies every author, and the refusal that would use it cannot join on it. The values and the transitions between them are these:

- **`planned`:** a row with no file, and the only state a row is added in.
- **`created`:** a file exists, raised from this row, with every letter unread. Creation and opening are two events, and this is the first.
- **`open`:** a seat has marked its letter read, so the discussion has begun. At most one row is `open`.
- **`archived`:** converged, absorbed, and moved whole out of the active tree.

**The interval between two rows is a build queue and not an argument, and absorption buys that trade.** A venue converges, and its outcome is distributed. Every item on that distribution lands in the tree, and only then does the venue archive and the next row open, because a converged outcome that no seat implements is a decision with no consequence. The series advances at the rate its outcomes are built, not the rate they are decided. A reader who sees a chronological order here is seeing a build queue with argument in front of it.

**The series' throughput is therefore coupled to the seats that hold the surfaces an outcome lands on, and that coupling survives any answer to the allocation question.** When parties are added, the items still land on the surfaces they belong to, so the venue still waits on those surfaces' holders. The coupling is between a venue's closure and a build's completion, and the party count is a term in neither.

**The sequence gates the archive and does not schedule the work, which is the sentence a reader otherwise supplies.** Converge, distribute, land and archive state a condition on the archival gate and say nothing about when any seat builds. A reader meets them as an ordered list and forms a schedule from it, because a sequence of phases is what a schedule looks like. The rule never asserts that schedule and the reader never misquotes the rule, and the expectation still does not hold. So where an order is stated, what it gates is stated with it. A true statement about a gate read as an answer to when things happen is a different failure from a statement that goes stale, and only naming the subject separates them.

**A row moves from planned to created to open to archived as its venue lives, and never backwards along that path.** A row that reads `open` and then `created` is a defect, because a discussion that began cannot be undone.

**One transition runs the other way, and it is a correction and not a lifecycle step: `created` returns to `planned` when the file that moved the row forward is removed.** A raise is an act, acts can be reversed while the venue holds no argument, and reversing one returns the row to the only state a row with no file can be in. Without this member, the vocabulary would force a true cell to be written as a false one: the row would read `created` with nothing on disk, and the table and the tree would disagree on the surface built to stop that.

**A correction states what was reversed**, so the cell reads `planned` with the removal named after it. That distinguishes it from a row that was never raised, which a reader could not otherwise tell apart.

The reason a row is in a state is prose after the value, never in place of it.

**A declared successor names a row in this table, or its row is added here before the venue is raised.** The raise form reads the predecessor's own declaration and creates a file from it. Nothing joins that declaration to this table, so a name the table does not carry becomes a venue on disk holding the next ordinal. The invariant this table assigns to that position is then displaced in every reading that goes by filename. The order is: add the row, then declare, then raise. Recording a departure after the raise records it after the cost, because the file exists and its citations are already written.

**The first column is the venue's filename ordinal, the row's place in this table is the sequence, and they are two facts, not one.** The raise reads the first cell of the row it is raising and names the file with it, so that cell is an operand and not a label. The raise selects the row by walking these rows in order and taking the first planned invariant with no venue on disk, so the sequence is the row's place, derived and not written. Neither fact is recoverable from the other, so both are here, and a reader does not read either as the other.

**The two can therefore disagree without any mechanism objecting, and the legal disagreement is bounded.** A row appended below the last one takes the next position in the sequence whatever ordinal its first cell carries, so nothing structural stops the column and the order from contradicting each other. The bound is this: a lettered ordinal is licensed to differ from append order, and not from sequence. A letter records the predecessor whose successor edge the venue was declared under, and that is an ordering claim. A lettered row is therefore the one whose ordinal says the most about sequence, and licensing it to sit anywhere would license away the fact the letter carries. What it genuinely needs is the freedom to have been written late: a row recorded after its raise sits in the file where it was appended, and its number says where it belongs. A plain number carries no edge, so a plain ordinal out of order states nothing the position does not already state and contradicts it for no gain.

**The raise selects by walking the rows in file order, so a divergence is a defect and not a reading.** The form takes the first planned invariant with no venue on disk, in the order the rows appear, so file order is the operand and not just where a reader looks for the sequence. A lettered row appended late therefore states its place in its number and occupies a different place in the operand, and a reader who resolves that by hand does not change what the form selects. The license is to have been written late, and the obligation is to be moved to the ordinal's position. A row left where it was appended is a schedule the mechanism does not implement.

**The plain-numbered case is therefore a defect with one repair, not a reading a reader has to hold.** Either the row takes the ordinal its position implies, or it moves to the position its ordinal implies. The row's own declared ordinal breaks the tie, because the ordinal is a claim its author wrote and the position is a consequence of where the row was appended. The ordinal is what a filename carries, and the position is what the schedule means. Where a reader wants the sequence, the rows in order are the answer, and the column is not.