§04 PART 5/5 (13,014 chars · Sections: Bring One Assignment With an Uncertain Outcome; The Twelve Coordination Claims; The Article 04 Claim Card; The Room Is Where Authority Becomes Current; Frequently Asked Questions; Continue the Series; Primary 2026 Sources; Publication Metadata) — ← Part 4 · §05 Part 1 → · 1-Call Brief · Full §04 · Raw .txt · All: P1 P2 P3 P4 P5

Bring One Assignment With an Uncertain Outcome

The Multi-Agent Coordination & Acceptance Audit Challenge evaluates one assignment whose delivery, ownership, or completion is currently hard to prove. The demonstration maps causal readiness, replays sealed-wake acceptance and refusal, and measures the resulting artifact and destination rather than trusting completion prose.

The challenge excludes universal adapter or native-session attestation, production write authority, and exactly-once external effects. Deployment and paid pilots are separately scoped; independent evaluation remains outside the commercial ladder through Article 09.

The Twelve Coordination Claims

ID Bounded claim Evidence and ceiling
04-C01 Split-brain state trees are refused, and project grants revalidate canonical path plus 192-bit combined kernel object identity Implemented and author-verified on local NTFS/ReFS territory; not a remote-share or host-admin guarantee
04-C02 Enrollment, thread-local sessions, native conversation binding, tier clamping, and multiplexer verb probing bind every connector call to a principal and route Implemented and author-verified on declared MCP/CLI paths and host contracts
04-C03 Room shards carry immutable scope bindings and parent-withholding closure Implemented and author-verified for graph queries, compositions, and exports; hash artifacts do not prove non-deletion
04-C04 The sync index reconciles handle-pinned journals across hash/HLC chains and binds checkpoints to conversation and view Implemented and author-verified for rotation, fork, and delivery-policy refusal paths
04-C05 The Work Gate requires live frontier and recursive causal-parent confirmation before all nine participant verbs Implemented and author-verified; blind writes receive a sync page, not authority
04-C06 Contribution verbs separate status, response, assignment, ownership transfer, and completion Implemented and author-verified for ambiguity, cross-Room evidence, successor, and no-wake paths
04-C07 Every wake is an 18-field permit revalidated at dispatch and worker claim Implemented and author-verified for binding, roster, registration, task, epoch, path, PID, and original-deadline changes
04-C08 Wake-time evidence is recipient-specific and governing-source coverage is continuous over [0, length) Implemented and author-verified through wake_delivery receipts and bounded time windows
04-C09 Native delivery and reply are distinct proof states; process exit alone never resolves an obligation Implemented and author-verified for declared adapters; not a universal UI or remote-session attestation
04-C10 Cancellation holds in-flight work and confirms owned-Job termination only at zero active processes Implemented and author-verified through the two-phase durable stop outbox; accepted destination effects remain for reconciliation
04-C11 Delegation and completion use 16-level ancestry, 7 acceptance kinds, and 14-key final authority revalidation Implemented and author-verified; acceptance is bounded by configured predicates and protected observation paths
04-C12 Five runtime invariants constrain event law and emit dedicated violation evidence Implemented and author-verified; exactly-once event handling does not prove exactly-once external effect

The Article 04 Claim Card

Mechanism:
  The AINA Room Coordination Plane
  (state identity, project grants, connection/session authority, tool policy,
   graph shards, visibility, sync, contribution verbs, wake permits,
   Session Factory, worker confinement, cancellation, acceptance, invariants)

Failure it governs:
  Source history and chat impersonating live authority;
  split-brain state and redirected territories;
  stale context, causal-parent blindness, and ambiguous obligations;
  stale queued wakes and wrong-session delivery;
  process exits and agent prose impersonating completion;
  unobserved cancellation and unverified task closure.

Positive path:
  EISA-recognized act
  → current principal, native conversation, project, Room scope
  → confirmed causal frontier
  → task-bound contribution and 18-field sealed wake
  → dispatch and split-lock worker-claim revalidation
  → confined execution and native reply proof
  → 7-kind artifact/destination acceptance
  → terminal evidence or explicit in-doubt reconciliation.

Refusal / hold path:
  project_root_redirected, actor_mismatch, graph_project_rebind_refused
  room_sync_required, room_sync_receipt_forked
  say_reply_target_ambiguous, cross_room_evidence_refused
  wake_room_authority_changed, wake_recipient_registration_changed
  wake_job_changed_during_validation, wake_job_expired
  wrong_body_rejected, process_exit_only
  held_until_reconciled, task_acceptance_changed_before_completion
  file_absent observation unconfirmed, IndoubtEffect.

Evidence status:
  Implemented and Author-Verified across the declared Windows reference
  embodiment and native adapter contracts.
  External 2026 research is primary-source context, not endorsement.
  Not Independently Validated and not a universal external exactly-once claim.

