§04 PART 1/5 (14,370 chars · Sections: Introduction & Overview; The Whole Machine, Not a Wake Queue; One Assignment Through the Machine; 1. Git and Chat Are Necessary—and Insufficient; 2. Subsystem 1: Territory and Principal Identity) — Part 2 → · 1-Call Brief · Full §04 · Raw .txt · All: P1 P2 P3 P4 P5
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.
[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:
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”:
- Territory and principal. The coordinator's credential, native conversation, project object, and Room scope are re-derived. The recipient's registration is current.
- 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.
- 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.
- Sealed assignment.
sendwrites the message and obligations, then seals an 18-field wake permit with the recipient, task, evidence, registration, Room authority, control epoch, and original deadline. - 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-betaand delivered with a freshwake_deliveryreceipt. - 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.
- Native delivery. The bound native session receives the prompt. Dispatch, body delivery, body visibility, wrong-body refusal, and reply remain separate facts.
- Reply and production. The worker returns a correlated reply and produces the required artifact. Process exit alone would leave the obligation unresolved.
- Privileged acceptance. The engine measures the artifact digest, distinct evidence origins, destination effect, and original worker receipt against the declared acceptance checks.
- 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<Rc<()>> 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:<UUID> 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:
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.
END OF §04 PART 1/5 — Next: https://blayneaina.com/04-the-room-why-git-and-chat-are-not-coordination-planes/part-2/ · §04 1-Call Brief · Raw .md