# §04 Part 1/5 — The Room Coordination Plane Canonical: https://blayneaina.com/04-the-room-why-git-and-chat-are-not-coordination-planes/part-1/ | Raw Article: https://blayneaina.com/04.md | Next Part: https://blayneaina.com/04/part-2.txt # The Room: Why Git and Chat Are Not Coordination Planes *Source history records what changed. Chat records what was said. The Room decides who may read, act, receive, stop, and close work now—and makes every transition prove it.* **By Blayne Aina · Principal Systems Architect and creator of AINA · October 31, 2026** --- A commit proves what source history recorded. A chat message proves what someone said. Neither proves who may mutate a live resource now, whether the intended native session received the assignment, whether the worker saw every causal parent before acting, whether a queued instruction still has authority, or whether the resulting work passed acceptance. That is the coordination problem. It does not disappear because agents have worktrees, checkpoints, tool schemas, and an execution log. Article 03 produced recognized constitutional acts and committed them as `eisa_<32hex>`. Article 04 is the machine that gives those acts a live authority domain: **The Room**. > **The Room is not a chat channel. It is a coordination plane that binds territory, identity, observation, delivery, execution, cancellation, and completion into one revalidated authority chain.** ## The Whole Machine, Not a Wake Queue The Room includes eleven cooperating mechanism families grouped into six architectural domains. Nine receive numbered subsystem sections below; worker staging and controller-side brokerage are developed within native execution and cancellation rather than numbered separately. Treating the Room as a messaging API leaves most of its assurance on the table. ```text [1. TERRITORY & PRINCIPAL PINNING] state-tree identity + 192-bit combined Win32 project object IDs CSPRNG enrollment + thread-local SessionGuard + native conversation binding EffectiveTier clamp + multiplexer verb probing + stdio/pre-model egress isolation │ ▼ [2. PER-ROOM GRAPH SHARDS & VISIBILITY] immutable scope binding + content-addressed artifacts monotonic parent-withholding closure + multi-Room composition reparse-safe snapshot recovery │ ▼ [3. ROOM SYNC ENGINE & PRE-ACTION WORK GATE] per-Room SQLite WAL sync index + handle-pinned journal reconciliation conversation/view checkpoints + recursive causal-parent verification atomic turn commit + Fold Rule + post-read revalidation │ ▼ [4. CONTRIBUTION GRAMMAR & SEALED WAKE PERMITS] note / reply / say / send / handoff / done with different authority effects 18-field room-wake-job-v3 + dispatch and split-lock revalidation per-recipient evidence delivery + complete governing-source coverage │ ▼ [5. NATIVE SESSIONS, CONFINED WORKERS & ACTIVE CANCELLATION] Session Factory v1 + five delivery/reply proof states row/column staging + controller-side MCP broker held in-flight operations + 1 Hz Job observer + two-phase stop outbox │ ▼ [6. TASK LINEAGE, PRIVILEGED ACCEPTANCE & RUNTIME INVARIANTS] 16-level delegation ancestry + 14-key completion revalidation 7 engine-evaluated acceptance kinds exactly_once + well_formed + exclusive + causal + resolution ``` The result is a continuous authority path: ```text EISA-recognized act → live actor, credential, native conversation, project, and Room scope → confirmed observation of the live causal frontier → task-bound contribution and sealed wake permit → dispatch-time and worker-claim authority revalidation → confined execution and native reply proof → destination and artifact acceptance → terminal evidence or explicit in-doubt state ``` ## One Assignment Through the Machine Consider a coordinator assigning renewal-evidence review to `reviewer-beta`. The path is not “write a prompt and hope the right agent answers”: 1. **Territory and principal.** The coordinator's credential, native conversation, project object, and Room scope are re-derived. The recipient's registration is current. 2. **Recognized work.** An EISA submission supplies the constitutional act and its evidence handles. The task binds that work to an exact project and acceptance contract. 3. **Observed readiness.** Before the coordinator can send, the Work Gate proves the conversation checkpoint covers the live frontier and every required causal parent is confirmed. 4. **Sealed assignment.** `send` writes the message and obligations, then seals an 18-field wake permit with the recipient, task, evidence, registration, Room authority, control epoch, and original deadline. 5. **Dispatch revalidation.** The Room rechecks the permit, roster, registration, task ancestry, governing source, project, admission, epoch, and remaining time. Evidence is admitted specifically for `reviewer-beta` and delivered with a fresh `wake_delivery` receipt. 6. **Split-lock worker claim.** The worker first validates context outside the transition lock, then rereads the job inside it and requires the unchanged binding digest before claiming. 7. **Native delivery.** The bound native session receives the prompt. Dispatch, body delivery, body visibility, wrong-body refusal, and reply remain separate facts. 8. **Reply and production.** The worker returns a correlated reply and produces the required artifact. Process exit alone would leave the obligation unresolved. 9. **Privileged acceptance.** The engine measures the artifact digest, distinct evidence origins, destination effect, and original worker receipt against the declared acceptance checks. 10. **Terminal closure.** Completion revalidates all 14 task-authority keys, releases the scope through the structured path, and records `task_done`. If registration changes before dispatch, the old wake stops with `wake_recipient_registration_changed`. If cancellation arrives after launch, new effects stop, the owned Job is terminated, and only `ActiveProcesses == 0` confirms quiescence. Any destination operation whose outcome is uncertain remains `held_until_reconciled`; it is not relabeled “cancelled and safe.” ## 1. Git and Chat Are Necessary—and Insufficient Git is an excellent source-history plane. Chat is an excellent human and model communication surface. The Room does not replace either. It prevents their artifacts from impersonating live authority. | Existing primitive | Native value | Additional question the Room answers | |---|---|---| | Tool-call schema | The proposal has a valid shape | Is this exact act recognized, currently standing, and inside the caller's verb and tier authority? | | Graph/workflow checkpoint | A prior plan can resume | Is that plan valid for the current target, conversation, task lineage, registration, generation, and control epoch? | | Git worktree | Source histories and working directories are separated | Who owns the live resource and may produce this effect now? | | Model reviewer or vote | More cognition and critique | Which deterministic predicate admits or refuses the act? | | Execution log | A tool reported an outcome | Did the destination and receipt chain verify it, and did the responsible native session return it? | | Idempotency key | A retry can be deduplicated | Was the effect committed, and was the original obligation actually answered? | Clean merges do not prove semantic non-interference. Two agents can edit different lines and violate a shared invariant. They can modify separate files whose combination is unsafe, call the same external API twice, or make locally valid decisions against the same stale pre-state. Mature coordination systems—consensus services, compare-and-swap stores, MVCC databases, lease and fencing protocols, durable workflow engines—absolutely can answer these questions. The claim is not that AINA invented coordination. The claim is that **source history and conversation are the wrong artifacts to carry its full burden**. A conventional stack that enforces the same canonical transition through the same current predicates earns the same functional credit. ## 2. Subsystem 1: Territory and Principal Identity Authority starts by proving which state tree and which physical project object the act concerns. ### Split-brain state-tree refusal Before the engine opens its state tree, `validate_state_dir` requires the state-directory identity marker. The marker carries an `id` and `canonical_path`; the machine bootstrap supplies the canonical instance and root. A missing marker, an unreadable bootstrap, a different instance ID, a noncanonical path, or a mismatched `SQUAD_ROOT` fails closed. This prevents two `.squad` trees from independently accumulating tasks, leases, credentials, and Room history while believing they are one machine. It is not a path prettification step. It is a split-brain admission gate. ### Project grants pin path and kernel object identity An owner-opened `ProjectGrant` binds: - a unique project ID and bounded name; - the requested and canonical root paths; - `root_object_id`, a 192-bit combined identity: a 64-bit volume serial number plus the 128-bit NTFS/ReFS file ID; - opening actor and time; - an optional governing-source grant and its reading policy. The directory is opened with backup semantics and queried through `GetFileInformationByHandleEx(FileIdInfo)`. Every live authorization rechecks both canonical path and object identity. A junction, symlink, replacement, or redirected root produces `project_root_redirected`. Project opening refuses non-directories, filesystem roots, broad owner containers, control and recovery storage, worker roots, and overlapping project territories. Roster membership does not widen this boundary. `ReadAuthority` applies the same provenance discipline to shared briefcases, contexts, artifacts, braindumps, and proposals: project-scoped records go to admitted project readers, coordination records to the appropriate Room roster, and legacy unscoped records only to their original author. ### CSPRNG enrollment without persistent plaintext secrets Agent enrollment generates a 32-byte secret with Windows `BCryptGenRandom`. The controller stores only `secret_sha256`, issuance, revocation, and target metadata. Host configuration receives the actual token for connection authentication; enrollment receipts do not return it. Multi-agent enrollment restores exact preimages if any step fails. Every call revalidates the current credential digest, so rotation and revocation affect live connections without a restart. ### Thread-local sessions and native conversation identity `SessionGuard` binds one authenticated session to one synchronous dispatch. Its `PhantomData>` prevents the authority guard from moving across threads, and `Drop` removes the active frame during normal return or unwind. `IS_HTTP_WORKER` closes the privilege-fallback path: an HTTP worker thread without an active request session never inherits the process launch principal. For supported Codex hosts, `bind_tool_request_context` reads `params._meta.threadId` outside model-authored arguments, requires a non-nil canonical UUID, and binds `codex:` as the native conversation. The authenticated host is the metadata trust boundary. This is not cryptographic attestation against every process that might possess its credential, and Article 04 does not claim otherwise. Self-identifying argument fields must match the bound principal. Mismatches produce `actor_mismatch` and an integrity signal rather than letting a model nominate a more privileged author. ### Tier clamping includes the route, not just the tool name The effective tier is the minimum of: ```text session-declared tier owner per-agent max_tier fleet-wide control ceiling ``` Owner policy and the fleet ceiling are re-read on every invocation. The multiplexer guard then derives verb routes from the MCP schema build table using `VERB_PROBE`. A denial of `room_note` therefore also blocks `squad_room` with `{"action":"note"}`. Blocking the friendly tool name while leaving the generic route open is not policy enforcement. ### Stdio and pre-model egress are separate boundaries The MCP transport duplicates its original input/output as private handles and clears inheritance flags. Process standard input is detached, and standard output is redirected to diagnostics so a child cannot corrupt the JSON-RPC wire or retain the parent's pipe accidentally. Before a result or error reaches model context, every string passes `redact_checked`. If the redaction policy cannot be established, the response becomes `tool_result_withheld`. The tool may already have run; the uninspected result still does not escape.