chess-sim/code/sim/expert.py

"""Scripted pick-and-place expert with ground-truth piece poses.

One primitive moves one piece: home, above source, descend, close on the head,
lift clear, traverse, above destination, descend, open, retreat, home. It is
planned in three parts (pick, lift, carry-and-place), each from the actual state. The
gripper points straight down with the jaws along a board diagonal where
possible, else along a rank or file. Grasps and releases are straight down; while
carrying over the far ranks, where straight-down reach runs out, the fingertips
lean outward by the least tilt that clears. The expert tries the directions in order of
finger clearance and keeps the first whose whole trajectory passes a collision
check in a planning copy of the model. After the grasp it
reads where the piece actually sits in the hand and plans the placement from that.

When all of those fail, three fallbacks follow, in this order: in-between jaw yaws
(22.5 degrees off the diagonals and axes); near the arm base (ranks 7-8), a carry that
leans the fingertips inward where it passes the shoulder; and near the base, a grasp
with the fingertips leaning inward, which keeps the wrist camera off the shoulder. A
piece grasped at a lean hangs at that lean, so it is set down with the wrist roll and
lean that stand it upright again. Moves that succeed without a fallback are planned
exactly as before.

Trajectories are joint targets at the recording rate, with minimum-jerk timing.
"""
from __future__ import annotations

import copy
import time
from dataclasses import dataclass, field

import mujoco
import numpy as np

from chess_world import ChessWorld
from grasp_geometry import measure_jaws, piece_profile, piece_triangles, plan_grasp
from kinematics import Kinematics

ARM, PIECE, STATIC, CARRIED, WRIST = 1, 2, 4, 8, 16   # collision classes in the planning model
WRIST_BODIES = ("gripper", "moving_jaw_so101_v1", "wrist_camera_mount", "wrist_camera")
PROXIMAL_BODIES = ("shoulder", "upper_arm", "lower_arm")   # can meet the hand when it rolls
DIAGONALS = np.radians([45, -45, 135, -135])
# Along a rank or file. Needed on rank 8, where a diagonal finger would reach over the
# rover deck; ranked after the diagonals, which keep the fingers furthest from neighbours.
AXES = np.radians([90, -90, 0, 180])
AXIS_PENALTY = 0.004
# In-between jaw yaws, tried only after every diagonal and axis option has failed. Near
# the arm base (ranks 7-8) the yaws that clear the neighbours can put the wrist camera
# or the jaw into the shoulder; an in-between yaw often clears both.
BETWEEN = np.radians([22.5, -22.5, 67.5, -67.5, 112.5, -112.5, 157.5, -157.5])
# Carrying close to the arm base, the folded arm can bring the wrist camera or the hand
# into the shoulder. As a last resort the carry leans the fingertips inward (toward the
# base) where the path runs within NEAR_BASE of the pan axis, which moves the hand's top
# away from the shoulder; the lean is gone again before the piece is set down.
INWARD_TILTS = np.radians([10, 20])
NEAR_BASE = (0.13, 0.17)      # m from the pan axis: full lean inside (ranks 7-8), none outside
IK_POS_TOL = 5e-4
TILTS = np.radians([0, 5, 10, 15, 20])
TILT_RATE = 0.25         # rad/s of tilt change allowed while carrying   # outward fingertip tilts tried when reach runs out
REACH_STEP = 0.003       # height search step; the result stays one step inside the edge
CORRIDOR = 0.021         # two feet radii and a margin: pieces closer than this to the carry path
VERTICAL_PHASES = ("descend", "close", "lift", "place", "open", "retreat", "check")
IK_ROT_TOL = 0.02


def min_jerk(n: int) -> np.ndarray:
    s = np.arange(1, n + 1) / n
    return 10 * s**3 - 15 * s**4 + 6 * s**5


def wrap(a):
    return (a + np.pi) % (2 * np.pi) - np.pi


@dataclass
class Destination:
    kind: str                  # "square" or "bin"
    pos: np.ndarray            # world point where the piece base should come to rest
    square: str | None = None


@dataclass
class Trajectory:
    q: list = field(default_factory=list)       # 5 arm joint targets per frame
    g: list = field(default_factory=list)       # gripper target per frame
    phase: list = field(default_factory=list)
    label: list | None = None                   # arm targets to record as the action, if not q (perturb_pick)

    def add(self, q, g, phase):
        self.q.append(np.asarray(q, float).copy())
        self.g.append(float(g))
        self.phase.append(phase)

    def __len__(self):
        return len(self.q)

    def extend(self, other: "Trajectory"):
        if self.label is not None or other.label is not None:
            self.label = (list(self.q) if self.label is None else self.label) + \
                         (list(other.q) if other.label is None else other.label)
        self.q += other.q
        self.g += other.g
        self.phase += other.phase


@dataclass
class PickPlan:
    traj: Trajectory
    yaw: float
    grasp: object
    offset: np.ndarray       # pinch point in the gripper frame
    grasp_point: np.ndarray  # world pinch point at the grasp
    q_grasp: np.ndarray
    carry_tilt: float = 0.0  # outward tilt at the top of the lift
    grasp_tilt: float = 0.0  # lean at the grasp (negative: fingertips toward the base)
    dart_offset_mm: list | None = None   # executed sideways offset (x, y) if perturbed (perturb_pick)


class PlanningFailed(Exception):
    pass


