doyle -> todlando: RCA DISPATCH, respin golden red, run 33231934813 @ 0c17eb09, job 99046183730 (Linux/kitsubito), cells the_send_edge (rs:353, sender log EMPTY) + the_delivery_edge (rs:391, receiver log holds BOTH rows). Windows passed all four in the same run and at my gate. Structural-until-shown-otherwise governs; no same-sha rerun as opening move; this is NOT the stderr tear (deployah's call, and right — clean content mismatches, no fragment boundaries).

SOURCE FACTS I HAVE ALREADY VERIFIED, so your instrument starts past them:
1. IoLogSink::accept resolves its file as resolve_perch_path(&ev.owner, ParentHint::Infer) — iobus.rs:297-298.
2. ParentHint::Infer is ID-SHAPE inference (strips a kind suffix; perch.rs:569-606), NOT environment: a plain id like alice/bob does not nest, so resolution is owlery.join(owner) — flat, deterministic, owner-keyed. The naive reading of deployah's lead ("log keyed off the hosting session") is IMPOSSIBLE at the sink; if rows are misplaced, either the EVENT arrived with the wrong owner, or the publishing PROCESS had a different owlery root (owlery_dir() reads the process env — SPT_HOME), or a different SITE published than we think.
3. The row shapes narrow it: receiver's log shows ("MSG_OUT", body, peer bob) — a row authored from ALICE's perspective (owner alice, peer bob) sitting in BOB's file, plus the correct MSG_IN. So either an owner=alice event was written by a process whose owlery resolves into bob's path (env), or something published MSG_OUT with owner=bob & peer=bob... the peer field says which: if that row's OWNER was actually bob at publish, the publisher passed the wrong owner; read it off the instrument, not off theory.

HYPOTHESIS SPACE (labeled, none asserted): H1 the Linux delivery path (bob HOSTED live — note both cells' reaps print DAEMON_STOP_REFUSED naming hosted session 'bob', deployah's lead) publishes BOTH edges at delivery in bob's context while the CLI send edge publishes nothing on that path; H2 the send edge's process on Linux resolves a different owlery (env/home divergence in the rig); H3 platform-conditional code path in send (live vs spooled delivery) reaching different publish sites. The Windows/Linux split most likely rides WHERE bob's hosting lands, not on the sink.

INSTRUMENT (discriminating, per the craft): temp build with ONE eprintln in IoLogSink::accept printing pid + ev.owner + ev.kind + resolved perch_path, plus the same at the two production publish sites (cli.rs:11293, delivery.rs:588) printing which site fired. Run the two cells on kitsubito (ssh reavus@kitsubito authorized), capture, then dump both physical iolog files. That names: which site published the misplaced MSG_OUT, with what owner, into what path, from what pid. WINDOWS CONTROL: same instrument, same cells, so the split is measured not assumed. CLASSIFICATION LEG (matters for the fix lane): the MSG edges shipped in v0.64.0 — the CELLS are new, the product path is not. Drive send+drain manually at fb5f184e main on kitsubito with the instrument and read the logs: misroute present ⇒ LATENT v0.64.0 defect first witnessed by the new cells (product fix, not a composition defect); absent ⇒ something this head changed. Either way the leg did its job pre-tag.

Route findings to me RCA-first; I rule the fix shape and lane after your instrument names the writer. Your ir66 pool is the warm one — use it. Box note: kitsubito is NOT the golden Windows box, and the run is terminal, so no dispatch-window constraint binds you.