Without UrHierarchy-Inherited Observer Registration Each Chat Room Requires Its Own Observer Registration

Claim

In the eOS-Harness MVA running against DGD 1.7.9 plus the eOS-kernellib chat-app multi-agent-coherence branch, when a chat room has neither its own observer nor an ancestor carrying one, a message posting in it is recorded by nothing. A room is created with no ur-object and no chat-room.message:main observer of its own; a post_message writes chat-room.message; the dispatcher's ancestry walk climbs query_ur_object() and finds no append observer at any level, so no reaction fires and the room's message log stays empty. This is the contrast that gives the inherited-observer demonstration its weight: a single observer on a shared ancestor serves the whole cohort, but a room outside that ancestry, carrying neither its own nor an inherited registration, records nothing. Absent the inherited registration, every room would require its own.

Grounds

This is an Empirical Observation. The grounds are a captured three-boot smoke run 2026-05-31 against the live MVA demonstration instance with examples/chat-app/ overlaid into the isolated runtime staging tree.

Setup (verifiable from repo state):

Driver: DGD 1.7.9 built from dworkin/dgd; binary symlinked into the runtime staging tree.
Kernel layer: eOSContinuum/eOS-kernellib's chat-app multi-agent-coherence branch at HEAD fbda75a.
Application layer: examples/chat-app/, deployed with the Chat domain overlay.
Runtime config: the instance config; the chat-app smoke script (expected 20 sentinels).

Load-bearing source (the negative-case phase in examples/chat-app/sys/test.c):

lone   = spawn_room("ChatApp:Room:NoInheritL");
olivia = spawn_user("olivia");
/* no ur-object, no observer registered */
CHAT_DAEMON->post_message(olivia, lone, "unheard");
/* asserts lone's message log is empty -- NO-INHERIT OK */

post_message writes chat-room.message; with no observer at the room and no ancestor to walk to, find_observers resolves nothing, so the append never runs and query_messages() stays at the empty array create() seeded.

Smoke transcript (the load-bearing portion of the result log after boot 1):

ChatApp:test: ANCESTRY OK
ChatApp:test: NO-INHERIT OK

NO-INHERIT OK writes only when the lone room's message log is empty after the post -- proving no observer fired. The assertion is inside catch{}; a recorded message logs a distinct FAIL.

What the evidence establishes:

A room outside any observer-carrying ancestry records nothing: the message posts, but the absent observer means no append fires and the log stays empty.
The behavior is the inheritance's contribution, shown by absence: the same post on a child of the ancestor (the positive) is recorded; the same post on a room with no ancestor is not.
Without inheritance, observer registration is per-room: this room would need its own register_observer call to record messages, which is exactly what the ancestor registration spares the cohort.

What the evidence does not establish:

That the post failed. The write to chat-room.message succeeded; what is absent is the reaction. The Observation is about the missing observer, not a broken post path.
A defect in the dispatcher. Finding no observer where none is registered is correct behavior; the Observation shows the cost of not registering (per-room setup), not a bug.
Cross-instance inheritance gaps. The demonstration is single-coherence-domain; ancestry resolution across a process or machine boundary is not exercised.

What Would Revise It

A recorded message on the lone room would falsify the records-nothing claim; the current evidence shows its log empty after the post.
An ancestry walk that resolved an observer where none was registered would indicate a dispatcher defect, a different (FAIL) outcome than the one captured.
A DGD or eOS-kernellib change to find_observers resolution when no observer is registered would invalidate the snapshot; the claim rests on DGD 1.7.9 plus the cited eOS-kernellib HEAD.

Sources

examples/chat-app/sys/test.c (eOS-kernellib) -- the no-inherit phase: a room with no ancestor observer records nothing.
examples/chat-app/obj/room.c (eOS-kernellib) -- create() seeding the empty chat-room.message-log; the ur inherit.
src/usr/Merry/sys/merry.c (eOS-kernellib) -- find_observers resolving nothing when no observer is registered at any ancestry level.
docs/chat-applications.md (eOS-kernellib) -- the "Multi-agent coherence" walkthrough, no-inherit phase.
The result log written into the runtime staging tree's usr/Chat/data/ path -- carries NO-INHERIT OK after a clean boot.
The chat-app smoke script and the instance config -- the three-boot regression harness and runtime config.

Relations

conforms_to::[[Observation Form Contract]]
- Carries has_epistemic_status::[[Empirical Observation]], names the measurement (one three-boot smoke run; the no-inherit phase assertion), states the limits (the post succeeded, only the reaction is absent; correct dispatcher behavior, not a defect; single-coherence-domain), and lists concrete revision conditions.
informs_downstream::[[Multiple Agents See Coherent State Without User-Land Coordination]]
- The Conviction holds that coherence is the platform's to provide. This Observation is the negative: a room outside the observer-carrying ancestry records nothing, showing that absent the inherited registration the reactive behavior is per-room work -- the coordination the ancestor registration removes for the cohort.
contrasts_with::[[One Observer on a Room Ancestor Fires for Every Room in the Cohort]]
- The positive-case peer. The positive shows one ancestor registration serving three child rooms; this negative shows a room with no ancestor observer recording nothing. Together they bound the mechanism: the inherited observer is what lets one registration serve the cohort coherently, and its absence is what would force per-room registration.