Verifier and artifacts:
  state_dir_id.json, ProjectGrant.root_object_id,
  secret_sha256, SessionGuard, EffectiveTier and VERB_PROBE,
  binding.json, content-addressed blobs, sync_index.db,
  conversation_key/view_gen checkpoints, causal CTE results,
  room-wake-job-v3/binding_sha256/RequestPermit,
  srv_ wake_delivery receipts, sf_ native sessions,
  room-stop-reports phase-1/phase-2 and committed markers,
  acceptance_results, task_done, invariant_violation nodes.

Scope and claim ceiling:
  Kernel object identity and process containment are Windows reference mechanisms.
  Native host metadata is trusted only within each adapter's declared contract.
  Composition is read authority, never execution authority.
  Delivery is not reply; reply is not acceptance; acceptance is configured evidence.
  Exactly-once event resolution is not exactly-once external effect.
  No privileged host-admin bypass or universal adapter claim is made.

Next stage in the machine:
  Article 04 establishes live coordination and verified assignment.
  Article 05 enforces typed leases, monotonic generations, and kernel write
  exclusion at the actual mutation window. Expiry alone is not fencing.

Commercial doorway:
  Multi-Agent Coordination & Acceptance Audit Challenge — bring one
  assignment with uncertain delivery, ownership, or completion; receive
  a causal-readiness map, sealed-wake validation replay, and artifact-based
  acceptance demonstration (Article 09 · me@blayneaina.com).

The Room Is Where Authority Becomes Current

A recognized act can be mathematically sound and still be operationally stale. The evidence may be valid, the partition correct, the destination plausible—and the worker may be reading an old frontier, holding a replaced registration, answering a superseded task, or exiting before it ever replied.

The Room closes that gap by making every stage re-establish its own predicates.

Territory is re-queried. Credentials are re-read. Conversation checkpoints are recomputed. Causal parents are walked. Wake permits are revalidated at launch and claim. Evidence is served to the recipient. Native replies are correlated. Cancellation is observed at the kernel. Acceptance is measured against live artifacts. Invariant violations remain visible.

That is why the Room is a coordination plane rather than a transcript.

Git tells you what history recorded. Chat tells you what was said. The Room tells you what may happen now—and what still has not been proven.

Article 05 narrows the final coordination question into the mutation window itself: who holds the typed lease and current generation, and how does the operating system prevent a stale writer from crossing the write syscall?

Frequently Asked Questions

Why aren't Git worktrees enough for multi-agent coordination?

Worktrees separate source histories and defer conflict resolution to a later merge. They do not establish current resource ownership, causal observation, wake validity, native delivery, or artifact acceptance. Git remains valuable for source history; those additional properties need a live coordination plane.

Why isn't a workflow checkpoint enough?

A checkpoint can resume a plan. It does not prove that the plan remains valid for the current actor, native conversation, registration, project, task ancestry, authority revision, or control epoch. The Room revalidates those conditions instead of treating resumability as standing.

What makes a Room wake different from a prompt queue?

A wake is an 18-field permit bound to the recipient, task, evidence, Room authority, registration, control epoch, and original deadline. It is revalidated at dispatch and again inside the worker's split-lock claim. A queued prompt by itself carries none of that proof.

Is delivery to an IDE session proof of completion?

No. Dispatch, body delivery, body visibility, wrong-body refusal, and reply are separate states. Process exit without a correlated reply is process_exit_only and leaves the obligation unresolved. Completion additionally requires privileged acceptance over actual artifacts and destination state.

Why does file_absent use try_exists()?

Because an unreadable or inaccessible path is not proven absent. try_exists() returns an observation error, and the acceptance check fails closed with observation: "unconfirmed" rather than converting missing permission into a passing absence claim.

Do the five invariants prove exactly-once external effects?

No. They constrain idempotency, lifecycle, exclusivity, causality, and resolution in the event system. A destination can still mutate before a receipt fails or crash occurs. That uncertainty must be observed and reconciled through the destination and recovery paths.

Continue the Series


Primary 2026 Sources


Publication Metadata

Title tag: The Room: Why Git and Chat Are Not Coordination Planes
Meta description: Why Git worktrees and chat transcripts cannot govern live agents: inside The Room's territory pins, causal sync gate, sealed wake permits, native-session proof, cancellation, and privileged acceptance.
Series navigation: Series index · Article 04 of From Proposal to Consequence: The AINA Transition-Governance Series.
Previous installment: Article 03 — Semantic Switch and EISA: Protected Computation and Entity Resolution.
Next installment: Article 05 — Expiry Is Not Fencing: Typed Leases and Kernel Write Exclusion.

END OF §04 PART 5/5 — Next Article: https://blayneaina.com/05-expiry-is-not-fencing-typed-leases-and-kernel-write-exclusion/part-1/ · §04 1-Call Brief · Raw .md