Webots sim-to-real fixes, DAgger pipeline, 360° proto variant

Today's session worked across the full Webots delivery stack — found and
fixed a cluster of bugs blocking the BC/RL transfer, then explored
training-side mitigations for the residual perception gap.

Bug fixes:
- Makefile FP_RATE default 2.0 → 0.0: BC demos used fp_rate=0 but RL
  fine-tune defaulted to fp_rate=2, poisoning the BC obs distribution
  and stalling PPO at 0% success across 1.46M+ steps.
- controllers/{shepherd_dog,sheep}/runtime.ini: Webots was launching
  controllers under system python3 (no numpy) and they were crashing
  silently. Pinned to the conda tir env.
- herding/config.py HERDING_WEBOTS preset: pen_latch_depth 0.5 → 2.0,
  max_new_tracks_per_step 3 → 1, static_reject 0.8 → 1.2. Stops phantom
  FPs near the gate from latching as permanently-penned tracks.
- herding/perception/sheep_tracker.py: penned tracks now decay at
  forget_steps × 8 instead of living forever. Adds get_positions
  min_freshness filter for deploy-time use.

Training/eval matches deployment:
- training/bc/collect.py: --dagger-policy flag for DAgger rollouts
  (policy drives, teacher labels) + --use-webots-preset for matched
  140° tracker + DR config.
- controllers/shepherd_dog/shepherd_dog.py: scan-fallback (0, 0.6) when
  BC/RL sees empty sheep_positions — recovers from FOV gaps.

Tooling:
- tools/dagger_round.sh: one-shot DAgger round (collect + concat + bc).
- tools/webots_sweep_gt.sh: full sweep with HERDING_USE_GT=1 for the
  perception-gap diagnosis matrix.
- protos/ShepherdDog360.proto: 360° FOV variant for the FOV-ablation
  comparison. Canonical proto stays at 140° per project spec.

Artifacts: v1 BC/RL policies for all 4 (drive × world) combos trained
in clean gym (success: diff/field 90-100%, diff/round 58%, mec/field
60-100%, mec/round 50-100%). DAgger r1/r2 BCs for diff/field show
12%→38% progression on gym HERDING_WEBOTS proxy but did not close
to actual Webots LiDAR (0/5 throughout). Next: LSTM policy or
learned tracker per the project-state memory.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

herding/world/diffdrive.py

@@ -2,14 +2,22 @@
 controllers.
 
 First-order rigid-body model — no slip, wheel-accel limits, or contact
-forces. Webots' ODE physics handles those at inference; the env stays
-close enough to first order that a policy trained here transfers.
+forces by default.  Pass ``slip_std`` and an ``rng`` to
+:func:`kinematics_step` / :func:`mecanum_kinematics_step` to add
+per-wheel Gaussian speed noise for domain randomisation.
 """
 
+from __future__ import annotations
+
 import math
+from typing import Optional
+
+import numpy as np
 
 
-def kinematics_step(x, y, h, w_left, w_right, wheel_radius, wheel_base, dt):
+def kinematics_step(x, y, h, w_left, w_right, wheel_radius, wheel_base, dt,
+                    slip_std: float = 0.0,
+                    rng: Optional[np.random.Generator] = None):
     """Integrate one step of differential-drive forward kinematics.
 
     Inputs
@@ -19,9 +27,15 @@ def kinematics_step(x, y, h, w_left, w_right, wheel_radius, wheel_base, dt):
     w_left, w_right : wheel angular velocities (rad/s)
     wheel_radius, wheel_base : robot dimensions (m)
     dt   : timestep (s)
+    slip_std : optional Gaussian std (rad/s) added to each wheel speed
+    rng  : numpy Generator for slip noise; required when slip_std > 0
 
     Returns (new_x, new_y, new_h).
     """
+    if slip_std > 0.0 and rng is not None:
+        noise = rng.normal(0.0, slip_std, size=2)
+        w_left = w_left + noise[0]
+        w_right = w_right + noise[1]
     v = (w_right + w_left) * wheel_radius * 0.5
     omega = (w_right - w_left) * wheel_radius / wheel_base
     new_x = x + v * math.cos(h) * dt
@@ -67,7 +81,9 @@ def heading_speed_to_wheels(heading, speed_motor, h, max_wheel_omega,
 # ---------------------------------------------------------------------------
 
 def mecanum_kinematics_step(x, y, h, w_fl, w_fr, w_rl, w_rr,
-                             wheel_radius, lx, ly, dt):
+                             wheel_radius, lx, ly, dt,
+                             slip_std: float = 0.0,
+                             rng: Optional[np.random.Generator] = None):
     """Integrate one step of mecanum forward kinematics.
 
     Parameters
@@ -79,9 +95,15 @@ def mecanum_kinematics_step(x, y, h, w_fl, w_fr, w_rl, w_rr,
     lx   : half the front-to-back axle distance (m)
     ly   : half the left-to-right axle distance (m)
     dt   : timestep (s)
+    slip_std : optional Gaussian std (rad/s) added to each wheel speed
+    rng  : numpy Generator for slip noise; required when slip_std > 0
 
     Returns (new_x, new_y, new_h).
     """
+    if slip_std > 0.0 and rng is not None:
+        noise = rng.normal(0.0, slip_std, size=4)
+        w_fl, w_fr = w_fl + noise[0], w_fr + noise[1]
+        w_rl, w_rr = w_rl + noise[2], w_rr + noise[3]
     r = wheel_radius
     vx_body = (w_fl + w_fr + w_rl + w_rr) * r / 4.0
     vy_body = (-w_fl + w_fr + w_rl - w_rr) * r / 4.0

herding/world/geometry.py

@@ -72,6 +72,36 @@ if FIELD_SHAPE == "field_round":
     GATE_Y = FIELD_ROUND_GATE_Y
 
 
+def configure_from_args(argv: list[str] | None = None) -> str:
+    """Parse ``--world`` from *argv* (or ``sys.argv[1:]``), call :func:`configure`,
+    and set ``HERDING_WORLD`` in the environment.
+
+    Returns the resolved world name (``"field"`` or ``"field_round"``).
+
+    Call this at the very top of any script that accepts a ``--world`` flag,
+    *before* importing anything from ``herding.*`` that depends on field
+    geometry.  This centralises the pre-parse logic that was previously
+    duplicated in ``bc/collect.py``, ``rl/train.py``, and ``eval.py``::
+
+        from herding.world.geometry import configure_from_args
+        configure_from_args()   # reads sys.argv
+    """
+    import os
+    import sys as _sys
+    args = argv if argv is not None else _sys.argv[1:]
+    world = "field"
+    for i, a in enumerate(args):
+        if a == "--world" and i + 1 < len(args):
+            world = args[i + 1]
+            break
+        if a.startswith("--world="):
+            world = a.split("=", 1)[1]
+            break
+    configure(world)
+    os.environ["HERDING_WORLD"] = world
+    return world
+
+
 def configure(shape: str) -> None:
     """Switch the active field geometry at runtime.