# Inbound motion deviation map — remote-entity animation + position vs retail

Date: 2026-07-02
Mode: **/investigate report — no code changes made.** This doc + the four mapper
reports under `2026-07-02-inbound-motion-maps/` are the only writes (uncommitted).
Branch: `claude/vigorous-joliot-f0c3ad`. Follows the handoff
`2026-07-02-inbound-motion-verbatim-port-handoff.md`.

## Symptom (acceptance oracle — user's live observation, axiom)

Watching a remote player in acdream: walk↔run transitions WITHOUT stopping react
too slowly in the motion interpreter, throwing animation + position off afterward
and compounding through continued running/turning; plus general sliding + position
errors on stop.

## Headline findings

1. **The premise behind acdream's current walk↔run mechanism is refuted.** The
   #39-era UP-velocity refinement layer (`ApplyPlayerLocomotionRefinement`,
   0.2 s UM-grace + 5–10 Hz UP cadence + 5.5/4.5 m/s hysteresis) was built on the
   2026-05-06 finding "the wire goes silent on Shift-toggle." Both oracles now
   contradict that finding:
   - **Retail sends.** `CommandInterpreter`'s HoldRun command handler
     (`0x85000001`, pseudo-C `acclient_2013_pseudo_c.txt:699322-699328`, addr
     0x006b37a8→0x006b3852) calls `SetHoldRun` then `SendMovementEvent()`
     **whenever the player is not standing still** — i.e. a Shift toggle while W
     is held emits a fresh MoveToState. (Same for HoldSidestep `0x85000002`.)
   - **ACE relays.** `GameActionMoveToState.cs:36` calls
     `BroadcastMovement(moveToState)` **unconditionally** for every inbound
     MoveToState (`Player_Networking.cs:364-365` → `GameMessageUpdateMotion`
     broadcast, with the WalkForward+HoldKey.Run→RunForward upgrade and
     run-skill speed recompute).
   So an observer **should** receive a UM with ForwardCommand flipping
   Walk↔Run on every Shift toggle. Why the 2026-05-06 clean test saw only
   Ready↔Run `[FWD_WIRE]` transitions is the one open empirical question —
   settle it with probe S0 below before touching the refinement layer.
2. **Retail never adapts animation from observed pace.** Three independent decomp
   dives + the ACE port cross-check all converge: the inbound position path
   (0xF748/0xF619 → `SmartBox::HandleReceivedPosition` → `MoveOrTeleport` →
   `InterpolationManager` chase) has **zero writes into `CMotionInterp`** — it
   only *reads* `get_adjusted_max_speed()` (×2.0) as the chase-speed cap. The
   wire's velocity field is a **dead parameter** in `MoveOrTeleport`
   (pseudo-C:284304 — passed, never dereferenced). Animation changes come only
   from motion events (0xF74C → `MovementManager::unpack_movement`).
   acdream's pace→cycle inference layer has **no retail equivalent** (DEV-2)
   and is an **unregistered deviation**.
3. **acdream's instant DR-velocity snap on walk↔run is retail-correct; the
   pose hard-cut is the real deviation.** Adversarial verification refuted the
   initial "retail paces velocity through the link clip" claim: in
   `GetObjectSequence`'s link-transition branch, `add_motion(new cycle)` is the
   LAST synchronous call and `CSequence::set_velocity` is a hard overwrite —
   the sequence velocity snaps to the new cycle's value the same tick
   (pseudo-C:298437-298468, 300798-300814; ACE `MotionTable.cs:144-168`,
   `Sequence.cs:127-130`). What acdream's Fix B loses is only the link **pose**
   (plus its authored root-motion frames): retail plays the authored
   walk↔run link clip to completion before the new cycle's animation starts.
4. **Retail's remote pipeline is one atomic funnel; acdream's is three loosely
   coupled writes.** That structural split (DEV-1) is what lets every gap
   (DEV-2/3/5/6) desync pose from velocity with nothing to reconcile them.

## The retail inbound model (what "verbatim" means here)

Two decoupled inbound paths, meeting only at the per-tick frame combiner:

