docs(vehicle): record the FBX bakes a -90 deg armature roll

The export rotates the armature -90 deg about X (wheel axle on Z) while leaving the
mesh unrotated. Head/tail, axis_forward:X, and armature pre-roll all failed to change
the imported bones. Next: post-import skeleton fix or bake_space_transform.

Game/GigLine/Source/GigLine/GigLineVehicle.cpp

@@ -318,7 +318,8 @@ void AGigLineVehicle::Tick(float DeltaSeconds)
 		{
 			if (DriveElapsed > 1.0f && DriveElapsed < 4.0f)
 			{
-				Movement->SetThrottleInput(1.0f);
+				const float Throttle = FParse::Param(FCommandLine::Get(), TEXT("reversetest")) ? -1.0f : 1.0f;
+				Movement->SetThrottleInput(Throttle);
 			}
 			else if (DriveElapsed >= 4.0f && !bDriveReported)
 			{

MEMORY.md

@@ -1048,3 +1048,47 @@ Historical task context from 2026-11-09/10; later vehicle findings above may sup
   X, not the bone's Y), the engine torque sign, or the throttle sign. Next probe: run the
   `-drivetest` with `SetThrottleInput(-1.0)` to split "throttle inverted" from "wheel spin
   inverted" in one run.
+
+## 2026-11-10 — Vehicle reverse: both throttle signs drive backward
+
+- `-reversetest` (negative throttle) shows the throttle sign is not the cause: forward
+  throttle → −224.9 km/h, reverse throttle → −99.5 km/h — **both backward**, so the wheel
+  spin is inverted relative to the engine torque, not the input mapping.
+- The mesh orientation is fine (imported bounds 476 × 228 cm, nose at +X). The earlier axle
+  flip (inward→outward) was a no-op, so the next check is the **imported wheel-bone
+  reference pose**: the axle (bone Y) may be landing on Unreal X or Z, not Y, so the wheel
+  spins about the wrong axis. `FPhysicsAssetUtils`-style body setup is not the cause either
+  (physics already simulates).
+- Kept `-reversetest` in the drive test as the diagnostic for this.
+
+## 2026-11-10 — Vehicle reverse: the skeleton is rolled 90° vs the mesh
+
+- Bone reference poses (`AnimPose.get_ref_bone_pose`) show the armature is **rolled 90°**:
+  `root` rot (roll 90, 0, 0), `Wheel_FL/RL` rot (90, 0, −180), `Wheel_FR/RR` rot (−90, 0, 0);
+  wheel centres land at Z ±0.81 instead of Y ±0.81. The mesh vertices are unrotated (bounds
+  476 × 228 × 144, nose +X), so the **FBX `axis_forward: -Y` conversion rotates the armature
+  but not the geometry** — the wheel axle (bone Y) ends up on a rotated axis, which is why the
+  engine torque drives the wheels backward and why the inward/outward axle flip was a no-op.
+- Fix belongs in the bone authoring, not the vehicle component: build the wheel bones so their
+  Y axis lands on Unreal +Y after the FBX conversion, or set `use_space_transform`/bake the
+  space transform so mesh and armature share one frame. Verify with the reference-pose probe
+  (`get_ref_bone_pose` → the wheel axle should read ±Y, not ±Z) before re-running the drive
+  test.
+
+## 2026-11-10 — Vehicle reverse: FBX armature bakes a −90° roll the build can't undo
+
+- Inspecting `vehicle_skeletal.fbx` (imported back into Blender) shows the export bakes a
+  **−90° rotation about X** into the armature: `root` tail (0,1.64,0), wheel tails at
+  (x, 0.33, ±0.83) — the wheel **axle lands on Z**, not Y. The mesh vertices are exported
+  unrotated (bounds 476×228×144), so mesh and armature come back in different frames.
+- Three Blender-side fixes were tried and **none changed the imported wheel bones**:
+  1. axle tail along −Z (head/tail) — reference pose unchanged;
+  2. `axis_forward: "X"` on the `_CHARACTER` preset — unchanged;
+  3. armature object pre-roll −90° about X — unrolled the `root` (roll 90→0) but left the
+     wheel bones at roll ±90 / Z ±0.81.
+- Conclusion: the export bakes the armature conversion regardless of head/tail or the
+  object transform. Remaining options (untried): `bake_space_transform: true` (also rolls
+  the mesh — would need the mesh un-rolled again in Unreal), or a **post-import skeleton
+  fix** — rotate each wheel bone's reference pose −90° about X in `ue_vehicle_import.py`
+  (or a commandlet) so the axle lands on Y. Verify with the `get_ref_bone_pose` probe
+  (axle should read ±Y) before re-running `-drivetest`.