diff --git a/README.md b/README.md
index 3fe53783..fa220a7d 100644
--- a/README.md
+++ b/README.md
@@ -19,26 +19,34 @@ crates, and no bundled game assets: benilla reads its data at runtime from your
 - **Models & animation** — GPU-skinned M2s with the full animation controller (cross-fades,
   one-shots, fidgets), a near feature-complete particle system, ribbons, and animated gameobjects
   (doors, chests, mailboxes, lifts).
-- **Characters** — customization end to end, the armor-region texture composite, held weapons and
-  sheathing, and mounts.
+- **Characters** — customization end to end, the armor-region texture composite, held weapons with
+  sheathing and enchant glows, shapeshift forms, stealth's fade, and mounts.
 - **Movement & travel** — a WoW-feel controller (run/strafe/jump/swim/step-up), networked movement
-  in both directions, a follow-camera with collision, ridden boats and zeppelins, and taxi flights.
+  in both directions, the server-granted modes (slow fall, levitate, water walking, roots and
+  stuns), a follow-camera with collision, ridden boats and zeppelins, and taxi flights.
 - **Networking** — SRP6 auth through world-session crypto, the object-descriptor mirror into the
-  ECS, and live wire coverage for movement, chat, spells and auras, party, mail, trade, vendors,
-  bank, trainers, quests, loot with group rolls, and death.
+  ECS, and live wire coverage for movement, chat, spells and auras, party, duels, inspect, the
+  social lists, mail, trade, vendors, bank, trainers, professions, quests, loot with group rolls,
+  item use and locks, and death.
 - **UI** — a from-scratch FrameXML + Lua UI engine driving the built-in interface: login and
-  character screens, the full HUD, the classic windows (bags, spellbook, talents, quests, mail,
-  merchant, trade, bank, world map, …), chat, and tooltips.
+  character screens, the full HUD (cast bars, breath and fatigue timers, combo points), the classic
+  windows (bags and keyring, spellbook, talents, quests, professions, social, inspect, mail,
+  merchant, trade, bank, world map, …), chat with its slash commands, nameplates, floating combat
+  text, chat bubbles, and tooltips.
 - **Combat** — melee with the faithful swing law, ranged and Auto Shot, casting with GCD, cooldowns
-  and the cancel ladder, and the spell-visual pipeline (kits, missiles, impacts, ground rings).
+  and the cancel ladder, combo points, ground-targeted casting, crowd control that really holds you
+  (roots, stuns, the Ice Block freeze), and the spell-visual pipeline (kits, missiles, impacts,
+  ground rings).
 - **Audio** — music, ambience, and SFX under the client's own selection and crossfade rules, with
   interior/underwater transitions and zone reverb.
 
 ## Not built yet
 
-Guilds, the auction house, hunter/warlock pets, duels and inspect, the social panel
-(friends/who), PvP systems, the macros/options/key-binding screens, and third-party addon
-loading — the Lua/FrameXML engine currently runs only the built-in UI.
+Guilds (past the name over a head), the auction house, hunter/warlock pet control (the pet bar),
+battlegrounds, honor and the zone-control PvP overlays (the PvP flag itself shows), the fishing
+minigame, camera-possession spells (Mind Vision, Sentry Totem), the try-on preview (dressing
+room), the macros/options/key-binding screens, and third-party addon loading — the Lua/FrameXML
+engine currently runs only the built-in UI.
 
 ## Running it
 
diff --git a/crates/benilla-protocol/src/messages/items.rs b/crates/benilla-protocol/src/messages/items.rs
index d9cf00c8..89775267 100644
--- a/crates/benilla-protocol/src/messages/items.rs
+++ b/crates/benilla-protocol/src/messages/items.rs
@@ -192,25 +192,51 @@ impl ItemInfo {
         self.use_spell.is_some() || self.inventory_type != 0
     }
 
-    /// Does a right-click **open** this concrete instance rather than use it? `instance_flags` is
-    /// the item object's `ITEM_FIELD_FLAGS` (0 for a template-only view, which can never be
-    /// openable — you can't right-click a hyperlink).
+    /// Does the tooltip put the green `<Right Click to Open>` line on this instance?
+    /// `instance_flags` is the item object's `ITEM_FIELD_FLAGS`; a template-only view (a
+    /// hyperlink, a merchant row) passes 0 and, being object-less, gets no line at all — the
+    /// reference's own gate 1 at `0x52e2e0`.
     ///
-    /// The one predicate behind both halves of the affordance: the tooltip's green
-    /// `<Right Click to Open>` line and the `CMSG_OPEN_ITEM` fork. It is the reference's own
-    /// tooltip condition (wow-re `tooltip-content-law.md` §1-OPENABLE, byte-read at
-    /// `0x52e2f8`–`0x52e321`): the template LOOTABLE bit [`ITEM_FLAG_LOOTABLE`] behind its lock
-    /// sub-gate — a [`ItemInfo::lock_id`] item only opens once the instance carries
+    /// VERIFIED wow-re `right-click-open.md` §1.4 (`0x52e2f8`–`0x52e321`), re-derived by a §5 pair
+    /// 2026-08-02: the template LOOTABLE bit [`ITEM_FLAG_LOOTABLE`] behind its **lock sub-gate** —
+    /// a [`ItemInfo::lock_id`] item earns the line only once the instance carries
     /// [`ITEM_DYNFLAG_UNLOCKED`] — **or** a wrapped gift ([`ITEM_FLAG_WRAPPER`] on the template
-    /// plus [`ITEM_DYNFLAG_WRAPPED`] on the instance). vmangos's `HandleOpenItemOpcode` gates on
-    /// exactly the same pair, so the two ends agree: what the tooltip promises is what the server
-    /// will honour, and a still-locked junkbox neither advertises the line nor sends the packet.
-    pub fn openable(&self, instance_flags: u32) -> bool {
+    /// plus [`ITEM_DYNFLAG_WRAPPED`] on the instance).
+    ///
+    /// **This is deliberately NOT the send condition** ([`Self::opens_loot`]). The line is a
+    /// promise, and the reference only makes it when opening will actually work; the *click*
+    /// tests the bare template bit and lets the server refuse a still-locked box with its own
+    /// error line. Decision 0896 — an earlier reading of ours collapsed the two, which would have
+    /// silently swallowed the click on every locked junkbox.
+    pub fn shows_open_line(&self, instance_flags: u32) -> bool {
         let lootable = self.flags & ITEM_FLAG_LOOTABLE != 0
             && (self.lock_id == 0 || instance_flags & ITEM_DYNFLAG_UNLOCKED != 0);
-        let gift =
-            self.flags & ITEM_FLAG_WRAPPER != 0 && instance_flags & ITEM_DYNFLAG_WRAPPED != 0;
-        lootable || gift
+        lootable || self.unwraps_gift(instance_flags)
+    }
+
+    /// Does a right-click on this instance send `CMSG_OPEN_ITEM` to **unwrap a gift**? The first
+    /// arm of the reference's use dispatcher (`0x5d8d00` #2, `0x5d8d92`/`0x5d8d9d` → the `0x5edd60`
+    /// emitter): template [`ITEM_FLAG_WRAPPER`] **and** instance [`ITEM_DYNFLAG_WRAPPED`].
+    ///
+    /// It is a separate predicate from [`Self::opens_loot`] because it sits at a different point
+    /// in the dispatcher's order — *before* the quest-starter and readable arms, where the loot
+    /// arm sits after them. A wrapper template whose instance is no longer wrapped takes the
+    /// begin-wrap cursor path instead (local, no packet; not built yet).
+    pub fn unwraps_gift(&self, instance_flags: u32) -> bool {
+        self.flags & ITEM_FLAG_WRAPPER != 0 && instance_flags & ITEM_DYNFLAG_WRAPPED != 0
+    }
+
+    /// Does a right-click on this template send `CMSG_OPEN_ITEM` to **loot it open**? The
+    /// reference's arm #8 (`0x5d8f7c: test al,4` → the `0x5edc80` emitter): a **bare** template
+    /// [`ITEM_FLAG_LOOTABLE`] test.
+    ///
+    /// VERIFIED wow-re `right-click-open.md` §3, positively *and* negatively — no `LockID`
+    /// (`[rec+0x1ac]`) operand exists anywhere on the send path, checked against a positive
+    /// control. So a **still-locked junkbox does send the packet**, and the server answers
+    /// `EQUIP_ERR_ITEM_LOCKED`, which is where the player's "Item is locked" line comes from.
+    /// Refusing locally instead would eat the click in silence.
+    pub fn opens_loot(&self) -> bool {
+        self.flags & ITEM_FLAG_LOOTABLE != 0
     }
 }
 
diff --git a/crates/benilla-ui/src/script/follow.rs b/crates/benilla-ui/src/script/follow.rs
new file mode 100644
index 00000000..8d90692c
--- /dev/null
+++ b/crates/benilla-ui/src/script/follow.rs
@@ -0,0 +1,91 @@
+//! The auto-follow **Era API surface** — two globals, no state.
+//!
+//! [`super::duel`]'s shape exactly: everything the UI *reads* about a follow arrives as an event
+//! argument (`AUTOFOLLOW_BEGIN`'s name), so there is no snapshot to push — only the outbound half.
+//! Each call queues a [`FollowRequest`] the app drains ([`super::UiScript::take_follow_requests`])
+//! and turns into its own follow start, keeping the engine free of ECS reach (decision 0068 §3).
+//!
+//! The two are the reference's own follow bindings, and between them they cover every shipped call
+//! site in the 1.12 FrameXML:
+//!
+//! | binding | called by | subject |
+//! |---|---|---|
+//! | `FollowUnit(unit)` | `SlashCmdList["FOLLOW"]` with no argument | a unit token |
+//! | `FollowByName(name, exactMatch)` | `SlashCmdList["FOLLOW"]` with one; `UnitPopup_OnClick`'s FOLLOW row | a name |
+//!
+//! `FollowByName` is `0x489ec0`, one more caller of the shared by-name resolver `0x493aa0` —
+//! typemask `0x10` (players only) and filter mode 2 (`CanAssist` + alive), with **the second Lua
+//! argument steering exact-only matching** (decision 0886's table). That argument is what makes the
+//! popup row different from the slash command: `UnitPopup.lua` passes `FollowByName(name, 1)`, so
+//! clicking *Follow* on a menu that already names the unit exactly must not prefix-match its way
+//! onto somebody else standing nearby, while `/follow rag` still may.
+//!
+//! benilla parses slash lines in Rust rather than in Lua (decision 0881), so the chat half of that
+//! table enters the app's follow funnel directly; these globals are the *other* half — the shipped
+//! UI's, and any addon's.
+
+use mlua::Lua;
+
+use super::Model;
+
+/// Outbound follow intents queued by the Era API calls, drained by the app
+/// ([`super::UiScript::take_follow_requests`]). Plain data — [`super::duel::DuelRequest`]'s twin.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum FollowRequest {
+    /// `FollowUnit(unit)` — follow whoever a unit token points at. The app resolves the token;
+    /// `"target"` is the bare `/follow`, and takes the selection **whatever it is** (the reference
+    /// applies no typemask on this path — decision 0890).
+    ByUnit(String),
+    /// `FollowByName(name, exactMatch)` — follow a player found by name. `exact` is the second Lua
+    /// argument: set, it skips the resolver's longest-common-prefix tier and admits only a
+    /// whole-string (case-insensitive) hit.
+    ByName { name: String, exact: bool },
+}
+
+impl super::UiScript {
+    /// Drain the follow intents queued since the last call.
+    pub fn take_follow_requests(&mut self) -> Vec<FollowRequest> {
+        std::mem::take(&mut self.model_mut().follow_requests)
+    }
+}
+
+/// Register the follow globals (the same style/place [`super::duel`] registers its own).
+pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
+    let g = lua.globals();
+
+    // FollowUnit(unit) — `SlashCmdList["FOLLOW"]`'s no-argument arm, `FollowUnit("target")`.
+    g.set(
+        "FollowUnit",
+        lua.create_function(|lua, unit: String| {
+            let mut model = lua.app_data_mut::<Model>().expect("model app_data");
+            model.follow_requests.push(FollowRequest::ByUnit(unit));
+            Ok(())
+        })?,
+    )?;
+
+    // FollowByName(name, exactMatch) — the unit popup's Follow row passes `1`; the slash command
+    // passes nothing, which is the prefix-matching case (`nil` is false here, as in the ref, where
+    // the argument reaches `0x493aa0` as a plain zero).
+    g.set(
+        "FollowByName",
+        lua.create_function(|lua, (name, exact): (String, Option<mlua::Value>)| {
+            // Absent is the slash command's case; the popup row passes `1`. A numeric zero counts
+            // as false as well — no shipped caller passes one, and treating it that way is the
+            // reading both plausible arg-2 fetches on the C side (`lua_toboolean` vs a number
+            // compare) agree on for every value that can actually arrive here.
+            let exact = match exact {
+                None | Some(mlua::Value::Nil) | Some(mlua::Value::Boolean(false)) => false,
+                Some(mlua::Value::Integer(n)) => n != 0,
+                Some(mlua::Value::Number(n)) => n != 0.0,
+                Some(_) => true,
+            };
+            let mut model = lua.app_data_mut::<Model>().expect("model app_data");
+            model
+                .follow_requests
+                .push(FollowRequest::ByName { name, exact });
+            Ok(())
+        })?,
+    )?;
+
+    Ok(())
+}
diff --git a/crates/benilla-ui/src/script/mod.rs b/crates/benilla-ui/src/script/mod.rs
index 68d5d1e9..aa876144 100644
--- a/crates/benilla-ui/src/script/mod.rs
+++ b/crates/benilla-ui/src/script/mod.rs
@@ -53,6 +53,7 @@ pub(crate) use editbox::adopt_text_region;
 mod duel;
 mod event;
 mod extract;
+mod follow;
 mod gossip;
 mod inspect;
 mod item_stats;
@@ -111,6 +112,7 @@ pub use craft::{CraftReagent, CraftRecipe, CraftState};
 pub use cursor::{CursorAction, CursorItem, CursorPayload, CursorSpell, WorldPick, EQUIPMENT_BAG};
 pub use death::{DeathAction, DeathUiState};
 pub use duel::DuelRequest;
+pub use follow::FollowRequest;
 pub use gossip::{GossipMenu, GossipOptionView, GossipQuestRow};
 pub use inspect::InspectView;
 pub use item_stats::{item_usable, ItemSetView, ItemTemplateView, PlayerReqState};