**Motion events (0xF74C / 0xF619-embedded)** —
`ACSmartBox::DispatchSmartBoxEvent` (pseudo-C:357117) →
`CPhysics::SetObjectMovement` (271370, staleness-gated on `update_times[8]`) →
`MovementManager::unpack_movement` (300563, **10-way jump table**: case 0 =
InterpretedMotionState, 6/7 = MoveTo, 8/9 = TurnToObject/TurnToHeading) →
`CMotionInterp::move_to_interpreted_state` (305936: flat `copy_movement_from`
overwrite of `interpreted_state`, caches `my_run_rate` from RunForward's
forward_speed) → `apply_interpreted_movement` (305713: per-slot
`DoInterpretedMotion`/`StopInterpretedMotion` dispatch in retail order — style,
forward, sidestep-or-stop, turn-or-stop, idle-stop enqueue) →
`CMotionTable::GetObjectSequence` (298636), which decides:
- **same substate + same speed sign** → fast path: `change_cycle_speed`
  (playback rate × newSpeed/oldSpeed) + `subtract_motion`/`combine_motion`
  velocity swap — same node keeps playing, **no restart** (acdream's SCFAST
  fast-path is the equivalent);
- **substate change (walk↔run!)** → link path: `get_link` (double-hop through
  the style default when no direct link / sign flip), `clear_physics` +
  `remove_cyclic_anims` (keeps a mid-playback link, drops the old loop),
  `add_motion(link)` + `add_motion(cycle)`, `re_modify` re-applies active
  modifiers. Velocity = the **cycle's** (last overwrite, instant); pose = link
  first, then cycle.
Bookkeeping: `MotionTableManager::add_to_queue`/`remove_redundant_links`/
`CheckForCompletedMotions` (290645-290854) + `CMotionInterp::pending_motions`/
`MotionDone` (305032/305238) reconcile completed commands at anim boundaries.

**Position events (0xF748/0xF619)** — `SmartBox::HandleReceivedPosition`
(92896): for remotes, `MoveOrTeleport` (284304) only — staleness-gated
(`POSITION_TS`/`TELEPORT_TS`), >96 units from player → plain snap, else
`InterpolationManager::InterpolateTo` node queue (cap 20). Per tick,
`adjust_offset` (353071) moves the full remaining distance capped at
`2 × get_adjusted_max_speed()` (fallback 7.5 m/s), stall detection (<30%
progress per 5 frames → fail counter >3 → hard snap). **acdream's
`InterpolationManager` is already a verbatim port of this (L.3).**

**Per tick** (`UpdateObjectInternal` 283611): `CPartArray::Update` →
`CSequence::update` fills the frame delta from **the animation frames' baked
per-frame deltas** (anim-node path) or `velocity×dt` (`apply_physics` fallback);
`PositionManager::adjust_offset` **overwrites** it when a chase node is active
(last-writer-wins, NOT additive — matches acdream's `ComputeOffset` REPLACE
dichotomy); then the **full collision sweep** (`transition`) runs for remotes
too (acdream deliberately skips it for grounded player remotes — DEV-10).

**Stop** — one path for every stop: `CMotionTable::StopSequenceMotion` (298954)
re-enters `GetObjectSequence` targeting the style default with force=1:
`clear_physics` zeroes velocity/omega **at transition start**, the idle-link's
authored deceleration plays, `add_to_queue(READY)` + `RemoveMotion` bookkeeping.
Modifier stop = `subtract_motion` only. No pace-derived stop inference.

## Ranked deviation map

