diff --git a/crates/benilla-app/assets/ui/OptionsFrame.xml b/crates/benilla-app/assets/ui/OptionsFrame.xml
index c87e3134..13deb82b 100644
--- a/crates/benilla-app/assets/ui/OptionsFrame.xml
+++ b/crates/benilla-app/assets/ui/OptionsFrame.xml
@@ -60,6 +60,9 @@
           through, the reference screenshot's actual mechanism; 0978 misread that ground as
           parchment) + UI-DialogBox-Border rope edge 32, insets 11/12/12/11. Title plate
           UI-DialogBox-Header at the options frames' 300x68 TOP (0,+12) seat, title on it.
+          ON TOP of that tile, inside the rope, a plain black 0.7 fill (1476) takes the
+          composite ground to 0.88: at the bare tile the world reached the option labels
+          hard enough to break them over bright terrain. The read-through stays, dimmed.
         · the era's one dark Options_InnerFrame panel → TWO 1.14 OptionsFrameListTemplate
           boxes: tooltip-border backdrops with the FILL AT ALPHA 0 (outlines — the ground
           shows through) and the border tinted LIGHTGRAY_FONT_COLOR 0.6, tops at -52 (1.14's
@@ -1525,6 +1528,37 @@
             <BackgroundInsets><AbsInset left="11" right="12" top="12" bottom="11"/></BackgroundInsets>
         </Backdrop>
         <Layers>
+            <Layer level="BACKGROUND">
+                <!-- THE GROUND DIM (1476) — a plain black fill over the tiled ground, because
+                     the tile alone is not a readable page. UI-DialogBox-Background decodes to a
+                     uniform (0,0,0,153) — pure black at 0.6 — so 40% of the world reaches the
+                     text: over snow, noon water or a lit sky the page ground lands near mid-grey
+                     and the option labels stop reading (the director's report). 0.6 is right for
+                     a dialog you glance at; the options window is a page you READ, and the era's
+                     own answer is an OPAQUE FlatPanelBackgroundTemplate panel — so darkening
+                     toward it is the era structure 0985 already gives us, wearing a plain colour
+                     fill, which 0985 names as an art byte we may author.
+                     Alpha 0.7 over the 0.6 tile composites to 0.88 (the world reaches the page at
+                     0.12), not 1.0: the faint read-through is the window's character, and 0981's
+                     "the reference was never parchment" finding stands — this dims the ground, it
+                     does not replace it.
+                     SEAT: inset 15 on all four sides, NOT the backdrop's own 11/12/12/11 bg
+                     insets. Regions sort AFTER the frame's own draw slot, which is where the
+                     backdrop's bg AND its 8 border pieces both live (extract.rs) — so this fill
+                     paints OVER the rope, and at the bg insets it would smear 0.7 black across
+                     the border's inner half. The rope's ink is measured, not guessed: every edge
+                     slice of UI-DialogBox-Border is opaque only in its outer ~11 units and dead
+                     by texel 16 of 32, and the corner slices' ink ends by 14 (decoded). 15 clears
+                     every inked texel and leaves at most a 1-unit lighter hairline inside the
+                     rope, where the rope reads as frame anyway. -->
+                <Texture name="$parentGroundDim">
+                    <Anchors>
+                        <Anchor point="TOPLEFT"><Offset><AbsDimension x="15" y="-15"/></Offset></Anchor>
+                        <Anchor point="BOTTOMRIGHT"><Offset><AbsDimension x="-15" y="15"/></Offset></Anchor>
+                    </Anchors>
+                    <Color r="0" g="0" b="0" a="0.7"/>
+                </Texture>
+            </Layer>
             <Layer level="ARTWORK">
                 <!-- The carved title plate at the 1.14 options frames' own seat: 300x68 at
                      TOP (0,+12) — OptionsFrameTemplates.xml l.244-255 (GameMenuFrame's plate
diff --git a/crates/benilla-app/src/capture/mod.rs b/crates/benilla-app/src/capture/mod.rs
index dbdcbcbd..387d7458 100644
--- a/crates/benilla-app/src/capture/mod.rs
+++ b/crates/benilla-app/src/capture/mod.rs
@@ -86,6 +86,7 @@ mod probe_binder;
 mod probe_book;
 mod probe_castcancel;
 mod probe_charcreate;
+mod probe_chest;
 mod probe_crossing;
 mod probe_mail;
 mod probe_melee;
@@ -105,6 +106,7 @@ pub(crate) use probe_binder::ProbeBinderPlugin;
 pub(crate) use probe_book::ProbeBookPlugin;
 pub(crate) use probe_castcancel::ProbeCastCancelPlugin;
 pub(crate) use probe_charcreate::ProbeCharCreatePlugin;
+pub(crate) use probe_chest::ProbeChestPlugin;
 pub(crate) use probe_crossing::ProbeCrossingPlugin;
 pub(crate) use probe_mail::ProbeMailPlugin;
 pub(crate) use probe_melee::ProbeMeleePlugin;
diff --git a/crates/benilla-app/src/capture/probe_chest.rs b/crates/benilla-app/src/capture/probe_chest.rs
new file mode 100644
index 00000000..18012eff
--- /dev/null
+++ b/crates/benilla-app/src/capture/probe_chest.rs
@@ -0,0 +1,391 @@
+//! The chest live probe (`WOW_PROBE_CHEST=1`) — **B84's instrument**: does the player kneel at an
+//! open chest?
+//!
+//! Goudy, 2026-07-26 (`#bugs` `1530708187173359646`): *"No looting/opening animation when using a
+//! chest"*, with a benilla/reference pair at the same Mirror Lake Orchard chest — the reference
+//! gnome kneeling over the open loot window, ours standing bolt upright. Decision 0515 had shipped
+//! the kneel keyed to the `CMSG_LOOT` send alone and recorded a chest's silence as *correct*; 1471
+//! is the correction (the real client also arms the latch in `OnLootResponse 0x5eb900`, and a chest
+//! never sends `CMSG_LOOT` at all).
+//!
+//! **A kneel is a number here, not a picture** (`method.md` step 4: timing and pose questions are
+//! settled with instruments). The probe reads the self unit's own
+//! [`AnimDriver::active_anim`][crate::creature_anim::AnimDriver::active_anim] — the id the base
+//! selector actually landed on — so the verdict is `50` (`Loot`) or it is not, with no screenshot
+//! and no eye in the loop. Three readings, in order, which is what makes it a *regression* test and
+//! not a one-sided assertion:
+//!
+//! 1. **BEFORE** — parked at the chest, window shut: the base anim must be `0` (`Stand`). This is
+//!    the control; a probe that only ever sees `50` cannot tell a fix from a stuck kneel.
+//! 2. **OPEN** — the chest used on the click's own route, the loot window up: must be `50`.
+//! 3. **AFTER** — `CloseLoot()` through the live VM: back to `0`.
+//!
+//! Nothing here re-decides what packet a chest takes. The probe resolves the object through
+//! [`crate::target::click::resolve_go_action`] — the same lock chain the mouse runs (0239/0752) —
+//! and sends whichever arm it names, so a chest whose `Lock.dbc` row changes shape still gets the
+//! packet the real click would send. (Every world chest carries a lock: `Lock.dbc` 43 is one
+//! `LockType 13 "Open Kneeling"` slot, 57 is `5 "Open"` + `6 "Treasure (DND)"`, all `Skill 0`, so
+//! the "Opening" spell every character knows satisfies them and the live arm is `OpenLock`.)
+//!
+//! The DONE line reports the two mechanism halves separately — `latch-while-open` (predicate A: a
+//! loot session is open) and `kneel-while-open` (predicate B: this *kind* of target is knelt at,
+//! decision 1477). They are not the same question, and the whole of B84's correction lives in the
+//! gap: a fishing bobber arms the latch exactly as a chest does and must still read `kneel=false`.
+//!
+//! ## The run recipe
+//!
+//! ```text
+//! WOW_NOSOUND=1 WOW_USER=probe0 WOW_PASS=pprobe0 WOW_CHAR=Probezero \
+//!     WOW_PROBE_CHEST=1 cargo run -q -p benilla
+//! ```
+//! (the slot-keyed probe identity — `pool-N` → `probeN`/`pprobeN`/`Probe<N-spelled>`, `method.md`
+//! "The local vmangos server"). `WOW_PROBE_CHEST=<x>,<y>,<z>[,<map>]` aims it at a different
+//! object; the default is a live `Battered Chest` spawn (`gameobject.guid` 26756, template 2843) in
+//! the Mirror Lake stretch of Elwynn, the same corner of the world the report came from. A chest is
+//! a respawning spawn point: if someone emptied that one it will be missing for its respawn timer,
+//! which the probe reports as a scan failure rather than as a passing run.
+//!
+//! Grep `PROBE_CHEST:` for the verdict; the probe self-exits when it lands.
+
+use bevy::prelude::*;
+
+use benilla_protocol::EntityKind;
+use benilla_ui::script::UiScript;
+
+use super::probes::ProbeClock;
+use crate::creature_anim::AnimDriver;
+use crate::net::{ChatKind, ClientCommand, Guid, NetCommands, NetEntity, ObjectStore, SelfPlayer};
+use crate::player::Player;
+use crate::target::click::{resolve_go_action, GoAction};
+use crate::target::lock::GoLockInputs;
+use crate::ui_loot::{LootKneel, LootLatch, LootState};
+
+/// The probe's default object: the `Worn Wooden Chest` at `gameobject` 3998644 (template 1765,
+/// `Lock.dbc` 43 → `LockType 13 "Open Kneeling"`, loot 1570) below Northshire in Elwynn.
+///
+/// **Not** the reporter's own Mirror Lake `Battered Chest`, deliberately, and the reason is the
+/// trap this probe fell into first: every ordinary world chest — that one included — is a
+/// **spawn-pool** member (`pool_gameobject`, one of pool 20004's many points spawned at a time), so
+/// a fixed coordinate finds nothing most of the time and the probe reads "no chest" where the real
+/// answer is "not this point today". 3998644 is unpooled with a 25 s respawn, so it is there every
+/// run and it comes back between runs. It is the same GameObject type, the same lock family and the
+/// same `SMSG_LOOT_RESPONSE`-only session as the reported object.
+const CHEST_AT: [f32; 4] = [-9474.37, 111.25, 57.03, 0.0];
+/// `GAMEOBJECT_TYPE_CHEST` — the strategy type a chest (and a herb/mining node) carries.
+const GO_TYPE_CHEST: i32 = 3;
+/// `AnimationData.dbc` ids the verdict is written in: the kneel we want, and the Stand we must
+/// return to. Named rather than inlined so the report reads as animations, not magic numbers.
+const ANIM_LOOT: u16 = 50;
+const ANIM_STAND: u16 = 0;
+
+/// Scan radius around the landing spot, in yards.
+const SCAN_RANGE: f32 = 25.0;
+/// Frames each window samples. The base anim is a settled per-frame state, so this is about
+/// outlasting a transient, not about statistics.
+const SAMPLE_FRAMES: usize = 60;
+const SETTLE_SECS: f64 = 5.0;
+const SCAN_TIMEOUT_SECS: f64 = 25.0;
+const LOOT_TIMEOUT_SECS: f64 = 15.0;
+const CLOSE_TIMEOUT_SECS: f64 = 10.0;
+
+/// The streamed-object columns the scan and the lock resolve both read — a `type` alias so the
+/// one `Query` stays inside clippy's complexity bar.
+type NearbyObject = (
+    &'static Guid,
+    &'static NetEntity,
+    &'static ObjectStore,
+    &'static Transform,
+    Option<&'static crate::go_anim::GoAnim>,
+);
+
+pub(crate) struct ProbeChestPlugin;
+
+impl Plugin for ProbeChestPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<ChestProbe>()
+            .add_systems(Update, chest_probe);
+    }
+}
+
+#[derive(Resource, Default)]
+struct ChestProbe {
+    phase: Phase,
+    /// The chest's guid, once the scan finds it.
+    chest: Option<u64>,
+    /// The base anim ids seen in each window, in frame order.
+    before: Vec<Option<u16>>,
+    open: Vec<Option<u16>>,
+    after: Vec<Option<u16>>,
+    /// The two mechanism readings taken when the OPEN window finished — reported beside the pose
+    /// so a failure says *which* half broke. They are deliberately separate: predicate A (a loot
+    /// session is open — the latch) and predicate B (this KIND of target is knelt at — decision
+    /// 1477). A fishing bobber is `latch=Some(...) kneel=false`, and that is correct.
+    latch_open: Option<u64>,
+    kneel_open: bool,
+    fails: u32,
+    exited: bool,
+}
+
+#[derive(Default, Clone, Copy, PartialEq)]
+enum Phase {
+    #[default]
+    Wait,
+    /// `.go` issued; letting the world stream the chest in.
+    Settling {
+        sent_at: f64,
+    },
+    /// Sampling with the chest SHUT — the control window.
+    Before,
+    /// The use packet is out; waiting for the server to open a loot window.
+    WaitLoot {
+        since: f64,
+    },
+    /// Sampling with the loot window OPEN — the reported condition.
+    Open,
+    /// `CloseLoot()` called; waiting for the window to actually go.
+    WaitClosed {
+        since: f64,
+    },
+    /// Sampling after the close — the "and it stands back up" half.
+    After,
+    Done,
+}
+
+/// Where the probe is aimed: `WOW_PROBE_CHEST=<x>,<y>,<z>[,<map>]`, else [`CHEST_AT`]. Anything
+/// unparseable falls back to the default rather than failing the run — the common value is `1`.
+fn target() -> [f32; 4] {
+    let Ok(raw) = std::env::var("WOW_PROBE_CHEST") else {
+        return CHEST_AT;
+    };
+    let parts: Vec<f32> = raw
+        .split(',')
+        .filter_map(|s| s.trim().parse().ok())
+        .collect();
+    match parts.len() {
+        3 => [parts[0], parts[1], parts[2], CHEST_AT[3]],
+        4 => [parts[0], parts[1], parts[2], parts[3]],
+        _ => CHEST_AT,
+    }
+}
+
+/// Whether the loot window is up, asked of the **live UI** rather than of our own state: the
+/// window is what the reporter saw, and `LootFrame` shows only once the feed has fired
+/// `LOOT_OPENED` off the wire. Falls back to the app-side session when the frame can't be read.
+fn window_open(script: &UiScript, loot: &LootState) -> bool {
+    script
+        .eval::<bool>("return LootFrame:IsShown() and 1 or nil")
+        .unwrap_or_else(|_| loot.source().is_some())
+}
+
+/// One window's verdict line: what the base slot held, how steadily, and whether it is the id the
+/// reference shows. `expect` is the id every frame of the window must carry.
+fn report(label: &str, expect: u16, seen: &[Option<u16>]) -> u32 {
+    let held = seen.iter().filter(|a| **a == Some(expect)).count();
+    // What it held instead, most-common first — the useful half of a failure.
+    let mut other: Vec<String> = Vec::new();
+    for a in seen.iter().filter(|a| **a != Some(expect)) {
+        let name = a.map_or_else(|| "none".to_string(), |id| id.to_string());
+        if !other.contains(&name) {
+            other.push(name);
+        }
+    }
+    if held == seen.len() && !seen.is_empty() {
+        info!(
+            "PROBE_CHEST: {label:<6} PASS — base anim {expect} on all {}/{} frames",
+            held,
+            seen.len()
+        );
+        0
+    } else {
+        error!(
+            "PROBE_CHEST: {label:<6} FAIL — base anim {expect} on only {}/{} frames (also saw: {})",
+            held,
+            seen.len(),
+            if other.is_empty() {
+                "nothing".to_string()
+            } else {
+                other.join(", ")
+            }
+        );
+        1
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn chest_probe(
+    time: ProbeClock,
+    mut probe: ResMut<ChestProbe>,
+    script: Option<NonSendMut<UiScript>>,
+    self_q: Query<&AnimDriver, With<SelfPlayer>>,
+    self_store: Query<&ObjectStore, With<SelfPlayer>>,
+    player: Res<Player>,
+    objects: Query<NearbyObject, Without<SelfPlayer>>,
+    mut go_inputs: GoLockInputs,
+    actions: Res<crate::ui_action::PlayerActions>,
+    loot: Res<LootState>,
+    latch: Res<LootLatch>,
+    kneel: Res<LootKneel>,
+    net: Res<NetCommands>,
+    mut exit: MessageWriter<AppExit>,
+) {
+    let Ok(driver) = self_q.single() else {
+        return; // not in-world yet
+    };
+    let Some(script) = script else {
+        return; // no UI VM this build — nothing this probe can drive
+    };
+    let now = time.elapsed_secs_f64();
+    let anim = driver.active_anim();
+
+    match probe.phase {
+        Phase::Wait => {
+            let [x, y, z, map] = target();
+            info!(
+                "PROBE_CHEST: heading to the chest ({x} {y} {z} map {map}) — B84's object, \
+                 GameObject type {GO_TYPE_CHEST}"
+            );
+            let _ = net.0.send(ClientCommand::Chat {
+                kind: ChatKind::Say,
+                target: None,
+                text: format!(".go xyz {x} {y} {z} {map}"),
+            });
+            probe.phase = Phase::Settling { sent_at: now };
+        }
+        Phase::Settling { sent_at } => {
+            if now - sent_at < SETTLE_SECS {
+                return;
+            }
+            let me = player.pos;
+            let chest = objects.iter().find(|(_, net_e, store, tf, _)| {
+                net_e.kind == EntityKind::GameObject
+                    && store.0.gameobject_type_id() == GO_TYPE_CHEST
+                    && tf.translation.distance(me) < SCAN_RANGE
+            });
+            if let Some((guid, ..)) = chest {
+                info!(
+                    "PROBE_CHEST: chest {:#x} in range — sampling {SAMPLE_FRAMES} frames with it SHUT",
+                    guid.0
+                );
+                probe.chest = Some(guid.0);
+                probe.phase = Phase::Before;
+            } else if now - sent_at > SCAN_TIMEOUT_SECS {
+                error!(
+                    "PROBE_CHEST: FAIL — no type-{GO_TYPE_CHEST} GameObject within {SCAN_RANGE} yd \
+                     in {SCAN_TIMEOUT_SECS}s. A chest is a respawning spawn point: if it was looted \
+                     recently it is simply not there yet. This is NOT a passing run"
+                );
+                probe.fails += 1;
+                probe.phase = Phase::Done;
+            }
+        }
+        Phase::Before => {
+            probe.before.push(anim);
+            if probe.before.len() < SAMPLE_FRAMES {
+                return;
+            }
+            let Some(guid) = probe.chest else {
+                probe.phase = Phase::Done;
+                return;
+            };
+            // The click's own route (0239/0752): ask the shared lock chain what the right-click
+            // would send, then send exactly that.
+            let go = objects
+                .iter()
+                .find(|(g, ..)| g.0 == guid)
+                .map(|(_, _, store, _, anim)| (store, crate::go_anim::go_state(anim, store)));
+            let me_store = self_store.single().ok();
+            match resolve_go_action(guid, &mut go_inputs, &actions.spells, go, me_store, &net) {
+                GoAction::Use => {
+                    info!("PROBE_CHEST: lockless — CMSG_GAMEOBJ_USE on {guid:#x}");
+                    let _ = net.0.send(ClientCommand::GameObjUse { guid });
+                }
+                GoAction::OpenLock(spell_id) => {
+                    info!("PROBE_CHEST: opener cast {spell_id} at {guid:#x} (the live arm)");
+                    let _ = net.0.send(ClientCommand::CastSpellGameObject {
+                        spell_id,
+                        go_guid: guid,
+                    });
+                }
+                GoAction::OpenByKey { .. } | GoAction::Refuse(_) => {
+                    error!(
+                        "PROBE_CHEST: FAIL — the lock chain refuses this object (key/unmet). Aim \
+                         the probe at a chest this character can actually open"
+                    );
+                    probe.fails += 1;
+                    probe.phase = Phase::Done;
+                    return;
+                }
+            }
+            probe.phase = Phase::WaitLoot { since: now };
+        }
+        Phase::WaitLoot { since } => {
+            if window_open(&script, &loot) {
+                info!(
+                    "PROBE_CHEST: loot window up on {:#x} — sampling {SAMPLE_FRAMES} frames OPEN",
+                    loot.source().unwrap_or_default()
+                );
+                probe.phase = Phase::Open;
+            } else if now - since > LOOT_TIMEOUT_SECS {
+                error!(
+                    "PROBE_CHEST: FAIL — no loot window within {LOOT_TIMEOUT_SECS}s of the use; \
+                     the anim question can't be asked at all"
+                );
+                probe.fails += 1;
+                probe.phase = Phase::Done;
+            }
+        }
+        Phase::Open => {
+            probe.open.push(anim);
+            if probe.open.len() >= SAMPLE_FRAMES {
+                probe.latch_open = latch.0;
+                probe.kneel_open = kneel.0;
+                info!("PROBE_CHEST: closing the window through the live VM's own CloseLoot()");
+                let _ = script.eval::<()>("CloseLoot()");
+                probe.phase = Phase::WaitClosed { since: now };
+            }
+        }
+        Phase::WaitClosed { since } => {
+            if !window_open(&script, &loot) {
+                info!("PROBE_CHEST: window closed — sampling {SAMPLE_FRAMES} frames AFTER");
+                probe.phase = Phase::After;
+            } else if now - since > CLOSE_TIMEOUT_SECS {
+                error!(
+                    "PROBE_CHEST: FAIL — the loot window never closed within {CLOSE_TIMEOUT_SECS}s"
+                );
+                probe.fails += 1;
+                probe.phase = Phase::Done;
+            }
+        }
+        Phase::After => {
+            probe.after.push(anim);
+            if probe.after.len() >= SAMPLE_FRAMES {
+                probe.phase = Phase::Done;
+            }
+        }
+        Phase::Done => {
+            if probe.exited {
+                return;
+            }
+            probe.exited = true;
+            let mut fails = probe.fails;
+            fails += report("BEFORE", ANIM_STAND, &probe.before);
+            fails += report("OPEN", ANIM_LOOT, &probe.open);
+            fails += report("AFTER", ANIM_STAND, &probe.after);
+            info!(
+                "PROBE_CHEST: DONE chest={:#x} latch-while-open={:?} kneel-while-open={} fail={fails}",
+                probe.chest.unwrap_or_default(),
+                probe.latch_open.map(|g| format!("{g:#x}")),
+                probe.kneel_open,
+            );
+            // The probe self-exit pattern (`ProbeExitPlugin::fire_probe_exit`): a polite AppExit
+            // plus a hard backstop thread, so a net/winit teardown hang can't leave a zombie
+            // client holding the probe account.
+            exit.write(AppExit::Success);
+            std::thread::spawn(|| {
+                std::thread::sleep(std::time::Duration::from_secs(5));
+                warn!("PROBE_CHEST: still alive 5s after AppExit — hard exit");
+                std::process::exit(0);
+            });
+        }
+    }
+}
diff --git a/crates/benilla-app/src/capture/probes/live_fps.rs b/crates/benilla-app/src/capture/probes/live_fps.rs
index 1f6f30c0..8be3718c 100644
--- a/crates/benilla-app/src/capture/probes/live_fps.rs
+++ b/crates/benilla-app/src/capture/probes/live_fps.rs
@@ -117,9 +117,14 @@ type ScreenParams<'w, 's> = (
 );
 
 #[derive(SystemParam)]
-struct SamplePin<'w> {
+struct SamplePin<'w, 's> {
     map: Option<Res<'w, benilla_world::world_map::CurrentMap>>,
     body: Option<Res<'w, crate::player::Player>>,
+    /// The eye the leg was measured through — pose-stamped like `sys_busy_pct` time-stamps load,
+    /// and for the same reason: two legs are only comparable if this matches. 1475's bring-up
+    /// lost an hour to a probe whose camera sat first-person pitched 26° down — a per-character
+    /// saved camera file, invisible in every count — and the census read as a regression hunt.
+    cam: Query<'w, 's, &'static GlobalTransform, With<benilla_world::view::WorldCamera>>,
 }
 
 /// Wait for in-world + the delay, uncap, warm, sample, print, exit — the live twin of the
@@ -339,6 +344,17 @@ fn drive_live_fps(
                 }
                 _ => String::new(),
             };
+            let cam_pose = pin
+                .cam
+                .iter()
+                .next()
+                .map(|gt| {
+                    let [x, y, z] = benilla_assets::coords::bevy_to_wow(gt.translation());
+                    let (yaw, pitch, _) =
+                        gt.to_scale_rotation_translation().1.to_euler(EulerRot::YXZ);
+                    format!(" cam={x:.1},{y:.1},{z:.1} cam_yaw={yaw:.2} cam_pitch={pitch:.2}")
+                })
+                .unwrap_or_default();
             let gate = match (seen.room.as_deref(), seen.windows.as_deref()) {
                 (Some(room), Some(w)) => format!(" room={room} windows={w}"),
                 _ => String::new(),
@@ -379,7 +395,7 @@ fn drive_live_fps(
                 seen.mats, seen.meshes, seen.images, seen.uv_anims, seen.tint_anims,
             );
             println!(
-                "FPS_PROBE scenario=live frames={} mean_ms={mean:.2} p50_ms={:.2} p95_ms={:.2} p99_ms={:.2} max_ms={:.2} fps={:.1} emitters={} active={} particles={} submeshes={} drawn={} streamed={} parked={} entities={}{rigs}{residency_line} px={}x{}{cpu}{sys}{present}{display}{gpu_line} occluded_frames={}{at_pin}{gate}{sky}{ribbons}{culled}",
+                "FPS_PROBE scenario=live frames={} mean_ms={mean:.2} p50_ms={:.2} p95_ms={:.2} p99_ms={:.2} max_ms={:.2} fps={:.1} emitters={} active={} particles={} submeshes={} drawn={} streamed={} parked={} entities={}{rigs}{residency_line} px={}x{}{cpu}{sys}{present}{display}{gpu_line} occluded_frames={}{at_pin}{cam_pose}{gate}{sky}{ribbons}{culled}",
                 v.len(),
                 at(0.50),
                 at(0.95),
diff --git a/crates/benilla-app/src/creature_anim.rs b/crates/benilla-app/src/creature_anim.rs
index 5de6d6a9..fa380d22 100644
--- a/crates/benilla-app/src/creature_anim.rs
+++ b/crates/benilla-app/src/creature_anim.rs
@@ -57,8 +57,10 @@ pub(crate) use twist::{wrap_pi, BodyTwist};
 /// The unit animation-LOD gate (decision 0448): park an off-frustum rig's per-bone pose
 /// evaluation — the clocks, the driver state machine, and the event tracks keep running, so
 /// off-screen combat stays audible (0075) and a re-appearing unit snaps to the absolute-clock
-/// pose. A modernization, not fidelity — the reference animates every in-range unit (wow-re
-/// `unit-anim-visibility-gate.md`).
+/// pose. Shipped as a modernization; wow-re's 2026-08-13 election correction
+/// (`outdoor-object-pass-election.md`) made it the faithful direction instead — decision 1473
+/// records that, and what still diverges (parked rigs keep drawing; the reference keeps only
+/// `MORE_AUDIBLE` creatures audible off-screen).
 mod lod;
 
 /// The unit's wielded weapon classes — `(item class, item subclass)` per hand, `None` for an empty
@@ -1058,6 +1060,11 @@ impl Plugin for CreatureAnimPlugin {
                 )
                     .chain()
                     .after(WorldStage::Net)
+                    // After predicate B's recompute (decision 1477): the loot leg's self trigger
+                    // is that boolean, and the reference has no gap between arming the latch and
+                    // posing — its chest arm force-plays Loot 50 in the same handler. Without
+                    // this edge the kneel lands a frame late at every loot window.
+                    .after(crate::ui_loot::resolve_loot_kneel)
                     // After Input so a sheath request (the Z toggle) executes the same frame.
                     .after(WorldStage::Input)
                     // Before the entity-visuals chain: [`VisualSheath`] writes must be applied
diff --git a/crates/benilla-app/src/creature_anim/driver.rs b/crates/benilla-app/src/creature_anim/driver.rs
index 366b2f6c..7894880d 100644
--- a/crates/benilla-app/src/creature_anim/driver.rs
+++ b/crates/benilla-app/src/creature_anim/driver.rs
@@ -332,10 +332,11 @@ pub(super) fn drive_animations(
     // client-local loot-target latch, and the frame clock.
     aux: (
         Option<Res<EmoteSounds>>,
-        // The loot-target latch (decision 0515): the SELF unit's kneel trigger — armed at the
-        // `CMSG_LOOT` send, dropped at release/refusal — read by the loot leg below. `Option`
-        // for the headless test worlds that don't build the loot seam.
-        Option<Res<crate::ui_loot::LootLatch>>,
+        // Predicate B's standing answer (decision 1477): whether the currently latched loot
+        // target is one the SELF unit kneels at — the loot leg's whole self trigger, since it is
+        // false while the latch is cold. `Option` for the headless test worlds that don't build
+        // the loot seam.
+        Option<Res<crate::ui_loot::LootKneel>>,
         // The frame clock — the key-bone cross-fade's only time source (decision 0878): its
         // retiring node is *frozen* on the clip's final frame, so unlike the wound's decay there
         // is no playback clock to read the λ window off.
@@ -348,7 +349,7 @@ pub(super) fn drive_animations(
     // diff-only filter; see the trace block after the mode machine).
     mut anim_trace_last: Local<std::collections::HashMap<Entity, String>>,
 ) {
-    let (emote_sounds, loot_latch, time) = aux;
+    let (emote_sounds, loot_kneel, time) = aux;
     let dt = time.delta_secs();
     // This frame's one-shot PLAY CALLS (swings + anim-emotes), gathered per unit and replayed
     // in the client's call order below ([`PlaySeq`] stamps — the net drain stamps packet order,
@@ -422,9 +423,11 @@ pub(super) fn drive_animations(
     let catalog = anim_data.as_deref().map(|d| &d.0);
     // `WOW_ANIM_COST=1` — the memo-sizing counter (1370 item 9's bracket): counts the frame's
     // RESTING rows, the shape an input-memo fast path would skip. Sizing only — no skip is
-    // taken here (an `AnimParked` filter is law-barred: 0448's off-screen-events law means a
-    // parked unit's driver must keep arming clips; the memo is the only safe shape, built when
-    // this number says it pays).
+    // taken here. (An `AnimParked` filter was law-barred by 0448's off-screen-events law; that
+    // law's premise — "the reference keeps every off-screen unit audible" — fell with wow-re's
+    // election correction, which keeps only `MORE_AUDIBLE` creatures ticking. Until 1473's
+    // event-gate leg lands as its own record, the driver still arms clips for every parked
+    // unit, and the memo remains the only safe skip shape.)
     let anim_cost = anim_cost_enabled();
     let (mut cost_rows, mut cost_resting) = (0u32, 0u32);
     for (
@@ -743,12 +746,21 @@ pub(super) fn drive_animations(
         }
 
         // The loot kneel's trigger (see [`select::LOOT`]; byte-verified, wow-re
-        // `loot-anim-leg.md` — the 2026-07-18 §5 fold-back, decision 0515): the predicate
-        // (`0x6126b0`) SPLITS on IsActivePlayer — the **self** unit kneels off the client-local
-        // loot-target latch ([`crate::ui_loot::LootLatch`], armed at the `CMSG_LOOT` send, so
-        // the kneel is client-predicted with no round-trip), a **remote** unit off its mirrored
-        // descriptor: `UNIT_FLAG_LOOTING` (0x400) set AND the `0x10000000` bit clear. Never
-        // mounted (the leg's `[+0xdc]==0` gate). Movement outranks by CHAIN POSITION, not an
+        // `loot-anim-leg.md` §5/§8 — decisions 0515 / 1471 / 1477): the leg needs **two**
+        // predicates, and both SPLIT on IsActivePlayer.
+        //
+        // **Self.** Predicate A (`0x6126b0`) is "a loot session is open" — the client-local
+        // loot-target latch. Predicate B (`0x612710`) is the per-object-CLASS filter: which
+        // *kind* of target the character kneels at. Only B is read here, because
+        // [`crate::ui_loot::LootKneel`] already folds in A (it is false whenever the latch is
+        // cold). Keeping them apart is the correction 1477 makes to 1471: a fishing bobber arms
+        // the latch exactly like a chest does, and the reference still does not kneel at it —
+        // the difference is entirely B's `GAMEOBJECT_TYPE_ID == 17` test.
+        //
+        // **Remote.** The mirrored descriptor: `UNIT_FLAG_LOOTING` (0x400) set AND the
+        // `0x10000000` bit clear.
+        //
+        // Never mounted (the leg's `[+0xdc]==0` gate). Movement outranks by CHAIN POSITION, not an
         // in-leg gate — the core ground selector claims first on any direction bit (`[9e8]&0xf`)
         // — transcribed as the `ANY_MOVE` test here; a stationary *swimmer* with the trigger up
         // kneels mid-tread, as the bytes order it (locomotion's swim block needs a direction
@@ -756,7 +768,7 @@ pub(super) fn drive_animations(
         let looting = !mounted
             && mv.flags & move_flags::ANY_MOVE == 0
             && if is_self {
-                loot_latch.as_ref().is_some_and(|l| l.0.is_some())
+                loot_kneel.as_ref().is_some_and(|k| k.0)
             } else {
                 store.is_some_and(|s| {
                     let f = s.0.unit_flags();
diff --git a/crates/benilla-app/src/creature_anim/driver/tests.rs b/crates/benilla-app/src/creature_anim/driver/tests.rs
index e256cea5..8522cae3 100644
--- a/crates/benilla-app/src/creature_anim/driver/tests.rs
+++ b/crates/benilla-app/src/creature_anim/driver/tests.rs
@@ -1082,15 +1082,18 @@ fn unit_flag_looting_kneels_stationary_units_only() {
 
 /// The loot kneel, SELF half (decision 0515 — the byte predicate `0x6126b0` splits on
 /// IsActivePlayer): the local player's kneel rides the client-local loot-target latch
-/// ([`crate::ui_loot::LootLatch`], the `[player+0x1d28]` mirror) — NOT its descriptor flag — so
-/// it starts the frame the `CMSG_LOOT` send arms the latch (client-predicted, before any server
-/// response reaches the descriptor) and ends the frame the latch drops.
+/// (predicate B's standing answer over the `[player+0x1d28]` latch — [`crate::ui_loot::LootKneel`],
+/// decision 1477) — NOT its descriptor flag — so it starts the frame the arm lands
+/// (client-predicted, before any server response reaches the descriptor) and ends the frame it
+/// drops. *Which* latched objects set that boolean is predicate B's own table, tested where it
+/// lives (`ui_loot::tests::predicate_b_decides_which_loot_targets_are_knelt_at`); this test is
+/// about the leg reading self and remote from two different places.
 #[test]
 fn the_self_kneel_rides_the_loot_latch_not_the_flag() {
     use benilla_protocol::messages::ObjectFields;
 
     let mut app = app();
-    app.init_resource::<crate::ui_loot::LootLatch>();
+    app.init_resource::<crate::ui_loot::LootKneel>();
     let model = ModelAnimations {
         graph: Handle::default(),
         clips: vec![clip(0, 1, true), clip(50, 2, false), clip(5, 3, true)],
@@ -1124,17 +1127,17 @@ fn the_self_kneel_rides_the_loot_latch_not_the_flag() {
         "the self unit ignores its own descriptor flag"
     );
 
-    // The CMSG_LOOT send arms the latch: the kneel is client-predicted the same frame cycle.
+    // The arm lands on a kneelable target: the kneel is client-predicted the same frame cycle.
     app.world_mut()
-        .resource_mut::<crate::ui_loot::LootLatch>()
-        .0 = Some(0x42);
+        .resource_mut::<crate::ui_loot::LootKneel>()
+        .0 = true;
     app.update();
     assert_eq!(gait(&app), Some(50), "the armed latch kneels the self unit");
 
     // The release/refusal drops the latch: straight back to Stand, no wire round-trip needed.
     app.world_mut()
-        .resource_mut::<crate::ui_loot::LootLatch>()
-        .0 = None;
+        .resource_mut::<crate::ui_loot::LootKneel>()
+        .0 = false;
     app.update();
     assert_eq!(
         gait(&app),
diff --git a/crates/benilla-app/src/creature_anim/lod.rs b/crates/benilla-app/src/creature_anim/lod.rs
index 59e00008..2c892f17 100644
--- a/crates/benilla-app/src/creature_anim/lod.rs
+++ b/crates/benilla-app/src/creature_anim/lod.rs
@@ -4,19 +4,26 @@
 //! the query's comment for why the old `With<AnimDriver>` filter left every animated GO
 //! sampling off-view).
 //!
-//! The reference has NO view cull on unit skeletons — every in-range, non-hidden unit is fully
-//! animated every frame (wow-re `unit-anim-visibility-gate.md`: worklist admission is the CGUnit
-//! render vtable chain, no frustum/occlusion/distance test — the 0364 §1 dispatch's verdict). So
-//! this gate is a *modernization*, not a fidelity copy, and it preserves the verdict's two
-//! observables:
+//! 0448 shipped this as a modernization against a reference that "has NO view cull on unit
+//! skeletons" — a verdict wow-re REFUTED on 2026-08-13 (`outdoor-object-pass-election.md`: every
+//! scene object, units included, is frustum/horizon/room-elected each frame, and a pass-2 unit
+//! is neither drawn, nor animated, nor event-ticked — except creatures flagged `MORE_AUDIBLE`,
+//! re-linked for tick only). So this gate turned out to be the *faithful* direction, not a
+//! departure; what still diverges is decision 1473's ledger — parked rigs keep DRAWING (the
+//! election never reached draw submission), and observable (ii) keeps every unit audible where
+//! the reference keeps only the flagged ones. The two observables preserved here:
 //!
-//! - **(i) the absolute-clock snap** — a re-appearing unit shows the pose "now" dictates. Nothing
-//!   here pauses an [`AnimationPlayer`]: Bevy's `advance_animations` keeps ticking every seek
-//!   clock, so waking is just sampling again — there is no frozen state to resume from.
-//! - **(ii) off-screen combat stays audible** — the event scanner
+//! - **(i) the absolute-clock snap** — faithful (`0x714260` samples the world clock): a
+//!   re-appearing unit shows the pose "now" dictates. Nothing here pauses an [`AnimationPlayer`]:
+//!   Bevy's `advance_animations` keeps ticking every seek clock, so waking is just sampling
+//!   again — there is no frozen state to resume from.
+//! - **(ii) off-screen combat stays audible — for EVERY unit**, which is now known to be MORE
+//!   than the reference grants (it silences all but `MORE_AUDIBLE` creatures): the event scanner
 //!   ([`super::events::fire_anim_events`]) reads the player's seek, not the bones, and the driver
 //!   state machine keeps arming clips for parked rigs; `$CSS`/`$CAH`/`$HIT` (0075), footsteps,
-//!   `$BWP`/`$BWR`, and the `$CSL`-keyed missile release (0430) all fire regardless of the camera.
+//!   `$BWP`/`$BWR`, and the `$CSL`-keyed missile release (0430) all fire regardless of the
+//!   camera. Narrowing this to the flagged set is 1473's event-gate leg — its own record when it
+//!   lands.
 //!
 //! The park mechanism is the [`AnimParked`] marker alone (decision 0712 — the evaluator took over
 //! from `animate_targets`, and the old per-joint `AnimatedBy` repoint died with the targets): the
@@ -50,13 +57,13 @@ use bevy::camera::primitives::{Frustum, Sphere as CullSphere};
 use bevy::ecs::entity::EntityHashMap;
 use bevy::prelude::*;
 
-use benilla_assets::{WmoGroupNav, WmoModel, WmoPortalRef};
+use benilla_assets::WmoModel;
 
 use crate::entities::mount::MountBody;
 use crate::net::Embodied;
 use crate::target::SelectionRadius;
 use benilla_world::view::WorldCamera;
-use benilla_world::wmo_portal::{UnitWmoRoom, WmoPortalInstance, WmoRoom};
+use benilla_world::wmo_portal::{room_pvs_visible, UnitWmoRoom, WmoPortalInstance};
 
 use benilla_world::rig_anim::{AnimParked, RigPose};
 
@@ -195,48 +202,11 @@ pub(super) fn gate_rig_animation(
     out_since.retain(|e, _| rigs.contains(*e));
 }
 
-/// The room leg's resolve chain: unit claim → placement instance → model → PVS bits. Fail-open
-/// at every seam (no claim, despawned placement, still-loading model) — a lookup miss must never
-/// park a drawable rig.
-fn room_pvs_visible(
-    room: Option<&UnitWmoRoom>,
-    instances: &Query<&WmoPortalInstance>,
-    wmos: &Assets<WmoModel>,
-) -> bool {
-    let Some(WmoRoom { instance, group }) = room.and_then(|r| r.room()) else {
-        return true;
-    };
-    let Ok(inst) = instances.get(instance) else {
-        return true;
-    };
-    let Some(model) = wmos.get(&inst.handle) else {
-        return true;
-    };
-    room_visible(&inst.visible, &model.group_nav, &model.portal_refs, group)
-}
-
-/// Is the claimed group — or any group one portal hop from it — in the PVS? The one-hop union is
-/// the doorway-straddle guard: a body can extend past its feet's room only through a portal
-/// opening, so the neighbour set bounds everything of the unit that could be on screen. Indices
-/// out of range read visible (fail-open, [`benilla_world::wmo_portal::WmoGroupVis::drawn_by`]'s
-/// convention); a group with no portal refs at all can only be seen with the camera inside it
-/// (the flood cannot reach it), which the direct bit already answered.
-fn room_visible(visible: &[bool], nav: &[WmoGroupNav], refs: &[WmoPortalRef], group: u16) -> bool {
-    let vis = |g: usize| visible.get(g).copied().unwrap_or(true);
-    if vis(group as usize) {
-        return true;
-    }
-    let Some(n) = nav.get(group as usize) else {
-        return true;
-    };
-    let Some(hops) = refs.get(n.ref_start as usize..(n.ref_start as usize + n.ref_count as usize))
-    else {
-        return true;
-    };
-    hops.iter().any(|r| vis(r.group as usize))
-}
-
 /// Register the gate: [`gate_rig_animation`] before the frame's pose evaluation.
+///
+/// The room predicate itself lives in [`benilla_world::wmo_portal::room_pvs_visible`] since 1475:
+/// the body draw election asks the identical question of the identical claim, and two private
+/// copies of one election term is exactly the drift 1473 catalogued.
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(PostUpdate, gate_rig_animation.before(AnimationSystems));
 }
@@ -249,7 +219,9 @@ mod tests {
 
     use benilla_assets::{
         bone_target_id, AnimClip, ModelAnimations, PoseBone, PoseClip, PoseSource, PoseTrack,
+        WmoGroupNav, WmoPortalRef,
     };
+    use benilla_world::wmo_portal::WmoRoom;
 
     use super::super::{events::fire_anim_events, AnimDriver, AnimSoundEvent};
     use super::*;
@@ -532,40 +504,6 @@ mod tests {
         }
     }
 
-    /// The room predicate's whole truth table: direct bit, the one-hop straddle guard, the
-    /// all-dark park, the sealed room, and both fail-open seams (group past every table, a
-    /// ref slice past the refs vec).
-    #[test]
-    fn room_visible_covers_the_hop_guard_and_fails_open() {
-        // Groups 0 ↔ 1 share one portal; group 2 is sealed (no refs).
-        let navs = vec![nav(0, 1), nav(1, 1), nav(2, 0)];
-        let refs = vec![pref(1), pref(0)];
-        assert!(
-            room_visible(&[true, false, false], &navs, &refs, 0),
-            "direct PVS bit"
-        );
-        assert!(
-            room_visible(&[true, false, false], &navs, &refs, 1),
-            "own bit dark but the neighbour lit — the doorway-straddle guard keeps it live"
-        );
-        assert!(
-            !room_visible(&[false, false, true], &navs, &refs, 0),
-            "own room and every hop dark ⇒ parked"
-        );
-        assert!(
-            !room_visible(&[true, true, false], &navs, &refs, 2),
-            "a sealed room's own bit decides — no hops exist to save it"
-        );
-        assert!(
-            room_visible(&[false], &navs, &refs, 9),
-            "a group past the PVS table reads visible (fail-open)"
-        );
-        assert!(
-            room_visible(&[false], &[nav(7, 2)], &refs, 0),
-            "a ref slice past the refs vec reads visible (fail-open)"
-        );
-    }
-
     /// The room leg end to end: an IN-FRUSTUM rig whose claimed room (and its one hop) is
     /// outside the PVS parks past the hysteresis window; setting the room's bit wakes it and its
     /// bones sample again — the same instant-wake law as the frustum leg.
diff --git a/crates/benilla-app/src/creature_anim/select.rs b/crates/benilla-app/src/creature_anim/select.rs
index 8d57b5de..ec03edda 100644
--- a/crates/benilla-app/src/creature_anim/select.rs
+++ b/crates/benilla-app/src/creature_anim/select.rs
@@ -57,14 +57,23 @@ pub(super) const STEALTH_STAND: u16 = 120;
 pub(super) const MOUNT: u16 = 91;
 
 /// Loot (50) — the kneel-and-rummage held while a unit's loot window is open. Byte-verified end
-/// to end (wow-re `loot-anim-leg.md`, the 2026-07-18 §5; decision 0515): the `0x5fd8b0` chain's
-/// loot leg `0x5fd260` → 0x32 = 50, chain order locomotion → **LOOT** → standState →
-/// combat/channel (movement outranks by position — the leg itself reads no movement state), leg
-/// gates `[+0xdc]==0` (never mounted) + the `[+0xd58]&0x40` enable. The **trigger predicate**
-/// (`0x6126b0`) splits on IsActivePlayer: the **self** unit keys the client-local loot-target
-/// latch (`[player+0x1d28]`, ours [`crate::ui_loot::LootLatch`]) — armed at the `CMSG_LOOT` send,
-/// so the kneel is client-predicted — while a **remote** unit keys its descriptor:
-/// [`UNIT_FLAG_LOOTING`] set and [`UNIT_FLAG_LOOT_SUPPRESS`] clear. The clip is authored
+/// to end (wow-re `loot-anim-leg.md`, the 2026-07-18 §5 + the 08-21 §5 trio; decisions 0515 /
+/// 1471 / 1477): the `0x5fd8b0` chain's loot leg `0x5fd260` → 0x32 = 50, chain order locomotion →
+/// **LOOT** → standState → combat/channel (movement outranks by position — the leg itself reads no
+/// movement state), leg gates `[+0xdc]==0` (never mounted) + the `[+0xd58]&0x40` enable.
+///
+/// The leg needs **two** predicates, and both split on IsActivePlayer:
+/// - **A `0x6126b0` — is a session open.** Self: the client-local loot-target latch
+///   (`[player+0x1d28]`, ours [`crate::ui_loot::LootLatch`]) — armed at the `CMSG_LOOT` send for a
+///   corpse, at `SMSG_SPELL_GO` for a chest, and at an admitted `SMSG_LOOT_RESPONSE` otherwise.
+///   Remote: [`UNIT_FLAG_LOOTING`] set and [`UNIT_FLAG_LOOT_SUPPRESS`] clear.
+/// - **B `0x612710` — is that KIND of target knelt at.** Self: a per-object-class filter, ours
+///   [`crate::ui_loot::LootKneel`]. It is why a fishing bobber arms the latch and still does not
+///   kneel, and 1471 shipped without it.
+///
+/// One consequence worth stating plainly, because it looks like a bug: on vmangos, other players
+/// never see us kneel at a chest. `Player::SendLoot` sets `UNIT_FLAG_LOOTING` only for
+/// `LOOT_CORPSE`, and the remote half has nothing else to read. The clip is authored
 /// **clamp** (HumanMale: one 0.5 s sequence, no variations): kneel down, freeze in the rummage
 /// pose; the rise back is the ordinary cross-fade to Stand when the trigger drops. Weapons stow
 /// for free — row 50 carries the `WeaponFlags & 4` force-stow the per-animation sheath
diff --git a/crates/benilla-app/src/dev.rs b/crates/benilla-app/src/dev.rs
index d19500e3..084b0b6b 100644
--- a/crates/benilla-app/src/dev.rs
+++ b/crates/benilla-app/src/dev.rs
@@ -113,6 +113,7 @@ impl Plugin for DevProbesPlugin {
                 "WOW_PROBE_CHAT",
                 "WOW_PROBE_KEY",
                 "WOW_PROBE_LUA",
+                "WOW_PROBE_CHEST",
                 "WOW_RIG",
                 "WOW_LIVE_FPS",
             ]
@@ -259,6 +260,13 @@ impl Plugin for DevProbesPlugin {
             if std::env::var("WOW_PROBE_BOOK").is_ok() {
                 app.add_plugins(crate::capture::ProbeBookPlugin);
             }
+            // The chest live probe: `WOW_PROBE_CHEST=1` parks at a real chest spawn, opens it on the
+            // click's own route and reports the self unit's base anim id before/during/after — B84's
+            // instrument, the numeric answer to "does the player kneel at a chest" (decision 1471;
+            // see `capture::ProbeChestPlugin`).
+            if std::env::var("WOW_PROBE_CHEST").is_ok() {
+                app.add_plugins(crate::capture::ProbeChestPlugin);
+            }
             // The cast-cancel live probe: `WOW_PROBE=castcancel` hearths and presses W mid-cast — the
             // local self-cancel's end-to-end timing instrument (see `capture::ProbeCastCancelPlugin`).
             if std::env::var("WOW_PROBE").as_deref() == Ok("castcancel") {
diff --git a/crates/benilla-app/src/entities/attach/dress.rs b/crates/benilla-app/src/entities/attach/dress.rs
index 665bd705..fc8ca937 100644
--- a/crates/benilla-app/src/entities/attach/dress.rs
+++ b/crates/benilla-app/src/entities/attach/dress.rs
@@ -245,17 +245,21 @@ pub(super) fn spawn_part(
         child.insert(benilla_world::rig_palette::RigPart(dress.unit));
     }
     if dress.rigged && part.skinned_mesh.is_some() {
-        // A streamed entity's M2 is **never view-culled** — the reference registers entity render
-        // records with effectively-infinite bounds and the one frustum cull in its machinery is
-        // map-doodad-only (wow-re `unit-anim-visibility-gate.md` §2/§4). Bevy's bind-pose `Aabb` is
-        // the wrong stand-in (the duel flag plants itself 9 yd below it) and is stomped anyway by
-        // `calculate_bounds` on any `Mesh3d` change. So the renderer gets the faithful
-        // `NoFrustumCulling`, and the `Aabb` beside it serves ONE master: the mouseover picker
-        // (`target/hover.rs`) — the armed idle's authored CAaBox when it has one, else the bind
-        // box, read from the part's build-time bound (decision 0834: the static mesh is
-        // `RENDER_WORLD`-only, so its main-world data — which the old `compute_aabb` fallback
-        // read — is gone after extract). Both `calculate_bounds` queries skip `NoFrustumCulling`
-        // entities, so this box survives.
+        // A skinned entity part is never PART-culled: the reference tests ONE sphere per scene
+        // object, never per batch, so the view cull belongs to the body ROOT's election
+        // (`exterior_cull`, 1270) and `NoFrustumCulling` keeps Bevy's per-part test out of its
+        // way. (0648 originally justified the marker as "the reference never view-culls entities
+        // at all", off a ≈1e7 render-bounds reading; wow-re's `outdoor-object-pass-election.md`
+        // refuted that 2026-08-13 — those fields are a position cache, and units ARE
+        // frustum/horizon/room-elected per frame. Decision 1473 records the correction and owns
+        // the outdoor half of the election.) Bevy's bind-pose `Aabb` is the wrong stand-in for
+        // picking (the duel flag plants itself 9 yd below it) and is stomped anyway by
+        // `calculate_bounds` on any `Mesh3d` change. So the `Aabb` beside the marker serves ONE
+        // master: the mouseover picker (`target/hover.rs`) — the armed idle's authored CAaBox
+        // when it has one, else the bind box, read from the part's build-time bound (decision
+        // 0834: the static mesh is `RENDER_WORLD`-only, so its main-world data — which the old
+        // `compute_aabb` fallback read — is gone after extract). Both `calculate_bounds` queries
+        // skip `NoFrustumCulling` entities, so this box survives.
         let picker_aabb = dress.idle_aabb.or(part.aabb);
         if let Some(aabb) = picker_aabb {
             child.insert((aabb, NoFrustumCulling));
diff --git a/crates/benilla-app/src/net/apply.rs b/crates/benilla-app/src/net/apply.rs
index 184fcbd9..06904be4 100644
--- a/crates/benilla-app/src/net/apply.rs
+++ b/crates/benilla-app/src/net/apply.rs
@@ -769,6 +769,7 @@ pub(super) fn apply_net_updates(
                 &mut ui_actions.2,
                 &mut ui_actions.6,
                 &mut ui_actions.7,
+                &mut loot_latch,
             ),
             SessionEvent::Chat(m) => {
                 chat::chat(m, &mut chat_log, &social, &net_commands, &mut server_said)
@@ -934,7 +935,15 @@ pub(super) fn apply_net_updates(
                 loot_type,
                 gold,
                 items,
-            } => loot_response(guid, loot_type, gold, items, &mut loot),
+            } => loot_response(
+                guid,
+                loot_type,
+                gold,
+                items,
+                &mut loot,
+                &mut loot_latch,
+                &net_commands,
+            ),
             SessionEvent::LootError { guid, error } => {
                 loot_error(guid, error, &mut ui_actions.4, &mut loot_latch)
             }
@@ -1130,6 +1139,7 @@ pub(super) fn apply_net_updates(
                 &mut ui_actions.15,
                 &mut audio.7,
                 &mut audio.10,
+                &mut loot_latch,
                 (
                     &mut ui_actions.10,
                     ui_actions.11.as_deref(),
diff --git a/crates/benilla-app/src/net/apply/loot.rs b/crates/benilla-app/src/net/apply/loot.rs
index dcd827b7..538792a4 100644
--- a/crates/benilla-app/src/net/apply/loot.rs
+++ b/crates/benilla-app/src/net/apply/loot.rs
@@ -12,20 +12,68 @@ use bevy::prelude::*;
 
 use super::super::SelfGuid;
 use crate::items::Items;
+use crate::net::ClientCommand;
 use crate::pending_item_ops::{LockClearedByFailure, PendingItemOps};
 use crate::ui_action::{UiError, UiErrorKeys};
 use crate::ui_items::{EquipError, EquipErrors};
 use crate::ui_loot::{LootErrors, LootLatch, LootState};
 use crate::ui_loot_roll::LootRolls;
 
-/// A loot window opened (`SMSG_LOOT_RESPONSE`'s normal shape), answering our `CMSG_LOOT`.
+/// The wire `loot_type` values `SMSG_LOOT_RESPONSE`'s **cold-latch** admission accepts
+/// (`0x5eb94b`/`0x5eb953`/`0x5eb95b`) — vmangos `LootType`'s `PICKPOCKETING(2)` · `FISHING(3)` ·
+/// `DISENCHANTING(4)`. The alphabet the bytes are drawing is *"the server started this session"*;
+/// `CORPSE(1)` is the client's own, and it is the one value a cold latch refuses.
+const SERVER_STARTED_LOOT: [u8; 3] = [2, 3, 4];
+
+/// A loot window opened (`SMSG_LOOT_RESPONSE`'s normal shape) — the answer to our `CMSG_LOOT`, or
+/// to anything else that opened a session: a chest, herb node, mining vein or fishing bobber all
+/// reach the window through an `OPEN_LOCK` cast, never through `CMSG_LOOT` (vmangos
+/// `Spell::SendLoot` → `Player::SendLoot`).
+///
+/// **This handler is an admission gate, not an unconditional open** (wow-re `loot-anim-leg.md` §7,
+/// byte-verified; decision 1477 correcting 1471). `0x5eb924`:
+///
+/// ```text
+/// ACCEPT ⇔ (latch != 0 && latch == pkt.guid) || (latch == 0 && loot_type ∈ {2,3,4})
+/// ```
+///
+/// Everything else is **refused** at `0x5eb963`: no window, a `CMSG_LOOT_RELEASE` bounced back for
+/// the *packet's* guid, and the latch cleared — **not** guid-matched, so an unsolicited response
+/// for B drops a live latch on A. The design the bytes state is a two-way handshake: type 1 means
+/// "I asked for this", and the client pre-armed at its own `CMSG_LOOT` send, so a type-1 answer
+/// with nothing latched is an answer to a question we never asked.
+///
+/// The accepted arm writes the latch verbatim (`0x5ebb60`) and — verified over the whole success
+/// path — calls **neither** the base-anim recompute nor the Loot-50 force-play. A chest is already
+/// kneeling by now: its arm was `SMSG_SPELL_GO` (§6, [`super::spells`]), one packet earlier.
 pub(super) fn loot_response(
     guid: u64,
     loot_type: u8,
     gold: u32,
     items: Vec<LootItem>,
     loot: &mut LootState,
+    latch: &mut LootLatch,
+    net: &crate::net::NetCommands,
 ) {
+    // `0x5eb924`–`0x5eb95b`, transcribed.
+    let accept = match latch.0 {
+        Some(latched) => latched == guid,
+        None => SERVER_STARTED_LOOT.contains(&loot_type),
+    };
+    if !accept {
+        // `0x5eb963`: bounce it. On this server nothing produces a refusal — a corpse always
+        // pre-arms and a chest/fishing answer carries type 2/3 — so this arm is inert today and
+        // carried for the faithful shape (and for a server that answers differently).
+        debug!(
+            "net: loot response {guid:#x} type {loot_type} REFUSED (latch {:?})",
+            latch.0
+        );
+        if loot_type != 0 {
+            let _ = net.0.send(ClientCommand::LootRelease { guid });
+        }
+        latch.0 = None; // NOT guid-matched — `0x5eb9d2` clears whatever was there
+        return;
+    }
     // The loot window opens (decision 0084): fill LootState from the wire; the feed
     // ([`crate::ui_loot`]) resolves rows + fires LOOT_OPENED next frame. `loot_type` rides along
     // for `IsFishingLoot()` (decision 1086).
@@ -34,6 +82,11 @@ pub(super) fn loot_response(
         items.len()
     );
     loot.open(guid, loot_type, gold, items);
+    // `0x5ebb60` — the packet's guid, verbatim. Re-arming a corpse's already-matching latch is a
+    // no-op; a chest re-arms what `SMSG_SPELL_GO` armed; a **fishing** bobber arms here for the
+    // first time and still does not kneel, because the pose is predicate B's call, not the
+    // latch's ([`crate::ui_loot::LootKneel`]).
+    latch.0 = Some(guid);
 }
 
 /// A fishing verdict with no loot window (`SMSG_FISH_ESCAPED` / `SMSG_FISH_NOT_HOOKED`, both
@@ -191,6 +244,7 @@ pub(super) fn item_template(entry: u32, info: Option<ItemInfo>, items: &mut Item
 /// [`PendingItemOps::clear_by_failure`]. This site has no `UiScript` to fire `ITEM_LOCK_CHANGED`
 /// through, so the transitioned slots queue in [`LockClearedByFailure`] for the container feed
 /// (`ui_items::feed::feed_containers`) to drain and fire next time it runs.
+#[allow(clippy::too_many_arguments)] // one dispatch arm's full input set
 pub(super) fn inventory_failure(
     reason: u8,
     required_level: Option<u32>,
@@ -199,6 +253,7 @@ pub(super) fn inventory_failure(
     equip_errors: &mut EquipErrors,
     pending: &mut PendingItemOps,
     lock_cleared: &mut LockClearedByFailure,
+    latch: &mut LootLatch,
 ) {
     debug!("net: inventory failure {reason:#04x} (item {item_guid:#x}, bag slot {bag_slot})");
     equip_errors.0.push(EquipError {
@@ -207,6 +262,13 @@ pub(super) fn inventory_failure(
         bag_slot,
     });
     lock_cleared.0.extend(pending.clear_by_failure(item_guid));
+    // The sixth loot-latch clear (`0x5e3a84`, wow-re `loot-anim-leg.md` §5; decision 1477): when
+    // the packet's **first item guid** is the object we are looting, the session ends here. It is
+    // how an item-container loot (a lockbox) closes when the move out of it fails — the one clear
+    // the 1471 census was missing. Guid-matched, as the bytes are.
+    if item_guid != 0 {
+        latch.clear_for(item_guid);
+    }
 }
 
 #[cfg(test)]
@@ -242,6 +304,132 @@ mod tests {
         assert_eq!(g("ERR_FISH_ESCAPED"), "Your fish got away!");
     }
 
+    /// A GameObject guid (HIGHGUID_GAMEOBJECT in the high dword) — a chest.
+    const CHEST: u64 = 0xF110_0000_0000_1234;
+    /// A creature guid — a corpse.
+    const CORPSE: u64 = 0xF130_0000_0000_00AB;
+
+    /// A `NetCommands` plus its receiver, so a test can read what the handler actually sent.
+    fn net() -> (
+        crate::net::NetCommands,
+        crossbeam_channel::Receiver<ClientCommand>,
+    ) {
+        let (tx, rx) = crossbeam_channel::unbounded();
+        (crate::net::NetCommands(tx), rx)
+    }
+
+    /// **B84 / decisions 1471 + 1477.** A chest never sends `CMSG_LOOT`, so the corpse branch's
+    /// arm-at-the-send (0515) never fires for it. `SMSG_SPELL_GO` is its real arm; the response's
+    /// own arm is the second half, and on a **cold** latch it admits only the server-started
+    /// types 2/3/4 (`0x5eb94b`–`0x5eb95b`). A chest's answer is wire type 2, so it opens and arms.
+    #[test]
+    fn a_cold_latch_admits_a_server_started_loot_and_arms_on_it() {
+        let (net, rx) = net();
+        let mut loot = LootState::default();
+        let mut latch = LootLatch::default();
+        assert_eq!(latch.0, None, "no CMSG_LOOT was sent, so nothing armed it");
+
+        loot_response(CHEST, 2, 0, Vec::new(), &mut loot, &mut latch, &net);
+        assert_eq!(latch.0, Some(CHEST), "the open window is the loot session");
+        assert_eq!(loot.source(), Some(CHEST), "…and the window opened");
+        assert!(
+            rx.try_recv().is_err(),
+            "an accepted response bounces nothing"
+        );
+
+        // The ordinary close path still ends it — the latch is guid-matched, and a chest guid is
+        // no different from a corpse one there.
+        loot_release_response(CHEST, &mut loot, &mut latch);
+        assert_eq!(latch.0, None, "the release ends the session");
+    }
+
+    /// The corpse path is untouched: the send already armed the latch with the same guid, so the
+    /// response takes the **GUID-match** branch (`0x5eb93e`) and its re-arm is a no-op.
+    #[test]
+    fn a_matching_latch_admits_any_loot_type() {
+        let (net, _rx) = net();
+        let mut loot = LootState::default();
+        let mut latch = LootLatch(Some(CORPSE)); // the `CMSG_LOOT` send, client-predicted
+        loot_response(CORPSE, 1, 0, Vec::new(), &mut loot, &mut latch, &net);
+        assert_eq!(latch.0, Some(CORPSE));
+        assert_eq!(loot.source(), Some(CORPSE));
+    }
+
+    /// **The refusal arm (`0x5eb963`, decision 1477).** `loot_type == 1` means "you asked for
+    /// this" — and a cold latch says we did not. The real client opens no window, bounces a
+    /// `CMSG_LOOT_RELEASE` for the *packet's* guid, and clears. 1471 shipped an unconditional
+    /// arm, which is exactly this case's divergence.
+    #[test]
+    fn a_cold_latch_refuses_a_corpse_typed_response_and_bounces_it() {
+        let (net, rx) = net();
+        let mut loot = LootState::default();
+        let mut latch = LootLatch::default();
+
+        loot_response(CORPSE, 1, 0, Vec::new(), &mut loot, &mut latch, &net);
+        assert_eq!(
+            loot.source(),
+            None,
+            "no window for an unasked-for corpse answer"
+        );
+        assert_eq!(latch.0, None, "…and nothing latched");
+        assert!(
+            matches!(rx.try_recv(), Ok(ClientCommand::LootRelease { guid }) if guid == CORPSE),
+            "the refusal releases the object the PACKET named"
+        );
+    }
+
+    /// The refuse arm's clear is **not** guid-matched (`0x5eb9d2`): an unsolicited response for B
+    /// drops a live latch on A, and releases B. Faithfully odd, and byte-verified.
+    #[test]
+    fn a_refusal_drops_whatever_latch_was_live_not_just_a_matching_one() {
+        let (net, rx) = net();
+        let mut loot = LootState::default();
+        let mut latch = LootLatch(Some(CORPSE));
+
+        loot_response(CHEST, 1, 0, Vec::new(), &mut loot, &mut latch, &net);
+        assert_eq!(latch.0, None, "A's latch is dropped by B's refusal");
+        assert!(
+            matches!(rx.try_recv(), Ok(ClientCommand::LootRelease { guid }) if guid == CHEST),
+            "…and it is B that gets released"
+        );
+    }
+
+    /// The sixth clear (`0x5e3a84`): an inventory-move failure whose first item guid IS the loot
+    /// target ends that session. Guid-matched, so an unrelated bag failure leaves it alone.
+    #[test]
+    fn an_inventory_failure_on_the_looted_object_clears_the_latch() {
+        const LOCKBOX: u64 = 0x4000_0000_0000_0007;
+        let mut errs = EquipErrors::default();
+        let mut pending = PendingItemOps::default();
+        let mut cleared = LockClearedByFailure::default();
+        let mut latch = LootLatch(Some(LOCKBOX));
+
+        // An unrelated item's failure must not end the session.
+        inventory_failure(
+            2,
+            None,
+            0x1234,
+            0,
+            &mut errs,
+            &mut pending,
+            &mut cleared,
+            &mut latch,
+        );
+        assert_eq!(latch.0, Some(LOCKBOX));
+
+        inventory_failure(
+            2,
+            None,
+            LOCKBOX,
+            0,
+            &mut errs,
+            &mut pending,
+            &mut cleared,
+            &mut latch,
+        );
+        assert_eq!(latch.0, None);
+    }
+
     const ME: u64 = 0x0000_0000_0000_002A;
     const THEM: u64 = 0x0000_0000_0000_00FF;
 
diff --git a/crates/benilla-app/src/net/apply/spells.rs b/crates/benilla-app/src/net/apply/spells.rs
index 671cba29..a048a047 100644
--- a/crates/benilla-app/src/net/apply/spells.rs
+++ b/crates/benilla-app/src/net/apply/spells.rs
@@ -285,6 +285,10 @@ pub(super) fn spell_start(
     }
 }
 
+/// `GAMEOBJECT_TYPE_ID` 3 — `CHEST`, the only GO type whose `OPEN_LOCK` cast arms the loot-target
+/// latch (`0x6e830c`; DOOR(0)/BUTTON(1) are skipped explicitly and every other type falls out).
+const GO_TYPE_CHEST: i32 = 3;
+
 /// The cast launched (`SMSG_SPELL_GO`): hit/miss lists + (for a ranged spell) the ammo display id
 /// for the projectile visual. The server schedules the *damage* itself off `Spell.dbc` Speed —
 /// nothing about missile travel rides this packet; the client (and we) rebuild the flight
@@ -314,6 +318,8 @@ pub(super) fn spell_go(
     queued_melee: &mut QueuedMeleeSpell,
     text: &mut MessageWriter<crate::combat_text::CombatTextSpawn>,
     go_lid: &mut MessageWriter<crate::go_anim::GoLidOpen>,
+    // The client-local loot-target latch — armed here for a chest (decision 1477, §6 above).
+    loot_latch: &mut crate::ui_loot::LootLatch,
     // The cooldown store + what its start laws read (grouped: one arm-body concern). The last
     // member is the PET's store — the reference inserts into two banks from this one handler
     // ([`pet_go_cooldown`]).
@@ -342,6 +348,37 @@ pub(super) fn spell_go(
     let (cooldowns, spells, items, net_commands, pet_bar) = cooldown_ctx;
     let now = Instant::now();
     let display = spells.and_then(|s| s.catalog.get(spell_id));
+    // **A chest's loot-target arm** (wow-re `loot-anim-leg.md` §6, byte-verified §5 trio; decision
+    // 1477). `Spell_C::HandleSpellGo 0x6e7a70` reaches `0x6e831b call SetLootTarget 0x5ed5f0`,
+    // which writes `[player+0x1d28]` and force-plays Loot 50 — so **this packet, not the loot
+    // response, is when the reference starts kneeling at a chest**. Its gates, transcribed:
+    // caster is the local player (`0x6e81b6`), the spell carries `SPELL_EFFECT_OPEN_LOCK` (0x21)
+    // or `OPEN_LOCK_ITEM` (0x3b) (`0x6e81f9`/`0x6e8202`), and the single target resolves as a
+    // GameObject whose `GAMEOBJECT_TYPE_ID` is **CHEST(3)** (`0x6e82df`–`0x6e830c`; DOOR/BUTTON
+    // are skipped explicitly, everything else falls out).
+    //
+    // One named divergence: the reference reads its target off the hit list and requires
+    // `hitCount == 1` (`0x6e82c1`). vmangos writes a GameObject target into `SpellCastTargets`,
+    // not the hit list, so we key on the packet's `go_target` — a single guid by construction,
+    // which is the same condition arrived at from the shape of our wire rather than from a count.
+    //
+    // No force-play is needed here: our loot leg is recomputed every frame from
+    // [`crate::ui_loot::LootKneel`], where the reference recomputes only on events and therefore
+    // has to kick the pose by hand.
+    if self_guid.0 == Some(caster) {
+        if let Some(go_guid) = go_target {
+            let is_open_lock = display.is_some_and(|d| d.open_lock.is_some());
+            let is_chest = index
+                .0
+                .get(&go_guid)
+                .and_then(|&e| stores.get(e).ok())
+                .is_some_and(|store| store.0.gameobject_type_id() == GO_TYPE_CHEST);
+            if is_open_lock && is_chest {
+                debug!("net: spell go — chest {go_guid:#x} becomes the loot target (kneel arm)");
+                loot_latch.0 = Some(go_guid);
+            }
+        }
+    }
     // Our own launch completes the cast bar (a shown bar fills green and fades; auto-repeat
     // shots — GO with no bar showing — no-op in the reference Lua) and opens the in-flight guard
     // (spell-id-keyed, so a triggered proc's GO mid-cast doesn't unblock the running cast early).
@@ -965,6 +1002,7 @@ mod tests {
                             &mut queued_melee,
                             &mut text,
                             &mut go_lid,
+                            &mut crate::ui_loot::LootLatch::default(),
                             (
                                 &mut cooldowns,
                                 None,
@@ -1114,6 +1152,7 @@ mod tests {
                             &mut queued_melee,
                             &mut text,
                             &mut go_lid,
+                            &mut crate::ui_loot::LootLatch::default(),
                             (
                                 &mut cooldowns,
                                 Some(&spells),
@@ -1249,6 +1288,7 @@ mod tests {
                         &mut queued_melee,
                         &mut text,
                         &mut go_lid,
+                        &mut crate::ui_loot::LootLatch::default(),
                         (
                             &mut cooldowns,
                             None,
diff --git a/crates/benilla-app/src/net/motion/facing.rs b/crates/benilla-app/src/net/motion/facing.rs
index 75a45233..a6e0f424 100644
--- a/crates/benilla-app/src/net/motion/facing.rs
+++ b/crates/benilla-app/src/net/motion/facing.rs
@@ -304,7 +304,17 @@ pub(in crate::net) fn drive_display_facing(
         // *goal*, not a freeze, which is what swings an NPC back when you close its window.
         let goal = goal.unwrap_or(state.wire);
         let new = filter_step(cur, goal, &mut state.hist);
-        tf.rotation = Quat::from_rotation_y(new);
+        // Write-on-change only (1473): a settled unit's `new` is bitwise `goal.rem_euclid(TAU)`
+        // every frame (the dead-band leg of `filter_step` returns the goal verbatim, never a
+        // re-derivation from `cur`), so this compare goes quiet one frame after settling. The
+        // unconditional write it replaces marked every standing NPC's `Transform` changed every
+        // frame — re-propagating its whole subtree and defeating each downstream `Changed` gate
+        // for the entire idle crowd (1445's swim gate, the water-side classifier's moved sweep,
+        // mesh re-extract) — the same defect `face_billboards` fixed for cards.
+        let rot = Quat::from_rotation_y(new);
+        if tf.rotation != rot {
+            tf.rotation = rot;
+        }
         // The turn-shuffle latch (decision 0123): while the ease still has meaningful yaw to
         // cover, the anim layer sees a signed turning step; settled drops it below.
         let remaining = crate::creature_anim::wrap_pi(goal - new);
@@ -568,6 +578,70 @@ mod tests {
         );
     }
 
+    /// The rotation write is a dead-band, not a metronome: once a governed unit settles, its
+    /// `Transform` stops being marked changed. This is the regression fence for 1473's defeat
+    /// finding — an unconditional same-value write re-propagated every standing NPC's subtree
+    /// every frame and silently un-gated each downstream `Changed` consumer (1445's swim gate,
+    /// the water-side classifier's moved sweep, mesh re-extract).
+    #[test]
+    fn a_settled_unit_stops_dirtying_its_transform() {
+        #[derive(Resource, Default)]
+        struct Dirty(usize);
+        fn spy(q: Query<Entity, (Changed<Transform>, With<NetEntity>)>, mut out: ResMut<Dirty>) {
+            out.0 = q.iter().count();
+        }
+        let mut app = App::new();
+        app.init_resource::<GuidIndex>()
+            .init_resource::<crate::ui_session::InteractNpc>()
+            .init_resource::<Dirty>()
+            .add_systems(Update, (drive_display_facing, spy).chain());
+        // Us OFF the vendor's axis (bearing ≈ 2.60 rad), deliberately: a goal at exactly ±π sits
+        // on the yaw wrap, where the client's unfolded-delta dead-band (its own byte-verified
+        // quirk) never snaps — the ease still goes bitwise-quiet there, but only via float
+        // underflow, ~16 pumps later. The representative case snaps inside the band in ~9.
+        app.world_mut().spawn((
+            SelfPlayer,
+            ActiveMover,
+            Transform::from_translation(wow_to_bevy([0.0, 3.0, 0.0])),
+        ));
+        let npc = app
+            .world_mut()
+            .spawn((
+                NetEntity {
+                    kind: EntityKind::Unit,
+                    display_id: None,
+                    scale: 1.0,
+                },
+                ObjectStore::default(),
+                Transform {
+                    translation: wow_to_bevy([5.0, 0.0, 0.0]),
+                    rotation: Quat::from_rotation_y(0.0),
+                    ..default()
+                },
+            ))
+            .id();
+        // Open a window on it: the vendor legitimately turns, dirtying the transform — the
+        // control that proves the spy sees real writes.
+        app.world_mut()
+            .resource_mut::<crate::ui_session::InteractNpc>()
+            .0 = Some(npc);
+        app.update(); // seeding frame (spawn itself also reads as Changed here)
+        app.update();
+        assert!(
+            app.world().resource::<Dirty>().0 > 0,
+            "a turning unit dirties its transform"
+        );
+        // The turn settles inside the dead-band in ~9 pumps; run past it, then check steady state.
+        for _ in 0..16 {
+            app.update();
+        }
+        assert_eq!(
+            app.world().resource::<Dirty>().0,
+            0,
+            "a settled unit must stop dirtying its transform"
+        );
+    }
+
     /// A coincident pair yields no bearing — a degenerate `atan2` would spin the unit to 0.
     #[test]
     fn a_coincident_pair_has_no_bearing() {
diff --git a/crates/benilla-app/src/target/click.rs b/crates/benilla-app/src/target/click.rs
index 0567d1e1..4122de83 100644
--- a/crates/benilla-app/src/target/click.rs
+++ b/crates/benilla-app/src/target/click.rs
@@ -427,7 +427,7 @@ pub(super) fn act_on_right_click(
 
 /// The right-click action a hovered GameObject resolves to (decisions 0239 / 0545 / 0752) — chosen
 /// by its lock, through the shared chain in [`super::lock`].
-enum GoAction {
+pub(crate) enum GoAction {
     /// No lock (or no lock data): `CMSG_GAMEOBJ_USE` — door / lever / quest object / mailbox /
     /// unlocked chest.
     Use,
@@ -478,7 +478,7 @@ enum KeyFact {
 /// `Spell.cpp:7892`), and only `CMSG_USE_ITEM` supplies it. That was recorded here as the server's
 /// gap; it was ours, and wow-re's note says so in the same breath — "the client never sends a bare
 /// CMSG_CAST_SPELL for a key lock".
-fn resolve_go_action(
+pub(crate) fn resolve_go_action(
     guid: u64,
     inputs: &mut GoLockInputs,
     known: &std::collections::BTreeSet<u32>,
diff --git a/crates/benilla-app/src/target/mod.rs b/crates/benilla-app/src/target/mod.rs
index 43711924..97b33125 100644
--- a/crates/benilla-app/src/target/mod.rs
+++ b/crates/benilla-app/src/target/mod.rs
@@ -46,7 +46,11 @@ use benilla_world::interact::{WorldClick, WorldRightClick};
 use benilla_world::schedule::WorldStage;
 
 mod by_name;
-mod click;
+// `pub(crate)` for the chest live probe alone (decision 1471): it resolves a GameObject's
+// right-click action through the very same [`click::resolve_go_action`] the mouse does, rather
+// than re-deciding lockless-vs-opener itself — an instrument that guesses the packet is testing
+// its own guess (`probe_book`'s pattern: drive the click's own route, never a parallel one).
+pub(crate) mod click;
 // `pub(crate)` for the hover inspector's interact-gate line (`interact/inspect.rs`): the overlay
 // states the very predicate the cursor runs ([`cursor_mode::go_highlightable`]) rather than a
 // re-derivation of it, so the readout can never drift from the behaviour it is reporting on.
diff --git a/crates/benilla-app/src/transport.rs b/crates/benilla-app/src/transport.rs
index 3b90aa00..a96806cb 100644
--- a/crates/benilla-app/src/transport.rs
+++ b/crates/benilla-app/src/transport.rs
@@ -384,22 +384,34 @@ fn tick_transports(
                 sample.map,
             );
         }
+        // Write-on-change only, on every component here (1473): a docked leg samples the
+        // identical pose each frame, and the unconditional writes this replaces re-dirtied the
+        // deck's whole subtree — transform propagation over every submesh plus a `Visibility`
+        // re-propagation — for every docked elevator on the map, every frame.
         if sample.map != current_map.0 {
-            *visibility = Visibility::Hidden;
+            visibility.set_if_neq(Visibility::Hidden);
             continue;
         }
-        *visibility = Visibility::Inherited;
-        transform.translation = benilla_assets::coords::wow_to_bevy(sample.pos);
-        transform.rotation = Quat::from_rotation_y(sample.heading);
+        visibility.set_if_neq(Visibility::Inherited);
+        let translation = benilla_assets::coords::wow_to_bevy(sample.pos);
+        let heading = Quat::from_rotation_y(sample.heading);
+        if transform.translation != translation || transform.rotation != heading {
+            transform.translation = translation;
+            transform.rotation = heading;
+        }
         // Mirror the pose into avian's own components: its Transform→Position sync runs in the
         // physics schedule (before Update), so without this the mover's same-frame casts would
         // see the deck one frame behind — ~0.5 yd astern at cruise. The broad-phase AABB still
         // lags a step, which is harmless (a rider stands deep inside the boat's AABB).
         if let Some(mut p) = position {
-            p.0 = transform.translation;
+            if p.0 != transform.translation {
+                p.0 = transform.translation;
+            }
         }
         if let Some(mut r) = rotation {
-            r.0 = transform.rotation;
+            if r.0 != transform.rotation {
+                r.0 = transform.rotation;
+            }
         }
     }
 }
@@ -456,3 +468,74 @@ fn compose_riders(
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use benilla_formats::ElevatorKeyframe;
+
+    /// A docked lift goes QUIET: `tick_transports` writes pose and visibility on change only
+    /// (1473) — the unconditional writes it replaces re-dirtied every docked elevator's whole
+    /// subtree (transform + `Visibility` propagation over all its submeshes), map-wide, every
+    /// frame. A two-frame pause path samples the identical pose forever, so after the first
+    /// arming write nothing may be marked changed.
+    #[test]
+    fn a_docked_lift_stops_dirtying_its_transform_and_visibility() {
+        #[derive(Resource, Default)]
+        struct Dirty {
+            transforms: usize,
+            visibilities: usize,
+        }
+        fn spy(
+            t: Query<Entity, (Changed<Transform>, With<Transport>)>,
+            v: Query<Entity, (Changed<Visibility>, With<Transport>)>,
+            mut out: ResMut<Dirty>,
+        ) {
+            out.transforms = t.iter().count();
+            out.visibilities = v.iter().count();
+        }
+        let mut app = App::new();
+        app.insert_resource(CurrentMap(0))
+            .init_resource::<Dirty>()
+            .add_systems(Update, (tick_transports, spy).chain());
+        app.world_mut().spawn((
+            Guid(0xF110_0000_0000_0001),
+            Transport {
+                drive: Drive::Lift(Lift {
+                    frames: Arc::new(vec![
+                        ElevatorKeyframe {
+                            time_ms: 0,
+                            pos: [0.0; 3],
+                        },
+                        ElevatorKeyframe {
+                            time_ms: 1000,
+                            pos: [0.0; 3],
+                        },
+                    ]),
+                    period_ms: 1000,
+                    base_pos: [10.0, 20.0, 30.0],
+                    quat: [0.0, 0.0, 0.0, 1.0],
+                    yaw: 0.5,
+                    map: 0,
+                }),
+                was_moving: false,
+            },
+            TransportAnchor {
+                progress_ms: 0,
+                at: Instant::now(),
+            },
+            Transform::default(),
+            Visibility::default(),
+        ));
+        app.update(); // arming frame: the first pose write lands (and spawn reads as Changed)
+        for _ in 0..3 {
+            app.update();
+        }
+        let dirty = app.world().resource::<Dirty>();
+        assert_eq!(
+            (dirty.transforms, dirty.visibilities),
+            (0, 0),
+            "a docked lift must stop dirtying its transform and visibility"
+        );
+    }
+}
diff --git a/crates/benilla-app/src/ui_loot.rs b/crates/benilla-app/src/ui_loot.rs
index b55d93db..cd23781e 100644
--- a/crates/benilla-app/src/ui_loot.rs
+++ b/crates/benilla-app/src/ui_loot.rs
@@ -296,19 +296,99 @@ pub(crate) struct LootConfig {
 }
 
 /// The client-local **loot-target latch** — the mirror of the real client's `[player+0x1d28]`
-/// guid (wow-re `loot-anim-leg.md`, the 2026-07-18 §5, decision 0515): set the instant
-/// `CMSG_LOOT` goes out (`0x5df253`, the same site that client-predicts the kneel before any
-/// server response) and cleared on release/close (`0x48f2c9`/`0x5ec0d4`). This — **not** the
-/// mirrored `UNIT_FLAG_LOOTING` descriptor bit — is what the local player's own kneel rides
-/// (the byte predicate `0x6126b0` splits: self → this latch, remote → the flag), so our kneel
-/// starts at the click and ends at the release with no wire round-trip on either edge. Ours
-/// clears **guid-matched** (release response / refusal / our own release sends) — the safe
-/// generalization of the client's clears under our corpse-switch race, where the *old* window's
-/// release response lands after the *new* loot request armed the latch — plus unconditionally at
-/// session teardown.
+/// guid (wow-re `loot-anim-leg.md` §5, the 2026-08-21 §5 trio; decisions 0515 / 1471 / **1477**).
+/// It says *a loot session is open on this object*, and it is read by far more than the kneel: the
+/// loot cursor, the re-loot lock-out (`0x5ec110`), `CMSG_LOOT_MONEY`'s gate, auto-loot.
+///
+/// **Whether we kneel at it is a separate question** — [`LootKneel`], the client's predicate B
+/// `0x612710`. Arming the latch is not arming the pose; conflating the two is what 1471 got wrong.
+///
+/// **The arms** (the real client has five; we model the three our wire can produce):
+/// - the `CMSG_LOOT` send (`0x5df253`/`0x5df40d`) — a **corpse** or player bones, armed at the
+///   click, so the kneel is client-predicted with no round-trip;
+/// - **`SMSG_SPELL_GO`** for an `OPEN_LOCK` cast that lands on a **chest**
+///   (`0x6e831b → SetLootTarget 0x5ed5f0`) — this, not the loot response, is a chest's real arm,
+///   and it is why the reference is already kneeling by the time the window opens;
+/// - `CGPlayer_C::OnLootResponse 0x5eb900`, through its **admission gate** — see
+///   [`crate::net::apply::loot::loot_response`]. Not unconditional: a `loot_type == 1` response
+///   against a cold latch is *refused and bounced*.
+///
+/// Not modelled: the `CMSG_OPEN_ITEM` arm (`0x5edcc0`, a lockbox). It would change no pose —
+/// predicate B refuses an ITEM — only the cursor and the re-loot lock-out; named in 1477 as a gap.
+///
+/// Cleared on release/close (`0x48f2c9`/`0x5ec0d4`). Ours clears **guid-matched** (release
+/// response / refusal / our own release sends) — the safe generalization of the client's clears
+/// under our corpse-switch race, where the *old* window's release response lands after the *new*
+/// loot request armed the latch — plus unconditionally at session teardown.
 #[derive(Resource, Default)]
 pub(crate) struct LootLatch(pub(crate) Option<u64>);
 
+/// **Predicate B `0x612710`, the local-player branch** — whether the object the [`LootLatch`]
+/// currently names is one the character *kneels at* (wow-re `loot-anim-leg.md` §8, byte-verified
+/// §5 trio 2026-08-21; decision 1477). The loot leg `0x5fd260` needs predicate A (a session is
+/// open) **and** this one, and the split is the whole reason a fishing bobber does not kneel while
+/// a chest does — the latch is armed identically for both.
+///
+/// The byte table, transcribed:
+///
+/// | latched object | kneels? |
+/// |---|---|
+/// | GameObject, any type but 17 (a chest, a herb node, a `FISHINGHOLE` 25) | yes |
+/// | GameObject type **17 `FISHINGNODE`** — a fishing bobber (`0x612772`) | **no** |
+/// | Unit with `UNIT_FIELD_HEALTH <= 0` — a creature corpse | yes |
+/// | Unit with health **> 0** — pickpocketing a live target (`0x61278c`) | **no** |
+/// | Item — a lockbox, a disenchant (`0x612797`, `!(TYPEMASK & 2)`) | **no** |
+/// | a guid the object manager cannot resolve (`0x612732`) | **no** |
+///
+/// Recomputed by [`resolve_loot_kneel`] each frame, **between the net drain and the anim driver**.
+/// That ordering is load-bearing, not tidiness: the reference does not poll this at all — it
+/// force-plays Loot 50 *at* the chest arm (`0x5ed619`, in the same `SMSG_SPELL_GO` handler that
+/// writes the latch), so the pose is up on the arming frame. Scheduling this system loose cost
+/// exactly one frame of Stand at the open, which the chest probe caught as 59/60.
+#[derive(Resource, Default)]
+pub(crate) struct LootKneel(pub(crate) bool);
+
+/// `GAMEOBJECT_TYPE_ID` 17 — `FISHINGNODE`, the bobber. The one GameObject type predicate B names
+/// explicitly, and the reason "the latch is armed" is not the same question as "we kneel"
+/// (`0x612772`; the test exists for exactly this case).
+const GO_TYPE_FISHINGNODE: i32 = 17;
+
+/// Recompute [`LootKneel`] from the latched object — predicate B `0x612710`'s local branch.
+/// `pub(crate)` so [`crate::creature_anim`]'s driver chain can order itself after it (see
+/// [`LootKneel`]: the reference's pose is up on the arming frame, so ours must be too).
+pub(crate) fn resolve_loot_kneel(
+    latch: Res<LootLatch>,
+    index: Res<crate::net::GuidIndex>,
+    objects: Query<(&crate::net::NetEntity, &crate::net::ObjectStore)>,
+    mut kneel: ResMut<LootKneel>,
+) {
+    let allowed = latch
+        .0
+        .and_then(|guid| index.0.get(&guid).copied())
+        .and_then(|e| objects.get(e).ok())
+        .is_some_and(|(net_entity, store)| match net_entity.kind {
+            // `0x612764`: a GameObject kneels unless it is the bobber.
+            benilla_protocol::EntityKind::GameObject => {
+                store.0.gameobject_type_id() != GO_TYPE_FISHINGNODE
+            }
+            // `0x61278c`: a unit kneels only once its `UNIT_FIELD_HEALTH` is not positive — read
+            // straight off the descriptor, as the bytes do (an unsent field is 0 in the client's
+            // descriptor array too, so `unwrap_or(0)` *is* the faithful read; this deliberately
+            // does not go through `unit_is_dead`, whose extra `max_health > 0` guard the
+            // reference has no counterpart for).
+            benilla_protocol::EntityKind::Unit | benilla_protocol::EntityKind::Player => {
+                store.0.unit_health().unwrap_or(0) == 0
+            }
+            // An ITEM never kneels (`0x612797`), and we stream no item entities anyway — the
+            // resolve above already answers `false` for a lockbox latch. Everything else
+            // (DynamicObject, Other) is not a loot target the reference reaches here.
+            _ => false,
+        });
+    if kneel.0 != allowed {
+        kneel.0 = allowed;
+    }
+}
+
 impl LootLatch {
     /// Drop the latch if it still points at `guid` (a release/refusal for that loot session).
     pub(crate) fn clear_for(&mut self, guid: u64) {
@@ -326,6 +406,7 @@ impl Plugin for UiLootPlugin {
             .init_resource::<LootErrors>()
             .init_resource::<LootConfig>()
             .init_resource::<LootLatch>()
+            .init_resource::<LootKneel>()
             .add_systems(
                 Update,
                 (
@@ -333,6 +414,10 @@ impl Plugin for UiLootPlugin {
                     // after it so a click's intent goes out the same frame (mirrors ui_merchant).
                     feed_loot.before(UiInput),
                     drain_loot.after(UiInput),
+                    // Predicate B, per frame, after the net drain that arms the latch. The anim
+                    // driver then orders itself after THIS (`crate::creature_anim`), closing the
+                    // arm→pose gap to zero frames, as the reference's force-play does.
+                    resolve_loot_kneel.after(benilla_world::schedule::WorldStage::Net),
                 ),
             );
     }
@@ -724,6 +809,84 @@ fn drain_loot(
 mod tests {
     use super::*;
     use benilla_protocol::messages::loot_type;
+    use benilla_protocol::messages::ObjectFields;
+    use benilla_protocol::EntityKind;
+
+    /// Descriptor field indices the predicate-B table reads.
+    const F_GO_TYPE_ID: u16 = 21;
+    const F_UNIT_HEALTH: u16 = 22;
+
+    /// Drive [`resolve_loot_kneel`] once over a world holding one latched object, and report what
+    /// predicate B said. `None` for `object` = the latch names a guid that does not resolve.
+    fn kneels_at(object: Option<(EntityKind, &[(u16, u32)])>) -> bool {
+        const GUID: u64 = 0xF110_0000_0000_0042;
+        let mut app = App::new();
+        app.init_resource::<LootLatch>()
+            .init_resource::<LootKneel>()
+            .init_resource::<crate::net::GuidIndex>()
+            .add_systems(Update, resolve_loot_kneel);
+        app.world_mut().resource_mut::<LootLatch>().0 = Some(GUID);
+        if let Some((kind, fields)) = object {
+            let e = app
+                .world_mut()
+                .spawn((
+                    crate::net::NetEntity {
+                        kind,
+                        display_id: None,
+                        scale: 1.0,
+                    },
+                    crate::net::ObjectStore(ObjectFields::from_pairs(fields)),
+                ))
+                .id();
+            app.world_mut()
+                .resource_mut::<crate::net::GuidIndex>()
+                .0
+                .insert(GUID, e);
+        }
+        app.update();
+        app.world().resource::<LootKneel>().0
+    }
+
+    /// **Predicate B `0x612710`, the local branch** (wow-re `loot-anim-leg.md` §8; decision 1477).
+    /// The whole row set, because the *point* of this predicate is that arming the latch is not
+    /// the same question as kneeling: a fishing bobber and a chest arm it identically, and only
+    /// one of them is knelt at. Without this filter, 1471's response-arm gave benilla a kneel at
+    /// a bobber, over a lockbox, and while pickpocketing — none of which the reference does.
+    #[test]
+    fn predicate_b_decides_which_loot_targets_are_knelt_at() {
+        // A GameObject that is not the bobber — a chest, a herb node, a FISHINGHOLE(25).
+        assert!(kneels_at(Some((
+            EntityKind::GameObject,
+            &[(F_GO_TYPE_ID, 3)]
+        ))));
+        assert!(kneels_at(Some((
+            EntityKind::GameObject,
+            &[(F_GO_TYPE_ID, 25)]
+        ))));
+        // `0x612772` — GAMEOBJECT_TYPE_ID 17 FISHINGNODE, the one type named explicitly.
+        assert!(!kneels_at(Some((
+            EntityKind::GameObject,
+            &[(F_GO_TYPE_ID, 17)]
+        ))));
+        // `0x61278c` — a corpse kneels, a live target (pickpocketing) does not.
+        assert!(kneels_at(Some((EntityKind::Unit, &[(F_UNIT_HEALTH, 0)]))));
+        assert!(!kneels_at(Some((EntityKind::Unit, &[(F_UNIT_HEALTH, 1)]))));
+        // `0x612732` — a guid the object manager cannot resolve (an item latch is this, for us).
+        assert!(!kneels_at(None));
+    }
+
+    /// A cold latch is not a kneel — predicate A's half, folded into the same resource so the
+    /// anim driver reads one boolean.
+    #[test]
+    fn a_cold_latch_never_kneels() {
+        let mut app = App::new();
+        app.init_resource::<LootLatch>()
+            .init_resource::<LootKneel>()
+            .init_resource::<crate::net::GuidIndex>()
+            .add_systems(Update, resolve_loot_kneel);
+        app.update();
+        assert!(!app.world().resource::<LootKneel>().0);
+    }
 
     fn item(slot: u8, entry: u32, count: u32) -> LootItem {
         LootItem {
diff --git a/crates/benilla-app/src/ui_script/options_tests.rs b/crates/benilla-app/src/ui_script/options_tests.rs
index 28009302..d891c3d8 100644
--- a/crates/benilla-app/src/ui_script/options_tests.rs
+++ b/crates/benilla-app/src/ui_script/options_tests.rs
@@ -6,7 +6,8 @@
 //! cite; 0989: the directed cuts — steppers and the corner X gone, the whole bar live via
 //! the engine's track-press law, the search box at the era's verbatim seat; 0992: the
 //! dropdown row shape on the 1.12 kit — Environment Detail — and the Nameplates page's
-//! three UnitName* rows).
+//! three UnitName* rows; 1476: the ground dim — a black fill over the 0.6 tile, seated clear
+//! of the rope's ink, because a 60% veil is not a page you can read over bright terrain).
 //!
 //! What these guard: the file loads clean inside the real neighbourhood (Fonts + UiPanels +
 //! GameMenuFrame); the menu's Options button is the door in (menu down, options up, on the ref's
@@ -295,6 +296,77 @@ fn the_selected_row_wears_the_gold_wash_and_hover_runs_blue() {
     assert!(s.errors().is_empty(), "script errors: {:?}", s.errors());
 }
 
+/// The GROUND DIM (1476) — the plain black fill that turns 0.6 of veil into a page you can
+/// read. Two laws here, both silently breakable by hand, and neither about the taste number:
+/// the fill must draw **above** the backdrop's tiled ground (a region sorts after its frame's
+/// own draw slot, which is the whole reason a region *can* dim it), and it must sit clear of
+/// the rope's **ink** — the border's four edge slices are dead from texel 16 of 32 and the
+/// corners' ink ends by 14 (decoded from `UI-DialogBox-Border`), so anything inset 14 or more
+/// darkens the page without touching the frame. At the backdrop's own 11/12/12/11 bg insets it
+/// would smear across the rope's inner half, which is exactly the mistake this pins.
+#[test]
+fn the_ground_dim_draws_over_the_tile_and_clear_of_the_rope() {
+    let mut s = harness();
+    s.run("ERA_WINDOW_SCALE = 1").unwrap();
+    s.run("ShowUIPanel(OptionsFrame)").unwrap();
+    s.resolve();
+
+    let edge = |frame: &str, side: &str| -> f32 {
+        s.eval(&format!("return {frame}:Get{side}()")).unwrap()
+    };
+    let (fl, fr, ft, fb) = (
+        edge("OptionsFrame", "Left"),
+        edge("OptionsFrame", "Right"),
+        edge("OptionsFrame", "Top"),
+        edge("OptionsFrame", "Bottom"),
+    );
+    let (dl, dr, dt, db) = (
+        edge("OptionsFrameGroundDim", "Left"),
+        edge("OptionsFrameGroundDim", "Right"),
+        edge("OptionsFrameGroundDim", "Top"),
+        edge("OptionsFrameGroundDim", "Bottom"),
+    );
+    for (name, inset) in [
+        ("left", dl - fl),
+        ("right", fr - dr),
+        ("top", ft - dt),
+        ("bottom", db - fb),
+    ] {
+        assert!(
+            inset >= 14.0,
+            "the dim must clear the rope's ink on the {name} — inset {inset}"
+        );
+    }
+
+    // Draw order: `extract` returns ascending z, so a later index draws later. The dim has to
+    // land after the tiled ground or it dims nothing.
+    let quads = s.extract();
+    let ground = quads
+        .iter()
+        .position(|q| match &q.content {
+            QuadContent::Backdrop { path, .. } => path.contains("UI-DialogBox-Background"),
+            _ => false,
+        })
+        .expect("the window still wears the 1.14 dialog ground");
+    let dim = quads
+        .iter()
+        .position(|q| {
+            let Some(r) = q.rect else { return false };
+            matches!(
+                &q.content,
+                QuadContent::Texture { path: None, color: Some(c), .. }
+                    if c[0] == 0.0 && c[1] == 0.0 && c[2] == 0.0 && c[3] > 0.0 && c[3] < 1.0
+            ) && (r.left - dl).abs() < 0.5
+                && (r.top - dt).abs() < 0.5
+        })
+        .expect("the black ground fill is drawn");
+    assert!(
+        dim > ground,
+        "the dim draws over the tile (ground #{ground}, dim #{dim})"
+    );
+    assert!(s.errors().is_empty(), "script errors: {:?}", s.errors());
+}
+
 /// Search (0984: the era SettingsPanel mechanism transcribed): typing reflows the LIVE
 /// matching rows under a clickable category head — a matched CHILD pulls its parent volume
 /// row in above it (the era parentInitializer rule) — the title reads "Search Results" and
diff --git a/crates/benilla-formats/tests/m2_loader_idle_is_stand.rs b/crates/benilla-formats/tests/m2_loader_idle_is_stand.rs
index b6659126..31c368e7 100644
--- a/crates/benilla-formats/tests/m2_loader_idle_is_stand.rs
+++ b/crates/benilla-formats/tests/m2_loader_idle_is_stand.rs
@@ -72,8 +72,9 @@ fn the_duel_flag_idle_resolves_to_stand_and_sits_planted() {
 
     // 4. Stand's AUTHORED bounds describe the planted flag — ground to tip — and emphatically NOT
     //    the bind pose (z +8.9..+14.7). This is the mouseover picker's volume for the armed idle
-    //    (entity M2s are never frustum-culled — the renderer takes `NoFrustumCulling`, faithful
-    //    to the reference's ≈1e7 entity render bounds; wow-re `unit-anim-visibility-gate.md`).
+    //    (entity M2 parts carry `NoFrustumCulling` — the view cull is the body ROOT's per-object
+    //    election, never a per-part box; the "≈1e7 entity render bounds" reading behind 0648 was
+    //    refuted by wow-re's `outdoor-object-pass-election.md` — decision 1473).
     //    The bind-pose `Aabb` Bevy would derive sits a whole model-height ABOVE the geometry that
     //    draws — as a cull box it hid the planted flag from every ground-level camera, and as a
     //    pick box it would put the hover target in the sky.
diff --git a/crates/benilla-world/src/entity_shade.rs b/crates/benilla-world/src/entity_shade.rs
index 3035f7af..823744bc 100644
--- a/crates/benilla-world/src/entity_shade.rs
+++ b/crates/benilla-world/src/entity_shade.rs
@@ -222,6 +222,9 @@ pub(crate) fn update_ground_shade(
         &GlobalTransform,
         &mut GroundShade,
         Option<&crate::world_unit::ViewerUnit>,
+        // The election's verdict on this root (1270/1475) — `Option` because a fixed doodad's
+        // shade root carries no `Visibility` of its own and must keep walking.
+        Option<&Visibility>,
     )>,
     children: Query<&Children>,
     // Parts are matched by carrying a `MeshTag`; interior-classified ones are skipped (their payload
@@ -248,7 +251,7 @@ pub(crate) fn update_ground_shade(
     };
     let step = SHADE_RAMP_PER_SEC * time.delta_secs();
     let ambient_step = AMBIENT_RAMP_PER_SEC * time.delta_secs();
-    for (root, gt, shade, is_self) in &mut roots {
+    for (root, gt, shade, is_self, root_vis) in &mut roots {
         // `WOW_INTERIOR_LOG=1`: a periodic SELF-node dump (every 3 s) — the probe run's definitive
         // "what state is the parked character actually in" line, attributable unlike the
         // change-triggered `[node]` lines below (wandering NPCs fire those constantly).
@@ -325,11 +328,19 @@ pub(crate) fn update_ground_shade(
             ramp_toward(a.z, at.z, ambient_step),
         );
         let byte = (shade.t * 255.0).round().clamp(0.0, 255.0) as u8;
+        // A root the election hid (1270/1475) draws nothing, so the re-assert walk below is
+        // skipped whole — 1473's audit found it running over every part of every off-view body.
+        // The ramps above kept stepping, so the byte is current the frame the body wakes; this
+        // system runs one stage before the election (Update vs PostUpdate), so the wake frame's
+        // walk re-asserts at most one frame late, into parts whose tags retained their last byte.
+        if root_vis.is_some_and(|v| *v == Visibility::Hidden) {
+            continue;
+        }
         // Push to every part below the root (body submeshes are direct children; held items/helm ride
         // joint entities deeper down — same full-tree walk as the self-fade). Change-gated per part on
         // the byte, so a settled entity writes nothing and never re-triggers render extraction. The
-        // walk itself is unconditional: it is the MeshTag re-assert over the classifier's exterior
-        // reclaim (1358), not a change-only push.
+        // walk itself is unconditional for a DRAWN root: it is the MeshTag re-assert over the
+        // classifier's exterior reclaim (1358), not a change-only push.
         root_shade.insert(root, byte);
         for part in children.iter_descendants(root) {
             let Ok((mut tag, lit)) = parts.get_mut(part) else {
diff --git a/crates/benilla-world/src/exterior_cull.rs b/crates/benilla-world/src/exterior_cull.rs
index f19bab33..862b8452 100644
--- a/crates/benilla-world/src/exterior_cull.rs
+++ b/crates/benilla-world/src/exterior_cull.rs
@@ -49,6 +49,16 @@
 //! So a body is exterior scene exactly when it is not in a WMO room, and the windows gate it like
 //! the ground it stands on — [`WorldUnit::bound`].
 //!
+//! **The outdoor half of the same election (decision 1475).** The reference's OUTSIDE leg is not a
+//! stand-down — it is one full-screen window through the same walk (`0x6811ff`), whose producer
+//! `0x683340` frustum-tests every node; and the sibling in-room producer `0x6834e0` submits a
+//! group's members only when the group is rendered, frustum-testing each. So outdoors a body's
+//! bound is tested against the camera's own view volume, and an in-room body draws only when its
+//! room (one portal hop padded — the doorway-straddle guard) is in the PVS *and* its box is in
+//! view. 1270 §6 deferred this half; 1473's audit is why it landed. `WOW_NO_DRAW_ELECTION=1` is
+//! the lever back to the window leg alone. Knowingly absent: the horizon-occlusion term
+//! (`0x686000`) — its own machinery, its own record.
+//!
 //! ## The clip geometry
 //!
 //! Per window, the reference bilerps the camera's four global corner rays (`0xc7bcd8`) by the window's
@@ -160,9 +170,14 @@ impl Plugin for ExteriorCullPlugin {
             apply_exterior_cull
                 .in_set(ExteriorCullSet)
                 // The windows are written by the flood in `Update`; the cull reads them and must land
-                // before Bevy's own visibility pass consumes the result this same frame.
+                // before Bevy's own visibility pass consumes the result this same frame — and before
+                // the hierarchy propagation, so a root verdict reaches `InheritedVisibility` (which
+                // 1283's consumers and the billboard mirror read) the SAME frame. 1270 only ordered
+                // against `CheckVisibility`, leaving a benign race the window leg never noticed; the
+                // frustum leg follows the camera every frame, so the frame of lag is pinned away.
                 .after(WmoPvsSet)
                 .after(bevy::transform::TransformSystems::Propagate)
+                .before(VisibilitySystems::VisibilityPropagate)
                 .before(VisibilitySystems::CheckVisibility),
         );
     }
@@ -359,20 +374,47 @@ type ElectedBody = (
 /// it is the sole authority for: terrain cells, the WDL far band, and — in the second query below,
 /// a different audience under the same law rather than a second system — the elected net bodies
 /// ([`ElectedBody`], decision 1270), whose roots nothing else writes.
+#[allow(clippy::too_many_arguments)]
+// A Bevy system's params are not an argument list to shorten — each is a distinct world access
+// the scheduler needs by name (the `update_ground_shade` precedent).
 fn apply_exterior_cull(
     windows: Res<ExteriorWindows>,
     cam: Query<(&GlobalTransform, &Projection), With<WorldCamera>>,
     mut scene: Query<UnownedScene, UnownedSceneFilter>,
     mut bodies: Query<ElectedBody>,
+    instances: Query<&crate::wmo_portal::WmoPortalInstance>,
+    wmos: Res<Assets<benilla_assets::WmoModel>>,
     mut verdict: ResMut<ExteriorCullVerdict>,
     trace: Option<Res<CullTrace>>,
+    mut no_election: Local<Option<bool>>,
 ) {
+    // `WOW_NO_DRAW_ELECTION=1` — disable 1475's frustum + room legs only (the 1270 window leg
+    // stays: it fixes a *correctness* report, not a cost). The A/B lever that brackets the
+    // election's worth at any pin, and the escape hatch if an artifact is ever reported.
+    let no_election =
+        *no_election.get_or_insert_with(|| std::env::var_os("WOW_NO_DRAW_ELECTION").is_some());
     let set = |vis: &mut Visibility, target: Visibility| {
         if *vis != target {
             *vis = target;
         }
     };
     let gate = ExteriorGate::build(&windows, cam.iter().next());
+    // The camera's own view volume, as the full-screen window: the reference's OUTSIDE leg is
+    // literally one `{0,0,1,1}` window through the same walk (`0x6811ff`), so outdoors is not a
+    // stand-down for bodies — an out-of-frustum body is elected pass 2, not drawn and not ticked
+    // (1473's correction of 0648; decision 1475). Built from this frame's own camera transform
+    // (we run after `Propagate`), never the `Frustum` component, which another PostUpdate set
+    // may not have refreshed yet. `None` (no camera) admits: a verdict without a view matrix
+    // would be arbitrary — `ExteriorGate::build`'s own law.
+    let full_view = cam.iter().next().and_then(|(cam_t, proj)| {
+        let clip_from_world = proj.get_clip_from_view() * cam_t.to_matrix().inverse();
+        window_frustum([-1.0, -1.0, 1.0, 1.0], &clip_from_world)
+    });
+    let in_view = |gt: &GlobalTransform, bound: &Aabb| {
+        full_view
+            .as_ref()
+            .is_none_or(|f| f.intersects_obb(bound, &gt.affine(), true, true))
+    };
     let (mut tested, mut hidden, mut unbounded) = (0usize, 0usize, 0usize);
     for (gt, aabb, mut vis) in &mut scene {
         tested += 1;
@@ -410,12 +452,29 @@ fn apply_exterior_cull(
         // *outdoors* makes a mob in your own room appear a frame late, guessing *in a room* makes a
         // mob outside appear through solid rock. And `UnitWmoRoom::default()` is itself a
         // no-room claim, so this simply decides the missing component the way the present one would.
-        let exempt = room.is_some_and(|r| r.room().is_some());
-        let admitted = exempt || gate.admits(gt, Some(bound));
+        let in_room = room.is_some_and(|r| r.room().is_some());
+        let admitted = if no_election {
+            // The lever: 1270's window leg alone — in-room exempt, outdoors a stand-down.
+            in_room || gate.admits(gt, Some(bound))
+        } else if in_room {
+            // The sibling producer (`0x6834e0`): submitted with its building iff its room — or a
+            // one-hop neighbour, the doorway-straddle guard — is in this frame's portal PVS,
+            // AND its box passes the camera frustum like any other group member (the producer
+            // frustum-tests members; a body behind the camera in a visible room is pass 2).
+            // Fail-open at every resolve seam ([`crate::wmo_portal::room_pvs_visible`]).
+            crate::wmo_portal::room_pvs_visible(room, &instances, &wmos) && in_view(gt, bound)
+        } else {
+            // The exterior walk: outdoors, the one full-screen window; indoors, the portal
+            // windows — which are already sub-frusta of the view, so no second frustum term.
+            match &gate {
+                ExteriorGate::Open => in_view(gt, bound),
+                ExteriorGate::Windows(_) => gate.admits(gt, Some(bound)),
+            }
+        };
         trace_body(
             &trace,
             e,
-            if exempt { "in-room" } else { "outdoor" },
+            if in_room { "in-room" } else { "outdoor" },
             gt,
             room,
             Some(bound),
@@ -549,6 +608,7 @@ mod tests {
     ) -> (Vec<Visibility>, ExteriorCullVerdict) {
         let mut app = App::new();
         app.init_resource::<ExteriorCullVerdict>()
+            .insert_resource(Assets::<benilla_assets::WmoModel>::default())
             .insert_resource(windows)
             .add_systems(Update, apply_exterior_cull);
         // The same camera the pure-frustum tests use: origin, down −Z, 90° fov.
@@ -690,21 +750,137 @@ mod tests {
         assert_eq!((verdict.bodies, verdict.bodies_hidden), (1, 1));
     }
 
-    /// Outdoors the driver takes its `{0,0,1,1}` leg and every body is submitted as before — the
-    /// arm that must never narrow, since it is the state the client spends most of its life in.
+    /// Outdoors the driver's `{0,0,1,1}` leg IS the ordinary frustum — the reference's outside
+    /// leg is one full-screen window through the same frustum-testing walk, so a body behind the
+    /// camera is elected pass 2: not drawn (decision 1475). This test asserted the opposite under
+    /// 1270 ("`Unrestricted` is a stand-down… the arm that must never narrow") — that law was
+    /// built before wow-re's election correction and is deliberately superseded here (1473).
     #[test]
-    fn outdoors_every_body_is_submitted() {
+    fn outdoors_the_full_screen_window_elects_the_bodies() {
         let (vis, verdict) = run_bodies(
             ExteriorWindows::Unrestricted,
             &[
                 (Vec3::new(0.0, 0.0, -50.0), outdoors(), creature_box()),
-                // Behind the camera, and still submitted: `Unrestricted` is a stand-down, not a
-                // frustum test. Bevy's own cull is what drops this one, one system later.
+                // Behind the camera: pass 2. Its parts carry `NoFrustumCulling` (0648's picker
+                // law), so this root verdict is the ONLY thing standing between an off-view
+                // crowd and the draw queue — the Goldshire premium of 1473.
                 (Vec3::new(0.0, 0.0, 50.0), outdoors(), creature_box()),
             ],
         );
-        assert_eq!(vis, vec![Visibility::Inherited; 2]);
-        assert_eq!((verdict.bodies, verdict.bodies_hidden), (2, 0));
+        assert_eq!(
+            vis,
+            vec![Visibility::Inherited, Visibility::Hidden],
+            "ahead is drawn; behind the camera is elected out"
+        );
+        assert_eq!((verdict.bodies, verdict.bodies_hidden), (2, 1));
+    }
+
+    /// The in-room fork of the same election: a body in a PVS-dark room is not drawn — the
+    /// sibling producer only submits members of rendered groups — and the moment the flood
+    /// reaches its room (or a one-hop neighbour), it draws again. The imp-upstairs-in-the-inn
+    /// case from 1473's audit: visible-room wiring, resolve chain and all, not just the truth
+    /// table (which lives with [`crate::wmo_portal::room_pvs_visible`]).
+    #[test]
+    fn a_body_in_a_pvs_dark_room_is_not_drawn_until_the_flood_reaches_it() {
+        let mut app = App::new();
+        app.init_resource::<ExteriorCullVerdict>()
+            .insert_resource(Assets::<benilla_assets::WmoModel>::default())
+            .insert_resource(ExteriorWindows::Unrestricted)
+            .add_systems(Update, apply_exterior_cull);
+        app.world_mut().spawn((
+            WorldCamera,
+            GlobalTransform::IDENTITY,
+            Projection::Perspective(PerspectiveProjection {
+                fov: std::f32::consts::FRAC_PI_2,
+                aspect_ratio: 1.0,
+                near: 0.1,
+                far: 1000.0,
+                ..default()
+            }),
+        ));
+        // A two-group building whose groups share no portal: group 0's verdict is its own bit.
+        // The nav table must be REAL — an absent nav entry is a fail-open seam that reads
+        // visible ([`crate::wmo_portal::room_pvs_visible`]'s law), which is right for a
+        // still-loading model and wrong as a test of the dark-room verdict.
+        let sealed = |_g: u16| benilla_assets::WmoGroupNav {
+            flags: 0,
+            bbox_min: [0.0; 3],
+            bbox_max: [0.0; 3],
+            ref_start: 0,
+            ref_count: 0,
+            area_table_id: 0,
+            fog_indices: [0; 4],
+            group_liquid: benilla_formats::NO_GROUP_LIQUID,
+        };
+        let model = benilla_assets::WmoModel {
+            wmo_id: 1,
+            group_nav: vec![sealed(0), sealed(1)],
+            portal_refs: Vec::new(),
+            ..Default::default()
+        };
+        let handle = app
+            .world_mut()
+            .resource_mut::<Assets<benilla_assets::WmoModel>>()
+            .add(model);
+        let inst = app
+            .world_mut()
+            .spawn(crate::wmo_portal::WmoPortalInstance {
+                handle,
+                world_from_local: bevy::math::Affine3A::IDENTITY,
+                name_set: 0,
+                visible: vec![false, false],
+                liquid_visited: vec![false, false],
+                flooded: vec![None, None],
+            })
+            .id();
+        // Dead ahead of the camera — only the room term can hide it.
+        let body = app
+            .world_mut()
+            .spawn((
+                GlobalTransform::from_translation(Vec3::new(0.0, 0.0, -50.0)),
+                crate::world_unit::WorldUnit {
+                    wades: true,
+                    scale: 1.0,
+                    height: 2.0,
+                    bound: Some(creature_box()),
+                },
+                crate::wmo_portal::UnitWmoRoom::claimed(crate::wmo_portal::WmoRoom {
+                    instance: inst,
+                    group: 0,
+                }),
+                Visibility::Inherited,
+            ))
+            .id();
+        app.update();
+        assert_eq!(
+            *app.world().entity(body).get::<Visibility>().unwrap(),
+            Visibility::Hidden,
+            "a PVS-dark room's body is not submitted"
+        );
+        // The flood reaches its room: drawn again the same frame.
+        app.world_mut()
+            .entity_mut(inst)
+            .get_mut::<crate::wmo_portal::WmoPortalInstance>()
+            .unwrap()
+            .visible[0] = true;
+        app.update();
+        assert_eq!(
+            *app.world().entity(body).get::<Visibility>().unwrap(),
+            Visibility::Inherited,
+            "PVS reach ⇒ drawn"
+        );
+        // And a lit room does not exempt a member from the view: the sibling producer
+        // frustum-tests members too. Move the body behind the camera — hidden again.
+        *app.world_mut()
+            .entity_mut(body)
+            .get_mut::<GlobalTransform>()
+            .unwrap() = GlobalTransform::from_translation(Vec3::new(0.0, 0.0, 50.0));
+        app.update();
+        assert_eq!(
+            *app.world().entity(body).get::<Visibility>().unwrap(),
+            Visibility::Hidden,
+            "a visible room's behind-camera member is still pass 2"
+        );
     }
 
     /// A doorway on the right admits the body on the right and rejects the one on the left — the
diff --git a/crates/benilla-world/src/wmo_portal/mod.rs b/crates/benilla-world/src/wmo_portal/mod.rs
index f844a630..637779b9 100644
--- a/crates/benilla-world/src/wmo_portal/mod.rs
+++ b/crates/benilla-world/src/wmo_portal/mod.rs
@@ -32,6 +32,7 @@ use std::sync::Arc;
 mod fog;
 mod interior;
 mod probe;
+mod room_vis;
 mod seed;
 
 use fog::select_wmo_fog;
@@ -47,6 +48,7 @@ pub use interior::{
 };
 pub use probe::WmoCullProbe;
 use probe::{TraceLog, PROBE_DUMP_PATH};
+pub use room_vis::room_pvs_visible;
 use seed::dominant_axes;
 pub use seed::{down_ray_seeds, floor_z_at, DownRaySeeds};
 
diff --git a/crates/benilla-world/src/wmo_portal/room_vis.rs b/crates/benilla-world/src/wmo_portal/room_vis.rs
new file mode 100644
index 00000000..ec1d1b6a
--- /dev/null
+++ b/crates/benilla-world/src/wmo_portal/room_vis.rs
@@ -0,0 +1,118 @@
+//! **Is a claimed WMO room visible this frame?** — the one answer two elections share.
+//!
+//! The reference elects an object standing in a WMO group with its building (`0x6834e0`, inside
+//! the WMO-group render path): if the group isn't rendered this frame, the object is pass 2 —
+//! neither drawn nor ticked. Two of our systems ask exactly that question of a body's
+//! [`UnitWmoRoom`] claim: the anim-LOD gate (`creature_anim::lod`, decision 0739 — parks the
+//! pose) and the body draw election (`crate::exterior_cull`, decision 1475 — hides the root).
+//! One function answers both, so the two can never drift apart (the drift is how 0448's park and
+//! 0648's draw ended up disagreeing for a month — decision 1473).
+
+use bevy::prelude::*;
+
+use benilla_assets::{WmoGroupNav, WmoModel, WmoPortalRef};
+
+use super::{UnitWmoRoom, WmoPortalInstance, WmoRoom};
+
+/// The room leg's resolve chain: unit claim → placement instance → model → PVS bits. Fail-open
+/// at every seam (no claim, despawned placement, still-loading model) — a lookup miss must never
+/// hide or park a drawable body.
+pub fn room_pvs_visible(
+    room: Option<&UnitWmoRoom>,
+    instances: &Query<&WmoPortalInstance>,
+    wmos: &Assets<WmoModel>,
+) -> bool {
+    let Some(WmoRoom { instance, group }) = room.and_then(|r| r.room()) else {
+        return true;
+    };
+    let Ok(inst) = instances.get(instance) else {
+        return true;
+    };
+    let Some(model) = wmos.get(&inst.handle) else {
+        return true;
+    };
+    room_visible(&inst.visible, &model.group_nav, &model.portal_refs, group)
+}
+
+/// Is the claimed group — or any group one portal hop from it — in the PVS? The one-hop union is
+/// the doorway-straddle guard: a body can extend past its feet's room only through a portal
+/// opening, so the neighbour set bounds everything of the unit that could be on screen. Indices
+/// out of range read visible (fail-open, [`super::WmoGroupVis::drawn_by`]'s convention); a group
+/// with no portal refs at all can only be seen with the camera inside it (the flood cannot reach
+/// it), which the direct bit already answered.
+fn room_visible(visible: &[bool], nav: &[WmoGroupNav], refs: &[WmoPortalRef], group: u16) -> bool {
+    let vis = |g: usize| visible.get(g).copied().unwrap_or(true);
+    if vis(group as usize) {
+        return true;
+    }
+    let Some(n) = nav.get(group as usize) else {
+        return true;
+    };
+    let Some(hops) = refs.get(n.ref_start as usize..(n.ref_start as usize + n.ref_count as usize))
+    else {
+        return true;
+    };
+    hops.iter().any(|r| vis(r.group as usize))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A [`WmoGroupNav`] whose only meaningful fields are its portal-ref slice — these tests
+    /// never touch flags/bounds.
+    fn nav(ref_start: u16, ref_count: u16) -> WmoGroupNav {
+        WmoGroupNav {
+            flags: 0,
+            bbox_min: [0.0; 3],
+            bbox_max: [0.0; 3],
+            ref_start,
+            ref_count,
+            area_table_id: 0,
+            fog_indices: [0; 4],
+            group_liquid: benilla_formats::NO_GROUP_LIQUID,
+        }
+    }
+
+    fn pref(group: u16) -> WmoPortalRef {
+        WmoPortalRef {
+            portal: 0,
+            group,
+            side: 1,
+        }
+    }
+
+    /// The room predicate's whole truth table: direct bit, the one-hop straddle guard, the
+    /// all-dark verdict, the sealed room, and both fail-open seams (group past every table, a
+    /// ref slice past the refs vec).
+    #[test]
+    fn room_visible_covers_the_hop_guard_and_fails_open() {
+        // Groups 0 ↔ 1 share one portal; group 2 is sealed (no refs).
+        let navs = vec![nav(0, 1), nav(1, 1), nav(2, 0)];
+        let refs = vec![pref(1), pref(0)];
+        assert!(
+            room_visible(&[true, false, false], &navs, &refs, 0),
+            "direct PVS bit"
+        );
+        assert!(
+            room_visible(&[true, false, false], &navs, &refs, 1),
+            "own bit dark but the neighbour lit — the doorway-straddle guard keeps it live"
+        );
+        assert!(
+            !room_visible(&[false, false, true], &navs, &refs, 0),
+            "own room and every hop dark ⇒ not visible"
+        );
+        assert!(
+            !room_visible(&[true, true, false], &navs, &refs, 2),
+            "a sealed room's own bit decides — no hops exist to save it"
+        );
+        assert!(
+            room_visible(&[false], &navs, &refs, 9),
+            "a group past the PVS table reads visible (fail-open)"
+        );
+        assert!(
+            room_visible(&[false], &[nav(7, 2)], &refs, 0),
+            "a ref slice past the refs vec reads visible (fail-open)"
+        );
+    }
+}