class Expert:
    def __init__(self, m: mujoco.MjModel, world: ChessWorld, cfg: dict):
        self.m, self.w, self.cfg = m, world, cfg
        self.kin = Kinematics(m)
        self.jaws = measure_jaws(m)
        self.fps = cfg["dataset"]["fps"]
        self.e, self.gcfg = cfg["expert"], cfg["grasp"]
        self.close_q = self.gcfg["close_q"]
        self.gripper_body = m.body("gripper").id
        self.grip_qadr = m.jnt_qposadr[m.joint("gripper").id]
        # Pan axis position on the table; the pan joint does not move it.
        dk = mujoco.MjData(m)
        mujoco.mj_kinematics(m, dk)
        self.pan_xy = dk.xanchor[m.joint("shoulder_pan").id][:2].copy()
        self.tris = {k: piece_triangles(m, next(n for n in world.pieces if world.kind[n] == k))
                     for k in world.height}
        self.profiles = {}
        self._planning_model()

    # ------------------------------------------------------------------ planning model
    def _planning_model(self):
        m = self.m
        pm = copy.deepcopy(m)
        pm.geom_contype[:] = 0
        pm.geom_conaffinity[:] = 0
        pm.geom_margin[:] = 0
        pm.geom_gap[:] = 0
        margin = self.e["plan_margin_mm"] / 1000
        root = m.body("shoulder").id
        arm_bodies = {b for b in range(m.nbody) if self._in_subtree(b, root)}
        self.arm_geoms = [g for g in range(m.ngeom) if m.geom_bodyid[g] in arm_bodies and m.geom_group[g] == 3]
        self.piece_geoms = {n: [g for g in range(m.ngeom) if m.geom_bodyid[g] == self.w.body[n] and m.geom_group[g] == 3]
                            for n in self.w.pieces}
        # Everything else that collides: board, tray, table, deck, both camera mounts, walls.
        piece_bodies = set(self.w.body.values())
        static = [g for g in range(m.ngeom) if m.geom_contype[g] and m.geom_bodyid[g] not in arm_bodies
                  and m.geom_bodyid[g] not in piece_bodies]
        # MuJoCo uses the larger margin of the two geoms, so a small arm margin sets the
        # arm-to-arm clearance while pieces and fixed obstacles bring their own.
        pm.geom_contype[self.arm_geoms] = ARM
        # Self-collision: the hand and wrist camera against the upper links.
        for g in self.arm_geoms:
            body = m.body(m.geom_bodyid[g]).name
            if body in WRIST_BODIES:
                pm.geom_contype[g] = ARM | WRIST
            elif body in PROXIMAL_BODIES:
                pm.geom_conaffinity[g] = WRIST
        for gs in self.piece_geoms.values():
            pm.geom_contype[gs] = PIECE
            pm.geom_conaffinity[gs] = ARM | CARRIED
            pm.geom_margin[gs] = margin
        pm.geom_contype[static] = STATIC
        pm.geom_conaffinity[static] = ARM
        self.static_geoms = static
        # The per-body bounding-volume tree is built at compile time and ignores these
        # runtime margins, so multi-hull bodies would only report actual overlap.
        pm.opt.disableflags |= int(mujoco.mjtDisableBit.mjDSBL_MIDPHASE)
        self.pm, self.pd = pm, mujoco.MjData(pm)

    def _in_subtree(self, b, root):
        while b > 0:
            if b == root:
                return True
            b = self.m.body_parentid[b]
        return False

    def _sync_planning(self, d, carried=None, ignored=()):
        """Copy the episode's board/tray pose and set per-plan roles of pieces."""
        pm = self.pm
        for b in (self.w.board, self.w.bin, self.w.table):
            pm.body_pos[b] = self.m.body_pos[b]
            pm.body_quat[b] = self.m.body_quat[b]
        for n, gs in self.piece_geoms.items():
            if n == carried:
                pm.geom_contype[gs], pm.geom_conaffinity[gs] = CARRIED, 0
            elif n in ignored:
                pm.geom_contype[gs], pm.geom_conaffinity[gs] = 0, 0
            else:
                pm.geom_contype[gs], pm.geom_conaffinity[gs] = PIECE, ARM | CARRIED
        # Margin sets for sideways and vertical motion (see phase2_config.toml).
        e = self.e
        self.margins = {}
        for mode, piece, carry in (("lateral", e["plan_margin_mm"], e["carry_margin_mm"]),
                                   ("vertical", e["vertical_margin_mm"], e["vertical_carry_margin_mm"]),
                                   ("lift", e["vertical_margin_mm"], e["lift_carry_margin_mm"])):
            mg = np.zeros(pm.ngeom)
            mg[self.arm_geoms] = e["self_margin_mm"] / 1000
            mg[self.static_geoms] = e["static_margin_mm"] / 1000
            for n, gs in self.piece_geoms.items():
                mg[gs] = (carry if n == carried else piece) / 1000
            self.margins[mode] = mg
        self.pd.qpos[:] = d.qpos

    def _collision_free(self, traj: Trajectory, start: int = 0, carried=None, rel=None, stride=2):
        """True if no checked frame puts the arm or the carried piece within the margin."""
        pd = self.pd
        idx = list(range(start, len(traj), stride))
        if len(traj) and idx[-1] != len(traj) - 1:
            idx.append(len(traj) - 1)
        for i in idx:
            pd.qpos[self.kin.qadr] = traj.q[i]
            pd.qpos[self.grip_qadr] = max(traj.g[i], self._grip_floor)
            if carried is not None and traj.phase[i] in ("lift", "traverse", "place"):
                mujoco.mj_kinematics(self.pm, pd)
                R = pd.xmat[self.gripper_body].reshape(3, 3)
                pos = pd.xpos[self.gripper_body] + R @ rel[0]
                quat = np.zeros(4)
                mujoco.mju_mat2Quat(quat, (R @ rel[1]).ravel())
                a = self.w.qadr[carried]
                pd.qpos[a:a + 3], pd.qpos[a + 3:a + 7] = pos, quat
            ph = traj.phase[i]
            self.pm.geom_margin[:] = self.margins["lift" if ph == "lift" else
                                                  "vertical" if ph in VERTICAL_PHASES else "lateral"]
            mujoco.mj_kinematics(self.pm, pd)
            mujoco.mj_collision(self.pm, pd)
            if pd.ncon:
                c = pd.contact[0]
                self.last_collision = (traj.phase[i], self.pm.body(self.pm.geom_bodyid[c.geom1]).name,
                                       self.pm.body(self.pm.geom_bodyid[c.geom2]).name)
                return False
        return True

    def _config_free(self, q, g):
        t = Trajectory()
        t.add(q, g, "check")
        return self._collision_free(t)

    # ------------------------------------------------------------------ geometry helpers
    def profile(self, name: str, closing_world: float, d):
        """Grasp profile of a piece for jaws closing along world yaw `closing_world`."""
        kind = self.w.kind[name]
        R = d.xmat[self.w.body[name]].reshape(3, 3)
        u = R.T @ np.array([np.cos(closing_world), np.sin(closing_world), 0])
        ang = np.arctan2(u[1], u[0])
        step = np.radians(5 if kind == "knight" else 10)
        key = (kind, int(round(ang / step)))
        if key not in self.profiles:
            a = key[1] * step
            self.profiles[key] = piece_profile(self.tris[kind], np.array([np.cos(a), np.sin(a)]))
        return self.profiles[key]

    def grasp_for(self, name, yaw, d, open_margin=None):
        prof = self.profile(name, yaw, d)
        tip = self.gcfg["tip_fraction"][self.w.kind[name]] * prof.height
        margin = self.gcfg["open_margins_mm"][0] / 1000 if open_margin is None else open_margin
        g = plan_grasp(self.jaws, prof, tip, self.gcfg["fixed_gap_mm"] / 1000, margin)
        return g, np.array([g.center_x, 0.0, self.jaws.tip_z])

    def _neighbour_tops(self, d, xy, radius, exclude=()):
        """Highest point of pieces whose axis is within `radius` of `xy` (world z)."""
        top = self.w.board_top
        for n in self.w.pieces:
            if n in exclude:
                continue
            p = d.xpos[self.w.body[n]]
            if np.linalg.norm(p[:2] - xy[:2]) < radius and p[2] > -0.1:
                top = max(top, p[2] + self.w.height[self.w.kind[n]])
        return top

    def _corridor_top(self, d, a, b, width, exclude=()):
        top = self.w.board_top
        ab = b[:2] - a[:2]
        L2 = max(ab @ ab, 1e-12)
        for n in self.w.pieces:
            if n in exclude:
                continue
            p = d.xpos[self.w.body[n]]
            if p[2] < -0.1:
                continue
            t = np.clip((p[:2] - a[:2]) @ ab / L2, 0, 1)
            if np.linalg.norm(p[:2] - (a[:2] + t * ab)) < width:
                top = max(top, p[2] + self.w.height[self.w.kind[n]])
        return top

    def _solve(self, point, yaw, offset, q_seed, global_search=False, tilt=0.0):
        if global_search:
            q, ep, er = self.kin.solve_global(point, yaw, offset, q_seed, tilt=tilt)
        else:
            q, ep, er = self.kin.solve(point, yaw, offset, q_seed, iters=60, tilt=tilt)
            if ep > IK_POS_TOL or er > IK_ROT_TOL:
                q, ep, er = self.kin.solve_global(point, yaw, offset, q_seed, tilt=tilt)
        if ep > IK_POS_TOL or er > IK_ROT_TOL:
            raise PlanningFailed(f"unreachable {np.round(point, 3)}")
        return q

    def _local(self, point, yaw, offset, q_seed, tilt=0.0):
        q, ep, er = self.kin.solve(point, yaw, offset, q_seed, iters=100, tilt=tilt)
        if ep > IK_POS_TOL or er > IK_ROT_TOL:
            raise PlanningFailed(f"unreachable {np.round(point, 3)}")
        return q

    def _reachable_height(self, xy, yaw, offset, q_seed, z_lo, z_hi, z_floor=None, tilt=0.0):
        """Highest z in [z_lo, z_hi] reachable at `xy` with the gripper vertical, found by
        walking up from z_lo on the same IK branch a trajectory would follow, then
        stepping back one step from the workspace edge. If z_lo itself is out of reach,
        the highest reachable z down to `z_floor`.
        """
        xy = np.asarray(xy)[:2]
        try:
            q = self._solve(np.r_[xy, z_lo], yaw, offset, q_seed, tilt=tilt)
        except PlanningFailed:
            if z_floor is None or z_floor >= z_lo:
                raise
            for z in np.r_[np.arange(z_lo - REACH_STEP, z_floor, -REACH_STEP), z_floor]:
                try:
                    return z, self._solve(np.r_[xy, z], yaw, offset, q_seed, tilt=tilt)
                except PlanningFailed:
                    continue
            raise
        try:
            return z_hi, self._local(np.r_[xy, z_hi], yaw, offset, q, tilt)
        except PlanningFailed:
            pass
        reached = [(z_lo, q)]
        for z in np.arange(z_lo + REACH_STEP, z_hi, REACH_STEP):
            try:
                q = self._local(np.r_[xy, z], yaw, offset, q, tilt)
            except PlanningFailed:
                break
            reached.append((z, q))
        return reached[-2] if len(reached) > 1 else reached[-1]

    # ------------------------------------------------------------------ trajectory pieces
    def _duration(self, value, rate, lo, hi):
        return float(np.clip(value / rate, lo, hi)) / self.speed

    def _joint_move(self, traj, q0, q1, g0, g1, phase):
        T = self._duration(np.max(np.abs(q1 - q0)), self.e["joint_speed"], 1.0, 3.0)
        for s in min_jerk(max(2, round(T * self.fps))):
            traj.add(q0 + (q1 - q0) * s, g0 + (g1 - g0) * s, phase)
        return q1

    def _cart_move(self, traj, q, p0, p1, yaw0, yaw1, offset, g0, g1, phase, speed, tmin, tmax,
                   tilt0=0.0, tilt1=0.0):
        dist = max(np.linalg.norm(p1 - p0), abs(wrap(yaw1 - yaw0)) * 0.03, abs(tilt1 - tilt0) * 0.08)
        T = self._duration(dist, speed, tmin, tmax)
        for s in min_jerk(max(2, round(T * self.fps))):
            q = self._solve(p0 + (p1 - p0) * s, yaw0 + wrap(yaw1 - yaw0) * s, offset, q,
                            tilt=tilt0 + (tilt1 - tilt0) * s)
            traj.add(q, g0 + (g1 - g0) * s, phase)
        return q

    def _hold(self, traj, q, g0, g1, secs, phase):
        n = max(1, round(secs / self.speed * self.fps))
        for s in min_jerk(n):
            traj.add(q, g0 + (g1 - g0) * s, phase)

    # ------------------------------------------------------------------ pick
    def plan_pick(self, d, name: str, rng) -> PickPlan:
        self.speed = rng.uniform(*self.e["speed_scale"])
        base = self.w.base_pos(d, name)
        q_now = d.qpos[self.kin.qadr].copy()
        g_now = float(d.qpos[self.grip_qadr])
        self._sync_planning(d, ignored=(name,))
        clearance = self.e["travel_clearance_mm"] / 1000
        errors = []
        margins = [m / 1000 for m in self.gcfg["open_margins_mm"]]
        primary = self._yaw_order(d, name, base)
        options = [(yaw, m, 0.0) for m in margins for yaw in primary]
        options += [(yaw, m, 0.0) for m in margins for yaw in self._yaw_order(d, name, base, BETWEEN)]
        # Last resort close to the base: grasp with the fingertips leaning inward, which
        # keeps the wrist camera and the hand's top off the shoulder. The piece then hangs
        # at that lean in the hand, and plan_place sets it down with a matching lean.
        if np.linalg.norm(base[:2] - self.pan_xy) < NEAR_BASE[1]:
            options += [(yaw, m, -lean) for lean in INWARD_TILTS for m in margins for yaw in primary]
        deadline = time.time() + self.e["plan_budget_s"]
        for yaw, margin, tilt in options:
            if time.time() > deadline:
                errors.append("time budget")
                break
            try:
                grasp, offset = self.grasp_for(name, yaw, d, margin)
                self._grip_floor = grasp.contact_q
                point = base + [0, 0, grasp.tip_height]
                top = self._neighbour_tops(d, base, 0.045, exclude=(name,))
                z_above = max(top + clearance + 0.004, point[2] + 0.025)
                q_grasp = self._solve(point, yaw, offset, q_now, global_search=True, tilt=tilt)
                if not self._config_free(q_grasp, grasp.open_q):
                    raise PlanningFailed(f"grasp pose collides {self.last_collision}")
                z_above, q_above = self._reachable_height(point, yaw, offset, q_grasp, point[2], z_above, tilt=tilt)
                if z_above < point[2] + 0.015:
                    raise PlanningFailed("no room above the source")
                above = np.r_[point[:2], z_above]
                traj = Trajectory()
                self._joint_move(traj, q_now, q_above, g_now, grasp.open_q, "approach")
                q = self._cart_move(traj, q_above, above, point, yaw, yaw, offset, grasp.open_q, grasp.open_q,
                                    "descend", self.e["vertical_speed"], 0.7, 1.8, tilt, tilt)
                self._hold(traj, q, grasp.open_q, grasp.open_q, 0.1, "descend")
                if not self._collision_free(traj):
                    raise PlanningFailed(f"collision {self.last_collision}")
                self._hold(traj, q, grasp.open_q, self.close_q, 0.45, "close")
                self._hold(traj, q, self.close_q, self.close_q, 0.25, "close")
                return PickPlan(traj, yaw, grasp, offset, point, q, grasp_tilt=tilt)
            except PlanningFailed as exc:
                errors.append(str(exc))
        raise PlanningFailed("pick: " + "; ".join(errors))

    def perturb_pick(self, d, name: str, pick: PickPlan, rng) -> PickPlan:
        """DART-style perturbation: execute the approach off-centre, record the clean plan.

        The executed hand drifts sideways by a random offset (`dart_radius_mm`, any direction)
        during the approach, holds it into the descent and returns to the planned path over a
        random `dart_return_s`, ending before the fingertips come within `dart_clear_mm` of the
        piece's top.
        From there on it follows the plan exactly. The recorded actions (`traj.label`) are the
        clean plan throughout, so an episode shows "from off-centre, command the centred path"
        and never an off-centre aim. The executed part is collision-checked with the target
        included; an offset that collides is redrawn, up to `dart_tries` times, else the plan
        runs unperturbed.
        """
        e, t = self.e, pick.traj
        desc = [i for i, ph in enumerate(t.phase) if ph == "descend"]
        if not desc or desc[0] < 2:
            return pick
        k0 = desc[0]
        top = self.w.base_pos(d, name)[2] + self.w.height[self.w.kind[name]]
        z_clear = top + e["dart_clear_mm"] / 1000
        pts = [self.kin.pose(q, pick.offset)[0] for q in t.q[k0:desc[-1] + 1]]
        k_clear = k0 + next((j for j, p in enumerate(pts) if p[2] <= z_clear), len(pts) - 1)
        n_down = min(round(rng.uniform(*e["dart_return_s"]) * self.fps), k_clear - 2)
        k_peak = k_clear - n_down
        k_up = min(k0, k_peak)
        w = np.zeros(len(t))
        w[:k_up] = np.r_[0.0, min_jerk(k_up - 1)]             # 0 at the start, full by the end of the approach
        w[k_up:k_peak] = 1.0                                   # held into the descent
        w[k_peak:k_clear] = 1 - min_jerk(n_down)               # back to 0 at k_clear - 1
        q_above = t.q[k0 - 1]
        p_above = self.kin.pose(q_above, pick.offset)[0]
        lo, hi = e["dart_radius_mm"]
        for _ in range(e["dart_tries"]):
            r, a = rng.uniform(lo, hi) / 1000, rng.uniform(0, 2 * np.pi)
            delta = np.array([r * np.cos(a), r * np.sin(a), 0.0])
            try:
                dq = self._solve(p_above + delta, pick.yaw, pick.offset, q_above, tilt=pick.grasp_tilt) - q_above
                ex = Trajectory()
                q = q_above
                for i in range(k_clear):
                    if i < k0:
                        q = t.q[i] + w[i] * dq
                    else:
                        q = self._solve(pts[i - k0] + w[i] * delta, pick.yaw, pick.offset, q, tilt=pick.grasp_tilt)
                    ex.add(q, t.g[i], t.phase[i])
            except PlanningFailed:
                continue
            self._sync_planning(d)                  # the target counts while the hand is off the plan
            free = self._collision_free(ex)
            self._sync_planning(d, ignored=(name,))
            if not free:
                continue
            ex.q += [q.copy() for q in t.q[k_clear:]]
            ex.g += t.g[k_clear:]
            ex.phase += t.phase[k_clear:]
            ex.label = [q.copy() for q in t.q]
            return PickPlan(ex, pick.yaw, pick.grasp, pick.offset, pick.grasp_point, pick.q_grasp,
                            pick.carry_tilt, pick.grasp_tilt, dart_offset_mm=[round(float(x), 2) for x in delta[:2] * 1000])
        return pick

    def _yaw_order(self, d, name, base, offsets=None):
        """Diagonals, best finger clearance to neighbouring pieces first (or the given
        board-relative `offsets`, ordered the same way)."""
        byaw = self.w.board_yaw()
        scored = []
        between = offsets is not None
        for off in (offsets if between else np.r_[DIAGONALS, AXES]):
            yaw = byaw + off
            u = np.array([np.cos(yaw), np.sin(yaw)])
            v = np.array([-u[1], u[0]])
            worst = 1.0
            for n in self.w.pieces:
                if n == name:
                    continue
                p = d.xpos[self.w.body[n]]
                rel = p[:2] - base[:2]
                if p[2] < -0.1 or np.linalg.norm(rel) > 0.06:
                    continue
                a, c = rel @ u, rel @ v
                r = self.w.foot_radius[self.w.kind[n]]
                # finger boxes: moving side +u 6..30 mm, fixed side -u 6..24 mm, across +-9 mm
                for lo, hi in ((0.006, 0.030), (-0.024, -0.006)):
                    du = max(lo - a, 0, a - hi)
                    dv = max(abs(c) - 0.009, 0)
                    worst = min(worst, np.hypot(du, dv) - r)
            penalty = 0.0 if off in DIAGONALS else AXIS_PENALTY
            scored.append((-worst + penalty, abs(wrap(off)) > np.pi / 2, yaw))
        order = [y for *_, y in sorted(scored)]
        if self.w.kind[name] == "knight" and not between:
            # Across the head: the normalised knight faces its local +y.
            R = d.xmat[self.w.body[name]].reshape(3, 3)
            facing = np.arctan2(R[1, 1], R[0, 1])
            order = [facing + np.pi / 2, facing - np.pi / 2] + order
        return order

    # ------------------------------------------------------------------ carry and place
    def _in_hand(self, d, name):
        """Piece base position and orientation in the gripper frame, as it actually sits."""
        gb = self.gripper_body
        Rg = d.xmat[gb].reshape(3, 3)
        Rp = d.xmat[self.w.body[name]].reshape(3, 3)
        return Rg.T @ (d.xpos[self.w.body[name]] - d.xpos[gb]), Rg.T @ Rp

    def _need_profile(self, d, name, start, target, careful=False, n=33):
        """Base height the carried piece needs at points along the straight carry path.

        At each point: the top of every piece whose axis is within the corridor, plus
        the clearance. Careful mode widens the corridor and adds all pieces within
        40 mm of the destination. Returns (path fraction s, needed base z, length).
        """
        clearance = self.e["travel_clearance_mm"] / 1000
        width = 0.028 if careful else CORRIDOR
        s = np.linspace(0, 1, n)
        xy = start[None, :2] + (target[:2] - start[:2])[None] * s[:, None]
        need = np.full(n, target[2] + 0.004)
        for other in self.w.pieces:
            if other == name:
                continue
            p = d.xpos[self.w.body[other]]
            if p[2] < -0.1:
                continue
            top = p[2] + self.w.height[self.w.kind[other]] + clearance
            near = np.linalg.norm(xy - p[:2], axis=1) < width
            need[near] = np.maximum(need[near], top)
            if careful and np.linalg.norm(p[:2] - target[:2]) < 0.04:
                need[-1] = max(need[-1], top)
        return s, need, float(np.linalg.norm(target[:2] - start[:2]))

    def _need_near(self, s, need, length, end, reach=0.03):
        """Largest need within `reach` metres of one end of the path (0 = start, 1 = end)."""
        dist = np.abs(s - end) * length
        return float(need[dist <= reach].max())

    def _travel_height(self, d, name, start, dest: Destination, careful=False):
        """Highest base height the carry needs anywhere on its way (kept for the tray)."""
        target = self._release_point(dest)
        _, need, _ = self._need_profile(d, name, start, target, careful)
        top = need.max()
        if dest.kind == "bin":
            top = max(top, self.w.bin_rim + self.m.body_pos[self.w.bin][2] + self.e["travel_clearance_mm"] / 1000)
        return max(top, target[2] + 0.02)

    def _release_point(self, dest: Destination):
        if dest.kind == "bin":
            return dest.pos + [0, 0, self.e["bin_release_mm"] / 1000]
        return dest.pos + [0, 0, self.e["place_drop_mm"] / 1000]

    def plan_lift(self, d, name: str, pick: PickPlan, dest: Destination) -> Trajectory:
        """Straight up from the planned grasp pose, as high as the carry needs and the arm reaches.

        Planned from the commanded grasp pose, not the slightly sagging measured one:
        at the edge of reach the measured pose can lie just outside the workspace.
        """
        rel = self._in_hand(d, name)
        base = self.w.base_pos(d, name)
        pinch_above_base = pick.grasp_point[2] - base[2]
        self._sync_planning(d, carried=name)
        self._grip_floor = pick.grasp.contact_q
        target = self._release_point(dest)
        prof = self._need_profile(d, name, base, target)
        z_base = max(self._need_near(*prof, end=0.0), base[2] + 0.012)
        if dest.kind == "bin":
            z_base = max(z_base, self._travel_height(d, name, base, dest))
        z_travel = z_base + pinch_above_base
        start = pick.grasp_point
        if pick.grasp_tilt:          # a leaned grasp lifts at the same lean
            tilt = pick.grasp_tilt
            z_lift, _ = self._reachable_height(start, pick.yaw, pick.offset, pick.q_grasp, start[2] + 0.005,
                                               max(z_travel, start[2] + 0.005), tilt=tilt)
        else:
            tilt, z_lift, _ = self._best_tilt(start, pick.yaw, pick.offset, pick.q_grasp,
                                              start[2] + 0.005, max(z_travel, start[2] + 0.005))
        pick.carry_tilt = tilt
        traj = Trajectory()
        self._cart_move(traj, pick.q_grasp, start, np.r_[start[:2], z_lift], pick.yaw, pick.yaw, pick.offset,
                        self.close_q, self.close_q, "lift", self.e["vertical_speed"], 0.6, 1.6, pick.grasp_tilt, tilt)
        # Neighbours already within the clearance where the lift starts (pieces up to 3 mm
        # off-centre on 22-25 mm squares can stand a fraction of a millimetre apart) are
        # left out of its check: the piece slides straight up past them, and the physics
        # judges whether they were disturbed. The arm and fixed obstacles stay checked.
        ignored = []
        start_frame = Trajectory()
        start_frame.add(traj.q[0], traj.g[0], "lift")
        while not self._collision_free(start_frame, carried=name, rel=rel) and len(ignored) < 4:
            _, a, b = self.last_collision
            other = b if a == name else a if b == name else None
            if other is None or other not in self.w.body:
                break
            ignored.append(other)
            self._sync_planning(d, carried=name, ignored=tuple(ignored))
        if not self._collision_free(traj, carried=name, rel=rel):
            raise PlanningFailed(f"lift: collision {self.last_collision}")
        return traj

    def plan_place(self, d, name: str, pick: PickPlan, dest: Destination, rng, home) -> Trajectory:
        """Traverse, place, open, retreat and return home, from where the piece hangs now."""
        rel = self._in_hand(d, name)
        q0 = d.qpos[self.kin.qadr].copy()
        start = self.w.base_pos(d, name)
        self._last_d = d
        errors = []
        lean_yaws = (self._upright_yaws(rel, pick.yaw, name, q0, self._release_point(dest))
                     if pick.grasp_tilt else None)
        deadline = time.time() + self.e["plan_budget_s"]
        for careful, target, yaw_dst, inward, lean in self._place_options(dest, pick.yaw, name, rng, start, lean_yaws):
            if time.time() > deadline:
                errors.append("time budget")
                break
            self._sync_planning(d, carried=name)
            self._grip_floor = pick.grasp.contact_q
            try:
                prof = self._need_profile(d, name, start, target, careful)
                if dest.kind == "bin":
                    rim = self._travel_height(d, name, start, dest, careful)
                    prof = (prof[0], np.maximum(prof[1], np.where(prof[0] > 0.6, rim, prof[1])), prof[2])
                z_end = max(self._need_near(*prof, end=1.0), target[2] + 0.012)
                if lean is None:
                    tilt_dst, z_dst, _ = self._best_tilt(target, yaw_dst, rel[0], q0, target[2], z_end)
                    end_tilt = 0.0
                else:                # a piece held at a lean goes down at the lean that stands it upright
                    z_dst, _ = self._reachable_height(target, yaw_dst, rel[0], q0, target[2], z_end, tilt=lean)
                    tilt_dst = end_tilt = lean
                traj = Trajectory()
                above_dst = np.r_[target[:2], z_dst]
                q = self._traverse(traj, q0, start, above_dst, pick.yaw, yaw_dst, rel[0], prof,
                                   pick.carry_tilt, tilt_dst, inward)
                q = self._cart_move(traj, q, above_dst, target, yaw_dst, yaw_dst, rel[0],
                                    self.close_q, self.close_q, "place", self.e["vertical_speed"], 0.7, 1.8,
                                    tilt_dst, end_tilt)
                if not self._collision_free(traj, carried=name, rel=rel):
                    raise PlanningFailed(f"collision {self.last_collision}")
                traj.extend(self._release_and_home(d, name, pick, q, yaw_dst, rng, home, end_tilt))
                self._last_place = dict(target=target, yaw=yaw_dst, tilt_dst=tilt_dst, end_tilt=end_tilt,
                                        pick=pick, home=home)
                return traj
            except PlanningFailed as exc:
                errors.append(str(exc))
        raise PlanningFailed("place: " + "; ".join(errors))

    def refine_descent(self, d, name: str, rng) -> Trajectory | None:
        """Re-plan the descent, release and return home from where the piece hangs now.

        The piece can slip a few millimetres in the hand while it is carried, and the
        placement was planned with the grip read after the lift. Called with the arm
        above the destination; aims the piece's actual base at the target. None if the
        new descent collides (the original plan then runs on)."""
        lp = getattr(self, "_last_place", None)
        if lp is None:
            return None
        rel = self._in_hand(d, name)
        q0 = d.qpos[self.kin.qadr].copy()
        self._sync_planning(d, carried=name)
        self._grip_floor = lp["pick"].grasp.contact_q
        traj = Trajectory()
        q = self._cart_move(traj, q0, self.w.base_pos(d, name), lp["target"], lp["yaw"], lp["yaw"], rel[0],
                            self.close_q, self.close_q, "place", self.e["vertical_speed"], 0.7, 1.8,
                            lp["tilt_dst"], lp["end_tilt"])
        if not self._collision_free(traj, carried=name, rel=rel):
            return None
        traj.extend(self._release_and_home(d, name, lp["pick"], q, lp["yaw"], rng, lp["home"], lp["end_tilt"]))
        return traj

    def _release_and_home(self, d, name, pick, q, yaw, rng, home, tilt=0.0) -> Trajectory:
        """Open, step the fixed finger off the piece it was pressed against (-x in the
        gripper frame), rise until the fingertips clear the piece, and go to rest.

        Tries a wide then a narrow opening, and a short then a full retreat. The placed
        piece stands between the jaws, so only the other pieces are checked.
        """
        self._sync_planning(d, ignored=(name,))
        prof = self.profile(name, pick.yaw, d)
        clear_top = prof.height - pick.grasp.tip_height + 0.008
        rises = sorted({min(clear_top, self.e["retreat_mm"] / 1000), self.e["retreat_mm"] / 1000})
        g_home = rng.uniform(*self.e["home_gripper"])
        errors = []
        for margin in self.gcfg["release_margins_mm"]:
            open_q = self.grasp_for(name, pick.yaw, d, margin / 1000)[0].open_q
            for rise in rises:
                try:
                    t = Trajectory()
                    self._hold(t, q, self.close_q, open_q, 0.3, "open")
                    self._hold(t, q, open_q, open_q, 0.15, "open")
                    p_tip, R = self.kin.pose(q, pick.offset)
                    shifted = p_tip - R[:, 0] * 0.001
                    qr = self._cart_move(t, q, p_tip, shifted, yaw, yaw, pick.offset, open_q, open_q,
                                         "retreat", 0.02, 0.15, 0.3, tilt, tilt)
                    z_up, _ = self._reachable_height(shifted, yaw, pick.offset, qr, shifted[2], shifted[2] + rise,
                                                     tilt=tilt)
                    qr = self._cart_move(t, qr, shifted, np.r_[shifted[:2], z_up], yaw, yaw, pick.offset,
                                         open_q, open_q, "retreat", 0.08, 0.4, 1.0, tilt, tilt)
                    for via in (None, np.r_[qr[:4], home[4]]):
                        t_home = Trajectory()
                        t_home.extend(t)
                        if via is not None:      # turn the wrist first, then fold
                            self._joint_move(t_home, qr, via, open_q, open_q, "home")
                        self._joint_move(t_home, qr if via is None else via, home, open_q, g_home, "home")
                        self._hold(t_home, home, g_home, g_home, 0.5, "home")
                        if self._collision_free(t_home):
                            return t_home
                        errors.append(f"collision {self.last_collision}")
                except PlanningFailed as exc:
                    errors.append(str(exc))
        raise PlanningFailed("release: " + "; ".join(errors))

    def _place_options(self, dest, yaw_src, name, rng, start, lean_yaws=None):
        """(careful, release point, jaw yaw, inward carry lean, placing lean) to try. The
        whole tray is highlighted, so a drop anywhere in it is correct; a few spots are
        tried. A piece held at a lean (`lean_yaws`: yaw and lean pairs from _upright_yaws)
        can only be set down with those; otherwise the placing lean is None (upright hand)."""
        points = [self._release_point(dest)]
        if dest.kind == "square":
            nudge = self._nudge(d_state=self._last_d, name=name, target=points[0])
            if nudge is not None:
                points.append(points[0] + nudge)
        if dest.kind == "bin":
            half = self.w.bin_half - 0.014
            points += [self.w.bin_point(*rng.uniform(-half, half), self.e["bin_release_mm"] / 1000) for _ in range(3)]
        if lean_yaws is not None:
            return [(c, p, y, 0.0, t) for c in (False, True) for p in points for y, t in lean_yaws]
        main = [(c, p, y) for c in (False, True) for p in points for y in self._dest_yaws(yaw_src, name)]
        out = [(*o, 0.0, None) for o in main]
        out += [(c, p, y, 0.0, None) for c in (False, True) for p in points
                for y in self._dest_yaws(yaw_src, name, BETWEEN)]
        near = min(np.linalg.norm(start[:2] - self.pan_xy), np.linalg.norm(points[0][:2] - self.pan_xy)) < NEAR_BASE[1]
        if near:
            out += [(c, p, y, lean, None) for lean in INWARD_TILTS for c, p, y in main if not c]
        if self.w.kind[name] == "knight":
            # Last resort: let the knight end up facing another way (it does not matter
            # in chess), which doubles the jaw yaws available near the base.
            free = [y for y in self._dest_yaws(yaw_src, name, any_facing=True)
                    if all(abs(wrap(y - o[2])) > 1e-6 for o in main)]
            out += [(c, p, y, 0.0, None) for c in (False, True) for p in points for y in free]
            if near:
                out += [(False, p, y, lean, None) for lean in INWARD_TILTS for p in points for y in free]
        return out

    def _upright_yaws(self, rel, yaw_src, name, q_seed, target):
        """Jaw yaws and leans at which a piece held at a lean stands upright at `target`.

        The arm can lean the hand only within its own vertical plane, so the wrist roll
        must turn the piece's axis (fixed in the hand) into that plane, and the lean then
        stands it up. Two yaws half a turn apart do this; each is kept if the piece ends
        within 2 degrees of upright. The plane barely changes across a square or the tray,
        so the nominal release point stands for the nudged ones."""
        u = rel[1][:, 2]                                   # piece axis in the gripper frame
        theta = float(np.arccos(np.clip(u[2], -1.0, 1.0)))
        beta = float(np.arctan2(u[1], u[0]))
        out = []
        for flip in (0.0, np.pi):
            psi, tp = yaw_src, 0.0
            try:
                for _ in range(3):                         # the arm's plane depends a little on yaw and lean
                    q = self._solve(target, psi, rel[0], q_seed, global_search=True, tilt=tp)
                    self.kin._set(q)
                    a = self.kin.d.xaxis[self.kin.lift_joint]
                    radial = np.cross(a, [0.0, 0.0, 1.0])[:2]
                    psi = yaw_src + wrap(np.arctan2(radial[1], radial[0]) + flip - beta - yaw_src)
                    errs = []
                    for t in (theta, -theta):
                        R = self.kin.target_rotation(target, psi, t)
                        errs.append((float(np.arccos(np.clip((R @ u)[2], -1.0, 1.0))), t))
                    err, tp = min(errs)
            except PlanningFailed:
                continue
            if err > np.radians(2):
                continue
            out.append((psi, tp))
        if self.w.kind[name] == "knight":                  # keep the knight facing where it faced if possible
            kept = [(psi, tp) for psi, tp in out if abs(wrap(psi - yaw_src)) <= np.pi / 2 + 0.2]
            out = kept + [o for o in out if o not in kept]
        return out

    def _nudge(self, d_state, name, target):
        """Small offset of the drop point away from neighbours crowding the square, the
        way a person sets a piece down a little off-centre. None if nothing crowds it."""
        push = np.zeros(2)
        for other in self.w.pieces:
            if other == name:
                continue
            p = d_state.xpos[self.w.body[other]]
            rel = target[:2] - p[:2]
            dist = np.linalg.norm(rel)
            if p[2] > -0.1 and 1e-6 < dist < 0.03:
                push += rel / dist**3
        if not push.any():
            return None
        return np.r_[push / np.linalg.norm(push) * self.e["place_nudge_mm"] / 1000, 0.0]

    def _dest_yaws(self, yaw_src, name, offsets=None, any_facing=False):
        byaw = self.w.board_yaw()
        if offsets is None:
            options = [yaw_src] + [byaw + o for o in np.r_[DIAGONALS, AXES]]
        else:
            options = [byaw + o for o in offsets]
        if self.w.kind[name] == "knight" and not any_facing:
            # Keep the knight facing where it faced; a half turn would reverse it.
            options = [o for o in options if abs(wrap(o - yaw_src)) < np.pi / 2 + 0.2]
        # Unwrapped targets: the short way round first, then the long way, which
        # moves the wrist camera to the other side of the arm.
        out = []
        for o in sorted(options, key=lambda o: abs(wrap(o - yaw_src))):
            short = wrap(o - yaw_src)
            out.append(yaw_src + short)
            if abs(short) > np.pi / 4:
                out.append(yaw_src + short - np.sign(short) * 2 * np.pi)
        return out

    def _best_tilt(self, xy, yaw, offset, q, z_lo, z_want):
        """Least outward tilt at which `z_want` is reachable at `xy`; else the tilt
        that reaches highest. Returns (tilt, z, q)."""
        best = None
        for tilt in TILTS:
            try:
                z, qz = self._reachable_height(xy, yaw, offset, q, z_lo, z_want, tilt=tilt)
            except PlanningFailed:
                continue
            if z >= z_want - 1e-6:
                return tilt, z, qz
            if best is None or z > best[1] + 1e-6:
                best = (tilt, z, qz)
        if best is None:
            raise PlanningFailed(f"unreachable {np.round(np.r_[np.asarray(xy)[:2], z_lo], 3)}")
        return best

    def _traverse(self, traj, q, a, b, yaw0, yaw1, offset, prof, tilt_a=0.0, tilt_b=0.0, inward=0.0):
        """Carry from a to b over the needed-height profile, lowered where the arm cannot
        reach that high. The profile is made tent-shaped (it rises over obstacles and never
        dips between them) and then followed with one minimum-jerk timing over its length.
        With `inward`, the fingertips lean that far toward the base where the path runs
        close to it (NEAR_BASE)."""
        s_prof, need, _ = prof
        rise = np.maximum.accumulate(np.maximum(need, a[2]))
        fall = np.maximum.accumulate(np.maximum(need, b[2])[::-1])[::-1]
        tent = np.minimum(rise, fall)
        n_check = 10
        pts, tilts = [], []
        qs = q
        floor = min(a[2], b[2])
        for s in np.linspace(0, 1, n_check + 2)[1:-1]:
            xy = a[:2] + (b[:2] - a[:2]) * s
            want = float(np.interp(s, s_prof, tent))
            z_lo = max(floor, min(want, max(a[2], b[2])))
            yaw = yaw0 + (yaw1 - yaw0) * self._turn(s)
            try:
                tilt, z, qs = self._best_tilt(np.r_[xy, 0], yaw, offset, qs, z_lo, want)
            except PlanningFailed:
                tilt = max(tilt_a, tilt_b)
                z, qs = self._reachable_height(np.r_[xy, 0], yaw, offset, qs, z_lo, want, z_floor=floor, tilt=tilt)
            pts.append(np.r_[xy, z])
            tilts.append(tilt)
        path = [a] + pts + [b]
        # Tilt changes gradually: hold the largest value within two samples, then average.
        tilts = np.r_[tilt_a, tilts, tilt_b]
        padded = np.r_[tilt_a, tilt_a, tilts, tilt_b, tilt_b]
        held = np.max([padded[i:i + len(tilts)] for i in range(5)], axis=0)
        tilts = np.convolve(np.r_[held[0], held, held[-1]], np.ones(3) / 3, mode="valid")
        if inward:
            r = np.array([np.linalg.norm(p[:2] - self.pan_xy) for p in path])
            near = np.clip((NEAR_BASE[1] - r) / (NEAR_BASE[1] - NEAR_BASE[0]), 0, 1)
            near = near * near * (3 - 2 * near)
            tilts = tilts - inward * near
        tilts[0], tilts[-1] = tilt_a, tilt_b
        # Arc-length parametrised polyline with one minimum-jerk profile over its length.
        seg = np.array([np.linalg.norm(p1 - p0) for p0, p1 in zip(path[:-1], path[1:])])
        total = seg.sum()
        T = self._duration(total, self.e["carry_speed"], 1.0, 3.5)
        T = max(T, np.abs(np.diff(tilts)).sum() / TILT_RATE / self.speed)
        cum = np.r_[0, np.cumsum(seg)] / max(total, 1e-9)
        for s in min_jerk(max(2, round(T * self.fps))):
            k = min(np.searchsorted(cum, s, side="right") - 1, len(seg) - 1)
            t = (s - cum[k]) / max(cum[k + 1] - cum[k], 1e-9)
            p = path[k] + (path[k + 1] - path[k]) * t
            tilt = tilts[k] + (tilts[k + 1] - tilts[k]) * t
            q = self._solve(p, yaw0 + (yaw1 - yaw0) * self._turn(s), offset, q, tilt=tilt)
            traj.add(q, self.close_q, "traverse")
        return q

    @staticmethod
    def _turn(s):
        """Wrist turn progress along the carry: all of it in the middle 60%, where
        the arm is closer in and reaches higher than over the far ranks."""
        t = np.clip((s - 0.2) / 0.6, 0, 1)
        return t * t * (3 - 2 * t)