All 10 deviations were adversarially verified through two lenses (refute vs
current acdream code / refute vs retail decomp+ACE). 9 CONFIRMED, 1 REFUTED
(DEV-4's velocity half — corrected below). Full verify evidence:
`…/tasks/waqdgyk0m.output` (session temp) — the load-bearing citations were
additionally re-read first-hand in this session.

| # | Sev | Deviation | Symptom link |
|---|-----|-----------|--------------|
| DEV-1 | HIGH | Remote inbound bypasses the CMotionInterp funnel: bulk-copy + direct `SetCycle` instead of `move_to_interpreted_state`/`apply_interpreted_movement` | Structural root: pose + DR velocity are separate writes; every gap desyncs them with no reconciliation |
| DEV-2 | HIGH | Non-retail grace-window + hysteresis pace→cycle inference for player remotes (`UmGraceSeconds=0.2`, promote 5.5 / demote 4.5 m/s) | The direct "reacts too slowly": ≥0.2 s + UP cadence + hysteresis-crossing before the gait flips; backlog builds meanwhile. **Unregistered deviation**; premise refuted (headline 1) |
| DEV-3 | HIGH | Stop is three unwired mechanisms (UM-Ready overwrite / dead UP-velocity StopCompletely / landing); no `StopSequenceMotion` path; nothing zeroes body velocity or reconciles the queue | Direct cause of stop-slide: pose goes Ready while the body drains pre-stop waypoints at up to 2× maxSpeed |
| DEV-4 | MED (corrected) | Fix B drops the authored walk↔run link **pose** (hard visual cut + lost link root motion). ~~Velocity snap~~ — REFUTED: retail snaps velocity instantly too | Visual-only hard cut at each toggle; NOT a position-error source |
| DEV-5 | HIGH | Inbound movement types 8/9 (TurnToObject/TurnToHeading) dropped → misapplied as `SetCycle(Ready)` | Mid-locomotion turn command becomes a spurious full stop — error injected exactly during "compounding through running/turning" |
| DEV-6 | MED | Sequence-number staleness gate missing (movementSequence/serverControlSequence/isAutonomous parsed-then-discarded; retail gates on `update_times[8]`) | A reordered stale UM re-applies the old gait or un-stops a stop (extends register TS-26 to UM) |
| DEV-7 | MED | `pending_motions`/`pending_animations`/`MotionDone`/`remove_redundant_links` lifecycle absent | Enabler: missing `remove_redundant_links` is what made rapid toggles restart links forever, forcing Fix B; without MotionDone nothing clears per-transition bookkeeping |
| DEV-8 | MED | Remote DR velocity synthesized from hardcoded gait constants at SetCycle time vs retail's MotionData-accumulated CSequence velocity (+ baked per-frame anim deltas) | Any per-gait speed mismatch vs ACE's integration = constant-rate error that fills the interp backlog → discharges as slide/snap |
| DEV-9 | MED | Modifier layer missing: no `re_modify`, single-cycle selection, omega formula-seeded instead of combine/subtract | Turn contribution approximated independently of the motion table → heading-rate error while running+turning |
| DEV-10 | LOW | Bifurcated position-drive paths; grounded player remotes skip the per-tick collision sweep (retail sweeps every entity) | None for this symptom directly; parity + pass-through-geometry hazard |

### Key anchors per deviation

- **DEV-1** — retail: pseudo-C 305936 (`move_to_interpreted_state` 0x005289c0),
  305713 (`apply_interpreted_movement` 0x00528600), 298636 (`GetObjectSequence`
  0x00522860), 293301 (`copy_movement_from` 0x0051e750). acdream:
  `GameWindow.cs:4590/4598` (bulk-copy), `:4769` (separate SetCycle), `:4517`
  (comment-only funnel ref); D6.2 raw-input funnel is local-player-only
  (`PlayerMovementController.cs:761-1014`). Nuance (verify correction): the
  sidestep/turn axes DO route through `DoInterpretedMotion`/`StopInterpretedMotion`
  (`GameWindow.cs:4794-4857`); the forward axis — the crux — is the bulk-copy.
- **DEV-2** — acdream: `GameWindow.cs:5095/5104/5110` (constants),
  `:5112-5300` (both methods), `:5128-5134` (the unconfirmed-premise comment).
  Retail: no equivalent exists (searched: InterpolationManager/PositionManager
  ranges 352000-353400 — zero `CMotionInterp` writes; `MoveOrTeleport` velocity
  param dead at 284304).
- **DEV-3** — retail: 298954 (`StopSequenceMotion` 0x00522fc0), 305635
  (`StopInterpretedMotion` 0x00528470), 301194 (`clear_physics` 0x00524d50).
  acdream: `GameWindow.cs:4364-4367` (UM-Ready), `:5711-5731` (dead UP-velocity
  stop — ACE player UPs carry velocity=null per `:5700-5710`), `:5527-5553`
  (landing = only `Interp.Clear` site); plus the acdream-invented 300 ms
  stop-detection window (`GameWindow.cs:4862-4890` + TickAnimations) — also
  retail-less, part of this cluster.
- **DEV-4** — retail: 298636 link branch; 298552 (`get_link`); 301777
  (`append_animation`); velocity-overwrite refutation: 298437-298468
  (`add_motion` 0x005224b0) + 300798-300814 (`set_velocity`/`set_omega`
  overwrites), ACE `MotionTable.cs:144-168` + `Sequence.cs:127-130/221-230`.
  acdream: `AnimationSequencer.cs:585-635` (Fix B), `:686-754` (velocity
  synthesis — retail-equivalent in timing).
- **DEV-5** — retail: 300563/300707 (jump table cases 8/9 →
  `MoveToManager::TurnToObject/TurnToHeading`). acdream:
  `UpdateMotion.cs:136-238` (no case 8/9), `GameWindow.cs:4364-4367`
  (null-command → Ready misfire). Confirmed live earlier: `mt=0x09` arrives,
  acdream plays Ready (2026-06-26 audit D9).
- **DEV-6** — retail: 271370 (`SetObjectMovement` staleness gate), 357224
  (`update_times[8]` compare). acdream: `UpdateMotion.cs:89-106`,
  `UpdatePosition.cs:29-31/156` (parsed-then-discarded).
- **DEV-7** — retail: 305238 (`MotionDone` 0x00527ec0), 290854
  (`MotionTableManager::add_to_queue` 0x0051bfe0), 290771
  (`remove_redundant_links` 0x0051bf20), 290645 (`CheckForCompletedMotions`).
  acdream: `AnimationSequencer.cs:401` (always-synchronous SetCycle),
  `:1128-1129` (`AnimationDoneSentinel` exists, unconsumed by any motion
  bookkeeping).
- **DEV-8** — retail: 298437-298492 (`add_motion`/`combine_motion`/
  `subtract_motion`), 302402 (`CSequence::update` — anim-frame deltas are the
  primary drive), 305160 (`get_state_velocity` constants 3.12/4.0 — the
  *logical* values acdream synthesizes). acdream: `AnimationSequencer.cs:686-754`.
- **DEV-9** — retail: 298636 (`re_modify` at rebuild tail), 298954 (modifier
  `subtract_motion` branch), 305713 (per-slot dispatch). acdream:
  `GameWindow.cs:4648-4683` (single-cycle pick), `:4841-4847` (ObservedOmega
  formula seed), `:10097-10106` (manual omega integration).
- **DEV-10** — retail: 280817/283611 (sweep for all entities). acdream:
  `GameWindow.cs:9717-9722` (fork), `:9883-9890` (sweep skipped, player-remote
  path), `:10156-10181` (sweep present, NPC path), `:5657` (NPC UP hard-snap).

## Recommended port campaign (for approval — no code written yet)

Ordered so each slice is independently landable, tests-first, minimal-surgery
(no sequencer rewrite; `SetCycle` internals stay). Every slice updates
`docs/architecture/retail-divergence-register.md` in the same commit.

- **S0 — the wire probe (no code).** Live capture, acdream as observer,
  actor driven from retail: `ACDREAM_DUMP_MOTION=1 ACDREAM_REMOTE_VEL_DIAG=1`,
  structured protocol with the walk↔run Shift toggle as the centerpiece;
  optionally WireMCP on loopback :9000 for the raw S→C bytes. Expected per the
  oracles: a UM with ForwardCommand flipping Walk↔Run on every toggle
  (`[UM_RAW]` is the arbiter — the 2026-05-06 test read `[FWD_WIRE]`, which
  only fires on interpreted-command *change* after acdream's own resolution).
  Outcome decides DEV-2's disposition. *(Needs the user driving the retail
  client — this is the one stop-and-wait step.)*
- **S1 — DEV-6 staleness gate.** ~30 isolated lines: capture the two u16s into
  `UpdateMotion.Parsed`, retail wraparound-newer compare per guid, drop stale.
  Unit-testable against the 0x7fff wraparound rule. Safe first commit.
- **S2 — DEV-1 funnel (the centerpiece), absorbing DEV-3 + DEV-9 dispatch.**
  Port `move_to_interpreted_state` + `apply_interpreted_movement` into
  `MotionInterpreter`, with `DoInterpretedMotion` routing to the existing
  `AnimationSequencer.SetCycle` as the `GetObjectSequence` backend.
  `OnLiveMotionUpdated`'s remote SubState branch collapses to one
  `move_to_interpreted_state(ims)` call; stop flows through
  `StopInterpretedMotion` (no `Interp.Clear()` band-aid — the queue's final
  waypoints ARE the true stop position); sidestep/turn become per-slot retail
  dispatch. Parity test first: replay a captured UM stream through old + new
  paths, assert identical SetCycle sequence + InterpretedState trace; then a
  stop-slide acceptance case.
- **S3 — DEV-7 bookkeeping.** `MotionTableManager` companion (pending_animations,
  `add_to_queue`, `remove_redundant_links`, `CheckForCompletedMotions`) wiring
  the existing `AnimationDoneSentinel`; `pending_motions`/`MotionDone` in
  `MotionInterpreter` second. Additive, decomp-semantics unit tests first.
- **S4 — DEV-4 corrected: retire Fix B.** Restore the link-pose enqueue for
  locomotion↔locomotion now that S3's `remove_redundant_links` removes Fix B's
  original justification (link-restart spam). Velocity stays instant
  (retail-correct). Acceptance: user visual side-by-side.
- **S5 — DEV-2 disposition per S0.** If UMs arrive: delete the refinement layer
  (dead weight + latency + feedback loop) and let the S2 funnel drive. If the
  wire is genuinely silent: keep a minimal layer as an explicitly registered
  ACE-adaptation row (a retail client on the same wire would show the stale
  gait too — matching retail display means NOT inferring), and file the gap
  against ACE. Either way DEV-2's machinery stops being an unregistered
  deviation.
- **S6 — remainder.** DEV-5 (parse types 8/9 → heading target; cross-check field
  order vs Chorizite + holtburger first), DEV-8 (evidence first: dump Humanoid
  MotionTable Walk/Run `MotionData.Velocity`+Flags from the dat, diff synthesized
  magnitudes vs ACE's integration), DEV-10 deferred (fold-in after S2; NPC
  hard-snap replacement needs explicit user approval per the reverted-campaign
  precedent).

## What we've ruled out

- "acdream lacks any transition machinery" — false; `SetCycle` resolves authored
  links (`GetLink`) and has the retail same-substate fast path (SCFAST ≈
  `change_cycle_speed`).
- "Retail paces the walk↔run *velocity* change through the link clip" — refuted
  (headline 3); instant velocity snap is retail-correct.
- "Retail refines the remote's cycle from UP-derived velocity" (#39's premise)
  — refuted; no such mechanism exists in the decomp (two independent dives +
  ACE cross-check).
- The `InterpolationManager` chase itself — already a verbatim port (L.3);
  constants re-verified this session (2× adjusted max speed, 0.05 desired
  distance, 30%/5-frame stall, fail>3 blip, 20-node cap, 96-unit gate upstream).

## What this is NOT

This is NOT a "port the whole CSequence/CPartArray stack" campaign — the
sequencer's node/link/queue mechanics are close enough that the funnel (DEV-1),
bookkeeping (DEV-7), and stop path (DEV-3) can be ported around it surgically;
and it is NOT a dead-reckoning-tuning problem — the chase is already retail,
it's the inputs (cycle + velocity source + stop signal) that deviate.

## S0 wire-probe RESULTS (2026-07-02, post-S1 live capture)

Observer acdream (+Acdream), actor retail-driven (guid 0x5000000B), structured
protocol incl. Shift toggles. 280 UMs captured (`launch-s0-wireprobe.log`).

1. **The wire is NOT silent — DEV-2's premise is dead.** Walk↔run toggles
   arrive explicitly: `fwd=0x0005 fwdSpd=null(=1.0)` ↔ `fwd=0x0007
   fwdSpd=2.85`. Root cause of the 2026-05-06 misreading: retail's
   default-difference packing baselines `forward_command` against **Ready**
   (`RawMotionState.Default`, our own D6.2b verbatim port) — W-held is
   non-default and always packed, so ACE (`MovementData.cs:104-119`) always
   re-emits it with the holdKey upgrade + run-skill speed.
2. **flags=0 "empty" autonomous UMs are frequent (127/209) and LEGITIMATE**
   — they are genuine keys-released / heading-only MoveToState relays
   (all-default raw state packs nothing; ACE `RawMotionState.Read` leaves
   absent = Invalid; `MovementData` emits nothing). Retail semantics
   (verified: `InterpretedMotionState` ctor 0x0051e8d0 defaults
   `forward_command=Ready`; `MovementManager::unpack_movement` case 0
   UnPacks into a default-constructed state;
   `CMotionInterp::move_to_interpreted_state` 0x005289c0 does a FLAT
   `copy_movement_from` + `apply_current_movement`): an empty UM = a real
   full stop. acdream already maps it to Ready — but the DEV-2 refinement
   then re-promotes the cycle from UP pace after the 0.2 s grace, producing
   a Ready↔Run thrash against legitimate stop signals. That thrash is the
   observed flicker/rubber-band component.
3. **S1 gate validated live**: 0 `[UM_STALE]` drops across 280 UMs;
   movementSeq advances +1 per UM; byte-level layout confirmed
   (`instanceSeq|movementSeq|serverControlSeq|isAutonomous` exactly where
   the parser reads them).
4. Also confirmed in `unpack_movement` (0x00524440) for the S2 port: the
   outer style u16 routes through `command_ids[]` and applies via
   `DoMotion` ONLY when it differs from the current style; motionFlags
   carries sticky-object (0x100 → `stick_to_object`) and standing_longjump
   (0x200); the actions list is consumed under a 15-bit
   `server_action_stamp` wraparound compare
   (`move_to_interpreted_state` 0x005289c0, lines 305953-305989).

**Disposition: S5 = delete the player pace-inference layer** (executed in the
same session; NPC `PlanFromVelocity` path untouched — its unification is S6).

## Provenance

- Workflow `wf_b92a5670-283`: 4 read-only mappers (retail decomp / ACE port /
  acdream code / prior-research claims — full reports preserved in
  `2026-07-02-inbound-motion-maps/`) → synthesis → 2-lens adversarial verify
  per deviation (25 agents, ~3.0 M tokens). The ACE-port mapper crashed on
  structured output AFTER writing its report file; synthesis read all four
  files. One verify lens (DEV-4 retail side) delivered the REFUTED verdict
  incorporated above.
- Targeted agents: retail remote-anim adaptation dive (+2 children:
  InterpolationManager decomp dump, ACE InterpolationManager cross-check).
- First-hand session reads: `OnLiveMotionUpdated` (GameWindow 4230-4930),
  DR tick path (9700-9920), `AnimationSequencer.SetCycle` (340-790),
  `ApplyServerControlledVelocityCycle`/`ApplyPlayerLocomotionRefinement`
  (5077-5300), `ServerControlledLocomotion`, `PositionManager`,
  `InterpolationManager`, `UpdatePosition` parser, ACE `Player_Tick.cs` /
  `Player_Networking.cs` / `GameActionMoveToState.cs`, decomp
  `SendMovementEvent`/HoldRun sites (699274-700312), 2026-06-04 deep-dive
  divergence list, ISSUES #39, divergence register scan.
- Corrections applied to the raw workflow output: DEV-1 anchor fix
  (`MotionInterpreter.cs:399/412/558` reference different retail functions —
  the only funnel comment-refs are `GameWindow.cs:4517` +
  `PlayerMovementController.cs:593`); DEV-4 rewritten per its refutation.