diff --git a/crates/benilla-app/assets/ui/OptionsFrame.xml b/crates/benilla-app/assets/ui/OptionsFrame.xml
index 3c13d6d0..ccc06b66 100644
--- a/crates/benilla-app/assets/ui/OptionsFrame.xml
+++ b/crates/benilla-app/assets/ui/OptionsFrame.xml
@@ -438,7 +438,7 @@
             Controls = {
                 "RowStickyTarget", "RowAssistAttack", "RowClearAFK",
                 "RowBlockTrades", "RowAutoSelfCast",
-                "RowAutoLoot", "RowInvertMouse", "RowMouseSpeed",
+                "RowAutoLoot", "RowInvertMouse", "RowMouseSpeed", "RowClickToMove",
                 "RowCameraFollowStyle", "RowFollowTerrain", "RowHeadBob",
                 "RowAutoFollowSpeed", "RowWaterCollision", "RowSmartPivot",
                 "RowMouseLookSpeed", "RowMaxCameraDistance",
@@ -1614,12 +1614,21 @@
                                                 BenillaOptionsSliderRow_Setup(this, 0.5, 1.5, 0.05)
                                             </OnLoad></Scripts>
                                         </Frame>
+                                        <!-- 1.12's box sits under the mouse slider. -->
+                                        <Frame name="$parentRowClickToMove" inherits="BenillaOptionsCheckboxRowTemplate">
+                                            <Anchors>
+                                                <Anchor point="TOPLEFT" relativeTo="$parentRowMouseSpeed" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                                <Anchor point="TOPRIGHT" relativeTo="$parentRowMouseSpeed" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                            </Anchors>
+                                            <Scripts><OnLoad>BenillaOptionsRow_OnLoad(this, "autointeract", "Click-to-Move",
+                                                "OPTION_TOOLTIP_CLICK_TO_MOVE")</OnLoad></Scripts>
+                                        </Frame>
                                         <!-- Smart 1, Always 2, Never 0 (UIOptionsFrame.lua:525,
                                              536, 547). -->
                                         <Frame name="$parentRowCameraFollowStyle" inherits="BenillaOptionsDropdownRowTemplate">
                                             <Anchors>
-                                                <Anchor point="TOPLEFT" relativeTo="$parentRowMouseSpeed" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
-                                                <Anchor point="TOPRIGHT" relativeTo="$parentRowMouseSpeed" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                                <Anchor point="TOPLEFT" relativeTo="$parentRowClickToMove" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                                <Anchor point="TOPRIGHT" relativeTo="$parentRowClickToMove" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
                                             </Anchors>
                                             <Scripts><OnLoad>
                                                 BenillaOptionsRow_OnLoad(this, "cameraSmoothStyle",
diff --git a/crates/benilla-app/src/cvars/table.rs b/crates/benilla-app/src/cvars/table.rs
index 59a22702..891fccfa 100644
--- a/crates/benilla-app/src/cvars/table.rs
+++ b/crates/benilla-app/src/cvars/table.rs
@@ -203,6 +203,9 @@ pub(crate) const REGISTERED: &[Registered] = &[
     // `deselectOnClick` and `mouseInvertPitch` are 1.12's own (`UIOptionsFrame.lua:8,4`);
     // `autoLootDefault` is the later-era name, 1.12 having only the shift gesture.
     same("deselectOnClick", "1"),
+    // `AutoInteract` (`0x603390`, record `[0xc4d9a4]`), Click-to-Move (`UIOptionsFrame.lua:7`):
+    // "1" on koKR alone (`0x603368`). The knob is [`crate::player::Approach`].
+    same("AutoInteract", "0"),
     // `BlockTrades` (`0x842fbc`), `UIOptionsFrame.lua:11`: the refusal leg `0x4bf7bc` fires only
     // when it is set. The knob is [`crate::ui_trade::BlockTrades`].
     same("BlockTrades", "0"),
diff --git a/crates/benilla-app/src/game_plugins.rs b/crates/benilla-app/src/game_plugins.rs
index 7486a11f..aa83695c 100644
--- a/crates/benilla-app/src/game_plugins.rs
+++ b/crates/benilla-app/src/game_plugins.rs
@@ -675,12 +675,18 @@ pub(crate) mod schedule_tests {
     ///   release, `transport::compose_riders` and `ground_deck_riders`): the readers take the
     ///   movement flags of the caster (`Player::move_flags`) and its target
     ///   (`RemoteMotion::flags`), and those writers touch `login_pitch`, the settle fields and a
-    ///   rider's pose, never the flags.
+    ///   rider's pose, never the flags;
+    /// - Click to Move's steer and arrival (`player::approach::steer_approach`,
+    ///   `target::click::act_on_arrival`) against what `steer_follow` and `act_on_right_click`
+    ///   already pair with: the steer is chained after follow's and writes the same `Player`
+    ///   fields, the arrival runs the click's dispatchers, and their `Transform` reads are the
+    ///   disjoint-lane kind. The dispatchers also carry the walk's start (`Player`,
+    ///   `FollowState`, `Approach`, the stand request), which only a click or an arrival writes.
     ///
     /// Raising the ceiling is a claim that a new undeclared order is acceptable: make it with the
     /// reason read off the dump, or declare the order (`.after`, a set, a `chain`). A resource
     /// that commutes by construction belongs in [`Classes`].
-    const UPDATE_ACTIONABLE_CEILING: usize = 4_860;
+    const UPDATE_ACTIONABLE_CEILING: usize = 4_930;
     const UPDATE_ACTIONABLE_SLACK: usize = 40;
 
     fn ratchet(what: &str, n: usize, ceiling: usize, slack: usize) {
diff --git a/crates/benilla-app/src/player.rs b/crates/benilla-app/src/player.rs
index 53186fb9..8fe96be4 100644
--- a/crates/benilla-app/src/player.rs
+++ b/crates/benilla-app/src/player.rs
@@ -23,6 +23,7 @@ use benilla_assets::AssetSet;
 use benilla_world::interact::{WorldClick, WorldRightClick};
 use benilla_world::schedule::WorldStage;
 
+mod approach;
 mod arc;
 mod net;
 // Writes the frame onto the body we drive: pose, `MovementState`, the counter-twist gap.
@@ -77,6 +78,11 @@ use camera_zoom::{apply_zoom_scroll, CAM_DIST_DEFAULT};
 // `/follow`: chat sends the request, `crate::target` resolves the subject into the state, and
 // `follow` owns the motion.
 pub(crate) use follow::{FollowRequest, FollowState};
+// Click to Move: `crate::target`'s dispatchers start it and run the verb it owes on arrival.
+pub(crate) use approach::{
+    can_auto_interact, Approach, ApproachVerb, AutoMove, Refused, Subject, RANGE_STOP_FRACTION,
+    TALK_STOP,
+};
 use state::{
     MoveSpeed, PlayerRide, AIR_NUDGE_SPEED, FALL_FAR_DROP, FALL_FAR_TIME, FOOT_CONE_HEIGHT,
     GROUND_COS, GROUND_PROBE, JUMP_SPEED, LAND_PROBE, MOUSELOOK_PITCH_CLAMP, RUN_BACK_RATIO,
@@ -205,6 +211,7 @@ impl Plugin for PlayerPlugin {
     fn build(&self, app: &mut App) {
         net::register(app);
         follow::plugin(app);
+        approach::plugin(app);
         camera_saved::plugin(app);
         camera_view::plugin(app);
         // The stream focus is published after `control`'s teleport snap and before the stream
@@ -339,11 +346,12 @@ impl Plugin for PlayerPlugin {
                 .run_if(not(resource_exists::<crate::run_mode::CaptureMode>))
                 .in_set(crate::char_select::InWorldGated),
         )
-        // `/follow` steers before `control`, so the player's own turn input lands after it and
-        // wins over the follow's steering.
+        // `/follow` and Click to Move steer before `control`, so the player's own turn input
+        // lands after them and wins over their steering.
         .add_systems(
             Update,
-            follow::steer_follow
+            (follow::steer_follow, approach::steer_approach)
+                .chain()
                 .in_set(WorldStage::Input)
                 .before(control)
                 .in_set(crate::char_select::InWorldGated),
diff --git a/crates/benilla-app/src/player/approach.rs b/crates/benilla-app/src/player/approach.rs
new file mode 100644
index 00000000..c9cea014
--- /dev/null
+++ b/crates/benilla-app/src/player/approach.rs
@@ -0,0 +1,587 @@
+//! Click to Move's approach (`AutoInteract`, "Toggles auto-move to interact target"): with the
+//! option on, a right-click on an NPC, a body to loot or skin, or a GameObject beyond the verb's
+//! reach walks the player there, and the verb runs on arrival. It is [`super::follow`]'s auto-move:
+//! one cell holds either (mode `0xc4d888`, guid `0xc4d980`), so arming one ends the other
+//! (`0x611130` calls the canceller `0x60fb60` first), the same input cancels both, and nothing goes
+//! on the wire but the movement. The terrain and sky walks (modes 4, 8) and the attack approach
+//! (mode 10) are not built.
+
+use std::f32::consts::PI;
+
+use bevy::ecs::system::SystemParam;
+use bevy::prelude::*;
+
+use benilla_protocol::EntityKind;
+
+use crate::net::{Embodied, Guid, GuidIndex, NetEntity, ObjectStore, SelfPlayer, UnitSpeeds};
+
+use super::follow::{self, FollowInput, FollowState};
+use super::state::Player;
+
+/// The verb an approach owes, by its mode in `0xc4d888`; the pending dispatcher `0x60fa20` runs it
+/// at the stop.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(crate) enum ApproachVerb {
+    /// Mode 5: the NPC-service dispatch `0x5f0130`.
+    Talk,
+    /// Mode 6: the unit loot `0x5df2a0`.
+    Loot,
+    /// Mode 7: the GameObject use `0x5f86b0`.
+    Use,
+    /// Mode 9: the skin cast `0x5f05e0`.
+    Skin,
+}
+
+/// What the start gate (`0x60fed0`) checks the target for.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(crate) enum Subject {
+    Unit { dead: bool },
+    Corpse,
+    GameObject,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(crate) enum Refused {
+    Silent,
+    /// `ERR_AUTOFOLLOW_TOO_FAR` (`0x126`, `0x61110c`).
+    TooFar,
+}
+
+/// Talk stops at half the 5.5556 yd service reach (`0x60e680`).
+pub(crate) const TALK_STOP: f32 = 5.555_555_3 * 0.5;
+/// Use and Skin stop at this fraction of the verb's range (`0x804588`).
+pub(crate) const RANGE_STOP_FRACTION: f32 = 0.9;
+/// No approach starts or lasts at 80 yd or more: modes 5-10's row in `0x860a58` (`0x60e5d1`).
+const LEASH_SQ: f32 = 6400.0;
+/// Within this many yards on the ground the goal's height is ignored (`0x80c4c8`).
+const FLAT_SNAP: f32 = 0.5;
+/// `automoveturnspeednarrow` and `automoveturnspeedwide`, deg/s (`0x6039e9`, `0x6039ca`).
+const TURN_NARROW: f32 = 800.0;
+const TURN_WIDE: f32 = 1200.0;
+/// Less ground than this in a frame while lined up and holding forward is stuck (`0x80c4dc`).
+const STUCK: f32 = 1.0 / 360.0;
+
+/// The approach in flight, and the verb an arrival owes.
+#[derive(Resource, Default)]
+pub(crate) struct Approach {
+    /// `AutoInteract`, `CanAutoInteract`'s last term (`0x60f925`).
+    pub(crate) enabled: bool,
+    goal: Option<Goal>,
+    /// The pending cells `0x60f940` fills (`0xc4da28`, `0xc4da78`, `0xc4d950`, `0xc4da20`).
+    pub(crate) arrived: Option<(ApproachVerb, u64)>,
+}
+
+struct Goal {
+    verb: ApproachVerb,
+    guid: u64,
+    /// `0xc4d910`.
+    stop: f32,
+    /// Latched by the first turn (`0x61042c`).
+    turn_rate: Option<f32>,
+    /// Bit 1 of `0xc4da48`: the facing has lined up once.
+    aligned: bool,
+    /// Last frame's position (`0xc4da84`).
+    last_pos: Vec3,
+    held: bool,
+}
+
+impl Approach {
+    /// The reference's `0x6103a0` for this mode family: an approach is in flight.
+    pub(crate) fn active(&self) -> bool {
+        self.goal.is_some()
+    }
+
+    pub(crate) fn stop(&mut self) {
+        self.goal = None;
+    }
+
+    #[cfg(test)]
+    pub(crate) fn stop_distance(&self) -> Option<f32> {
+        self.goal.as_ref().map(|g| g.stop)
+    }
+}
+
+/// `CanAutoInteract` (`0x60f900`): alive, driving our own body, and the option on.
+pub(crate) fn can_auto_interact(enabled: bool, me: Option<&ObjectStore>, player: &Player) -> bool {
+    enabled
+        && me.is_some_and(|s| s.0.unit_health().unwrap_or(0) > 0)
+        && player.foreign_mover.is_none()
+        && !player.control_lost
+}
+
+/// The start: the gate (`0x60fed0`, `0x610300`) and the arm `0x611130`.
+#[derive(SystemParam)]
+pub(crate) struct AutoMove<'w, 's> {
+    pub(crate) approach: ResMut<'w, Approach>,
+    follow: ResMut<'w, FollowState>,
+    player: Res<'w, Player>,
+    me: Query<'w, 's, (&'static Guid, &'static ObjectStore), With<SelfPlayer>>,
+    stand: MessageWriter<'w, super::StandStateRequest>,
+}
+
+impl AutoMove<'_, '_> {
+    pub(crate) fn can_auto_interact(&self) -> bool {
+        can_auto_interact(
+            self.approach.enabled,
+            self.me.single().ok().map(|(_, s)| s),
+            &self.player,
+        )
+    }
+
+    pub(crate) fn start(
+        &mut self,
+        verb: ApproachVerb,
+        guid: u64,
+        subject: Subject,
+        at: Vec3,
+        stop: f32,
+    ) -> Result<(), Refused> {
+        let Ok((me, store)) = self.me.single() else {
+            return Err(Refused::Silent);
+        };
+        let admitted = match (verb, subject) {
+            (ApproachVerb::Talk, Subject::Unit { .. }) => true,
+            (ApproachVerb::Loot | ApproachVerb::Skin, Subject::Corpse) => true,
+            (ApproachVerb::Loot | ApproachVerb::Skin, Subject::Unit { dead }) => dead,
+            (ApproachVerb::Use, Subject::GameObject) => true,
+            _ => false,
+        };
+        if !admitted
+            || guid == me.0
+            || self.player.foreign_mover.is_some()
+            || self.player.control_lost
+            || store.0.unit_health().unwrap_or(0) == 0
+        {
+            return Err(Refused::Silent);
+        }
+        let standing = store.0.unit_stand_state() == 0;
+        self.follow.stop();
+        self.approach.stop();
+        if self.player.pos.distance_squared(at) >= LEASH_SQ {
+            return Err(Refused::TooFar);
+        }
+        info!("approach: {verb:?} {guid:#x}, stopping {stop:.2} yd short");
+        self.approach.goal = Some(Goal {
+            verb,
+            guid,
+            stop,
+            turn_rate: None,
+            aligned: false,
+            last_pos: self.player.pos,
+            held: false,
+        });
+        if !standing {
+            self.stand.write(super::StandStateRequest { state: 0 });
+        }
+        Ok(())
+    }
+}
+
+fn speed_scale(speed: f32) -> f32 {
+    (speed / follow::SPEED_NORM).max(1.0)
+}
+
+/// The goal distance, squared (`0x610e40`'s tail): on the ground alone once inside the snap
+/// radius, unless swimming. Talk's radius never scales with speed.
+fn goal_distance_sq(verb: ApproachVerb, delta: Vec3, speed: f32, swimming: bool) -> f32 {
+    let snap = if verb == ApproachVerb::Talk {
+        FLAT_SNAP
+    } else {
+        FLAT_SNAP * speed_scale(speed)
+    };
+    let flat = delta.x * delta.x + delta.z * delta.z;
+    if !swimming && flat <= snap * snap {
+        flat
+    } else {
+        delta.length_squared()
+    }
+}
+
+/// The arrive distance (`0x610add`-`0x610b07`): the stop distance scaled by the mover's current
+/// speed over 7 (`0x7c4c90`, 0 at rest), never below 1×; Talk's is never scaled.
+fn arrive_distance(verb: ApproachVerb, stop: f32, speed: f32) -> f32 {
+    if verb == ApproachVerb::Talk {
+        stop
+    } else {
+        stop * speed_scale(speed)
+    }
+}
+
+/// The rate the first turn latches, rad/s: wide for a turn of more than 120° (`0x61043f`).
+fn turn_rate(remaining: f32) -> f32 {
+    let deg = if remaining.abs() > 2.0 * PI / 3.0 {
+        TURN_WIDE
+    } else {
+        TURN_NARROW
+    };
+    deg.to_radians()
+}
+
+/// Steer toward the goal and hold forward; on arrival face it and owe its verb. After
+/// [`follow::steer_follow`], which clears [`Player::auto_forward`].
+pub(super) fn steer_approach(
+    time: Res<Time>,
+    mut approach: ResMut<Approach>,
+    mut player: ResMut<Player>,
+    mover: Query<&UnitSpeeds, With<Embodied>>,
+    index: Res<GuidIndex>,
+    targets: Query<(&Transform, Option<&ObjectStore>, Option<&NetEntity>)>,
+    input: FollowInput,
+) {
+    let Some(goal) = approach.goal.as_mut() else {
+        return;
+    };
+    // `GetCurrentSpeed` on last frame's word, as the reference reads the mover's own.
+    let speed = mover
+        .single()
+        .map_or(0.0, |s| crate::net::current_speed(&s.0, player.move_flags));
+    if input.cancels(&player) {
+        info!("approach: cancelled by the player's own movement input");
+        approach.stop();
+        return;
+    }
+    let Some((tf, store, kind)) = index.0.get(&goal.guid).and_then(|e| targets.get(*e).ok()) else {
+        info!("approach: the target is gone");
+        approach.stop();
+        return;
+    };
+    // `0x610f13`-`0x610f40`: a unit on a taxi ends it, a dead one too unless the verb wants a body.
+    if kind.is_some_and(|k| matches!(k.kind, EntityKind::Unit | EntityKind::Player)) {
+        let store = store.map(|s| &s.0);
+        let taxi = store.is_some_and(|s| s.unit_flags() & super::UNIT_FLAG_TAXI_FLIGHT != 0);
+        let dead = store.is_none_or(|s| s.unit_health().unwrap_or(0) == 0);
+        if taxi || (dead && !matches!(goal.verb, ApproachVerb::Loot | ApproachVerb::Skin)) {
+            info!("approach: the target left reach (taxi {taxi}, dead {dead})");
+            approach.stop();
+            return;
+        }
+    }
+    let target = tf.translation;
+    let delta = target - player.pos;
+    let d2 = goal_distance_sq(goal.verb, delta, speed, player.swimming);
+    if d2 >= LEASH_SQ {
+        info!("approach: beyond 80 yd");
+        approach.stop();
+        return;
+    }
+    // `0x61073c`: once lined up, a frame that ends farther off than the last aborts, but not Talk.
+    if goal.aligned
+        && goal.verb != ApproachVerb::Talk
+        && goal.last_pos.distance_squared(target) < player.pos.distance_squared(target)
+    {
+        info!("approach: no longer closing");
+        approach.stop();
+        return;
+    }
+    let flat = Vec3::new(delta.x, 0.0, delta.z);
+    let bearing = follow::bearing_to(flat);
+    let remaining = follow::wrap_pi(bearing - player.face_yaw);
+    let turning = remaining.abs() > follow::TURN_DEADZONE;
+    if turning {
+        let rate = *goal.turn_rate.get_or_insert_with(|| turn_rate(remaining));
+        player.face_yaw = follow::steer(player.face_yaw, bearing, rate, time.delta_secs());
+    } else {
+        goal.aligned = true;
+    }
+    let arrive = arrive_distance(goal.verb, goal.stop, speed);
+    if d2 <= arrive * arrive {
+        info!("approach: arrived at {:.2} yd", d2.sqrt());
+        // The arrival's canceller faces the target (`0x60fbe8`).
+        if flat.length_squared() > f32::EPSILON {
+            player.face_yaw = bearing;
+        }
+        approach.arrived = Some((goal.verb, goal.guid));
+        approach.goal = None;
+        return;
+    }
+    // Rooted, the reference lets go of forward (`0x610b4a`), which also spares the stuck test.
+    let hold = !player.modes.rooted;
+    if !turning && goal.held && player.pos.distance_squared(goal.last_pos) < STUCK * STUCK {
+        info!("approach: stuck");
+        approach.stop();
+        return;
+    }
+    if follow::vertically_degenerate(delta) {
+        info!("approach: the target is straight overhead");
+        approach.stop();
+        return;
+    }
+    goal.last_pos = player.pos;
+    goal.held = hold;
+    player.auto_forward = hold;
+}
+
+fn on_cvar(ev: On<crate::cvars::CvarChanged>, mut approach: ResMut<Approach>) {
+    if ev.is("AutoInteract") {
+        approach.enabled = ev.flag();
+    }
+}
+
+pub(super) fn plugin(app: &mut App) {
+    app.init_resource::<Approach>().add_observer(on_cvar);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::state::MoveSpeed;
+    use super::*;
+    use benilla_protocol::messages::ObjectFields;
+    use bevy::ecs::system::RunSystemOnce;
+
+    #[test]
+    fn talk_stops_inside_the_service_reach_and_never_scales() {
+        assert!((TALK_STOP - 2.777_777_7).abs() < 1e-5);
+        assert_eq!(
+            arrive_distance(ApproachVerb::Talk, TALK_STOP, 14.0),
+            TALK_STOP
+        );
+        assert_eq!(arrive_distance(ApproachVerb::Loot, 5.0, 7.0), 5.0);
+        assert_eq!(arrive_distance(ApproachVerb::Loot, 5.0, 14.0), 10.0);
+        assert_eq!(arrive_distance(ApproachVerb::Use, 5.0, 3.5), 5.0);
+        assert_eq!(arrive_distance(ApproachVerb::Use, 5.0, 0.0), 5.0, "at rest");
+    }
+
+    #[test]
+    fn the_goal_flattens_only_inside_the_snap_radius() {
+        let above = Vec3::new(0.3, 4.0, 0.3);
+        assert!((goal_distance_sq(ApproachVerb::Use, above, 7.0, false) - 0.18).abs() < 1e-5);
+        assert!((goal_distance_sq(ApproachVerb::Use, above, 7.0, true) - 16.18).abs() < 1e-4);
+        let far = Vec3::new(3.0, 4.0, 0.0);
+        assert_eq!(goal_distance_sq(ApproachVerb::Use, far, 7.0, false), 25.0);
+    }
+
+    const ME: u64 = 0x1;
+    const VENDOR: u64 = 0xF00D;
+    const DT: f32 = 1.0 / 60.0;
+
+    /// Our body at the origin facing -Z, alive (and seated when `stand_state` is set), a vendor at
+    /// `at`, and both steers chained as the plugin runs them.
+    fn world(at: Vec3, stand_state: u32) -> App {
+        let mut app = App::new();
+        app.init_resource::<Time>()
+            .init_resource::<Approach>()
+            .init_resource::<FollowState>()
+            .init_resource::<Player>()
+            .init_resource::<GuidIndex>()
+            .init_resource::<ButtonInput<MouseButton>>()
+            .init_resource::<crate::bindings::BindingsState>()
+            .init_resource::<super::super::camera::CameraControl>()
+            .init_resource::<super::super::view_subject::ViewSubject>()
+            .insert_resource(MoveSpeed {
+                value: 7.0,
+                env_override: false,
+            })
+            .add_message::<super::super::StandStateRequest>()
+            .add_systems(Update, (follow::steer_follow, steer_approach).chain());
+        app.world_mut().resource_mut::<Approach>().enabled = true;
+        app.world_mut().spawn((
+            SelfPlayer,
+            Guid(ME),
+            ObjectStore(ObjectFields::from_pairs(&[
+                (22, 100),
+                (28, 100),
+                (138, stand_state),
+            ])),
+        ));
+        let vendor = app
+            .world_mut()
+            .spawn((Guid(VENDOR), Transform::from_translation(at)))
+            .id();
+        app.world_mut()
+            .resource_mut::<GuidIndex>()
+            .0
+            .insert(VENDOR, vendor);
+        app
+    }
+
+    fn start(app: &mut App, verb: ApproachVerb, subject: Subject, at: Vec3) -> Result<(), Refused> {
+        app.world_mut()
+            .run_system_once(move |mut auto: AutoMove| {
+                auto.start(verb, VENDOR, subject, at, TALK_STOP)
+            })
+            .unwrap()
+    }
+
+    /// One frame: the steers, then the controller's walk along the facing while forward is held.
+    fn frame(app: &mut App, walks: bool) {
+        app.world_mut()
+            .resource_mut::<Time>()
+            .advance_by(std::time::Duration::from_secs_f32(DT));
+        app.update();
+        let mut player = app.world_mut().resource_mut::<Player>();
+        if walks && player.auto_forward {
+            let forward = Quat::from_rotation_y(player.face_yaw) * Vec3::NEG_Z;
+            player.pos += forward * 7.0 * DT;
+        }
+    }
+
+    #[test]
+    fn a_vendor_out_of_reach_is_walked_to_and_owed_the_talk() {
+        let at = Vec3::new(14.0, 0.0, 0.0);
+        let mut app = world(at, 0);
+        assert_eq!(
+            start(
+                &mut app,
+                ApproachVerb::Talk,
+                Subject::Unit { dead: false },
+                at
+            ),
+            Ok(())
+        );
+        frame(&mut app, true);
+        assert!(
+            app.world().resource::<Player>().auto_forward,
+            "forward from the first frame"
+        );
+        let mut frames = 1;
+        while app.world().resource::<Approach>().arrived.is_none() {
+            assert!(frames < 300, "never arrived");
+            frame(&mut app, true);
+            frames += 1;
+        }
+        let player = app.world().resource::<Player>();
+        let left = player.pos.distance(at);
+        assert!(
+            left <= TALK_STOP && left > TALK_STOP - 7.0 * DT - 1e-3,
+            "stopped {left} yd off, not at the 2.78 yd stop"
+        );
+        assert!(!player.auto_forward, "forward let go at the stop");
+        assert!(
+            (follow::wrap_pi(player.face_yaw - follow::bearing_to(at - player.pos))).abs() < 1e-4,
+            "facing the vendor"
+        );
+        let approach = app.world().resource::<Approach>();
+        assert_eq!(approach.arrived, Some((ApproachVerb::Talk, VENDOR)));
+        assert!(!approach.active());
+    }
+
+    #[test]
+    fn the_arm_ends_a_follow_and_refuses_past_80_yards() {
+        let near = Vec3::new(14.0, 0.0, 0.0);
+        let mut app = world(near, 0);
+        app.world_mut()
+            .resource_mut::<FollowState>()
+            .start(0xBEEF, "Friend".into());
+        assert_eq!(
+            start(
+                &mut app,
+                ApproachVerb::Talk,
+                Subject::Unit { dead: false },
+                near
+            ),
+            Ok(())
+        );
+        assert!(
+            app.world().resource::<FollowState>().guid.is_none(),
+            "one auto-move cell"
+        );
+
+        let far = Vec3::new(80.0, 0.0, 0.0);
+        assert_eq!(
+            start(
+                &mut app,
+                ApproachVerb::Talk,
+                Subject::Unit { dead: false },
+                far
+            ),
+            Err(Refused::TooFar)
+        );
+        assert!(
+            !app.world().resource::<Approach>().active(),
+            "the arm cancelled the last walk"
+        );
+    }
+
+    #[test]
+    fn the_gate_admits_each_verb_its_own_kind_of_target() {
+        let at = Vec3::new(14.0, 0.0, 0.0);
+        let mut app = world(at, 0);
+        for (verb, subject, ok) in [
+            (ApproachVerb::Talk, Subject::Unit { dead: false }, true),
+            (ApproachVerb::Talk, Subject::GameObject, false),
+            (ApproachVerb::Loot, Subject::Unit { dead: true }, true),
+            (ApproachVerb::Loot, Subject::Unit { dead: false }, false),
+            (ApproachVerb::Loot, Subject::Corpse, true),
+            (ApproachVerb::Skin, Subject::Unit { dead: false }, false),
+            (ApproachVerb::Use, Subject::GameObject, true),
+            (ApproachVerb::Use, Subject::Unit { dead: false }, false),
+        ] {
+            let got = start(&mut app, verb, subject, at);
+            assert_eq!(got.is_ok(), ok, "{verb:?} at {subject:?}: {got:?}");
+        }
+    }
+
+    #[test]
+    fn a_seated_player_stands_to_walk() {
+        let at = Vec3::new(14.0, 0.0, 0.0);
+        let mut app = world(at, 1);
+        assert_eq!(
+            start(
+                &mut app,
+                ApproachVerb::Talk,
+                Subject::Unit { dead: false },
+                at
+            ),
+            Ok(())
+        );
+        let asks: Vec<u8> = app
+            .world_mut()
+            .resource_mut::<Messages<super::super::StandStateRequest>>()
+            .drain()
+            .map(|m| m.state)
+            .collect();
+        assert_eq!(asks, vec![0]);
+    }
+
+    #[test]
+    fn the_players_own_movement_cancels_the_walk() {
+        let at = Vec3::new(14.0, 0.0, 0.0);
+        let mut app = world(at, 0);
+        assert_eq!(
+            start(
+                &mut app,
+                ApproachVerb::Talk,
+                Subject::Unit { dead: false },
+                at
+            ),
+            Ok(())
+        );
+        frame(&mut app, true);
+        app.world_mut()
+            .resource_mut::<ButtonInput<MouseButton>>()
+            .press(MouseButton::Forward);
+        frame(&mut app, true);
+        let approach = app.world().resource::<Approach>();
+        assert!(!approach.active() && approach.arrived.is_none());
+    }
+
+    #[test]
+    fn a_walk_that_cannot_move_gives_up_once_lined_up() {
+        let at = Vec3::new(14.0, 0.0, 0.0);
+        let mut app = world(at, 0);
+        assert_eq!(
+            start(&mut app, ApproachVerb::Use, Subject::GameObject, at),
+            Ok(())
+        );
+        frame(&mut app, false);
+        frame(&mut app, false);
+        assert!(
+            app.world().resource::<Approach>().active(),
+            "still turning, where standing still is not stuck"
+        );
+        for _ in 0..60 {
+            frame(&mut app, false);
+        }
+        let approach = app.world().resource::<Approach>();
+        assert!(!approach.active(), "stuck against a wall");
+        assert!(approach.arrived.is_none(), "nothing owed");
+    }
+
+    #[test]
+    fn the_first_turn_picks_the_wide_rate_past_120_degrees() {
+        assert_eq!(turn_rate(0.5), 800f32.to_radians());
+        assert_eq!(turn_rate(-2.0 * PI / 3.0), 800f32.to_radians());
+        assert_eq!(turn_rate(2.2), 1200f32.to_radians());
+        assert_eq!(turn_rate(-PI), 1200f32.to_radians());
+    }
+}
diff --git a/crates/benilla-app/src/player/embody.rs b/crates/benilla-app/src/player/embody.rs
index 26284af0..e63f5098 100644
--- a/crates/benilla-app/src/player/embody.rs
+++ b/crates/benilla-app/src/player/embody.rs
@@ -15,6 +15,7 @@
 
 use bevy::prelude::*;
 
+use super::approach::Approach;
 use super::follow::FollowState;
 use super::state::Player;
 use crate::creature_anim::MovementState;
@@ -26,6 +27,7 @@ pub(super) fn maintain_embodiment(
     mut commands: Commands,
     mut player: ResMut<Player>,
     mut follow: ResMut<FollowState>,
+    mut approach: ResMut<Approach>,
     guids: (Res<SelfGuid>, Res<GuidIndex>),
     self_body: Query<Entity, With<SelfPlayer>>,
     attached: Query<Entity, With<Embodied>>,
@@ -49,6 +51,7 @@ pub(super) fn maintain_embodiment(
             // `SetActiveMover` `0x6006e0` cancels click-to-move and follow on the outgoing mover,
             // through `0x6103a0` → `0x60fb60(0, 1)`.
             follow.stop();
+            approach.stop();
         }
     }
 
@@ -91,6 +94,7 @@ mod tests {
         let mut app = App::new();
         app.init_resource::<Player>()
             .init_resource::<FollowState>()
+            .init_resource::<Approach>()
             .init_resource::<SelfGuid>()
             .init_resource::<GuidIndex>()
             .add_systems(Update, maintain_embodiment);
diff --git a/crates/benilla-app/src/player/follow.rs b/crates/benilla-app/src/player/follow.rs
index c28d5c11..e539346d 100644
--- a/crates/benilla-app/src/player/follow.rs
+++ b/crates/benilla-app/src/player/follow.rs
@@ -7,7 +7,7 @@
 //! A player's movement start cancels it on the key-down edge: the start emitters call `0x60e990`,
 //! which cancels at `0x60e9b5` unless bit 0 of `ds:0xc4da48` is set, and only follow's own emitters
 //! (`0x60e790`, `0x60e7f0`, `0x60e8a0`, `0x60e940`) set it; ours is a flag,
-//! [`Player::follow_forward`], so it never reaches the cancel. Jump survives (`0x60e990(0, 0)` at
+//! [`Player::auto_forward`], so it never reaches the cancel. Jump survives (`0x60e990(0, 0)` at
 //! `0x60dea8`), as do key releases, sitting, the walk toggle, damage, combat, mounting, casting and
 //! the followee leaving range (`0x6107e5` skips follow's mode at `0x610749`, `0x610752`).
 //!
@@ -29,10 +29,10 @@ use super::state::{MoveSpeed, Player};
 const TURN_RATE: f32 = PI;
 
 /// Inside this many radians of the bearing, follow stops turning (`0x6108bb` → `0x60e920`).
-const TURN_DEADZONE: f32 = 0.001;
+pub(super) const TURN_DEADZONE: f32 = 0.001;
 
 /// The speed the thresholds scale by (`0x80c4d0`), the base run speed.
-const SPEED_NORM: f32 = 7.0;
+pub(super) const SPEED_NORM: f32 = 7.0;
 
 /// The base stop distance (`0x80c4c0`), a constant, not a CVar.
 const STOP_DISTANCE: f32 = 3.0;
@@ -116,7 +116,7 @@ fn follow_cancelled(
 }
 
 /// Wrap an angle into `[-π, π)`.
-fn wrap_pi(a: f32) -> f32 {
+pub(super) fn wrap_pi(a: f32) -> f32 {
     let t = std::f32::consts::TAU;
     let x = (a + PI).rem_euclid(t);
     x - PI
@@ -124,23 +124,23 @@ fn wrap_pi(a: f32) -> f32 {
 
 /// The `face_yaw` pointing at a horizontal Bevy-space delta, matching `control`'s forward
 /// `from_rotation_y(y) * NEG_Z = (-sin y, 0, -cos y)`: `y = atan2(-dx, -dz)`.
-fn bearing_to(delta: Vec3) -> f32 {
+pub(super) fn bearing_to(delta: Vec3) -> f32 {
     (-delta.x).atan2(-delta.z)
 }
 
 /// The followee is within 1° of straight up or down, where the bearing means nothing (`0x610d32`).
-fn vertically_degenerate(delta: Vec3) -> bool {
+pub(super) fn vertically_degenerate(delta: Vec3) -> bool {
     let dist = delta.length();
     dist > f32::EPSILON && delta.y.abs() / dist > VERTICAL_ALIGN_COS
 }
 
 /// Turn toward `bearing` by at most `rate × dt`, not inside the deadzone (`0x6103d0`).
-fn steer(face: f32, bearing: f32, dt: f32) -> f32 {
+pub(super) fn steer(face: f32, bearing: f32, rate: f32, dt: f32) -> f32 {
     let remaining = wrap_pi(bearing - face);
     if remaining.abs() <= TURN_DEADZONE {
         return face;
     }
-    let budget = TURN_RATE * dt;
+    let budget = rate * dt;
     face + remaining.clamp(-budget, budget)
 }
 
@@ -176,6 +176,26 @@ impl FollowInput<'_, '_> {
         .any(|&c| self.binds.just_pressed(c))
     }
 
+    /// The cancel set, the start emitters' `0x60e990` and the input tick's teardown, which end any
+    /// auto-move.
+    pub(super) fn cancels(&self, player: &Player) -> bool {
+        // The world's buttons, not the device's: the both-button run is two bindings held, and a
+        // press a UI frame captured dispatches neither.
+        let both_engaged = self.rig.world_mouse.both() && self.rig.world_mouse.rose();
+        follow_cancelled(
+            self.move_start(),
+            // The on edge: `control` toggles `autorun` after this, so the flag is the pre-toggle
+            // value.
+            self.buttons.just_pressed(MouseButton::Forward) && !player.autorun,
+            both_engaged,
+            self.rig.look == Some(LookButton::Right),
+            // The teardown leg, or the body handed to a server spline; the ride term is not one of
+            // the reference's conjuncts (`0x5144e0`), and its reference side is untraced.
+            self.input_torn_down(player.modes.rooted, player.foreign_mover.is_none())
+                || player.server_riding(),
+        )
+    }
+
     /// The input tick's teardown leg ([`super::state::MoverInput::torn_down`]), which the reference
     /// takes (`0x5146d6 call 0x60fb60`) only with both predicates down (`0x5146c3`, `0x5146ce`):
     /// death, far sight, or root and stun together end a follow, a root alone does not.
@@ -193,7 +213,7 @@ impl FollowInput<'_, '_> {
     }
 }
 
-/// Cancel, re-resolve the followee, steer, and set [`Player::follow_forward`] for `control`. The
+/// Cancel, re-resolve the followee, steer, and set [`Player::auto_forward`] for `control`. The
 /// cancel comes first, as the reference's start emitters run ahead of the axis math (`0x5150a7` vs
 /// the emitter tail `0x5151a0`).
 pub(super) fn steer_follow(
@@ -205,25 +225,11 @@ pub(super) fn steer_follow(
     transforms: Query<&Transform>,
     input: FollowInput,
 ) {
-    player.follow_forward = false;
+    player.auto_forward = false;
     if follow.guid.is_none() {
         return;
     }
-    // ── The cancel set ──
-    // The world's buttons, not the device's: the both-button run is two bindings held, and a
-    // press a UI frame captured dispatches neither.
-    let both_engaged = input.rig.world_mouse.both() && input.rig.world_mouse.rose();
-    if follow_cancelled(
-        input.move_start(),
-        // The on edge: `control` toggles `autorun` after this, so the flag is the pre-toggle value.
-        input.buttons.just_pressed(MouseButton::Forward) && !player.autorun,
-        both_engaged,
-        input.rig.look == Some(LookButton::Right),
-        // The teardown leg, or the body handed to a server spline; the ride term is not one of the
-        // reference's conjuncts (`0x5144e0`), and its reference side is untraced.
-        input.input_torn_down(player.modes.rooted, player.foreign_mover.is_none())
-            || player.server_riding(),
-    ) {
+    if input.cancels(&player) {
         info!("follow: cancelled by the player's own movement input");
         follow.stop();
         return;
@@ -253,7 +259,7 @@ pub(super) fn steer_follow(
         return;
     }
     let bearing = bearing_to(flat);
-    player.face_yaw = steer(player.face_yaw, bearing, time.delta_secs());
+    player.face_yaw = steer(player.face_yaw, bearing, TURN_RATE, time.delta_secs());
     let moving = should_move(follow.moving, distance, speed.value);
     if moving != follow.moving {
         info!(
@@ -283,7 +289,7 @@ pub(super) fn steer_follow(
         }
     }
     follow.moving = moving;
-    player.follow_forward = moving;
+    player.auto_forward = moving;
 }
 
 /// Whether `WOW_FOLLOW_TRACE` is set, read once.
@@ -350,18 +356,18 @@ mod tests {
     #[test]
     fn the_turn_is_rate_limited_and_has_a_deadzone() {
         // 180°/s for a 0.1 s tick is 18° of the 90°.
-        let after = steer(0.0, PI / 2.0, 0.1);
+        let after = steer(0.0, PI / 2.0, TURN_RATE, 0.1);
         assert!(
             (after - TURN_RATE * 0.1).abs() < 1e-6,
             "clamped to the budget"
         );
-        assert!((steer(0.0, 0.05, 1.0) - 0.05).abs() < 1e-6);
-        assert_eq!(steer(1.0, 1.0 + TURN_DEADZONE / 2.0, 1.0), 1.0);
+        assert!((steer(0.0, 0.05, TURN_RATE, 1.0) - 0.05).abs() < 1e-6);
+        assert_eq!(steer(1.0, 1.0 + TURN_DEADZONE / 2.0, TURN_RATE, 1.0), 1.0);
     }
 
     #[test]
     fn steering_takes_the_short_way_round() {
-        let after = steer(PI - 0.05, -PI + 0.05, 1.0);
+        let after = steer(PI - 0.05, -PI + 0.05, TURN_RATE, 1.0);
         assert!(
             wrap_pi(after - (PI - 0.05)) > 0.0,
             "should wrap forward across ±π"
diff --git a/crates/benilla-app/src/player/input.rs b/crates/benilla-app/src/player/input.rs
index b4cf1bb4..e208d343 100644
--- a/crates/benilla-app/src/player/input.rs
+++ b/crates/benilla-app/src/player/input.rs
@@ -41,9 +41,9 @@ pub(super) fn look_input(
             rig.world_mouse.held(LookButton::Left) || steer_held,
             bit::LEFT_MOUSE,
         );
-        // `/follow` sets the forward bit through W's own setter, so it arms the camera like W.
+        // The auto-move sets the forward bit through W's own setter, so it arms the camera like W.
         set(
-            binds.pressed(crate::bindings::Input::MoveForward) || player.follow_forward,
+            binds.pressed(crate::bindings::Input::MoveForward) || player.auto_forward,
             bit::FORWARD,
         );
         set(
@@ -153,10 +153,11 @@ pub(super) fn move_axes(
     // ── The forward/back axis ── The order of S and autorun decides: S held, then autorun
     // toggled, keeps both (the toggle pushes `0x1000`, so `test cl,0x30` misses) and the
     // reference sends MSG_MOVE_STOP with S held; autorun, then S, clears the bit at key-down and
-    // walks you backward. `/follow` is a held forward, W's own bit `0x100000` through W's setter,
-    // so it nets against S like W and never trips the cancel set, which fires on key-down edges.
+    // walks you backward. The auto-move is a held forward, W's own bit `0x100000` through W's
+    // setter, so it nets against S like W and never trips the cancel set, which fires on key-down
+    // edges.
     let fwd_axis = state::forward_axis(
-        binds.pressed(crate::bindings::Input::MoveForward) || player.follow_forward,
+        binds.pressed(crate::bindings::Input::MoveForward) || player.auto_forward,
         binds.pressed(crate::bindings::Input::MoveBackward),
         both_buttons,
         autorun,
diff --git a/crates/benilla-app/src/player/state.rs b/crates/benilla-app/src/player/state.rs
index d1a62cf7..03a0d328 100644
--- a/crates/benilla-app/src/player/state.rs
+++ b/crates/benilla-app/src/player/state.rs
@@ -296,10 +296,11 @@ pub(crate) struct Player {
     /// current bit (`0x60e080`). Observers read our gait off it, and it is in the server-authored
     /// merge mask, so a server move can flip it ([`super::wire_in`]); it owes no ack.
     pub(super) walking: bool,
-    /// `/follow` holding forward this frame: the reference's follow pushes W's own bit
-    /// (`0x60e790`), so this is a [`forward_axis`] term. Rewritten each frame by
-    /// [`super::follow::steer_follow`] just before the controller reads it.
-    pub(super) follow_forward: bool,
+    /// The auto-move (`/follow` or Click to Move) holding forward this frame: the reference pushes
+    /// W's own bit (`0x60e790`), so this is a [`forward_axis`] term. Rewritten each frame by
+    /// [`super::follow::steer_follow`] and [`super::approach::steer_approach`] just before the
+    /// controller reads it.
+    pub(super) auto_forward: bool,
     /// Free-fly (`F`): the camera moves on its own and the avatar/server position is frozen.
     pub(crate) detached: bool,
     /// `SMSG_CLIENT_CONTROL_UPDATE` with `allowMove = 0` named the unit we drive: us, while someone
diff --git a/crates/benilla-app/src/target/by_name.rs b/crates/benilla-app/src/target/by_name.rs
index e5d4bde6..5cf1e50c 100644
--- a/crates/benilla-app/src/target/by_name.rs
+++ b/crates/benilla-app/src/target/by_name.rs
@@ -406,6 +406,7 @@ pub(super) fn follow_requests(
     cast: Res<crate::spell::PendingCast>,
     mut errors: ResMut<crate::ui_action::UiErrorKeys>,
     mut follow: ResMut<crate::player::FollowState>,
+    mut approach: ResMut<crate::player::Approach>,
 ) {
     for request in requests.read() {
         let resolved = match request {
@@ -448,6 +449,8 @@ pub(super) fn follow_requests(
         match resolved {
             Some((guid, name)) => {
                 info!("follow: now following \"{name}\" guid {guid:#x}");
+                // The arm `0x611130` cancels what runs first: one auto-move cell.
+                approach.stop();
                 follow.start(guid, name);
             }
             None => {
diff --git a/crates/benilla-app/src/target/click.rs b/crates/benilla-app/src/target/click.rs
index ffe98c02..f5b5587d 100644
--- a/crates/benilla-app/src/target/click.rs
+++ b/crates/benilla-app/src/target/click.rs
@@ -162,63 +162,492 @@ fn interaction_already_open_on(target: u64, interact: &crate::ui_session::Intera
     interact.1 == Some(target)
 }
 
+/// The refusals and openers the dispatchers raise.
+#[derive(bevy::ecs::system::SystemParam)]
+pub(crate) struct Feedback<'w> {
+    errors: ResMut<'w, crate::ui_action::UiErrorKeys>,
+    cast_errors: ResMut<'w, crate::ui_action::CastErrors>,
+    mail: ResMut<'w, crate::ui_mail::MailOpen>,
+    item_text: ResMut<'w, crate::ui_item_text::ItemTextOpen>,
+    // The opener queue: this system cannot also hold `CastLadder` (a second `Items` and
+    // `CastErrors` borrow), so the lock verdict goes to `ui_action::drain::drain_go_openers`.
+    openers: ResMut<'w, crate::ui_action::GoOpenerCasts>,
+    // The stone's refusals need the roster, so they run in `drain_meeting_stone_joins`.
+    stone_uses: MessageWriter<'w, crate::ui_dialog_verbs::MeetingStoneUse>,
+}
+
+/// The dispatchers, which take the object (`0x5f0130`, `0x5df2a0`, `0x5df130`, `0x5f86b0`,
+/// `0x5f05e0`): a right-click reaches them through [`act_on_right_click`] with Click to Move's
+/// walk, an approach's arrival through [`act_on_arrival`] without it.
+#[derive(bevy::ecs::system::SystemParam)]
+pub(crate) struct Dispatch<'w, 's> {
+    seam: crate::creature_anim::AttackSeam<'w, 's>,
+    self_player: Query<'w, 's, (Entity, &'static Guid, Has<Engaged>), With<SelfPlayer>>,
+    // Through `creature_anim::gesture`, the chat path's entry, as the reference's dispatcher does.
+    gestures: ResMut<'w, crate::creature_anim::GestureQueue>,
+    go_inputs: GoLockInputs<'w, 's>,
+    player_actions: Res<'w, crate::ui_action::PlayerActions>,
+    // The skin leg's spells (`[0xb700e4]`, `[0xb700e8]`), already gated by the classifier.
+    learned: Res<'w, crate::ui_action::LearnedAbilities>,
+    // The GameObject leg also reads the object's anim state (the Action gate).
+    stores: Query<
+        'w,
+        's,
+        (
+            &'static ObjectStore,
+            Option<&'static crate::go_anim::GoAnim>,
+        ),
+    >,
+    places: Query<'w, 's, &'static Transform>,
+    service: ServiceArms<'w>,
+    feedback: Feedback<'w>,
+    auto: crate::player::AutoMove<'w, 's>,
+}
+
+/// The Loot walk's stop radius: the arm (`0x611130`) takes the square root (`0x6111ab`) of what
+/// the mode's stop function stores, and Loot's is the linear melee reach (`0x6112b6`), 5.0 for a
+/// corpse (`0x611317`).
+fn loot_stop(reach: f32) -> f32 {
+    reach.sqrt()
+}
+
+impl Dispatch<'_, '_> {
+    fn me(&self) -> Option<(Entity, u64, bool)> {
+        self.self_player
+            .single()
+            .ok()
+            .map(|(e, g, engaged)| (e, g.0, engaged))
+    }
+
+    fn self_store(&self) -> Option<&ObjectStore> {
+        let (me, ..) = self.me()?;
+        self.stores.get(me).ok().map(|(s, _)| s)
+    }
+
+    /// The reference's one mounted predicate, the player's `UNIT_FIELD_MOUNTDISPLAYID`.
+    fn mounted(&self) -> bool {
+        self.self_store()
+            .is_some_and(|s| s.0.unit_mount_display_id() != 0)
+    }
+
+    /// Centre to centre, as the cursor measures.
+    fn dist_sq(&self, target: Entity) -> Option<f32> {
+        let (me, ..) = self.me()?;
+        let a = self.places.get(me).ok()?.translation;
+        Some(a.distance_squared(self.places.get(target).ok()?.translation))
+    }
+
+    fn melee_reach(&self, target: Entity) -> f32 {
+        match (self.stores.get(target).ok(), self.self_store()) {
+            (Some((it, _)), Some(me)) => cursor_mode::melee_reach(it, me),
+            _ => cursor_mode::MELEE_FLOOR,
+        }
+    }
+
+    fn approach(
+        &mut self,
+        verb: crate::player::ApproachVerb,
+        target: Entity,
+        guid: u64,
+        subject: crate::player::Subject,
+        stop: f32,
+    ) -> bool {
+        let Ok(at) = self.places.get(target).map(|t| t.translation) else {
+            return false;
+        };
+        match self.auto.start(verb, guid, subject, at, stop) {
+            Ok(()) => true,
+            Err(crate::player::Refused::TooFar) => {
+                self.feedback
+                    .errors
+                    .0
+                    .push(crate::ui_action::UiError::key("ERR_AUTOFOLLOW_TOO_FAR"));
+                false
+            }
+            Err(crate::player::Refused::Silent) => false,
+        }
+    }
+
+    /// A GameObject out of its use range (`0x5f3346`, error `0xe1`): the approach (`0x610300`) when
+    /// `walk` and the object is no fishing bobber (`0x5f8705`), which stops short of this object's
+    /// range. A walk that does not start, the leash's `ERR_AUTOFOLLOW_TOO_FAR` first, leaves
+    /// `ERR_USE_TOO_FAR` (`0x5f874b`). Deviation: the reference's arm reads the last object's
+    /// stop (`0x611336` before `0x610383` stores this one's), so its first walk has no stop.
+    fn walk_to_object(&mut self, entity: Entity, guid: u64, go_type: i32, walk: bool) -> bool {
+        let walked = walk
+            && go_type != cursor_mode::GO_TYPE_FISHINGNODE
+            && self.approach(
+                crate::player::ApproachVerb::Use,
+                entity,
+                guid,
+                crate::player::Subject::GameObject,
+                crate::player::RANGE_STOP_FRACTION
+                    * cursor_mode::go_interact_range_sq(go_type).sqrt(),
+            );
+        if !walked {
+            self.feedback
+                .errors
+                .0
+                .push(crate::ui_action::UiError::key("ERR_USE_TOO_FAR"));
+        }
+        walked
+    }
+
+    /// `0x5f86b0`, `OnUse` past its highlightable gate: the GameObject's own mounted gate, its type's
+    /// use handler, then its lock. A usable object out of `in_reach` goes to
+    /// [`Self::walk_to_object`].
+    fn use_gameobject(&mut self, entity: Entity, guid: u64, in_reach: bool, walk: bool) {
+        let self_mounted = self.mounted();
+        let self_store = self
+            .me()
+            .and_then(|(e, ..)| self.stores.get(e).ok())
+            .map(|(s, _)| s);
+        let go = self
+            .stores
+            .get(entity)
+            .ok()
+            .map(|(s, anim)| (s, crate::go_anim::go_state(anim, s)));
+        // The GameObject's own mounted gate (`0x5f31a8`) returns before the opener: no packet, no
+        // cast. It applies only without a Lock.dbc row (`0x5f8180`, a pointer test, so an
+        // all-empty row counts, unlike `LockCatalog::is_locked`); a locked object is refused by
+        // its opener cast. Only MAILBOX is exempt (`0x5f31bb`). Silent: the key has no text or
+        // sound, and `0x4945b0` drops the empty string.
+        let lock_id = self.go_inputs.templates.get(guid).map_or(0, |t| t.lock_id);
+        let has_lock_row = lock_id != 0
+            && self
+                .go_inputs
+                .locks
+                .as_deref()
+                .is_some_and(|l| l.0.slots(lock_id).is_some());
+        let go_type = go.map_or(-1, |(s, _)| s.0.gameobject_type_id());
+        if self_mounted && !has_lock_row && go_type != cursor_mode::GO_TYPE_MAILBOX {
+            debug!(
+                "right-click gameobject {guid:#x}: refused, mounted (lock-less type {go_type}, silent)"
+            );
+            return;
+        }
+        // MAILBOX (type 19) opens locally: its use handler `0x5f6820` sends no
+        // `CMSG_GAMEOBJ_USE`, and `MAIL_SHOW` → `CheckInbox` asks for the list.
+        if go_type == cursor_mode::GO_TYPE_MAILBOX {
+            if in_reach {
+                debug!("right-click mailbox: open mail window {guid:#x}");
+                self.feedback.mail.click(guid);
+            } else {
+                self.walk_to_object(entity, guid, go_type, walk);
+            }
+            return;
+        }
+        // TEXT (type 9) opens locally (`0x5f58c0` → `0x4e32e0(goGuid, 0)`; vmangos' `Use` has no
+        // type-9 case); a re-click closes it, and the page is read at paint time.
+        if go_type == cursor_mode::GO_TYPE_TEXT {
+            if !in_reach {
+                self.walk_to_object(entity, guid, go_type, walk);
+            } else if self.feedback.item_text.toggle_closed(guid) {
+                debug!("right-click text gameobject: re-click closes {guid:#x}");
+            } else {
+                debug!("right-click text gameobject: read {guid:#x}");
+                self.feedback.item_text.open_pages(guid);
+            }
+            return;
+        }
+        // MEETINGSTONE (type 23) has its own use slot `0x5f69d0`: four client-side refusals, then
+        // `CMSG 0x292 {u64 goGuid}` (`0x4c9ff0`), never `CMSG_GAMEOBJ_USE`, whose type-23 arm in
+        // vmangos does nothing (`GameObject.cpp:1836`). Types 9, 19, 23 and 28 override the shared
+        // sender `0x5f33e0`.
+        if go_type == cursor_mode::GO_TYPE_MEETINGSTONE {
+            if in_reach {
+                debug!("right-click meeting stone: {guid:#x}");
+                self.feedback
+                    .stone_uses
+                    .write(crate::ui_dialog_verbs::MeetingStoneUse { go_guid: guid });
+            } else {
+                self.walk_to_object(entity, guid, go_type, walk);
+            }
+            return;
+        }
+        // By lock: used, opened by its opener cast, or refused locally (`0x5f3427..`).
+        match resolve_go_action(
+            guid,
+            &mut self.go_inputs,
+            &self.player_actions.spells,
+            go,
+            self_store,
+            &self.seam.net,
+        ) {
+            GoAction::Use | GoAction::OpenLock(_) | GoAction::OpenByKey(_) if !in_reach => {
+                self.walk_to_object(entity, guid, go_type, walk);
+            }
+            GoAction::Use => {
+                debug!("right-click gameobject use: {guid:#x}");
+                if benilla_assets::trace::enabled_for("use") {
+                    benilla_assets::trace::line(
+                        "use",
+                        &format!("SEND CMSG_GAMEOBJ_USE guid={guid:#x}"),
+                    );
+                }
+                let _ = self.seam.net.0.send(ClientCommand::GameObjUse { guid });
+            }
+            // Both opener arms queue for the one cast path, as the reference reaches `TryCast
+            // 0x6e4b60` from the use sender (`0x5f35c0`) like a button press.
+            GoAction::OpenLock(spell_id) => {
+                debug!("right-click gameobject open-lock: cast {spell_id} at {guid:#x}");
+                self.feedback
+                    .openers
+                    .0
+                    .push(crate::ui_action::GoOpener::Spell {
+                        spell_id,
+                        go_guid: guid,
+                    });
+            }
+            GoAction::OpenByKey(it) => {
+                debug!(
+                    "right-click gameobject open-by-key: use item ({},{}) blk {} at {guid:#x}",
+                    it.bag_index, it.slot, it.spell_index
+                );
+                self.feedback
+                    .openers
+                    .0
+                    .push(crate::ui_action::GoOpener::Key(it));
+            }
+            GoAction::Refuse(err) => {
+                debug!("right-click gameobject {guid:#x}: locked, refused ({err:?})");
+                if let Some(err) = err {
+                    self.feedback.errors.0.push(err);
+                }
+            }
+        }
+    }
+
+    /// `0x5df130`: `CMSG_LOOT` at a lootable corpse, walked to first when `walk` and beyond its
+    /// 5 yd (`0x5df1c3`), stopping at [`loot_stop`] of 5. A walk that does not start falls through
+    /// to the send.
+    fn loot_corpse(&mut self, entity: Entity, guid: u64, walk: bool) {
+        if walk
+            && self
+                .dist_sq(entity)
+                .is_some_and(|d2| d2 > cursor_mode::CORPSE_INTERACT_RANGE_SQ)
+            && self.approach(
+                crate::player::ApproachVerb::Loot,
+                entity,
+                guid,
+                crate::player::Subject::Corpse,
+                loot_stop(cursor_mode::MELEE_FLOOR),
+            )
+        {
+            return;
+        }
+        debug!("right-click corpse loot: {guid:#x}");
+        let _ = self.seam.net.0.send(ClientCommand::Loot { guid });
+        // Predicted, as for a unit corpse (`[player+0x1d28]` armed at the send).
+        self.seam.loot_latch.0 = Some(guid);
+    }
+
+    /// `0x5df2a0`: `CMSG_LOOT` at a dead unit, which `can_loot` (`CanLootNow 0x5ec110`) must
+    /// allow, walked to first when `walk` and beyond melee reach. A walk that does not start falls
+    /// through to the send.
+    fn loot_unit(&mut self, entity: Entity, guid: u64, can_loot: bool, walk: bool) {
+        if !can_loot {
+            return;
+        }
+        let reach = self.melee_reach(entity);
+        if walk
+            && self.dist_sq(entity).is_some_and(|d2| d2 > reach * reach)
+            && self.approach(
+                crate::player::ApproachVerb::Loot,
+                entity,
+                guid,
+                crate::player::Subject::Unit { dead: true },
+                loot_stop(reach),
+            )
+        {
+            return;
+        }
+        debug!("right-click loot: {guid:#x}");
+        let _ = self.seam.net.0.send(ClientCommand::Loot { guid });
+        // Predicted at the send, as the reference's sender (`0x5df253`) arms `[player+0x1d28]` and
+        // kneels before any reply; the anim driver reads the latch.
+        self.seam.loot_latch.0 = Some(guid);
+    }
+
+    /// `0x5f05e0`: the skin cast at a body. Out of reach it walks there when `walk`, and either way
+    /// casts nothing (`0x5f06c4`).
+    fn skin(
+        &mut self,
+        entity: Entity,
+        guid: u64,
+        spell_id: u32,
+        subject: crate::player::Subject,
+        in_reach: bool,
+        walk: bool,
+    ) {
+        if !in_reach {
+            if walk {
+                let reach = match subject {
+                    crate::player::Subject::Corpse => cursor_mode::MELEE_FLOOR,
+                    _ => self.melee_reach(entity),
+                };
+                let stop = crate::player::RANGE_STOP_FRACTION * reach;
+                self.approach(
+                    crate::player::ApproachVerb::Skin,
+                    entity,
+                    guid,
+                    subject,
+                    stop,
+                );
+            }
+            return;
+        }
+        // The cast's mounted check (`0x6094f0`, reason `0x39`), the one place a rider is told
+        // anything; the record comes off [`GoLockInputs`]' catalog, this system's only `Spells`.
+        let mounted = self.mounted();
+        let def = self
+            .go_inputs
+            .spells
+            .as_ref()
+            .and_then(|s| s.catalog.get(spell_id));
+        if crate::spell::validator::cast_mounted_refusal(mounted, def) {
+            debug!("right-click skin: refused locally — mounted (0x39)");
+            self.feedback.cast_errors.push_local(spell_id, 0x39);
+        } else {
+            debug!("right-click skin: {guid:#x} (spell {spell_id})");
+            let _ = self.seam.net.0.send(ClientCommand::CastSpell {
+                spell_id,
+                target: Some(guid),
+            });
+        }
+    }
+
+    /// `0x5f0130`: the NPC-service ladder. Out of the 5.5556 yd reach it walks there when `walk`,
+    /// returning before the ladder and the gesture (`0x5f022f`), and otherwise sends nothing.
+    fn talk(&mut self, entity: Entity, guid: u64, in_reach: bool, walk: bool) {
+        if !in_reach {
+            if walk {
+                self.approach(
+                    crate::player::ApproachVerb::Talk,
+                    entity,
+                    guid,
+                    crate::player::Subject::Unit { dead: false },
+                    crate::player::TALK_STOP,
+                );
+            }
+            return;
+        }
+        // The reference's own `UNIT_NPC_FLAGS` ladder (`0x5f0289`), not the cursor kind, which its
+        // cursor ladder (`0x482336`) projects lossily; the re-click gate comes first.
+        if interaction_already_open_on(guid, &self.service.interact) {
+            debug!("right-click interact: {guid:#x} — its window is already open, nothing sent");
+            return;
+        }
+        let npc_flags = self
+            .stores
+            .get(entity)
+            .map(|(s, _)| s.0.unit_npc_flags())
+            .unwrap_or(0);
+        let me = self.me();
+        let self_store = self.self_store();
+        // Peeked, not taken: the cursor clears only once a sale goes out. The reference sends the
+        // cursor's stored guid; we resolve the held `(bag, slot)`, which a pickup locks, and a slot
+        // with no guid opens the list instead.
+        let cursor_sale = self
+            .service
+            .script
+            .as_deref()
+            .and_then(|s| s.cursor_item())
+            .and_then(|item| {
+                let slot0 = u8::try_from(item.slot.saturating_sub(1)).unwrap_or(0);
+                self_store.and_then(|s| {
+                    crate::ui_items::slot_guid(&s.0, item.bag, slot0, &self.go_inputs.objects)
+                })
+            });
+        let ghost = self_store.is_some_and(|s| s.0.player_is_ghost());
+        let Some(arm) = service_arm(npc_flags, self.service.quest.status(guid)) else {
+            // `0x5f05ca`: no consulted bit does nothing, gesture included.
+            debug!("right-click interact: {guid:#x} matches no service bit — nothing sent");
+            return;
+        };
+        match service_action(arm, guid, ghost, cursor_sale) {
+            ServiceAction::Send(cmd) => {
+                debug!("right-click interact: {guid:#x} ({arm:?})");
+                let _ = self.seam.net.0.send(cmd);
+            }
+            ServiceAction::SellFromCursor(cmd) => {
+                debug!("right-click interact: {guid:#x} (vendor — selling the held item)");
+                let _ = self.seam.net.0.send(cmd);
+                // The sell clear: the slot stays greyed until the server's update.
+                if let Some(script) = self.service.script.as_deref_mut() {
+                    script.take_cursor_item_for_sale();
+                }
+            }
+            ServiceAction::AskBinder => {
+                debug!("right-click interact: {guid:#x} (innkeeper — CONFIRM_BINDER, no packet)");
+                self.service.binder.ask(guid);
+            }
+            ServiceAction::AskSpiritHealer => {
+                debug!(
+                    "right-click interact: {guid:#x} (spirit healer — CONFIRM_XP_LOSS, no packet)"
+                );
+                self.service.death.ask_spirit_healer(guid);
+            }
+            ServiceAction::AcquireSpiritGuide => {
+                debug!("right-click interact: {guid:#x} (spirit guide — adopting, 0x2E2)");
+                let outcome = self.service.spirit.click_guide(guid);
+                if outcome.cancel_aura {
+                    if let Some(script) = self.service.script.as_deref_mut() {
+                        script.fire_event("AREA_SPIRIT_HEALER_OUT_OF_RANGE", vec![]);
+                    }
+                    let _ = self.seam.net.0.send(ClientCommand::CancelAura {
+                        spell_id: crate::ui_dialog_verbs::AREA_SPIRIT_HEALER_AURA,
+                    });
+                }
+                if let Some(healer) = outcome.query {
+                    let _ = self
+                        .seam
+                        .net
+                        .0
+                        .send(ClientCommand::AreaSpiritHealerQuery { healer });
+                }
+            }
+            ServiceAction::Silent(why) => {
+                debug!("right-click interact: {guid:#x} ({arm:?}) — silent: {why}");
+            }
+        }
+        // Talk on every taken arm, silent ones too (each arm of `0x5f0130` ends `call
+        // 0x60bb30(0)`); the anim's WeaponFlags `0x10` stows a drawn weapon for good.
+        if let Some((_, my_guid, _)) = me {
+            self.gestures
+                .push(my_guid, crate::creature_anim::Gesture::Talk);
+        }
+    }
+}
+
 /// On a clean right-click, select the press pick's unit and act by the cursor's classification
 /// (the INTERACT leg `0x492820`): a GameObject, a corpse, an attack, loot, skin, or the
 /// `UNIT_NPC_FLAGS` ladder ([`service_arm`]). The range gray (`unable`) suppresses every send but
-/// attack, which the server holds until in reach; there is no auto-approach yet.
-// `ui_feedback` is the overflow bundle past the 16-SystemParam ceiling.
-#[allow(clippy::type_complexity)]
+/// attack, which the server holds until in reach; with Click to Move on, each dispatcher walks
+/// there instead (`CanAutoInteract` is their approach flag, `0x60c170`, `0x5d6c6f`).
 pub(super) fn act_on_right_click(
     mut clicks: MessageReader<WorldRightClick>,
     // The press pick: the reference picks once, on the down edge (`0x481f00`).
     press: Res<PressPick>,
     mut selection: ResMut<Selection>,
-    mut seam: crate::creature_anim::AttackSeam,
-    self_player: Query<(Entity, &Guid, Has<Engaged>), With<SelfPlayer>>,
-    // Through `creature_anim::gesture`, the chat path's entry, as the reference's dispatcher does.
-    mut gestures: ResMut<crate::creature_anim::GestureQueue>,
-    mut go_inputs: GoLockInputs,
-    player_actions: Res<crate::ui_action::PlayerActions>,
-    // The skin leg's spell (`[0xb700e4]`), already gated by the classifier.
-    learned: Res<crate::ui_action::LearnedAbilities>,
-    // The GameObject leg also reads the object's anim state (the Action gate).
-    stores: Query<(&ObjectStore, Option<&crate::go_anim::GoAnim>)>,
-    mut service: ServiceArms,
-    ui_feedback: (
-        ResMut<crate::ui_action::UiErrorKeys>,
-        ResMut<crate::ui_action::CastErrors>,
-        ResMut<crate::ui_mail::MailOpen>,
-        ResMut<crate::ui_item_text::ItemTextOpen>,
-        // The opener queue: this system cannot also hold `CastLadder` (a second `Items` and
-        // `CastErrors` borrow), so the lock verdict goes to `ui_action::drain::drain_go_openers`.
-        ResMut<crate::ui_action::GoOpenerCasts>,
-        // The stone's refusals need the roster, so they run in `drain_meeting_stone_joins`.
-        MessageWriter<crate::ui_dialog_verbs::MeetingStoneUse>,
-    ),
+    mut dispatch: Dispatch,
 ) {
-    let (mut ui_error_keys, mut cast_errors, mut mail, mut item_text, mut openers, mut stone_uses) =
-        ui_feedback;
     if clicks.read().last().is_none() {
         return;
     }
     let (hovered, hovered_object, cursor) = (&press.hovered, &press.object, &press.cursor);
-    // The reference's one mounted predicate, the player's `UNIT_FIELD_MOUNTDISPLAYID`.
-    let self_store = self_player
-        .single()
-        .ok()
-        .and_then(|(e, _, _)| stores.get(e).ok())
-        .map(|(s, _)| s);
-    let self_mounted = self_store.is_some_and(|s| s.0.unit_mount_display_id() != 0);
+    let walk = dispatch.auto.can_auto_interact();
+    let self_mounted = dispatch.mounted();
     // A GameObject is used, never falling through to units: `OnUse 0x5f8660` gates on
     // highlightable (our `Point` cursor, silent), then usable (`0x5f3130`), whose lock arm toasts
-    // first, even out of range. Out of range (`unable`) this shows nothing; the reference shows
-    // `ERR_USE_TOO_FAR` (`0x5f874b`) unless its auto-walk `0x610300` starts (`AutoInteract` on).
+    // first, even out of range.
     if go_is_nearest(hovered, hovered_object) {
-        // Traced (tag `use`): a `Point` cursor and the range gray both refuse silently here.
+        // Traced (tag `use`): a `Point` cursor refuses silently; the range gray raises
+        // `ERR_USE_TOO_FAR`.
         if benilla_assets::trace::enabled_for("use") {
             let ty = hovered_object
                 .target
-                .and_then(|e| stores.get(e).ok())
+                .and_then(|e| dispatch.stores.get(e).ok())
                 .map_or(-1, |(s, _)| s.0.gameobject_type_id());
             benilla_assets::trace::line(
                 "use",
@@ -231,109 +660,21 @@ pub(super) fn act_on_right_click(
             );
         }
         if cursor.kind != cursor_mode::CursorKind::Point {
-            if let Some(guid) = hovered_object.guid {
-                let go = hovered_object
-                    .target
-                    .and_then(|e| stores.get(e).ok())
-                    .map(|(s, anim)| (s, crate::go_anim::go_state(anim, s)));
-                // The GameObject's own mounted gate (`0x5f31a8`) returns before the opener: no
-                // packet, no cast. It applies only without a Lock.dbc row (`0x5f8180`, a pointer
-                // test, so an all-empty row counts, unlike `LockCatalog::is_locked`); a locked
-                // object is refused by its opener cast. Only MAILBOX is exempt (`0x5f31bb`).
-                // Silent: the key has no text or sound, and `0x4945b0` drops the empty string.
-                let lock_id = go_inputs.templates.get(guid).map_or(0, |t| t.lock_id);
-                let has_lock_row = lock_id != 0
-                    && go_inputs
-                        .locks
-                        .as_deref()
-                        .is_some_and(|l| l.0.slots(lock_id).is_some());
-                let go_type = go.map_or(-1, |(s, _)| s.0.gameobject_type_id());
-                if self_mounted && !has_lock_row && go_type != cursor_mode::GO_TYPE_MAILBOX {
-                    debug!(
-                        "right-click gameobject {guid:#x}: refused, mounted (lock-less type {go_type}, silent)"
-                    );
-                    return;
-                }
-                // MAILBOX (type 19) opens locally: its use handler `0x5f6820` sends no
-                // `CMSG_GAMEOBJ_USE`, and `MAIL_SHOW` → `CheckInbox` asks for the list.
-                if go.is_some_and(|(s, _)| s.0.gameobject_type_id() == cursor_mode::GO_TYPE_MAILBOX)
-                {
-                    if !cursor.unable {
-                        debug!("right-click mailbox: open mail window {guid:#x}");
-                        mail.click(guid);
-                    }
-                    return;
-                }
-                // TEXT (type 9) opens locally (`0x5f58c0` → `0x4e32e0(goGuid, 0)`; vmangos' `Use`
-                // has no type-9 case); a re-click closes it, and the page is read at paint time.
-                if go.is_some_and(|(s, _)| s.0.gameobject_type_id() == cursor_mode::GO_TYPE_TEXT) {
-                    if !cursor.unable {
-                        if item_text.toggle_closed(guid) {
-                            debug!("right-click text gameobject: re-click closes {guid:#x}");
-                        } else {
-                            debug!("right-click text gameobject: read {guid:#x}");
-                            item_text.open_pages(guid);
-                        }
-                    }
-                    return;
-                }
-                // MEETINGSTONE (type 23) has its own use slot `0x5f69d0`: four client-side
-                // refusals, then `CMSG 0x292 {u64 goGuid}` (`0x4c9ff0`), never `CMSG_GAMEOBJ_USE`,
-                // whose type-23 arm in vmangos does nothing (`GameObject.cpp:1836`). Types 9, 19,
-                // 23 and 28 override the shared sender `0x5f33e0`.
-                if go.is_some_and(|(s, _)| {
-                    s.0.gameobject_type_id() == cursor_mode::GO_TYPE_MEETINGSTONE
-                }) {
-                    if !cursor.unable {
-                        debug!("right-click meeting stone: {guid:#x}");
-                        stone_uses.write(crate::ui_dialog_verbs::MeetingStoneUse { go_guid: guid });
-                    }
-                    return;
-                }
-                // By lock: used, opened by its opener cast, or refused locally (`0x5f3427..`).
-                match resolve_go_action(
-                    guid,
-                    &mut go_inputs,
-                    &player_actions.spells,
-                    go,
-                    self_store,
-                    &seam.net,
-                ) {
-                    GoAction::Use if cursor.unable => {}
-                    GoAction::OpenLock(_) | GoAction::OpenByKey(_) if cursor.unable => {}
-                    GoAction::Use => {
-                        debug!("right-click gameobject use: {guid:#x}");
-                        if benilla_assets::trace::enabled_for("use") {
-                            benilla_assets::trace::line(
-                                "use",
-                                &format!("SEND CMSG_GAMEOBJ_USE guid={guid:#x}"),
-                            );
-                        }
-                        let _ = seam.net.0.send(ClientCommand::GameObjUse { guid });
-                    }
-                    // Both opener arms queue for the one cast path, as the reference reaches
-                    // `TryCast 0x6e4b60` from the use sender (`0x5f35c0`) like a button press.
-                    GoAction::OpenLock(spell_id) => {
-                        debug!("right-click gameobject open-lock: cast {spell_id} at {guid:#x}");
-                        openers.0.push(crate::ui_action::GoOpener::Spell {
-                            spell_id,
-                            go_guid: guid,
-                        });
-                    }
-                    GoAction::OpenByKey(it) => {
-                        debug!(
-                            "right-click gameobject open-by-key: use item ({},{}) blk {} at {guid:#x}",
-                            it.bag_index, it.slot, it.spell_index
-                        );
-                        openers.0.push(crate::ui_action::GoOpener::Key(it));
-                    }
-                    GoAction::Refuse(err) => {
-                        debug!("right-click gameobject {guid:#x}: locked, refused ({err:?})");
-                        if let Some(err) = err {
-                            ui_error_keys.0.push(err);
-                        }
-                    }
-                }
+            if let (Some(entity), Some(guid)) = (hovered_object.target, hovered_object.guid) {
+                // Walking, the range arm (`0x5f330c`) is the object's own: the PickLock cursor
+                // never grays, and the gray folds the lock in.
+                let in_reach = if walk {
+                    let go_type = dispatch
+                        .stores
+                        .get(entity)
+                        .map_or(-1, |(s, _)| s.0.gameobject_type_id());
+                    dispatch
+                        .dist_sq(entity)
+                        .is_some_and(|d2| d2 <= cursor_mode::go_interact_range_sq(go_type))
+                } else {
+                    !cursor.unable
+                };
+                dispatch.use_gameobject(entity, guid, in_reach, walk);
             }
         }
         return;
@@ -345,7 +686,7 @@ pub(super) fn act_on_right_click(
     // skin cast (`0x5f05e0`). Your own corpse takes neither: the resurrect prompt comes from the
     // 40 yd `CORPSE_IN_RANGE` poll (`0x492130`), never a click.
     if let (Some(entity), Some(guid)) = (hovered.corpse, hovered.corpse_guid) {
-        let store = stores.get(entity).ok().map(|(s, _)| s);
+        let store = dispatch.stores.get(entity).ok().map(|(s, _)| s);
         if benilla_assets::trace::enabled_for("use") {
             benilla_assets::trace::line(
                 "use",
@@ -359,47 +700,42 @@ pub(super) fn act_on_right_click(
                 ),
             );
         }
+        let (lootable, insignia) = (
+            store.is_some_and(|s| s.0.corpse_lootable()),
+            store.is_some_and(|s| s.0.corpse_pvp_insignia()),
+        );
         // A rider fails leg 1 (`0x5d6c2a jg`) with no error and falls to leg 2, silently.
-        if !self_mounted && store.is_some_and(|s| s.0.corpse_lootable()) {
+        if !self_mounted && lootable {
             // Not standing: the client-local red `ERR_LOOT_NOTSTANDING`, no packet (`0x5d6c3b` →
             // `GetStandState 0x5ed570`, non-zero → `0x496720(0x85)`).
-            let standing = self_store.is_none_or(|s| s.0.unit_stand_state() == 0);
-            if !standing {
+            if dispatch
+                .self_store()
+                .is_some_and(|s| s.0.unit_stand_state() != 0)
+            {
                 debug!("right-click corpse loot: refused, not standing ({guid:#x})");
-                ui_error_keys
+                dispatch
+                    .feedback
+                    .errors
                     .0
                     .push(crate::ui_action::UiError::key("ERR_LOOT_NOTSTANDING"));
                 return;
             }
             // Range rides the cursor's gray, so the pouch is never lit where the click refuses.
             if !cursor.unable {
-                debug!("right-click corpse loot: {guid:#x}");
-                let _ = seam.net.0.send(ClientCommand::Loot { guid });
-                // Predicted, as for a unit corpse (`[player+0x1d28]` armed at the send).
-                seam.loot_latch.0 = Some(guid);
+                dispatch.loot_corpse(entity, guid, walk);
             }
-        } else if store.is_some_and(|s| s.0.corpse_pvp_insignia()) {
+        } else if insignia {
             // Leg 2. `skin_player_corpse` mirrors `[0xb700e8]`, `None` for every 1.12.1 player,
             // so this is inert as in the reference; the unfriendly test is not built.
-            if let Some(spell_id) = learned.skin_player_corpse {
-                if !cursor.unable {
-                    // The cast's mounted check, where a mounted click lands; the record comes off
-                    // [`GoLockInputs`]' catalog, this system's only `Spells` handle.
-                    let def = go_inputs
-                        .spells
-                        .as_ref()
-                        .and_then(|s| s.catalog.get(spell_id));
-                    if crate::spell::validator::cast_mounted_refusal(self_mounted, def) {
-                        debug!("right-click corpse insignia: refused locally — mounted (0x39)");
-                        cast_errors.push_local(spell_id, 0x39);
-                    } else {
-                        debug!("right-click corpse insignia: {guid:#x} (spell {spell_id})");
-                        let _ = seam.net.0.send(ClientCommand::CastSpell {
-                            spell_id,
-                            target: Some(guid),
-                        });
-                    }
-                }
+            if let Some(spell_id) = dispatch.learned.skin_player_corpse {
+                dispatch.skin(
+                    entity,
+                    guid,
+                    spell_id,
+                    crate::player::Subject::Corpse,
+                    !cursor.unable,
+                    walk,
+                );
             }
         }
         return;
@@ -410,7 +746,7 @@ pub(super) fn act_on_right_click(
     // The dispatcher's attack arm (`0x60c18c`), not the sword: a dead, ghost or mounted player
     // still takes it and is refused inside (`0x60c1a1`, `0x60c1bc`), never reaching a service.
     let attack = press.attack_fork.0;
-    let target = stores.get(entity).ok().map(|(s, _)| s);
+    let target = dispatch.stores.get(entity).ok().map(|(s, _)| s);
     // ── The dead-target fork of the unit dispatcher `0x60bea0` ──
     // Loot routes by classification (dead and `UNIT_DYNFLAG_LOOTABLE`), not the cursor kind, whose
     // Pickup(8) a live vendor shares. A rider skips the loot leg for the skin leg (`0x60bf98`),
@@ -421,7 +757,7 @@ pub(super) fn act_on_right_click(
         dead_fork,
         target.is_some_and(|s| s.0.unit_lootable()),
         target.is_some_and(|s| s.0.unit_flags() & cursor_mode::UNIT_FLAG_SKINNABLE != 0),
-        learned.skinning.is_some(),
+        dispatch.learned.skinning.is_some(),
     );
     if benilla_assets::trace::enabled_for("use") {
         benilla_assets::trace::line(
@@ -445,17 +781,17 @@ pub(super) fn act_on_right_click(
             ),
         );
     }
-    let me = self_player.single().ok();
+    let me = dispatch.me();
     // A mid-combat click on a vendor or corpse switches and stops, never swings (`0x5ecb70`); the
     // sword, not the fork, as the re-swing also needs the player's own legs.
     let outcome = scan::commit(
         &mut selection,
-        &mut seam,
+        &mut dispatch.seam,
         entity,
         guid,
         target,
         me.is_some_and(|(_, _, e)| e),
-        me.map(|(_, g, _)| g.0),
+        me.map(|(_, g, _)| g),
         press.attack(),
     );
     match unit_branch(attack, dead_fork, leg) {
@@ -463,7 +799,8 @@ pub(super) fn act_on_right_click(
             // Silent after the select: the click's `0x60c247 call 0x5ecb70` has no `DisplayError`,
             // and the red `ERR_ATTACK_*` lines are `0x612df0`'s (the Attack action, pet attack,
             // TryCast). The predicate is `0x612df0`'s; `0x5ecb70`'s own set is not transcribed.
-            if crate::ui_action::attack_actor_blocked(self_store, me.map(|(_, g, _)| g.0)).is_some()
+            if crate::ui_action::attack_actor_blocked(dispatch.self_store(), me.map(|(_, g, _)| g))
+                .is_some()
             {
                 // refused: the selection stands, no swing, nothing said
             } else {
@@ -471,46 +808,37 @@ pub(super) fn act_on_right_click(
                 // `0x5ecb70`'s body through the seam; `swung` means the commit's re-swing already
                 // went out, which `0x5eccda` keeps from sending twice.
                 let engaged = me.is_some_and(|(_, _, e)| e);
-                seam.start(guid, engaged || outcome.swung, false);
+                dispatch.seam.start(guid, engaged || outcome.swung, false);
             }
         }
         UnitBranch::Dead(DeadUnitLeg::Loot) => {
-            // `CMSG_LOOT`, no talk gesture; the stand-state check (`0x60bfb7` → `0x60c007 push
-            // 0x85`) matches the corpse leg's.
-            if self_store.is_some_and(|s| s.0.unit_stand_state() != 0) {
+            // The stand-state check (`0x60bfb7` → `0x60c007 push 0x85`) matches the corpse leg's.
+            if dispatch
+                .self_store()
+                .is_some_and(|s| s.0.unit_stand_state() != 0)
+            {
                 debug!("right-click loot: refused, not standing ({guid:#x})");
-                ui_error_keys
+                dispatch
+                    .feedback
+                    .errors
                     .0
                     .push(crate::ui_action::UiError::key("ERR_LOOT_NOTSTANDING"));
-            } else if !cursor.unable {
-                debug!("right-click loot: {guid:#x}");
-                let _ = seam.net.0.send(ClientCommand::Loot { guid });
-                // Predicted at the send, as the reference's sender (`0x5df253`) arms
-                // `[player+0x1d28]` and kneels before any reply; the anim driver reads the latch.
-                seam.loot_latch.0 = Some(guid);
+            } else {
+                dispatch.loot_unit(entity, guid, !cursor.unable, walk);
             }
         }
         UnitBranch::Dead(DeadUnitLeg::Skin) => {
             // The skin leg (`0x60c01f`): the known Skinning spell (`[0xb700e4]`) at a corpse the
-            // loot leg declined, lootable ones included while mounted. Its cast mounted check
-            // (`0x6094f0`, reason `0x39`) is the one place a rider is told anything.
-            if !cursor.unable {
-                if let Some(spell_id) = learned.skinning {
-                    let def = go_inputs
-                        .spells
-                        .as_ref()
-                        .and_then(|s| s.catalog.get(spell_id));
-                    if crate::spell::validator::cast_mounted_refusal(self_mounted, def) {
-                        debug!("right-click skin: refused locally — mounted (0x39)");
-                        cast_errors.push_local(spell_id, 0x39);
-                    } else {
-                        debug!("right-click skin: {guid:#x} (spell {spell_id})");
-                        let _ = seam.net.0.send(ClientCommand::CastSpell {
-                            spell_id,
-                            target: Some(guid),
-                        });
-                    }
-                }
+            // loot leg declined, lootable ones included while mounted.
+            if let Some(spell_id) = dispatch.learned.skinning {
+                dispatch.skin(
+                    entity,
+                    guid,
+                    spell_id,
+                    crate::player::Subject::Unit { dead: true },
+                    !cursor.unable,
+                    walk,
+                );
             }
         }
         // Terminal: a dead unit that took no leg does nothing; only the alive branch (`0x60c162`)
@@ -518,95 +846,78 @@ pub(super) fn act_on_right_click(
         UnitBranch::Dead(DeadUnitLeg::Nothing) => {
             debug!("right-click unit {guid:#x}: dead fork took no leg — nothing sent");
         }
-        UnitBranch::Service if !cursor.unable => {
-            // The reference's own `UNIT_NPC_FLAGS` ladder (`0x5f0289`), not the cursor kind, which
-            // its cursor ladder (`0x482336`) projects lossily; the re-click gate comes first.
-            if interaction_already_open_on(guid, &service.interact) {
-                debug!(
-                    "right-click interact: {guid:#x} — its window is already open, nothing sent"
-                );
-                return;
-            }
-            let npc_flags = stores
+        UnitBranch::Service => dispatch.talk(entity, guid, !cursor.unable, walk),
+    }
+}
+
+/// The verb an approach owed, once it arrived (`0x60fa20`, run at the stop): the dispatcher alone,
+/// with no select, no cursor and no walk but Use's. Each looks its object up by type (`0x468460`),
+/// and the loot's asks for a unit (`0x60fa41`), so a corpse object walked to is not looted.
+pub(super) fn act_on_arrival(
+    mut dispatch: Dispatch,
+    index: Res<crate::net::GuidIndex>,
+    kinds: Query<&crate::net::NetEntity>,
+) {
+    use crate::player::{ApproachVerb, Subject};
+    use benilla_protocol::EntityKind;
+    let Some((verb, guid)) = dispatch.auto.approach.arrived.take() else {
+        return;
+    };
+    let Some(&entity) = index.0.get(&guid) else {
+        return;
+    };
+    let kind = kinds.get(entity).ok().map(|k| k.kind);
+    let unit = matches!(kind, Some(EntityKind::Unit | EntityKind::Player));
+    let d2 = dispatch.dist_sq(entity).unwrap_or(f32::INFINITY);
+    debug!(
+        "approach: arrived for {verb:?} at {guid:#x}, {:.2} yd",
+        d2.sqrt()
+    );
+    match verb {
+        ApproachVerb::Talk if unit => dispatch.talk(entity, guid, d2 <= SERVICE_RANGE_SQ, false),
+        // `0x5df2a0`'s own lootable test (`0x6003a0`), which the click's dead fork made earlier.
+        ApproachVerb::Loot if unit => {
+            if dispatch
+                .stores
                 .get(entity)
-                .map(|(s, _)| s.0.unit_npc_flags())
-                .unwrap_or(0);
-            // Peeked, not taken: the cursor clears only once a sale goes out. The reference sends
-            // the cursor's stored guid; we resolve the held `(bag, slot)`, which a pickup locks,
-            // and a slot with no guid opens the list instead.
-            let cursor_sale = service
-                .script
-                .as_deref()
-                .and_then(|s| s.cursor_item())
-                .and_then(|item| {
-                    let slot0 = u8::try_from(item.slot.saturating_sub(1)).unwrap_or(0);
-                    self_store.and_then(|s| {
-                        crate::ui_items::slot_guid(&s.0, item.bag, slot0, &go_inputs.objects)
-                    })
-                });
-            let Some(arm) = service_arm(npc_flags, service.quest.status(guid)) else {
-                // `0x5f05ca`: no consulted bit does nothing, gesture included.
-                debug!("right-click interact: {guid:#x} matches no service bit — nothing sent");
-                return;
-            };
-            match service_action(
-                arm,
-                guid,
-                self_store.is_some_and(|s| s.0.player_is_ghost()),
-                cursor_sale,
-            ) {
-                ServiceAction::Send(cmd) => {
-                    debug!("right-click interact: {guid:#x} ({arm:?})");
-                    let _ = seam.net.0.send(cmd);
-                }
-                ServiceAction::SellFromCursor(cmd) => {
-                    debug!("right-click interact: {guid:#x} (vendor — selling the held item)");
-                    let _ = seam.net.0.send(cmd);
-                    // The sell clear: the slot stays greyed until the server's update.
-                    if let Some(script) = service.script.as_deref_mut() {
-                        script.take_cursor_item_for_sale();
-                    }
-                }
-                ServiceAction::AskBinder => {
-                    debug!(
-                        "right-click interact: {guid:#x} (innkeeper — CONFIRM_BINDER, no packet)"
-                    );
-                    service.binder.ask(guid);
-                }
-                ServiceAction::AskSpiritHealer => {
-                    debug!("right-click interact: {guid:#x} (spirit healer — CONFIRM_XP_LOSS, no packet)");
-                    service.death.ask_spirit_healer(guid);
-                }
-                ServiceAction::AcquireSpiritGuide => {
-                    debug!("right-click interact: {guid:#x} (spirit guide — adopting, 0x2E2)");
-                    let outcome = service.spirit.click_guide(guid);
-                    if outcome.cancel_aura {
-                        if let Some(script) = service.script.as_deref_mut() {
-                            script.fire_event("AREA_SPIRIT_HEALER_OUT_OF_RANGE", vec![]);
-                        }
-                        let _ = seam.net.0.send(ClientCommand::CancelAura {
-                            spell_id: crate::ui_dialog_verbs::AREA_SPIRIT_HEALER_AURA,
-                        });
-                    }
-                    if let Some(healer) = outcome.query {
-                        let _ = seam
-                            .net
-                            .0
-                            .send(ClientCommand::AreaSpiritHealerQuery { healer });
-                    }
-                }
-                ServiceAction::Silent(why) => {
-                    debug!("right-click interact: {guid:#x} ({arm:?}) — silent: {why}");
-                }
-            }
-            // Talk on every taken arm, silent ones too (each arm of `0x5f0130` ends `call
-            // 0x60bb30(0)`); the anim's WeaponFlags `0x10` stows a drawn weapon for good.
-            if let Some((_, my_guid, _)) = me {
-                gestures.push(my_guid.0, crate::creature_anim::Gesture::Talk);
+                .is_ok_and(|(s, _)| s.0.unit_lootable())
+            {
+                let reach = dispatch.melee_reach(entity);
+                let can_loot = dispatch.auto.can_auto_interact() || d2 <= reach * reach;
+                dispatch.loot_unit(entity, guid, can_loot, false);
             }
         }
-        // Beyond the 5.5556 yd service range nothing is sent (no auto-approach yet).
-        UnitBranch::Service => {}
+        ApproachVerb::Use if kind == Some(EntityKind::GameObject) => {
+            let go_type = dispatch
+                .stores
+                .get(entity)
+                .map_or(-1, |(s, _)| s.0.gameobject_type_id());
+            // Still out of range, `0x5f86b0`'s range arm walks again (`0x610300`).
+            let walk = dispatch.auto.can_auto_interact();
+            dispatch.use_gameobject(
+                entity,
+                guid,
+                d2 <= cursor_mode::go_interact_range_sq(go_type),
+                walk,
+            );
+        }
+        // The spell by the target: a corpse or a player's body takes `[0xb700e8]` (`0x5f0608`).
+        ApproachVerb::Skin => {
+            let spell = if matches!(kind, Some(EntityKind::Corpse | EntityKind::Player)) {
+                dispatch.learned.skin_player_corpse
+            } else {
+                dispatch.learned.skinning
+            };
+            if let Some(spell_id) = spell {
+                let subject = if kind == Some(EntityKind::Corpse) {
+                    Subject::Corpse
+                } else {
+                    Subject::Unit { dead: true }
+                };
+                dispatch.skin(entity, guid, spell_id, subject, true, false);
+            }
+        }
+        _ => {}
     }
 }
 
@@ -1614,6 +1925,9 @@ mod tests {
         world.init_resource::<crate::ui_item_text::ItemTextOpen>();
         world.init_resource::<crate::ui_action::GoOpenerCasts>();
         world.init_resource::<Messages<crate::ui_dialog_verbs::MeetingStoneUse>>();
+        world.init_resource::<crate::player::Approach>();
+        world.init_resource::<crate::player::FollowState>();
+        world.init_resource::<crate::player::Player>();
         world.spawn((SelfPlayer, Guid(ME)));
         let boar = world
             .spawn((Guid(BOAR), store(&[(F_HEALTH, 100), (F_MAXHEALTH, 100)])))
@@ -1768,8 +2082,334 @@ mod tests {
         );
     }
 
-    /// Out of interact range the click sends nothing, like the shared arms; the reference shows
-    /// `ERR_USE_TOO_FAR` unless its auto-walk (`0x610300`) starts.
+    const VENDOR: u64 = 0x7E0D;
+
+    /// Our body alive at the origin, Click to Move set as `walk`, and a vendor at `at`.
+    fn walking_world(
+        at: Vec3,
+        walk: bool,
+    ) -> (World, Entity, crossbeam_channel::Receiver<ClientCommand>) {
+        const F_NPC_FLAGS: u16 = 147;
+        let (tx, rx) = crossbeam_channel::unbounded::<ClientCommand>();
+        let (mut world, _boar) = right_click_world();
+        world.insert_resource(NetCommands(tx));
+        world.resource_mut::<crate::player::Approach>().enabled = walk;
+        let me = world
+            .query_filtered::<Entity, With<SelfPlayer>>()
+            .single(&world)
+            .unwrap();
+        world.entity_mut(me).insert((
+            store(&[(F_HEALTH, 100), (F_MAXHEALTH, 100)]),
+            Transform::default(),
+        ));
+        let vendor = world
+            .spawn((
+                Guid(VENDOR),
+                store(&[(F_HEALTH, 100), (F_MAXHEALTH, 100), (F_NPC_FLAGS, 0x4)]),
+                Transform::from_translation(at),
+                crate::net::NetEntity {
+                    kind: benilla_protocol::EntityKind::Unit,
+                    display_id: None,
+                    scale: 1.0,
+                },
+            ))
+            .id();
+        world
+            .resource_mut::<crate::net::GuidIndex>()
+            .0
+            .insert(VENDOR, vendor);
+        (world, vendor, rx)
+    }
+
+    fn click_vendor(world: &mut World, vendor: Entity) {
+        *world.resource_mut::<PressPick>() = PressPick {
+            hovered: Hovered {
+                target: Some(vendor),
+                guid: Some(VENDOR),
+                distance: 14.0,
+                ..Hovered::default()
+            },
+            cursor: WorldCursor {
+                kind: cursor_mode::CursorKind::Buy,
+                unable: true,
+            },
+            ..PressPick::default()
+        };
+        world
+            .resource_mut::<Messages<WorldRightClick>>()
+            .write(WorldRightClick);
+        world.run_system_once(act_on_right_click).unwrap();
+    }
+
+    /// `0x5f0130`: out of reach, `CanAutoInteract` starts the walk and nothing goes out; with the
+    /// option off the click stays refused.
+    #[test]
+    fn a_far_vendor_click_walks_only_with_click_to_move_on() {
+        for walk in [true, false] {
+            let (mut world, vendor, rx) = walking_world(Vec3::new(14.0, 0.0, 0.0), walk);
+            click_vendor(&mut world, vendor);
+            assert_eq!(
+                world.resource::<crate::player::Approach>().active(),
+                walk,
+                "AutoInteract {walk}"
+            );
+            let sent: Vec<ClientCommand> = rx.try_iter().collect();
+            assert!(
+                !sent
+                    .iter()
+                    .any(|c| matches!(c, ClientCommand::ListInventory { .. })),
+                "no list before the walk ends: {sent:?}"
+            );
+        }
+    }
+
+    /// `0x60fa20` on arrival: the ladder alone, with no select and no walk of its own.
+    #[test]
+    fn an_arrival_opens_the_vendor_it_walked_to() {
+        let (mut world, _vendor, rx) = walking_world(Vec3::new(2.5, 0.0, 0.0), true);
+        world.resource_mut::<crate::player::Approach>().arrived =
+            Some((crate::player::ApproachVerb::Talk, VENDOR));
+        world.run_system_once(act_on_arrival).unwrap();
+        let sent: Vec<ClientCommand> = rx.try_iter().collect();
+        assert!(
+            matches!(
+                sent.as_slice(),
+                [ClientCommand::ListInventory { guid: VENDOR }]
+            ),
+            "{sent:?}"
+        );
+        assert!(world
+            .resource::<crate::player::Approach>()
+            .arrived
+            .is_none());
+    }
+
+    const CHEST: u64 = 0xC4E5;
+
+    fn spawn_object(world: &mut World, go_type: u32, at: Vec3) -> Entity {
+        let object = world
+            .spawn((
+                Guid(CHEST),
+                store(&[(GO_TYPE_FIELD, go_type)]),
+                Transform::from_translation(at),
+                crate::net::NetEntity {
+                    kind: benilla_protocol::EntityKind::GameObject,
+                    display_id: None,
+                    scale: 1.0,
+                },
+            ))
+            .id();
+        world
+            .resource_mut::<crate::net::GuidIndex>()
+            .0
+            .insert(CHEST, object);
+        object
+    }
+
+    fn spawn_chest(world: &mut World, at: Vec3) -> Entity {
+        spawn_object(world, 3, at)
+    }
+
+    /// Right-click the object out of reach (the cursor grayed, as for a far object), and the red
+    /// error keys the click raised.
+    fn click_far_object(world: &mut World, object: Entity, distance: f32) -> Vec<&'static str> {
+        *world.resource_mut::<PressPick>() = PressPick {
+            object: HoveredObject {
+                target: Some(object),
+                guid: Some(CHEST),
+                distance,
+            },
+            cursor: WorldCursor {
+                kind: cursor_mode::CursorKind::Interact,
+                unable: true,
+            },
+            ..PressPick::default()
+        };
+        world
+            .resource_mut::<Messages<WorldRightClick>>()
+            .write(WorldRightClick);
+        world.run_system_once(act_on_right_click).unwrap();
+        world
+            .resource::<crate::ui_action::UiErrorKeys>()
+            .0
+            .iter()
+            .map(|e| e.key)
+            .collect()
+    }
+
+    /// `0x5df2a0`: beyond melee reach the walk comes first and nothing is looted yet.
+    #[test]
+    fn a_far_body_to_loot_is_walked_to_before_the_loot() {
+        const BODY: u64 = 0xB0D7;
+        const F_DYNAMIC_FLAGS: u16 = 143;
+        let (mut world, _vendor, rx) = walking_world(Vec3::new(14.0, 0.0, 0.0), true);
+        let body = world
+            .spawn((
+                Guid(BODY),
+                store(&[(F_HEALTH, 0), (F_MAXHEALTH, 100), (F_DYNAMIC_FLAGS, 0x1)]),
+                Transform::from_xyz(0.0, 0.0, -12.0),
+            ))
+            .id();
+        *world.resource_mut::<PressPick>() = PressPick {
+            hovered: Hovered {
+                target: Some(body),
+                guid: Some(BODY),
+                distance: 12.0,
+                ..Hovered::default()
+            },
+            cursor: WorldCursor {
+                kind: cursor_mode::CursorKind::Pickup,
+                unable: false,
+            },
+            ..PressPick::default()
+        };
+        world
+            .resource_mut::<Messages<WorldRightClick>>()
+            .write(WorldRightClick);
+        world.run_system_once(act_on_right_click).unwrap();
+        assert!(world.resource::<crate::player::Approach>().active());
+        assert!(!rx
+            .try_iter()
+            .any(|c| matches!(c, ClientCommand::Loot { .. })));
+    }
+
+    /// `0x611130`: a Loot walk stops at the square root (`0x6111ab`) of the linear melee reach
+    /// `0x6112b6` stores: `sqrt(5)` for a corpse (`0x611317`), `sqrt(max(rA + rB + 1.3333, 5))`
+    /// for a unit.
+    #[test]
+    fn a_loot_walk_stops_at_the_square_root_of_the_melee_reach() {
+        const BODY: u64 = 0xB0D7;
+        const CORPSE: u64 = 0xC0D5;
+        const F_DYNAMIC_FLAGS: u16 = 143;
+        const F_COMBAT_REACH: u16 = 130;
+        let loot_click = |world: &mut World, hovered: Hovered| {
+            *world.resource_mut::<PressPick>() = PressPick {
+                hovered,
+                cursor: WorldCursor {
+                    kind: cursor_mode::CursorKind::Pickup,
+                    unable: false,
+                },
+                ..PressPick::default()
+            };
+            world
+                .resource_mut::<Messages<WorldRightClick>>()
+                .write(WorldRightClick);
+            world.run_system_once(act_on_right_click).unwrap();
+        };
+        // A unit of reach 4 against our default 1.5: 4 + 1.5 + 1.3333 = 6.8333.
+        let (mut world, _vendor, _rx) = walking_world(Vec3::new(14.0, 0.0, 0.0), true);
+        let body = world
+            .spawn((
+                Guid(BODY),
+                store(&[
+                    (F_HEALTH, 0),
+                    (F_MAXHEALTH, 100),
+                    (F_DYNAMIC_FLAGS, 0x1),
+                    (F_COMBAT_REACH, 4.0_f32.to_bits()),
+                ]),
+                Transform::from_xyz(0.0, 0.0, -12.0),
+            ))
+            .id();
+        loot_click(
+            &mut world,
+            Hovered {
+                target: Some(body),
+                guid: Some(BODY),
+                distance: 12.0,
+                ..Hovered::default()
+            },
+        );
+        let stop = world
+            .resource::<crate::player::Approach>()
+            .stop_distance()
+            .expect("the unit walk starts");
+        assert!(
+            (stop - (4.0_f32 + 1.5 + 1.333_333_3).sqrt()).abs() < 1e-3,
+            "{stop}"
+        );
+        // A corpse object has no unit to look up: reach 5.0, stop sqrt(5).
+        let (mut world, _vendor, _rx) = walking_world(Vec3::new(14.0, 0.0, 0.0), true);
+        let corpse = world
+            .spawn((
+                Guid(CORPSE),
+                store(&[(benilla_protocol::field::FIELD_CORPSE_DYNAMIC_FLAGS, 0x1)]),
+                Transform::from_xyz(0.0, 0.0, -12.0),
+            ))
+            .id();
+        loot_click(
+            &mut world,
+            Hovered {
+                corpse: Some(corpse),
+                corpse_guid: Some(CORPSE),
+                distance: 12.0,
+                ..Hovered::default()
+            },
+        );
+        let stop = world
+            .resource::<crate::player::Approach>()
+            .stop_distance()
+            .expect("the corpse walk starts");
+        assert!((stop - 5.0_f32.sqrt()).abs() < 1e-5, "{stop}");
+    }
+
+    /// `0x5f86b0` → `0x610300`: a far object's use walks first, its range read off the object.
+    #[test]
+    fn a_far_object_is_walked_to_before_its_use() {
+        let (mut world, _vendor, rx) = walking_world(Vec3::new(14.0, 0.0, 0.0), true);
+        let chest = spawn_chest(&mut world, Vec3::new(0.0, 0.0, -20.0));
+        *world.resource_mut::<PressPick>() = PressPick {
+            object: HoveredObject {
+                target: Some(chest),
+                guid: Some(CHEST),
+                distance: 20.0,
+            },
+            cursor: WorldCursor {
+                kind: cursor_mode::CursorKind::Interact,
+                unable: true,
+            },
+            ..PressPick::default()
+        };
+        world
+            .resource_mut::<Messages<WorldRightClick>>()
+            .write(WorldRightClick);
+        world.run_system_once(act_on_right_click).unwrap();
+        assert!(world.resource::<crate::player::Approach>().active());
+        assert!(!rx
+            .try_iter()
+            .any(|c| matches!(c, ClientCommand::GameObjUse { .. })));
+    }
+
+    /// An arrival short of the object's range walks again, as `0x5f86b0`'s range arm does.
+    #[test]
+    fn an_object_still_out_of_range_on_arrival_is_walked_to_again() {
+        let (mut world, _vendor, rx) = walking_world(Vec3::new(14.0, 0.0, 0.0), true);
+        spawn_chest(&mut world, Vec3::new(0.0, 0.0, -20.0));
+        world.resource_mut::<crate::player::Approach>().arrived =
+            Some((crate::player::ApproachVerb::Use, CHEST));
+        world.run_system_once(act_on_arrival).unwrap();
+        assert!(world.resource::<crate::player::Approach>().active());
+        assert!(!rx
+            .try_iter()
+            .any(|c| matches!(c, ClientCommand::GameObjUse { .. })));
+    }
+
+    /// The arm's leash (`0x6110a0`): at 80 yd "Target is too far away." and no walk.
+    #[test]
+    fn a_vendor_80_yards_off_is_too_far_to_walk_to() {
+        let (mut world, vendor, _rx) = walking_world(Vec3::new(80.0, 0.0, 0.0), true);
+        click_vendor(&mut world, vendor);
+        assert!(!world.resource::<crate::player::Approach>().active());
+        let keys: Vec<&str> = world
+            .resource::<crate::ui_action::UiErrorKeys>()
+            .0
+            .iter()
+            .map(|e| e.key)
+            .collect();
+        assert_eq!(keys, vec!["ERR_AUTOFOLLOW_TOO_FAR"]);
+    }
+
+    /// Out of interact range the click sends nothing and raises `ERR_USE_TOO_FAR` (`0x5f874b`),
+    /// the stone's own use slot (`0x5f69d0`) never running.
     #[test]
     fn an_out_of_range_meeting_stone_click_sends_nothing() {
         const STONE: u64 = 0x5702;
@@ -1801,5 +2441,63 @@ mod tests {
             .next()
             .is_none());
         assert!(rx.try_iter().next().is_none());
+        let keys: Vec<&str> = world
+            .resource::<crate::ui_action::UiErrorKeys>()
+            .0
+            .iter()
+            .map(|e| e.key)
+            .collect();
+        assert_eq!(keys, vec!["ERR_USE_TOO_FAR"]);
+    }
+
+    /// `0x5f86b0`: the usable test (`0x5f3130`) refuses out of range with `0xe1`, and with the
+    /// option off the auto-walk (`0x610300`) is false, so `0x5f874b` raises `ERR_USE_TOO_FAR`: for
+    /// the shared arms and the mailbox, text and stone, whose slot `+0x18` is the same test.
+    #[test]
+    fn a_far_object_click_is_too_far_with_click_to_move_off() {
+        for go_type in [3, 9, 19, 23] {
+            let (mut world, _vendor, rx) = walking_world(Vec3::new(14.0, 0.0, 0.0), false);
+            let object = spawn_object(&mut world, go_type, Vec3::new(0.0, 0.0, -20.0));
+            let keys = click_far_object(&mut world, object, 20.0);
+            assert_eq!(keys, vec!["ERR_USE_TOO_FAR"], "type {go_type}");
+            assert!(!world.resource::<crate::player::Approach>().active());
+            assert!(rx.try_iter().next().is_none(), "type {go_type}");
+        }
+    }
+
+    /// The arm's leash (`0x6110a0`) refuses the walk with `0x126`, and `0x610300` returns false, so
+    /// `0xe1` follows.
+    #[test]
+    fn a_leashed_far_object_click_raises_both_errors_in_order() {
+        let (mut world, _vendor, _rx) = walking_world(Vec3::new(14.0, 0.0, 0.0), true);
+        let chest = spawn_chest(&mut world, Vec3::new(0.0, 0.0, -90.0));
+        let keys = click_far_object(&mut world, chest, 90.0);
+        assert_eq!(keys, vec!["ERR_AUTOFOLLOW_TOO_FAR", "ERR_USE_TOO_FAR"]);
+        assert!(!world.resource::<crate::player::Approach>().active());
+    }
+
+    /// A walk that starts raises nothing.
+    #[test]
+    fn a_walkable_far_object_click_raises_no_error() {
+        let (mut world, _vendor, _rx) = walking_world(Vec3::new(14.0, 0.0, 0.0), true);
+        let chest = spawn_chest(&mut world, Vec3::new(0.0, 0.0, -20.0));
+        let keys = click_far_object(&mut world, chest, 20.0);
+        assert!(keys.is_empty(), "{keys:?}");
+        assert!(world.resource::<crate::player::Approach>().active());
+    }
+
+    /// A fishing node, out of its 100 yd, never takes the walk (`0x5f8705`) and goes straight to
+    /// `0x5f874b`.
+    #[test]
+    fn a_far_fishing_node_is_too_far_even_with_click_to_move_on() {
+        let (mut world, _vendor, _rx) = walking_world(Vec3::new(14.0, 0.0, 0.0), true);
+        let node = spawn_object(
+            &mut world,
+            cursor_mode::GO_TYPE_FISHINGNODE as u32,
+            Vec3::new(0.0, 0.0, -120.0),
+        );
+        let keys = click_far_object(&mut world, node, 120.0);
+        assert_eq!(keys, vec!["ERR_USE_TOO_FAR"]);
+        assert!(!world.resource::<crate::player::Approach>().active());
     }
 }
diff --git a/crates/benilla-app/src/target/cursor_mode.rs b/crates/benilla-app/src/target/cursor_mode.rs
index 57167d01..2c9d5350 100644
--- a/crates/benilla-app/src/target/cursor_mode.rs
+++ b/crates/benilla-app/src/target/cursor_mode.rs
@@ -150,12 +150,16 @@ const ATTACK_RANGE_SQ: f32 = 109.2025;
 /// floor, so large creatures reach farther. Gates skin (`0x6e3480`) and loot (`CanLootNow
 /// 0x5ec110`), center to center, boundary-inclusive.
 const MELEE_OFFSET: f32 = 1.333_33;
-const MELEE_FLOOR: f32 = 5.0;
+pub(super) const MELEE_FLOOR: f32 = 5.0;
+
+pub(super) fn melee_reach(target: &ObjectStore, me: &ObjectStore) -> f32 {
+    (target.0.unit_combat_reach() + me.0.unit_combat_reach() + MELEE_OFFSET).max(MELEE_FLOOR)
+}
 
 /// A corpse's interact reach, squared: a flat 5 yd, since a corpse has no combat reach and the
 /// melee formula falls to its floor. `CanLootNow 0x5ec110` and the `CMSG_LOOT` sender `0x5df130`
 /// both compare against 25.0.
-const CORPSE_INTERACT_RANGE_SQ: f32 = 25.0;
+pub(super) const CORPSE_INTERACT_RANGE_SQ: f32 = 25.0;
 
 /// `GAMEOBJECT_TYPE_GENERIC`: decoration whose highlightable slot is constant false (`0x5f47f0`),
 /// so it never shows an interact cursor.
@@ -203,7 +207,7 @@ pub(crate) const GO_TYPE_FISHINGNODE: i32 = 17;
 /// `GAMEOBJECT_TYPE_CHAIR` (7): its own range predicate `0x5f5670` accepts within 3.0 yd
 /// (`[0xc4d808]`, written only by `0x5f98b0` as 3.0 squared).
 pub(crate) const GO_TYPE_CHAIR: i32 = 7;
-fn go_interact_range_sq(type_id: i32) -> f32 {
+pub(super) fn go_interact_range_sq(type_id: i32) -> f32 {
     match type_id {
         GO_TYPE_FISHINGNODE => 100.0 * 100.0,
         // Measured to the object; the reference (seats from `0x5f5760`) and vmangos
@@ -493,6 +497,8 @@ struct CorpseFacts {
     dist_sq: f32,
     /// The already-looting override: `[player+0x1d28/2c] == corpse GUID`.
     looting_this: bool,
+    /// `CanAutoInteract`, which `CanLootNow` asks first and then skips its range (`0x5ec11b`).
+    can_auto_interact: bool,
     auto_loot: bool,
     /// Key 0, shift.
     shift_held: bool,
@@ -502,7 +508,7 @@ fn corpse_cursor(f: CorpseFacts) -> Option<(CursorKind, bool)> {
     // Leg 1, lootable: able within `CanLootNow 0x5ec110`'s reach or while this corpse's loot
     // window is open; Pickup or LootAll by key 0 (`0x41f8f0` at `0x4827f8`), grayed at `0x482818`.
     if f.lootable {
-        let able = f.dist_sq <= CORPSE_INTERACT_RANGE_SQ || f.looting_this;
+        let able = f.can_auto_interact || f.dist_sq <= CORPSE_INTERACT_RANGE_SQ || f.looting_this;
         return Some((loot_cursor(f.auto_loot, f.shift_held), !able));
     }
     // Leg 2, the PvP insignia (`0x482875..0x4828a2`), inert in 1.12.1 as no player holds a
@@ -523,7 +529,7 @@ pub(super) fn classify_cursor(
     reputations: Res<Reputations>,
     (mut cursor, mut fork): (ResMut<WorldCursor>, ResMut<AttackFork>),
     // `control_lost` is the attack leg's `[0xb4b3e4]` clear.
-    player: Res<crate::player::Player>,
+    (player, approach): (Res<crate::player::Player>, Res<crate::player::Approach>),
     units: Query<(
         &Transform,
         Option<&ObjectStore>,
@@ -542,6 +548,11 @@ pub(super) fn classify_cursor(
     // `[0xb72038]`, the queued area; absent in a headless build, which reads as not queued.
     stone: Option<Res<crate::ui_dialog_verbs::MeetingStone>>,
 ) {
+    let can_auto_interact = crate::player::can_auto_interact(
+        approach.enabled,
+        self_q.single().ok().map(|(_, s)| s),
+        &player,
+    );
     // A GameObject that is not highlightable clears the cursor, as the reference's handler does.
     let resolve_go = || {
         let (go_tf, store, anim) = units.get(hovered_object.target?).ok()?;
@@ -606,8 +617,7 @@ pub(super) fn classify_cursor(
         let store = store?;
         let (self_tf, self_store) = self_q.single().ok()?;
         let dist_sq = unit_tf.translation.distance_squared(self_tf.translation);
-        let reach = (store.0.unit_combat_reach() + self_store.0.unit_combat_reach() + MELEE_OFFSET)
-            .max(MELEE_FLOOR);
+        let reach = melee_reach(store, self_store);
         let in_melee = dist_sq <= reach * reach;
 
         let dead = store.0.unit_is_dead();
@@ -616,7 +626,10 @@ pub(super) fn classify_cursor(
                 // Grayed by `CanLootNow 0x5ec110`'s melee reach; the reference's mid-loot state
                 // block and open-loot-window override are not applied to units.
                 let shift = keys.pressed(KeyCode::ShiftLeft) || keys.pressed(KeyCode::ShiftRight);
-                return Some((loot_cursor(loot_cfg.auto_loot, shift), !in_melee));
+                return Some((
+                    loot_cursor(loot_cfg.auto_loot, shift),
+                    !(can_auto_interact || in_melee),
+                ));
             }
             // Skin also needs the learn latch `[0xb700e4 + 4×isPlayerTarget]` (`0x482589`): a
             // player who has learned no Skinning spell sees Point.
@@ -666,6 +679,7 @@ pub(super) fn classify_cursor(
             skin_latch: learned.skin_player_corpse.is_some(),
             dist_sq: corpse_tf.translation.distance_squared(self_tf.translation),
             looting_this: loot_latch.0.is_some() && loot_latch.0 == hovered.corpse_guid,
+            can_auto_interact,
             auto_loot: loot_cfg.auto_loot,
             shift_held: shift,
         })
@@ -693,6 +707,25 @@ mod tests {
     use super::*;
     use benilla_protocol::messages::dialog_status;
 
+    /// `CanLootNow 0x5ec110` skips its range under `CanAutoInteract` (`0x5ec11b`), so the click
+    /// that walks there finds a lit pouch.
+    #[test]
+    fn click_to_move_lights_a_far_corpses_pouch() {
+        let far = CorpseFacts {
+            lootable: true,
+            dist_sq: 400.0,
+            ..CorpseFacts::default()
+        };
+        assert_eq!(corpse_cursor(far), Some((CursorKind::Pickup, true)));
+        assert_eq!(
+            corpse_cursor(CorpseFacts {
+                can_auto_interact: true,
+                ..far
+            }),
+            Some((CursorKind::Pickup, false))
+        );
+    }
+
     #[test]
     fn the_corpse_classifier_has_two_legs_and_no_own_corpse_leg() {
         let near = 25.0; // exactly the gate, which is inclusive
diff --git a/crates/benilla-app/src/target/mod.rs b/crates/benilla-app/src/target/mod.rs
index 4006c6e1..ff7abf2f 100644
--- a/crates/benilla-app/src/target/mod.rs
+++ b/crates/benilla-app/src/target/mod.rs
@@ -326,7 +326,8 @@ impl Plugin for TargetPlugin {
                     // order is free.
                     crate::spell::targeting::commit_ground_cast_on_click,
                     crate::spell::targeting::commit_object_cast_on_click,
-                    click::act_on_right_click,
+                    // The verb a walk owes runs at its stop, ahead of this frame's click.
+                    (click::act_on_arrival, click::act_on_right_click).chain(),
                     // The loot close's guid-scoped deselect.
                     click::clear_target_requests,
                     // The script calls that touch the selection, the cast or the targeting cursor
diff --git a/crates/benilla-app/src/ui_chat/idle.rs b/crates/benilla-app/src/ui_chat/idle.rs
index 49ce968c..af38230e 100644
--- a/crates/benilla-app/src/ui_chat/idle.rs
+++ b/crates/benilla-app/src/ui_chat/idle.rs
@@ -90,9 +90,10 @@ pub(crate) struct IdleGates {
     /// `UNIT_FIELD_MOUNTDISPLAYID > 0`, the sit's.
     pub(crate) mounted: bool,
     /// The sit's fourth gate (`0x482f84 call 0x6103a0`): for a solo player, the movement-action
-    /// mode `[0xc4d888]` at its in-world `0xc`. `/follow` sets 3 (`FollowUnit 0x489e00`) and
-    /// autorun never moves it, so a follower whose target has stopped is not seated.
-    pub(crate) following: bool,
+    /// mode `[0xc4d888]` at its in-world `0xc`. `/follow` sets 3 (`FollowUnit 0x489e00`), Click to
+    /// Move 5 to 9, and autorun never moves it, so a follower whose target has stopped is not
+    /// seated.
+    pub(crate) auto_moving: bool,
     /// `UNIT_FIELD_FLAGS` bit 20 (`0x100000`), the AFK's, not the sit's.
     pub(crate) on_taxi: bool,
     /// The optimistic mirror `[0xb6e5cc]`: the AFK's second gate, and its anti-repeat.
@@ -114,7 +115,7 @@ pub(crate) fn idle_action(idle: Duration, gates: IdleGates) -> IdleAction {
         };
     }
     IdleAction {
-        sit: gates.stand_state == 0 && !gates.in_combat && !gates.mounted && !gates.following,
+        sit: gates.stand_state == 0 && !gates.in_combat && !gates.mounted && !gates.auto_moving,
         afk: !gates.on_taxi && !gates.afk,
         camp: false,
     }
@@ -131,6 +132,7 @@ pub(crate) fn idle_handler(
     commands: Res<crate::net::NetCommands>,
     mut stand: MessageWriter<crate::player::StandStateRequest>,
     follow: Res<crate::player::FollowState>,
+    approach: Res<crate::player::Approach>,
     logout: Res<crate::ui_logout::LogoutState>,
 ) {
     let idle = time.elapsed().saturating_sub(last.0);
@@ -148,7 +150,7 @@ pub(crate) fn idle_handler(
             mounted: store.0.unit_mount_display_id() != 0,
             on_taxi: flags & crate::player::UNIT_FLAG_TAXI_FLIGHT != 0,
             afk: mirror.is_afk(),
-            following: follow.guid.is_some(),
+            auto_moving: follow.guid.is_some() || approach.active(),
         }
     });
     let action = match gates {
@@ -325,7 +327,7 @@ mod tests {
                  `[0xc4d888]` non-`0xc` implies translating, which `stand_state_refused` refuses \
                  downstream. The AFK mark is untouched: it is not one of the sit's gates",
                 IdleGates {
-                    following: true,
+                    auto_moving: true,
                     ..open()
                 },
                 IdleAction {
@@ -501,6 +503,7 @@ mod tests {
             .init_resource::<ChatLog>()
             .init_resource::<LastInput>()
             .init_resource::<crate::player::FollowState>()
+            .init_resource::<crate::player::Approach>()
             .init_resource::<crate::ui_logout::LogoutState>()
             .add_message::<crate::player::StandStateRequest>()
             .insert_resource(NetCommands(tx));
diff --git a/crates/benilla-app/src/ui_script/options_tests.rs b/crates/benilla-app/src/ui_script/options_tests.rs
index 229dbd9e..ce8c4338 100644
--- a/crates/benilla-app/src/ui_script/options_tests.rs
+++ b/crates/benilla-app/src/ui_script/options_tests.rs
@@ -1796,6 +1796,39 @@ fn the_controls_checkboxes_write_flags_with_the_interface_panel_kit() {
     assert!(s.errors().is_empty(), "script errors: {:?}", s.errors());
 }
 
+/// Click-to-Move (`UIOptionsFrame.lua:7`) moves `AutoInteract`, which boots off as 1.12's Western
+/// client registers it (`0x603374`).
+#[test]
+fn the_controls_page_offers_click_to_move_on_autointeract() {
+    benilla_formats::wow_data_or_skip!();
+    let mut s = harness_on(audio_harness());
+    s.run("ShowUIPanel(BenillaOptionsFrame)").unwrap();
+    let _ = s.take_cvar_changes();
+    let row = "BenillaOptionsFrameContainerBodyControlsRowClickToMove";
+    assert_eq!(
+        s.eval::<String>(&format!("return {row}Label:GetText()"))
+            .unwrap(),
+        "Click-to-Move"
+    );
+    assert!(
+        !s.eval::<bool>(&format!("return {row}Check:GetChecked()"))
+            .unwrap(),
+        "off by default"
+    );
+
+    s.run(&format!("{row}Check:Click()")).unwrap();
+    assert_eq!(
+        s.take_cvar_changes(),
+        vec![("AutoInteract".to_string(), "1".to_string())]
+    );
+    assert_eq!(
+        s.eval::<String>("return GetCVar(\"AutoInteract\")")
+            .unwrap(),
+        "1"
+    );
+    assert!(s.errors().is_empty(), "script errors: {:?}", s.errors());
+}
+
 #[test]
 fn defaults_resets_the_controls_page_to_registered_defaults() {
     benilla_formats::wow_data_or_skip!();
@@ -2281,9 +2314,9 @@ fn every_row_tooltip_key_resolves_in_the_real_global_strings() {
         );
         checked += 1;
     }
-    // 82 rows less the three untipped below; four of the 79 carry a `BENILLA_` key, and a dropdown
+    // 83 rows less the three untipped below; four of the 80 carry a `BENILLA_` key, and a dropdown
     // row is checked on the key it wears at rest.
-    assert_eq!(checked, 79, "every tipped row carries a live key");
+    assert_eq!(checked, 80, "every tipped row carries a live key");
     assert_eq!(
         untipped,
         vec![
@@ -2379,8 +2412,8 @@ fn every_flavor_of_row_raises_its_plate_from_the_page_it_lives_on() {
             s.errors()
         );
     }
-    // Every tipped row: the same 79 the key census counts.
-    assert_eq!(raised, 79, "every row but Auto Loot raises a description");
+    // Every tipped row: the same 80 the key census counts.
+    assert_eq!(raised, 80, "every row but Auto Loot raises a description");
 }
 
 /// 1.12's AdvancedOptionsCombatText box as saved-global rows: a click writes the global, never a
@@ -4036,17 +4069,6 @@ fn without_a_seated_measurer_the_same_fit_reads_zero() {
 // nothing and reads back nil, so its box would offer a setting benilla does not have. A CVar is
 // registered only once something reads it.
 const UNBACKED_REFERENCE_CVARS: &[(&str, &str)] = &[
-    (
-        "autointeract",
-        "click-to-move — the one row here that is a whole movement mode rather than a knob. \
-         `CanAutoInteract 0x60f900` gates the world-click pick mask's bit 0 and inverts \
-         `0x5ec110`'s interaction-distance refusal, so an out-of-range corpse/GO/NPC/cast click \
-         queues an approach (`0x60fed0`, move kinds 6/7/9/0xa) instead of refusing. The commit \
-         itself puts NOTHING on the wire — it stamps a local goal at `0x611130` — and the packets \
-         are its consequences (a stand, then the original verb on arrival). benilla has only the \
-         keyboard controller and /follow (mode 3). Registered default is \"0\" on every locale but \
-         koKR (`0x603374` selects on the locale index), so stock West ships it OFF",
-    ),
     (
         "UnitNamePlayerPVPTitle",
         "the PvP rank prefix on the overhead name line — slot a4 of `0x608f50`, bit `0x20` of the \