@@ -257,6 +259,7 @@ impl UiScript {
         party::install(&lua)?;
         social::install(&lua)?;
         duel::install(&lua)?;
+        follow::install(&lua)?;
         session::install(&lua)?;
         pvp::install(&lua)?;
         death::install(&lua)?;
diff --git a/crates/benilla-ui/src/script/model.rs b/crates/benilla-ui/src/script/model.rs
index e4f4fcff..3912025b 100644
--- a/crates/benilla-ui/src/script/model.rs
+++ b/crates/benilla-ui/src/script/model.rs
@@ -4,9 +4,9 @@ use crate::layout::{LayoutInput, LayoutSolver, Rect};
 use crate::widget::{FrameHandle, RegionHandle, WidgetArena};
 
 use super::{
-    backdrop, bank, char_stats, container, craft, cursor, death, duel, gossip, inspect, item_text,
-    loot, loot_roll, mail, merchant, party, quest, quest_log, session, skills, slider, social,
-    spellbook, taxi, trade, tradeskill, trainer, ActionSlot, AuraState, FontObject,
+    backdrop, bank, char_stats, container, craft, cursor, death, duel, follow, gossip, inspect,
+    item_text, loot, loot_roll, mail, merchant, party, quest, quest_log, session, skills, slider,
+    social, spellbook, taxi, trade, tradeskill, trainer, ActionSlot, AuraState, FontObject,
     ItemTemplateView, PlayerReqState, RegionData, ScriptValue, SoundRequest, UnitState,
 };
 
@@ -180,6 +180,11 @@ pub(crate) struct Model {
     /// [`super::UiScript::take_duel_requests`] drain — the outbound seam ([`duel`]). There is no
     /// duel *snapshot* beside it: everything the UI reads arrives as event arguments.
     pub(crate) duel_requests: Vec<duel::DuelRequest>,
+    /// Follow intents (`FollowUnit`/`FollowByName`) queued since the app's last
+    /// [`super::UiScript::take_follow_requests`] drain — the outbound seam ([`follow`]). The duel
+    /// queue's twin, snapshot-less for the same reason: the only thing the UI reads back is the
+    /// `AUTOFOLLOW_BEGIN`/`AUTOFOLLOW_END` pair the app fires, which carries its own argument.
+    pub(crate) follow_requests: Vec<follow::FollowRequest>,
     /// Session-exit intents (`Logout`/`Quit`/`CancelLogout`/`ForceQuit`) queued since the app's
     /// last [`super::UiScript::take_session_requests`] drain — the outbound seam ([`session`]).
     /// Snapshot-less like the duel queue above: what the UI reads back (the camp/quit countdown)
@@ -707,6 +712,7 @@ impl Model {
             social_requests: Vec::new(),
             tell_requests: Vec::new(),
             duel_requests: Vec::new(),
+            follow_requests: Vec::new(),
             session_requests: Vec::new(),
             pvp_toggles: 0,
             sound_queue: Vec::new(),
diff --git a/crates/benilla-ui/src/script/tests/tooltip_item/law.rs b/crates/benilla-ui/src/script/tests/tooltip_item/law.rs
index 6b780b0b..a3657048 100644
--- a/crates/benilla-ui/src/script/tests/tooltip_item/law.rs
+++ b/crates/benilla-ui/src/script/tests/tooltip_item/law.rs
@@ -426,8 +426,10 @@ fn required_level_one_is_hidden() {
 /// then READABLE off the instance text id (its template's PageText is 0 — the
 /// director-reported gap). An unresolved creator (name query in flight) emits no line. LOCKED
 /// yields to the instance UNLOCKED bit — which is also what un-gates ITEM_OPENABLE: a bag hover
-/// on an openable instance DOES show the green `<Right Click to Open>` (director-observed on a
-/// clam; see `ItemInstance::openable_source` for why this overrides §1-OPENABLE's p6 reading).
+/// on an openable instance shows the green `<Right Click to Open>` (director-observed on a clam;
+/// wow-re `right-click-open.md` §1 re-derived the `p6` leg selector that had it suppressed).
+/// A **running cooldown** takes SetBagItem's other leg and suppresses the line — the two are
+/// structurally exclusive on this binding (decision 0896).
 #[test]
 fn instance_tail_creator_and_readable() {
     let mut s = script();
@@ -474,11 +476,21 @@ fn instance_tail_creator_and_readable() {
     slots.insert(3, slot(2589, false, Some("Geoffrey"), 0)); // crafted, still locked
     slots.insert(4, slot(2589, false, None, 0x4)); // unlocked → LOCKED gone, open line on
     slots.insert(5, slot(7973, false, None, 0)); // the clam: lockless, openable outright
+                                                 // The same clam with a RUNNING cooldown — `SetBagItem`'s p6=1 leg, which skips the openable
+                                                 // tree entirely (the ITEM_COOLDOWN_TIME line takes its place in the reference; that line has
+                                                 // no feed here yet, so this slot renders bare).
+    slots.insert(
+        6,
+        ContainerSlot {
+            cooldown: Some((1_000, 30_000, true)),
+            ..slot(7973, false, None, 0)
+        },
+    );
     s.set_container(
         0,
         Some(ContainerState {
             name: Some("Backpack".into()),
-            num_slots: 5,
+            num_slots: 6,
             slots,
         }),
     );
@@ -526,5 +538,18 @@ fn instance_tail_creator_and_readable() {
         .unwrap();
     let texts: Vec<String> = lines_of(&mut s).into_iter().map(|(t, _)| t).collect();
     assert_eq!(texts, vec!["Small Barnacled Clam", "<Right Click to Open>"]);
+    // The same clam mid-cooldown takes SetBagItem's OTHER leg (p6=1) — the openable tree is
+    // skipped wholesale, so the green line is gone (the reference prints ITEM_COOLDOWN_TIME in
+    // its place; unfed here). `hasCooldown`, the binding's own return, is the same boolean.
+    let has_cd: bool = s
+        .eval(r#"TT:SetOwner(getglobal("SlotL"), "ANCHOR_RIGHT"); return TT:SetBagItem(0, 6)"#)
+        .unwrap();
+    assert!(has_cd, "the cooldown leg is what the return value reports");
+    let texts: Vec<String> = lines_of(&mut s).into_iter().map(|(t, _)| t).collect();
+    assert_eq!(
+        texts,
+        vec!["Small Barnacled Clam"],
+        "a running cooldown suppresses ITEM_OPENABLE — the two lines are exclusive here"
+    );
     assert!(s.take_errors().is_empty());
 }
diff --git a/crates/benilla-ui/src/script/tooltip_item/mod.rs b/crates/benilla-ui/src/script/tooltip_item/mod.rs
index acdf63d7..d981656f 100644
--- a/crates/benilla-ui/src/script/tooltip_item/mod.rs
+++ b/crates/benilla-ui/src/script/tooltip_item/mod.rs
@@ -309,10 +309,13 @@ pub(super) fn install_methods(lua: &Lua, m: &Table) -> mlua::Result<()> {
                                 creator: s.creator.clone(),
                                 has_text: false,
                                 flags: s.flags,
-                                // Unobservable either way: nothing openable is equippable, so the
-                                // doll hover has no case to show. Left `false` (wow-re
-                                // §1-OPENABLE's p6 reading) rather than flipped on the bag's
-                                // evidence — see `ItemInstance::openable_source`.
+                                // `SetInventoryItem 0x532ee0` also has p6=0 legs (`0x533106`,
+                                // `0x5332ad`) — the "this binding can never emit OPENABLE" claim
+                                // is dead here too (wow-re `right-click-open.md` §1.2). Which leg
+                                // each takes is not pinned, and the case is unobservable anyway:
+                                // nothing openable is equippable, so the doll hover has no clam to
+                                // show. Left `false` deliberately — inventing a selector we have
+                                // not read would be the §4 trade, and there is nothing to gain.
                                 openable_source: false,
                             },
                         )
@@ -367,24 +370,33 @@ pub(super) fn install_methods(lua: &Lua, m: &Table) -> mlua::Result<()> {
                     .and_then(|c| c.slots.get(&slot))
                     .filter(|s| s.item_id != 0)
                 {
-                    Some(s) => (
-                        s.item_id,
-                        s.count.max(1),
-                        s.cooldown.is_some_and(|(rem, _, en)| en && rem > 0),
-                        s.link.clone(),
-                        s.quality.unwrap_or(1),
-                        render::ItemInstance {
-                            durability: s.durability,
-                            creator: s.creator.clone(),
-                            has_text: s.readable,
-                            flags: s.flags,
-                            // The bag hover DOES emit `<Right Click to Open>` — director-observed
-                            // (a clam in a bag), against wow-re §1-OPENABLE's p6 reading. See
-                            // `ItemInstance::openable_source`: that gate is under re-derivation,
-                            // and the observation is the ground truth we build on.
-                            openable_source: true,
-                        },
-                    ),
+                    // The reference's own leg selector, byte-read: `SetBagItem 0x534620` asks the
+                    // item-cooldown query `0x6e2ed0` and takes the p6=1 (instance-block) leg iff
+                    // **all three** of enable/start/duration are non-zero — a genuinely running
+                    // cooldown. That one boolean is both the Lua `hasCooldown` return and the
+                    // openable gate's inverse, so they are computed once, here (decision 0896).
+                    Some(s) => {
+                        let has_cd = s
+                            .cooldown
+                            .is_some_and(|(start, dur, en)| en && start > 0 && dur > 0);
+                        (
+                            s.item_id,
+                            s.count.max(1),
+                            has_cd,
+                            s.link.clone(),
+                            s.quality.unwrap_or(1),
+                            render::ItemInstance {
+                                durability: s.durability,
+                                creator: s.creator.clone(),
+                                has_text: s.readable,
+                                flags: s.flags,
+                                // p6 == 0 ⇔ no running cooldown. A clam shows the green line; the
+                                // same clam mid-cooldown would show ITEM_COOLDOWN_TIME instead
+                                // (that line has no feed here yet — a separate, pre-existing gap).
+                                openable_source: !has_cd,
+                            },
+                        )
+                    }
                     None => return Ok(MultiValue::from_vec(vec![Value::Nil])),
                 }
             };
diff --git a/crates/benilla-ui/src/script/tooltip_item/render.rs b/crates/benilla-ui/src/script/tooltip_item/render.rs
index ce632d49..62aa06e3 100644
--- a/crates/benilla-ui/src/script/tooltip_item/render.rs
+++ b/crates/benilla-ui/src/script/tooltip_item/render.rs
@@ -29,24 +29,25 @@ pub(super) struct ItemInstance {
     /// Instance `ITEM_FIELD_FLAGS` — the openable lock sub-gate reads UNLOCKED `0x4`
     /// (`0x52e30c`) and the wrapped-gift arm WRAPPED `0x8` (`0x52e31d`).
     pub flags: u32,
-    /// May this source emit the ITEM_OPENABLE line at all?
+    /// May this source emit the ITEM_OPENABLE line? = the reference's `p6 == 0` — "this tooltip
+    /// carries **no** caller-supplied instance block" (`[this+0x440]`, tested at `0x52e2e8`: when
+    /// it is set, the builder evaluates only READABLE and skips the openable tree entirely).
     ///
-    /// wow-re §1-OPENABLE (byte-census 2026-07-20) reads a `[this+0x440]` gate at `0x52e2e8` as
-    /// bypassing the whole openable tree for every `p6=1` binding, and concludes that
-    /// `SetBagItem` — the binding your own bags hover through — can NEVER emit it. **That
-    /// conclusion is contradicted by ground truth:** the director's screenshot shows a Small
-    /// Barnacled Clam hovered IN A BAG with the green `<Right Click to Open>` line, and vmangos's
-    /// own `ITEM_FLAG_LOOTABLE` comment names that exact client behaviour ("It or lockid set
-    /// enable for client show 'Right click to open'"). A line that could only ever appear on the
-    /// send-mail / auction-sell / buyback tooltips would also be behaviourally absurd. The note is
-    /// additionally self-inconsistent there (§1-CREATOR puts the GIFTCREATOR read at `0x52e32a`,
-    /// inside the region §1-OPENABLE calls the openable emit + jump), so the transcription — not
-    /// the observation — is the suspect. A wow-re §5 re-derivation of `[0x52e2e0, 0x52e376)` is in
-    /// flight; until it lands, the bag hover follows the director's eyes.
+    /// **This is not a per-binding constant.** wow-re's earlier §1-OPENABLE said `SetBagItem`
+    /// passes `p6=1` and so could *never* show the line — which is why our bag hover had no green
+    /// line at all, and which the director's screenshot of a clam falsified. The re-derivation
+    /// (wow-re `right-click-open.md` §1, §5 pair 2026-08-02) found the cause: the old p6 table was
+    /// enumerated per *binding* from the instance-block **writers**, so it only ever saw the p6=1
+    /// leg. A per-**call-site** census of all 31 `0x52b650` sites finds five callers with two or
+    /// more legs, and `SetBagItem 0x534620` is one: `0x534900` p6=1 and `0x53493e` p6=0.
     ///
-    /// The flag is kept rather than deleted because the *template-vs-instance* distinction it also
-    /// carries is settled (gate 1, `0x52e2e0`: no object ⇒ no line — you can't right-click a
-    /// hyperlink), and because the p6 split may still be real for the sources we cannot observe.
+    /// What selects the leg is the item-cooldown query `0x6e2ed0` at `0x53483a` — p6=1 iff
+    /// **enable, start and duration are all non-zero**, i.e. iff the item has a *running
+    /// cooldown*. That same block writes `this+0x408 = start + duration − now`, whose sole
+    /// consumer is the ITEM_COOLDOWN_TIME line and the builder's `hasCooldown` return. So on the
+    /// bag binding the two lines are structurally exclusive: **an item on cooldown shows
+    /// "Cooldown remaining", the same item off cooldown shows `<Right Click to Open>`.**
+    /// Decision 0896.
     pub openable_source: bool,
 }
 
@@ -449,12 +450,18 @@ pub(super) fn render_view(
             }
         }
     }
-    // ITEM_OPENABLE / ITEM_READABLE — ONE line, openable wins (the if/else at
-    // `0x52e2f2..0x52e35d`, wow-re §1-OPENABLE): openable = a p6=0 source AND the template
-    // loot flag `0x4` behind its lock sub-gate (LockID set → only once the instance carries
-    // UNLOCKED `0x4`), or a wrapped gift (template WRAPPER `0x200` + instance WRAPPED `0x8`);
-    // readable = template PageText (the CGItem vtable `+0x74` getter `0x5d9e10`) OR the
-    // instance letter text. Both green.
+    // ITEM_OPENABLE / ITEM_READABLE — ONE line, openable wins outright (the `jmp 0x52e35d` past
+    // the READABLE test; `0x52e2f2..0x52e35d`, wow-re `right-click-open.md` §1.4, re-verified
+    // unchanged by the 2026-08-02 §5 pair): openable = a p6=0 source ([`ItemInstance::
+    // openable_source`]) AND the template loot flag `0x4` behind its lock sub-gate (LockID set →
+    // only once the instance carries UNLOCKED `0x4`), or a wrapped gift (template WRAPPER `0x200`
+    // + instance WRAPPED `0x8`); readable = template PageText (the CGItem vtable `+0x74` getter
+    // `0x5d9e10`) OR the instance letter text. Both green.
+    //
+    // Note the lock sub-gate is the LINE's, not the CLICK's: the send arm tests the bare template
+    // bit, so a locked junkbox stays silent here while its right-click still goes out and draws
+    // the server's "Item is locked" (decision 0896, `ItemInfo::opens_loot`). The click order is
+    // also the inverse of this one — READABLE wins there.
     let openable = inst.openable_source
         && ((v.flags & 0x4 != 0 && (v.lock_id == 0 || inst.flags & 0x4 != 0))
             || (v.flags & 0x200 != 0 && inst.flags & 0x8 != 0));
diff --git a/crates/benilla/assets/ui/UnitPopup.xml b/crates/benilla/assets/ui/UnitPopup.xml
index 51579108..465bfe6c 100644
--- a/crates/benilla/assets/ui/UnitPopup.xml
+++ b/crates/benilla/assets/ui/UnitPopup.xml
@@ -16,10 +16,13 @@
       exactly zero times — so the row was a deviation that made this menu read wrong against the
       reference. `/pvp` is the toggle the client has.
     - DEFERRED ENTRIES: rows whose backing system doesn't exist yet are HIDDEN outright (the
-      BENILLA_UNITPOPUP_DEFERRED set in HideButtons) rather than shown-dead: FOLLOW (its CMSG
-      family is its own slice), TARGET (the friends list), GUILD_PROMOTE/GUILD_LEAVE (the guild
-      arc), RESET_INSTANCES (instances). TRADE came out with decision 0592 P1, DUEL with 0633,
-      INSPECT with 0631. Everything a menu SHOWS works. The PET menu and the RAID_* rank rows stay
+      BENILLA_UNITPOPUP_DEFERRED set in HideButtons) rather than shown-dead: TARGET (the friends
+      list), GUILD_PROMOTE/GUILD_LEAVE (the guild arc), RESET_INSTANCES (instances). TRADE came out
+      with decision 0592 P1, DUEL with 0633, INSPECT with 0631, FOLLOW with 0890's follow-up — and
+      that last entry's stated reason ("its CMSG family is its own slice") was simply WRONG: 0890
+      verified auto-follow sends nothing at all, it is pure client-side movement, so the row was
+      waiting on a wire slice that does not exist. It was the motion law it really needed.
+      Everything a menu SHOWS works. The PET menu and the RAID_* rank rows stay
       in the tables but are unreachable (no "pet" token, no raid roster) — their OnClick branches
       are trimmed with the rest.
     - Lua 5.1: the ref's 5.0 `for i, v in t do` iteration is ipairs/pairs here; strsub → the
@@ -131,7 +134,7 @@
 
         -- The DEFERRED set (header): entries hidden until their backing arc lands.
         BENILLA_UNITPOPUP_DEFERRED = {
-            FOLLOW = 1, TARGET = 1,
+            TARGET = 1,
             GUILD_PROMOTE = 1, GUILD_LEAVE = 1, RESET_INSTANCES = 1,
         };
 
@@ -567,8 +570,14 @@
                 -- Open the inspect window (decision 0631) — the ref UnitPopup_OnClick's INSPECT arm
                 -- verbatim: InspectUnit(unit), which gates on CanInspect and sends CMSG_INSPECT.
                 InspectUnit(unit);
+            elseif ( button == "FOLLOW" ) then
+                -- Begin auto-following — the ref UnitPopup_OnClick's FOLLOW arm verbatim, by NAME
+                -- and EXACT. That `1` is the resolver's exact-only flag, and it matters: this menu
+                -- already knows the unit's name to the letter, so unlike `/follow rag` it must not
+                -- prefix-match its way onto a bystander. Client-side movement only, no wire.
+                FollowByName(name, 1);
             end
-            -- DEFERRED branches trimmed with their rows (header): TARGET/FOLLOW,
+            -- DEFERRED branches trimmed with their rows (header): TARGET,
             -- GUILD_*, RESET_INSTANCES, PET_*, RAID_LEADER/PROMOTE/DEMOTE/REMOVE.
             PlaySound("UChatScrollButton");
         end
diff --git a/crates/benilla/assets/ui/ZoneText.xml b/crates/benilla/assets/ui/ZoneText.xml
index 235ba703..d0b9ee79 100644
--- a/crates/benilla/assets/ui/ZoneText.xml
+++ b/crates/benilla/assets/ui/ZoneText.xml
@@ -7,11 +7,13 @@ by the FadingFrame kit when the app fires the ZONE_CHANGED family off the player
 (`area.rs`).
 
 Quoted from ref-ZoneText.xml as the live 5875 patch chain ships it (patch.MPQ overrides the
-interface.MPQ copy — decision 0246), reduced by ONE frame: AutoFollowStatus (the /follow status
-text, the only thing ref-ZoneText.lua actually contains) stays behind until follow support
-exists. The FadingFrame kit (ref-FadingFrame.lua, its own TOC line right before ZoneText.xml)
-is inlined verbatim below instead: ZoneTextFrame/SubZoneTextFrame are its only consumers in the
-whole 1.12 FrameXML (grep-verified over the extraction), so it rides with them.
+interface.MPQ copy — decision 0246) — now all THREE of its frames, the third being
+AutoFollowStatus (the /follow status text, and the only thing ref-ZoneText.lua actually
+contains), which waited here until follow support existed and no longer does. The FadingFrame
+kit (ref-FadingFrame.lua, its own TOC line right before ZoneText.xml) is inlined verbatim below
+too: ZoneTextFrame/SubZoneTextFrame are its only consumers in the whole 1.12 FrameXML
+(grep-verified over the extraction), so it rides with them. AutoFollowStatus is NOT one of
+them — it rolls its own fade, which is why the kit stays a two-frame affair.
 
 The subtle law worth naming (it looks like a bug and is not): SubZoneTextString — a child of
 SubZoneTextFrame — anchors to regions of the *other* frame (ZoneTextString / PVPInfoTextString),
@@ -28,6 +30,15 @@ PvP info shows only on NEW_AREA (SetZoneText(1)).
         CONTESTED_TERRITORY = CONTESTED_TERRITORY or "Contested Territory";
         FACTION_CONTROLLED_TERRITORY = FACTION_CONTROLLED_TERRITORY or "%s Territory"; -- Faction name
         FREE_FOR_ALL_TERRITORY = FREE_FOR_ALL_TERRITORY or "PvP Area";
+        AUTOFOLLOWSTART = AUTOFOLLOWSTART or "Following %s.";
+        AUTOFOLLOWSTOP = AUTOFOLLOWSTOP or "You stop following %s.";
+
+        -- The ref's localization identity (UIParent.lua), so the AutoFollowStatus body below can
+        -- stay verbatim. Guarded like everything else here rather than leaning on UnitPopup.xml
+        -- happening to load first — a one-line helper is no place to acquire a load-order edge.
+        if ( not TEXT ) then
+            TEXT = function(s) return s end
+        end
 
         -- ── ref-FadingFrame.lua, verbatim ──────────────────────────────────────────────────────
         function FadingFrame_SetFadeInTime(this, time)
@@ -114,6 +125,49 @@ PvP info shows only on NEW_AREA (SetZoneText(1)).
                 SubZoneTextString:SetPoint("TOP", "ZoneTextString", "BOTTOM", 0, 0);
             end
         end
+
+        -- ── ref-ZoneText.lua, verbatim ─────────────────────────────────────────────────────────
+        -- The auto-follow status line. Note it does NOT use the FadingFrame kit above: its own
+        -- OnUpdate rolls a plain linear alpha fade with no fade-in and no hold, started only on
+        -- AUTOFOLLOW_END. BEGIN is a full reset (fadeTime cleared, alpha restored, shown), which
+        -- is why a follow that switches subject needs no END first.
+        AUTOFOLLOW_STATUS_FADETIME = 4.0;
+
+        function AutoFollowStatus_OnLoad()
+            this:RegisterEvent("AUTOFOLLOW_BEGIN");
+            this:RegisterEvent("AUTOFOLLOW_END");
+            this:RegisterEvent("PLAYER_ENTERING_WORLD");
+        end
+
+        function AutoFollowStatus_OnEvent(event)
+            if ( event == "AUTOFOLLOW_BEGIN" ) then
+                this.unit = arg1;
+                this.fadeTime = nil;
+                this:SetAlpha(1.0);
+                AutoFollowStatusText:SetText(format(TEXT(AUTOFOLLOWSTART),this.unit));
+                this:Show();
+            end
+            if ( event == "AUTOFOLLOW_END" ) then
+                this.fadeTime = AUTOFOLLOW_STATUS_FADETIME;
+                AutoFollowStatusText:SetText(format(TEXT(AUTOFOLLOWSTOP),this.unit));
+                this:Show();
+            end
+            if ( event == "PLAYER_ENTERING_WORLD" ) then
+                this:Hide();
+            end
+        end
+
+        function AutoFollowStatus_OnUpdate(elapsed)
+            if( this.fadeTime ) then
+                if( elapsed >= this.fadeTime ) then
+                    this:Hide();
+                else
+                    this.fadeTime = this.fadeTime - elapsed;
+                    local alpha = this.fadeTime / AUTOFOLLOW_STATUS_FADETIME;
+                    this:SetAlpha(alpha);
+                end
+            end
+        end
     ]]></Script>
     <!-- These frames are shown when the current zone or subzone changes.
          (ref carries toplevel="true" on both; dropped here — SetToplevel is a v1 object-model
@@ -238,4 +292,46 @@ PvP info shows only on NEW_AREA (SetZoneText(1)).
             </OnUpdate>
         </Scripts>
     </Frame>
+    <!-- The auto-follow status line, quoted from ref-ZoneText.xml. The only thing ref-ZoneText.lua
+         actually contains, and the reason that .lua exists at all; it waited here until follow
+         support did (decisions 0890, 0893). `setAllPoints` over UIParent, so the line sits dead
+         centre of the screen. BACKGROUND strata: it is under everything, which is why a full-screen
+         panel hides it.
+
+         ONE DEVIATION, forced: the ref anchors the string CENTER to **WorldFrame**, and benilla has
+         no WorldFrame — it is the reference's 3D-scene layer frame, which our renderer does not
+         model as a frame at all. This is the ONLY `relativeTo="WorldFrame"` in the whole 1.12
+         FrameXML (grep-verified over the extraction), so it buys no convention; left verbatim it
+         merely logged an unresolved-anchor WARN every boot and fell back to the owner. UIParent is
+         the right substitute and not an approximation: both are full-screen in the reference, so
+         their CENTERs coincide, and AutoFollowStatus is setAllPoints over UIParent anyway. -->
+    <Frame name="AutoFollowStatus" parent="UIParent" setAllPoints="true" frameStrata="BACKGROUND" hidden="true">
+        <Layers>
+            <Layer level="ARTWORK">
+                <FontString name="AutoFollowStatusText" inherits="GameFontNormal">
+                    <Anchors>
+                        <Anchor point="CENTER" relativeTo="UIParent">
+                            <Offset>
+                                <AbsDimension x="0" y="0"/>
+                            </Offset>
+                        </Anchor>
+                    </Anchors>
+                    <FontHeight>
+                        <AbsValue val="20"/>
+                    </FontHeight>
+                </FontString>
+            </Layer>
+        </Layers>
+        <Scripts>
+            <OnLoad>
+                AutoFollowStatus_OnLoad();
+            </OnLoad>
+            <OnEvent>
+                AutoFollowStatus_OnEvent(event);
+            </OnEvent>
+            <OnUpdate>
+                AutoFollowStatus_OnUpdate(arg1);
+            </OnUpdate>
+        </Scripts>
+    </Frame>
 </Ui>
diff --git a/crates/benilla/src/items.rs b/crates/benilla/src/items.rs
index 0ebadda0..6ff17d4b 100644
--- a/crates/benilla/src/items.rs
+++ b/crates/benilla/src/items.rs
@@ -294,13 +294,13 @@ mod tests {
         assert!(items.take_fresh().is_empty(), "a drain empties the queue");
     }
 
-    /// The one predicate both halves of the right-click-to-open affordance ask
-    /// (`ItemInfo::openable`): the tooltip's green line and the `CMSG_OPEN_ITEM` fork. Its whole
-    /// subtlety is the two sub-gates — a `LockID` template stays shut until the INSTANCE carries
-    /// UNLOCKED, and a wrapper template needs the instance's WRAPPED bit — so a template-only
-    /// view (instance flags 0) can never be openable.
+    /// The right-click-to-open predicates — and the fact that the **line and the click are not the
+    /// same test** (decision 0896). The tooltip's `shows_open_line` carries the lock sub-gate (a
+    /// `LockID` template earns the line only once the INSTANCE says UNLOCKED); the click's
+    /// `opens_loot` is the BARE template bit, so a still-locked junkbox sends anyway and the
+    /// server supplies the refusal. Getting that backwards eats the click in silence.
     #[test]
-    fn openable_is_the_lootable_bit_behind_its_lock_and_gift_sub_gates() {
+    fn open_line_carries_the_lock_gate_the_open_send_does_not() {
         let plain = |flags: u32, lock_id: u32| {
             let mut t = info("Small Barnacled Clam");
             t.flags = flags;
@@ -308,19 +308,33 @@ mod tests {
             t
         };
 
-        // The clam: LOOTABLE, no lock — openable outright, instance flags irrelevant.
-        assert!(plain(ITEM_FLAG_LOOTABLE, 0).openable(0));
-        // An ordinary item is never openable, however its instance is flagged.
-        assert!(!plain(0, 0).openable(ITEM_DYNFLAG_UNLOCKED | ITEM_DYNFLAG_WRAPPED));
-        // A junkbox: LOOTABLE but locked — shut until the instance says UNLOCKED.
-        assert!(!plain(ITEM_FLAG_LOOTABLE, 7).openable(0));
-        assert!(plain(ITEM_FLAG_LOOTABLE, 7).openable(ITEM_DYNFLAG_UNLOCKED));
-        // Gift wrap: the WRAPPER template opens only while the instance is still WRAPPED.
-        assert!(!plain(ITEM_FLAG_WRAPPER, 0).openable(0));
-        assert!(plain(ITEM_FLAG_WRAPPER, 0).openable(ITEM_DYNFLAG_WRAPPED));
-        // The wrapped arm ignores the lock gate entirely — it is the sibling `||`, not a nested
-        // case: a wrapped gift of a locked box opens as the gift.
-        assert!(plain(ITEM_FLAG_WRAPPER | ITEM_FLAG_LOOTABLE, 7).openable(ITEM_DYNFLAG_WRAPPED));
+        // The clam: LOOTABLE, no lock — line and send agree, instance flags irrelevant.
+        assert!(plain(ITEM_FLAG_LOOTABLE, 0).shows_open_line(0));
+        assert!(plain(ITEM_FLAG_LOOTABLE, 0).opens_loot());
+        // An ordinary item does neither, however its instance is flagged.
+        assert!(!plain(0, 0).shows_open_line(ITEM_DYNFLAG_UNLOCKED | ITEM_DYNFLAG_WRAPPED));
+        assert!(!plain(0, 0).opens_loot());
+        // A junkbox: LOOTABLE but locked. **The two predicates part company here** — no line
+        // until the instance says UNLOCKED, but the click goes out either way.
+        assert!(!plain(ITEM_FLAG_LOOTABLE, 7).shows_open_line(0));
+        assert!(plain(ITEM_FLAG_LOOTABLE, 7).shows_open_line(ITEM_DYNFLAG_UNLOCKED));
+        assert!(
+            plain(ITEM_FLAG_LOOTABLE, 7).opens_loot(),
+            "the send ignores LockID entirely — the server owns the refusal"
+        );
+        // Gift wrap: the WRAPPER template unwraps only while the instance is still WRAPPED, and
+        // that arm is its own dispatcher position, not a nested case of the loot arm.
+        assert!(!plain(ITEM_FLAG_WRAPPER, 0).unwraps_gift(0));
+        assert!(plain(ITEM_FLAG_WRAPPER, 0).unwraps_gift(ITEM_DYNFLAG_WRAPPED));
+        assert!(
+            !plain(ITEM_FLAG_WRAPPER, 0).opens_loot(),
+            "WRAPPER is not LOOTABLE"
+        );
+        assert!(plain(ITEM_FLAG_WRAPPER, 0).shows_open_line(ITEM_DYNFLAG_WRAPPED));
+        // A wrapped gift of a locked box: the gift arm ignores the lock gate on both sides.
+        let gift_box = plain(ITEM_FLAG_WRAPPER | ITEM_FLAG_LOOTABLE, 7);
+        assert!(gift_box.unwraps_gift(ITEM_DYNFLAG_WRAPPED));
+        assert!(gift_box.shows_open_line(ITEM_DYNFLAG_WRAPPED));
     }
 
     #[test]
diff --git a/crates/benilla/src/main.rs b/crates/benilla/src/main.rs
index 8aa64952..0bbf8c10 100644
--- a/crates/benilla/src/main.rs
+++ b/crates/benilla/src/main.rs
@@ -108,6 +108,7 @@ mod ui_char;
 mod ui_chat;
 mod ui_craft;
 mod ui_duel;
+mod ui_follow;
 mod ui_gamma;
 mod ui_gossip;
 mod ui_hide;
@@ -193,6 +194,7 @@ use ui_char::UiCharPlugin;
 use ui_chat::UiChatPlugin;
 use ui_craft::UiCraftPlugin;
 use ui_duel::UiDuelPlugin;
+use ui_follow::UiFollowPlugin;
 use ui_gossip::UiGossipPlugin;
 use ui_item_text::UiItemTextPlugin;
 use ui_items::UiItemsPlugin;
@@ -613,6 +615,9 @@ fn main() -> AppExit {
     // Duels (decision 0633): the wire session, the client-side countdown tick, the four Era
     // events, and the accept/cancel/challenge intents.
     .add_plugins(UiDuelPlugin)
+    // Auto-follow's UI seam: the popup's Follow row + `FollowUnit`/`FollowByName` inbound, and
+    // the AUTOFOLLOW_BEGIN/END pair that drives the centre-screen status line outbound.
+    .add_plugins(UiFollowPlugin)
     // Leaving (decision 0674): the game menu's Logout/Exit Game — the request, the server's
     // 20-second answer narrated as the CAMP/QUIT countdown, and the process exit.
     .add_plugins(UiLogoutPlugin)
diff --git a/crates/benilla/src/player/follow.rs b/crates/benilla/src/player/follow.rs
index 4da641b2..e1583651 100644
--- a/crates/benilla/src/player/follow.rs
+++ b/crates/benilla/src/player/follow.rs
@@ -1,17 +1,16 @@
-//! `/follow` — the auto-follow movement mode (decision 0890).
+//! `/follow` — the auto-follow movement mode (decisions 0890, 0893).
 //!
 //! The finding that shapes this module: **follow synthesizes keyboard input.** It owns no
 //! translation of its own. Every state change in the reference funnels through the movement
 //! singleton's setter (`0x60e790` sets the move-forward bit `0x100000`, `0x60e7f0` clears it) — the
 //! same setter the MoveForward keybinding drives, one of ~40 stubs in the keybinding command table
 //! at `0x513de0`-`0x514273`. So follow is "hold W for me, and steer", and the right implementation
-//! reuses the controller wholesale rather than growing a second mover (wow-re
-//! `object-layer/scratch/targeting-by-name.md` PART D, §5-cross-checked).
+//! reuses the controller wholesale rather than growing a second mover.
 //!
 //! It also sends **nothing on the wire** — corroborated against vmangos, which has no follow opcode
 //! in 1.12.1. The server only ever sees the ordinary movement stream our synthesized input produces.
 //!
-//! ## The law
+//! ## The motion law
 //!
 //! - **Facing is steered, never snapped** (`0x6103d0`/`0x6108xx`): turn toward the followee at
 //!   [`TURN_RATE`] = π rad/s (180°/s), clamped to `min(remaining, rate × elapsed)`, and stop turning
@@ -24,19 +23,62 @@
 //!   whatever a held forward key yields for *you*, which is why follow falls behind a faster runner.
 //! - **A hysteresis band, not a stop distance** — see [`should_move`]. Arrive is inclusive, resume is
 //!   one-directional. The gap between the two is why follow visibly starts and stops rather than
-//!   juddering on a single threshold.
+//!   juddering on a single threshold. Arrival does **not** end the follow.
 //!
-//! ## The one INFERRED rule
+//! ## The cancel set — what actually makes this a *mode*
 //!
-//! The reference cancels follow when the player turns ~180° away (band 160°-220°), but wow-re could
-//! not trace *what that angle is measured against* — it is explicitly flagged unresolved. Measuring
-//! it against the live bearing alone cannot be right: starting a follow while facing away from the
-//! followee would then cancel on the first tick, before the steer had a chance to turn us.
+//! **Every player-initiated movement START cancels the follow, on the key-DOWN edge.** A key
+//! *release* never does, and neither does the follow's own synthesized input.
 //!
-//! So this module latches [`FollowState::aligned`] the first time the facing comes inside the band
-//! and only cancels *after* that. Observable behaviour: starting a follow facing any direction works
-//! and turns you around; deliberately turning around once you are following drops it. That matches
-//! what the band is plainly *for*, and is marked INFERRED until the reference angle is pinned.
+//! The mechanism sits two layers below the keybinding stubs, which is why reading the handlers
+//! answers "nothing cancels follow" and is wrong about the behaviour — the same failure mode
+//! wow-re's RF-0079 hit on autorun. Every movement START emitter calls **`0x60e990`**, which
+//! cancels at `0x60e9b5` unless the re-entrancy bracket `ds:0xc4da48` **bit 0** is set — and
+//! follow's own four emitters (`0x60e790`, `0x60e7f0`, `0x60e8a0`, `0x60e940`) set that bracket
+//! around their calls. A real key press never sets it. **That asymmetry is the entire mechanism.**
+//!
+//! We need no bracket of our own, because our synthesized input is [`Player::follow_forward`] — a
+//! flag the controller reads, never a key event — so it cannot reach the cancel at all.
+//!
+//! | action | benilla key | verdict |
+//! |---|---|---|
+//! | MoveForward / MoveBackward | `W` / `S` | **cancels** (key-DOWN) |
+//! | TurnLeft / TurnRight | `A` / `D` | **cancels** (key-DOWN) |
+//! | StrafeLeft / StrafeRight | `Q` / `E` | **cancels** (key-DOWN) |
+//! | ToggleAutoRun | `MouseButton::Forward` | **cancels**, on the ON edge only |
+//! | both-mouse-buttons run | `L`+`R` | **cancels**, on the both-held transition |
+//! | mouse-look turning | `R` held | **cancels** while held, however far the mouse moved |
+//! | **Jump** | `Space` | **survives** — the one emitter passing `0x60e990(0,0)` (`0x60dea8`) |
+//! | Sit / stand | — | **survives** (a `CMSG_STANDSTATECHANGE`, no guard call) |
+//! | walk/run toggle | — | **survives** |
+//! | any key release | — | **survives** |
+//!
+//! Plus the non-input cancels: **losing the mover** (death, stun, a taxi hand-off — the reference's
+//! second, rarer site at `0x5146d6`), the followee becoming unresolvable or **dying**, and the
+//! degenerate-bearing guard below.
+//!
+//! ## What is deliberately NOT here
+//!
+//! **The ~180° turn-away cancel is drunk-only, and is therefore absent.** 0890 shipped it as an
+//! INFERRED rule with a latch invented to make the 160°-220° band self-consistent. The band is
+//! real (`0x80c604` = 2.7925267 rad, `0x80c600` = 3.8397243 rad, both strict) — but its whole
+//! evaluation is gated at `0x610a3d` on an argument that is the **inebriation fraction**,
+//! `min([[unit+0xe68]+0x1d], 100) × 0.01`. That byte is proven to be drunkenness by two independent
+//! consumers of the identical expression: the `DRUNK_MESSAGE_SELF%d` formatter at `0x5e2ac3`, and
+//! `0x60001a` comparing the same fraction against 0.5 to pick an animation state. **On a sober
+//! character the band never executes**, so a client that does not model inebriation must not
+//! implement it — and benilla does not. (Its real arming trigger is turn-*convergence*, not "inside
+//! the band", with a stochastic disarm at `0x61092e`; recorded for whoever adds drunkenness.)
+//!
+//! Also refuted by census, each a real "surely this cancels follow?" candidate: taking damage,
+//! entering combat, mounting, beginning a cast, and the followee simply going out of range
+//! (`0x6107e5` explicitly excludes follow's mode at `0x610749`/`0x610752`).
+//!
+//! ## The start gate lives elsewhere
+//!
+//! Who you may begin following — a living, assistable **player**, and only while you are alive,
+//! unstunned and not casting — is [`crate::target::by_name`]'s, because that is where the subject
+//! is resolved. The refusals it raises are real error lines, not silence.
 
 use std::f32::consts::PI;
 
@@ -44,6 +86,7 @@ use bevy::prelude::*;
 
 use crate::net::GuidIndex;
 
+use super::camera::{CameraControl, LookButton};
 use super::state::{MoveSpeed, Player};
 
 /// Follow's facing-turn rate, rad/s — `0xc4d93c`, seeded `0x40490fdb` = π at `0x6111f9`. Its own
@@ -65,22 +108,26 @@ const STOP_DISTANCE: f32 = 3.0;
 /// closes below 3.0 / 4.5 yd however slowly you are moving.
 const RESUME_FACTOR: f32 = 1.5;
 
-/// How far off the bearing the facing must sit for a deliberate turn to drop the follow. The
-/// reference's band is 160°-220°; wrapped into `[0, π]` that is "at least 160° off".
-const CANCEL_ANGLE: f32 = 160.0 * PI / 180.0;
+/// `cos(1°)`. The degenerate-bearing guard at `0x610d32` ends the follow once the followee sits
+/// within one degree of straight up or down (`|dy| / dist > cos 1°`) — at which point the
+/// horizontal bearing a beeline needs is numerically meaningless. Held in `0xc4d9d0`, seeded at
+/// `0x610c8d` from `.rdata 0x80c5f8`.
+const VERTICAL_ALIGN_COS: f32 = 0.999_847_7;
 
 /// Who we are following, and the hysteresis latch — the reference's followed-guid pair `0xc4d980`
-/// (armed `0x6111c9`, cleared `0x60fc1e`) plus the state its band implies.
+/// (armed `0x6111c9`, cleared `0x60fc1e`; **exactly two writers each**, earned by an
+/// opcode-agnostic raw-byte scan for the little-endian addresses, not a literal-displacement grep).
 #[derive(Resource, Default)]
 pub(crate) struct FollowState {
     /// The followee's guid, or `None` when not following.
     pub(crate) guid: Option<u64>,
+    /// The followee's name as it read at the moment the follow began — what
+    /// `AUTOFOLLOW_BEGIN`'s argument carries, and therefore what the status text says. Latched
+    /// rather than re-read so the line can't change under a rename or a cache eviction mid-follow.
+    pub(crate) name: String,
     /// Whether the synthesized forward input is currently held. The band's latch: which threshold
     /// applies depends on which side we are already on.
     moving: bool,
-    /// Whether the facing has come inside [`CANCEL_ANGLE`] at least once since the follow began —
-    /// the guard on the INFERRED turn-away cancel (see the module header).
-    aligned: bool,
     /// `WOW_FOLLOW_TRACE` bookkeeping: when the last trace line went out, and where we were.
     /// `None` until a tick has seeded it.
     traced_at: f64,
@@ -89,10 +136,10 @@ pub(crate) struct FollowState {
 
 impl FollowState {
     /// Begin following `guid`, from a clean band.
-    pub(crate) fn start(&mut self, guid: u64) {
+    pub(crate) fn start(&mut self, guid: u64, name: String) {
         self.guid = Some(guid);
+        self.name = name;
         self.moving = false;
-        self.aligned = false;
         self.traced_at = 0.0;
         self.traced_pos = None;
     }
@@ -100,17 +147,26 @@ impl FollowState {
     /// Stop following. Returns whether we actually were.
     pub(crate) fn stop(&mut self) -> bool {
         self.moving = false;
-        self.aligned = false;
         self.guid.take().is_some()
     }
 }
 
-/// `/follow [name]` — start following. `None` is the bare form (`FollowUnit("target")`), whose
-/// subject is the current selection; a name resolves **players only** and additionally through the
-/// reference's filter mode 2 (`CanAssist` + alive), which is [`crate::target`]'s to apply.
+/// Start following — the app-side funnel every entry point converges on, whether it came from the
+/// chat parser (decision 0881 parses slash lines in Rust) or from the Era API globals the shipped
+/// UI calls ([`benilla_ui::script::FollowRequest`], via [`crate::ui_follow`]).
+///
+/// The two variants are the reference's own two bindings. They differ in how the subject is *found*
+/// — a name resolves players only and through the by-name resolver's filter mode 2, a token takes
+/// whatever it points at — but **not** in what is allowed: the start gate downstream applies to
+/// both alike, which is why `/follow` on a creature refuses either way.
 #[derive(bevy::ecs::message::Message, Clone, Debug)]
-pub(crate) struct FollowRequest {
-    pub(crate) name: Option<String>,
+pub(crate) enum FollowRequest {
+    /// `FollowUnit(unit)` — the bare `/follow` is `FollowUnit("target")`.
+    Unit(String),
+    /// `FollowByName(name, exactMatch)`. `exact` is the second Lua argument: the unit popup's
+    /// Follow row passes `1` (it already knows the exact name and must not prefix-match onto a
+    /// bystander), `/follow <name>` passes nothing.
+    Name { name: String, exact: bool },
 }
 
 /// The distance at which follow **arrives** and lets go of the key (`0x610ad2`-`0x610b1b`):
@@ -136,6 +192,25 @@ fn should_move(was_moving: bool, distance: f32, speed: f32) -> bool {
     }
 }
 
+/// Does this frame's input **destroy** the follow? See the module header's table for the census
+/// and for what is deliberately absent.
+///
+/// `move_start` is the key-DOWN **edge** of any movement start (W/S/A/D/Q/E), never held state —
+/// the reference cancels in the START emitters and its STOP siblings carry no guard call at all,
+/// which is why letting go of a key never resumes a follow you just broke. `autorun_engaged` is
+/// likewise the ON edge only (the OFF edge routes to the unguarded `0x60dc90`). `mouse_look` is a
+/// *level*, not an edge: the camera's facing commit re-enters the guard every frame the look is
+/// held, regardless of how far the mouse actually moved.
+fn follow_cancelled(
+    move_start: bool,
+    autorun_engaged: bool,
+    both_engaged: bool,
+    mouse_look: bool,
+    lost_mover: bool,
+) -> bool {
+    move_start || autorun_engaged || both_engaged || mouse_look || lost_mover
+}
+
 /// Wrap an angle into `(-π, π]`.
 fn wrap_pi(a: f32) -> f32 {
     let t = std::f32::consts::TAU;
@@ -153,6 +228,13 @@ fn bearing_to(delta: Vec3) -> f32 {
     (-delta.x).atan2(-delta.z)
 }
 
+/// Is the followee within one degree of straight up or down? `0x610d32`'s guard — at that point the
+/// horizontal bearing is numerically meaningless and the follow ends rather than spinning.
+fn vertically_degenerate(delta: Vec3) -> bool {
+    let dist = delta.length();
+    dist > f32::EPSILON && delta.y.abs() / dist > VERTICAL_ALIGN_COS
+}
+
 /// Turn `face` toward `bearing` by at most this tick's budget, or leave it alone inside the
 /// deadzone. The reference's `min(remaining, rate × elapsed)` clamp.
 fn steer(face: f32, bearing: f32, dt: f32) -> f32 {
@@ -164,13 +246,47 @@ fn steer(face: f32, bearing: f32, dt: f32) -> f32 {
     face + remaining.clamp(-budget, budget)
 }
 
-/// Drive the follow: re-resolve the followee, steer the facing, and decide whether the synthesized
-/// forward input is held this tick. Runs immediately **before** `control`, which reads
-/// [`Player::follow_forward`] as one more term of its forward axis — the reference's shape exactly,
-/// where follow pushes the same move-forward bit the W key does.
+/// Everything the cancel set reads. Bundled so [`steer_follow`]'s own parameter list stays about
+/// the motion.
+#[derive(bevy::ecs::system::SystemParam)]
+pub(super) struct FollowInput<'w> {
+    keys: Res<'w, ButtonInput<KeyCode>>,
+    buttons: Res<'w, ButtonInput<MouseButton>>,
+    /// The camera rig, for the mouse-look level. Read one frame behind `control`'s own update,
+    /// which is deliberate and harmless: the cancel then lands on the frame *after* the look
+    /// begins, versus the reference's same-frame commit.
+    rig: Res<'w, CameraControl>,
+    /// While a focused UI EditBox owns the keyboard, keyboard reads see "no keys held" — so typing
+    /// "we should go" in chat must not break your follow. `control`'s own gate, applied here for
+    /// the same reason.
+    capture: Res<'w, crate::ui_script::UiKeyboardCapture>,
+}
+
+impl FollowInput<'_> {
+    /// The key-DOWN edge of any movement start. A/D are turn keys normally and strafe keys under
+    /// mouse-look; either way they are a movement start and either way they cancel, so the
+    /// distinction the controller draws does not matter here.
+    fn move_start(&self) -> bool {
+        !self.capture.0
+            && self.keys.any_just_pressed([
+                KeyCode::KeyW,
+                KeyCode::KeyS,
+                KeyCode::KeyA,
+                KeyCode::KeyD,
+                KeyCode::KeyQ,
+                KeyCode::KeyE,
+            ])
+    }
+}
+
+/// Drive the follow: cancel if this frame's input says so, then re-resolve the followee, steer the
+/// facing, and decide whether the synthesized forward input is held this tick. Runs immediately
+/// **before** `control`, which reads [`Player::follow_forward`] as one more term of its forward
+/// axis — the reference's shape exactly, where follow pushes the same move-forward bit W does.
 ///
-/// The player's own turn input runs *after* this in the same frame and therefore wins; that is what
-/// makes the turn-away cancel reachable at all.
+/// The cancel runs before the steer for the reference's own reason: it lives in the movement START
+/// emitters, which run ahead of the axis math (`0x5150a7` vs the emitter tail `0x5151a0`), so the
+/// frame you break a follow on is a frame the follow never steers.
 pub(super) fn steer_follow(
     time: Res<Time>,
     mut follow: ResMut<FollowState>,
@@ -178,8 +294,30 @@ pub(super) fn steer_follow(
     speed: Res<MoveSpeed>,
     index: Res<GuidIndex>,
     transforms: Query<&Transform>,
+    input: FollowInput,
 ) {
     player.follow_forward = false;
+    if follow.guid.is_none() {
+        return;
+    }
+    // ── The cancel set ── before anything else this frame (see the doc above).
+    let both_engaged = input.buttons.pressed(MouseButton::Left)
+        && input.buttons.pressed(MouseButton::Right)
+        && (input.buttons.just_pressed(MouseButton::Left)
+            || input.buttons.just_pressed(MouseButton::Right));
+    if follow_cancelled(
+        input.move_start(),
+        // The ON edge only: `control` toggles `autorun` AFTER this runs, so the flag we read here
+        // is still the pre-toggle value, and "press while off" is exactly the engage.
+        input.buttons.just_pressed(MouseButton::Forward) && !player.autorun,
+        both_engaged,
+        input.rig.look == Some(LookButton::Right),
+        player.modes.rooted || player.server_riding(),
+    ) {
+        info!("follow: cancelled by the player's own movement input");
+        follow.stop();
+        return;
+    }
     let Some(guid) = follow.guid else { return };
     // Re-resolved every tick, nothing cached — a followee that streams out ends the follow
     // (`0x610e40` → `0x6106e7`).
@@ -194,22 +332,19 @@ pub(super) fn steer_follow(
         return;
     };
     let delta = target - player.pos;
+    // The degenerate-bearing guard (`0x610d32`), checked on the FULL 3D delta before the bearing is
+    // taken from the flattened one.
+    if vertically_degenerate(delta) {
+        info!("follow: the followee is within 1° of straight overhead — follow ends");
+        follow.stop();
+        return;
+    }
     let flat = Vec3::new(delta.x, 0.0, delta.z);
     let distance = flat.length();
     if distance < f32::EPSILON {
         return;
     }
     let bearing = bearing_to(flat);
-    // The INFERRED turn-away cancel (module header): only armed once the facing has come inside the
-    // band, so beginning a follow while facing away turns us around instead of cancelling.
-    let off_bearing = wrap_pi(bearing - player.face_yaw).abs();
-    if off_bearing < CANCEL_ANGLE {
-        follow.aligned = true;
-    } else if follow.aligned {
-        info!("follow: turned away from the followee — follow ends");
-        follow.stop();
-        return;
-    }
     player.face_yaw = steer(player.face_yaw, bearing, time.delta_secs());
     let moving = should_move(follow.moving, distance, speed.value);
     if moving != follow.moving {
@@ -339,4 +474,41 @@ mod tests {
             "should wrap forward across ±π"
         );
     }
+
+    /// The cancel set's table, in its own terms. Each argument is one row of the module header, and
+    /// the two that matter most are the FALSE ones: jump and a plain key release are VERIFIED
+    /// survivors, not oversights — they reach the guard with `realStart = 0` or never reach it.
+    #[test]
+    fn any_movement_start_cancels_but_jump_and_releases_do_not() {
+        // Nothing happening: a follow just keeps following, however long it runs.
+        assert!(!follow_cancelled(false, false, false, false, false));
+        // Each start, alone, is enough.
+        assert!(follow_cancelled(true, false, false, false, false));
+        assert!(follow_cancelled(false, true, false, false, false));
+        assert!(follow_cancelled(false, false, true, false, false));
+        assert!(follow_cancelled(false, false, false, true, false));
+        // Losing the mover — death, stun, a taxi hand-off — is a LEVEL, not an edge.
+        assert!(follow_cancelled(false, false, false, false, true));
+        // Jump and key releases never become any of those arguments (see `FollowInput::move_start`,
+        // which reads `just_pressed` and does not list Space at all), so the all-false row above IS
+        // the jump case — asserted here so deleting Space's absence breaks a test.
+        assert!(
+            !follow_cancelled(false, false, false, false, false),
+            "a jump leaves every cancel input false"
+        );
+    }
+
+    /// The degenerate-bearing guard (`0x610d32`) — a followee straight overhead ends the follow,
+    /// one a degree off the vertical does not. The horizontal case must be nowhere near it.
+    #[test]
+    fn a_followee_straight_overhead_ends_the_follow() {
+        assert!(vertically_degenerate(Vec3::new(0.0, 30.0, 0.0)));
+        assert!(vertically_degenerate(Vec3::new(0.0, -30.0, 0.0)));
+        // 1° off vertical is outside the guard: tan(1°) ≈ 0.01746, so 30 yd up needs > 0.52 yd out.
+        assert!(!vertically_degenerate(Vec3::new(0.6, 30.0, 0.0)));
+        // The ordinary case — a followee on roughly your own level — is untouched.
+        assert!(!vertically_degenerate(Vec3::new(10.0, 2.0, 5.0)));
+        // A zero delta is not "degenerate": it is the arrived case, which the band owns.
+        assert!(!vertically_degenerate(Vec3::ZERO));
+    }
 }
diff --git a/crates/benilla/src/sound/combat.rs b/crates/benilla/src/sound/combat.rs
index db0bff96..f59849a1 100644
--- a/crates/benilla/src/sound/combat.rs
+++ b/crates/benilla/src/sound/combat.rs
@@ -20,21 +20,31 @@
 //! tag many creature attack clips never author — ogre.m2 authors it in 1 of its ~14 attack
 //! variations, so ogre hits were near-silent):
 //!
-//! - a **natural-weapon** swing (`$AHn` fired the dispatch) plays the attacker's
-//!   `CreatureSoundData.CustomAttack[n]` column INSTEAD of the generic weapon impact — the
-//!   `SWINGNOHITSOUND` latch (`0x6247d0` §f);
-//! - otherwise: parry → the attacker row's parry slot (metal/wood by the victim's weapon),
-//!   block → the shield slot, a landed hit → the `WeaponImpactSounds` impact/crit slot for the
-//!   victim's material (`CreatureImpactType`);
-//! - plus the victim's injury vocal (`Injury`/`InjuryCritical`/`InjuryCrushing`) on every
-//!   damaging, undefended hit.
+//! It is **two blocks in the client's order**, not one pick (decision 0899):
+//!
+//! 1. `0x6247d0`'s own weapon-sound block, at the attacker — a **natural-weapon** swing
+//!    (`$AHn` fired the dispatch) plays the attacker's `CreatureSoundData.CustomAttack[n]`
+//!    column INSTEAD of the generic weapon impact (the `SWINGNOHITSOUND` latch, `0x6247d0` §f);
+//!    otherwise a landed hit plays the `WeaponImpactSounds` impact/crit slot for the victim's
+//!    material (`CreatureImpactType`).
+//! 2. `0x624530`'s **victimState-keyed clang**, at the victim — parry (`0x6245bb` →
+//!    `0x623640(sel=0)`) takes the attacker row's parry slot (metal/wood by the victim's
+//!    weapon), block (`0x6245d8` → `sel=1`) the shield slot. This block is reached on **every**
+//!    impact tag: the `$AHn` digit block "has zero effect on the victim dispatch", so a beast's
+//!    bite and the parry clang both sound.
+//!
+//! Plus the victim's injury vocal (`Injury`/`InjuryCritical`/`InjuryCrushing`) on every
+//! damaging, undefended hit.
 //!
 //! A `text_only` flush (supersede/attack-stop) drops its sounds — only the floating number
 //! flushes (decision 0149's flush law, inherited from the shared dispatch).
 //!
 //! INTERIM readings (flagged for a wow-re pass): victims' armor lands on the flesh slot (the
 //! chain/plate slots need the armor-material chain);
-//! blocks assume a metal shield; the injury vocal plays on every damaging hit (the client may
+//! blocks assume a metal shield; a defended outcome suppresses block 1's generic weapon impact
+//! (the tail's latch test `0x624936` carries no victimState gate in the trace, so whether it
+//! also plays under a clang is unpinned);
+//! the injury vocal plays on every damaging hit (the client may
 //! throttle); the deflect (`0x457f20`) and immune/absorb (`0x458610`) positioned stubs' kit ids
 //! are unpinned, so those branches stay silent here; the natural-weapon column is gated on
 //! contact like the weapon impact (whether the digit block also plays on a whiff is unpinned).
@@ -131,6 +141,44 @@ fn no_contact(swing: &SwingMessage) -> bool {
         )
 }
 
+/// A defended outcome — parry or block. These take their sound from the victim dispatch's
+/// victimState-keyed clang ([`defense_clang`]), never from the attacker's weapon-sound block.
+fn defended(victim_state: u32) -> bool {
+    matches!(victim_state, VICTIM_PARRY | VICTIM_BLOCK)
+}
+
+/// `0x624530`'s clang: the attacker's weapon row × the victim's defense (`0x623640`). Parry
+/// picks metal/wood by the victim's own weapon body; block takes the shield slot. Crit does not
+/// tier it — the parry/shield columns carry the same kit in both tables.
+fn defense_clang(
+    row: &benilla_formats::WeaponImpactRow,
+    victim_state: u32,
+    victim_wooden: bool,
+) -> u32 {
+    let slot = match (victim_state, victim_wooden) {
+        (VICTIM_PARRY, true) => impact_slot::PARRY_WOOD,
+        (VICTIM_PARRY, false) => impact_slot::PARRY_METAL,
+        _ => impact_slot::SHIELD_METAL,
+    };
+    row.impact[slot]
+}
+
+/// `0x6247d0`'s generic weapon impact for a landed hit: the victim's `CreatureImpactType`
+/// material slot off the attacker's weapon row, crit-tiered.
+fn landed_impact(row: &benilla_formats::WeaponImpactRow, impact_type: u32, crit: bool) -> u32 {
+    let slot = match impact_type {
+        1 => impact_slot::STONE,
+        2 => impact_slot::WOOD,
+        3 => impact_slot::ETHEREAL,
+        _ => impact_slot::FLESH,
+    };
+    if crit {
+        row.crit[slot]
+    } else {
+        row.impact[slot]
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 fn combat_sounds(
     mut swings: MessageReader<SwingMessage>,
@@ -234,52 +282,54 @@ fn combat_sounds(
         };
         let crit = swing.hit_info & HITINFO_CRITICAL != 0;
         if !no_contact(swing) {
+            // The attacker's weapon row (`0x625460(attacker, leftswing)`) — shared by both
+            // blocks below. `None` for a wand/thrown: no melee row, nothing to strike with.
+            let offhand = swing.hit_info & 0x4 != 0;
+            let (subclass, wooden) = swing_weapon(attacker.and_then(|(_, w, _)| w), offhand);
+            let row = impacts.0.get(subclass, !wooden);
+            let defended = defended(swing.victim_state);
+
+            // `0x6247d0`'s own weapon-sound block, BEFORE the victim dispatch: the `$AHn` digit
+            // column, else the generic `WeaponImpactSounds` impact behind the SWINGNOHITSOUND
+            // latch. A defended outcome takes its sound from the dispatch below instead
+            // (INTERIM, decision 0899: the tail's latch test `0x624936` carries no victimState
+            // gate in the trace, so whether the generic impact ALSO plays under a clang is
+            // unpinned — we suppress, which is what the game sounds like).
             if let Some(n) = imp.natural {
-                // The `$AHn` digit column: the attacker's own natural-weapon sound replaces the
-                // generic weapon impact (the SWINGNOHITSOUND latch).
+                // The attacker's own natural-weapon sound replaces the generic weapon impact.
                 let vocal = attacker
                     .and_then(|(_, _, net)| net.display_id)
                     .and_then(|d| voices.0.for_display(d))
                     .and_then(|v| v.custom_attack.get(usize::from(n)).copied())
                     .unwrap_or(0);
                 play(&mut kits, &mut out, vocal, pos, "natural impact");
-            } else {
-                let offhand = swing.hit_info & 0x4 != 0;
-                let (subclass, wooden) = swing_weapon(attacker.and_then(|(_, w, _)| w), offhand);
-                if let Some(row) = impacts.0.get(subclass, !wooden) {
-                    let kit = match swing.victim_state {
-                        VICTIM_PARRY => {
-                            // The parry family by the *victim's* weapon body (INTERIM heuristic).
-                            let victim_wooden = victim
-                                .map(|(_, w, _)| swing_weapon(w, false).1)
-                                .unwrap_or(false);
-                            row.impact[if victim_wooden {
-                                impact_slot::PARRY_WOOD
-                            } else {
-                                impact_slot::PARRY_METAL
-                            }]
-                        }
-                        VICTIM_BLOCK => row.impact[impact_slot::SHIELD_METAL],
-                        _ => {
-                            // A landed hit: the victim's material slot (players/rowless → flesh).
-                            let material = victim
-                                .and_then(|(_, _, net)| net.display_id)
-                                .and_then(|d| voices.0.for_display(d))
-                                .map(|v| v.impact_type)
-                                .unwrap_or(0);
-                            let slot = match material {
-                                1 => impact_slot::STONE,
-                                2 => impact_slot::WOOD,
-                                3 => impact_slot::ETHEREAL,
-                                _ => impact_slot::FLESH,
-                            };
-                            let table = if crit { &row.crit } else { &row.impact };
-                            table[slot]
-                        }
-                    };
+            } else if !defended {
+                if let Some(row) = row {
+                    // A landed hit: the victim's material slot (players/rowless → flesh).
+                    let material = victim
+                        .and_then(|(_, _, net)| net.display_id)
+                        .and_then(|d| voices.0.for_display(d))
+                        .map(|v| v.impact_type)
+                        .unwrap_or(0);
+                    let kit = landed_impact(row, material, crit);
                     play(&mut kits, &mut out, kit, pos, "impact");
                 }
-                // else: no melee row (wand/thrown) — nothing to strike with.
+            }
+
+            // `0x624530`'s victimState-keyed clang (`0x6245bb` parry → `0x623640(sel=0)`,
+            // `0x6245d8` block → `sel=1`), emitted at the VICTIM (`vtable+0x14` on `this`).
+            // Reached on EVERY impact tag — the `$AHn` digit block "has zero effect on the
+            // victim dispatch" (wow-re `melee-impact-timing.md` §f): a wolf's bite and the
+            // parry clang both sound. Decision 0899 — 0525 wrongly let the natural column
+            // swallow this, so every beast you parried was silent.
+            if let (true, Some(row)) = (defended, row) {
+                // The parry family by the *victim's* weapon body (INTERIM heuristic).
+                let victim_wooden = victim
+                    .map(|(_, w, _)| swing_weapon(w, false).1)
+                    .unwrap_or(false);
+                let kit = defense_clang(row, swing.victim_state, victim_wooden);
+                let at = victim.map(|(t, ..)| t.translation).unwrap_or(pos);
+                play(&mut kits, &mut out, kit, at, "defense clang");
             }
         }
 
@@ -315,3 +365,64 @@ pub(super) fn plugin(app: &mut App) {
     app.add_systems(Startup, load_weapon_impacts.after(AssetSet::Open))
         .add_systems(Update, combat_sounds.in_set(WorldStage::Present));
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A row shaped like the real 5875 Sword1H-metal row (byte-verified ids): flesh 143/144,
+    /// parry-metal 1002, parry-wood 1001, shield-metal 3263.
+    fn sword1h_metal() -> benilla_formats::WeaponImpactRow {
+        let mut impact = [0u32; 10];
+        let mut crit = [0u32; 10];
+        impact[impact_slot::FLESH] = 143;
+        crit[impact_slot::FLESH] = 144;
+        impact[impact_slot::STONE] = 3206;
+        impact[impact_slot::SHIELD_METAL] = 3263;
+        crit[impact_slot::SHIELD_METAL] = 3263;
+        impact[impact_slot::PARRY_METAL] = 1002;
+        impact[impact_slot::PARRY_WOOD] = 1001;
+        benilla_formats::WeaponImpactRow { impact, crit }
+    }
+
+    /// The clang picks the parry family by the VICTIM's weapon body, the shield slot for a
+    /// block — and never crit-tiers (the data carries one kit in both tables).
+    #[test]
+    fn defense_clang_picks_parry_by_victim_body_and_shield_for_block() {
+        let row = sword1h_metal();
+        assert_eq!(defense_clang(&row, VICTIM_PARRY, false), 1002);
+        assert_eq!(defense_clang(&row, VICTIM_PARRY, true), 1001);
+        assert_eq!(defense_clang(&row, VICTIM_BLOCK, false), 3263);
+        assert_eq!(defense_clang(&row, VICTIM_BLOCK, true), 3263);
+    }
+
+    /// Parry and block are the defended pair — the outcomes whose sound comes from the victim
+    /// dispatch's clang instead of the attacker's weapon-sound block. A landed hit is not.
+    #[test]
+    fn only_parry_and_block_are_defended() {
+        assert!(defended(VICTIM_PARRY));
+        assert!(defended(VICTIM_BLOCK));
+        for other in [
+            0,
+            1,
+            VICTIM_DODGE,
+            4,
+            VICTIM_EVADE,
+            VICTIM_IMMUNE,
+            VICTIM_DEFLECT,
+        ] {
+            assert!(!defended(other), "victimState {other} is not a defense");
+        }
+    }
+
+    /// The landed hit reads the victim's `CreatureImpactType` slot, crit-tiered; an unknown
+    /// material falls to flesh (players carry no creature row).
+    #[test]
+    fn landed_impact_reads_material_slot_crit_tiered() {
+        let row = sword1h_metal();
+        assert_eq!(landed_impact(&row, 0, false), 143);
+        assert_eq!(landed_impact(&row, 0, true), 144);
+        assert_eq!(landed_impact(&row, 1, false), 3206);
+        assert_eq!(landed_impact(&row, 99, false), 143, "unknown → flesh");
+    }
+}
diff --git a/crates/benilla/src/target/by_name.rs b/crates/benilla/src/target/by_name.rs
index 5ada9b31..0305ec97 100644
--- a/crates/benilla/src/target/by_name.rs
+++ b/crates/benilla/src/target/by_name.rs
@@ -147,9 +147,66 @@ fn common_prefix_len(query: &str, name: &str) -> usize {
         .count()
 }
 
+/// The follow start gate's decision, as a pure function of the five things it reads — so the
+/// **order** of the chain (which refusal you see when two apply at once) is pinned by test rather
+/// than by whichever `if` happens to come first after an edit.
+///
+/// `0x60fed0`'s mode-3 chain, in its own order, with the message ids it pushes:
+///
+/// | check | site | failure |
+/// |---|---|---|
+/// | followee typemask `0x10` (PLAYER) | `0x60ff5f` | `0x128` `ERR_INVALID_FOLLOW_TARGET` |
+/// | `CanAssist` the followee (`0x606ba0`) | `0x60ff6a` | `0x128`, the same line |
+/// | we are alive | `0x60ff7c` | `0x7e` `ERR_PLAYER_DEAD` |
+/// | we are not stunned (`UNIT_FIELD_FLAGS & 0x40000`) | `0x60ff95` | `0x191` `ERR_GENERIC_STUNNED` |
+/// | we are not casting (`[[mover+0x110]+0x228] == 0`) | `0x60ffb9` | `0x134` `ERR_TOOBUSYTOFOLLOW` |
+///
+/// There is deliberately **no followee-alive check** and **no distance check**. A corpse can be
+/// followed (it is the per-tick death test that ends the follow, not the gate), and the
+/// max-distance machinery — `0x6110a0`, which raises `ERR_AUTOFOLLOW_TOO_FAR` at the binary's only
+/// `0x126` call site — is **disabled by data**: follow's row in the per-mode table `0x860a58` has a
+/// `0.0f` threshold, which `0x6110c8` short-circuits on. So the error string ships, the code ships,
+/// and no distance is ever enforced at either end. One `.rdata` float from being a real limit.
+fn follow_refusal_key(
+    followee_is_player: bool,
+    can_assist_followee: bool,
+    we_are_dead: bool,
+    we_are_stunned: bool,
+    we_are_casting: bool,
+) -> Option<&'static str> {
+    if !followee_is_player || !can_assist_followee {
+        return Some("ERR_INVALID_FOLLOW_TARGET");
+    }
+    if we_are_dead {
+        return Some("ERR_PLAYER_DEAD");
+    }
+    if we_are_stunned {
+        return Some("ERR_GENERIC_STUNNED");
+    }
+    if we_are_casting {
+        return Some("ERR_TOOBUSYTOFOLLOW");
+    }
+    None
+}
+
+/// Whether the resolver's **second tier** is live — the shared resolver's exact-only parameter,
+/// which every caller in the table above sources from the second Lua argument.
+///
+/// It is not decoration: `UnitPopup.lua`'s Follow row passes `FollowByName(name, 1)`, and a menu
+/// that already names its unit exactly must not prefix-match its way onto a bystander who happens
+/// to share a first letter. `/follow rag` still may, because the slash command passes nothing.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(crate) enum Match {
+    /// Tier 1 then tier 2 — a whole-string hit, else the longest common prefix.
+    PrefixOk,
+    /// Tier 1 only. Tier 2 is skipped entirely, so a query that is not the whole name matches
+    /// nothing at all.
+    ExactOnly,
+}
+
 /// Score one candidate against the query, or `None` when it does not match at all. The reference's
 /// running best length seeds at **1**, so a zero-length overlap is not a match.
-fn rank(query: &str, name: &str, dist2: f32) -> Option<Rank> {
+fn rank(query: &str, name: &str, dist2: f32, mode: Match) -> Option<Rank> {
     if query.eq_ignore_ascii_case(name) {
         return Some(Rank {
             exact: true,
@@ -157,6 +214,9 @@ fn rank(query: &str, name: &str, dist2: f32) -> Option<Rank> {
             dist2,
         });
     }
+    if mode == Match::ExactOnly {
+        return None;
+    }
     let prefix = common_prefix_len(query, name);
     (prefix >= 1).then_some(Rank {
         exact: false,
@@ -238,13 +298,54 @@ impl ByNameScan<'_, '_> {
         ) >= 4
     }
 
+    /// The **follow start gate** — `0x60fed0`'s mode-3 chain (reached via the remap
+    /// `0x610094[3] = 1` → `0x610084[1]` = `0x60ff59`), in the reference's own order. Returns the
+    /// GlobalStrings key of the *first* refusal, or `None` to let the follow begin.
+    ///
+    /// This gate is why 0890's "the bare form follows whatever you have selected, creature or
+    /// player, with no such filter" was **true and yet wrong about the behaviour**. That sentence
+    /// was about the by-name *resolver's* filter, and it is correct: `FollowUnit` never goes
+    /// through `0x493aa0`. But the gate below sits downstream of both bindings, so a creature is
+    /// refused all the same — with "You can't follow that unit.", which is exactly what the real
+    /// client says. Being right about *a* mechanism is not being right about *the* cause.
+    ///
+    /// Each refusal is a real error line through the one `CGGameUI::DisplayError` route
+    /// ([`crate::ui_action::UiErrorKeys`]) rather than silence, because that is what the reference
+    /// does — these five have message ids, and three of the four strings exist for no other caller.
+    fn follow_refusal(
+        &self,
+        followee: u64,
+        followee_store: Option<&ObjectStore>,
+        casting: bool,
+    ) -> Option<&'static str> {
+        let self_store = self.self_q.single().ok().and_then(|(_, _, _, s)| s);
+        follow_refusal_key(
+            guid::is_player(followee),
+            super::ring_reaction(
+                self.factions.as_deref(),
+                &self.reputations,
+                followee_store,
+                self_store,
+            ) >= 4,
+            self_store.is_some_and(|s| s.0.unit_is_dead()),
+            self_store.is_some_and(|s| s.0.unit_flags() & crate::player::UNIT_FLAG_STUNNED != 0),
+            casting,
+        )
+    }
+
     /// Resolve a name to a unit, or `None`. See the module header for the full law.
     ///
     /// Every call logs its verdict under the `by-name:` prefix — one line per typed command, so a
     /// "`/target` won't take that mob" report is diagnosable from the log rather than re-guessed
     /// (the `WOW_TAB_TRACE` instrument's shape, ungated because the cost is per-command, not
     /// per-frame). The line names how many candidates were eligible, which won, and on what.
-    fn resolve(&self, query: &str, search: NameSearch, filter: Filter) -> Option<(Entity, u64)> {
+    fn resolve(
+        &self,
+        query: &str,
+        search: NameSearch,
+        filter: Filter,
+        mode: Match,
+    ) -> Option<(Entity, u64, String)> {
         let query = query.trim();
         if query.is_empty() {
             return None;
@@ -269,7 +370,7 @@ impl ByNameScan<'_, '_> {
             };
             considered += 1;
             let dist2 = tf.translation.distance_squared(origin);
-            let Some(r) = rank(query, name, dist2) else {
+            let Some(r) = rank(query, name, dist2, mode) else {
                 continue;
             };
             if best.as_ref().is_none_or(|(_, _, b, _)| r.beats(*b)) {
@@ -286,10 +387,10 @@ impl ByNameScan<'_, '_> {
             ),
             None => info!(
                 "by-name: \"{query}\" ({search:?}) -> NO MATCH over {considered} named candidates \
-                 ({nameless} unnamed); target left untouched"
+                 ({nameless} unnamed, {mode:?}); target left untouched"
             ),
         }
-        best.map(|(e, g, _, _)| (e, g))
+        best.map(|(e, g, _, name)| (e, g, name))
     }
 }
 
@@ -307,9 +408,12 @@ pub(super) fn target_by_name_requests(
     mut commit: SelectCommit,
 ) {
     for request in requests.read() {
-        let Some((entity, guid)) =
-            scan_params.resolve(&request.name, NameSearch::AnyUnit, Filter::AcceptAll)
-        else {
+        let Some((entity, guid, _)) = scan_params.resolve(
+            &request.name,
+            NameSearch::AnyUnit,
+            Filter::AcceptAll,
+            Match::PrefixOk,
+        ) else {
             continue;
         };
         commit.commit(entity, guid);
@@ -340,8 +444,13 @@ pub(super) fn assist_requests(
         // The basis: a named PLAYER, or — bare — whatever is currently selected.
         let basis = match &request.name {
             Some(name) => scan_params
-                .resolve(name, NameSearch::PlayerOnly, Filter::AcceptAll)
-                .map(|(e, _)| e),
+                .resolve(
+                    name,
+                    NameSearch::PlayerOnly,
+                    Filter::AcceptAll,
+                    Match::PrefixOk,
+                )
+                .map(|(e, _, _)| e),
             None => commit.selection.target,
         };
         let Some(basis) = basis else {
@@ -377,28 +486,71 @@ pub(super) fn assist_requests(
 /// Drain `/follow [name]`: resolve the subject and hand it to [`crate::player`], which owns the
 /// motion (decision 0890). Nothing goes on the wire — follow is client-side movement only.
 ///
-/// The two forms differ in more than the argument. A **name** goes through the resolver with the
-/// reference's filter mode 2 — players only, and only ones that are **alive and assistable** — so
-/// `/follow <an enemy>` finds nothing. The **bare** form is `FollowUnit("target")`, a unit-token
-/// resolve that never touches the by-name path at all, so it follows whatever you have selected,
-/// creature or player, with no such filter.
+/// The two forms differ in how the subject is **found** — a name goes through the resolver with
+/// the reference's filter mode 2 (players only, alive and assistable), a token takes whatever it
+/// points at — but **not** in what is allowed. [`ByNameScan::follow_refusal`] sits downstream of
+/// both, so `/follow` on a creature refuses either way, with the reference's own error line.
+///
+/// The followee's **name** is latched here rather than re-read later: it is what
+/// `AUTOFOLLOW_BEGIN` carries into the status text ([`crate::ui_follow`]), and the resolver has
+/// already produced it for the by-name half.
+#[allow(clippy::too_many_arguments)] // a Bevy system's param list IS its dependency set
 pub(super) fn follow_requests(
     mut requests: MessageReader<crate::player::FollowRequest>,
     scan_params: ByNameScan,
     selection: Res<Selection>,
+    group: Res<crate::ui_party::GroupState>,
+    index: Res<GuidIndex>,
+    stores: Query<&ObjectStore>,
+    cast: Res<crate::ui_cast::PendingCast>,
+    mut errors: ResMut<crate::ui_action::UiErrorKeys>,
     mut follow: ResMut<crate::player::FollowState>,
 ) {
     for request in requests.read() {
-        let resolved = match &request.name {
-            Some(name) => scan_params
-                .resolve(name, NameSearch::PlayerOnly, Filter::AssistableAlive)
-                .map(|(_, guid)| guid),
-            None => selection.guid,
+        let resolved = match request {
+            crate::player::FollowRequest::Name { name, exact } => scan_params
+                .resolve(
+                    name,
+                    NameSearch::PlayerOnly,
+                    Filter::AssistableAlive,
+                    if *exact {
+                        Match::ExactOnly
+                    } else {
+                        Match::PrefixOk
+                    },
+                )
+                .map(|(_, guid, name)| (guid, name)),
+            // `"target"` is deliberately NOT routed through `player_token_guid`: that helper
+            // applies the inspect/popup family's players-only typemask *at the token*, whereas
+            // follow's typemask is the start gate's, one layer down, and must produce the gate's
+            // error line rather than a silent nothing. The party tokens do go through it — they
+            // can only ever name a player anyway, and it knows the roster order.
+            crate::player::FollowRequest::Unit(token) => match token.as_str() {
+                "target" => selection.guid,
+                tok => crate::ui_unit::player_token_guid(tok, &selection, &group),
+            }
+            .map(|guid| {
+                let name = scan_params.names.peek(guid).unwrap_or_default().to_string();
+                (guid, name)
+            }),
         };
+        // The start gate, applied to whichever way the subject was found.
+        if let Some((guid, _)) = &resolved {
+            let followee = index.0.get(guid).and_then(|e| stores.get(*e).ok());
+            if let Some(key) = scan_params.follow_refusal(
+                *guid,
+                followee,
+                cast.in_flight(std::time::Instant::now()),
+            ) {
+                info!("follow: refused — {key}");
+                errors.0.push(crate::ui_action::UiError::key(key));
+                continue;
+            }
+        }
         match resolved {
-            Some(guid) => {
-                info!("follow: now following guid {guid:#x}");
-                follow.start(guid);
+            Some((guid, name)) => {
+                info!("follow: now following \"{name}\" guid {guid:#x}");
+                follow.start(guid, name);
             }
             None => {
                 // The reference's `if GetSlashCmdTarget(msg)` guard and the resolver's own miss both
@@ -492,17 +644,76 @@ mod tests {
     #[test]
     fn a_match_needs_one_folded_character() {
         // The reference seeds its best length at 1, so zero overlap is not a match at all.
-        assert!(rank("zzz", "Ragnaros", 1.0).is_none());
-        assert_eq!(rank("rag", "Ragnaros", 1.0).map(|r| r.prefix), Some(3));
+        assert!(rank("zzz", "Ragnaros", 1.0, Match::PrefixOk).is_none());
+        assert_eq!(
+            rank("rag", "Ragnaros", 1.0, Match::PrefixOk).map(|r| r.prefix),
+            Some(3)
+        );
     }
 
     #[test]
     fn whole_string_match_is_case_insensitive_and_ranks_exact() {
-        let r = rank("kobold vermin", "Kobold Vermin", 9.0).expect("matches");
+        let r = rank("kobold vermin", "Kobold Vermin", 9.0, Match::PrefixOk).expect("matches");
         assert!(r.exact, "tier 1 is case-insensitive whole-string");
         // A multi-word creature name is the case that made the whole-argument trim load-bearing.
     }
 
+    /// The exact-only flag is the unit popup's Follow row (`FollowByName(name, 1)`): tier 2 is
+    /// skipped outright, so the prefix that `/follow rag` rides cannot fire. Tier 1 is unaffected
+    /// and stays case-insensitive — "exact" is about the whole string, never about case.
+    /// The follow start gate's chain, in the reference's order. The order is the point: a dead
+    /// player who targets a creature sees "You can't follow that unit.", not "You are dead" — the
+    /// followee checks come first, and both of them raise the SAME message id (0x128).
+    #[test]
+    fn the_follow_gate_refuses_in_the_references_own_order() {
+        // The clean case.
+        assert_eq!(follow_refusal_key(true, true, false, false, false), None);
+        // A creature — the correction that matters most, and the reason `/follow` on a mob refuses
+        // however you got there (0890 read the by-name filter and missed this gate below it).
+        assert_eq!(
+            follow_refusal_key(false, true, false, false, false),
+            Some("ERR_INVALID_FOLLOW_TARGET")
+        );
+        // An enemy player fails CanAssist, and shares the creature's line.
+        assert_eq!(
+            follow_refusal_key(true, false, false, false, false),
+            Some("ERR_INVALID_FOLLOW_TARGET")
+        );
+        // Our own three, each shadowed by the followee checks above it.
+        assert_eq!(
+            follow_refusal_key(true, true, true, false, false),
+            Some("ERR_PLAYER_DEAD")
+        );
+        assert_eq!(
+            follow_refusal_key(true, true, false, true, false),
+            Some("ERR_GENERIC_STUNNED")
+        );
+        assert_eq!(
+            follow_refusal_key(true, true, false, false, true),
+            Some("ERR_TOOBUSYTOFOLLOW")
+        );
+        // Everything wrong at once: the followee's line wins outright.
+        assert_eq!(
+            follow_refusal_key(false, false, true, true, true),
+            Some("ERR_INVALID_FOLLOW_TARGET")
+        );
+        // Dead AND stunned: dead wins, because it is checked first.
+        assert_eq!(
+            follow_refusal_key(true, true, true, true, true),
+            Some("ERR_PLAYER_DEAD")
+        );
+    }
+
+    #[test]
+    fn exact_only_skips_the_prefix_tier_but_keeps_the_case_fold() {
+        assert!(rank("rag", "Ragnaros", 1.0, Match::ExactOnly).is_none());
+        assert!(
+            rank("RAGNAROS", "Ragnaros", 1.0, Match::ExactOnly)
+                .expect("whole-string still matches")
+                .exact
+        );
+    }
+
     #[test]
     fn exact_beats_any_prefix_and_nearest_breaks_the_tie() {
         // Our deliberate deviation: the reference's enumeration-order early-out would let a nearer
diff --git a/crates/benilla/src/ui_chat/input/mod.rs b/crates/benilla/src/ui_chat/input/mod.rs
index da14a193..0ee72ad3 100644
--- a/crates/benilla/src/ui_chat/input/mod.rs
+++ b/crates/benilla/src/ui_chat/input/mod.rs
@@ -529,9 +529,14 @@ pub(super) fn drain_chat_input(
                 chat_out.assist.write(crate::target::AssistRequest { name });
             }
             // `/follow` (decision 0890) — the subject is resolved by `crate::target` and the motion
-            // is `crate::player`'s; chat only carries the ask. Bare follows the current selection.
+            // is `crate::player`'s; chat only carries the ask. The two arms are the ref handler's
+            // own two calls: bare is `FollowUnit("target")`, named is `FollowByName(name)` with no
+            // second argument, i.e. prefix matching live.
             ParsedChat::Follow { name } => {
-                chat_out.follow.write(crate::player::FollowRequest { name });
+                chat_out.follow.write(match name {
+                    Some(name) => crate::player::FollowRequest::Name { name, exact: false },
+                    None => crate::player::FollowRequest::Unit("target".into()),
+                });
             }
             // The ref's handler is `SlashCmdList["PVP"] = function() TogglePVP() end` — one line
             // over the same binding the popup row calls, so it enters the same intent queue
diff --git a/crates/benilla/src/ui_follow.rs b/crates/benilla/src/ui_follow.rs
new file mode 100644
index 00000000..77ddd678
--- /dev/null
+++ b/crates/benilla/src/ui_follow.rs
@@ -0,0 +1,119 @@
+//! The app-side **follow bridge** — the seam between the auto-follow movement mode
+//! ([`crate::player::follow`], decision 0890) and the UI that has to say so.
+//!
+//! Two directions, one small module:
+//!
+//! - **In.** Drain the Era API's follow intents ([`benilla_ui::script::FollowRequest`], queued by
+//!   `FollowUnit`/`FollowByName`) into the app's own [`crate::player::FollowRequest`] funnel, which
+//!   [`crate::target::by_name`] resolves. The unit popup's **Follow** row is the shipped caller;
+//!   the slash command reaches the same funnel directly, because benilla parses slash lines in Rust
+//!   (decision 0881).
+//! - **Out.** Fire `AUTOFOLLOW_BEGIN` / `AUTOFOLLOW_END` on the follow state's transitions. That
+//!   pair is the *entire* interface the reference gives the UI for follow — there is no
+//!   `IsFollowing()` and no unit token for the followee, so a status display is only possible at
+//!   all because the events carry the name.
+//!
+//! ## What the events drive
+//!
+//! `AutoFollowStatus` (ZoneText.xml) — a `setAllPoints` frame over `UIParent` carrying one
+//! centre-anchored 20px `GameFontNormal` string. On `AUTOFOLLOW_BEGIN` it latches `arg1`, sets alpha
+//! to 1 and shows `AUTOFOLLOWSTART` ("Following %s."); on `AUTOFOLLOW_END` it swaps the text to
+//! `AUTOFOLLOWSTOP` ("You stop following %s.") — reusing the *latched* name, which is why END needs
+//! no argument of its own — and starts a linear 4-second alpha fade to hidden. It is not the
+//! FadingFrame kit; `AutoFollowStatus_OnUpdate` rolls its own fade, with no fade-in and no hold.
+//!
+//! So the "You stop following X" line is the reason [`crate::player::FollowState`] latches the name
+//! at start rather than re-reading it: by the time the follow ends, the followee may well be gone.
+//!
+//! ## Transitions
+//!
+//! Start → `BEGIN`. Stop → `END`. A follow that *switches* subject fires **`END` then `BEGIN`**:
+//! the reference's arm routine calls the canceller first (`0x61113e`, inside `0x611130`), so
+//! re-issuing `/follow` while already following really does emit both, in that order. On screen the
+//! pair is indistinguishable from `BEGIN` alone — `AutoFollowStatus_OnEvent`'s BEGIN arm is a full
+//! reset, clearing `fadeTime` and restoring alpha — but an addon listening for `AUTOFOLLOW_END`
+//! would notice, so we emit what the reference emits.
+//!
+//! ## The three paths where the reference does NOT fire `END`
+//!
+//! Two writers set the follow mode cell `0xc4d888` back to `0xc` **directly** (`0x5fb646`,
+//! `0x60396f`), bypassing the canceller entirely: no event fires, and `0xc4d980` is left holding a
+//! stale guid. A third miss is the canceller's own early-out (`0x60fb70`), which skips the fire
+//! *and* the state clear. The two direct writers' triggers are INFERRED to be zoning / world-leave
+//! / logout.
+//!
+//! We do not reproduce this. It is a reference **bug** whose visible symptom is the status line
+//! surviving a zone change with nobody to hide it — and our shape cannot reproduce it anyway, since
+//! the line follows [`FollowState`] rather than a separately-cleared cell. Recorded because "the
+//! status text is stuck after a zone" is a real report someone may one day file *against the real
+//! client*, and the answer is "yes, it does that".
+
+use bevy::prelude::*;
+
+use benilla_ui::script::{FollowRequest as ScriptFollowRequest, ScriptValue, UiScript};
+
+use crate::player::{FollowRequest, FollowState};
+use crate::ui_script::UiInput;
+
+/// What the VM has last been told, so the two events fire exactly on transitions and never once a
+/// frame. Mirrors [`FollowState::guid`]; `None` means the VM believes no follow is running.
+#[derive(Resource, Default)]
+pub(crate) struct FollowFeed {
+    told: Option<u64>,
+}
+
+/// Push the follow state's transitions into the VM as the reference's two events.
+fn feed_follow(
+    script: Option<NonSendMut<UiScript>>,
+    follow: Res<FollowState>,
+    mut feed: ResMut<FollowFeed>,
+) {
+    let Some(mut script) = script else {
+        return;
+    };
+    match (follow.guid, feed.told) {
+        // Started, or switched subject. A switch emits END first, because the reference's arm
+        // routine calls the canceller before arming (see the module header).
+        (Some(guid), told) if told != Some(guid) => {
+            if told.is_some() {
+                script.fire_event("AUTOFOLLOW_END", vec![]);
+            }
+            script.fire_event(
+                "AUTOFOLLOW_BEGIN",
+                vec![ScriptValue::Str(follow.name.clone())],
+            );
+            feed.told = Some(guid);
+        }
+        // Stopped — by arrival at an unresolvable followee, by the turn-away cancel, or by any of
+        // the input cancels. END carries no argument: the frame reuses the name BEGIN latched.
+        (None, Some(_)) => {
+            script.fire_event("AUTOFOLLOW_END", vec![]);
+            feed.told = None;
+        }
+        _ => {}
+    }
+}
+
+/// Drain the Era API's follow intents into the app's own funnel.
+fn drain_follow(script: Option<NonSendMut<UiScript>>, mut out: MessageWriter<FollowRequest>) {
+    let Some(mut script) = script else {
+        return;
+    };
+    for request in script.take_follow_requests() {
+        out.write(match request {
+            ScriptFollowRequest::ByUnit(unit) => FollowRequest::Unit(unit),
+            ScriptFollowRequest::ByName { name, exact } => FollowRequest::Name { name, exact },
+        });
+    }
+}
+
+pub(crate) struct UiFollowPlugin;
+
+impl Plugin for UiFollowPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<FollowFeed>().add_systems(
+            Update,
+            (feed_follow.before(UiInput), drain_follow.after(UiInput)),
+        );
+    }
+}
diff --git a/crates/benilla/src/ui_items/drain.rs b/crates/benilla/src/ui_items/drain.rs
index d1f774e4..b22d6356 100644
--- a/crates/benilla/src/ui_items/drain.rs
+++ b/crates/benilla/src/ui_items/drain.rs
@@ -209,126 +209,181 @@ pub(super) fn drain_container_uses(
             }
             continue;
         }
-        // The openable fork: a clam, an unlocked lockbox, a wrapped gift. `CMSG_OPEN_ITEM`, not
-        // `CMSG_USE_ITEM` — the server's `HandleOpenItemOpcode` is the only handler that answers
-        // with `SendLoot(item guid, LOOT_CORPSE)`, i.e. a loot window over a thing in your bag;
-        // sending USE_ITEM instead casts the item's (absent) on-use spell and nothing happens,
-        // which is exactly the "no way to open clams" symptom. The predicate is
-        // `ItemInfo::openable` — literally the same call the tooltip's `<Right Click to Open>`
-        // line makes, so the promise and the packet cannot drift apart.
-        //
-        // It sits ABOVE the readable fork because the reference's own tooltip law makes the two
-        // mutually exclusive with **openable winning** (wow-re `tooltip-content-law.md`
-        // §1-OPENABLE, the `jmp` past the READABLE test): a wrapped gift that also carries letter
-        // text opens, it does not read. Below the merchant/bank intercepts, which outrank every
-        // ordinary click.
-        let openable = self_q
+        // Everything the reference's click law reads off the clicked slot, resolved once. `None` =
+        // an empty slot, or a template still in flight — the click then falls all the way through
+        // to a plain USE, whose refusal is at least visible (the template is all but always cached
+        // by click time; the bag needed it for the icon).
+        let clicked = self_q
             .iter()
             .next()
             .and_then(|store| slot_guid(&store.0, bag, slot0.unwrap_or(0), &items))
             .and_then(|guid| {
                 let obj = items.object(guid)?;
                 let inst_flags = obj.item_flags().unwrap_or(0);
+                let item_text_id = obj.item_text_id().unwrap_or(0);
                 let entry = obj.object_entry()?;
-                items
-                    .template(entry, guid, &commands)?
-                    .openable(inst_flags)
-                    .then_some(guid)
+                let t = items.template(entry, guid, &commands)?;
+                Some(Clicked {
+                    guid,
+                    entry,
+                    item_text_id,
+                    inventory_type: t.inventory_type,
+                    display_info_id: t.display_info_id,
+                    start_quest: t.start_quest,
+                    // The wire's spell byte is a template BLOCK ordinal (decision 0666) — the
+                    // template is right here, so send the real one rather than assuming 0.
+                    spell_index: t.use_spell_index().unwrap_or(0),
+                    unwraps_gift: t.unwraps_gift(inst_flags),
+                    opens_loot: t.opens_loot(),
+                })
             });
-        if let Some(guid) = openable {
-            debug!("ui_items: open item {guid:#x} (lua bag {bag} → wire {bag_index}/{wire_slot})");
+
+        // The reference's equip-vs-use fork (`0x4fa3b9`/`0x4fa3bd`, wow-re `right-click-open.md`
+        // §2), with the ammo sub-fork `cursor-dragdrop-slots.md` pins: the auto-equip sender
+        // `0x5e1480` sends `CMSG_SET_AMMO` (the item entry) for an ammo-class item,
+        // `CMSG_AUTOEQUIP_ITEM` for any other equippable (inventoryType != 0 — weapons, armor,
+        // bags). display_id feeds the synthetic pickup→place auto-equip sound (this path never
+        // moves the cursor; a drag already gets that pair via the cursor-payload transitions).
+        //
+        // The arm carries the reference's own **quest guard** (`0x4fa3bd`–`0x4fa3cc`, decision
+        // 0664): it equips only when `StartQuest` (`[rec+0x1a8]`) is 0, so a quest-starter falls
+        // through *whatever* its inventoryType — the five equippable ones (Pendant of Myzrael,
+        // Arena Master, …) offer their quest on a right-click, they don't put themselves on.
+        //
+        // **Everything below this fork is `0x5d8d00`, the USE dispatcher, in ITS OWN order**
+        // (wow-re `right-click-open.md` §3) — an equippable item never reaches any of it.
+        if let Some(c) = clicked.filter(|c| c.start_quest == 0 && c.inventory_type != 0) {
+            if c.inventory_type == INVTYPE_AMMO {
+                // Ammo loads by entry (`CMSG_SET_AMMO`), NOT the equip swap wire — the stack stays
+                // in the bag and `PLAYER_AMMO_ID` references it (decision 0526). The server
+                // refuses a wrong/absent ranged weapon via `SMSG_INVENTORY_CHANGE_FAILURE`.
+                debug!(
+                    "ui_items: set ammo entry {} (lua bag {bag} slot {slot})",
+                    c.entry
+                );
+                let _ = commands.0.send(ClientCommand::SetAmmo { entry: c.entry });
+            } else {
+                debug!("ui_items: auto-equip (lua bag {bag} → wire {bag_index}/{wire_slot})");
+                let _ = commands.0.send(ClientCommand::AutoEquipItem {
+                    bag_index,
+                    slot: wire_slot,
+                });
+            }
+            equip_sound.write(crate::sound::AutoEquipSound {
+                display_id: c.display_info_id,
+            });
+            continue;
+        }
+        // #2 — the wrapped gift (`0x5d8d92`/`0x5d8d9d` → emitter `0x5edd60`): `CMSG_OPEN_ITEM`
+        // unwraps it. FIRST in the dispatcher, ahead of the quest and readable arms, so a gift
+        // that also carries letter text unwraps rather than reads. (vmangos answers this one with
+        // an entry swap out of `character_gifts`, not a loot window.)
+        if let Some(c) = clicked.filter(|c| c.unwraps_gift) {
+            debug!(
+                "ui_items: unwrap gift {:#x} (lua bag {bag} → wire {bag_index}/{wire_slot})",
+                c.guid
+            );
             let _ = commands.0.send(ClientCommand::OpenItem {
                 bag_index,
                 slot: wire_slot,
             });
             continue;
         }
-        // The readable fork: an item INSTANCE carrying `ITEM_FIELD_ITEM_TEXT_ID` (a mail-made
-        // permanent letter) opens the reader instead of a use — client-side, no permission
-        // packet (vmangos' `CMSG_READ_ITEM` handler gates on the *template*'s PageText, which is
-        // 0 for the Plain Letter; the text rides the ask-once `CMSG_ITEM_TEXT_QUERY` instead).
-        let read = self_q
-            .iter()
-            .next()
-            .and_then(|store| slot_guid(&store.0, bag, slot0.unwrap_or(0), &items))
-            .and_then(|guid| {
-                items
-                    .object(guid)
-                    .and_then(|o| o.item_text_id())
-                    .filter(|&t| t != 0)
-                    .map(|t| (guid, t))
-            });
-        if let Some((guid, text_id)) = read {
-            debug!("ui_items: read item {guid:#x} (text {text_id}, lua bag {bag} slot {slot})");
-            item_text.open(guid, text_id);
+        // #3 — the quest-starter (`0x5d8dd2`, decision 0664): the item's own guid is the
+        // questgiver. Placed at the reference's position rather than at the tail, so a starter
+        // that is *also* readable or lootable offers its quest instead of reading/opening. Routed
+        // through the one shared use fork, which is what turns a non-zero StartQuest into the
+        // item-guid query.
+        if let Some(c) = clicked.filter(|c| c.start_quest != 0) {
+            debug!(
+                "ui_items: quest-starter {:#x} offers quest {}",
+                c.guid, c.start_quest
+            );
+            let _ = commands.0.send(super::item_use_command(
+                Some(c.guid),
+                c.start_quest,
+                bag_index,
+                wire_slot,
+                c.spell_index,
+            ));
             continue;
         }
-        // The real client's equip-vs-use fork, with the ammo sub-fork wow-re
-        // `cursor-dragdrop-slots.md` pins: the auto-equip sender `0x5e1480` sends `CMSG_SET_AMMO`
-        // (the item entry) for an ammo-class item, `CMSG_AUTOEQUIP_ITEM` for any other equippable
-        // (inventoryType != 0 — weapons, armor, bags), and only a non-equippable is a USE (food,
-        // potions, hearthstone). The template is all but always cached by click time (the bag
-        // needed it for the icon); unresolved falls back to USE, whose refusal is at least visible.
-        // display_id feeds the synthetic pickup→place auto-equip sound (this path never moves the
-        // cursor; a drag already gets that pair via the cursor-payload transitions).
+        // #6 — readable: an item INSTANCE carrying `ITEM_FIELD_ITEM_TEXT_ID` (a mail-made
+        // permanent letter) opens the reader — client-side, no permission packet (vmangos'
+        // `CMSG_READ_ITEM` handler gates on the *template*'s PageText, which is 0 for the Plain
+        // Letter; the text rides the ask-once `CMSG_ITEM_TEXT_QUERY` instead).
         //
-        // The equip arm carries the reference's own **quest guard** (`0x4fa3bd`–`0x4fa3cc`,
-        // decision 0664): `Script::UseContainerItem` equips only when the cache record's
-        // `StartQuest` (`[rec+0x1a8]`) is 0, so a quest-starter goes to the use fork *whatever* its
-        // inventoryType — the five equippable ones (Pendant of Myzrael, Arena Master, …) offer their
-        // quest on a right-click, they don't put themselves on.
-        let resolved = self_q
-            .iter()
-            .next()
-            .and_then(|store| slot_guid(&store.0, bag, slot0.unwrap_or(0), &items))
-            .and_then(|guid| {
-                let entry = items.object(guid)?.object_entry()?;
-                let t = items.template(entry, guid, &commands)?;
-                Some((
-                    guid,
-                    entry,
-                    t.inventory_type,
-                    t.display_info_id,
-                    t.start_quest,
-                    // The wire's spell byte is a template BLOCK ordinal (decision 0666) — the
-                    // template is right here, so send the real one rather than assuming 0.
-                    t.use_spell_index().unwrap_or(0),
-                ))
-            });
-        let equippable = resolved.is_some_and(|(_, _, inv_type, _, q, _)| q == 0 && inv_type != 0);
-        match resolved {
-            // Ammo loads by entry (`CMSG_SET_AMMO`), NOT the equip swap wire — the stack stays in
-            // the bag and `PLAYER_AMMO_ID` references it (decision 0526). The server refuses a
-            // wrong/absent ranged weapon via `SMSG_INVENTORY_CHANGE_FAILURE`.
-            Some((_, entry, INVTYPE_AMMO, display_id, _, _)) if equippable => {
-                debug!("ui_items: set ammo entry {entry} (lua bag {bag} slot {slot})");
-                let _ = commands.0.send(ClientCommand::SetAmmo { entry });
-                equip_sound.write(crate::sound::AutoEquipSound { display_id });
-            }
-            Some((_, _, _, display_id, _, _)) if equippable => {
-                debug!("ui_items: auto-equip (lua bag {bag} → wire {bag_index}/{wire_slot})");
-                let _ = commands.0.send(ClientCommand::AutoEquipItem {
-                    bag_index,
-                    slot: wire_slot,
-                });
-                equip_sound.write(crate::sound::AutoEquipSound { display_id });
-            }
-            _ => {
-                let (guid, start_quest, spell_index) =
-                    resolved.map_or((None, 0, 0), |(guid, _, _, _, q, i)| (Some(guid), q, i));
-                debug!("ui_items: use item (lua bag {bag} → wire {bag_index}/{wire_slot}, starts quest {start_quest})");
-                let _ = commands.0.send(super::item_use_command(
-                    guid,
-                    start_quest,
-                    bag_index,
-                    wire_slot,
-                    spell_index,
-                ));
-            }
+        // The dispatcher's arm **#5** — the same local open off the *template*'s `PageText`
+        // (`0x5d8e4c`) — has no feed here yet (books/pages aren't built). When it lands it belongs
+        // immediately above this one, and still above the open arm: the send order is the INVERSE
+        // of the tooltip's, where OPENABLE wins over READABLE. A template that is both readable
+        // and lootable therefore *shows* `<Right Click to Open>` and *reads* on click — the
+        // reference's own inversion, byte-verified, not a slip of ours.
+        if let Some(c) = clicked.filter(|c| c.item_text_id != 0) {
+            debug!(
+                "ui_items: read item {:#x} (text {}, lua bag {bag} slot {slot})",
+                c.guid, c.item_text_id
+            );
+            item_text.open(c.guid, c.item_text_id);
+            continue;
         }
+        // #8 — the open arm (`0x5d8f7c: test al,4` → emitter `0x5edc80`): a **bare** template
+        // LOOTABLE test. `CMSG_OPEN_ITEM`, not `CMSG_USE_ITEM` — the server's
+        // `HandleOpenItemOpcode` is the only handler that answers with
+        // `SendLoot(item guid, LOOT_CORPSE)`, i.e. a loot window over a thing in your bag; sending
+        // USE_ITEM instead casts the item's (absent) on-use spell and nothing happens, which was
+        // exactly the "no way to open clams" symptom.
+        //
+        // Deliberately looser than the tooltip line's predicate (`ItemInfo::shows_open_line`): the
+        // send consults **neither** LockID nor the instance UNLOCKED bit (VERIFIED both ways — no
+        // `[rec+0x1ac]` operand exists anywhere on the send path). So a still-locked junkbox DOES
+        // send, and the server's `EQUIP_ERR_ITEM_LOCKED` is where the player's "Item is locked"
+        // line comes from. Gating locally would eat the click in silence (decision 0896).
+        if let Some(c) = clicked.filter(|c| c.opens_loot) {
+            debug!(
+                "ui_items: open item {:#x} (lua bag {bag} → wire {bag_index}/{wire_slot})",
+                c.guid
+            );
+            let _ = commands.0.send(ClientCommand::OpenItem {
+                bag_index,
+                slot: wire_slot,
+            });
+            continue;
+        }
+        // The tail: a plain use (food, potions, hearthstone). The quest arm already fired above,
+        // so the shared fork's own quest leg is inert here by construction.
+        debug!("ui_items: use item (lua bag {bag} → wire {bag_index}/{wire_slot})");
+        let _ = commands.0.send(super::item_use_command(
+            clicked.map(|c| c.guid),
+            0,
+            bag_index,
+            wire_slot,
+            clicked.map_or(0, |c| c.spell_index),
+        ));
     }
 }
 
+/// One clicked bag slot, resolved: the live instance's guid and the template scalars the
+/// reference's fork chain tests, read once so the chain above is a plain ordered cascade rather
+/// than five repeats of the same lookup. Copy-cheap on purpose — no borrow of [`Items`] outlives
+/// the resolve.
+#[derive(Clone, Copy)]
+struct Clicked {
+    guid: u64,
+    /// `OBJECT_FIELD_ENTRY` — the ammo arm addresses by entry, not by slot (decision 0526).
+    entry: u32,
+    /// Instance `ITEM_FIELD_ITEM_TEXT_ID` (a mail-made permanent letter); 0 = not a letter.
+    item_text_id: u32,
+    inventory_type: u32,
+    display_info_id: u32,
+    start_quest: u32,
+    spell_index: u8,
+    /// `ItemInfo::unwraps_gift` for this instance — dispatcher arm #2.
+    unwraps_gift: bool,
+    /// `ItemInfo::opens_loot` for this template — dispatcher arm #8.
+    opens_loot: bool,
+}
+
 /// Drain the pick/place/swap/split moves `PickupContainerItem`/`SplitContainerItem` queued and
 /// send them on the wire (decision 0216 §6, whole-space since slice 2).
 ///
diff --git a/crates/benilla/src/ui_script/unit_popup_tests.rs b/crates/benilla/src/ui_script/unit_popup_tests.rs
index c27058df..81a54138 100644
--- a/crates/benilla/src/ui_script/unit_popup_tests.rs
+++ b/crates/benilla/src/ui_script/unit_popup_tests.rs
@@ -4,7 +4,7 @@
 //! `SetItemRef` player branch + its minimal `FriendsFrame` stand-in (`ItemRef.xml`). Proven
 //! serverless through the real hit/route paths.
 
-use benilla_ui::script::{PartyRequest, UiScript, UnitState};
+use benilla_ui::script::{FollowRequest, PartyRequest, UiScript, UnitState};
 
 fn load_xml(s: &UiScript, file: &str) {
     let text = std::fs::read_to_string(
@@ -53,6 +53,9 @@ fn bake_strings(s: &UiScript) {
         -- `Interface\FrameXML\GlobalStrings.lua:2327` off the 1.12.1 patch chain — which is what the
         -- app itself runs at boot (`load_global_strings`); this stub only stands in for it here.
         INSPECT = "Inspect"
+        -- The follow row's label (decision 0893), likewise the real
+        -- `GlobalStrings.lua:1981` value off the 1.12.1 patch chain.
+        FOLLOW = "Follow"
         CANCEL = "Cancel"
         RAID_TARGET_ICON = "Raid Target Icon"
     "#,
@@ -176,15 +179,16 @@ fn solo_target_right_click_invites_a_player() {
         s.eval::<bool>("return DropDownList1:IsVisible()").unwrap(),
         "a friendly player target opens the PLAYER menu solo"
     );
-    // title (Ally) + Whisper + Inspect + Invite + Trade + Duel + Cancel — only FOLLOW is still
-    // DEFERRED, and the raid-target submenu needs a party. (Trade came out of the deferred set in
-    // decision 0592 P1, Inspect in 0631, Duel in 0633 — Inspect precedes Invite/Trade/Duel in the
-    // reference's own PLAYER menu order, which is why every row below it sits one later than it did
-    // before 0631.)
+    // title (Ally) + Whisper + Inspect + Invite + Trade + Follow + Duel + Cancel — nothing in the
+    // PLAYER menu is DEFERRED any more, and only the raid-target submenu (which needs a party) is
+    // absent. (Trade came out of the deferred set in decision 0592 P1, Inspect in 0631, Duel in
+    // 0633, Follow in 0893 — Inspect precedes Invite/Trade/Follow/Duel in the reference's own
+    // PLAYER menu order, which is why every row below it sits one later than it did before 0631,
+    // and Duel one later again than before 0893.)
     assert_eq!(
         s.eval::<i64>("return DropDownList1.numButtons").unwrap(),
-        7,
-        "title + Whisper + Inspect + Invite + Trade + Duel + Cancel"
+        8,
+        "title + Whisper + Inspect + Invite + Trade + Follow + Duel + Cancel"
     );
     assert_eq!(
         s.eval::<String>("return DropDownList1Button3:GetText()")
@@ -204,6 +208,11 @@ fn solo_target_right_click_invites_a_player() {
     assert_eq!(
         s.eval::<String>("return DropDownList1Button6:GetText()")
             .unwrap(),
+        "Follow"
+    );
+    assert_eq!(
+        s.eval::<String>("return DropDownList1Button7:GetText()")
+            .unwrap(),
         "Duel"
     );
 
@@ -286,6 +295,73 @@ fn solo_target_trade_click_queues_an_initiate() {
     assert!(s.errors().is_empty(), "script errors: {:?}", s.errors());
 }
 
+/// Clicking the **Follow** row (un-deferred in decision 0893) through the real hit path reaches
+/// `FollowByName("Ally", 1)` — and the `1` is the point of the test, not decoration. That second
+/// argument is the resolver's exact-only flag: the menu already knows the unit's name to the
+/// letter, so unlike `/follow rag` it must not prefix-match its way onto a bystander. A dispatch
+/// that dropped the argument would still queue a follow and still look right on screen, which is
+/// exactly the kind of break a row-label assertion cannot see.
+#[test]
+fn solo_target_follow_click_queues_an_exact_by_name_follow() {
+    let mut s = UiScript::new().unwrap();
+    s.set_screen_size(1024.0, 768.0);
+    bake_strings(&s);
+    load_popup_frames(&s);
+
+    s.set_unit(
+        "player",
+        Some(UnitState {
+            exists: true,
+            name: Some("Me".into()),
+            is_player: true,
+            ..UnitState::default()
+        }),
+    );
+    s.set_unit(
+        "target",
+        Some(UnitState {
+            exists: true,
+            name: Some("Ally".into()),
+            health: 40,
+            max_health: 40,
+            is_player: true,
+            reaction: 5,
+            ..UnitState::default()
+        }),
+    );
+    s.fire_event("PLAYER_TARGET_CHANGED", vec![]);
+    s.resolve();
+    assert!(s.errors().is_empty(), "load errors: {:?}", s.errors());
+
+    let (cx, cy) = s
+        .eval::<(f64, f64)>("return BenillaTargetFrame:GetCenter()")
+        .unwrap();
+    s.mouse_button(cx as f32, cy as f32, "RightButton", true);
+    s.mouse_button(cx as f32, cy as f32, "RightButton", false);
+    s.resolve();
+    assert_eq!(
+        s.eval::<String>("return DropDownList1Button6:GetText()")
+            .unwrap(),
+        "Follow",
+        "Follow is the sixth row (title + Whisper + Inspect + Invite + Trade + Follow)"
+    );
+
+    let (fx, fy) = s
+        .eval::<(f64, f64)>("return DropDownList1Button6:GetCenter()")
+        .unwrap();
+    s.mouse_button(fx as f32, fy as f32, "LeftButton", true);
+    s.mouse_button(fx as f32, fy as f32, "LeftButton", false);
+    assert_eq!(
+        s.take_follow_requests(),
+        vec![FollowRequest::ByName {
+            name: "Ally".into(),
+            exact: true,
+        }],
+        "the popup follows by NAME and exactly — not by unit token, and not prefix-matched"
+    );
+    assert!(s.errors().is_empty(), "script errors: {:?}", s.errors());
+}
+
 /// Clicking the **Inspect** row (un-deferred in decision 0631) through the real hit path reaches
 /// `InspectUnit("target")` — the same "the row is there but the click does nothing" seam 0592 hit on
 /// Trade, which is a dispatch break (`button == "INSPECT"` never matching) that a row-label test
diff --git a/crates/benilla/src/ui_script/zone_text_tests.rs b/crates/benilla/src/ui_script/zone_text_tests.rs
index 58b8e883..0cda176b 100644
--- a/crates/benilla/src/ui_script/zone_text_tests.rs
+++ b/crates/benilla/src/ui_script/zone_text_tests.rs
@@ -325,3 +325,87 @@ fn subzone_seat_hangs_under_the_territory_line_on_new_area() {
     );
     assert!(s.errors().is_empty(), "errors: {:?}", s.errors());
 }
+
+/// `AutoFollowStatus` — the third frame in `ZoneText.xml`, and the only thing `ref-ZoneText.lua`
+/// actually contains (decision 0893). The app fires `AUTOFOLLOW_BEGIN` with the followee's name and
+/// `AUTOFOLLOW_END` with nothing; the frame does the rest.
+///
+/// The load-bearing assertion is that **END reuses the name BEGIN latched**. That is why the app
+/// gets to fire END with no argument at all, and why [`crate::player::FollowState`] latches the
+/// name at start rather than re-reading it — by the time a follow ends, the followee is often gone.
+#[test]
+fn the_autofollow_status_line_names_the_followee_and_fades_on_end() {
+    let mut s = harness();
+    assert!(
+        !visible(&s, "AutoFollowStatus"),
+        "hidden until a follow begins"
+    );
+
+    s.fire_event(
+        "AUTOFOLLOW_BEGIN",
+        vec![benilla_ui::script::ScriptValue::Str("Probeone".into())],
+    );
+    s.resolve();
+    assert!(visible(&s, "AutoFollowStatus"));
+    assert_eq!(text_of(&s, "AutoFollowStatusText"), "Following Probeone.");
+    let alpha: f32 = s.eval("return AutoFollowStatus:GetAlpha()").unwrap();
+    assert!((alpha - 1.0).abs() < 0.01, "full alpha while following");
+
+    // A follow that runs for a while must NOT fade — the fade is armed only by END, and there is
+    // no hold timer to expire (this is not the FadingFrame kit).
+    s.tick(10.0);
+    assert!(visible(&s, "AutoFollowStatus"), "no fade while following");
+    let alpha: f32 = s.eval("return AutoFollowStatus:GetAlpha()").unwrap();
+    assert!((alpha - 1.0).abs() < 0.01, "still opaque after 10 s");
+
+    // END carries no argument: the line reuses the latched name.
+    s.fire_event("AUTOFOLLOW_END", vec![]);
+    s.resolve();
+    assert_eq!(
+        text_of(&s, "AutoFollowStatusText"),
+        "You stop following Probeone.",
+        "END has no argument of its own — the name comes from what BEGIN latched"
+    );
+    // A linear 4 s fade, no hold: half gone at 2 s, hidden past 4.
+    s.tick(2.0);
+    let alpha: f32 = s.eval("return AutoFollowStatus:GetAlpha()").unwrap();
+    assert!((alpha - 0.5).abs() < 0.05, "mid-fade alpha, got {alpha}");
+    s.tick(2.5);
+    assert!(!visible(&s, "AutoFollowStatus"), "gone after the 4 s fade");
+    assert!(s.errors().is_empty(), "errors: {:?}", s.errors());
+}
+
+/// A follow that switches subject fires `BEGIN` alone (see `crate::ui_follow`'s header). The
+/// reference's own handler treats BEGIN as a full reset — it clears `fadeTime`, restores alpha and
+/// re-shows — so a switch made *during* the end-fade must come back to a clean, opaque line rather
+/// than inheriting the dying one's alpha.
+#[test]
+fn a_begin_during_the_end_fade_resets_the_line() {
+    let mut s = harness();
+    s.fire_event(
+        "AUTOFOLLOW_BEGIN",
+        vec![benilla_ui::script::ScriptValue::Str("Probeone".into())],
+    );
+    s.fire_event("AUTOFOLLOW_END", vec![]);
+    s.tick(3.0); // most of the way through the fade
+    let faded: f32 = s.eval("return AutoFollowStatus:GetAlpha()").unwrap();
+    assert!(faded < 0.4, "mid-fade, got {faded}");
+
+    s.fire_event(
+        "AUTOFOLLOW_BEGIN",
+        vec![benilla_ui::script::ScriptValue::Str("Probetwo".into())],
+    );
+    s.resolve();
+    assert_eq!(text_of(&s, "AutoFollowStatusText"), "Following Probetwo.");
+    let alpha: f32 = s.eval("return AutoFollowStatus:GetAlpha()").unwrap();
+    assert!(
+        (alpha - 1.0).abs() < 0.01,
+        "BEGIN restores alpha, got {alpha}"
+    );
+    s.tick(10.0);
+    assert!(
+        visible(&s, "AutoFollowStatus"),
+        "and clears the pending fade rather than letting it finish"
+    );
+    assert!(s.errors().is_empty(), "errors: {:?}", s.errors());
+}