From d0ff59163f2a600c4a2809ff7a9fa5125a5681f7 Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Wed, 15 Jul 2026 07:02:31 +0000
Subject: [PATCH 01/19] feat(pick): wrist-camera visual-servo grasp for
 pick_any_object + tuning panel
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add a wrist-camera fine-alignment stage to the pick_any_object grasp, and the
Teleop tuning panel that drives it. After the base parks the object in the
head-camera pick box, the arm goes to an operator-posed search position (up
high, elbow ~90°, wrist camera looking down), Gemini marks the object, and the
arm visual-servos straight down onto it: center-in-box first, then descend one
step, repeating until a stop height where the blind ladder finishes the grasp.

Tracking is HSV color segmentation + CamShift, not optical flow: during the
descent the object grows ~2.5x in the wrist image and fabric deforms, which
slides LK patches onto the carpet. A likelihood-ratio color model (object vs
surrounding floor) back-projected each frame is scale- and deformation-proof,
and its score honestly reports occlusion/loss instead of tracking carpet.

The pick_any_object skill and its runtime helpers (arm_rest_position,
gripper_open, gripper_close) move from the gitignored workspace/custom_skills/
into workspace/innate_skills/ so the pipeline is tracked and works from a fresh
checkout. Bare-name skill chaining still resolves them (local/ then innate-os/).

Panel (Teleop, key "o"): live top-down + side grasp views, per-stage sliders
that publish overrides the running skill applies mid-run, and a draggable wrist
box + detection marker over the arm-camera video for aiming the servo.

Topics: skill -> /pick_any_object/debug (stage events), panel ->
/pick_any_object/tuning (parameter overrides).
---
 webapp/css/app.css                           |  332 +++++
 webapp/js/constants.js                       |    6 +
 webapp/js/teleop/main.js                     |    2 +
 webapp/js/teleop/pickTunePanel.js            | 1237 +++++++++++++++++
 workspace/innate_skills/arm_rest_position.py |  105 ++
 workspace/innate_skills/gripper_close.py     |   56 +
 workspace/innate_skills/gripper_open.py      |   53 +
 workspace/innate_skills/pick_any_object.py   | 1296 ++++++++++++++++++
 8 files changed, 3087 insertions(+)
 create mode 100644 webapp/js/teleop/pickTunePanel.js
 create mode 100644 workspace/innate_skills/arm_rest_position.py
 create mode 100644 workspace/innate_skills/gripper_close.py
 create mode 100644 workspace/innate_skills/gripper_open.py
 create mode 100644 workspace/innate_skills/pick_any_object.py

diff --git a/webapp/css/app.css b/webapp/css/app.css
index bf5ae931f..c9398be68 100644
--- a/webapp/css/app.css
+++ b/webapp/css/app.css
@@ -872,6 +872,268 @@ button {
   color: var(--accent);
 }
 
+/* ---- pick-tuning panel (Teleop) ------------------------------------------ */
+
+/* Toggle sits under the telemetry card, left edge — same glass pulse-button
+   language as the profiling toggle. */
+.picktune-toggle {
+  position: absolute;
+  top: 92px;
+  left: 14px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  padding: 0;
+  background: var(--glass);
+  backdrop-filter: blur(14px);
+  -webkit-backdrop-filter: blur(14px);
+  border: 1px solid var(--hairline);
+  border-radius: 9px;
+  color: var(--muted);
+  cursor: pointer;
+  transition: color 150ms ease, border-color 150ms ease;
+}
+
+.picktune-toggle:hover {
+  color: var(--text);
+  border-color: var(--hairline-strong);
+}
+
+.picktune-toggle.active {
+  color: var(--accent);
+  border-color: var(--accent-dim);
+}
+
+/* A pick run is streaming debug events — pulse green even while closed. */
+.picktune-toggle.running {
+  color: var(--ok);
+  border-color: var(--ok);
+}
+
+.picktune {
+  position: absolute;
+  top: 134px;
+  left: 14px;
+  z-index: 2;
+  width: 324px;
+  max-height: calc(100% - 148px);
+  overflow-y: auto;
+  padding: 11px 14px;
+  background: rgb(0 0 0 / 66%);
+  backdrop-filter: blur(20px);
+  -webkit-backdrop-filter: blur(20px);
+  border: 1px solid var(--hairline);
+  border-radius: 11px;
+  user-select: none;
+  -webkit-user-select: none;
+}
+
+.picktune-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 10px;
+}
+
+.picktune-head .profiling-hint {
+  margin-left: auto;
+}
+
+.picktune-sync {
+  font-size: 10px;
+  color: var(--muted);
+}
+
+.picktune-sync.live {
+  color: var(--ok);
+}
+
+.picktune-canvas {
+  display: block;
+  width: 296px;
+  height: 252px;
+  border: 1px solid var(--hairline);
+  border-radius: 8px;
+}
+
+/* Side (x–z) grasp view under the top-down view. */
+.picktune-canvas-side {
+  height: 150px;
+  margin-top: 8px;
+}
+
+/* Grasp reticle over the live head video: the skill's grasp pixel, centered
+   on (left,top) set in JS. Lives in .video-stage, drawn above the frame but
+   below the glass overlays. */
+.picktune-grab {
+  position: absolute;
+  z-index: 1;
+  transform: translate(-50%, -50%);
+  color: var(--accent);
+  pointer-events: none;
+  filter: drop-shadow(0 0 2px rgb(0 0 0 / 70%));
+}
+
+.picktune-grab-tag {
+  position: absolute;
+  top: 50%;
+  left: calc(100% + 4px);
+  transform: translateY(-50%);
+  font-size: 10px;
+  color: inherit;
+  white-space: nowrap;
+}
+
+/* Detection marker (box corners at Gemini's pixel) — green to read apart
+   from the amber grasp target. Its tag hangs left so the two labels don't
+   collide when detection and grasp target sit centimeters apart (the usual
+   case: they differ only by the fingertip offset). */
+.picktune-seen {
+  color: var(--ok);
+}
+
+.picktune-seen .picktune-grab-tag {
+  left: auto;
+  right: calc(100% + 4px);
+}
+
+/* The positioning goal square on the video: put the detection inside this and
+   the base stops. Green while the skill reports the detection inside.
+   Draggable — moving it re-aims the skill (sweet_x / box_y). */
+.picktune-boxgoal {
+  position: absolute;
+  z-index: 1;
+  transform: translate(-50%, -50%);
+  border: 1.5px dashed var(--accent-dim);
+  border-radius: 2px;
+  pointer-events: auto;
+  cursor: grab;
+  touch-action: none;
+}
+
+.picktune-boxgoal.dragging {
+  cursor: grabbing;
+  border-color: var(--accent);
+}
+
+/* Inner accept box: the point must land in THIS to stop positioning. Solid
+   amber guide; greens (with the tag) when the skill reports the point inside. */
+.picktune-boxaccept {
+  position: absolute;
+  left: 50%;
+  top: 50%;
+  transform: translate(-50%, -50%);
+  border: 1.5px solid var(--accent-dim);
+  border-radius: 2px;
+  pointer-events: none;
+}
+
+.picktune-boxgoal.inside .picktune-boxaccept {
+  border-color: var(--ok);
+}
+
+.picktune-boxgoal-tag {
+  position: absolute;
+  bottom: calc(100% + 3px);
+  left: 0;
+  font-size: 10px;
+  color: var(--accent-dim);
+  white-space: nowrap;
+}
+
+.picktune-boxgoal.inside .picktune-boxgoal-tag {
+  color: var(--ok);
+}
+
+.picktune-group {
+  margin-top: 10px;
+  margin-bottom: 4px;
+}
+
+.picktune-param {
+  display: grid;
+  grid-template-columns: 82px 1fr 64px;
+  align-items: center;
+  gap: 8px;
+  padding: 1px 0;
+}
+
+.picktune-param-label {
+  font-size: 11px;
+  color: var(--muted);
+  white-space: nowrap;
+}
+
+/* Overridden away from the code default — flag it. */
+.picktune-param.dirty .picktune-param-label {
+  color: var(--accent);
+}
+
+.picktune-param-value {
+  font-size: 11px;
+  color: var(--text);
+  text-align: right;
+  white-space: nowrap;
+}
+
+.picktune-slider {
+  width: 100%;
+  height: 3px;
+  appearance: none;
+  -webkit-appearance: none;
+  background: var(--hairline-strong);
+  border-radius: 2px;
+  outline: none;
+  cursor: pointer;
+}
+
+.picktune-slider::-webkit-slider-thumb {
+  appearance: none;
+  -webkit-appearance: none;
+  width: 11px;
+  height: 11px;
+  border-radius: 50%;
+  background: var(--text);
+  border: none;
+}
+
+.picktune-slider::-moz-range-thumb {
+  width: 11px;
+  height: 11px;
+  border-radius: 50%;
+  background: var(--text);
+  border: none;
+}
+
+.picktune-param.dirty .picktune-slider::-webkit-slider-thumb {
+  background: var(--accent);
+}
+
+.picktune-param.dirty .picktune-slider::-moz-range-thumb {
+  background: var(--accent);
+}
+
+.picktune-footer {
+  display: flex;
+  justify-content: flex-end;
+  margin: 10px 0;
+}
+
+.picktune-log {
+  margin-top: 4px;
+  max-height: 108px;
+  overflow-y: auto;
+  font-size: 10px;
+  line-height: 1.5;
+  color: var(--muted);
+}
+
+.picktune-log-line.warn {
+  color: var(--danger);
+}
+
 /* ---- record HUD (Collect page) ------------------------------------------ */
 
 .overlay-record {
@@ -1563,6 +1825,76 @@ button {
   margin: 2px 0;
 }
 
+/* Live follower-joint readout — a subtle click-to-copy array literal. */
+.arm-follower {
+  position: relative;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+/* Copy icon sitting beside the readout. */
+.arm-follower-copy {
+  flex: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 2px;
+  color: var(--muted);
+  background: transparent;
+  border: 0;
+  cursor: pointer;
+}
+
+.arm-follower-copy:hover:not(:disabled) {
+  color: var(--text);
+}
+
+.arm-follower-copy:disabled {
+  opacity: 0.4;
+  cursor: default;
+}
+
+/* "Copied" confirmation, floated above the readout on click. */
+.arm-follower-tip {
+  position: absolute;
+  bottom: calc(100% + 3px);
+  left: 0;
+  font-size: 9px;
+  color: var(--ok);
+  background: var(--panel);
+  border: 1px solid var(--ok);
+  border-radius: 3px;
+  padding: 1px 5px;
+  pointer-events: none;
+}
+
+.arm-follower-value {
+  flex: 1;
+  min-width: 0;
+  text-align: left;
+  font-size: 9px;
+  line-height: 1.3;
+  color: var(--muted);
+  background: transparent;
+  border: 0;
+  padding: 0;
+  cursor: pointer;
+  word-break: break-word;
+}
+
+.arm-follower-value:hover:not(:disabled) {
+  color: var(--text);
+}
+
+.arm-follower-value:disabled {
+  cursor: default;
+}
+
+.arm-follower-value.copied {
+  color: var(--ok);
+}
+
 .arm-services {
   display: flex;
   flex-direction: column;
diff --git a/webapp/js/constants.js b/webapp/js/constants.js
index c52d6e2d1..4873163e3 100644
--- a/webapp/js/constants.js
+++ b/webapp/js/constants.js
@@ -132,6 +132,12 @@ export const PINNED_SKILLS = ["navigate with vision", "navigate with position",
 export const EXECUTE_SKILL_ACTION = "/execute_skill";
 export const EXECUTE_SKILL_ACTION_TYPE = "brain_messages/action/ExecuteSkill";
 
+// Pick-tuning panel (Teleop) <-> pick_any_object skill. DEBUG streams the
+// skill's stage events (std_msgs/String JSON: {ev, t, ...}); TUNING carries
+// live parameter overrides the same way ({param_key: number, ...}).
+export const PICK_DEBUG_TOPIC = "/pick_any_object/debug";
+export const PICK_TUNING_TOPIC = "/pick_any_object/tuning";
+
 export const HEAD_MIN_DEG = -40;
 export const HEAD_MAX_DEG = 70;
 
diff --git a/webapp/js/teleop/main.js b/webapp/js/teleop/main.js
index 37d636718..7c3213852 100644
--- a/webapp/js/teleop/main.js
+++ b/webapp/js/teleop/main.js
@@ -23,6 +23,7 @@ import { createTtsBar } from "./ttsBar.js";
 import { createTelemetry } from "./telemetry.js";
 import { createArmPanel } from "./armPanel.js";
 import { createProfilingPanel } from "./profilingPanel.js";
+import { createPickTunePanel } from "./pickTunePanel.js";
 import { createSkillsMenu } from "./skillsMenu.js";
 import { createCameraSwitch } from "./cameraSwitch.js";
 
@@ -92,6 +93,7 @@ function buildCockpit(root) {
     createSkillsMenu(ttsOverlay, ros),
     createArmPanel(armOverlay, ros, { hideServices: !!config.simControls }),
     ...(config.simControls ? [] : [createProfilingPanel(root, session)]),
+    createPickTunePanel(root, ros, session),
     createCameraSwitch(root, session, ros),
     keyboard,
   );
diff --git a/webapp/js/teleop/pickTunePanel.js b/webapp/js/teleop/pickTunePanel.js
new file mode 100644
index 000000000..c95ea1107
--- /dev/null
+++ b/webapp/js/teleop/pickTunePanel.js
@@ -0,0 +1,1237 @@
+// @ts-check
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2026 Innate Inc
+// Pick-tuning panel — a live workbench for iterating on the pick_any_object
+// skill's POSITION and GRASP stages. A crosshair toggle under the telemetry
+// card (or "o") opens it; hidden by default so the cockpit stays clean.
+//
+// Top: a top-down base_link view (robot at the bottom, +x forward/up) that
+// plots every metric localization the skill reports on /pick_any_object/debug,
+// with the sweet-spot ring, bearing/approach tolerance geometry, and the arm's
+// grasp-reach clamp box drawn from the *current* slider values — so you see a
+// run converge (or not) against the exact thresholds you set. Under it: a
+// side (x–z) view of the grasp — the planned hover→descend ladder from the
+// sliders, overlaid with the actual EE positions each stage reports, so a
+// missed grasp shows exactly where the descent diverged. Below: sliders
+// that publish overrides to /pick_any_object/tuning (applied live, mid-run,
+// by the skill) and a compact event log.
+//
+// The skill also reprojects its grasp target back onto the head frame and
+// sends the pixel (grab_px) on the debug topic. We draw a reticle over the
+// live video at that pixel — the actual spot on the floor the fingers will
+// close on — so you can watch the aim on the real image, not just the plot.
+// The detection pixel from each localize event gets its own marker (green box
+// corners) so you see where Gemini found the object vs where the arm will
+// grab; it clears whenever the base starts moving, since a stored pixel no
+// longer matches the shifted view, and reappears on the next localization.
+// The head video is object-fit:contain (letterboxed, never cropped), so the
+// 640×480 pixel maps to the screen with a single uniform scale + centering.
+// When the ARM (wrist) camera is on the big stage instead, the same stage
+// hosts the wrist-align overlays: a draggable goal box in raw wrist-image
+// pixels (wrist_box_u/v) and the skill's wrist detection marker.
+//
+// Sync protocol: overrides persist in localStorage and are re-published every
+// time the skill reports run_start, which closes the cold-start gap (the
+// skill only subscribes once its first run begins). The skill acks every
+// tuning message by echoing its live params; "live" in the header means the
+// last echo matches our sliders.
+
+import { PICK_DEBUG_TOPIC, PICK_TUNING_TOPIC } from "../constants.js";
+
+const TOGGLE_KEY = "KeyO";
+const STORAGE_KEY = "innate.pickTune.overrides";
+const PUBLISH_DEBOUNCE_MS = 120;
+const LOG_CAP = 40;
+
+// Grasp-target clamp in pick_any_object.py's _grasp_at — drawn as the reach box.
+const REACH = { xMin: 0.22, xMax: 0.4, yMax: 0.1 };
+
+/**
+ * @typedef {{ key: string, label: string, unit: string, min: number, max: number, step: number, def: number }} ParamSpec
+ */
+
+// Mirrors TUNABLE in workspace/custom_skills/pick_any_object.py — keep the
+// keys and defaults in sync (defaults here are what Reset publishes).
+/** @type {{ label: string, params: ParamSpec[] }[]} */
+const PARAM_GROUPS = [
+  {
+    // Position first: box x (forward) + box y (lateral) are the two coords the
+    // video drag writes, kept adjacent so the pair is obvious. box x can aim
+    // past the arm's ~0.43 m grasp reach — beyond that the grasp saturates at
+    // the reach clamp (positioning still works, the fingers just stop short).
+    label: "pick box (image goal)",
+    params: [
+      { key: "sweet_x", label: "box x", unit: "m", min: 0.2, max: 1.0, step: 0.005, def: 0.3 },
+      { key: "box_y", label: "box y", unit: "m", min: -0.12, max: 0.12, step: 0.005, def: 0 },
+      { key: "box_half_px", label: "box half", unit: "px", min: 15, max: 120, step: 5, def: 40 },
+      { key: "accept_frac", label: "accept", unit: "×", min: 0.2, max: 1, step: 0.05, def: 0.5 },
+      { key: "box_steps", label: "max steps", unit: "", min: 2, max: 10, step: 1, def: 6 },
+      { key: "bearing_go_deg", label: "bearing go", unit: "°", min: 1, max: 15, step: 0.5, def: 4 },
+    ],
+  },
+  {
+    // Pixel-servo gains for the optical-flow follower: rad/s (or m/s) per 100 px
+    // of tracked-point error from the box centre.
+    label: "follow (px servo)",
+    params: [
+      { key: "follow_gain_ang", label: "turn gain", unit: "", min: 0.05, max: 1.0, step: 0.05, def: 0.3 },
+      { key: "follow_gain_lin", label: "drive gain", unit: "", min: 0.01, max: 0.2, step: 0.01, def: 0.06 },
+    ],
+  },
+  {
+    label: "detect",
+    params: [
+      { key: "tilt_deg", label: "head tilt", unit: "°", min: -35, max: -10, step: 1, def: -20 },
+      { key: "settle_s", label: "settle", unit: "s", min: 0.2, max: 3, step: 0.1, def: 1.2 },
+    ],
+  },
+  {
+    label: "rotate loop",
+    params: [
+      { key: "rot_tol_deg", label: "tol", unit: "°", min: 0.5, max: 6, step: 0.25, def: 2.5 },
+      { key: "rot_kp", label: "kp", unit: "", min: 0.3, max: 3, step: 0.1, def: 1.2 },
+      { key: "rot_wz_max", label: "wz max", unit: "rad/s", min: 0.15, max: 0.8, step: 0.05, def: 0.5 },
+      { key: "rot_wz_min", label: "wz min", unit: "rad/s", min: 0.05, max: 0.3, step: 0.01, def: 0.15 },
+    ],
+  },
+  {
+    label: "drive loop",
+    params: [
+      { key: "drive_tol_m", label: "tol", unit: "m", min: 0.005, max: 0.05, step: 0.005, def: 0.015 },
+      { key: "drive_kp", label: "kp", unit: "", min: 0.1, max: 1, step: 0.05, def: 0.3 },
+      { key: "drive_v_max", label: "v max", unit: "m/s", min: 0.04, max: 0.2, step: 0.01, def: 0.1 },
+      { key: "drive_v_min", label: "v min", unit: "m/s", min: 0.02, max: 0.08, step: 0.005, def: 0.04 },
+    ],
+  },
+  {
+    // Wrist visual-servo descent: the hover goes to the operator's posed
+    // search position (up high, wrist camera on the object), Gemini seeds the
+    // object pixel there, then optical flow tracks it on wrist frames while
+    // the arm steps down, correcting x/y each cycle; z drops only while the
+    // point is inside the wrist box (drag it on the arm-camera view). Gains
+    // are SIGNED — the wrist cam is mirrored — so flip one live if the servo
+    // diverges instead of centering.
+    label: "wrist servo (arm cam)",
+    params: [
+      { key: "wrist_steps", label: "gemini seeds", unit: "", min: 0, max: 4, step: 1, def: 2 },
+      { key: "wrist_stop_z", label: "stop z", unit: "m", min: 0.02, max: 0.12, step: 0.005, def: 0.04 },
+      { key: "wrist_z_step", label: "z step", unit: "m", min: 0.005, max: 0.04, step: 0.005, def: 0.01 },
+      { key: "wrist_move_s", label: "step t", unit: "s", min: 0.2, max: 1.5, step: 0.1, def: 0.5 },
+      { key: "wrist_pitch", label: "pitch", unit: "rad", min: 0.6, max: 1.55, step: 0.01, def: 0.82 },
+      { key: "wrist_box_u", label: "box u", unit: "px", min: 0, max: 640, step: 5, def: 320 },
+      { key: "wrist_box_v", label: "box v", unit: "px", min: 0, max: 480, step: 5, def: 240 },
+      { key: "wrist_half_px", label: "box half", unit: "px", min: 20, max: 160, step: 5, def: 60 },
+      { key: "wrist_kx", label: "fwd gain", unit: "", min: -0.12, max: 0.12, step: 0.005, def: -0.04 },
+      { key: "wrist_ky", label: "lat gain", unit: "", min: -0.12, max: 0.12, step: 0.005, def: -0.04 },
+      { key: "wrist_step_max", label: "step max", unit: "m", min: 0.01, max: 0.08, step: 0.005, def: 0.04 },
+      { key: "wrist_settle_s", label: "settle", unit: "s", min: 0.2, max: 2, step: 0.1, def: 0.8 },
+    ],
+  },
+  {
+    label: "grasp descent",
+    params: [
+      { key: "grasp_x_off", label: "x offset", unit: "m", min: 0, max: 0.08, step: 0.005, def: 0.03 },
+      { key: "hover_z", label: "hover z", unit: "m", min: 0.08, max: 0.25, step: 0.005, def: 0.15 },
+      { key: "hover_s", label: "hover t", unit: "s", min: 0.8, max: 4, step: 0.1, def: 2 },
+      { key: "descend_z1", label: "step z1", unit: "m", min: 0.02, max: 0.14, step: 0.005, def: 0.1 },
+      { key: "descend_z2", label: "step z2", unit: "m", min: 0.01, max: 0.12, step: 0.005, def: 0.06 },
+      { key: "descend_z3", label: "step z3", unit: "m", min: 0, max: 0.1, step: 0.005, def: 0.03 },
+      { key: "floor_z", label: "floor z", unit: "m", min: 0, max: 0.05, step: 0.002, def: 0.01 },
+      { key: "descend_s", label: "step t", unit: "s", min: 0.4, max: 3, step: 0.1, def: 1.2 },
+      { key: "descend_abort_z", label: "abort z", unit: "m", min: 0.05, max: 0.2, step: 0.005, def: 0.12 },
+      { key: "arm_pitch", label: "pitch", unit: "rad", min: 1, max: 1.55, step: 0.01, def: 1.3 },
+    ],
+  },
+  {
+    label: "grasp close · lift",
+    params: [
+      { key: "close_strength", label: "strength", unit: "", min: 0.2, max: 1, step: 0.05, def: 0.6 },
+      { key: "close_s", label: "close t", unit: "s", min: 0.5, max: 3, step: 0.1, def: 1.5 },
+      { key: "close_settle_s", label: "settle", unit: "s", min: 0, max: 2, step: 0.1, def: 0.8 },
+      { key: "twist_rad", label: "twist", unit: "rad", min: 0, max: 1.4, step: 0.05, def: 0.6 },
+      { key: "lift_rad", label: "lift", unit: "rad", min: 0.2, max: 1.4, step: 0.05, def: 0.6 },
+    ],
+  },
+];
+
+/** @type {ParamSpec[]} */
+const ALL_PARAMS = PARAM_GROUPS.flatMap((g) => g.params);
+
+// Top-down view window in base_link meters: x (forward) up, y (left) left.
+// xMax spans the full box x range so the goal stays on-canvas at max reach-out.
+const VIEW = { xMin: -0.08, xMax: 1.08, canvasW: 296, canvasH: 252 };
+
+// Head-camera frame size the skill's grasp pixel is expressed in (IMG_W/IMG_H
+// in pick_any_object.py). Only a fallback — the live <video>'s intrinsic size
+// wins when known.
+const IMG = { w: 640, h: 480 };
+
+// Head-camera geometry, mirrored from pick_any_object.py (URDF values) so the
+// pick box can be drawn from the sliders without asking the skill.
+const HEAD_ORIGIN = [-0.040751, -0.0002, 0.25882];
+const CAM_IN_HEAD = [0.04327, 0.0297, -0.000275];
+const HFOV_DEG = 70;
+const FX = IMG.w / (2 * Math.tan(((HFOV_DEG / 2) * Math.PI) / 180));
+
+/** Camera pose (position + axes) for a head tilt. @param {number} tiltDeg */
+function camPose(tiltDeg) {
+  const t = (tiltDeg * Math.PI) / 180;
+  const c = Math.cos(t);
+  const s = Math.sin(t);
+  /** @param {[number, number, number]} v */
+  const rot = (v) => [c * v[0] - s * v[2], v[1], s * v[0] + c * v[2]];
+  const r = rot(/** @type {[number, number, number]} */ (CAM_IN_HEAD));
+  return {
+    cam: [HEAD_ORIGIN[0] + r[0], HEAD_ORIGIN[1] + r[1], HEAD_ORIGIN[2] + r[2]],
+    fwd: rot([1, 0, 0]),
+    right: rot([0, -1, 0]),
+    down: rot([0, 0, -1]),
+  };
+}
+
+/** Floor point (base_link x,y, z=0) -> image pixel, or null behind the camera.
+ *  Mirror of floor_to_pixel in pick_any_object.py.
+ *  @param {number} x @param {number} y @param {number} tiltDeg */
+function floorToPixel(x, y, tiltDeg) {
+  const { cam, fwd, right, down } = camPose(tiltDeg);
+  const D = [x - cam[0], y - cam[1], -cam[2]];
+  const a = D[0] * fwd[0] + D[1] * fwd[1] + D[2] * fwd[2];
+  if (a <= 1e-6) return null;
+  const b = D[0] * right[0] + D[1] * right[1] + D[2] * right[2];
+  const cc = D[0] * down[0] + D[1] * down[1] + D[2] * down[2];
+  return { u: IMG.w / 2 + (b / a) * FX, v: IMG.h / 2 + (cc / a) * FX };
+}
+
+/** Image pixel -> floor point, or null above the horizon.
+ *  Mirror of pixel_to_floor in pick_any_object.py.
+ *  @param {number} u @param {number} v @param {number} tiltDeg */
+function pixelToFloor(u, v, tiltDeg) {
+  const { cam, fwd, right, down } = camPose(tiltDeg);
+  const xo = (u - IMG.w / 2) / FX;
+  const yo = (v - IMG.h / 2) / FX;
+  const d = [0, 1, 2].map((i) => fwd[i] + xo * right[i] + yo * down[i]);
+  if (d[2] >= -1e-6) return null;
+  const t = -cam[2] / d[2];
+  return { x: cam[0] + t * d[0], y: cam[1] + t * d[1] };
+}
+
+/**
+ * @param {HTMLElement} parent cockpit root — owns the toggle button + panel.
+ * @param {import("../rosClient.js").RosClient} rosClient
+ * @param {import("../webrtcSession.js").WebRtcSession} [session]
+ *   Video session — tells us which camera fills the big stage: head-camera
+ *   overlays (reticle, pick box) only show on "main", wrist-align overlays
+ *   only on "arm" (a floor pixel is meaningless on the wrist cam and vice
+ *   versa).
+ * @returns {{ destroy: () => void }}
+ */
+export function createPickTunePanel(parent, rosClient, session) {
+  const toggleBtn = document.createElement("button");
+  toggleBtn.type = "button";
+  toggleBtn.className = "picktune-toggle";
+  toggleBtn.title = "Pick tuning (o)";
+  toggleBtn.setAttribute("aria-label", "Toggle pick-tuning panel");
+  toggleBtn.innerHTML =
+    '<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" ' +
+    'stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">' +
+    '<circle cx="12" cy="12" r="7"/><line x1="12" y1="2" x2="12" y2="6"/>' +
+    '<line x1="12" y1="18" x2="12" y2="22"/><line x1="2" y1="12" x2="6" y2="12"/>' +
+    '<line x1="18" y1="12" x2="22" y2="12"/></svg>';
+
+  const wrap = document.createElement("div");
+  wrap.className = "picktune";
+  wrap.hidden = true;
+
+  const head = document.createElement("div");
+  head.className = "picktune-head";
+  const title = document.createElement("span");
+  title.className = "microlabel";
+  title.textContent = "pick tuning";
+  const sync = document.createElement("span");
+  sync.className = "picktune-sync mono";
+  sync.textContent = "defaults";
+  const hint = document.createElement("span");
+  hint.className = "profiling-hint mono";
+  hint.textContent = "o";
+  head.append(title, sync, hint);
+
+  const canvas = document.createElement("canvas");
+  canvas.className = "picktune-canvas";
+
+  const sideCanvas = document.createElement("canvas");
+  sideCanvas.className = "picktune-canvas picktune-canvas-side";
+
+  const paramsEl = document.createElement("div");
+  paramsEl.className = "picktune-params";
+
+  const footer = document.createElement("div");
+  footer.className = "picktune-footer";
+  const resetBtn = document.createElement("button");
+  resetBtn.type = "button";
+  resetBtn.className = "sim-button";
+  resetBtn.textContent = "Reset defaults";
+  footer.append(resetBtn);
+
+  const logHead = document.createElement("p");
+  logHead.className = "microlabel";
+  logHead.textContent = "events";
+  const logEl = document.createElement("div");
+  logEl.className = "picktune-log mono";
+
+  wrap.append(head, canvas, sideCanvas, paramsEl, footer, logHead, logEl);
+  parent.append(toggleBtn, wrap);
+
+  // Reticle drawn over the live video at the skill's grasp pixel. Lives in the
+  // video stage (not the panel) so it shows whether or not the panel is open,
+  // and its coordinate origin is the stage — the same box the <video> fills.
+  const videoStage = /** @type {HTMLElement | null} */ (parent.querySelector(".video-stage"));
+  const reticle = document.createElement("div");
+  reticle.className = "picktune-grab";
+  reticle.hidden = true;
+  reticle.innerHTML =
+    '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
+    'stroke-width="1.6" aria-hidden="true">' +
+    '<circle cx="24" cy="24" r="13"/>' +
+    '<line x1="24" y1="3" x2="24" y2="14"/><line x1="24" y1="34" x2="24" y2="45"/>' +
+    '<line x1="3" y1="24" x2="14" y2="24"/><line x1="34" y1="24" x2="45" y2="24"/>' +
+    '<circle cx="24" cy="24" r="2.2" fill="currentColor" stroke="none"/></svg>' +
+    '<span class="picktune-grab-tag mono">grasp target</span>';
+  if (videoStage) videoStage.appendChild(reticle);
+
+  // Detection marker: box corners around the pixel Gemini reported, in the
+  // detection color, so "seen here" and "grabbing here" read apart at a glance.
+  const seenMark = document.createElement("div");
+  seenMark.className = "picktune-grab picktune-seen";
+  seenMark.hidden = true;
+  seenMark.innerHTML =
+    '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
+    'stroke-width="1.6" aria-hidden="true">' +
+    '<path d="M8 16 V8 H16"/><path d="M32 8 H40 V16"/>' +
+    '<path d="M40 32 V40 H32"/><path d="M16 40 H8 V32"/></svg>' +
+    '<span class="picktune-grab-tag mono">detected</span>';
+  if (videoStage) videoStage.appendChild(seenMark);
+
+  // The pick box: the positioning goal square, drawn whenever the head video
+  // is up (it's the standing aim frame, not per-run state). Turns green while
+  // the skill reports the detection inside it.
+  const boxGoal = document.createElement("div");
+  boxGoal.className = "picktune-boxgoal";
+  boxGoal.hidden = true;
+  // Inner accept box (accept_frac of the outer): the point must land in THIS to
+  // stop positioning. Greens when the skill reports inside; the outer stays a
+  // dim guide. Sized in placeReticle from the accept_frac slider.
+  boxGoal.innerHTML =
+    '<span class="picktune-boxgoal-tag mono">pick box</span>' +
+    '<div class="picktune-boxaccept"></div>';
+  const boxAccept = /** @type {HTMLElement} */ (boxGoal.querySelector(".picktune-boxaccept"));
+  if (videoStage) videoStage.appendChild(boxGoal);
+
+  // The wrist box: the wrist-align goal square, shown when the ARM camera is
+  // on the big stage. Same idea as the pick box, but in raw wrist-image pixels
+  // (wrist_box_u/v) — no floor projection, the wrist cam has none. Draggable.
+  const wristBox = document.createElement("div");
+  wristBox.className = "picktune-boxgoal";
+  wristBox.hidden = true;
+  wristBox.innerHTML = '<span class="picktune-boxgoal-tag mono">wrist box</span>';
+  if (videoStage) videoStage.appendChild(wristBox);
+
+  // Wrist detection marker: where Gemini found the object on the wrist image.
+  const wristMark = document.createElement("div");
+  wristMark.className = "picktune-grab picktune-seen";
+  wristMark.hidden = true;
+  wristMark.innerHTML =
+    '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
+    'stroke-width="1.6" aria-hidden="true">' +
+    '<path d="M8 16 V8 H16"/><path d="M32 8 H40 V16"/>' +
+    '<path d="M40 32 V40 H32"/><path d="M16 40 H8 V32"/></svg>' +
+    '<span class="picktune-grab-tag mono">wrist detect</span>';
+  if (videoStage) videoStage.appendChild(wristMark);
+
+  // ---- state ---------------------------------------------------------------
+
+  /** Slider overrides (partial, key -> value). @type {Record<string, number>} */
+  let overrides = loadOverrides();
+  /** Params last echoed by the skill, or null before any echo. @type {Record<string, number> | null} */
+  let skillParams = null;
+  /** Localizations of the current run, in arrival order. @type {{ x: number, y: number, final: boolean }[]} */
+  let points = [];
+  /** @type {{ tx: number, ty: number } | null} */
+  let grasp = null;
+  /** EE positions the grasp stages report, in arrival order. @type {{ x: number, z: number, kind: "hover"|"descend"|"lift", ok?: boolean }[]} */
+  let armTrail = [];
+  /** Gripper joint before/after the close, from the "close" event. @type {{ open: number | undefined, closed: number | undefined } | null} */
+  let closeJ6 = null;
+  /** Skill's grasp target in 640×480 image px, or null when none is active. @type {{ u: number, v: number } | null} */
+  let grabPx = null;
+  /** Latest detection pixel from localize; null after base motion shifts the view. @type {{ u: number, v: number } | null} */
+  let seenPx = null;
+  /** Latest wrist-camera detection pixel from wrist_align. @type {{ u: number, v: number } | null} */
+  let wristPx = null;
+  let running = false;
+  /** @type {number | null} */
+  let publishTimer = null;
+  /** @type {Map<string, { row: HTMLElement, slider: HTMLInputElement, value: HTMLElement }>} */
+  const rows = new Map();
+
+  /** @returns {Record<string, number>} */
+  function loadOverrides() {
+    /** @type {Record<string, number>} */
+    const out = {};
+    try {
+      const parsed = JSON.parse(localStorage.getItem(STORAGE_KEY) ?? "{}");
+      for (const spec of ALL_PARAMS) {
+        const v = parsed?.[spec.key];
+        if (typeof v === "number" && Number.isFinite(v)) out[spec.key] = v;
+      }
+    } catch {
+      // Corrupt storage — start from code defaults.
+    }
+    return out;
+  }
+
+  function saveOverrides() {
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(overrides));
+    } catch {
+      // Storage unavailable (private mode) — tuning still works, just not remembered.
+    }
+  }
+
+  /** Effective value of a param: the override, else the code default. @param {ParamSpec} spec */
+  function valueOf(spec) {
+    return overrides[spec.key] ?? spec.def;
+  }
+
+  // ---- publishing ------------------------------------------------------------
+
+  /**
+   * Publish parameter values to the skill, debounced so slider drags don't
+   * flood rosbridge. `payload` is merged skill-side (unknown keys ignored).
+   * @param {Record<string, number>} payload
+   */
+  function publishTuning(payload) {
+    if (publishTimer !== null) clearTimeout(publishTimer);
+    publishTimer = window.setTimeout(() => {
+      publishTimer = null;
+      // The skill advertises/subscribes these topics at skills-server load
+      // (see guidelines() in pick_any_object.py), so this publish only fails
+      // when the server itself is down — the run_start republish then recovers.
+      if (rosClient.state === "connected") {
+        rosClient.publish(PICK_TUNING_TOPIC, { data: JSON.stringify(payload) });
+      }
+    }, PUBLISH_DEBOUNCE_MS);
+  }
+
+  function publishOverrides() {
+    if (Object.keys(overrides).length > 0) publishTuning(overrides);
+  }
+
+  // ---- params UI -------------------------------------------------------------
+
+  for (const group of PARAM_GROUPS) {
+    const groupLabel = document.createElement("p");
+    groupLabel.className = "microlabel picktune-group";
+    groupLabel.textContent = group.label;
+    paramsEl.appendChild(groupLabel);
+    for (const spec of group.params) paramsEl.appendChild(buildRow(spec));
+  }
+
+  /** @param {ParamSpec} spec */
+  function buildRow(spec) {
+    const row = document.createElement("div");
+    row.className = "picktune-param";
+
+    const label = document.createElement("span");
+    label.className = "picktune-param-label";
+    label.textContent = spec.label;
+
+    const slider = document.createElement("input");
+    slider.type = "range";
+    slider.className = "picktune-slider";
+    slider.min = String(spec.min);
+    slider.max = String(spec.max);
+    slider.step = String(spec.step);
+    slider.value = String(valueOf(spec));
+
+    const value = document.createElement("span");
+    value.className = "picktune-param-value mono";
+
+    slider.addEventListener("input", () => {
+      const v = Number(slider.value);
+      if (v === spec.def) delete overrides[spec.key];
+      else overrides[spec.key] = v;
+      saveOverrides();
+      // Send the full override set (idempotent merge) so a lost message never
+      // leaves the skill holding a stale sibling value.
+      publishTuning(Object.keys(overrides).length > 0 ? overrides : { [spec.key]: v });
+      syncRow(spec);
+      syncHeader();
+      draw();
+    });
+
+    row.append(label, slider, value);
+    rows.set(spec.key, { row, slider, value });
+    syncRow(spec);
+    return row;
+  }
+
+  /** Repaint one row: value text + dirty highlight. @param {ParamSpec} spec */
+  function syncRow(spec) {
+    const r = rows.get(spec.key);
+    if (!r) return;
+    const v = valueOf(spec);
+    const decimals = spec.step >= 1 ? 0 : spec.step >= 0.05 ? 2 : 3;
+    r.value.textContent = `${v.toFixed(decimals)}${spec.unit}`;
+    r.row.classList.toggle("dirty", spec.key in overrides);
+  }
+
+  /** Header pill: defaults / edited / live (skill echo matches sliders). */
+  function syncHeader() {
+    const dirty = Object.keys(overrides).length > 0;
+    let text = dirty ? "edited" : "defaults";
+    let live = false;
+    if (skillParams) {
+      live = ALL_PARAMS.every((spec) => {
+        const echoed = skillParams?.[spec.key];
+        return typeof echoed !== "number" || Math.abs(echoed - valueOf(spec)) < 1e-6;
+      });
+      if (live) text = dirty ? "live · edited" : "live · defaults";
+    }
+    sync.textContent = text;
+    sync.classList.toggle("live", live);
+  }
+
+  resetBtn.addEventListener("click", () => {
+    overrides = {};
+    saveOverrides();
+    // Explicit full-defaults publish so a running skill reverts immediately.
+    publishTuning(Object.fromEntries(ALL_PARAMS.map((s) => [s.key, s.def])));
+    for (const spec of ALL_PARAMS) {
+      const r = rows.get(spec.key);
+      if (r) r.slider.value = String(spec.def);
+      syncRow(spec);
+    }
+    syncHeader();
+    draw();
+  });
+
+  // ---- top-down canvas ---------------------------------------------------
+
+  const dpr = Math.min(window.devicePixelRatio || 1, 2);
+  canvas.width = VIEW.canvasW * dpr;
+  canvas.height = VIEW.canvasH * dpr;
+  const ctx = canvas.getContext("2d");
+  const scale = VIEW.canvasH / (VIEW.xMax - VIEW.xMin); // px per meter
+
+  // Side (x–z) view window for the grasp: forward right, up up. Spans the
+  // reach box plus margin; z covers floor to a little above max hover.
+  const SIDE = { xMin: 0.14, xMax: 0.48, zMin: -0.02, zMax: 0.28, canvasH: 150 };
+  sideCanvas.width = VIEW.canvasW * dpr;
+  sideCanvas.height = SIDE.canvasH * dpr;
+  const sctx = sideCanvas.getContext("2d");
+
+  /** base_link (x fwd, y left) -> canvas px. @param {number} x @param {number} y */
+  function toPx(x, y) {
+    return {
+      px: VIEW.canvasW / 2 - y * scale,
+      py: VIEW.canvasH - (x - VIEW.xMin) * scale,
+    };
+  }
+
+  function draw() {
+    if (!ctx || wrap.hidden) return;
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    ctx.clearRect(0, 0, VIEW.canvasW, VIEW.canvasH);
+    const css = getComputedStyle(wrap);
+    const cHair = css.getPropertyValue("--hairline") || "rgb(255 255 255 / 8%)";
+    const cHairStrong = css.getPropertyValue("--hairline-strong") || "rgb(255 255 255 / 16%)";
+    const cMuted = css.getPropertyValue("--muted") || "#8a8a93";
+    const cAccent = css.getPropertyValue("--accent") || "#e8a33d";
+    const cAccentDim = css.getPropertyValue("--accent-dim") || "rgb(232 163 61 / 40%)";
+    const cOk = css.getPropertyValue("--ok") || "#56c28c";
+
+    // 0.1 m grid.
+    ctx.lineWidth = 1;
+    ctx.strokeStyle = cHair;
+    ctx.beginPath();
+    for (let gx = 0; gx <= VIEW.xMax; gx += 0.1) {
+      const { py } = toPx(gx, 0);
+      ctx.moveTo(0, py);
+      ctx.lineTo(VIEW.canvasW, py);
+    }
+    const yHalf = VIEW.canvasW / 2 / scale;
+    for (let gy = 0; gy <= yHalf; gy += 0.1) {
+      for (const s of gy === 0 ? [0] : [-1, 1]) {
+        const { px } = toPx(0, gy * s);
+        ctx.moveTo(px, 0);
+        ctx.lineTo(px, VIEW.canvasH);
+      }
+    }
+    ctx.stroke();
+
+    const sweetX = valueOf(ALL_PARAMS.find((p) => p.key === "sweet_x") ?? PARAM_GROUPS[0].params[0]);
+    const bearingGo = ((overrides.bearing_go_deg ?? 4) * Math.PI) / 180;
+
+    // Bearing-go wedge from the robot origin.
+    const origin = toPx(0, 0);
+    ctx.strokeStyle = cHairStrong;
+    ctx.setLineDash([3, 4]);
+    ctx.beginPath();
+    for (const s of [-1, 1]) {
+      const end = toPx(0.72 * Math.cos(bearingGo), 0.72 * Math.sin(bearingGo) * s);
+      ctx.moveTo(origin.px, origin.py);
+      ctx.lineTo(end.px, end.py);
+    }
+    ctx.stroke();
+
+    // Sweet-spot ring (distance target).
+    ctx.strokeStyle = cAccentDim;
+    ctx.beginPath();
+    ctx.arc(origin.px, origin.py, sweetX * scale, -Math.PI / 2 - 0.5, -Math.PI / 2 + 0.5);
+    ctx.stroke();
+    ctx.setLineDash([]);
+
+    // Pick box footprint: the image-goal square back-projected onto the floor.
+    // Outer = the drawn box (box_half_px); inner = the accept box the detection
+    // must land in to stop positioning (accept_frac × outer, solid).
+    const center = floorToPixel(sweetX, paramValue("box_y"), paramValue("tilt_deg"));
+    if (center) {
+      const half = paramValue("box_half_px");
+      const tilt = paramValue("tilt_deg");
+      /** @param {number} h @param {string} color */
+      const footprint = (h, color) => {
+        const corners = [
+          [-h, -h],
+          [h, -h],
+          [h, h],
+          [-h, h],
+        ].map(([du, dv]) => pixelToFloor(center.u + du, center.v + dv, tilt));
+        if (!corners.every(Boolean)) return;
+        ctx.strokeStyle = color;
+        ctx.beginPath();
+        corners.forEach((pt, i) => {
+          const { px, py } = toPx(/** @type {any} */ (pt).x, /** @type {any} */ (pt).y);
+          if (i === 0) ctx.moveTo(px, py);
+          else ctx.lineTo(px, py);
+        });
+        ctx.closePath();
+        ctx.stroke();
+      };
+      ctx.setLineDash([3, 3]);
+      footprint(half, cAccentDim);
+      ctx.setLineDash([]);
+      footprint(half * paramValue("accept_frac"), cAccent);
+    }
+
+    // Arm-reach clamp box (grasp tx/ty limits).
+    const boxA = toPx(REACH.xMax, REACH.yMax);
+    const boxB = toPx(REACH.xMin, -REACH.yMax);
+    ctx.strokeStyle = cMuted;
+    ctx.setLineDash([2, 3]);
+    ctx.strokeRect(boxA.px, boxA.py, boxB.px - boxA.px, boxB.py - boxA.py);
+    ctx.setLineDash([]);
+
+    // Aim-point crosshair (box centre on the floor).
+    const sweet = toPx(sweetX, paramValue("box_y"));
+    ctx.strokeStyle = cAccent;
+    ctx.beginPath();
+    ctx.moveTo(sweet.px - 5, sweet.py);
+    ctx.lineTo(sweet.px + 5, sweet.py);
+    ctx.moveTo(sweet.px, sweet.py - 5);
+    ctx.lineTo(sweet.px, sweet.py + 5);
+    ctx.stroke();
+
+    // Robot base at origin with a forward notch.
+    ctx.strokeStyle = cMuted;
+    const half = 0.09 * scale;
+    ctx.strokeRect(origin.px - half, origin.py - 0.06 * scale, half * 2, 0.12 * scale);
+    ctx.beginPath();
+    ctx.moveTo(origin.px, origin.py - 0.06 * scale);
+    ctx.lineTo(origin.px, origin.py - 0.1 * scale);
+    ctx.stroke();
+
+    // Localization trail: older estimates dim, the latest bright; the run's
+    // final (position_done) estimate ringed in green.
+    ctx.strokeStyle = cHairStrong;
+    ctx.beginPath();
+    points.forEach((pt, i) => {
+      const { px, py } = toPx(pt.x, pt.y);
+      if (i === 0) ctx.moveTo(px, py);
+      else ctx.lineTo(px, py);
+    });
+    ctx.stroke();
+    points.forEach((pt, i) => {
+      const { px, py } = toPx(pt.x, pt.y);
+      const last = i === points.length - 1;
+      ctx.fillStyle = last ? cAccent : cMuted;
+      ctx.beginPath();
+      ctx.arc(px, py, last ? 4 : 2.5, 0, Math.PI * 2);
+      ctx.fill();
+      if (pt.final) {
+        ctx.strokeStyle = cOk;
+        ctx.beginPath();
+        ctx.arc(px, py, 6.5, 0, Math.PI * 2);
+        ctx.stroke();
+      }
+    });
+
+    // Grasp target (post-clamp tx/ty) as a hollow diamond.
+    if (grasp) {
+      const { px, py } = toPx(grasp.tx, grasp.ty);
+      ctx.strokeStyle = cAccent;
+      ctx.beginPath();
+      ctx.moveTo(px, py - 5);
+      ctx.lineTo(px + 5, py);
+      ctx.lineTo(px, py + 5);
+      ctx.lineTo(px - 5, py);
+      ctx.closePath();
+      ctx.stroke();
+    }
+
+    drawSide();
+    placeReticle();
+  }
+
+  /** Effective value by key (override else code default). @param {string} key */
+  function paramValue(key) {
+    const spec = ALL_PARAMS.find((s) => s.key === key);
+    return spec ? valueOf(spec) : 0;
+  }
+
+  /** base_link (x fwd, z up) -> side-canvas px. @param {number} x @param {number} z */
+  function toSidePx(x, z) {
+    return {
+      px: ((x - SIDE.xMin) / (SIDE.xMax - SIDE.xMin)) * VIEW.canvasW,
+      py: SIDE.canvasH - ((z - SIDE.zMin) / (SIDE.zMax - SIDE.zMin)) * SIDE.canvasH,
+    };
+  }
+
+  /** Side view: planned hover→descend ladder from the sliders, the abort
+   *  threshold, and the EE positions the running grasp actually reported. */
+  function drawSide() {
+    if (!sctx || wrap.hidden) return;
+    sctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    sctx.clearRect(0, 0, VIEW.canvasW, SIDE.canvasH);
+    const css = getComputedStyle(wrap);
+    const cHair = css.getPropertyValue("--hairline") || "rgb(255 255 255 / 8%)";
+    const cHairStrong = css.getPropertyValue("--hairline-strong") || "rgb(255 255 255 / 16%)";
+    const cMuted = css.getPropertyValue("--muted") || "#8a8a93";
+    const cText = css.getPropertyValue("--text") || "#e7e7ea";
+    const cAccent = css.getPropertyValue("--accent") || "#e8a33d";
+    const cOk = css.getPropertyValue("--ok") || "#56c28c";
+    const cDanger = css.getPropertyValue("--danger") || "#d96a5a";
+
+    // Grid: 0.1 m in x, 0.05 m in z.
+    sctx.lineWidth = 1;
+    sctx.strokeStyle = cHair;
+    sctx.beginPath();
+    for (let gx = Math.ceil(SIDE.xMin * 10) / 10; gx <= SIDE.xMax; gx += 0.1) {
+      const { px } = toSidePx(gx, 0);
+      sctx.moveTo(px, 0);
+      sctx.lineTo(px, SIDE.canvasH);
+    }
+    for (let gz = 0.05; gz <= SIDE.zMax; gz += 0.05) {
+      const { py } = toSidePx(0, gz);
+      sctx.moveTo(0, py);
+      sctx.lineTo(VIEW.canvasW, py);
+    }
+    sctx.stroke();
+
+    // The floor, and the descend-abort threshold above it.
+    const floor = toSidePx(SIDE.xMin, 0);
+    sctx.strokeStyle = cHairStrong;
+    sctx.beginPath();
+    sctx.moveTo(0, floor.py);
+    sctx.lineTo(VIEW.canvasW, floor.py);
+    sctx.stroke();
+    const abortY = toSidePx(0, paramValue("descend_abort_z")).py;
+    sctx.strokeStyle = cDanger;
+    sctx.setLineDash([2, 4]);
+    sctx.beginPath();
+    sctx.moveTo(0, abortY);
+    sctx.lineTo(VIEW.canvasW, abortY);
+    sctx.stroke();
+    sctx.setLineDash([]);
+
+    // Planned ladder at the run's clamped tx (else derived from the sliders):
+    // hover → z1 → z2 → z3 → floor, with the wrist-pitch pointer at hover.
+    const sweetX = paramValue("sweet_x");
+    const lx = grasp ? grasp.tx : Math.max(REACH.xMin, Math.min(REACH.xMax, sweetX - paramValue("grasp_x_off")));
+    const hoverZ = paramValue("hover_z");
+    const ladder = [hoverZ, paramValue("descend_z1"), paramValue("descend_z2"), paramValue("descend_z3"), paramValue("floor_z")];
+    sctx.strokeStyle = cHairStrong;
+    sctx.setLineDash([2, 3]);
+    sctx.beginPath();
+    const top = toSidePx(lx, hoverZ);
+    const bottom = toSidePx(lx, ladder[ladder.length - 1]);
+    sctx.moveTo(top.px, top.py);
+    sctx.lineTo(bottom.px, bottom.py);
+    sctx.stroke();
+    sctx.setLineDash([]);
+    for (const z of ladder) {
+      const { px, py } = toSidePx(lx, z);
+      sctx.strokeStyle = z === hoverZ ? cAccent : cMuted;
+      sctx.beginPath();
+      if (z === hoverZ) {
+        sctx.arc(px, py, 4, 0, Math.PI * 2);
+      } else {
+        sctx.moveTo(px - 4, py);
+        sctx.lineTo(px + 4, py);
+      }
+      sctx.stroke();
+    }
+    // Pitch pointer: the wrist approach direction at the hover point.
+    const pitch = paramValue("arm_pitch");
+    sctx.strokeStyle = cAccent;
+    sctx.beginPath();
+    sctx.moveTo(top.px, top.py);
+    const tip = toSidePx(lx + 0.05 * Math.cos(pitch), hoverZ - 0.05 * Math.sin(pitch));
+    sctx.lineTo(tip.px, tip.py);
+    sctx.stroke();
+
+    // Actual EE trail from the run's hover/descend/lift events.
+    sctx.strokeStyle = cHairStrong;
+    sctx.beginPath();
+    armTrail.forEach((pt, i) => {
+      const { px, py } = toSidePx(pt.x, pt.z);
+      if (i === 0) sctx.moveTo(px, py);
+      else sctx.lineTo(px, py);
+    });
+    sctx.stroke();
+    armTrail.forEach((pt, i) => {
+      const { px, py } = toSidePx(pt.x, pt.z);
+      const last = i === armTrail.length - 1;
+      sctx.fillStyle =
+        pt.kind === "descend" && pt.ok === false ? cDanger : pt.kind === "lift" ? cOk : last ? cAccent : cText;
+      sctx.beginPath();
+      sctx.arc(px, py, last ? 4 : 2.5, 0, Math.PI * 2);
+      sctx.fill();
+      if (pt.kind === "lift") {
+        sctx.strokeStyle = cOk;
+        sctx.beginPath();
+        sctx.arc(px, py, 6.5, 0, Math.PI * 2);
+        sctx.stroke();
+      }
+    });
+
+    // Close outcome, bottom-left: gripper joint before → after the squeeze.
+    if (closeJ6) {
+      sctx.fillStyle = cMuted;
+      sctx.font = "10px " + (css.getPropertyValue("--font-mono") || "monospace");
+      const fmt = (/** @type {number | undefined} */ v) => (typeof v === "number" ? v.toFixed(3) : "?");
+      sctx.fillText(`close j6 ${fmt(closeJ6.open)} → ${fmt(closeJ6.closed)}`, 6, SIDE.canvasH - 6);
+    }
+  }
+
+  // ---- grasp reticle over the live video ----------------------------------
+
+  /** True when the head camera fills the big stage (a floor pixel only maps
+   *  onto that view). Defaults to true when no session was passed. */
+  function headCamPrimary() {
+    return !session || session.primaryCamera?.name === "main";
+  }
+
+  /** True when the wrist ("arm") camera fills the big stage — the view the
+   *  wrist-align box and detection marker live on. */
+  function wristCamPrimary() {
+    return session?.primaryCamera?.name === "arm";
+  }
+
+  /** Letterbox geometry of the live video inside the stage (object-fit:
+   *  contain → one uniform scale + symmetric offsets), or null when no video
+   *  is up. Camera-agnostic — both cams are 640×480 and the video's intrinsic
+   *  size wins; callers gate on WHICH camera is primary.
+   *  @returns {{ s: number, offX: number, offY: number } | null} */
+  function stageGeom() {
+    const video = /** @type {HTMLVideoElement | null} */ (videoStage?.querySelector("video"));
+    if (!video || !video.srcObject) return null;
+    const boxW = videoStage ? videoStage.clientWidth : 0;
+    const boxH = videoStage ? videoStage.clientHeight : 0;
+    if (!boxW || !boxH) return null;
+    const iw = video.videoWidth || IMG.w;
+    const ih = video.videoHeight || IMG.h;
+    const s = Math.min(boxW / iw, boxH / ih);
+    return { s, offX: (boxW - iw * s) / 2, offY: (boxH - ih * s) / 2 };
+  }
+
+  /** Position (or hide) the image-pixel markers and the goal boxes over the
+   *  video — head-camera overlays when the head cam is primary, wrist-camera
+   *  overlays when the arm cam is. */
+  function placeReticle() {
+    const g = stageGeom();
+    const headG = g && headCamPrimary() ? g : null;
+    const wristG = g && wristCamPrimary() ? g : null;
+    const markers = [
+      { el: reticle, px: grabPx, geom: headG },
+      { el: seenMark, px: seenPx, geom: headG },
+      { el: wristMark, px: wristPx, geom: wristG },
+    ];
+    for (const { el, px, geom } of markers) {
+      if (!px || !geom) {
+        el.hidden = true;
+        continue;
+      }
+      el.style.left = `${geom.offX + px.u * geom.s}px`;
+      el.style.top = `${geom.offY + px.v * geom.s}px`;
+      el.hidden = false;
+    }
+    // The wrist-align goal square, straight from the pixel sliders.
+    if (wristG) {
+      const side = 2 * paramValue("wrist_half_px") * wristG.s;
+      wristBox.style.left = `${wristG.offX + paramValue("wrist_box_u") * wristG.s}px`;
+      wristBox.style.top = `${wristG.offY + paramValue("wrist_box_v") * wristG.s}px`;
+      wristBox.style.width = `${side}px`;
+      wristBox.style.height = `${side}px`;
+      wristBox.hidden = false;
+    } else {
+      wristBox.hidden = true;
+    }
+    // The pick box goal square, from the current sliders.
+    const center = headG ? floorToPixel(paramValue("sweet_x"), paramValue("box_y"), paramValue("tilt_deg")) : null;
+    if (!headG || !center) {
+      boxGoal.hidden = true;
+      return;
+    }
+    const side = 2 * paramValue("box_half_px") * headG.s;
+    boxGoal.style.left = `${headG.offX + center.u * headG.s}px`;
+    boxGoal.style.top = `${headG.offY + center.v * headG.s}px`;
+    boxGoal.style.width = `${side}px`;
+    boxGoal.style.height = `${side}px`;
+    // Inner accept box, centered, sized as a fraction of the outer.
+    const acceptPct = `${paramValue("accept_frac") * 100}%`;
+    boxAccept.style.width = acceptPct;
+    boxAccept.style.height = acceptPct;
+    boxGoal.hidden = false;
+  }
+
+  // Video letterbox geometry shifts on any stage resize; the reticle's validity
+  // also flips when the primary camera or the stream changes (switch to wrist
+  // cam, stream drop). Re-place on both so a mid-grasp camera switch is instant,
+  // not delayed to the next debug event.
+  const onResize = () => placeReticle();
+  window.addEventListener("resize", onResize);
+  const unsubSession = session ? session.onChange(() => placeReticle()) : null;
+
+  // ---- drag the pick box on the video ---------------------------------------
+  // Dragging converts the cursor back to a floor point (pixelToFloor) and
+  // writes it into the same tunables the skill aims at: sweet_x (forward) and
+  // box_y (lateral). Sliders, overrides, and the skill stay in sync — the box
+  // is the tool, the params are the truth.
+
+  /** Set a param as if its slider was moved: snap to step, clamp to range,
+   *  update the row UI and the override map. @param {string} key @param {number} v */
+  function setParamValue(key, v) {
+    const spec = ALL_PARAMS.find((p) => p.key === key);
+    const r = rows.get(key);
+    if (!spec || !r) return;
+    const snapped = Math.max(spec.min, Math.min(spec.max, Math.round(v / spec.step) * spec.step));
+    r.slider.value = String(snapped);
+    if (Math.abs(snapped - spec.def) < 1e-9) delete overrides[key];
+    else overrides[key] = snapped;
+    syncRow(spec);
+  }
+
+  let draggingBox = false;
+
+  /** @param {PointerEvent} e */
+  function dragBoxTo(e) {
+    const g = stageGeom();
+    if (!g || !videoStage) return;
+    const rect = videoStage.getBoundingClientRect();
+    const u = (e.clientX - rect.left - g.offX) / g.s;
+    const v = (e.clientY - rect.top - g.offY) / g.s;
+    const f = pixelToFloor(u, v, paramValue("tilt_deg"));
+    if (!f) return; // above the horizon — no floor point there
+    setParamValue("sweet_x", f.x);
+    setParamValue("box_y", f.y);
+    saveOverrides();
+    // Explicit effective values: a drag back to defaults must still reach a
+    // skill that holds the old aim.
+    publishTuning({ ...overrides, sweet_x: paramValue("sweet_x"), box_y: paramValue("box_y") });
+    syncHeader();
+    draw(); // re-derives the box from the (clamped) params — cursor stays honest
+    placeReticle();
+  }
+
+  boxGoal.addEventListener("pointerdown", (e) => {
+    if (!stageGeom()) return;
+    draggingBox = true;
+    boxGoal.classList.add("dragging");
+    boxGoal.setPointerCapture(e.pointerId);
+    e.preventDefault();
+  });
+  boxGoal.addEventListener("pointermove", (e) => {
+    if (draggingBox) dragBoxTo(e);
+  });
+  const endBoxDrag = () => {
+    draggingBox = false;
+    boxGoal.classList.remove("dragging");
+  };
+  boxGoal.addEventListener("pointerup", endBoxDrag);
+  boxGoal.addEventListener("pointercancel", endBoxDrag);
+
+  // Drag the wrist box on the arm-camera view — writes wrist_box_u/v (raw
+  // wrist-image pixels) into the same slider/override machinery.
+  let draggingWrist = false;
+
+  /** @param {PointerEvent} e */
+  function dragWristTo(e) {
+    const g = stageGeom();
+    if (!g || !videoStage) return;
+    const rect = videoStage.getBoundingClientRect();
+    setParamValue("wrist_box_u", (e.clientX - rect.left - g.offX) / g.s);
+    setParamValue("wrist_box_v", (e.clientY - rect.top - g.offY) / g.s);
+    saveOverrides();
+    // Explicit effective values — a drag back to defaults must still reach a
+    // skill that holds the old aim.
+    publishTuning({ ...overrides, wrist_box_u: paramValue("wrist_box_u"), wrist_box_v: paramValue("wrist_box_v") });
+    syncHeader();
+    placeReticle();
+  }
+
+  wristBox.addEventListener("pointerdown", (e) => {
+    if (!stageGeom()) return;
+    draggingWrist = true;
+    wristBox.classList.add("dragging");
+    wristBox.setPointerCapture(e.pointerId);
+    e.preventDefault();
+  });
+  wristBox.addEventListener("pointermove", (e) => {
+    if (draggingWrist) dragWristTo(e);
+  });
+  const endWristDrag = () => {
+    draggingWrist = false;
+    wristBox.classList.remove("dragging");
+  };
+  wristBox.addEventListener("pointerup", endWristDrag);
+  wristBox.addEventListener("pointercancel", endWristDrag);
+
+  // ---- event log + debug feed ---------------------------------------------
+
+  /** @param {string} line @param {boolean} [warn] */
+  function logLine(line, warn = false) {
+    const el = document.createElement("div");
+    el.className = "picktune-log-line" + (warn ? " warn" : "");
+    el.textContent = line;
+    logEl.appendChild(el);
+    while (logEl.childElementCount > LOG_CAP) logEl.firstElementChild?.remove();
+    logEl.scrollTop = logEl.scrollHeight;
+  }
+
+  /** @param {number | undefined} n @param {number} [d] */
+  const num = (n, d = 2) => (typeof n === "number" ? n.toFixed(d) : "?");
+
+  /** @param {any} ev */
+  function onDebugEvent(ev) {
+    switch (ev.ev) {
+      case "run_start":
+        points = [];
+        grasp = null;
+        armTrail = [];
+        closeJ6 = null;
+        grabPx = null;
+        seenPx = null;
+        wristPx = null;
+        boxGoal.classList.remove("inside");
+        wristBox.classList.remove("inside");
+        running = true;
+        skillParams = ev.params ?? skillParams;
+        logLine(`run start "${ev.prompt ?? ""}"`);
+        // The skill just (re)subscribed — reassert our overrides so a fresh
+        // instance never runs on stale/default values while sliders say otherwise.
+        publishOverrides();
+        break;
+      case "run_end":
+        running = false;
+        grabPx = null;
+        seenPx = null;
+        wristPx = null;
+        boxGoal.classList.remove("inside");
+        wristBox.classList.remove("inside");
+        logLine("run end");
+        break;
+      case "params":
+        // No log line — the header's live/edited pill reflects it, and after
+        // hot-reloads retired skill instances echo too (identical acks).
+        skillParams = ev.params ?? null;
+        break;
+      case "localize":
+        seenPx = Array.isArray(ev.px) ? { u: ev.px[0], v: ev.px[1] } : null;
+        if (Array.isArray(ev.xy)) {
+          points.push({ x: ev.xy[0], y: ev.xy[1], final: false });
+          logLine(`loc px(${num(ev.px?.[0], 0)},${num(ev.px?.[1], 0)}) → (${num(ev.xy[0], 3)}, ${num(ev.xy[1], 3)})`);
+        } else {
+          logLine("loc — not found", true);
+        }
+        break;
+      case "servo":
+        // High-rate (~10 Hz) optical-flow tracking updates during the follow.
+        // Glide the marker to the tracked point and colour the box; no log line
+        // (per-tick logging would swamp the event feed).
+        if (Array.isArray(ev.px)) seenPx = { u: ev.px[0], v: ev.px[1] };
+        boxGoal.classList.toggle("inside", ev.inside === true);
+        break;
+      case "position":
+        boxGoal.classList.toggle("inside", ev.inside === true);
+        logLine(
+          `pos ${num(ev.step, 0)}: px(${num(ev.px?.[0], 0)},${num(ev.px?.[1], 0)}) ` +
+            (ev.inside ? "IN box" : "out — correcting"),
+          false,
+        );
+        break;
+      case "position_done":
+        if (Array.isArray(ev.xy)) {
+          const last = points[points.length - 1];
+          if (last && last.x === ev.xy[0] && last.y === ev.xy[1]) last.final = true;
+          const n = ev.attempts ?? ev.steps;
+          logLine(`pos done — in box${typeof n === "number" ? ` (${n} re-detects)` : ""}`);
+        } else {
+          boxGoal.classList.remove("inside");
+          logLine(`pos failed — ${ev.reason ?? "lost object"}`, true);
+        }
+        break;
+      case "rotate":
+        seenPx = null; // view is about to shift — the stored pixel goes stale
+        logLine(`rot ${num(ev.angle_deg, 1)}°`);
+        break;
+      case "rotate_done":
+        logLine(`rot done err ${num(ev.err_deg, 1)}° in ${num(ev.s, 1)}s`);
+        break;
+      case "drive":
+        seenPx = null; // same — the base is moving under the camera
+        logLine(`drv ${num(ev.dist_m, 3)}m`);
+        break;
+      case "drive_done":
+        logLine(`drv done err ${num(ev.err_m, 3)}m in ${num(ev.s, 1)}s`);
+        break;
+      case "grasp":
+        // A fresh attempt (the deep retry re-enters here) — clear the old trail.
+        grasp = { tx: ev.tx, ty: ev.ty };
+        armTrail = [];
+        closeJ6 = null;
+        grabPx = Array.isArray(ev.grab_px) ? { u: ev.grab_px[0], v: ev.grab_px[1] } : null;
+        // Pin the "detected" marker to the object point so the amber grasp
+        // target and the green object marker sit side by side — their gap is
+        // the reach clamp (grasp aims short when the object is out of reach).
+        if (Array.isArray(ev.obj_px)) seenPx = { u: ev.obj_px[0], v: ev.obj_px[1] };
+        logLine(
+          `grasp tx ${num(ev.tx, 3)} ty ${num(ev.ty, 3)}${ev.deep ? " (deep)" : ""}` +
+            (ev.clamped ? " — REACH-CLAMPED: grasp short of object (lower box x)" : ""),
+          ev.clamped === true,
+        );
+        break;
+      case "hover":
+        if (Array.isArray(ev.ee)) armTrail.push({ x: ev.ee[0], z: ev.ee[2], kind: "hover" });
+        logLine(`hover ee z ${num(ev.ee?.[2], 3)}`);
+        break;
+      case "wrist_seed":
+        // A Gemini look on the wrist image (initial seed or re-seed on loss).
+        wristPx = Array.isArray(ev.px) ? { u: ev.px[0], v: ev.px[1] } : null;
+        if (wristPx) {
+          logLine(`wrist seed px(${num(ev.px?.[0], 0)},${num(ev.px?.[1], 0)}) @z ${num(ev.z, 2)}`);
+        } else {
+          logLine("wrist seed — not seen", true);
+        }
+        break;
+      case "wrist_servo":
+        // Per-cycle optical-flow tracking during the servo descent: glide the
+        // marker, colour the box, extend the side-view EE trail. No log line
+        // (a full descent is ~10-20 cycles and would swamp the feed).
+        if (Array.isArray(ev.px)) wristPx = { u: ev.px[0], v: ev.px[1] };
+        wristBox.classList.toggle("inside", ev.inside === true);
+        grasp = { tx: ev.tx, ty: ev.ty };
+        if (Array.isArray(ev.ee)) armTrail.push({ x: ev.ee[0], z: ev.ee[2], kind: "descend", ok: true });
+        break;
+      case "wrist_done":
+        // Refined grasp target — re-pin the head-view reticle to match.
+        grasp = { tx: ev.tx, ty: ev.ty };
+        grabPx = Array.isArray(ev.grab_px) ? { u: ev.grab_px[0], v: ev.grab_px[1] } : grabPx;
+        logLine(
+          `wrist done @z ${num(ev.z, 2)} — ${ev.reason ?? "?"} (tx ${num(ev.tx, 3)} ty ${num(ev.ty, 3)})`,
+          ev.reason !== "reached stop z",
+        );
+        break;
+      case "descend":
+        if (Array.isArray(ev.ee)) armTrail.push({ x: ev.ee[0], z: ev.ee[2], kind: "descend", ok: ev.ok !== false });
+        logLine(`des → ${num(ev.z, 3)} ee z ${num(ev.ee?.[2], 3)}${ev.ok === false ? " contact" : ""}`, ev.ok === false);
+        break;
+      case "grasp_abort":
+        logLine(`grasp abort — ${ev.reason ?? "?"} (ee z ${num(ev.ee_z, 3)})`, true);
+        break;
+      case "close":
+        closeJ6 = { open: ev.j6_open, closed: ev.j6 };
+        logLine(`close j6 ${num(ev.j6_open, 3)} → ${num(ev.j6, 3)}`);
+        break;
+      case "twist":
+        logLine(`twist j4 ${num(ev.j4, 2)}`);
+        break;
+      case "lift":
+        if (Array.isArray(ev.ee)) armTrail.push({ x: ev.ee[0], z: ev.ee[2], kind: "lift" });
+        logLine(`lift ee z ${num(ev.ee?.[2], 3)} j6 ${num(ev.j6, 3)}${ev.ik_fallback ? " (ik fallback)" : ""}`);
+        break;
+      case "verify":
+        logLine(
+          `verify ${ev.held ? "HELD" : "not held"} — floor ${ev.floor_clear ? "clear" : "object"}, j6 ${num(ev.j6, 3)}`,
+          !ev.held,
+        );
+        break;
+      default:
+        logLine(String(ev.ev ?? "?"));
+    }
+    toggleBtn.classList.toggle("running", running);
+    syncHeader();
+    draw();
+    placeReticle();
+  }
+
+  const unsubDebug = rosClient.subscribe(PICK_DEBUG_TOPIC, (msg) => {
+    if (typeof msg?.data !== "string") return;
+    try {
+      onDebugEvent(JSON.parse(msg.data));
+    } catch {
+      // Not JSON — ignore.
+    }
+  });
+
+  // ---- open / close ---------------------------------------------------------
+
+  /** @param {boolean} open */
+  function setOpen(open) {
+    wrap.hidden = !open;
+    toggleBtn.classList.toggle("active", open);
+    toggleBtn.setAttribute("aria-pressed", String(open));
+    if (open) draw();
+  }
+
+  toggleBtn.addEventListener("click", () => setOpen(Boolean(wrap.hidden)));
+
+  /** @param {KeyboardEvent} e */
+  function onKeyDown(e) {
+    if (e.code !== TOGGLE_KEY || e.repeat || e.metaKey || e.ctrlKey || e.altKey) return;
+    const el = document.activeElement;
+    if (el instanceof HTMLElement && (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.isContentEditable)) {
+      return;
+    }
+    setOpen(Boolean(wrap.hidden));
+  }
+  window.addEventListener("keydown", onKeyDown);
+
+  syncHeader();
+
+  return {
+    destroy() {
+      if (publishTimer !== null) clearTimeout(publishTimer);
+      unsubDebug();
+      if (unsubSession) unsubSession();
+      window.removeEventListener("keydown", onKeyDown);
+      window.removeEventListener("resize", onResize);
+      reticle.remove();
+      seenMark.remove();
+      boxGoal.remove();
+      wristBox.remove();
+      wristMark.remove();
+      toggleBtn.remove();
+      wrap.remove();
+    },
+  };
+}
diff --git a/workspace/innate_skills/arm_rest_position.py b/workspace/innate_skills/arm_rest_position.py
new file mode 100644
index 000000000..55ffb0196
--- /dev/null
+++ b/workspace/innate_skills/arm_rest_position.py
@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Innate Inc
+"""
+Arm Rest Position Skill — move the arm to its resting pose.
+
+Callable from any skill's code as a plain function:
+
+    from innate.skills import arm_rest_position
+    arm_rest_position()            # blocks until the arm is resting
+
+(also runnable from the agent, the webapp skills menu, and
+`scripts/innate skill run local/arm_rest_position`).
+"""
+
+import time
+
+from brain_client.skills.types import (
+    Interface,
+    InterfaceType,
+    RobotState,
+    RobotStateType,
+    Skill,
+    SkillResult,
+)
+
+# joints 1-6 = base yaw, shoulder, elbow, wrist pitch, wrist roll, gripper.
+# The folded rest shape, but with the wrist pitch (j4) lifted to 0.55 so the
+# gripper clears the floor instead of pitching down into it: at the old j4~0.87+
+# the gripper jammed into the ground and tripped/broke a servo when driven here
+# under torque.
+# These are the values the arm actually REACHES and HOLDS (j1/j2 clamp to their
+# limits, so commanding "more folded" just settles here). j4=0.30 lifts the
+# wrist ~2 cm further than the first floor-clearing try (0.55, where the
+# fingertips still grazed the floor) — verified live: ee_link z ~0.042 m.
+REST_POSITION = [1.5708, -1.2195, 1.5723, 0.30, 0.0, 0.0031]
+
+
+class ArmRestPosition(Skill):
+    """Move the arm to the resting position."""
+
+    manipulation = Interface(InterfaceType.MANIPULATION)
+    joint_states = RobotState(RobotStateType.LAST_JOINT_STATES)
+
+    def __init__(self, logger):
+        super().__init__(logger)
+        self._cancelled = False
+
+    @property
+    def name(self):
+        return "arm_rest_position"
+
+    def guidelines(self):
+        return (
+            "Use this to move the arm to its resting position (folded against "
+            "the body, servos unloaded). Safe while holding an object: the "
+            "gripper keeps its current closure unless keep_gripper=False."
+        )
+
+    def execute(self, duration: int = 3, keep_gripper: bool = True):
+        """
+        Move the arm to the resting pose.
+
+        Args:
+            duration: Trajectory duration in seconds.
+            keep_gripper: Keep the gripper's current closure (default) so a
+                held object isn't released; False also restores the captured
+                rest gripper value.
+        """
+        self._cancelled = False
+
+        if self.manipulation is None:
+            return "Manipulation interface not available", SkillResult.FAILURE
+
+        target = list(REST_POSITION)
+        if keep_gripper:
+            js = self.joint_states
+            try:
+                target[5] = float(js["position"][5])
+            except (KeyError, IndexError, TypeError):
+                pass  # no reading — fall back to the captured gripper value
+
+        self.logger.info(
+            f"Moving arm to rest position {[round(j, 3) for j in target]} "
+            f"over {duration}s"
+        )
+        success = self.manipulation.move_to_joint_positions(
+            joint_positions=target, duration=duration, blocking=False
+        )
+        if not success:
+            return "Failed to send arm command", SkillResult.FAILURE
+
+        # Wait for motion to complete (with cancellation check)
+        start_time = time.time()
+        while time.time() - start_time < duration:
+            if self._cancelled:
+                return "Arm motion cancelled", SkillResult.CANCELLED
+            time.sleep(0.1)
+
+        return "Arm moved to rest position", SkillResult.SUCCESS
+
+    def cancel(self):
+        """Cancel the arm movement."""
+        self._cancelled = True
+        return "Arm motion cancelled"
diff --git a/workspace/innate_skills/gripper_close.py b/workspace/innate_skills/gripper_close.py
new file mode 100644
index 000000000..c20bf37eb
--- /dev/null
+++ b/workspace/innate_skills/gripper_close.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Innate Inc
+"""
+Gripper Close — a simple command to close the claw.
+
+Callable from any skill's code as a plain function:
+
+    from innate.skills import gripper_close
+    gripper_close()             # close the claw
+    gripper_close(strength=0.2) # close harder (firmer grip)
+
+(also from the agent, the webapp skills menu, and
+`scripts/innate skill run local/gripper_close`).
+
+Enables arm torque first so the claw still moves after an overload left the
+servo torque-disabled.
+"""
+
+from brain_client.skills.types import Interface, InterfaceType, Skill, SkillResult
+
+
+class GripperClose(Skill):
+    """Close the gripper (claw)."""
+
+    manipulation = Interface(InterfaceType.MANIPULATION)
+
+    def __init__(self, logger):
+        super().__init__(logger)
+        self._cancelled = False
+
+    @property
+    def name(self):
+        return "gripper_close"
+
+    def guidelines(self):
+        return (
+            "Close the gripper/claw. strength adds squeeze (radians past the "
+            "closed stop) for a firmer grip; default 0.0."
+        )
+
+    def execute(self, strength: float = 0.0, duration: float = 1.0):
+        """Close the claw. strength = extra radians of squeeze past closed."""
+        if self.manipulation is None:
+            return "Manipulation interface not available", SkillResult.FAILURE
+        self.manipulation.torque_on()
+        ok = self.manipulation.close_gripper(
+            strength=strength, duration=duration, blocking=True
+        )
+        if not ok:
+            return "Failed to close gripper", SkillResult.FAILURE
+        return "Gripper closed", SkillResult.SUCCESS
+
+    def cancel(self):
+        self._cancelled = True
+        return "Gripper motion cancelled"
diff --git a/workspace/innate_skills/gripper_open.py b/workspace/innate_skills/gripper_open.py
new file mode 100644
index 000000000..0aa00ddc5
--- /dev/null
+++ b/workspace/innate_skills/gripper_open.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Innate Inc
+"""
+Gripper Open — a simple command to open the claw.
+
+Callable from any skill's code as a plain function:
+
+    from innate.skills import gripper_open
+    gripper_open()      # fully open the claw
+
+(also from the agent, the webapp skills menu, and
+`scripts/innate skill run local/gripper_open`).
+
+Enables arm torque first. A hard close that overloads the servo leaves its
+torque disabled, after which a plain open silently does nothing — that's why
+opening from a resting closed claw failed. Enabling torque first makes it move.
+"""
+
+from brain_client.skills.types import Interface, InterfaceType, Skill, SkillResult
+
+
+class GripperOpen(Skill):
+    """Open the gripper (claw)."""
+
+    manipulation = Interface(InterfaceType.MANIPULATION)
+
+    def __init__(self, logger):
+        super().__init__(logger)
+        self._cancelled = False
+
+    @property
+    def name(self):
+        return "gripper_open"
+
+    def guidelines(self):
+        return "Open the gripper/claw. percent=100 (default) is fully open."
+
+    def execute(self, percent: float = 100.0, duration: float = 1.0):
+        """Open the claw. percent 0-100 (default fully open)."""
+        if self.manipulation is None:
+            return "Manipulation interface not available", SkillResult.FAILURE
+        self.manipulation.torque_on()  # a torque-disabled servo won't move
+        ok = self.manipulation.open_gripper(
+            percent=percent, duration=duration, blocking=True
+        )
+        if not ok:
+            return "Failed to open gripper", SkillResult.FAILURE
+        return "Gripper opened", SkillResult.SUCCESS
+
+    def cancel(self):
+        self._cancelled = True
+        return "Gripper motion cancelled"
diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
new file mode 100644
index 000000000..764c6c886
--- /dev/null
+++ b/workspace/innate_skills/pick_any_object.py
@@ -0,0 +1,1296 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Innate Inc
+"""
+Pick any object from the floor, given a text prompt.
+
+The key idea is to localize metrically (pixel -> floor plane -> base_link x,y)
+instead of pixel-servoing forever. Once you have a metric fix you can just
+drive there and grasp. No depth camera, no hand-eye calibration — just URDF
+geometry and a pinhole model.
+
+Validated live on mars-the-44th (2026-07-10): found a sock, grasped it,
+proved it kinetically.
+
+Pipeline:
+
+  1. FIND      tilt the head down, ask Gemini for a pixel
+  2. LOCALIZE  back-project that pixel onto z=0 (the floor)
+  3. POSITION  track the detection point with optical flow and servo the base
+               until it sits in a "pick box" on the image (~20 Hz, no Gemini
+               in the loop). Re-detect only to confirm / recover from drift.
+  4. GRASP     IK hover above the estimate, wrist-align (below), descend,
+               close, twist, lift
+     WRIST ALIGN go to the operator's posed search position (up high, elbow
+               ~90°, wrist camera on the object), get a tight box from
+               Gemini, learn a color model of the object vs the floor, then
+               segment every wrist frame (~5 Hz) and CamShift-follow the
+               blob while stepping the arm down with IK — correcting x/y to
+               keep it in the wrist box, descending only while it's inside
+               — until wrist_stop_z, where the blind ladder finishes the
+               approach and the gripper closes.
+  5. VERIFY    back up 15 cm, check the floor is empty (held objects travel
+               with the robot). Also check the gripper joint isn't open.
+
+That's it. Everything else is plumbing and knobs.
+"""
+
+import base64
+import json
+import math
+import os
+import re
+import time
+from pathlib import Path
+
+import cv2
+import numpy as np
+from google import genai
+from google.genai import types as genai_types
+from std_msgs.msg import String
+
+from brain_client.skills.types import (
+    Interface,
+    InterfaceType,
+    RobotState,
+    RobotStateType,
+    Skill,
+    SkillResult,
+)
+from innate.skills import SkillFailed, arm_rest_position, gripper_close, gripper_open
+
+# -----------------------------------------------------------------------------
+# geometry from mars.urdf
+# base_footprint == base_link, so z=0 is the floor. Camera sits in the head,
+# head pitches about y. That's enough to raycast a pixel onto the floor.
+# -----------------------------------------------------------------------------
+HEAD_ORIGIN = (-0.040751, -0.0002, 0.25882)  # base_link -> head joint
+CAM_IN_HEAD = (0.04327, 0.0297, -0.000275)   # head -> left camera optical
+IMG_W, IMG_H = 640, 480
+HFOV_DEG = 70.0
+
+# hardware-tuned constants (not exposed to the live panel)
+GRIPPER_EMPTY_J6 = -0.085  # joint6 when fingers are open / empty
+VERIFY_BACKUP_M = 0.15     # how far to reverse before asking "is it gone?"
+
+# Carry pose after a successful pick — joints 1-5 posed by the operator. j6 is
+# NOT taken from here (the posed value was near-open); the gripper stays firmly
+# CLOSED on the sock — see _rest_arm.
+CARRY_ARM = [0.0537, -0.5031, 0.4157, 0.9434, -0.0077]
+
+# -----------------------------------------------------------------------------
+# live-tunable knobs. Defaults are the hardware-tuned values. The webapp
+# pick-tuning panel publishes JSON overrides on TUNING_TOPIC; we apply them
+# at the next read, mid-run. Keep keys in sync with pickTunePanel.js.
+# -----------------------------------------------------------------------------
+TUNABLE = {
+    # FIND / LOCALIZE
+    "tilt_deg": -20.0,          # head pitch while working (negative = down)
+    "settle_s": 1.2,            # wait after stopping before grabbing a frame
+    # POSITION — the "pick box" on the image
+    "sweet_x": 0.30,            # want the object this far ahead in base_link
+    "box_y": 0.0,               # lateral offset of the box centre (drag in UI)
+    "box_half_px": 40.0,        # half-width of the goal square, image pixels
+    "accept_frac": 0.5,         # stop only when the point is within this
+                                #   fraction of box_half_px of the centre — a
+                                #   concentric inner box. Accepting anywhere in
+                                #   the full box let the arm grasp at an edge,
+                                #   short of the object; center it instead.
+    "box_steps": 6.0,           # max follow / re-detect attempts
+    "bearing_go_deg": 4.0,      # stepwise fallback: fix heading above this
+    "follow_gain_ang": 0.3,     # px-servo: rad/s per 100 px of horizontal error
+    "follow_gain_lin": 0.06,    # px-servo: m/s per 100 px of vertical error
+    # closed-loop base (odometry)
+    "rot_tol_deg": 2.5,
+    "rot_kp": 1.2,
+    "rot_wz_max": 0.5,
+    "rot_wz_min": 0.15,         # below this the motors just don't move
+    "drive_tol_m": 0.015,
+    "drive_kp": 0.3,
+    "drive_v_max": 0.10,
+    "drive_v_min": 0.04,
+    # WRIST ALIGN — visual-servo descent over the wrist camera, starting from
+    # the operator's posed search position (WRIST_SEARCH_ARM). Gemini seeds
+    # the object pixel, optical flow tracks it on wrist frames while the arm
+    # steps down; x/y corrected each cycle, z drops only while inside the box.
+    "wrist_steps": 2.0,         # Gemini looks allowed (seed + re-seeds after
+                                #   a tracking loss); 0 disables the stage
+    "wrist_stop_z": 0.04,       # hand off to the blind descend ladder here
+    "wrist_z_step": 0.01,       # descend per verified step, meters
+    "wrist_move_s": 0.5,        # per-cycle arm move duration
+    "wrist_pitch": 0.82,        # ee pitch during the servo — the operator's
+                                #   posed search pose (WRIST_SEARCH_ARM) has
+                                #   the wrist camera looking down at exactly
+                                #   this pitch. The ladder rotates to
+                                #   arm_pitch for the grasp itself; any offset
+                                #   that rotation causes is absorbed by where
+                                #   the wrist box sits on the image.
+    "wrist_box_u": 320.0,       # goal pixel on the wrist image (drag in UI)
+    "wrist_box_v": 240.0,
+    "wrist_half_px": 60.0,      # accept half-width, pixels
+    "wrist_kx": -0.04,          # m forward per 100 px of vertical (v) error
+    "wrist_ky": -0.04,          # m left per 100 px of horizontal (u) error.
+                                #   Both SIGNED: the wrist cam is mirrored and
+                                #   the mount is untested — flip one live if a
+                                #   nudge diverges instead of centering. Gains
+                                #   are "at z=0.15" and auto-scale with height.
+    "wrist_step_max": 0.04,     # single-nudge clamp, meters
+    "wrist_settle_s": 0.8,      # settle before a Gemini seed frame
+    # GRASP
+    "grasp_x_off": 0.03,        # fingertips land ~3 cm forward of ee_link
+    "hover_z": 0.15,
+    "hover_s": 2.0,
+    "descend_z1": 0.10,         # descent ladder, top -> bottom
+    "descend_z2": 0.06,
+    "descend_z3": 0.03,
+    "floor_z": 0.01,            # deep second attempt goes all the way to 0
+    "descend_s": 1.2,
+    "descend_abort_z": 0.12,    # if EE is still above this, arm is limp — abort
+    "arm_pitch": 1.30,
+    "close_strength": 0.60,     # firm grip held through the lift. NOT higher:
+                                #   0.85 squeezes j6 at max current against finger/
+                                #   object contact and OVERCURRENT-TRIPS the gripper
+                                #   servo, which then won't open on the next grasp.
+    "close_s": 1.5,
+    "close_settle_s": 0.8,
+    "twist_rad": 0.6,           # wrist roll while closed winds fabric on
+    "lift_rad": 0.6,            # shoulder-up joint delta
+}
+
+DEBUG_TOPIC = "/pick_any_object/debug"
+TUNING_TOPIC = "/pick_any_object/tuning"
+
+FOLLOW_TIMEOUT_S = 20.0  # one optical-flow follow attempt
+WRIST_ALIGN_TIMEOUT_S = 60.0  # whole wrist-servo descent (deliberately slow:
+                              # every step waits for two verified flow matches)
+WRIST_MAX_JUMP_PX = 80.0      # a tracked blob moving more than this between
+                              # consecutive frames isn't our object — drop it
+WRIST_SEG_MIN_SCORE = 25.0    # mean back-projection likelihood (0-255) inside
+                              # the tracked window below which the object is
+                              # considered lost (segmentation collapsed)
+# Wrist camera sits ~7 cm above ee_link (URDF: on link5, up the wrist). Only
+# used to scale the px->m gains with camera height as the arm descends.
+WRIST_CAM_ABOVE_EE = 0.07
+# The wrist-servo search position, posed by the operator (2026-07-14): elbow
+# high near 90°, wrist camera looking down at the floor ahead. FK puts ee_link
+# at (0.296, -0.022, 0.198), ee pitch 0.8221. This IS the hover — the servo
+# descends from wherever this pose is. It also seeds the KDL-LMA IK (which
+# converges to the branch nearest the current joints), keeping every servo
+# move on this elbow-up branch. j1 is re-aimed at the target, j4 is derived
+# (j2+j3+j4 = wrist_pitch, = the posed j4 at the default pitch), and j6 keeps
+# the gripper, so only j2/j3/j5 are used verbatim.
+WRIST_SEARCH_ARM = [0.1473, -0.0706, -0.4449, 1.3376, -0.0491]
+# Lucas-Kanade defaults — a small patch beats a single point
+_LK_PARAMS = dict(
+    winSize=(21, 21), maxLevel=3,
+    criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 20, 0.03),
+)
+
+
+def _load_gemini_key() -> str:
+    # env first, then the repo .env — same pattern as the rest of the stack
+    key = os.environ.get("GEMINI_API_KEY", "")
+    if key:
+        return key
+    env_path = Path.home() / "innate-os" / ".env"
+    if env_path.exists():
+        m = re.search(r"^GEMINI_API_KEY=(.+)$", env_path.read_text(), re.M)
+        if m:
+            return m.group(1).strip().strip('"')
+    return ""
+
+
+# -----------------------------------------------------------------------------
+# floor localization: pixel + head tilt -> (x, y) in base_link
+# Pure math. No ROS, no depth. If the ray doesn't hit the floor (or hits
+# behind the robot), return None.
+# -----------------------------------------------------------------------------
+def _head_rot(tilt_rad):
+    # pitch about +y: nose down is negative tilt in our convention
+    c, s = math.cos(tilt_rad), math.sin(tilt_rad)
+    return ((c, 0.0, -s), (0.0, 1.0, 0.0), (s, 0.0, c))
+
+
+def _rot(R, v):
+    return tuple(sum(R[i][k] * v[k] for k in range(3)) for i in range(3))
+
+
+def pixel_to_floor(u, v, head_tilt_deg):
+    """Cast a ray from the camera through pixel (u,v) and intersect z=0."""
+    fx = IMG_W / (2.0 * math.tan(math.radians(HFOV_DEG) / 2.0))
+    cx, cy = IMG_W / 2.0, IMG_H / 2.0
+    R = _head_rot(math.radians(head_tilt_deg))
+    cam = tuple(HEAD_ORIGIN[i] + _rot(R, CAM_IN_HEAD)[i] for i in range(3))
+    # camera frame in base_link: forward, right, down (optical convention)
+    fwd, right, down = _rot(R, (1, 0, 0)), _rot(R, (0, -1, 0)), _rot(R, (0, 0, -1))
+    xo, yo = (u - cx) / fx, (v - cy) / fx
+    d = tuple(fwd[i] + xo * right[i] + yo * down[i] for i in range(3))
+    if d[2] >= -1e-6:  # ray not pointing at the floor
+        return None
+    t = -cam[2] / d[2]
+    x, y = cam[0] + t * d[0], cam[1] + t * d[1]
+    return (x, y) if x > 0 else None  # behind the robot = nonsense
+
+
+def floor_to_pixel(x, y, head_tilt_deg):
+    """Inverse: floor point (x,y,0) -> image pixel. Used to draw the pick box
+    and the grasp target back onto the live head-camera frame."""
+    fx = IMG_W / (2.0 * math.tan(math.radians(HFOV_DEG) / 2.0))
+    cx, cy = IMG_W / 2.0, IMG_H / 2.0
+    R = _head_rot(math.radians(head_tilt_deg))
+    cam = tuple(HEAD_ORIGIN[i] + _rot(R, CAM_IN_HEAD)[i] for i in range(3))
+    fwd, right, down = _rot(R, (1, 0, 0)), _rot(R, (0, -1, 0)), _rot(R, (0, 0, -1))
+    D = (x - cam[0], y - cam[1], -cam[2])
+    a = sum(D[i] * fwd[i] for i in range(3))
+    if a <= 1e-6:  # on or behind the image plane
+        return None
+    b = sum(D[i] * right[i] for i in range(3))
+    c = sum(D[i] * down[i] for i in range(3))
+    return (cx + (b / a) * fx, cy + (c / a) * fx)
+
+
+def _r(v, nd=4):
+    """round that passes None through (absent sensor readings)."""
+    return round(v, nd) if isinstance(v, (int, float)) else None
+
+
+# -----------------------------------------------------------------------------
+# the skill
+# -----------------------------------------------------------------------------
+class PickAnyObject(Skill):
+    """Pick up any object on the floor, specified by a natural-language prompt."""
+
+    manipulation = Interface(InterfaceType.MANIPULATION)
+    mobility = Interface(InterfaceType.MOBILITY)
+    head = Interface(InterfaceType.HEAD)
+    main_image = RobotState(RobotStateType.LAST_MAIN_CAMERA_IMAGE_B64)
+    wrist_image = RobotState(RobotStateType.LAST_WRIST_CAMERA_IMAGE_B64)
+    joint_states = RobotState(RobotStateType.LAST_JOINT_STATES)
+    odom = RobotState(RobotStateType.LAST_ODOM)
+
+    def __init__(self, logger):
+        super().__init__(logger)
+        self._cancelled = False
+        key = _load_gemini_key()
+        self._gemini = genai.Client(api_key=key) if key else None
+        self._p = dict(TUNABLE)  # live copy; panel mutates this
+        self._dbg_pub = None
+        self._tuning_sub = None
+
+    @property
+    def name(self):
+        return "pick_any_object"
+
+    def guidelines(self):
+        # called on every skill-server load/reload — set up topics early so the
+        # webapp panel can subscribe before the first execute()
+        self._ensure_debug_io()
+        return (
+            "Pick up an object lying on the floor, described in natural language "
+            "(e.g. prompt='the white sock', 'a red cup'). The robot localizes the "
+            "object metrically with the head camera, drives above it, grasps, and "
+            "verifies the grasp by backing up and checking the floor. The arm is "
+            "returned to rest either way."
+        )
+
+    # -------------------------------------------------------------------------
+    # debug telemetry + live tuning (webapp pick-tuning panel)
+    # -------------------------------------------------------------------------
+    def _ensure_debug_io(self):
+        # node isn't available in __init__; create pubs/subs once we have it
+        if self._dbg_pub is not None or self.node is None:
+            return
+        self._dbg_pub = self.node.create_publisher(String, DEBUG_TOPIC, 10)
+        self._tuning_sub = self.node.create_subscription(
+            String, TUNING_TOPIC, self._on_tuning, 10
+        )
+
+    def _on_tuning(self, msg):
+        try:
+            incoming = json.loads(msg.data)
+        except json.JSONDecodeError:
+            return
+        if not isinstance(incoming, dict):
+            return
+        # only known float knobs; ignore everything else
+        applied = {
+            k: float(v)
+            for k, v in incoming.items()
+            if k in self._p and isinstance(v, (int, float))
+        }
+        if applied:
+            self._p.update(applied)
+            self.logger.info(f"[PickAnyObject] tuning applied: {applied}")
+        # ack with the full live set so the panel can confirm sync
+        self._dbg("params", params=dict(self._p))
+
+    def _dbg(self, ev, **fields):
+        if self._dbg_pub is None:
+            return
+        fields.update(t=round(time.time(), 3), ev=ev)
+        self._dbg_pub.publish(String(data=json.dumps(fields)))
+
+    # -------------------------------------------------------------------------
+    # vision: Gemini finds a pixel, geometry turns it into a floor point
+    # -------------------------------------------------------------------------
+    def _gemini_call(self, image_b64, question, retries=3):
+        for attempt in range(retries):
+            try:
+                resp = self._gemini.models.generate_content(
+                    model="gemini-3.5-flash",
+                    contents=[
+                        genai_types.Part.from_bytes(
+                            data=base64.b64decode(image_b64), mime_type="image/jpeg"
+                        ),
+                        question,
+                    ],
+                    config=genai_types.GenerateContentConfig(
+                        temperature=0.0,
+                        thinking_config=genai_types.ThinkingConfig(
+                            thinking_level=genai_types.ThinkingLevel.LOW
+                        ),
+                    ),
+                )
+                return resp.text or ""
+            except Exception as e:  # noqa: BLE001
+                self.logger.warning(
+                    f"[PickAnyObject] Gemini failed (try {attempt + 1}/{retries}): {e}"
+                )
+                if attempt < retries - 1:
+                    time.sleep(2.0 * (attempt + 1))
+        return None
+
+    def _detect_px(self, prompt):
+        """One fresh head frame -> best grasp pixel for `prompt`, or None."""
+        self._stop_base()
+        time.sleep(self._p["settle_s"])  # blur kills detection
+        img = self.main_image
+        if not img:
+            return None
+        # ask for the thickest / bunched-up part — that's where two fingers
+        # actually get purchase. Flat middle of a sock is a bad pinch.
+        text = self._gemini_call(
+            img,
+            f"Find '{prompt}' lying on the floor in this image. Match precisely — "
+            "not paper/packaging when asked for clothing, and NOT anything held "
+            "by the robot arm. Return ONLY a JSON list of matches, each "
+            '{"box_2d":[ymin,xmin,ymax,xmax], "grasp_point":[y,x]} normalized '
+            "0-1000, best first. grasp_point is the THICKEST / most bunched-up / "
+            "highest part of the object — the best spot for a two-finger gripper "
+            "to pinch, NOT the flat middle. Empty list if not present.",
+        )
+        return self._parse_det_px(text)
+
+    @staticmethod
+    def _parse_dets(text):
+        """Gemini detection reply -> list of detection dicts (may be empty)."""
+        if not text:
+            return []
+        text = re.sub(r"```(?:json)?", "", text)
+        m = re.search(r"\[.*\]", text, re.S)
+        if not m:
+            return []
+        try:
+            dets = json.loads(m.group(0))
+        except json.JSONDecodeError:
+            return []
+        return [d for d in dets if isinstance(d, dict)]
+
+    @classmethod
+    def _parse_det_px(cls, text):
+        """Gemini detection reply -> best (u, v) pixel, or None."""
+        for det in cls._parse_dets(text):
+            gp = det.get("grasp_point")
+            if gp and len(gp) >= 2:
+                # Gemini coords are [y,x] in 0..1000 — flip to (u,v) pixels
+                return (float(gp[1]) / 1000.0 * IMG_W, float(gp[0]) / 1000.0 * IMG_H)
+            b = det.get("box_2d")
+            if b and len(b) >= 4:
+                y0, x0, y1, x1 = [float(v) for v in b[:4]]
+                y0, y1 = sorted((y0, y1))
+                x0, x1 = sorted((x0, x1))
+                return ((x0 + x1) / 2 / 1000.0 * IMG_W, (y0 + y1) / 2 / 1000.0 * IMG_H)
+        return None
+
+    @classmethod
+    def _parse_det_box(cls, text):
+        """Gemini detection reply -> best pixel box (x, y, w, h), or None."""
+        for det in cls._parse_dets(text):
+            b = det.get("box_2d")
+            if b and len(b) >= 4:
+                y0, x0, y1, x1 = [float(v) for v in b[:4]]
+                y0, y1 = sorted((y0, y1))
+                x0, x1 = sorted((x0, x1))
+                x = int(x0 / 1000.0 * IMG_W)
+                y = int(y0 / 1000.0 * IMG_H)
+                w = int((x1 - x0) / 1000.0 * IMG_W)
+                h = int((y1 - y0) / 1000.0 * IMG_H)
+                if w >= 8 and h >= 8:  # a sliver can't seed a color model
+                    return (x, y, w, h)
+        return None
+
+    def _localize(self, prompt):
+        """(x, y) of the object in base_link, or None."""
+        return self._localize_px(prompt)[0]
+
+    def _localize_px(self, prompt):
+        """Detect + back-project. Returns ((x,y)|None, pixel|None)."""
+        px = self._detect_px(prompt)
+        if px is None:
+            self._dbg("localize", px=None, xy=None)
+            return None, None
+        xy = pixel_to_floor(px[0], px[1], self._p["tilt_deg"])
+        if xy:
+            self.logger.info(
+                f"[PickAnyObject] px=({px[0]:.0f},{px[1]:.0f}) -> "
+                f"base_link ({xy[0]:.3f},{xy[1]:.3f})"
+            )
+        self._dbg(
+            "localize",
+            px=[round(px[0], 1), round(px[1], 1)],
+            xy=[round(xy[0], 4), round(xy[1], 4)] if xy else None,
+            tilt_deg=self._p["tilt_deg"],
+        )
+        return xy, px
+
+    # -------------------------------------------------------------------------
+    # base control, closed-loop on odometry
+    # when odom is missing we fall back to timed open-loop — never a silent no-op
+    # -------------------------------------------------------------------------
+    def _stop_base(self):
+        self.mobility.send_cmd_vel(0.0, 0.0, 0.1)
+
+    def _odom_xyt(self):
+        """(x, y, theta). Accepts both the nested dict and the flat dataclass."""
+        od = self.odom
+        if od is None:
+            return None
+        try:
+            if isinstance(od, dict):
+                p = od["pose"]["pose"]["position"]
+                return (float(p["x"]), float(p["y"]),
+                        math.radians(float(od["theta_degrees"])))
+            return (float(od.x), float(od.y), float(od.theta))
+        except (KeyError, AttributeError, TypeError):
+            return None
+
+    def _rotate_by(self, angle, tol=None, timeout=12.0):
+        self._dbg("rotate", angle_deg=round(math.degrees(angle), 1))
+        od = self._odom_xyt()
+        if od is None:
+            # poor man's rotate: open-loop timed yaw
+            self.mobility.send_cmd_vel(0.0, math.copysign(0.35, angle),
+                                       abs(angle) / 0.35)
+            time.sleep(abs(angle) / 0.35 + 0.4)
+            return
+        target = od[2] + angle
+        t0 = time.time()
+        err = angle
+        while time.time() - t0 < timeout and not self._cancelled:
+            od = self._odom_xyt()
+            if od is None:
+                break
+            # wrap to [-pi, pi]
+            err = math.atan2(math.sin(target - od[2]), math.cos(target - od[2]))
+            if abs(err) < (tol if tol is not None
+                           else math.radians(self._p["rot_tol_deg"])):
+                break
+            wz_max = self._p["rot_wz_max"]
+            wz = max(-wz_max, min(wz_max, self._p["rot_kp"] * err))
+            if abs(wz) < self._p["rot_wz_min"]:
+                wz = math.copysign(self._p["rot_wz_min"], wz)
+            self.mobility.send_cmd_vel(0.0, wz, 0.15)
+            time.sleep(0.08)
+        self._stop_base()
+        self._dbg("rotate_done", err_deg=round(math.degrees(err), 2),
+                  s=round(time.time() - t0, 2))
+
+    def _drive(self, dist, tol=None, timeout=15.0):
+        tol = tol if tol is not None else self._p["drive_tol_m"]
+        if abs(dist) < tol:
+            return
+        self._dbg("drive", dist_m=round(dist, 3))
+        od = self._odom_xyt()
+        if od is None:
+            self.logger.warning("[PickAnyObject] no odom — open-loop drive")
+            self.mobility.send_cmd_vel(math.copysign(0.08, dist), 0.0,
+                                       abs(dist) / 0.08)
+            time.sleep(abs(dist) / 0.08 + 0.4)
+            return
+        x0, y0 = od[0], od[1]
+        t0 = time.time()
+        err = abs(dist)
+        while time.time() - t0 < timeout and not self._cancelled:
+            od = self._odom_xyt()
+            if od is None:
+                break
+            gone = math.hypot(od[0] - x0, od[1] - y0)
+            err = abs(dist) - gone
+            if err < tol:
+                break
+            v = math.copysign(
+                max(self._p["drive_v_min"],
+                    min(self._p["drive_v_max"], self._p["drive_kp"] * err)),
+                dist,
+            )
+            self.mobility.send_cmd_vel(v, 0.0, 0.15)
+            time.sleep(0.08)
+        self._stop_base()
+        self._dbg("drive_done", err_m=round(err, 4), s=round(time.time() - t0, 2))
+
+    # -------------------------------------------------------------------------
+    # arm. Servos can brown out mid-move — check FK, reboot once, then abort
+    # loudly rather than continuing limp into the floor.
+    # -------------------------------------------------------------------------
+    class ArmUnhealthy(RuntimeError):
+        pass
+
+    def _ee_xyz(self):
+        pose = self.manipulation.get_current_end_effector_pose()
+        try:
+            p = pose["position"]
+            return (float(p["x"]), float(p["y"]), float(p["z"]))
+        except (KeyError, TypeError):
+            return None
+
+    def _gripper_j6(self):
+        js = self.joint_states
+        try:
+            return js["position"][5] if js else None
+        except (KeyError, IndexError, TypeError):
+            return None
+
+    def _recover_arm(self):
+        self.logger.warning("[PickAnyObject] recovering arm (reboot + torque on)")
+        self.manipulation.reboot_servos()
+        time.sleep(2.0)
+        self.manipulation.torque_on()
+        time.sleep(0.5)
+
+    def _move_arm(self, x, y, z, pitch, duration=1.5, tol=0.05):
+        """Cartesian move with a health check. Recover + retry once, then raise."""
+        for attempt in (1, 2):
+            ok = self.manipulation.move_to_cartesian_pose(
+                x=x, y=y, z=z, roll=0.0, pitch=pitch, yaw=0.0,
+                duration=duration, blocking=True,
+            )
+            cur = self._ee_xyz()
+            err = math.dist(cur, (x, y, z)) if cur is not None else None
+            if ok and err is not None and err <= tol:
+                return True
+            self.logger.warning(
+                f"[PickAnyObject] arm not tracking (ok={ok} err={err}) — "
+                f"{'recovering' if attempt == 1 else 'giving up'}"
+            )
+            if attempt == 1:
+                self._recover_arm()
+        raise self.ArmUnhealthy(f"arm failed to reach ({x:.2f},{y:.2f},{z:.2f})")
+
+    def _rest_arm(self, keep_grip):
+        """Fold to home. If carrying: go to the operator's CARRY_ARM pose with
+        the gripper held firmly CLOSED (j6 = -close_strength). Command the full
+        close, not the achieved stalled-on-object value, so the squeeze holds
+        while carrying — otherwise the grip relaxes and the sock slips."""
+        if keep_grip:
+            target = CARRY_ARM + [-self._p["close_strength"]]
+        else:
+            target = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+        for _ in range(2):
+            self.manipulation.move_to_joint_positions(
+                joint_positions=target, duration=3, blocking=True,
+            )
+            time.sleep(0.3)
+
+    # -------------------------------------------------------------------------
+    # stages
+    # -------------------------------------------------------------------------
+    def _search(self, prompt):
+        """Look straight, then right 30°, then left 60°. First hit wins."""
+        # +yaw = left (CCW), -yaw = right (CW)
+        for i, turn in enumerate((0.0, -math.radians(30), math.radians(60))):
+            if self._cancelled:
+                return None
+            if turn:
+                if i == 1:
+                    self.say("Scanning around for it.")
+                self._rotate_by(turn)
+            xy = self._localize(prompt)
+            if xy is not None:
+                return xy
+        return None
+
+    def _sweet_box(self):
+        """Pick-box centre (from sweet_x, box_y), outer half-width in pixels,
+        and the inner accept half-width (accept_frac * outer). The base stops
+        only once the tracked point sits inside the INNER box — accepting it
+        anywhere in the outer box let the arm grasp at an edge, short of the
+        object. The webapp draws both squares from the same params."""
+        c = floor_to_pixel(self._p["sweet_x"], self._p["box_y"],
+                           self._p["tilt_deg"])
+        half = self._p["box_half_px"]
+        return c, half, half * self._p["accept_frac"]
+
+    # ---- detection-point following ------------------------------------------
+    # Gemini is slow (~1s). Optical flow is free. So: detect once, track the
+    # pixel at camera rate, and P-servo the base until it's in the pick box.
+    # -------------------------------------------------------------------------
+    def _gray_frame(self):
+        img = self.main_image
+        if not img:
+            return None
+        try:
+            arr = np.frombuffer(base64.b64decode(img), np.uint8)
+            return cv2.imdecode(arr, cv2.IMREAD_GRAYSCALE)
+        except Exception:  # noqa: BLE001 — a bad frame just skips a cycle
+            return None
+
+    @staticmethod
+    def _grid_pts(u, v, step=12, n=2):
+        """(2n+1)^2 feature points around (u,v). A patch tracks; a point doesn't."""
+        pts = [[u + dx * step, v + dy * step]
+               for dx in range(-n, n + 1) for dy in range(-n, n + 1)]
+        return np.array(pts, dtype=np.float32).reshape(-1, 1, 2)
+
+    def _track_point(self, prev_gray, gray, grid):
+        """LK one step. Median of survivors = object's new pixel. None if lost."""
+        nxt, status, _ = cv2.calcOpticalFlowPyrLK(
+            prev_gray, gray, grid, None, **_LK_PARAMS)
+        if nxt is None or status is None:
+            return None
+        good = nxt[status.flatten() == 1].reshape(-1, 2)
+        if len(good) < 3:
+            return None
+        return float(np.median(good[:, 0])), float(np.median(good[:, 1]))
+
+    def _follow_into_box(self, seed_px):
+        """High-rate follow loop. No Gemini. Returns one of:
+        ('in_box', (u,v)) | ('lost', None) | ('timeout', None) | ('noframe', None)
+        """
+        prev = self._gray_frame()
+        if prev is None:
+            return "noframe", None
+        u, v = seed_px
+        grid = self._grid_pts(u, v)
+        in_box, last_dbg = 0, 0.0
+        t0 = time.time()
+        while time.time() - t0 < FOLLOW_TIMEOUT_S and not self._cancelled:
+            gray = self._gray_frame()
+            if gray is None:
+                time.sleep(0.03)
+                continue
+            tracked = self._track_point(prev, gray, grid)
+            prev = gray
+            if tracked is None:
+                self._stop_base()
+                return "lost", None
+            u, v = tracked
+            grid = self._grid_pts(u, v)  # recenter the patch
+            if not (0 <= u < IMG_W and 0 <= v < IMG_H):
+                self._stop_base()
+                return "lost", None
+
+            (cu, cv), half, accept = self._sweet_box()  # re-read: box moves live
+            eu, ev = u - cu, v - cv
+            inside = abs(eu) <= accept and abs(ev) <= accept
+
+            now = time.time()
+            if now - last_dbg > 0.1:  # ~10 Hz marker for the webapp
+                self._dbg("servo", px=[round(u, 1), round(v, 1)],
+                          box=[round(cu, 1), round(cv, 1), half,
+                               round(accept, 1)], inside=inside)
+                last_dbg = now
+
+            if inside:
+                in_box += 1
+                self._stop_base()
+                if in_box >= 3:  # debounce a few frames
+                    return "in_box", (u, v)
+                time.sleep(0.03)
+                continue
+            in_box = 0
+
+            # per-axis pixel servo. object right of box -> turn CW (-wz);
+            # object low in the image (too close) -> back up (-vx).
+            # gains are "per 100 px" so the numbers stay human-sized.
+            # Deadband on the INNER accept box, not the outer one — otherwise the
+            # servo would stop driving at the outer edge and never reach accept.
+            if abs(eu) <= accept:
+                wz = 0.0
+            else:
+                wz = max(-self._p["rot_wz_max"],
+                         min(self._p["rot_wz_max"],
+                             -self._p["follow_gain_ang"] / 100.0 * eu))
+                if abs(wz) < self._p["rot_wz_min"]:
+                    wz = math.copysign(self._p["rot_wz_min"], wz)
+            if abs(ev) <= accept:
+                vx = 0.0
+            else:
+                vx = max(-self._p["drive_v_max"],
+                         min(self._p["drive_v_max"],
+                             -self._p["follow_gain_lin"] / 100.0 * ev))
+                if abs(vx) < self._p["drive_v_min"]:
+                    vx = math.copysign(self._p["drive_v_min"], vx)
+            self.mobility.send_cmd_vel(vx, wz, 0.15)
+            time.sleep(0.03)
+        self._stop_base()
+        return "timeout", None
+
+    def _position_above(self, prompt, xy):
+        """Get the object into the pick box via optical-flow following.
+        Gemini reseeds after a tracking loss and confirms at the end.
+        Falls back to discrete stepwise corrections if there's no camera."""
+        if self._gray_frame() is None:
+            return self._position_stepwise(prompt, xy)
+
+        # seed from the caller's fix — no extra Gemini call
+        seed = floor_to_pixel(xy[0], xy[1], self._p["tilt_deg"])
+        for attempt in range(int(self._p["box_steps"])):
+            if self._cancelled:
+                return None
+            if seed is None:
+                seed = self._detect_px(prompt)
+                if seed is None:
+                    self._dbg("position_done", xy=None, reason="lost")
+                    return None
+            result, _pt = self._follow_into_box(seed)
+            if result == "noframe":
+                return self._position_stepwise(prompt, xy)
+            if result == "lost":
+                seed = None  # re-detect and try again
+                continue
+            # in_box or timeout — confirm with one real detection
+            xy2, px2 = self._localize_px(prompt)
+            if px2 is None:
+                self._dbg("position_done", xy=None, reason="lost")
+                return None
+            (cu, cv), half, accept = self._sweet_box()
+            if (xy2 is not None
+                    and abs(px2[0] - cu) <= accept and abs(px2[1] - cv) <= accept):
+                self._dbg("position_done",
+                          xy=[round(xy2[0], 4), round(xy2[1], 4)], attempts=attempt)
+                return xy2
+            seed = px2 if xy2 is not None else None
+        self._dbg("position_done", xy=None, reason="never inside the box")
+        return None
+
+    def _position_stepwise(self, prompt, xy):
+        """Odometry-free / no-camera fallback: one discrete correction per look.
+        Turn OR drive (never both), re-detect, repeat."""
+        target_bearing = math.atan2(self._p["box_y"], self._p["sweet_x"])
+        target_range = math.hypot(self._p["sweet_x"], self._p["box_y"])
+        px = floor_to_pixel(xy[0], xy[1], self._p["tilt_deg"])
+        for step in range(int(self._p["box_steps"])):
+            if self._cancelled:
+                return None
+            if px is None:
+                xy, px = self._localize_px(prompt)
+                if px is None:
+                    self._dbg("position_done", xy=None, reason="lost")
+                    return None
+            (cu, cv), half, accept = self._sweet_box()
+            inside = (xy is not None
+                      and abs(px[0] - cu) <= accept and abs(px[1] - cv) <= accept)
+            self._dbg("position", step=step,
+                      px=[round(px[0], 1), round(px[1], 1)],
+                      xy=[round(xy[0], 4), round(xy[1], 4)] if xy else None,
+                      box=[round(cu, 1), round(cv, 1), half, round(accept, 1)],
+                      inside=inside)
+            if inside:
+                self._dbg("position_done",
+                          xy=[round(xy[0], 4), round(xy[1], 4)], steps=step)
+                return xy
+            if xy is None:  # pixel above the horizon — bogus, retry
+                px = None
+                continue
+            bearing_err = math.atan2(xy[1], xy[0]) - target_bearing
+            if abs(bearing_err) > math.radians(self._p["bearing_go_deg"]):
+                self._rotate_by(bearing_err)
+            else:
+                self._drive(math.hypot(xy[0], xy[1]) - target_range)
+            px = None  # we moved; re-detect before the next correction
+        self._dbg("position_done", xy=None, reason="never inside the box")
+        return None
+
+    # -------------------------------------------------------------------------
+    # GRASP — everything after the base is parked. Five moves, top to bottom:
+    #
+    #   1. search pose  joint move to the operator's posed arm: up high,
+    #                   elbow ~90°, wrist camera looking down at the floor
+    #   2. seed         ask Gemini for a tight box around the object in the
+    #                   wrist image; learn a color model of it vs the floor
+    #   3. servo down   segment every frame and CamShift-follow the blob;
+    #                   after two verified frames, center it or descend 1 cm
+    #   4. final push   below wrist_stop_z the camera is too close to help —
+    #                   rotate to the grasp pitch and press to the floor
+    #   5. close        squeeze, twist the fabric on, lift
+    #
+    # Steps 1-3 are skipped when wrist_steps is 0 (classic blind grasp).
+    # -------------------------------------------------------------------------
+    def _ee_dbg(self):
+        ee = self._ee_xyz()
+        return [round(v, 4) for v in ee] if ee else None
+
+    def _wrist_seed(self, prompt, z):
+        """Gemini, where is the object in the wrist image? Returns
+        (center, box) with box = (x, y, w, h) pixels, or (None, None).
+        Asks for a TIGHT bounding box — its center is the object's center,
+        and the box itself seeds the segmentation color model. Gemini places
+        boxes much more reliably than point guesses. Same 640x480 as head."""
+        time.sleep(self._p["wrist_settle_s"])  # let the arm stop swaying
+        img = self.wrist_image
+        text = self._gemini_call(
+            img,
+            f"Wrist camera on a robot gripper, looking down at the floor. "
+            f"Find '{prompt}' on the floor. Ignore the gripper fingers "
+            "themselves. Return ONLY a JSON list of matches, each "
+            '{"box_2d":[ymin,xmin,ymax,xmax]} normalized 0-1000, best first, '
+            "each box TIGHT around its object. Empty list if not visible.",
+        ) if img else None
+        box = self._parse_det_box(text)
+        px = (box[0] + box[2] / 2.0, box[1] + box[3] / 2.0) if box else None
+        self._dbg("wrist_seed", z=round(z, 3),
+                  px=[round(px[0], 1), round(px[1], 1)] if px else None)
+        return px, box
+
+    def _next_wrist_hsv(self, last_b64, timeout=1.5):
+        """Wait for a NEW wrist frame (the topic is ~5 Hz) and decode it to
+        HSV. Returns (hsv|None, b64) — b64 unchanged on timeout."""
+        t0 = time.time()
+        while time.time() - t0 < timeout and not self._cancelled:
+            img = self.wrist_image
+            if img and img != last_b64:
+                try:
+                    arr = np.frombuffer(base64.b64decode(img), np.uint8)
+                    bgr = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+                except Exception:  # noqa: BLE001 — a bad frame just skips
+                    bgr = None
+                if bgr is not None:
+                    return cv2.cvtColor(bgr, cv2.COLOR_BGR2HSV), img
+            time.sleep(0.04)
+        return None, last_b64
+
+    # Why segmentation instead of point tracking: during the descent the
+    # object grows ~2.5x in the image and the fabric deforms — optical-flow
+    # patches don't survive that and slide onto the carpet. A color model is
+    # scale- and deformation-proof: learn what the object looks like COMPARED
+    # to the floor right around it, then find that blob in every frame.
+    _SEG_BINS = [16, 8, 8]                    # H, S, V histogram bins
+    _SEG_RANGES = [0, 180, 0, 256, 0, 256]
+
+    def _seg_model(self, hsv, box):
+        """Likelihood-ratio color model from the seed box: histogram of the
+        object over histogram of a surrounding ring of floor. Bins where the
+        object beats the floor get high weight, shared colors get ~0 — so
+        back-projection lights up the object and stays dark on carpet.
+        Returns a uint8 [16,8,8] lookup table, or None if degenerate."""
+        x, y, w, h = box
+        obj = hsv[y:y + h, x:x + w]
+        rx0, ry0 = max(0, x - w // 2), max(0, y - h // 2)
+        ring = hsv[ry0:y + h + h // 2, rx0:x + w + w // 2]
+        h_obj = cv2.calcHist([obj], [0, 1, 2], None,
+                             self._SEG_BINS, self._SEG_RANGES)
+        h_ring = cv2.calcHist([ring], [0, 1, 2], None,
+                              self._SEG_BINS, self._SEG_RANGES)
+        ratio = h_obj / (np.maximum(h_ring - h_obj, 0.0) + 1.0)
+        if ratio.max() <= 0:
+            return None
+        return (255.0 * ratio / ratio.max()).astype(np.uint8)
+
+    def _seg_track(self, hsv, model, window):
+        """One segmentation step: back-project the color model (a direct
+        numpy bin lookup — cv2.calcBackProject silently returns zeros for
+        3-D histograms on this build) and let CamShift follow the blob from
+        the previous window, adapting it as the object grows during the
+        descent. Returns (center|None, window, score) — None when the
+        likelihood collapsed (lost / occluded) or the window degenerated."""
+        ih = (hsv[:, :, 0].astype(np.int32) * self._SEG_BINS[0]) // 180
+        i_s = (hsv[:, :, 1].astype(np.int32) * self._SEG_BINS[1]) // 256
+        iv = (hsv[:, :, 2].astype(np.int32) * self._SEG_BINS[2]) // 256
+        bp = model[np.clip(ih, 0, self._SEG_BINS[0] - 1), i_s, iv]
+        crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)
+        _rot, window = cv2.CamShift(bp, window, crit)
+        x, y, w, h = window
+        if w < 4 or h < 4 or w * h > 0.4 * IMG_W * IMG_H:
+            return None, window, 0.0
+        score = float(bp[y:y + h, x:x + w].mean())
+        if score < WRIST_SEG_MIN_SCORE:
+            return None, window, score
+        return (x + w / 2.0, y + h / 2.0), window, score
+
+    def _wrist_servo(self, prompt, tx, ty):
+        """Servo the arm down over the object, wrist camera as the eye.
+
+        Watch, then act. Watch: segment the object with a color model
+        (learned once from the Gemini seed box against the floor around it)
+        and follow the blob with CamShift until two consecutive frames
+        agree, arm still. Act: one move — center the blob (nudge x/y toward
+        the wrist box) if it's off, and only once it has been seen INSIDE
+        the box on two consecutive frames descend one wrist_z_step. Center
+        first, then step down; repeat until wrist_stop_z. A failed match
+        gets two frames of patience (blur, mid-move frames, occlusion); a
+        persistent loss spends one Gemini look to re-find the object and
+        relearn the model (wrist_steps looks total, seed included).
+
+        Returns (x, y, z) for the final push. If the object was never seen,
+        the caller's (tx, ty) come back unchanged so the push falls back on
+        the head-camera estimate."""
+        p = self._p
+        ee = self._ee_xyz()
+        z = ee[2] if ee else p["hover_z"]
+        looks = int(p["wrist_steps"]) - 1  # Gemini budget after the seed
+
+        px, box = self._wrist_seed(prompt, z)
+        if px is None:
+            self._dbg("wrist_done", tx=round(tx, 4), ty=round(ty, 4),
+                      z=round(z, 3), reason="not seen")
+            return tx, ty, z
+        x, y = (ee[0], ee[1]) if ee else (tx, ty)  # servo from the real pose
+
+        hsv, raw = self._next_wrist_hsv(None)
+        if hsv is None:
+            self._dbg("wrist_done", tx=round(tx, 4), ty=round(ty, 4),
+                      z=round(z, 3), reason="no wrist frames")
+            return tx, ty, z
+        model = self._seg_model(hsv, box)  # what the object looks like here
+        if model is None:
+            self._dbg("wrist_done", tx=round(tx, 4), ty=round(ty, 4),
+                      z=round(z, 3), reason="not seen")
+            return tx, ty, z
+        window = box
+        guess = px  # where we expect the blob in the NEXT frame
+        deadline = time.time() + WRIST_ALIGN_TIMEOUT_S
+        streak = 0    # verified matches since the arm last moved
+        centered = 0  # consecutive verified matches INSIDE the box
+        misses = 0    # consecutive failed matches (blur, mid-move, occlusion)
+        reason = "reached stop z"
+        while z > p["wrist_stop_z"] + 1e-6:
+            if self._cancelled:
+                reason = "cancelled"
+                break
+            if time.time() > deadline:
+                reason = "timeout"
+                break
+            hsv, raw = self._next_wrist_hsv(raw)
+            if hsv is None:
+                reason = "no wrist frames"
+                break
+
+            pt, window, _score = self._seg_track(hsv, model, window)
+            if pt is not None and math.hypot(
+                    pt[0] - guess[0], pt[1] - guess[1]) > WRIST_MAX_JUMP_PX:
+                pt = None  # a blob elsewhere isn't our object
+            if pt is None:
+                streak = 0
+                centered = 0
+                misses += 1
+                if misses < 3:
+                    window = box  # retry from the last trusted window
+                    continue  # transient (blurred / mid-move frame) — wait
+                if looks <= 0:  # persistent loss — worth one Gemini look?
+                    reason = "lost track"
+                    break
+                looks -= 1
+                pt, box = self._wrist_seed(prompt, z)
+                if pt is None:
+                    reason = "lost track"
+                    break
+                hsv, raw = self._next_wrist_hsv(raw)
+                if hsv is None:
+                    reason = "no wrist frames"
+                    break
+                model = self._seg_model(hsv, box)  # the view changed: relearn
+                if model is None:
+                    reason = "lost track"
+                    break
+                window = box
+            misses = 0
+            box = window  # last trusted window
+            px = pt
+            guess = px
+            streak += 1
+
+            err_u = px[0] - p["wrist_box_u"]
+            err_v = px[1] - p["wrist_box_v"]
+            inside = (abs(err_u) <= p["wrist_half_px"]
+                      and abs(err_v) <= p["wrist_half_px"])
+            centered = centered + 1 if inside else 0
+            self._dbg("wrist_servo", px=[round(px[0], 1), round(px[1], 1)],
+                      z=round(z, 3), inside=inside,
+                      tx=round(x, 4), ty=round(y, 4), ee=self._ee_dbg())
+            if streak < 2:
+                continue  # watch one more frame before trusting it
+            if inside and centered < 2:
+                continue  # just entered the box — confirm it stays centered
+
+            if centered >= 2:
+                z = max(p["wrist_stop_z"], z - p["wrist_z_step"])
+                # descending barely moves the (centered) pixel: guess stays px
+            else:
+                # px -> meters: gains are tuned at z=0.15 and shrink as the
+                # camera nears the floor, so scale by the current height.
+                s = (z + WRIST_CAM_ABOVE_EE) / (0.15 + WRIST_CAM_ABOVE_EE)
+                cap = p["wrist_step_max"]
+                x += max(-cap, min(cap, p["wrist_kx"] / 100.0 * err_v * s))
+                y += max(-cap, min(cap, p["wrist_ky"] / 100.0 * err_u * s))
+                x = max(0.22, min(0.40, x))  # the arm's reach box
+                y = max(-0.10, min(0.10, y))
+                # feed-forward: this correction should land the object at the
+                # box center — tell the tracker to look for it there
+                guess = (p["wrist_box_u"], p["wrist_box_v"])
+            self._move_arm(x, y, z, pitch=p["wrist_pitch"],
+                           duration=p["wrist_move_s"])
+            streak = 0
+            centered = 0  # the view shifted — re-confirm centering
+
+        grab = floor_to_pixel(x + p["grasp_x_off"], y, p["tilt_deg"])
+        self._dbg("wrist_done", tx=round(x, 4), ty=round(y, 4), z=round(z, 3),
+                  reason=reason,
+                  grab_px=[round(grab[0], 1), round(grab[1], 1)]
+                  if grab else None)
+        return x, y, z
+
+    def _goto_search_pose(self, bearing):
+        """Joint move to the operator's posed search arm (WRIST_SEARCH_ARM):
+        up high, elbow ~90°, wrist camera on the floor ahead. j1 aims along
+        `bearing`, j4 completes the camera pitch (j2+j3+j4 = wrist_pitch),
+        the gripper keeps its position. Starting here also pins the IK to
+        the elbow-up branch — LMA converges to the solution nearest the
+        current joints — so the whole descent keeps this arm shape."""
+        a = WRIST_SEARCH_ARM
+        j6 = self._gripper_j6()
+        pose = [bearing, a[1], a[2],
+                self._p["wrist_pitch"] - a[1] - a[2], a[4],
+                j6 if j6 is not None else 0.0]
+        self.manipulation.move_to_joint_positions(
+            joint_positions=pose, duration=self._p["hover_s"], blocking=True)
+        time.sleep(0.3)
+        self._dbg("hover", ee=self._ee_dbg())
+
+    def _open_gripper_checked(self):
+        """Open the claw, and make sure it actually opened. A prior hard
+        close can overcurrent-trip the gripper servo — a hardware fault
+        torque_on alone can't clear — after which open silently no-ops and
+        the hand stays shut straight into the grasp. Reboot clears the trip."""
+        gripper_open()
+        j6 = self._gripper_j6()
+        if j6 is not None and j6 < 0.10:
+            self.logger.warning(
+                f"[PickAnyObject] gripper did not open (j6={j6:.3f}); "
+                "rebooting servos to clear a trip, then retrying")
+            self._dbg("gripper_reboot", j6=_r(j6))
+            self._recover_arm()
+            gripper_open()
+
+    def _push_to_floor(self, x, y, z_from, deep):
+        """The last blind centimeters: rotate to the grasp pitch and descend
+        rung by rung to the floor. A rung that fails is floor contact /
+        overload — recover and grasp there. Raises if the arm never got low
+        enough for a grasp to make sense."""
+        p = self._p
+        rungs = [p["descend_z1"], p["descend_z2"], p["descend_z3"],
+                 0.0 if deep else p["floor_z"]]
+        for z in rungs:
+            if z >= z_from - 1e-6:  # the servo already descended past this
+                continue
+            if self._cancelled:
+                return
+            ok = self.manipulation.move_to_cartesian_pose(
+                x=x, y=y, z=z, roll=0.0, pitch=p["arm_pitch"], yaw=0.0,
+                duration=p["descend_s"], blocking=True,
+            )
+            self._dbg("descend", z=round(z, 3), ok=bool(ok), ee=self._ee_dbg())
+            if not ok:
+                self._recover_arm()
+                break
+        ee = self._ee_xyz()
+        if ee is not None and ee[2] > p["descend_abort_z"]:
+            self._dbg("grasp_abort", reason="arm would not descend",
+                      ee_z=round(ee[2], 4))
+            self._recover_arm()
+            raise self.ArmUnhealthy("arm would not descend")
+
+    def _close_twist_lift(self, x, y):
+        """Take it: squeeze, wind the fabric onto the fingers, lift. Twist
+        and lift happen in JOINT space — an IK lift would recompute joint5
+        and unwind the object off the fingers. j6 holds the FULL close
+        command throughout: re-commanding the achieved (stalled-on-object)
+        position instead relaxes the squeeze mid-lift and drops socks."""
+        p = self._p
+        j6_open = self._gripper_j6()
+        gripper_close(strength=p["close_strength"], duration=p["close_s"])
+        time.sleep(p["close_settle_s"])
+        self._dbg("close", j6_open=_r(j6_open), j6=_r(self._gripper_j6()),
+                  strength=p["close_strength"])
+
+        grip = -p["close_strength"]
+        try:
+            j = list(self.joint_states["position"][:6])
+            j[4] = max(-1.4, min(1.4, j[4] + p["twist_rad"]))
+            j[5] = grip
+            self.manipulation.move_to_joint_positions(
+                joint_positions=j, duration=1.0, blocking=True)
+            time.sleep(0.3)
+            self._dbg("twist", j4=round(j[4], 3))
+            j = list(self.joint_states["position"][:6])
+            j[1] = max(-1.4, j[1] - p["lift_rad"])  # shoulder up = lift
+            j[5] = grip
+            self.manipulation.move_to_joint_positions(
+                joint_positions=j, duration=2.0, blocking=True)
+            time.sleep(0.3)
+            self._dbg("lift", ee=self._ee_dbg(), j6=_r(self._gripper_j6()))
+        except (KeyError, IndexError, TypeError):  # no joint state — IK lift
+            self._move_arm(x, y, 0.22, pitch=p["arm_pitch"], duration=2.0,
+                           tol=0.10)
+            self._dbg("lift", ee=self._ee_dbg(), j6=_r(self._gripper_j6()),
+                      ik_fallback=True)
+
+    def _grasp_at(self, prompt, xy, deep=False):
+        """The grasp, start to finish — see the section comment above. `xy`
+        is the object on the floor in base_link. Every number reads self._p
+        so the panel can retune a grasp mid-run."""
+        p = self._p
+        # aim short: fingertips land ~grasp_x_off forward of ee_link
+        x = max(0.22, min(0.40, xy[0] - p["grasp_x_off"]))
+        y = max(-0.10, min(0.10, xy[1]))
+
+        # telemetry: where the object is vs where the fingers will land (they
+        # differ only when the object is outside the reach box — aim clamped)
+        grab_px = floor_to_pixel(x + p["grasp_x_off"], y, p["tilt_deg"])
+        obj_px = floor_to_pixel(xy[0], xy[1], p["tilt_deg"])
+        clamped = (abs((xy[0] - p["grasp_x_off"]) - x) > 1e-4
+                   or abs(xy[1] - y) > 1e-4)
+        self._dbg("grasp", xy=[round(xy[0], 4), round(xy[1], 4)],
+                  tx=round(x, 4), ty=round(y, 4), deep=deep,
+                  grab_px=[round(grab_px[0], 1), round(grab_px[1], 1)]
+                  if grab_px else None,
+                  obj_px=[round(obj_px[0], 1), round(obj_px[1], 1)]
+                  if obj_px else None,
+                  clamped=clamped)
+
+        self._open_gripper_checked()
+
+        if p["wrist_steps"] >= 1:
+            self._goto_search_pose(math.atan2(y, x))
+            x, y, z = self._wrist_servo(prompt, x, y)
+        else:  # classic blind grasp: IK hover above the estimate
+            z = p["hover_z"]
+            self._move_arm(x, y, z, pitch=p["arm_pitch"],
+                           duration=p["hover_s"])
+            self._dbg("hover", ee=self._ee_dbg())
+
+        self._push_to_floor(x, y, z, deep)
+        if self._cancelled:
+            return
+        self._close_twist_lift(x, y)
+
+    # -------------------------------------------------------------------------
+    # VERIFY — did we actually get it?
+    # -------------------------------------------------------------------------
+    def _grasp_verified(self, prompt):
+        """Back up so a held object travels with us, then ask the head camera
+        if the floor is clear. (Wrist cam is mirrored — don't trust it.)"""
+        self._drive(-VERIFY_BACKUP_M)
+        time.sleep(self._p["settle_s"])
+        j6 = self._gripper_j6()
+        img = self.main_image
+        floor_text = self._gemini_call(
+            img,
+            f"Robot head camera looking at the floor. Is '{prompt}' lying ON the "
+            "floor/carpet anywhere in view? Something hanging from the robot's "
+            "gripper does NOT count as on the floor. Answer only YES or NO.",
+        ) if img else None
+        floor_clear = bool(floor_text) and "NO" in floor_text.upper()
+        j6_ok = j6 is not None and j6 > GRIPPER_EMPTY_J6 + 0.02
+        held = floor_clear and j6_ok
+        self.logger.info(
+            f"[PickAnyObject] verify: floor={floor_text!r} j6={j6} "
+            f"-> {'HELD' if held else 'NOT HELD'}"
+        )
+        self._dbg("verify", floor_clear=floor_clear, j6=_r(j6), held=held)
+        return held
+
+    # -------------------------------------------------------------------------
+    # entry point
+    # -------------------------------------------------------------------------
+    def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
+        """
+        Pick up the object described by `prompt` from the floor.
+
+        Args:
+            prompt: Natural-language description, e.g. "the white sock".
+            max_base_steps: kept for interface compatibility; unused in v3.
+        """
+        self._cancelled = False
+        if self._gemini is None:
+            return "GEMINI_API_KEY not configured", SkillResult.FAILURE
+        if self.manipulation is None or self.mobility is None:
+            return "Manipulation/mobility interface not available", SkillResult.FAILURE
+
+        self._ensure_debug_io()
+        self._dbg("run_start", prompt=prompt, params=dict(self._p))
+
+        holding = False
+        try:
+            self.head.set_position(int(round(self._p["tilt_deg"])))
+            time.sleep(0.8)
+            # Fold the arm to rest BEFORE searching so it's low and swung to the
+            # side, out of the head camera's downward view (a lifted arm sits in
+            # frame and hides the floor). The rest pose now clears the floor, so
+            # this no longer jams the gripper into the ground. Best-effort — a
+            # failed fold shouldn't abort the pick (a cancel still propagates).
+            try:
+                arm_rest_position()
+            except SkillFailed as e:
+                self.logger.warning(f"[PickAnyObject] rest-before-search failed: {e}")
+
+            self.say(f"Looking for {prompt}.")
+            xy = self._search(prompt)
+            if xy is None:
+                return (
+                    f"Could not find '{prompt}' on the floor, even after scanning",
+                    SkillResult.FAILURE,
+                )
+
+            # one shot: position -> grasp -> verify. No retry re-approach —
+            # driving forward again after a miss surprised the operator.
+            if self._cancelled:
+                return "Cancelled", SkillResult.CANCELLED
+            xy = self._position_above(prompt, xy)
+            if xy is None:
+                return (
+                    f"Could not centre '{prompt}' in the pick box",
+                    SkillResult.FAILURE,
+                )
+            self.say("Picking it up.")
+            self._grasp_at(prompt, xy)
+            if self._grasp_verified(prompt):
+                holding = True
+                self.say("Got it.")
+                return (
+                    f"Picked up '{prompt}' (verified: floor clear after backing up)",
+                    SkillResult.SUCCESS,
+                )
+            self.say("I couldn't get a grip on it.")
+            return (
+                f"Grasp missed — '{prompt}' is still on the floor (verified after "
+                "backing up)",
+                SkillResult.FAILURE,
+            )
+        except self.ArmUnhealthy as e:
+            self.say("My arm isn't responding properly, stopping.")
+            return f"Arm servo failure: {e}", SkillResult.FAILURE
+        finally:
+            self._dbg("run_end")
+            self._stop_base()
+            try:
+                self._rest_arm(keep_grip=holding)
+            except Exception as e:  # noqa: BLE001
+                self.logger.warning(f"[PickAnyObject] rest-arm failed: {e}")
+            if self.head is not None:
+                self.head.set_position(0)
+
+    def cancel(self):
+        self._cancelled = True
+        if self.mobility is not None:
+            self.mobility.send_cmd_vel(0.0, 0.0, 0.1)
+        return "Pick cancelled"

From d7acf1baf070c6625b7f491296dd0edbdad6b93a Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Thu, 16 Jul 2026 21:47:35 +0000
Subject: [PATCH 02/19] refactor(skills): shared skill_lib for arm primitives +
 camera geometry
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Introduce workspace/skill_lib/ — plain Python modules skills import directly,
no Skill classes, no roster entries. Functions take the interfaces they need
as explicit arguments. The hardware lessons now live exactly once:

- skill_lib/arm.py: verified gripper open (overcurrent-trip reboot recovery),
  close with the strength-cap lesson, health-checked cartesian moves (FK
  verify, recover + retry, raise ArmUnhealthy), servo recovery, reach clamps.
- skill_lib/geometry.py: head-camera <-> floor pinhole projection, moved
  verbatim from pick_any_object (pure math; the webapp panel mirrors it).

gripper_open / gripper_close become thin wrappers over the lib — and
gripper_open GAINS the trip-recovery verification that previously only
pick_any_object had. pick_any_object drops ~150 lines of private helpers
(_move_arm, _recover_arm, geometry, inline reach clamps) for lib calls, and
calls the lib directly instead of round-tripping gripper skills through the
invoker.

Import contract: skills import the lib at module top — the loader puts the
repo root on sys.path only while a skill module executes (namespace-package
import, verified live). catalog.reload_all/reload_selective now evict cached
workspace.skill_lib modules so a normal skills reload picks up lib edits too.

No behavior or compatibility changes otherwise: skill IDs, innate.skills
chaining, panel debug events, and TUNABLE keys are unchanged. Verified live
on the robot: reload loads all 23 skills, pick_any_object acks its params
through the lib imports, and gripper_close/gripper_open ran end-to-end via
the skill CLI (claw physically cycled and returned to open).
---
 .../brain_client/skills/catalog.py            |  11 ++
 workspace/innate_skills/gripper_close.py      |  21 +--
 workspace/innate_skills/gripper_open.py       |  30 ++--
 workspace/innate_skills/pick_any_object.py    | 159 ++++--------------
 workspace/skill_lib/README.md                 |  31 ++++
 workspace/skill_lib/arm.py                    | 113 +++++++++++++
 workspace/skill_lib/geometry.py               |  62 +++++++
 7 files changed, 272 insertions(+), 155 deletions(-)
 create mode 100644 workspace/skill_lib/README.md
 create mode 100644 workspace/skill_lib/arm.py
 create mode 100644 workspace/skill_lib/geometry.py

diff --git a/ros2_ws/src/brain/brain_client/brain_client/skills/catalog.py b/ros2_ws/src/brain/brain_client/brain_client/skills/catalog.py
index 9c69cb555..4cd6a6bfb 100644
--- a/ros2_ws/src/brain/brain_client/brain_client/skills/catalog.py
+++ b/ros2_ws/src/brain/brain_client/brain_client/skills/catalog.py
@@ -15,6 +15,7 @@
 import os
 import re
 import shutil
+import sys
 import threading
 import time
 import types
@@ -269,8 +270,17 @@ def _compute_skill_id(self, path: str | Path) -> str:
         return f"{prefix}/{basename}"
 
     # --- reload ---
+    @staticmethod
+    def _evict_skill_lib() -> None:
+        """Drop cached workspace.skill_lib modules so a skills reload picks up
+        lib edits too — skill files re-import the lib as they load. Without
+        this, sys.modules keeps serving the pre-edit lib to reloaded skills."""
+        for name in [m for m in sys.modules if m.startswith("workspace.skill_lib")]:
+            del sys.modules[name]
+
     def reload_all(self) -> None:
         self._logger.info("Reloading skills...")
+        self._evict_skill_lib()
         self._skills_directories = self._resolve_skills_directories()
         new_code_skills = self._load_code_skills(self._skills_directories)
         new_physical, new_in_training = self._load_physical_skills(self._skills_directories)
@@ -291,6 +301,7 @@ def reload_selective(self, skill_ids: list[str]) -> list[str]:
                 return list(self._code_skills.keys()) + list(self._physical_skills.keys())
 
         self._logger.info(f"Selectively reloading skills: {skill_ids}")
+        self._evict_skill_lib()
         reloaded = []
         for skill_id in skill_ids:
             basename = skill_id.split("/", 1)[-1] if "/" in skill_id else skill_id
diff --git a/workspace/innate_skills/gripper_close.py b/workspace/innate_skills/gripper_close.py
index c20bf37eb..4f8b94095 100644
--- a/workspace/innate_skills/gripper_close.py
+++ b/workspace/innate_skills/gripper_close.py
@@ -11,13 +11,14 @@
     gripper_close(strength=0.2) # close harder (firmer grip)
 
 (also from the agent, the webapp skills menu, and
-`scripts/innate skill run local/gripper_close`).
+`scripts/innate skill run gripper_close`).
 
-Enables arm torque first so the claw still moves after an overload left the
-servo torque-disabled.
+The implementation lives in workspace/skill_lib/arm.py (close): torque on
+first so the claw still moves after an overload left the servo disabled.
 """
 
 from brain_client.skills.types import Interface, InterfaceType, Skill, SkillResult
+from workspace.skill_lib import arm as armlib
 
 
 class GripperClose(Skill):
@@ -25,10 +26,6 @@ class GripperClose(Skill):
 
     manipulation = Interface(InterfaceType.MANIPULATION)
 
-    def __init__(self, logger):
-        super().__init__(logger)
-        self._cancelled = False
-
     @property
     def name(self):
         return "gripper_close"
@@ -36,21 +33,17 @@ def name(self):
     def guidelines(self):
         return (
             "Close the gripper/claw. strength adds squeeze (radians past the "
-            "closed stop) for a firmer grip; default 0.0."
+            "closed stop) for a firmer grip; default 0.0. Keep it <= 0.6 on a "
+            "real object — more overcurrent-trips the servo."
         )
 
     def execute(self, strength: float = 0.0, duration: float = 1.0):
         """Close the claw. strength = extra radians of squeeze past closed."""
         if self.manipulation is None:
             return "Manipulation interface not available", SkillResult.FAILURE
-        self.manipulation.torque_on()
-        ok = self.manipulation.close_gripper(
-            strength=strength, duration=duration, blocking=True
-        )
-        if not ok:
+        if not armlib.close(self.manipulation, strength=strength, duration=duration):
             return "Failed to close gripper", SkillResult.FAILURE
         return "Gripper closed", SkillResult.SUCCESS
 
     def cancel(self):
-        self._cancelled = True
         return "Gripper motion cancelled"
diff --git a/workspace/innate_skills/gripper_open.py b/workspace/innate_skills/gripper_open.py
index 0aa00ddc5..f76bfbd31 100644
--- a/workspace/innate_skills/gripper_open.py
+++ b/workspace/innate_skills/gripper_open.py
@@ -10,24 +10,29 @@
     gripper_open()      # fully open the claw
 
 (also from the agent, the webapp skills menu, and
-`scripts/innate skill run local/gripper_open`).
+`scripts/innate skill run gripper_open`).
 
-Enables arm torque first. A hard close that overloads the servo leaves its
-torque disabled, after which a plain open silently does nothing — that's why
-opening from a resting closed claw failed. Enabling torque first makes it move.
+The implementation lives in workspace/skill_lib/arm.py (open_checked):
+torque on first, then VERIFY the claw actually opened — an overcurrent-
+tripped servo no-ops silently — rebooting to clear a trip and retrying.
 """
 
-from brain_client.skills.types import Interface, InterfaceType, Skill, SkillResult
+from brain_client.skills.types import (
+    Interface,
+    InterfaceType,
+    RobotState,
+    RobotStateType,
+    Skill,
+    SkillResult,
+)
+from workspace.skill_lib import arm as armlib
 
 
 class GripperOpen(Skill):
     """Open the gripper (claw)."""
 
     manipulation = Interface(InterfaceType.MANIPULATION)
-
-    def __init__(self, logger):
-        super().__init__(logger)
-        self._cancelled = False
+    joint_states = RobotState(RobotStateType.LAST_JOINT_STATES)
 
     @property
     def name(self):
@@ -40,14 +45,13 @@ def execute(self, percent: float = 100.0, duration: float = 1.0):
         """Open the claw. percent 0-100 (default fully open)."""
         if self.manipulation is None:
             return "Manipulation interface not available", SkillResult.FAILURE
-        self.manipulation.torque_on()  # a torque-disabled servo won't move
-        ok = self.manipulation.open_gripper(
-            percent=percent, duration=duration, blocking=True
+        ok = armlib.open_checked(
+            self.manipulation, lambda: armlib.gripper_j6(self.joint_states),
+            percent=percent, duration=duration, logger=self.logger,
         )
         if not ok:
             return "Failed to open gripper", SkillResult.FAILURE
         return "Gripper opened", SkillResult.SUCCESS
 
     def cancel(self):
-        self._cancelled = True
         return "Gripper motion cancelled"
diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
index 764c6c886..94c24a12a 100644
--- a/workspace/innate_skills/pick_any_object.py
+++ b/workspace/innate_skills/pick_any_object.py
@@ -57,17 +57,9 @@
     Skill,
     SkillResult,
 )
-from innate.skills import SkillFailed, arm_rest_position, gripper_close, gripper_open
-
-# -----------------------------------------------------------------------------
-# geometry from mars.urdf
-# base_footprint == base_link, so z=0 is the floor. Camera sits in the head,
-# head pitches about y. That's enough to raycast a pixel onto the floor.
-# -----------------------------------------------------------------------------
-HEAD_ORIGIN = (-0.040751, -0.0002, 0.25882)  # base_link -> head joint
-CAM_IN_HEAD = (0.04327, 0.0297, -0.000275)   # head -> left camera optical
-IMG_W, IMG_H = 640, 480
-HFOV_DEG = 70.0
+from innate.skills import SkillFailed, arm_rest_position
+from workspace.skill_lib import arm as armlib
+from workspace.skill_lib.geometry import IMG_H, IMG_W, floor_to_pixel, pixel_to_floor
 
 # hardware-tuned constants (not exposed to the live panel)
 GRIPPER_EMPTY_J6 = -0.085  # joint6 when fingers are open / empty
@@ -200,53 +192,8 @@ def _load_gemini_key() -> str:
     return ""
 
 
-# -----------------------------------------------------------------------------
-# floor localization: pixel + head tilt -> (x, y) in base_link
-# Pure math. No ROS, no depth. If the ray doesn't hit the floor (or hits
-# behind the robot), return None.
-# -----------------------------------------------------------------------------
-def _head_rot(tilt_rad):
-    # pitch about +y: nose down is negative tilt in our convention
-    c, s = math.cos(tilt_rad), math.sin(tilt_rad)
-    return ((c, 0.0, -s), (0.0, 1.0, 0.0), (s, 0.0, c))
-
-
-def _rot(R, v):
-    return tuple(sum(R[i][k] * v[k] for k in range(3)) for i in range(3))
-
-
-def pixel_to_floor(u, v, head_tilt_deg):
-    """Cast a ray from the camera through pixel (u,v) and intersect z=0."""
-    fx = IMG_W / (2.0 * math.tan(math.radians(HFOV_DEG) / 2.0))
-    cx, cy = IMG_W / 2.0, IMG_H / 2.0
-    R = _head_rot(math.radians(head_tilt_deg))
-    cam = tuple(HEAD_ORIGIN[i] + _rot(R, CAM_IN_HEAD)[i] for i in range(3))
-    # camera frame in base_link: forward, right, down (optical convention)
-    fwd, right, down = _rot(R, (1, 0, 0)), _rot(R, (0, -1, 0)), _rot(R, (0, 0, -1))
-    xo, yo = (u - cx) / fx, (v - cy) / fx
-    d = tuple(fwd[i] + xo * right[i] + yo * down[i] for i in range(3))
-    if d[2] >= -1e-6:  # ray not pointing at the floor
-        return None
-    t = -cam[2] / d[2]
-    x, y = cam[0] + t * d[0], cam[1] + t * d[1]
-    return (x, y) if x > 0 else None  # behind the robot = nonsense
-
-
-def floor_to_pixel(x, y, head_tilt_deg):
-    """Inverse: floor point (x,y,0) -> image pixel. Used to draw the pick box
-    and the grasp target back onto the live head-camera frame."""
-    fx = IMG_W / (2.0 * math.tan(math.radians(HFOV_DEG) / 2.0))
-    cx, cy = IMG_W / 2.0, IMG_H / 2.0
-    R = _head_rot(math.radians(head_tilt_deg))
-    cam = tuple(HEAD_ORIGIN[i] + _rot(R, CAM_IN_HEAD)[i] for i in range(3))
-    fwd, right, down = _rot(R, (1, 0, 0)), _rot(R, (0, -1, 0)), _rot(R, (0, 0, -1))
-    D = (x - cam[0], y - cam[1], -cam[2])
-    a = sum(D[i] * fwd[i] for i in range(3))
-    if a <= 1e-6:  # on or behind the image plane
-        return None
-    b = sum(D[i] * right[i] for i in range(3))
-    c = sum(D[i] * down[i] for i in range(3))
-    return (cx + (b / a) * fx, cy + (c / a) * fx)
+# floor localization (pixel + head tilt <-> base_link x,y) lives in
+# workspace/skill_lib/geometry.py — imported above, same names.
 
 
 def _r(v, nd=4):
@@ -539,52 +486,14 @@ def _drive(self, dist, tol=None, timeout=15.0):
         self._dbg("drive_done", err_m=round(err, 4), s=round(time.time() - t0, 2))
 
     # -------------------------------------------------------------------------
-    # arm. Servos can brown out mid-move — check FK, reboot once, then abort
-    # loudly rather than continuing limp into the floor.
+    # arm. Health-checked moves, recovery, and reach clamps live in
+    # workspace/skill_lib/arm.py (armlib) — thin state accessors stay here.
     # -------------------------------------------------------------------------
-    class ArmUnhealthy(RuntimeError):
-        pass
-
     def _ee_xyz(self):
-        pose = self.manipulation.get_current_end_effector_pose()
-        try:
-            p = pose["position"]
-            return (float(p["x"]), float(p["y"]), float(p["z"]))
-        except (KeyError, TypeError):
-            return None
+        return armlib.ee_xyz(self.manipulation)
 
     def _gripper_j6(self):
-        js = self.joint_states
-        try:
-            return js["position"][5] if js else None
-        except (KeyError, IndexError, TypeError):
-            return None
-
-    def _recover_arm(self):
-        self.logger.warning("[PickAnyObject] recovering arm (reboot + torque on)")
-        self.manipulation.reboot_servos()
-        time.sleep(2.0)
-        self.manipulation.torque_on()
-        time.sleep(0.5)
-
-    def _move_arm(self, x, y, z, pitch, duration=1.5, tol=0.05):
-        """Cartesian move with a health check. Recover + retry once, then raise."""
-        for attempt in (1, 2):
-            ok = self.manipulation.move_to_cartesian_pose(
-                x=x, y=y, z=z, roll=0.0, pitch=pitch, yaw=0.0,
-                duration=duration, blocking=True,
-            )
-            cur = self._ee_xyz()
-            err = math.dist(cur, (x, y, z)) if cur is not None else None
-            if ok and err is not None and err <= tol:
-                return True
-            self.logger.warning(
-                f"[PickAnyObject] arm not tracking (ok={ok} err={err}) — "
-                f"{'recovering' if attempt == 1 else 'giving up'}"
-            )
-            if attempt == 1:
-                self._recover_arm()
-        raise self.ArmUnhealthy(f"arm failed to reach ({x:.2f},{y:.2f},{z:.2f})")
+        return armlib.gripper_j6(self.joint_states)
 
     def _rest_arm(self, keep_grip):
         """Fold to home. If carrying: go to the operator's CARRY_ARM pose with
@@ -1032,13 +941,13 @@ def _wrist_servo(self, prompt, tx, ty):
                 cap = p["wrist_step_max"]
                 x += max(-cap, min(cap, p["wrist_kx"] / 100.0 * err_v * s))
                 y += max(-cap, min(cap, p["wrist_ky"] / 100.0 * err_u * s))
-                x = max(0.22, min(0.40, x))  # the arm's reach box
-                y = max(-0.10, min(0.10, y))
+                x, y = armlib.clamp_reach(x, y)
                 # feed-forward: this correction should land the object at the
                 # box center — tell the tracker to look for it there
                 guess = (p["wrist_box_u"], p["wrist_box_v"])
-            self._move_arm(x, y, z, pitch=p["wrist_pitch"],
-                           duration=p["wrist_move_s"])
+            armlib.move_checked(self.manipulation, x, y, z,
+                                pitch=p["wrist_pitch"],
+                                duration=p["wrist_move_s"], logger=self.logger)
             streak = 0
             centered = 0  # the view shifted — re-confirm centering
 
@@ -1067,19 +976,11 @@ def _goto_search_pose(self, bearing):
         self._dbg("hover", ee=self._ee_dbg())
 
     def _open_gripper_checked(self):
-        """Open the claw, and make sure it actually opened. A prior hard
-        close can overcurrent-trip the gripper servo — a hardware fault
-        torque_on alone can't clear — after which open silently no-ops and
-        the hand stays shut straight into the grasp. Reboot clears the trip."""
-        gripper_open()
-        j6 = self._gripper_j6()
-        if j6 is not None and j6 < 0.10:
-            self.logger.warning(
-                f"[PickAnyObject] gripper did not open (j6={j6:.3f}); "
-                "rebooting servos to clear a trip, then retrying")
-            self._dbg("gripper_reboot", j6=_r(j6))
-            self._recover_arm()
-            gripper_open()
+        """Open the claw, verified (trip recovery) — see armlib.open_checked."""
+        armlib.open_checked(
+            self.manipulation, self._gripper_j6, logger=self.logger,
+            on_reboot=lambda j6: self._dbg("gripper_reboot", j6=_r(j6)),
+        )
 
     def _push_to_floor(self, x, y, z_from, deep):
         """The last blind centimeters: rotate to the grasp pitch and descend
@@ -1100,14 +1001,14 @@ def _push_to_floor(self, x, y, z_from, deep):
             )
             self._dbg("descend", z=round(z, 3), ok=bool(ok), ee=self._ee_dbg())
             if not ok:
-                self._recover_arm()
+                armlib.recover(self.manipulation, self.logger)
                 break
         ee = self._ee_xyz()
         if ee is not None and ee[2] > p["descend_abort_z"]:
             self._dbg("grasp_abort", reason="arm would not descend",
                       ee_z=round(ee[2], 4))
-            self._recover_arm()
-            raise self.ArmUnhealthy("arm would not descend")
+            armlib.recover(self.manipulation, self.logger)
+            raise armlib.ArmUnhealthy("arm would not descend")
 
     def _close_twist_lift(self, x, y):
         """Take it: squeeze, wind the fabric onto the fingers, lift. Twist
@@ -1117,7 +1018,8 @@ def _close_twist_lift(self, x, y):
         position instead relaxes the squeeze mid-lift and drops socks."""
         p = self._p
         j6_open = self._gripper_j6()
-        gripper_close(strength=p["close_strength"], duration=p["close_s"])
+        armlib.close(self.manipulation, strength=p["close_strength"],
+                     duration=p["close_s"])
         time.sleep(p["close_settle_s"])
         self._dbg("close", j6_open=_r(j6_open), j6=_r(self._gripper_j6()),
                   strength=p["close_strength"])
@@ -1139,8 +1041,9 @@ def _close_twist_lift(self, x, y):
             time.sleep(0.3)
             self._dbg("lift", ee=self._ee_dbg(), j6=_r(self._gripper_j6()))
         except (KeyError, IndexError, TypeError):  # no joint state — IK lift
-            self._move_arm(x, y, 0.22, pitch=p["arm_pitch"], duration=2.0,
-                           tol=0.10)
+            armlib.move_checked(self.manipulation, x, y, 0.22,
+                                pitch=p["arm_pitch"], duration=2.0, tol=0.10,
+                                logger=self.logger)
             self._dbg("lift", ee=self._ee_dbg(), j6=_r(self._gripper_j6()),
                       ik_fallback=True)
 
@@ -1150,8 +1053,7 @@ def _grasp_at(self, prompt, xy, deep=False):
         so the panel can retune a grasp mid-run."""
         p = self._p
         # aim short: fingertips land ~grasp_x_off forward of ee_link
-        x = max(0.22, min(0.40, xy[0] - p["grasp_x_off"]))
-        y = max(-0.10, min(0.10, xy[1]))
+        x, y = armlib.clamp_reach(xy[0] - p["grasp_x_off"], xy[1])
 
         # telemetry: where the object is vs where the fingers will land (they
         # differ only when the object is outside the reach box — aim clamped)
@@ -1174,8 +1076,9 @@ def _grasp_at(self, prompt, xy, deep=False):
             x, y, z = self._wrist_servo(prompt, x, y)
         else:  # classic blind grasp: IK hover above the estimate
             z = p["hover_z"]
-            self._move_arm(x, y, z, pitch=p["arm_pitch"],
-                           duration=p["hover_s"])
+            armlib.move_checked(self.manipulation, x, y, z,
+                                pitch=p["arm_pitch"], duration=p["hover_s"],
+                                logger=self.logger)
             self._dbg("hover", ee=self._ee_dbg())
 
         self._push_to_floor(x, y, z, deep)
@@ -1276,7 +1179,7 @@ def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
                 "backing up)",
                 SkillResult.FAILURE,
             )
-        except self.ArmUnhealthy as e:
+        except armlib.ArmUnhealthy as e:
             self.say("My arm isn't responding properly, stopping.")
             return f"Arm servo failure: {e}", SkillResult.FAILURE
         finally:
diff --git a/workspace/skill_lib/README.md b/workspace/skill_lib/README.md
new file mode 100644
index 000000000..211e145db
--- /dev/null
+++ b/workspace/skill_lib/README.md
@@ -0,0 +1,31 @@
+# skill_lib — shared primitives for skills
+
+Plain Python modules skills import directly. No `Skill` classes here; no
+registration, no roster entry, no invoker round trip — just functions that
+take the interfaces they need as arguments.
+
+```python
+from workspace.skill_lib import arm as armlib
+
+armlib.open_checked(self.manipulation, self._gripper_j6)
+armlib.move_checked(self.manipulation, x, y, z, pitch=1.3, logger=self.logger)
+```
+
+## What belongs where
+
+- **Here**: short blocking device commands, recovery sequences (servo trip /
+  brownout handling), reach clamps, pure math (camera geometry). Functions
+  the *author of a skill* calls.
+- **A `Skill`**: anything the agent or an operator invokes by name, and
+  anything long-running enough to need cancellation checks and step
+  telemetry. The moment a second skill wants to copy a private helper,
+  that helper moves here.
+
+## Two rules
+
+1. **Import at the top of the skill file, never inside a function.** The
+   skill loader puts the repo root on `sys.path` only while the skill module
+   executes; a lazy import inside `execute()` will not resolve.
+2. **Editing a lib file mid-session:** `/brain/reload_primitives` evicts
+   `workspace.skill_lib*` from `sys.modules` before reloading skills, so a
+   normal skills reload picks up lib edits too (see `catalog.reload_all`).
diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
new file mode 100644
index 000000000..3b2c35e83
--- /dev/null
+++ b/workspace/skill_lib/arm.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Innate Inc
+"""Arm primitives shared by skills. The hardware lessons live here once.
+
+Plain functions: pass the manipulation interface (and, where needed, a
+joint-state getter) explicitly — no ambient context, no Skill machinery.
+Rule of thumb: short blocking device commands, recovery sequences, and
+pure math belong here; anything long-running or cancellable stays a Skill.
+
+Import gotcha (applies to all of workspace/skill_lib): import at the TOP of
+a skill file. The skill loader puts the repo root on sys.path only while the
+skill module executes, so a lazy import inside execute() will not resolve.
+"""
+
+import math
+import time
+
+# The arm's grasp-reach box in base_link meters — beyond it, IK strains or
+# the fingers land short. The webapp draws this box (REACH in pickTunePanel.js).
+REACH_X = (0.22, 0.40)
+REACH_Y = (-0.10, 0.10)
+
+
+class ArmUnhealthy(RuntimeError):
+    """Servo brownout / refusal — abort loudly, never continue limp."""
+
+
+def clamp_reach(x, y):
+    """Clamp a grasp / servo target into the arm's reach box."""
+    return (max(REACH_X[0], min(REACH_X[1], x)),
+            max(REACH_Y[0], min(REACH_Y[1], y)))
+
+
+def ee_xyz(manipulation):
+    """Current end-effector position from FK, or None while state is absent."""
+    pose = manipulation.get_current_end_effector_pose()
+    try:
+        p = pose["position"]
+        return (float(p["x"]), float(p["y"]), float(p["z"]))
+    except (KeyError, TypeError):
+        return None
+
+
+def gripper_j6(joint_states):
+    """Gripper joint (j6) from a joint_states dict, or None."""
+    try:
+        return joint_states["position"][5] if joint_states else None
+    except (KeyError, IndexError, TypeError):
+        return None
+
+
+def recover(manipulation, logger=None):
+    """Reboot servos + torque on — the only cure for an overcurrent trip or
+    a brownout (torque_on alone can't clear a tripped servo's hardware error)."""
+    if logger:
+        logger.warning("[arm] recovering (reboot + torque on)")
+    manipulation.reboot_servos()
+    time.sleep(2.0)
+    manipulation.torque_on()
+    time.sleep(0.5)
+
+
+def move_checked(manipulation, x, y, z, pitch, duration=1.5, tol=0.05, logger=None):
+    """Cartesian move with a health check: verify FK landed within tol,
+    recover + retry once, then raise ArmUnhealthy rather than let a limp
+    arm continue into the floor."""
+    for attempt in (1, 2):
+        ok = manipulation.move_to_cartesian_pose(
+            x=x, y=y, z=z, roll=0.0, pitch=pitch, yaw=0.0,
+            duration=duration, blocking=True,
+        )
+        cur = ee_xyz(manipulation)
+        err = math.dist(cur, (x, y, z)) if cur is not None else None
+        if ok and err is not None and err <= tol:
+            return True
+        if logger:
+            logger.warning(f"[arm] not tracking (ok={ok} err={err}) — "
+                           f"{'recovering' if attempt == 1 else 'giving up'}")
+        if attempt == 1:
+            recover(manipulation, logger)
+    raise ArmUnhealthy(f"arm failed to reach ({x:.2f},{y:.2f},{z:.2f})")
+
+
+def open_checked(manipulation, get_j6, percent=100.0, duration=1.0,
+                 logger=None, on_reboot=None):
+    """Open the gripper and VERIFY it opened. A prior hard close can
+    overcurrent-TRIP the gripper servo — a hardware error torque_on alone
+    can't clear — after which open silently does nothing and the hand stays
+    shut. If j6 says it didn't open, reboot to clear the trip and retry.
+    on_reboot(j6) is called before the reboot (telemetry hook)."""
+    manipulation.torque_on()  # a torque-disabled servo won't move at all
+    ok = manipulation.open_gripper(percent=percent, duration=duration, blocking=True)
+    j6 = get_j6()
+    if j6 is not None and j6 < 0.10:
+        if logger:
+            logger.warning(f"[arm] gripper did not open (j6={j6:.3f}); "
+                           "rebooting servos to clear a trip, then retrying")
+        if on_reboot:
+            on_reboot(j6)
+        recover(manipulation, logger)
+        ok = manipulation.open_gripper(percent=percent, duration=duration, blocking=True)
+    return bool(ok)
+
+
+def close(manipulation, strength=0.0, duration=1.0):
+    """Close the gripper. strength = extra squeeze past the closed stop.
+    Keep it <= ~0.6 against a real object: higher stalls j6 at max current
+    on the fingers and overcurrent-trips the servo (open then no-ops until
+    a reboot)."""
+    manipulation.torque_on()
+    return bool(manipulation.close_gripper(strength=strength, duration=duration,
+                                           blocking=True))
diff --git a/workspace/skill_lib/geometry.py b/workspace/skill_lib/geometry.py
new file mode 100644
index 000000000..16d2e76ca
--- /dev/null
+++ b/workspace/skill_lib/geometry.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Innate Inc
+"""Head-camera <-> floor geometry. Pure math: no ROS, no depth sensor — a
+pinhole model plus the URDF head kinematics is enough to raycast a pixel
+onto the floor plane (base_footprint == base_link, so the floor is z=0).
+
+The webapp mirrors these constants and both projections (pickTunePanel.js)
+so the pick box can be drawn without a skill round trip — keep them in sync.
+"""
+
+import math
+
+HEAD_ORIGIN = (-0.040751, -0.0002, 0.25882)  # base_link -> head joint (URDF)
+CAM_IN_HEAD = (0.04327, 0.0297, -0.000275)   # head -> left camera optical
+IMG_W, IMG_H = 640, 480
+HFOV_DEG = 70.0
+
+
+def _head_rot(tilt_rad):
+    # pitch about +y: nose down is negative tilt in our convention
+    c, s = math.cos(tilt_rad), math.sin(tilt_rad)
+    return ((c, 0.0, -s), (0.0, 1.0, 0.0), (s, 0.0, c))
+
+
+def _rot(R, v):
+    return tuple(sum(R[i][k] * v[k] for k in range(3)) for i in range(3))
+
+
+def pixel_to_floor(u, v, head_tilt_deg):
+    """Cast a ray from the camera through pixel (u,v) and intersect z=0.
+    None if the ray misses the floor or lands behind the robot."""
+    fx = IMG_W / (2.0 * math.tan(math.radians(HFOV_DEG) / 2.0))
+    cx, cy = IMG_W / 2.0, IMG_H / 2.0
+    R = _head_rot(math.radians(head_tilt_deg))
+    cam = tuple(HEAD_ORIGIN[i] + _rot(R, CAM_IN_HEAD)[i] for i in range(3))
+    # camera frame in base_link: forward, right, down (optical convention)
+    fwd, right, down = _rot(R, (1, 0, 0)), _rot(R, (0, -1, 0)), _rot(R, (0, 0, -1))
+    xo, yo = (u - cx) / fx, (v - cy) / fx
+    d = tuple(fwd[i] + xo * right[i] + yo * down[i] for i in range(3))
+    if d[2] >= -1e-6:  # ray not pointing at the floor
+        return None
+    t = -cam[2] / d[2]
+    x, y = cam[0] + t * d[0], cam[1] + t * d[1]
+    return (x, y) if x > 0 else None  # behind the robot = nonsense
+
+
+def floor_to_pixel(x, y, head_tilt_deg):
+    """Inverse: floor point (x,y,0) -> image pixel, or None behind the
+    image plane. Exact inverse of pixel_to_floor (round-trips to <0.1 px)."""
+    fx = IMG_W / (2.0 * math.tan(math.radians(HFOV_DEG) / 2.0))
+    cx, cy = IMG_W / 2.0, IMG_H / 2.0
+    R = _head_rot(math.radians(head_tilt_deg))
+    cam = tuple(HEAD_ORIGIN[i] + _rot(R, CAM_IN_HEAD)[i] for i in range(3))
+    fwd, right, down = _rot(R, (1, 0, 0)), _rot(R, (0, -1, 0)), _rot(R, (0, 0, -1))
+    D = (x - cam[0], y - cam[1], -cam[2])
+    a = sum(D[i] * fwd[i] for i in range(3))
+    if a <= 1e-6:  # on or behind the image plane
+        return None
+    b = sum(D[i] * right[i] for i in range(3))
+    c = sum(D[i] * down[i] for i in range(3))
+    return (cx + (b / a) * fx, cy + (c / a) * fx)

From a4c98e8da5753c11773e5af19da551ef4a1120fd Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Thu, 16 Jul 2026 22:53:54 +0000
Subject: [PATCH 03/19] feat(pick): route vision calls through the Innate proxy
 (gemini service)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the direct google-genai client in pick_any_object with the Innate
ProxyClient. Vision requests now go to the proxy's OpenAI-compatible endpoint
(service "gemini", POST /v1/chat/completions) with the image as a data URI —
the proxy holds the upstream API key; the robot authenticates with its
service key. Drops the GEMINI_API_KEY load path and the genai dependency from
this skill.

Verified against the live proxy that the service name, endpoint, and vision
body shape are all accepted (they pass path validation and body parsing and
reach the proxy's auth check). The native Gemini REST path
(models/{model}:generateContent) is NOT usable through the proxy — it rejects
the ":" in the path — so OpenAI-compat is the route.

KNOWN BLOCKER (deploy step, not a code issue): this robot's service key is
not yet authorized for the "gemini" service — the proxy returns 403 until an
admin grants access. Detection will fail with 403 until then; grant the key
"gemini" access, then verify a real pick end-to-end.
---
 workspace/innate_skills/pick_any_object.py | 115 +++++++++------------
 1 file changed, 47 insertions(+), 68 deletions(-)

diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
index 94c24a12a..4a8a266a7 100644
--- a/workspace/innate_skills/pick_any_object.py
+++ b/workspace/innate_skills/pick_any_object.py
@@ -38,15 +38,12 @@
 import base64
 import json
 import math
-import os
 import re
 import time
-from pathlib import Path
 
 import cv2
 import numpy as np
-from google import genai
-from google.genai import types as genai_types
+from innate_proxy import ProxyClient
 from std_msgs.msg import String
 
 from brain_client.skills.types import (
@@ -61,6 +58,14 @@
 from workspace.skill_lib import arm as armlib
 from workspace.skill_lib.geometry import IMG_H, IMG_W, floor_to_pixel, pixel_to_floor
 
+# Vision model, reached through the Innate proxy's OpenAI-compatible endpoint
+# (service "gemini", /v1/chat/completions). The proxy holds the upstream key;
+# the robot authenticates with its service key. NOTE: the service key must be
+# granted access to the "gemini" service or the proxy returns 403.
+GEMINI_SERVICE = "gemini"
+GEMINI_ENDPOINT = "/v1/chat/completions"
+GEMINI_MODEL = "gemini-3.5-flash"
+
 # hardware-tuned constants (not exposed to the live panel)
 GRIPPER_EMPTY_J6 = -0.085  # joint6 when fingers are open / empty
 VERIFY_BACKUP_M = 0.15     # how far to reverse before asking "is it gone?"
@@ -152,25 +157,11 @@
 DEBUG_TOPIC = "/pick_any_object/debug"
 TUNING_TOPIC = "/pick_any_object/tuning"
 
-FOLLOW_TIMEOUT_S = 20.0  # one optical-flow follow attempt
-WRIST_ALIGN_TIMEOUT_S = 60.0  # whole wrist-servo descent (deliberately slow:
-                              # every step waits for two verified flow matches)
-WRIST_MAX_JUMP_PX = 80.0      # a tracked blob moving more than this between
-                              # consecutive frames isn't our object — drop it
-WRIST_SEG_MIN_SCORE = 25.0    # mean back-projection likelihood (0-255) inside
-                              # the tracked window below which the object is
-                              # considered lost (segmentation collapsed)
-# Wrist camera sits ~7 cm above ee_link (URDF: on link5, up the wrist). Only
-# used to scale the px->m gains with camera height as the arm descends.
+FOLLOW_TIMEOUT_S = 20.0
+WRIST_ALIGN_TIMEOUT_S = 60.0
+WRIST_MAX_JUMP_PX = 80.0
+WRIST_SEG_MIN_SCORE = 25.0
 WRIST_CAM_ABOVE_EE = 0.07
-# The wrist-servo search position, posed by the operator (2026-07-14): elbow
-# high near 90°, wrist camera looking down at the floor ahead. FK puts ee_link
-# at (0.296, -0.022, 0.198), ee pitch 0.8221. This IS the hover — the servo
-# descends from wherever this pose is. It also seeds the KDL-LMA IK (which
-# converges to the branch nearest the current joints), keeping every servo
-# move on this elbow-up branch. j1 is re-aimed at the target, j4 is derived
-# (j2+j3+j4 = wrist_pitch, = the posed j4 at the default pitch), and j6 keeps
-# the gripper, so only j2/j3/j5 are used verbatim.
 WRIST_SEARCH_ARM = [0.1473, -0.0706, -0.4449, 1.3376, -0.0491]
 # Lucas-Kanade defaults — a small patch beats a single point
 _LK_PARAMS = dict(
@@ -179,23 +170,6 @@
 )
 
 
-def _load_gemini_key() -> str:
-    # env first, then the repo .env — same pattern as the rest of the stack
-    key = os.environ.get("GEMINI_API_KEY", "")
-    if key:
-        return key
-    env_path = Path.home() / "innate-os" / ".env"
-    if env_path.exists():
-        m = re.search(r"^GEMINI_API_KEY=(.+)$", env_path.read_text(), re.M)
-        if m:
-            return m.group(1).strip().strip('"')
-    return ""
-
-
-# floor localization (pixel + head tilt <-> base_link x,y) lives in
-# workspace/skill_lib/geometry.py — imported above, same names.
-
-
 def _r(v, nd=4):
     """round that passes None through (absent sensor readings)."""
     return round(v, nd) if isinstance(v, (int, float)) else None
@@ -218,8 +192,11 @@ class PickAnyObject(Skill):
     def __init__(self, logger):
         super().__init__(logger)
         self._cancelled = False
-        key = _load_gemini_key()
-        self._gemini = genai.Client(api_key=key) if key else None
+        # Vision runs through the Innate proxy (upstream key managed there);
+        # None when the robot has no proxy credentials configured.
+        self._proxy = ProxyClient()
+        if not self._proxy.is_available():
+            self._proxy = None
         self._p = dict(TUNABLE)  # live copy; panel mutates this
         self._dbg_pub = None
         self._tuning_sub = None
@@ -281,27 +258,35 @@ def _dbg(self, ev, **fields):
     # vision: Gemini finds a pixel, geometry turns it into a floor point
     # -------------------------------------------------------------------------
     def _gemini_call(self, image_b64, question, retries=3):
+        """Ask the vision model about an image. Routes through the Innate
+        proxy's OpenAI-compatible chat endpoint (image as a data URI); returns
+        the reply text, or None after `retries` failures."""
+        proxy = self._proxy
+        if proxy is None:
+            return None
+        body = {
+            "model": GEMINI_MODEL,
+            "temperature": 0.0,
+            "messages": [{
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": question},
+                    {"type": "image_url", "image_url": {
+                        "url": f"data:image/jpeg;base64,{image_b64}"}},
+                ],
+            }],
+        }
         for attempt in range(retries):
             try:
-                resp = self._gemini.models.generate_content(
-                    model="gemini-3.5-flash",
-                    contents=[
-                        genai_types.Part.from_bytes(
-                            data=base64.b64decode(image_b64), mime_type="image/jpeg"
-                        ),
-                        question,
-                    ],
-                    config=genai_types.GenerateContentConfig(
-                        temperature=0.0,
-                        thinking_config=genai_types.ThinkingConfig(
-                            thinking_level=genai_types.ThinkingLevel.LOW
-                        ),
-                    ),
-                )
-                return resp.text or ""
+                with proxy.request_stream(
+                    GEMINI_SERVICE, GEMINI_ENDPOINT, method="POST", json=body,
+                ) as resp:
+                    resp.raise_for_status()
+                    data = json.loads(resp.read())
+                return data["choices"][0]["message"]["content"] or ""
             except Exception as e:  # noqa: BLE001
                 self.logger.warning(
-                    f"[PickAnyObject] Gemini failed (try {attempt + 1}/{retries}): {e}"
+                    f"[PickAnyObject] vision call failed (try {attempt + 1}/{retries}): {e}"
                 )
                 if attempt < retries - 1:
                     time.sleep(2.0 * (attempt + 1))
@@ -1124,8 +1109,8 @@ def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
             max_base_steps: kept for interface compatibility; unused in v3.
         """
         self._cancelled = False
-        if self._gemini is None:
-            return "GEMINI_API_KEY not configured", SkillResult.FAILURE
+        if self._proxy is None:
+            return "Innate proxy not configured (INNATE_SERVICE_KEY)", SkillResult.FAILURE
         if self.manipulation is None or self.mobility is None:
             return "Manipulation/mobility interface not available", SkillResult.FAILURE
 
@@ -1135,12 +1120,8 @@ def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
         holding = False
         try:
             self.head.set_position(int(round(self._p["tilt_deg"])))
-            time.sleep(0.8)
-            # Fold the arm to rest BEFORE searching so it's low and swung to the
-            # side, out of the head camera's downward view (a lifted arm sits in
-            # frame and hides the floor). The rest pose now clears the floor, so
-            # this no longer jams the gripper into the ground. Best-effort — a
-            # failed fold shouldn't abort the pick (a cancel still propagates).
+            time.sleep(0.5)
+            # Fold the arm to rest BEFORE searching to not hide the camera pov
             try:
                 arm_rest_position()
             except SkillFailed as e:
@@ -1154,8 +1135,6 @@ def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
                     SkillResult.FAILURE,
                 )
 
-            # one shot: position -> grasp -> verify. No retry re-approach —
-            # driving forward again after a miss surprised the operator.
             if self._cancelled:
                 return "Cancelled", SkillResult.CANCELLED
             xy = self._position_above(prompt, xy)

From e89b0723ff01c0c212ed5324d47566d9bef2aed6 Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Fri, 17 Jul 2026 07:34:34 +0000
Subject: [PATCH 04/19] feat(pick): two-camera grasp verify, skill_lib
 vision/gemini, cancellation refactor

pick_any_object:
- _grasp_verified now sends BOTH head + wrist cameras to Gemini so a
  held object (visible in the mirrored wrist view) isn't misread as
  dropped; degrades to head-only if the wrist frame is absent.
- cancellation via SkillCancelled + _checkpoint() replaces the
  cancelled-as-None plumbing (one raise, one except in execute); fixes
  cancel-during-search being misreported as FAILURE.
- extracted the pure vision math and proxy vision call into
  workspace/skill_lib/{vision,gemini}.py; gemini.ask_image now takes
  one image or a list (multi-image support).

Also folded in (per 'everything'):
- pyright: return-type annotations on Skill base (types.py) +
  pyrightconfig.json; /etc/innate.env perms enforcement in
  post_update.sh; webapp pick tuning panel rename to pickOverlay.js;
  in-progress pyright cleanups across other innate_skills.
---
 pyrightconfig.json                            |   14 +
 .../brain_client/brain_client/skills/types.py |    8 +-
 scripts/update/post_update.sh                 |   13 +
 webapp/css/app.css                            |  191 +--
 webapp/js/constants.js                        |    6 +-
 webapp/js/teleop/main.js                      |    4 +-
 webapp/js/teleop/pickOverlay.js               |  339 +++++
 webapp/js/teleop/pickTunePanel.js             | 1237 -----------------
 workspace/innate_skills/arm_utils.py          |    4 +-
 .../innate_skills/detect_opponent_move.py     |   18 +-
 workspace/innate_skills/head_emotion.py       |    4 +-
 .../innate_skills/navigate_to_position.py     |   10 +-
 .../innate_skills/navigate_with_vision.py     |    9 +-
 workspace/innate_skills/pick_any_object.py    |  892 ++++--------
 workspace/innate_skills/recalibrate_manual.py |    4 +-
 workspace/innate_skills/record_position.py    |    4 +-
 workspace/innate_skills/reset_chess_game.py   |    4 +-
 workspace/innate_skills/retrieve_emails.py    |    6 +-
 workspace/innate_skills/send_email.py         |    2 +-
 .../innate_skills/send_picture_via_email.py   |    2 +-
 workspace/skill_lib/arm.py                    |   41 +-
 workspace/skill_lib/gemini.py                 |   57 +
 workspace/skill_lib/geometry.py               |   22 +-
 workspace/skill_lib/vision.py                 |  150 ++
 24 files changed, 927 insertions(+), 2114 deletions(-)
 create mode 100644 pyrightconfig.json
 create mode 100644 webapp/js/teleop/pickOverlay.js
 delete mode 100644 webapp/js/teleop/pickTunePanel.js
 create mode 100644 workspace/skill_lib/gemini.py
 create mode 100644 workspace/skill_lib/vision.py

diff --git a/pyrightconfig.json b/pyrightconfig.json
new file mode 100644
index 000000000..220abfbd2
--- /dev/null
+++ b/pyrightconfig.json
@@ -0,0 +1,14 @@
+{
+  "pythonVersion": "3.10",
+  "pythonPlatform": "Linux",
+  "extraPaths": [
+    "ros2_ws/src/brain/brain_client",
+    "ros2_ws/src/cloud/clients/proxy-client",
+    "ros2_ws/install/brain_client/local/lib/python3.10/dist-packages",
+    "ros2_ws/install/brain_messages/local/lib/python3.10/dist-packages",
+    "ros2_ws/install/innate_cloud_msgs/local/lib/python3.10/dist-packages",
+    "ros2_ws/install/mars_msgs/local/lib/python3.10/dist-packages",
+    "/opt/ros/humble/lib/python3.10/site-packages",
+    "/opt/ros/humble/local/lib/python3.10/dist-packages"
+  ]
+}
diff --git a/ros2_ws/src/brain/brain_client/brain_client/skills/types.py b/ros2_ws/src/brain/brain_client/brain_client/skills/types.py
index d7dfe1e73..7a9e23904 100644
--- a/ros2_ws/src/brain/brain_client/brain_client/skills/types.py
+++ b/ros2_ws/src/brain/brain_client/brain_client/skills/types.py
@@ -208,7 +208,7 @@ def __init__(self, logger):
 
     @property
     @abstractmethod
-    def name(self):
+    def name(self) -> str:
         """
         The name of the skill.
         Must be defined by every subclass.
@@ -216,7 +216,7 @@ def name(self):
         pass
 
     @abstractmethod
-    def execute(self, *args, **kwargs):
+    def execute(self, *args, **kwargs) -> tuple:
         """
         Execute the skill.
 
@@ -389,14 +389,14 @@ def inject_interface(self, interface_type: InterfaceType, interface_instance):
                 return True
         return False
 
-    def guidelines(self):
+    def guidelines(self) -> str | None:
         """
         Optionally provide guidelines for this skill.
         Subclasses may override this method if guidelines are available.
         """
         return None
 
-    def guidelines_when_running(self):
+    def guidelines_when_running(self) -> str | None:
         """
         Optionally provide guidelines for this skill when it is running.
         Subclasses may override this method if guidelines are available.
diff --git a/scripts/update/post_update.sh b/scripts/update/post_update.sh
index 0401695d6..890b14c0a 100755
--- a/scripts/update/post_update.sh
+++ b/scripts/update/post_update.sh
@@ -228,6 +228,19 @@ if [ -f "$ENV_FILE" ]; then
     fi
 fi
 
+# Enforce ownership/mode on an existing /etc/innate.env no matter how it got there:
+# a hand-created file (sudo redirect/tee) ends up 600 root:root, which the non-root
+# launch readers can't open — print_runtime_env.py then treats it as absent and the
+# service key silently drops out of the runtime env (proxy "not configured").
+# Idempotent; matches the seeded state above. Contents are never touched.
+if [ -f "$SYSTEM_ENV_FILE" ]; then
+    if [ "$(stat -c '%U:%G %a' "$SYSTEM_ENV_FILE")" != "root:$ACTUAL_USER 640" ]; then
+        chown "root:$ACTUAL_USER" "$SYSTEM_ENV_FILE"
+        chmod 640 "$SYSTEM_ENV_FILE"
+        log "Fixed $SYSTEM_ENV_FILE ownership/mode to root:$ACTUAL_USER 640 so launch readers can read the service key"
+    fi
+fi
+
 # -----------------------------------------------------------------------------
 # 0a. Migrate user-created data into the post-refactor layout.
 # The refactor moved agents/skills/inputs under workspace/ and maps + nav-state
diff --git a/webapp/css/app.css b/webapp/css/app.css
index c9398be68..37dfb7f9f 100644
--- a/webapp/css/app.css
+++ b/webapp/css/app.css
@@ -872,97 +872,7 @@ button {
   color: var(--accent);
 }
 
-/* ---- pick-tuning panel (Teleop) ------------------------------------------ */
-
-/* Toggle sits under the telemetry card, left edge — same glass pulse-button
-   language as the profiling toggle. */
-.picktune-toggle {
-  position: absolute;
-  top: 92px;
-  left: 14px;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  width: 32px;
-  height: 32px;
-  padding: 0;
-  background: var(--glass);
-  backdrop-filter: blur(14px);
-  -webkit-backdrop-filter: blur(14px);
-  border: 1px solid var(--hairline);
-  border-radius: 9px;
-  color: var(--muted);
-  cursor: pointer;
-  transition: color 150ms ease, border-color 150ms ease;
-}
-
-.picktune-toggle:hover {
-  color: var(--text);
-  border-color: var(--hairline-strong);
-}
-
-.picktune-toggle.active {
-  color: var(--accent);
-  border-color: var(--accent-dim);
-}
-
-/* A pick run is streaming debug events — pulse green even while closed. */
-.picktune-toggle.running {
-  color: var(--ok);
-  border-color: var(--ok);
-}
-
-.picktune {
-  position: absolute;
-  top: 134px;
-  left: 14px;
-  z-index: 2;
-  width: 324px;
-  max-height: calc(100% - 148px);
-  overflow-y: auto;
-  padding: 11px 14px;
-  background: rgb(0 0 0 / 66%);
-  backdrop-filter: blur(20px);
-  -webkit-backdrop-filter: blur(20px);
-  border: 1px solid var(--hairline);
-  border-radius: 11px;
-  user-select: none;
-  -webkit-user-select: none;
-}
-
-.picktune-head {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  margin-bottom: 10px;
-}
-
-.picktune-head .profiling-hint {
-  margin-left: auto;
-}
-
-.picktune-sync {
-  font-size: 10px;
-  color: var(--muted);
-}
-
-.picktune-sync.live {
-  color: var(--ok);
-}
-
-.picktune-canvas {
-  display: block;
-  width: 296px;
-  height: 252px;
-  border: 1px solid var(--hairline);
-  border-radius: 8px;
-}
-
-/* Side (x–z) grasp view under the top-down view. */
-.picktune-canvas-side {
-  height: 150px;
-  margin-top: 8px;
-}
+/* ---- pick overlays (Teleop) ---------------------------------------------- */
 
 /* Grasp reticle over the live head video: the skill's grasp pixel, centered
    on (left,top) set in JS. Lives in .video-stage, drawn above the frame but
@@ -1000,22 +910,14 @@ button {
 }
 
 /* The positioning goal square on the video: put the detection inside this and
-   the base stops. Green while the skill reports the detection inside.
-   Draggable — moving it re-aims the skill (sweet_x / box_y). */
+   the base stops. Green while the skill reports the detection inside. */
 .picktune-boxgoal {
   position: absolute;
   z-index: 1;
   transform: translate(-50%, -50%);
   border: 1.5px dashed var(--accent-dim);
   border-radius: 2px;
-  pointer-events: auto;
-  cursor: grab;
-  touch-action: none;
-}
-
-.picktune-boxgoal.dragging {
-  cursor: grabbing;
-  border-color: var(--accent);
+  pointer-events: none;
 }
 
 /* Inner accept box: the point must land in THIS to stop positioning. Solid
@@ -1047,93 +949,6 @@ button {
   color: var(--ok);
 }
 
-.picktune-group {
-  margin-top: 10px;
-  margin-bottom: 4px;
-}
-
-.picktune-param {
-  display: grid;
-  grid-template-columns: 82px 1fr 64px;
-  align-items: center;
-  gap: 8px;
-  padding: 1px 0;
-}
-
-.picktune-param-label {
-  font-size: 11px;
-  color: var(--muted);
-  white-space: nowrap;
-}
-
-/* Overridden away from the code default — flag it. */
-.picktune-param.dirty .picktune-param-label {
-  color: var(--accent);
-}
-
-.picktune-param-value {
-  font-size: 11px;
-  color: var(--text);
-  text-align: right;
-  white-space: nowrap;
-}
-
-.picktune-slider {
-  width: 100%;
-  height: 3px;
-  appearance: none;
-  -webkit-appearance: none;
-  background: var(--hairline-strong);
-  border-radius: 2px;
-  outline: none;
-  cursor: pointer;
-}
-
-.picktune-slider::-webkit-slider-thumb {
-  appearance: none;
-  -webkit-appearance: none;
-  width: 11px;
-  height: 11px;
-  border-radius: 50%;
-  background: var(--text);
-  border: none;
-}
-
-.picktune-slider::-moz-range-thumb {
-  width: 11px;
-  height: 11px;
-  border-radius: 50%;
-  background: var(--text);
-  border: none;
-}
-
-.picktune-param.dirty .picktune-slider::-webkit-slider-thumb {
-  background: var(--accent);
-}
-
-.picktune-param.dirty .picktune-slider::-moz-range-thumb {
-  background: var(--accent);
-}
-
-.picktune-footer {
-  display: flex;
-  justify-content: flex-end;
-  margin: 10px 0;
-}
-
-.picktune-log {
-  margin-top: 4px;
-  max-height: 108px;
-  overflow-y: auto;
-  font-size: 10px;
-  line-height: 1.5;
-  color: var(--muted);
-}
-
-.picktune-log-line.warn {
-  color: var(--danger);
-}
-
 /* ---- record HUD (Collect page) ------------------------------------------ */
 
 .overlay-record {
diff --git a/webapp/js/constants.js b/webapp/js/constants.js
index 4873163e3..7436b13fa 100644
--- a/webapp/js/constants.js
+++ b/webapp/js/constants.js
@@ -132,11 +132,9 @@ export const PINNED_SKILLS = ["navigate with vision", "navigate with position",
 export const EXECUTE_SKILL_ACTION = "/execute_skill";
 export const EXECUTE_SKILL_ACTION_TYPE = "brain_messages/action/ExecuteSkill";
 
-// Pick-tuning panel (Teleop) <-> pick_any_object skill. DEBUG streams the
-// skill's stage events (std_msgs/String JSON: {ev, t, ...}); TUNING carries
-// live parameter overrides the same way ({param_key: number, ...}).
+// Pick overlays (Teleop) <- pick_any_object skill: the skill's stage events
+// (std_msgs/String JSON: {ev, t, ...}) drive the video-stage aim overlays.
 export const PICK_DEBUG_TOPIC = "/pick_any_object/debug";
-export const PICK_TUNING_TOPIC = "/pick_any_object/tuning";
 
 export const HEAD_MIN_DEG = -40;
 export const HEAD_MAX_DEG = 70;
diff --git a/webapp/js/teleop/main.js b/webapp/js/teleop/main.js
index 7c3213852..8bb373456 100644
--- a/webapp/js/teleop/main.js
+++ b/webapp/js/teleop/main.js
@@ -23,7 +23,7 @@ import { createTtsBar } from "./ttsBar.js";
 import { createTelemetry } from "./telemetry.js";
 import { createArmPanel } from "./armPanel.js";
 import { createProfilingPanel } from "./profilingPanel.js";
-import { createPickTunePanel } from "./pickTunePanel.js";
+import { createPickOverlay } from "./pickOverlay.js";
 import { createSkillsMenu } from "./skillsMenu.js";
 import { createCameraSwitch } from "./cameraSwitch.js";
 
@@ -93,7 +93,7 @@ function buildCockpit(root) {
     createSkillsMenu(ttsOverlay, ros),
     createArmPanel(armOverlay, ros, { hideServices: !!config.simControls }),
     ...(config.simControls ? [] : [createProfilingPanel(root, session)]),
-    createPickTunePanel(root, ros, session),
+    createPickOverlay(root, ros, session),
     createCameraSwitch(root, session, ros),
     keyboard,
   );
diff --git a/webapp/js/teleop/pickOverlay.js b/webapp/js/teleop/pickOverlay.js
new file mode 100644
index 000000000..cd9fb35bf
--- /dev/null
+++ b/webapp/js/teleop/pickOverlay.js
@@ -0,0 +1,339 @@
+// @ts-check
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2026 Innate Inc
+// Pick overlays — live aim feedback for the pick_any_object skill, drawn over
+// the video stage while a run is active (run_start → run_end on
+// /pick_any_object/debug). Nothing shows when the skill is idle.
+//
+// The skill reprojects its grasp target back onto the head frame and sends the
+// pixel (grab_px) on the debug topic. We draw a reticle over the live video at
+// that pixel — the actual spot on the floor the fingers will close on. The
+// detection pixel from each localize event gets its own marker (green box
+// corners) so you see where Gemini found the object vs where the arm will
+// grab; it clears whenever the base starts moving, since a stored pixel no
+// longer matches the shifted view, and reappears on the next localization.
+// The head video is object-fit:contain (letterboxed, never cropped), so the
+// 640×480 pixel maps to the screen with a single uniform scale + centering.
+// When the ARM (wrist) camera is on the big stage instead, the same stage
+// hosts the wrist-align overlays: the goal box in raw wrist-image pixels
+// (wrist_box_u/v) and the skill's wrist detection marker.
+
+import { PICK_DEBUG_TOPIC } from "../constants.js";
+
+// Display-only mirrors of the skill's aim defaults (TUNABLE in
+// pick_any_object.py) — the boxes are drawn from these, never written.
+const SWEET_X = 0.3;
+const BOX_Y = 0;
+const BOX_HALF_PX = 40;
+const ACCEPT_FRAC = 0.5;
+const TILT_DEG = -20;
+const WRIST_BOX_U = 320;
+const WRIST_BOX_V = 240;
+const WRIST_HALF_PX = 60;
+
+// Head-camera frame size the skill's grasp pixel is expressed in (IMG_W/IMG_H
+// in pick_any_object.py). Only a fallback — the live <video>'s intrinsic size
+// wins when known.
+const IMG = { w: 640, h: 480 };
+
+// Head-camera geometry, mirrored from pick_any_object.py (URDF values) so the
+// pick box can be drawn without asking the skill.
+const HEAD_ORIGIN = [-0.040751, -0.0002, 0.25882];
+const CAM_IN_HEAD = [0.04327, 0.0297, -0.000275];
+const HFOV_DEG = 70;
+const FX = IMG.w / (2 * Math.tan(((HFOV_DEG / 2) * Math.PI) / 180));
+
+/** Camera pose (position + axes) for a head tilt. @param {number} tiltDeg */
+function camPose(tiltDeg) {
+  const t = (tiltDeg * Math.PI) / 180;
+  const c = Math.cos(t);
+  const s = Math.sin(t);
+  /** @param {[number, number, number]} v */
+  const rot = (v) => [c * v[0] - s * v[2], v[1], s * v[0] + c * v[2]];
+  const r = rot(/** @type {[number, number, number]} */ (CAM_IN_HEAD));
+  return {
+    cam: [HEAD_ORIGIN[0] + r[0], HEAD_ORIGIN[1] + r[1], HEAD_ORIGIN[2] + r[2]],
+    fwd: rot([1, 0, 0]),
+    right: rot([0, -1, 0]),
+    down: rot([0, 0, -1]),
+  };
+}
+
+/** Floor point (base_link x,y, z=0) -> image pixel, or null behind the camera.
+ *  Mirror of floor_to_pixel in pick_any_object.py.
+ *  @param {number} x @param {number} y @param {number} tiltDeg */
+function floorToPixel(x, y, tiltDeg) {
+  const { cam, fwd, right, down } = camPose(tiltDeg);
+  const D = [x - cam[0], y - cam[1], -cam[2]];
+  const a = D[0] * fwd[0] + D[1] * fwd[1] + D[2] * fwd[2];
+  if (a <= 1e-6) return null;
+  const b = D[0] * right[0] + D[1] * right[1] + D[2] * right[2];
+  const cc = D[0] * down[0] + D[1] * down[1] + D[2] * down[2];
+  return { u: IMG.w / 2 + (b / a) * FX, v: IMG.h / 2 + (cc / a) * FX };
+}
+
+/**
+ * @param {HTMLElement} parent cockpit root — must contain the .video-stage.
+ * @param {import("../rosClient.js").RosClient} rosClient
+ * @param {import("../webrtcSession.js").WebRtcSession} [session]
+ *   Video session — tells us which camera fills the big stage: head-camera
+ *   overlays (reticle, pick box) only show on "main", wrist-align overlays
+ *   only on "arm" (a floor pixel is meaningless on the wrist cam and vice
+ *   versa).
+ * @returns {{ destroy: () => void }}
+ */
+export function createPickOverlay(parent, rosClient, session) {
+  const videoStage = /** @type {HTMLElement | null} */ (parent.querySelector(".video-stage"));
+
+  // Reticle drawn over the live video at the skill's grasp pixel.
+  const reticle = document.createElement("div");
+  reticle.className = "picktune-grab";
+  reticle.hidden = true;
+  reticle.innerHTML =
+    '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
+    'stroke-width="1.6" aria-hidden="true">' +
+    '<circle cx="24" cy="24" r="13"/>' +
+    '<line x1="24" y1="3" x2="24" y2="14"/><line x1="24" y1="34" x2="24" y2="45"/>' +
+    '<line x1="3" y1="24" x2="14" y2="24"/><line x1="34" y1="24" x2="45" y2="24"/>' +
+    '<circle cx="24" cy="24" r="2.2" fill="currentColor" stroke="none"/></svg>' +
+    '<span class="picktune-grab-tag mono">grasp target</span>';
+  if (videoStage) videoStage.appendChild(reticle);
+
+  // Detection marker: box corners around the pixel Gemini reported, in the
+  // detection color, so "seen here" and "grabbing here" read apart at a glance.
+  const seenMark = document.createElement("div");
+  seenMark.className = "picktune-grab picktune-seen";
+  seenMark.hidden = true;
+  seenMark.innerHTML =
+    '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
+    'stroke-width="1.6" aria-hidden="true">' +
+    '<path d="M8 16 V8 H16"/><path d="M32 8 H40 V16"/>' +
+    '<path d="M40 32 V40 H32"/><path d="M16 40 H8 V32"/></svg>' +
+    '<span class="picktune-grab-tag mono">detected</span>';
+  if (videoStage) videoStage.appendChild(seenMark);
+
+  // The pick box: the positioning goal square, shown only while a run is
+  // active. Turns green while the skill reports the detection inside it.
+  const boxGoal = document.createElement("div");
+  boxGoal.className = "picktune-boxgoal";
+  boxGoal.hidden = true;
+  // Inner accept box (ACCEPT_FRAC of the outer): the point must land in THIS
+  // to stop positioning. Greens when the skill reports inside; the outer stays
+  // a dim guide.
+  boxGoal.innerHTML =
+    '<span class="picktune-boxgoal-tag mono">pick box</span>' +
+    '<div class="picktune-boxaccept"></div>';
+  const boxAccept = /** @type {HTMLElement} */ (boxGoal.querySelector(".picktune-boxaccept"));
+  if (videoStage) videoStage.appendChild(boxGoal);
+
+  // The wrist box: the wrist-align goal square, shown when the ARM camera is
+  // on the big stage during a run. Same idea as the pick box, but in raw
+  // wrist-image pixels (wrist_box_u/v) — no floor projection, the wrist cam
+  // has none.
+  const wristBox = document.createElement("div");
+  wristBox.className = "picktune-boxgoal";
+  wristBox.hidden = true;
+  wristBox.innerHTML = '<span class="picktune-boxgoal-tag mono">wrist box</span>';
+  if (videoStage) videoStage.appendChild(wristBox);
+
+  // Wrist detection marker: where Gemini found the object on the wrist image.
+  const wristMark = document.createElement("div");
+  wristMark.className = "picktune-grab picktune-seen";
+  wristMark.hidden = true;
+  wristMark.innerHTML =
+    '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
+    'stroke-width="1.6" aria-hidden="true">' +
+    '<path d="M8 16 V8 H16"/><path d="M32 8 H40 V16"/>' +
+    '<path d="M40 32 V40 H32"/><path d="M16 40 H8 V32"/></svg>' +
+    '<span class="picktune-grab-tag mono">wrist detect</span>';
+  if (videoStage) videoStage.appendChild(wristMark);
+
+  // ---- state ---------------------------------------------------------------
+
+  /** Skill's grasp target in 640×480 image px, or null when none is active. @type {{ u: number, v: number } | null} */
+  let grabPx = null;
+  /** Latest detection pixel from localize; null after base motion shifts the view. @type {{ u: number, v: number } | null} */
+  let seenPx = null;
+  /** Latest wrist-camera detection pixel from wrist_align. @type {{ u: number, v: number } | null} */
+  let wristPx = null;
+  let running = false;
+
+  // ---- overlays over the live video ----------------------------------------
+
+  /** True when the head camera fills the big stage (a floor pixel only maps
+   *  onto that view). Defaults to true when no session was passed. */
+  function headCamPrimary() {
+    return !session || session.primaryCamera?.name === "main";
+  }
+
+  /** True when the wrist ("arm") camera fills the big stage — the view the
+   *  wrist-align box and detection marker live on. */
+  function wristCamPrimary() {
+    return session?.primaryCamera?.name === "arm";
+  }
+
+  /** Letterbox geometry of the live video inside the stage (object-fit:
+   *  contain → one uniform scale + symmetric offsets), or null when no video
+   *  is up. Camera-agnostic — both cams are 640×480 and the video's intrinsic
+   *  size wins; callers gate on WHICH camera is primary.
+   *  @returns {{ s: number, offX: number, offY: number } | null} */
+  function stageGeom() {
+    const video = /** @type {HTMLVideoElement | null} */ (videoStage?.querySelector("video"));
+    if (!video || !video.srcObject) return null;
+    const boxW = videoStage ? videoStage.clientWidth : 0;
+    const boxH = videoStage ? videoStage.clientHeight : 0;
+    if (!boxW || !boxH) return null;
+    const iw = video.videoWidth || IMG.w;
+    const ih = video.videoHeight || IMG.h;
+    const s = Math.min(boxW / iw, boxH / ih);
+    return { s, offX: (boxW - iw * s) / 2, offY: (boxH - ih * s) / 2 };
+  }
+
+  /** Position (or hide) the image-pixel markers and the goal boxes over the
+   *  video — head-camera overlays when the head cam is primary, wrist-camera
+   *  overlays when the arm cam is. The goal boxes only show while a run is
+   *  active; a stale aim frame over an idle robot reads as noise. */
+  function placeOverlays() {
+    const g = stageGeom();
+    const headG = g && headCamPrimary() ? g : null;
+    const wristG = g && wristCamPrimary() ? g : null;
+    const markers = [
+      { el: reticle, px: grabPx, geom: headG },
+      { el: seenMark, px: seenPx, geom: headG },
+      { el: wristMark, px: wristPx, geom: wristG },
+    ];
+    for (const { el, px, geom } of markers) {
+      if (!px || !geom) {
+        el.hidden = true;
+        continue;
+      }
+      el.style.left = `${geom.offX + px.u * geom.s}px`;
+      el.style.top = `${geom.offY + px.v * geom.s}px`;
+      el.hidden = false;
+    }
+    // The wrist-align goal square.
+    if (running && wristG) {
+      const side = 2 * WRIST_HALF_PX * wristG.s;
+      wristBox.style.left = `${wristG.offX + WRIST_BOX_U * wristG.s}px`;
+      wristBox.style.top = `${wristG.offY + WRIST_BOX_V * wristG.s}px`;
+      wristBox.style.width = `${side}px`;
+      wristBox.style.height = `${side}px`;
+      wristBox.hidden = false;
+    } else {
+      wristBox.hidden = true;
+    }
+    // The pick box goal square.
+    const center = running && headG ? floorToPixel(SWEET_X, BOX_Y, TILT_DEG) : null;
+    if (!headG || !center) {
+      boxGoal.hidden = true;
+      return;
+    }
+    const side = 2 * BOX_HALF_PX * headG.s;
+    boxGoal.style.left = `${headG.offX + center.u * headG.s}px`;
+    boxGoal.style.top = `${headG.offY + center.v * headG.s}px`;
+    boxGoal.style.width = `${side}px`;
+    boxGoal.style.height = `${side}px`;
+    // Inner accept box, centered, sized as a fraction of the outer.
+    const acceptPct = `${ACCEPT_FRAC * 100}%`;
+    boxAccept.style.width = acceptPct;
+    boxAccept.style.height = acceptPct;
+    boxGoal.hidden = false;
+  }
+
+  // Video letterbox geometry shifts on any stage resize; the overlays' validity
+  // also flips when the primary camera or the stream changes (switch to wrist
+  // cam, stream drop). Re-place on both so a mid-grasp camera switch is instant,
+  // not delayed to the next debug event.
+  const onResize = () => placeOverlays();
+  window.addEventListener("resize", onResize);
+  const unsubSession = session ? session.onChange(() => placeOverlays()) : null;
+
+  // ---- debug feed ---------------------------------------------------------
+
+  /** @param {any} ev */
+  function onDebugEvent(ev) {
+    switch (ev.ev) {
+      case "run_start":
+        grabPx = null;
+        seenPx = null;
+        wristPx = null;
+        boxGoal.classList.remove("inside");
+        wristBox.classList.remove("inside");
+        running = true;
+        break;
+      case "run_end":
+        running = false;
+        grabPx = null;
+        seenPx = null;
+        wristPx = null;
+        boxGoal.classList.remove("inside");
+        wristBox.classList.remove("inside");
+        break;
+      case "localize":
+        seenPx = Array.isArray(ev.px) ? { u: ev.px[0], v: ev.px[1] } : null;
+        break;
+      case "servo":
+        // High-rate (~10 Hz) optical-flow tracking updates during the follow:
+        // glide the marker to the tracked point and colour the box.
+        if (Array.isArray(ev.px)) seenPx = { u: ev.px[0], v: ev.px[1] };
+        boxGoal.classList.toggle("inside", ev.inside === true);
+        break;
+      case "position":
+        boxGoal.classList.toggle("inside", ev.inside === true);
+        break;
+      case "position_done":
+        if (!Array.isArray(ev.xy)) boxGoal.classList.remove("inside");
+        break;
+      case "rotate":
+      case "drive":
+        seenPx = null; // view is about to shift — the stored pixel goes stale
+        break;
+      case "grasp":
+        grabPx = Array.isArray(ev.grab_px) ? { u: ev.grab_px[0], v: ev.grab_px[1] } : null;
+        // Pin the "detected" marker to the object point so the amber grasp
+        // target and the green object marker sit side by side — their gap is
+        // the reach clamp (grasp aims short when the object is out of reach).
+        if (Array.isArray(ev.obj_px)) seenPx = { u: ev.obj_px[0], v: ev.obj_px[1] };
+        break;
+      case "wrist_seed":
+        // A Gemini look on the wrist image (initial seed or re-seed on loss).
+        wristPx = Array.isArray(ev.px) ? { u: ev.px[0], v: ev.px[1] } : null;
+        break;
+      case "wrist_servo":
+        // Per-cycle tracking during the servo descent: glide the marker,
+        // colour the box.
+        if (Array.isArray(ev.px)) wristPx = { u: ev.px[0], v: ev.px[1] };
+        wristBox.classList.toggle("inside", ev.inside === true);
+        break;
+      case "wrist_done":
+        // Refined grasp target — re-pin the head-view reticle to match.
+        grabPx = Array.isArray(ev.grab_px) ? { u: ev.grab_px[0], v: ev.grab_px[1] } : grabPx;
+        break;
+      default:
+        break;
+    }
+    placeOverlays();
+  }
+
+  const unsubDebug = rosClient.subscribe(PICK_DEBUG_TOPIC, (msg) => {
+    if (typeof msg?.data !== "string") return;
+    try {
+      onDebugEvent(JSON.parse(msg.data));
+    } catch {
+      // Not JSON — ignore.
+    }
+  });
+
+  return {
+    destroy() {
+      unsubDebug();
+      if (unsubSession) unsubSession();
+      window.removeEventListener("resize", onResize);
+      reticle.remove();
+      seenMark.remove();
+      boxGoal.remove();
+      wristBox.remove();
+      wristMark.remove();
+    },
+  };
+}
diff --git a/webapp/js/teleop/pickTunePanel.js b/webapp/js/teleop/pickTunePanel.js
deleted file mode 100644
index c95ea1107..000000000
--- a/webapp/js/teleop/pickTunePanel.js
+++ /dev/null
@@ -1,1237 +0,0 @@
-// @ts-check
-// SPDX-License-Identifier: Apache-2.0
-// Copyright (c) 2026 Innate Inc
-// Pick-tuning panel — a live workbench for iterating on the pick_any_object
-// skill's POSITION and GRASP stages. A crosshair toggle under the telemetry
-// card (or "o") opens it; hidden by default so the cockpit stays clean.
-//
-// Top: a top-down base_link view (robot at the bottom, +x forward/up) that
-// plots every metric localization the skill reports on /pick_any_object/debug,
-// with the sweet-spot ring, bearing/approach tolerance geometry, and the arm's
-// grasp-reach clamp box drawn from the *current* slider values — so you see a
-// run converge (or not) against the exact thresholds you set. Under it: a
-// side (x–z) view of the grasp — the planned hover→descend ladder from the
-// sliders, overlaid with the actual EE positions each stage reports, so a
-// missed grasp shows exactly where the descent diverged. Below: sliders
-// that publish overrides to /pick_any_object/tuning (applied live, mid-run,
-// by the skill) and a compact event log.
-//
-// The skill also reprojects its grasp target back onto the head frame and
-// sends the pixel (grab_px) on the debug topic. We draw a reticle over the
-// live video at that pixel — the actual spot on the floor the fingers will
-// close on — so you can watch the aim on the real image, not just the plot.
-// The detection pixel from each localize event gets its own marker (green box
-// corners) so you see where Gemini found the object vs where the arm will
-// grab; it clears whenever the base starts moving, since a stored pixel no
-// longer matches the shifted view, and reappears on the next localization.
-// The head video is object-fit:contain (letterboxed, never cropped), so the
-// 640×480 pixel maps to the screen with a single uniform scale + centering.
-// When the ARM (wrist) camera is on the big stage instead, the same stage
-// hosts the wrist-align overlays: a draggable goal box in raw wrist-image
-// pixels (wrist_box_u/v) and the skill's wrist detection marker.
-//
-// Sync protocol: overrides persist in localStorage and are re-published every
-// time the skill reports run_start, which closes the cold-start gap (the
-// skill only subscribes once its first run begins). The skill acks every
-// tuning message by echoing its live params; "live" in the header means the
-// last echo matches our sliders.
-
-import { PICK_DEBUG_TOPIC, PICK_TUNING_TOPIC } from "../constants.js";
-
-const TOGGLE_KEY = "KeyO";
-const STORAGE_KEY = "innate.pickTune.overrides";
-const PUBLISH_DEBOUNCE_MS = 120;
-const LOG_CAP = 40;
-
-// Grasp-target clamp in pick_any_object.py's _grasp_at — drawn as the reach box.
-const REACH = { xMin: 0.22, xMax: 0.4, yMax: 0.1 };
-
-/**
- * @typedef {{ key: string, label: string, unit: string, min: number, max: number, step: number, def: number }} ParamSpec
- */
-
-// Mirrors TUNABLE in workspace/custom_skills/pick_any_object.py — keep the
-// keys and defaults in sync (defaults here are what Reset publishes).
-/** @type {{ label: string, params: ParamSpec[] }[]} */
-const PARAM_GROUPS = [
-  {
-    // Position first: box x (forward) + box y (lateral) are the two coords the
-    // video drag writes, kept adjacent so the pair is obvious. box x can aim
-    // past the arm's ~0.43 m grasp reach — beyond that the grasp saturates at
-    // the reach clamp (positioning still works, the fingers just stop short).
-    label: "pick box (image goal)",
-    params: [
-      { key: "sweet_x", label: "box x", unit: "m", min: 0.2, max: 1.0, step: 0.005, def: 0.3 },
-      { key: "box_y", label: "box y", unit: "m", min: -0.12, max: 0.12, step: 0.005, def: 0 },
-      { key: "box_half_px", label: "box half", unit: "px", min: 15, max: 120, step: 5, def: 40 },
-      { key: "accept_frac", label: "accept", unit: "×", min: 0.2, max: 1, step: 0.05, def: 0.5 },
-      { key: "box_steps", label: "max steps", unit: "", min: 2, max: 10, step: 1, def: 6 },
-      { key: "bearing_go_deg", label: "bearing go", unit: "°", min: 1, max: 15, step: 0.5, def: 4 },
-    ],
-  },
-  {
-    // Pixel-servo gains for the optical-flow follower: rad/s (or m/s) per 100 px
-    // of tracked-point error from the box centre.
-    label: "follow (px servo)",
-    params: [
-      { key: "follow_gain_ang", label: "turn gain", unit: "", min: 0.05, max: 1.0, step: 0.05, def: 0.3 },
-      { key: "follow_gain_lin", label: "drive gain", unit: "", min: 0.01, max: 0.2, step: 0.01, def: 0.06 },
-    ],
-  },
-  {
-    label: "detect",
-    params: [
-      { key: "tilt_deg", label: "head tilt", unit: "°", min: -35, max: -10, step: 1, def: -20 },
-      { key: "settle_s", label: "settle", unit: "s", min: 0.2, max: 3, step: 0.1, def: 1.2 },
-    ],
-  },
-  {
-    label: "rotate loop",
-    params: [
-      { key: "rot_tol_deg", label: "tol", unit: "°", min: 0.5, max: 6, step: 0.25, def: 2.5 },
-      { key: "rot_kp", label: "kp", unit: "", min: 0.3, max: 3, step: 0.1, def: 1.2 },
-      { key: "rot_wz_max", label: "wz max", unit: "rad/s", min: 0.15, max: 0.8, step: 0.05, def: 0.5 },
-      { key: "rot_wz_min", label: "wz min", unit: "rad/s", min: 0.05, max: 0.3, step: 0.01, def: 0.15 },
-    ],
-  },
-  {
-    label: "drive loop",
-    params: [
-      { key: "drive_tol_m", label: "tol", unit: "m", min: 0.005, max: 0.05, step: 0.005, def: 0.015 },
-      { key: "drive_kp", label: "kp", unit: "", min: 0.1, max: 1, step: 0.05, def: 0.3 },
-      { key: "drive_v_max", label: "v max", unit: "m/s", min: 0.04, max: 0.2, step: 0.01, def: 0.1 },
-      { key: "drive_v_min", label: "v min", unit: "m/s", min: 0.02, max: 0.08, step: 0.005, def: 0.04 },
-    ],
-  },
-  {
-    // Wrist visual-servo descent: the hover goes to the operator's posed
-    // search position (up high, wrist camera on the object), Gemini seeds the
-    // object pixel there, then optical flow tracks it on wrist frames while
-    // the arm steps down, correcting x/y each cycle; z drops only while the
-    // point is inside the wrist box (drag it on the arm-camera view). Gains
-    // are SIGNED — the wrist cam is mirrored — so flip one live if the servo
-    // diverges instead of centering.
-    label: "wrist servo (arm cam)",
-    params: [
-      { key: "wrist_steps", label: "gemini seeds", unit: "", min: 0, max: 4, step: 1, def: 2 },
-      { key: "wrist_stop_z", label: "stop z", unit: "m", min: 0.02, max: 0.12, step: 0.005, def: 0.04 },
-      { key: "wrist_z_step", label: "z step", unit: "m", min: 0.005, max: 0.04, step: 0.005, def: 0.01 },
-      { key: "wrist_move_s", label: "step t", unit: "s", min: 0.2, max: 1.5, step: 0.1, def: 0.5 },
-      { key: "wrist_pitch", label: "pitch", unit: "rad", min: 0.6, max: 1.55, step: 0.01, def: 0.82 },
-      { key: "wrist_box_u", label: "box u", unit: "px", min: 0, max: 640, step: 5, def: 320 },
-      { key: "wrist_box_v", label: "box v", unit: "px", min: 0, max: 480, step: 5, def: 240 },
-      { key: "wrist_half_px", label: "box half", unit: "px", min: 20, max: 160, step: 5, def: 60 },
-      { key: "wrist_kx", label: "fwd gain", unit: "", min: -0.12, max: 0.12, step: 0.005, def: -0.04 },
-      { key: "wrist_ky", label: "lat gain", unit: "", min: -0.12, max: 0.12, step: 0.005, def: -0.04 },
-      { key: "wrist_step_max", label: "step max", unit: "m", min: 0.01, max: 0.08, step: 0.005, def: 0.04 },
-      { key: "wrist_settle_s", label: "settle", unit: "s", min: 0.2, max: 2, step: 0.1, def: 0.8 },
-    ],
-  },
-  {
-    label: "grasp descent",
-    params: [
-      { key: "grasp_x_off", label: "x offset", unit: "m", min: 0, max: 0.08, step: 0.005, def: 0.03 },
-      { key: "hover_z", label: "hover z", unit: "m", min: 0.08, max: 0.25, step: 0.005, def: 0.15 },
-      { key: "hover_s", label: "hover t", unit: "s", min: 0.8, max: 4, step: 0.1, def: 2 },
-      { key: "descend_z1", label: "step z1", unit: "m", min: 0.02, max: 0.14, step: 0.005, def: 0.1 },
-      { key: "descend_z2", label: "step z2", unit: "m", min: 0.01, max: 0.12, step: 0.005, def: 0.06 },
-      { key: "descend_z3", label: "step z3", unit: "m", min: 0, max: 0.1, step: 0.005, def: 0.03 },
-      { key: "floor_z", label: "floor z", unit: "m", min: 0, max: 0.05, step: 0.002, def: 0.01 },
-      { key: "descend_s", label: "step t", unit: "s", min: 0.4, max: 3, step: 0.1, def: 1.2 },
-      { key: "descend_abort_z", label: "abort z", unit: "m", min: 0.05, max: 0.2, step: 0.005, def: 0.12 },
-      { key: "arm_pitch", label: "pitch", unit: "rad", min: 1, max: 1.55, step: 0.01, def: 1.3 },
-    ],
-  },
-  {
-    label: "grasp close · lift",
-    params: [
-      { key: "close_strength", label: "strength", unit: "", min: 0.2, max: 1, step: 0.05, def: 0.6 },
-      { key: "close_s", label: "close t", unit: "s", min: 0.5, max: 3, step: 0.1, def: 1.5 },
-      { key: "close_settle_s", label: "settle", unit: "s", min: 0, max: 2, step: 0.1, def: 0.8 },
-      { key: "twist_rad", label: "twist", unit: "rad", min: 0, max: 1.4, step: 0.05, def: 0.6 },
-      { key: "lift_rad", label: "lift", unit: "rad", min: 0.2, max: 1.4, step: 0.05, def: 0.6 },
-    ],
-  },
-];
-
-/** @type {ParamSpec[]} */
-const ALL_PARAMS = PARAM_GROUPS.flatMap((g) => g.params);
-
-// Top-down view window in base_link meters: x (forward) up, y (left) left.
-// xMax spans the full box x range so the goal stays on-canvas at max reach-out.
-const VIEW = { xMin: -0.08, xMax: 1.08, canvasW: 296, canvasH: 252 };
-
-// Head-camera frame size the skill's grasp pixel is expressed in (IMG_W/IMG_H
-// in pick_any_object.py). Only a fallback — the live <video>'s intrinsic size
-// wins when known.
-const IMG = { w: 640, h: 480 };
-
-// Head-camera geometry, mirrored from pick_any_object.py (URDF values) so the
-// pick box can be drawn from the sliders without asking the skill.
-const HEAD_ORIGIN = [-0.040751, -0.0002, 0.25882];
-const CAM_IN_HEAD = [0.04327, 0.0297, -0.000275];
-const HFOV_DEG = 70;
-const FX = IMG.w / (2 * Math.tan(((HFOV_DEG / 2) * Math.PI) / 180));
-
-/** Camera pose (position + axes) for a head tilt. @param {number} tiltDeg */
-function camPose(tiltDeg) {
-  const t = (tiltDeg * Math.PI) / 180;
-  const c = Math.cos(t);
-  const s = Math.sin(t);
-  /** @param {[number, number, number]} v */
-  const rot = (v) => [c * v[0] - s * v[2], v[1], s * v[0] + c * v[2]];
-  const r = rot(/** @type {[number, number, number]} */ (CAM_IN_HEAD));
-  return {
-    cam: [HEAD_ORIGIN[0] + r[0], HEAD_ORIGIN[1] + r[1], HEAD_ORIGIN[2] + r[2]],
-    fwd: rot([1, 0, 0]),
-    right: rot([0, -1, 0]),
-    down: rot([0, 0, -1]),
-  };
-}
-
-/** Floor point (base_link x,y, z=0) -> image pixel, or null behind the camera.
- *  Mirror of floor_to_pixel in pick_any_object.py.
- *  @param {number} x @param {number} y @param {number} tiltDeg */
-function floorToPixel(x, y, tiltDeg) {
-  const { cam, fwd, right, down } = camPose(tiltDeg);
-  const D = [x - cam[0], y - cam[1], -cam[2]];
-  const a = D[0] * fwd[0] + D[1] * fwd[1] + D[2] * fwd[2];
-  if (a <= 1e-6) return null;
-  const b = D[0] * right[0] + D[1] * right[1] + D[2] * right[2];
-  const cc = D[0] * down[0] + D[1] * down[1] + D[2] * down[2];
-  return { u: IMG.w / 2 + (b / a) * FX, v: IMG.h / 2 + (cc / a) * FX };
-}
-
-/** Image pixel -> floor point, or null above the horizon.
- *  Mirror of pixel_to_floor in pick_any_object.py.
- *  @param {number} u @param {number} v @param {number} tiltDeg */
-function pixelToFloor(u, v, tiltDeg) {
-  const { cam, fwd, right, down } = camPose(tiltDeg);
-  const xo = (u - IMG.w / 2) / FX;
-  const yo = (v - IMG.h / 2) / FX;
-  const d = [0, 1, 2].map((i) => fwd[i] + xo * right[i] + yo * down[i]);
-  if (d[2] >= -1e-6) return null;
-  const t = -cam[2] / d[2];
-  return { x: cam[0] + t * d[0], y: cam[1] + t * d[1] };
-}
-
-/**
- * @param {HTMLElement} parent cockpit root — owns the toggle button + panel.
- * @param {import("../rosClient.js").RosClient} rosClient
- * @param {import("../webrtcSession.js").WebRtcSession} [session]
- *   Video session — tells us which camera fills the big stage: head-camera
- *   overlays (reticle, pick box) only show on "main", wrist-align overlays
- *   only on "arm" (a floor pixel is meaningless on the wrist cam and vice
- *   versa).
- * @returns {{ destroy: () => void }}
- */
-export function createPickTunePanel(parent, rosClient, session) {
-  const toggleBtn = document.createElement("button");
-  toggleBtn.type = "button";
-  toggleBtn.className = "picktune-toggle";
-  toggleBtn.title = "Pick tuning (o)";
-  toggleBtn.setAttribute("aria-label", "Toggle pick-tuning panel");
-  toggleBtn.innerHTML =
-    '<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" ' +
-    'stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">' +
-    '<circle cx="12" cy="12" r="7"/><line x1="12" y1="2" x2="12" y2="6"/>' +
-    '<line x1="12" y1="18" x2="12" y2="22"/><line x1="2" y1="12" x2="6" y2="12"/>' +
-    '<line x1="18" y1="12" x2="22" y2="12"/></svg>';
-
-  const wrap = document.createElement("div");
-  wrap.className = "picktune";
-  wrap.hidden = true;
-
-  const head = document.createElement("div");
-  head.className = "picktune-head";
-  const title = document.createElement("span");
-  title.className = "microlabel";
-  title.textContent = "pick tuning";
-  const sync = document.createElement("span");
-  sync.className = "picktune-sync mono";
-  sync.textContent = "defaults";
-  const hint = document.createElement("span");
-  hint.className = "profiling-hint mono";
-  hint.textContent = "o";
-  head.append(title, sync, hint);
-
-  const canvas = document.createElement("canvas");
-  canvas.className = "picktune-canvas";
-
-  const sideCanvas = document.createElement("canvas");
-  sideCanvas.className = "picktune-canvas picktune-canvas-side";
-
-  const paramsEl = document.createElement("div");
-  paramsEl.className = "picktune-params";
-
-  const footer = document.createElement("div");
-  footer.className = "picktune-footer";
-  const resetBtn = document.createElement("button");
-  resetBtn.type = "button";
-  resetBtn.className = "sim-button";
-  resetBtn.textContent = "Reset defaults";
-  footer.append(resetBtn);
-
-  const logHead = document.createElement("p");
-  logHead.className = "microlabel";
-  logHead.textContent = "events";
-  const logEl = document.createElement("div");
-  logEl.className = "picktune-log mono";
-
-  wrap.append(head, canvas, sideCanvas, paramsEl, footer, logHead, logEl);
-  parent.append(toggleBtn, wrap);
-
-  // Reticle drawn over the live video at the skill's grasp pixel. Lives in the
-  // video stage (not the panel) so it shows whether or not the panel is open,
-  // and its coordinate origin is the stage — the same box the <video> fills.
-  const videoStage = /** @type {HTMLElement | null} */ (parent.querySelector(".video-stage"));
-  const reticle = document.createElement("div");
-  reticle.className = "picktune-grab";
-  reticle.hidden = true;
-  reticle.innerHTML =
-    '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
-    'stroke-width="1.6" aria-hidden="true">' +
-    '<circle cx="24" cy="24" r="13"/>' +
-    '<line x1="24" y1="3" x2="24" y2="14"/><line x1="24" y1="34" x2="24" y2="45"/>' +
-    '<line x1="3" y1="24" x2="14" y2="24"/><line x1="34" y1="24" x2="45" y2="24"/>' +
-    '<circle cx="24" cy="24" r="2.2" fill="currentColor" stroke="none"/></svg>' +
-    '<span class="picktune-grab-tag mono">grasp target</span>';
-  if (videoStage) videoStage.appendChild(reticle);
-
-  // Detection marker: box corners around the pixel Gemini reported, in the
-  // detection color, so "seen here" and "grabbing here" read apart at a glance.
-  const seenMark = document.createElement("div");
-  seenMark.className = "picktune-grab picktune-seen";
-  seenMark.hidden = true;
-  seenMark.innerHTML =
-    '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
-    'stroke-width="1.6" aria-hidden="true">' +
-    '<path d="M8 16 V8 H16"/><path d="M32 8 H40 V16"/>' +
-    '<path d="M40 32 V40 H32"/><path d="M16 40 H8 V32"/></svg>' +
-    '<span class="picktune-grab-tag mono">detected</span>';
-  if (videoStage) videoStage.appendChild(seenMark);
-
-  // The pick box: the positioning goal square, drawn whenever the head video
-  // is up (it's the standing aim frame, not per-run state). Turns green while
-  // the skill reports the detection inside it.
-  const boxGoal = document.createElement("div");
-  boxGoal.className = "picktune-boxgoal";
-  boxGoal.hidden = true;
-  // Inner accept box (accept_frac of the outer): the point must land in THIS to
-  // stop positioning. Greens when the skill reports inside; the outer stays a
-  // dim guide. Sized in placeReticle from the accept_frac slider.
-  boxGoal.innerHTML =
-    '<span class="picktune-boxgoal-tag mono">pick box</span>' +
-    '<div class="picktune-boxaccept"></div>';
-  const boxAccept = /** @type {HTMLElement} */ (boxGoal.querySelector(".picktune-boxaccept"));
-  if (videoStage) videoStage.appendChild(boxGoal);
-
-  // The wrist box: the wrist-align goal square, shown when the ARM camera is
-  // on the big stage. Same idea as the pick box, but in raw wrist-image pixels
-  // (wrist_box_u/v) — no floor projection, the wrist cam has none. Draggable.
-  const wristBox = document.createElement("div");
-  wristBox.className = "picktune-boxgoal";
-  wristBox.hidden = true;
-  wristBox.innerHTML = '<span class="picktune-boxgoal-tag mono">wrist box</span>';
-  if (videoStage) videoStage.appendChild(wristBox);
-
-  // Wrist detection marker: where Gemini found the object on the wrist image.
-  const wristMark = document.createElement("div");
-  wristMark.className = "picktune-grab picktune-seen";
-  wristMark.hidden = true;
-  wristMark.innerHTML =
-    '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
-    'stroke-width="1.6" aria-hidden="true">' +
-    '<path d="M8 16 V8 H16"/><path d="M32 8 H40 V16"/>' +
-    '<path d="M40 32 V40 H32"/><path d="M16 40 H8 V32"/></svg>' +
-    '<span class="picktune-grab-tag mono">wrist detect</span>';
-  if (videoStage) videoStage.appendChild(wristMark);
-
-  // ---- state ---------------------------------------------------------------
-
-  /** Slider overrides (partial, key -> value). @type {Record<string, number>} */
-  let overrides = loadOverrides();
-  /** Params last echoed by the skill, or null before any echo. @type {Record<string, number> | null} */
-  let skillParams = null;
-  /** Localizations of the current run, in arrival order. @type {{ x: number, y: number, final: boolean }[]} */
-  let points = [];
-  /** @type {{ tx: number, ty: number } | null} */
-  let grasp = null;
-  /** EE positions the grasp stages report, in arrival order. @type {{ x: number, z: number, kind: "hover"|"descend"|"lift", ok?: boolean }[]} */
-  let armTrail = [];
-  /** Gripper joint before/after the close, from the "close" event. @type {{ open: number | undefined, closed: number | undefined } | null} */
-  let closeJ6 = null;
-  /** Skill's grasp target in 640×480 image px, or null when none is active. @type {{ u: number, v: number } | null} */
-  let grabPx = null;
-  /** Latest detection pixel from localize; null after base motion shifts the view. @type {{ u: number, v: number } | null} */
-  let seenPx = null;
-  /** Latest wrist-camera detection pixel from wrist_align. @type {{ u: number, v: number } | null} */
-  let wristPx = null;
-  let running = false;
-  /** @type {number | null} */
-  let publishTimer = null;
-  /** @type {Map<string, { row: HTMLElement, slider: HTMLInputElement, value: HTMLElement }>} */
-  const rows = new Map();
-
-  /** @returns {Record<string, number>} */
-  function loadOverrides() {
-    /** @type {Record<string, number>} */
-    const out = {};
-    try {
-      const parsed = JSON.parse(localStorage.getItem(STORAGE_KEY) ?? "{}");
-      for (const spec of ALL_PARAMS) {
-        const v = parsed?.[spec.key];
-        if (typeof v === "number" && Number.isFinite(v)) out[spec.key] = v;
-      }
-    } catch {
-      // Corrupt storage — start from code defaults.
-    }
-    return out;
-  }
-
-  function saveOverrides() {
-    try {
-      localStorage.setItem(STORAGE_KEY, JSON.stringify(overrides));
-    } catch {
-      // Storage unavailable (private mode) — tuning still works, just not remembered.
-    }
-  }
-
-  /** Effective value of a param: the override, else the code default. @param {ParamSpec} spec */
-  function valueOf(spec) {
-    return overrides[spec.key] ?? spec.def;
-  }
-
-  // ---- publishing ------------------------------------------------------------
-
-  /**
-   * Publish parameter values to the skill, debounced so slider drags don't
-   * flood rosbridge. `payload` is merged skill-side (unknown keys ignored).
-   * @param {Record<string, number>} payload
-   */
-  function publishTuning(payload) {
-    if (publishTimer !== null) clearTimeout(publishTimer);
-    publishTimer = window.setTimeout(() => {
-      publishTimer = null;
-      // The skill advertises/subscribes these topics at skills-server load
-      // (see guidelines() in pick_any_object.py), so this publish only fails
-      // when the server itself is down — the run_start republish then recovers.
-      if (rosClient.state === "connected") {
-        rosClient.publish(PICK_TUNING_TOPIC, { data: JSON.stringify(payload) });
-      }
-    }, PUBLISH_DEBOUNCE_MS);
-  }
-
-  function publishOverrides() {
-    if (Object.keys(overrides).length > 0) publishTuning(overrides);
-  }
-
-  // ---- params UI -------------------------------------------------------------
-
-  for (const group of PARAM_GROUPS) {
-    const groupLabel = document.createElement("p");
-    groupLabel.className = "microlabel picktune-group";
-    groupLabel.textContent = group.label;
-    paramsEl.appendChild(groupLabel);
-    for (const spec of group.params) paramsEl.appendChild(buildRow(spec));
-  }
-
-  /** @param {ParamSpec} spec */
-  function buildRow(spec) {
-    const row = document.createElement("div");
-    row.className = "picktune-param";
-
-    const label = document.createElement("span");
-    label.className = "picktune-param-label";
-    label.textContent = spec.label;
-
-    const slider = document.createElement("input");
-    slider.type = "range";
-    slider.className = "picktune-slider";
-    slider.min = String(spec.min);
-    slider.max = String(spec.max);
-    slider.step = String(spec.step);
-    slider.value = String(valueOf(spec));
-
-    const value = document.createElement("span");
-    value.className = "picktune-param-value mono";
-
-    slider.addEventListener("input", () => {
-      const v = Number(slider.value);
-      if (v === spec.def) delete overrides[spec.key];
-      else overrides[spec.key] = v;
-      saveOverrides();
-      // Send the full override set (idempotent merge) so a lost message never
-      // leaves the skill holding a stale sibling value.
-      publishTuning(Object.keys(overrides).length > 0 ? overrides : { [spec.key]: v });
-      syncRow(spec);
-      syncHeader();
-      draw();
-    });
-
-    row.append(label, slider, value);
-    rows.set(spec.key, { row, slider, value });
-    syncRow(spec);
-    return row;
-  }
-
-  /** Repaint one row: value text + dirty highlight. @param {ParamSpec} spec */
-  function syncRow(spec) {
-    const r = rows.get(spec.key);
-    if (!r) return;
-    const v = valueOf(spec);
-    const decimals = spec.step >= 1 ? 0 : spec.step >= 0.05 ? 2 : 3;
-    r.value.textContent = `${v.toFixed(decimals)}${spec.unit}`;
-    r.row.classList.toggle("dirty", spec.key in overrides);
-  }
-
-  /** Header pill: defaults / edited / live (skill echo matches sliders). */
-  function syncHeader() {
-    const dirty = Object.keys(overrides).length > 0;
-    let text = dirty ? "edited" : "defaults";
-    let live = false;
-    if (skillParams) {
-      live = ALL_PARAMS.every((spec) => {
-        const echoed = skillParams?.[spec.key];
-        return typeof echoed !== "number" || Math.abs(echoed - valueOf(spec)) < 1e-6;
-      });
-      if (live) text = dirty ? "live · edited" : "live · defaults";
-    }
-    sync.textContent = text;
-    sync.classList.toggle("live", live);
-  }
-
-  resetBtn.addEventListener("click", () => {
-    overrides = {};
-    saveOverrides();
-    // Explicit full-defaults publish so a running skill reverts immediately.
-    publishTuning(Object.fromEntries(ALL_PARAMS.map((s) => [s.key, s.def])));
-    for (const spec of ALL_PARAMS) {
-      const r = rows.get(spec.key);
-      if (r) r.slider.value = String(spec.def);
-      syncRow(spec);
-    }
-    syncHeader();
-    draw();
-  });
-
-  // ---- top-down canvas ---------------------------------------------------
-
-  const dpr = Math.min(window.devicePixelRatio || 1, 2);
-  canvas.width = VIEW.canvasW * dpr;
-  canvas.height = VIEW.canvasH * dpr;
-  const ctx = canvas.getContext("2d");
-  const scale = VIEW.canvasH / (VIEW.xMax - VIEW.xMin); // px per meter
-
-  // Side (x–z) view window for the grasp: forward right, up up. Spans the
-  // reach box plus margin; z covers floor to a little above max hover.
-  const SIDE = { xMin: 0.14, xMax: 0.48, zMin: -0.02, zMax: 0.28, canvasH: 150 };
-  sideCanvas.width = VIEW.canvasW * dpr;
-  sideCanvas.height = SIDE.canvasH * dpr;
-  const sctx = sideCanvas.getContext("2d");
-
-  /** base_link (x fwd, y left) -> canvas px. @param {number} x @param {number} y */
-  function toPx(x, y) {
-    return {
-      px: VIEW.canvasW / 2 - y * scale,
-      py: VIEW.canvasH - (x - VIEW.xMin) * scale,
-    };
-  }
-
-  function draw() {
-    if (!ctx || wrap.hidden) return;
-    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
-    ctx.clearRect(0, 0, VIEW.canvasW, VIEW.canvasH);
-    const css = getComputedStyle(wrap);
-    const cHair = css.getPropertyValue("--hairline") || "rgb(255 255 255 / 8%)";
-    const cHairStrong = css.getPropertyValue("--hairline-strong") || "rgb(255 255 255 / 16%)";
-    const cMuted = css.getPropertyValue("--muted") || "#8a8a93";
-    const cAccent = css.getPropertyValue("--accent") || "#e8a33d";
-    const cAccentDim = css.getPropertyValue("--accent-dim") || "rgb(232 163 61 / 40%)";
-    const cOk = css.getPropertyValue("--ok") || "#56c28c";
-
-    // 0.1 m grid.
-    ctx.lineWidth = 1;
-    ctx.strokeStyle = cHair;
-    ctx.beginPath();
-    for (let gx = 0; gx <= VIEW.xMax; gx += 0.1) {
-      const { py } = toPx(gx, 0);
-      ctx.moveTo(0, py);
-      ctx.lineTo(VIEW.canvasW, py);
-    }
-    const yHalf = VIEW.canvasW / 2 / scale;
-    for (let gy = 0; gy <= yHalf; gy += 0.1) {
-      for (const s of gy === 0 ? [0] : [-1, 1]) {
-        const { px } = toPx(0, gy * s);
-        ctx.moveTo(px, 0);
-        ctx.lineTo(px, VIEW.canvasH);
-      }
-    }
-    ctx.stroke();
-
-    const sweetX = valueOf(ALL_PARAMS.find((p) => p.key === "sweet_x") ?? PARAM_GROUPS[0].params[0]);
-    const bearingGo = ((overrides.bearing_go_deg ?? 4) * Math.PI) / 180;
-
-    // Bearing-go wedge from the robot origin.
-    const origin = toPx(0, 0);
-    ctx.strokeStyle = cHairStrong;
-    ctx.setLineDash([3, 4]);
-    ctx.beginPath();
-    for (const s of [-1, 1]) {
-      const end = toPx(0.72 * Math.cos(bearingGo), 0.72 * Math.sin(bearingGo) * s);
-      ctx.moveTo(origin.px, origin.py);
-      ctx.lineTo(end.px, end.py);
-    }
-    ctx.stroke();
-
-    // Sweet-spot ring (distance target).
-    ctx.strokeStyle = cAccentDim;
-    ctx.beginPath();
-    ctx.arc(origin.px, origin.py, sweetX * scale, -Math.PI / 2 - 0.5, -Math.PI / 2 + 0.5);
-    ctx.stroke();
-    ctx.setLineDash([]);
-
-    // Pick box footprint: the image-goal square back-projected onto the floor.
-    // Outer = the drawn box (box_half_px); inner = the accept box the detection
-    // must land in to stop positioning (accept_frac × outer, solid).
-    const center = floorToPixel(sweetX, paramValue("box_y"), paramValue("tilt_deg"));
-    if (center) {
-      const half = paramValue("box_half_px");
-      const tilt = paramValue("tilt_deg");
-      /** @param {number} h @param {string} color */
-      const footprint = (h, color) => {
-        const corners = [
-          [-h, -h],
-          [h, -h],
-          [h, h],
-          [-h, h],
-        ].map(([du, dv]) => pixelToFloor(center.u + du, center.v + dv, tilt));
-        if (!corners.every(Boolean)) return;
-        ctx.strokeStyle = color;
-        ctx.beginPath();
-        corners.forEach((pt, i) => {
-          const { px, py } = toPx(/** @type {any} */ (pt).x, /** @type {any} */ (pt).y);
-          if (i === 0) ctx.moveTo(px, py);
-          else ctx.lineTo(px, py);
-        });
-        ctx.closePath();
-        ctx.stroke();
-      };
-      ctx.setLineDash([3, 3]);
-      footprint(half, cAccentDim);
-      ctx.setLineDash([]);
-      footprint(half * paramValue("accept_frac"), cAccent);
-    }
-
-    // Arm-reach clamp box (grasp tx/ty limits).
-    const boxA = toPx(REACH.xMax, REACH.yMax);
-    const boxB = toPx(REACH.xMin, -REACH.yMax);
-    ctx.strokeStyle = cMuted;
-    ctx.setLineDash([2, 3]);
-    ctx.strokeRect(boxA.px, boxA.py, boxB.px - boxA.px, boxB.py - boxA.py);
-    ctx.setLineDash([]);
-
-    // Aim-point crosshair (box centre on the floor).
-    const sweet = toPx(sweetX, paramValue("box_y"));
-    ctx.strokeStyle = cAccent;
-    ctx.beginPath();
-    ctx.moveTo(sweet.px - 5, sweet.py);
-    ctx.lineTo(sweet.px + 5, sweet.py);
-    ctx.moveTo(sweet.px, sweet.py - 5);
-    ctx.lineTo(sweet.px, sweet.py + 5);
-    ctx.stroke();
-
-    // Robot base at origin with a forward notch.
-    ctx.strokeStyle = cMuted;
-    const half = 0.09 * scale;
-    ctx.strokeRect(origin.px - half, origin.py - 0.06 * scale, half * 2, 0.12 * scale);
-    ctx.beginPath();
-    ctx.moveTo(origin.px, origin.py - 0.06 * scale);
-    ctx.lineTo(origin.px, origin.py - 0.1 * scale);
-    ctx.stroke();
-
-    // Localization trail: older estimates dim, the latest bright; the run's
-    // final (position_done) estimate ringed in green.
-    ctx.strokeStyle = cHairStrong;
-    ctx.beginPath();
-    points.forEach((pt, i) => {
-      const { px, py } = toPx(pt.x, pt.y);
-      if (i === 0) ctx.moveTo(px, py);
-      else ctx.lineTo(px, py);
-    });
-    ctx.stroke();
-    points.forEach((pt, i) => {
-      const { px, py } = toPx(pt.x, pt.y);
-      const last = i === points.length - 1;
-      ctx.fillStyle = last ? cAccent : cMuted;
-      ctx.beginPath();
-      ctx.arc(px, py, last ? 4 : 2.5, 0, Math.PI * 2);
-      ctx.fill();
-      if (pt.final) {
-        ctx.strokeStyle = cOk;
-        ctx.beginPath();
-        ctx.arc(px, py, 6.5, 0, Math.PI * 2);
-        ctx.stroke();
-      }
-    });
-
-    // Grasp target (post-clamp tx/ty) as a hollow diamond.
-    if (grasp) {
-      const { px, py } = toPx(grasp.tx, grasp.ty);
-      ctx.strokeStyle = cAccent;
-      ctx.beginPath();
-      ctx.moveTo(px, py - 5);
-      ctx.lineTo(px + 5, py);
-      ctx.lineTo(px, py + 5);
-      ctx.lineTo(px - 5, py);
-      ctx.closePath();
-      ctx.stroke();
-    }
-
-    drawSide();
-    placeReticle();
-  }
-
-  /** Effective value by key (override else code default). @param {string} key */
-  function paramValue(key) {
-    const spec = ALL_PARAMS.find((s) => s.key === key);
-    return spec ? valueOf(spec) : 0;
-  }
-
-  /** base_link (x fwd, z up) -> side-canvas px. @param {number} x @param {number} z */
-  function toSidePx(x, z) {
-    return {
-      px: ((x - SIDE.xMin) / (SIDE.xMax - SIDE.xMin)) * VIEW.canvasW,
-      py: SIDE.canvasH - ((z - SIDE.zMin) / (SIDE.zMax - SIDE.zMin)) * SIDE.canvasH,
-    };
-  }
-
-  /** Side view: planned hover→descend ladder from the sliders, the abort
-   *  threshold, and the EE positions the running grasp actually reported. */
-  function drawSide() {
-    if (!sctx || wrap.hidden) return;
-    sctx.setTransform(dpr, 0, 0, dpr, 0, 0);
-    sctx.clearRect(0, 0, VIEW.canvasW, SIDE.canvasH);
-    const css = getComputedStyle(wrap);
-    const cHair = css.getPropertyValue("--hairline") || "rgb(255 255 255 / 8%)";
-    const cHairStrong = css.getPropertyValue("--hairline-strong") || "rgb(255 255 255 / 16%)";
-    const cMuted = css.getPropertyValue("--muted") || "#8a8a93";
-    const cText = css.getPropertyValue("--text") || "#e7e7ea";
-    const cAccent = css.getPropertyValue("--accent") || "#e8a33d";
-    const cOk = css.getPropertyValue("--ok") || "#56c28c";
-    const cDanger = css.getPropertyValue("--danger") || "#d96a5a";
-
-    // Grid: 0.1 m in x, 0.05 m in z.
-    sctx.lineWidth = 1;
-    sctx.strokeStyle = cHair;
-    sctx.beginPath();
-    for (let gx = Math.ceil(SIDE.xMin * 10) / 10; gx <= SIDE.xMax; gx += 0.1) {
-      const { px } = toSidePx(gx, 0);
-      sctx.moveTo(px, 0);
-      sctx.lineTo(px, SIDE.canvasH);
-    }
-    for (let gz = 0.05; gz <= SIDE.zMax; gz += 0.05) {
-      const { py } = toSidePx(0, gz);
-      sctx.moveTo(0, py);
-      sctx.lineTo(VIEW.canvasW, py);
-    }
-    sctx.stroke();
-
-    // The floor, and the descend-abort threshold above it.
-    const floor = toSidePx(SIDE.xMin, 0);
-    sctx.strokeStyle = cHairStrong;
-    sctx.beginPath();
-    sctx.moveTo(0, floor.py);
-    sctx.lineTo(VIEW.canvasW, floor.py);
-    sctx.stroke();
-    const abortY = toSidePx(0, paramValue("descend_abort_z")).py;
-    sctx.strokeStyle = cDanger;
-    sctx.setLineDash([2, 4]);
-    sctx.beginPath();
-    sctx.moveTo(0, abortY);
-    sctx.lineTo(VIEW.canvasW, abortY);
-    sctx.stroke();
-    sctx.setLineDash([]);
-
-    // Planned ladder at the run's clamped tx (else derived from the sliders):
-    // hover → z1 → z2 → z3 → floor, with the wrist-pitch pointer at hover.
-    const sweetX = paramValue("sweet_x");
-    const lx = grasp ? grasp.tx : Math.max(REACH.xMin, Math.min(REACH.xMax, sweetX - paramValue("grasp_x_off")));
-    const hoverZ = paramValue("hover_z");
-    const ladder = [hoverZ, paramValue("descend_z1"), paramValue("descend_z2"), paramValue("descend_z3"), paramValue("floor_z")];
-    sctx.strokeStyle = cHairStrong;
-    sctx.setLineDash([2, 3]);
-    sctx.beginPath();
-    const top = toSidePx(lx, hoverZ);
-    const bottom = toSidePx(lx, ladder[ladder.length - 1]);
-    sctx.moveTo(top.px, top.py);
-    sctx.lineTo(bottom.px, bottom.py);
-    sctx.stroke();
-    sctx.setLineDash([]);
-    for (const z of ladder) {
-      const { px, py } = toSidePx(lx, z);
-      sctx.strokeStyle = z === hoverZ ? cAccent : cMuted;
-      sctx.beginPath();
-      if (z === hoverZ) {
-        sctx.arc(px, py, 4, 0, Math.PI * 2);
-      } else {
-        sctx.moveTo(px - 4, py);
-        sctx.lineTo(px + 4, py);
-      }
-      sctx.stroke();
-    }
-    // Pitch pointer: the wrist approach direction at the hover point.
-    const pitch = paramValue("arm_pitch");
-    sctx.strokeStyle = cAccent;
-    sctx.beginPath();
-    sctx.moveTo(top.px, top.py);
-    const tip = toSidePx(lx + 0.05 * Math.cos(pitch), hoverZ - 0.05 * Math.sin(pitch));
-    sctx.lineTo(tip.px, tip.py);
-    sctx.stroke();
-
-    // Actual EE trail from the run's hover/descend/lift events.
-    sctx.strokeStyle = cHairStrong;
-    sctx.beginPath();
-    armTrail.forEach((pt, i) => {
-      const { px, py } = toSidePx(pt.x, pt.z);
-      if (i === 0) sctx.moveTo(px, py);
-      else sctx.lineTo(px, py);
-    });
-    sctx.stroke();
-    armTrail.forEach((pt, i) => {
-      const { px, py } = toSidePx(pt.x, pt.z);
-      const last = i === armTrail.length - 1;
-      sctx.fillStyle =
-        pt.kind === "descend" && pt.ok === false ? cDanger : pt.kind === "lift" ? cOk : last ? cAccent : cText;
-      sctx.beginPath();
-      sctx.arc(px, py, last ? 4 : 2.5, 0, Math.PI * 2);
-      sctx.fill();
-      if (pt.kind === "lift") {
-        sctx.strokeStyle = cOk;
-        sctx.beginPath();
-        sctx.arc(px, py, 6.5, 0, Math.PI * 2);
-        sctx.stroke();
-      }
-    });
-
-    // Close outcome, bottom-left: gripper joint before → after the squeeze.
-    if (closeJ6) {
-      sctx.fillStyle = cMuted;
-      sctx.font = "10px " + (css.getPropertyValue("--font-mono") || "monospace");
-      const fmt = (/** @type {number | undefined} */ v) => (typeof v === "number" ? v.toFixed(3) : "?");
-      sctx.fillText(`close j6 ${fmt(closeJ6.open)} → ${fmt(closeJ6.closed)}`, 6, SIDE.canvasH - 6);
-    }
-  }
-
-  // ---- grasp reticle over the live video ----------------------------------
-
-  /** True when the head camera fills the big stage (a floor pixel only maps
-   *  onto that view). Defaults to true when no session was passed. */
-  function headCamPrimary() {
-    return !session || session.primaryCamera?.name === "main";
-  }
-
-  /** True when the wrist ("arm") camera fills the big stage — the view the
-   *  wrist-align box and detection marker live on. */
-  function wristCamPrimary() {
-    return session?.primaryCamera?.name === "arm";
-  }
-
-  /** Letterbox geometry of the live video inside the stage (object-fit:
-   *  contain → one uniform scale + symmetric offsets), or null when no video
-   *  is up. Camera-agnostic — both cams are 640×480 and the video's intrinsic
-   *  size wins; callers gate on WHICH camera is primary.
-   *  @returns {{ s: number, offX: number, offY: number } | null} */
-  function stageGeom() {
-    const video = /** @type {HTMLVideoElement | null} */ (videoStage?.querySelector("video"));
-    if (!video || !video.srcObject) return null;
-    const boxW = videoStage ? videoStage.clientWidth : 0;
-    const boxH = videoStage ? videoStage.clientHeight : 0;
-    if (!boxW || !boxH) return null;
-    const iw = video.videoWidth || IMG.w;
-    const ih = video.videoHeight || IMG.h;
-    const s = Math.min(boxW / iw, boxH / ih);
-    return { s, offX: (boxW - iw * s) / 2, offY: (boxH - ih * s) / 2 };
-  }
-
-  /** Position (or hide) the image-pixel markers and the goal boxes over the
-   *  video — head-camera overlays when the head cam is primary, wrist-camera
-   *  overlays when the arm cam is. */
-  function placeReticle() {
-    const g = stageGeom();
-    const headG = g && headCamPrimary() ? g : null;
-    const wristG = g && wristCamPrimary() ? g : null;
-    const markers = [
-      { el: reticle, px: grabPx, geom: headG },
-      { el: seenMark, px: seenPx, geom: headG },
-      { el: wristMark, px: wristPx, geom: wristG },
-    ];
-    for (const { el, px, geom } of markers) {
-      if (!px || !geom) {
-        el.hidden = true;
-        continue;
-      }
-      el.style.left = `${geom.offX + px.u * geom.s}px`;
-      el.style.top = `${geom.offY + px.v * geom.s}px`;
-      el.hidden = false;
-    }
-    // The wrist-align goal square, straight from the pixel sliders.
-    if (wristG) {
-      const side = 2 * paramValue("wrist_half_px") * wristG.s;
-      wristBox.style.left = `${wristG.offX + paramValue("wrist_box_u") * wristG.s}px`;
-      wristBox.style.top = `${wristG.offY + paramValue("wrist_box_v") * wristG.s}px`;
-      wristBox.style.width = `${side}px`;
-      wristBox.style.height = `${side}px`;
-      wristBox.hidden = false;
-    } else {
-      wristBox.hidden = true;
-    }
-    // The pick box goal square, from the current sliders.
-    const center = headG ? floorToPixel(paramValue("sweet_x"), paramValue("box_y"), paramValue("tilt_deg")) : null;
-    if (!headG || !center) {
-      boxGoal.hidden = true;
-      return;
-    }
-    const side = 2 * paramValue("box_half_px") * headG.s;
-    boxGoal.style.left = `${headG.offX + center.u * headG.s}px`;
-    boxGoal.style.top = `${headG.offY + center.v * headG.s}px`;
-    boxGoal.style.width = `${side}px`;
-    boxGoal.style.height = `${side}px`;
-    // Inner accept box, centered, sized as a fraction of the outer.
-    const acceptPct = `${paramValue("accept_frac") * 100}%`;
-    boxAccept.style.width = acceptPct;
-    boxAccept.style.height = acceptPct;
-    boxGoal.hidden = false;
-  }
-
-  // Video letterbox geometry shifts on any stage resize; the reticle's validity
-  // also flips when the primary camera or the stream changes (switch to wrist
-  // cam, stream drop). Re-place on both so a mid-grasp camera switch is instant,
-  // not delayed to the next debug event.
-  const onResize = () => placeReticle();
-  window.addEventListener("resize", onResize);
-  const unsubSession = session ? session.onChange(() => placeReticle()) : null;
-
-  // ---- drag the pick box on the video ---------------------------------------
-  // Dragging converts the cursor back to a floor point (pixelToFloor) and
-  // writes it into the same tunables the skill aims at: sweet_x (forward) and
-  // box_y (lateral). Sliders, overrides, and the skill stay in sync — the box
-  // is the tool, the params are the truth.
-
-  /** Set a param as if its slider was moved: snap to step, clamp to range,
-   *  update the row UI and the override map. @param {string} key @param {number} v */
-  function setParamValue(key, v) {
-    const spec = ALL_PARAMS.find((p) => p.key === key);
-    const r = rows.get(key);
-    if (!spec || !r) return;
-    const snapped = Math.max(spec.min, Math.min(spec.max, Math.round(v / spec.step) * spec.step));
-    r.slider.value = String(snapped);
-    if (Math.abs(snapped - spec.def) < 1e-9) delete overrides[key];
-    else overrides[key] = snapped;
-    syncRow(spec);
-  }
-
-  let draggingBox = false;
-
-  /** @param {PointerEvent} e */
-  function dragBoxTo(e) {
-    const g = stageGeom();
-    if (!g || !videoStage) return;
-    const rect = videoStage.getBoundingClientRect();
-    const u = (e.clientX - rect.left - g.offX) / g.s;
-    const v = (e.clientY - rect.top - g.offY) / g.s;
-    const f = pixelToFloor(u, v, paramValue("tilt_deg"));
-    if (!f) return; // above the horizon — no floor point there
-    setParamValue("sweet_x", f.x);
-    setParamValue("box_y", f.y);
-    saveOverrides();
-    // Explicit effective values: a drag back to defaults must still reach a
-    // skill that holds the old aim.
-    publishTuning({ ...overrides, sweet_x: paramValue("sweet_x"), box_y: paramValue("box_y") });
-    syncHeader();
-    draw(); // re-derives the box from the (clamped) params — cursor stays honest
-    placeReticle();
-  }
-
-  boxGoal.addEventListener("pointerdown", (e) => {
-    if (!stageGeom()) return;
-    draggingBox = true;
-    boxGoal.classList.add("dragging");
-    boxGoal.setPointerCapture(e.pointerId);
-    e.preventDefault();
-  });
-  boxGoal.addEventListener("pointermove", (e) => {
-    if (draggingBox) dragBoxTo(e);
-  });
-  const endBoxDrag = () => {
-    draggingBox = false;
-    boxGoal.classList.remove("dragging");
-  };
-  boxGoal.addEventListener("pointerup", endBoxDrag);
-  boxGoal.addEventListener("pointercancel", endBoxDrag);
-
-  // Drag the wrist box on the arm-camera view — writes wrist_box_u/v (raw
-  // wrist-image pixels) into the same slider/override machinery.
-  let draggingWrist = false;
-
-  /** @param {PointerEvent} e */
-  function dragWristTo(e) {
-    const g = stageGeom();
-    if (!g || !videoStage) return;
-    const rect = videoStage.getBoundingClientRect();
-    setParamValue("wrist_box_u", (e.clientX - rect.left - g.offX) / g.s);
-    setParamValue("wrist_box_v", (e.clientY - rect.top - g.offY) / g.s);
-    saveOverrides();
-    // Explicit effective values — a drag back to defaults must still reach a
-    // skill that holds the old aim.
-    publishTuning({ ...overrides, wrist_box_u: paramValue("wrist_box_u"), wrist_box_v: paramValue("wrist_box_v") });
-    syncHeader();
-    placeReticle();
-  }
-
-  wristBox.addEventListener("pointerdown", (e) => {
-    if (!stageGeom()) return;
-    draggingWrist = true;
-    wristBox.classList.add("dragging");
-    wristBox.setPointerCapture(e.pointerId);
-    e.preventDefault();
-  });
-  wristBox.addEventListener("pointermove", (e) => {
-    if (draggingWrist) dragWristTo(e);
-  });
-  const endWristDrag = () => {
-    draggingWrist = false;
-    wristBox.classList.remove("dragging");
-  };
-  wristBox.addEventListener("pointerup", endWristDrag);
-  wristBox.addEventListener("pointercancel", endWristDrag);
-
-  // ---- event log + debug feed ---------------------------------------------
-
-  /** @param {string} line @param {boolean} [warn] */
-  function logLine(line, warn = false) {
-    const el = document.createElement("div");
-    el.className = "picktune-log-line" + (warn ? " warn" : "");
-    el.textContent = line;
-    logEl.appendChild(el);
-    while (logEl.childElementCount > LOG_CAP) logEl.firstElementChild?.remove();
-    logEl.scrollTop = logEl.scrollHeight;
-  }
-
-  /** @param {number | undefined} n @param {number} [d] */
-  const num = (n, d = 2) => (typeof n === "number" ? n.toFixed(d) : "?");
-
-  /** @param {any} ev */
-  function onDebugEvent(ev) {
-    switch (ev.ev) {
-      case "run_start":
-        points = [];
-        grasp = null;
-        armTrail = [];
-        closeJ6 = null;
-        grabPx = null;
-        seenPx = null;
-        wristPx = null;
-        boxGoal.classList.remove("inside");
-        wristBox.classList.remove("inside");
-        running = true;
-        skillParams = ev.params ?? skillParams;
-        logLine(`run start "${ev.prompt ?? ""}"`);
-        // The skill just (re)subscribed — reassert our overrides so a fresh
-        // instance never runs on stale/default values while sliders say otherwise.
-        publishOverrides();
-        break;
-      case "run_end":
-        running = false;
-        grabPx = null;
-        seenPx = null;
-        wristPx = null;
-        boxGoal.classList.remove("inside");
-        wristBox.classList.remove("inside");
-        logLine("run end");
-        break;
-      case "params":
-        // No log line — the header's live/edited pill reflects it, and after
-        // hot-reloads retired skill instances echo too (identical acks).
-        skillParams = ev.params ?? null;
-        break;
-      case "localize":
-        seenPx = Array.isArray(ev.px) ? { u: ev.px[0], v: ev.px[1] } : null;
-        if (Array.isArray(ev.xy)) {
-          points.push({ x: ev.xy[0], y: ev.xy[1], final: false });
-          logLine(`loc px(${num(ev.px?.[0], 0)},${num(ev.px?.[1], 0)}) → (${num(ev.xy[0], 3)}, ${num(ev.xy[1], 3)})`);
-        } else {
-          logLine("loc — not found", true);
-        }
-        break;
-      case "servo":
-        // High-rate (~10 Hz) optical-flow tracking updates during the follow.
-        // Glide the marker to the tracked point and colour the box; no log line
-        // (per-tick logging would swamp the event feed).
-        if (Array.isArray(ev.px)) seenPx = { u: ev.px[0], v: ev.px[1] };
-        boxGoal.classList.toggle("inside", ev.inside === true);
-        break;
-      case "position":
-        boxGoal.classList.toggle("inside", ev.inside === true);
-        logLine(
-          `pos ${num(ev.step, 0)}: px(${num(ev.px?.[0], 0)},${num(ev.px?.[1], 0)}) ` +
-            (ev.inside ? "IN box" : "out — correcting"),
-          false,
-        );
-        break;
-      case "position_done":
-        if (Array.isArray(ev.xy)) {
-          const last = points[points.length - 1];
-          if (last && last.x === ev.xy[0] && last.y === ev.xy[1]) last.final = true;
-          const n = ev.attempts ?? ev.steps;
-          logLine(`pos done — in box${typeof n === "number" ? ` (${n} re-detects)` : ""}`);
-        } else {
-          boxGoal.classList.remove("inside");
-          logLine(`pos failed — ${ev.reason ?? "lost object"}`, true);
-        }
-        break;
-      case "rotate":
-        seenPx = null; // view is about to shift — the stored pixel goes stale
-        logLine(`rot ${num(ev.angle_deg, 1)}°`);
-        break;
-      case "rotate_done":
-        logLine(`rot done err ${num(ev.err_deg, 1)}° in ${num(ev.s, 1)}s`);
-        break;
-      case "drive":
-        seenPx = null; // same — the base is moving under the camera
-        logLine(`drv ${num(ev.dist_m, 3)}m`);
-        break;
-      case "drive_done":
-        logLine(`drv done err ${num(ev.err_m, 3)}m in ${num(ev.s, 1)}s`);
-        break;
-      case "grasp":
-        // A fresh attempt (the deep retry re-enters here) — clear the old trail.
-        grasp = { tx: ev.tx, ty: ev.ty };
-        armTrail = [];
-        closeJ6 = null;
-        grabPx = Array.isArray(ev.grab_px) ? { u: ev.grab_px[0], v: ev.grab_px[1] } : null;
-        // Pin the "detected" marker to the object point so the amber grasp
-        // target and the green object marker sit side by side — their gap is
-        // the reach clamp (grasp aims short when the object is out of reach).
-        if (Array.isArray(ev.obj_px)) seenPx = { u: ev.obj_px[0], v: ev.obj_px[1] };
-        logLine(
-          `grasp tx ${num(ev.tx, 3)} ty ${num(ev.ty, 3)}${ev.deep ? " (deep)" : ""}` +
-            (ev.clamped ? " — REACH-CLAMPED: grasp short of object (lower box x)" : ""),
-          ev.clamped === true,
-        );
-        break;
-      case "hover":
-        if (Array.isArray(ev.ee)) armTrail.push({ x: ev.ee[0], z: ev.ee[2], kind: "hover" });
-        logLine(`hover ee z ${num(ev.ee?.[2], 3)}`);
-        break;
-      case "wrist_seed":
-        // A Gemini look on the wrist image (initial seed or re-seed on loss).
-        wristPx = Array.isArray(ev.px) ? { u: ev.px[0], v: ev.px[1] } : null;
-        if (wristPx) {
-          logLine(`wrist seed px(${num(ev.px?.[0], 0)},${num(ev.px?.[1], 0)}) @z ${num(ev.z, 2)}`);
-        } else {
-          logLine("wrist seed — not seen", true);
-        }
-        break;
-      case "wrist_servo":
-        // Per-cycle optical-flow tracking during the servo descent: glide the
-        // marker, colour the box, extend the side-view EE trail. No log line
-        // (a full descent is ~10-20 cycles and would swamp the feed).
-        if (Array.isArray(ev.px)) wristPx = { u: ev.px[0], v: ev.px[1] };
-        wristBox.classList.toggle("inside", ev.inside === true);
-        grasp = { tx: ev.tx, ty: ev.ty };
-        if (Array.isArray(ev.ee)) armTrail.push({ x: ev.ee[0], z: ev.ee[2], kind: "descend", ok: true });
-        break;
-      case "wrist_done":
-        // Refined grasp target — re-pin the head-view reticle to match.
-        grasp = { tx: ev.tx, ty: ev.ty };
-        grabPx = Array.isArray(ev.grab_px) ? { u: ev.grab_px[0], v: ev.grab_px[1] } : grabPx;
-        logLine(
-          `wrist done @z ${num(ev.z, 2)} — ${ev.reason ?? "?"} (tx ${num(ev.tx, 3)} ty ${num(ev.ty, 3)})`,
-          ev.reason !== "reached stop z",
-        );
-        break;
-      case "descend":
-        if (Array.isArray(ev.ee)) armTrail.push({ x: ev.ee[0], z: ev.ee[2], kind: "descend", ok: ev.ok !== false });
-        logLine(`des → ${num(ev.z, 3)} ee z ${num(ev.ee?.[2], 3)}${ev.ok === false ? " contact" : ""}`, ev.ok === false);
-        break;
-      case "grasp_abort":
-        logLine(`grasp abort — ${ev.reason ?? "?"} (ee z ${num(ev.ee_z, 3)})`, true);
-        break;
-      case "close":
-        closeJ6 = { open: ev.j6_open, closed: ev.j6 };
-        logLine(`close j6 ${num(ev.j6_open, 3)} → ${num(ev.j6, 3)}`);
-        break;
-      case "twist":
-        logLine(`twist j4 ${num(ev.j4, 2)}`);
-        break;
-      case "lift":
-        if (Array.isArray(ev.ee)) armTrail.push({ x: ev.ee[0], z: ev.ee[2], kind: "lift" });
-        logLine(`lift ee z ${num(ev.ee?.[2], 3)} j6 ${num(ev.j6, 3)}${ev.ik_fallback ? " (ik fallback)" : ""}`);
-        break;
-      case "verify":
-        logLine(
-          `verify ${ev.held ? "HELD" : "not held"} — floor ${ev.floor_clear ? "clear" : "object"}, j6 ${num(ev.j6, 3)}`,
-          !ev.held,
-        );
-        break;
-      default:
-        logLine(String(ev.ev ?? "?"));
-    }
-    toggleBtn.classList.toggle("running", running);
-    syncHeader();
-    draw();
-    placeReticle();
-  }
-
-  const unsubDebug = rosClient.subscribe(PICK_DEBUG_TOPIC, (msg) => {
-    if (typeof msg?.data !== "string") return;
-    try {
-      onDebugEvent(JSON.parse(msg.data));
-    } catch {
-      // Not JSON — ignore.
-    }
-  });
-
-  // ---- open / close ---------------------------------------------------------
-
-  /** @param {boolean} open */
-  function setOpen(open) {
-    wrap.hidden = !open;
-    toggleBtn.classList.toggle("active", open);
-    toggleBtn.setAttribute("aria-pressed", String(open));
-    if (open) draw();
-  }
-
-  toggleBtn.addEventListener("click", () => setOpen(Boolean(wrap.hidden)));
-
-  /** @param {KeyboardEvent} e */
-  function onKeyDown(e) {
-    if (e.code !== TOGGLE_KEY || e.repeat || e.metaKey || e.ctrlKey || e.altKey) return;
-    const el = document.activeElement;
-    if (el instanceof HTMLElement && (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.isContentEditable)) {
-      return;
-    }
-    setOpen(Boolean(wrap.hidden));
-  }
-  window.addEventListener("keydown", onKeyDown);
-
-  syncHeader();
-
-  return {
-    destroy() {
-      if (publishTimer !== null) clearTimeout(publishTimer);
-      unsubDebug();
-      if (unsubSession) unsubSession();
-      window.removeEventListener("keydown", onKeyDown);
-      window.removeEventListener("resize", onResize);
-      reticle.remove();
-      seenMark.remove();
-      boxGoal.remove();
-      wristBox.remove();
-      wristMark.remove();
-      toggleBtn.remove();
-      wrap.remove();
-    },
-  };
-}
diff --git a/workspace/innate_skills/arm_utils.py b/workspace/innate_skills/arm_utils.py
index 894977abb..797c1d2c4 100644
--- a/workspace/innate_skills/arm_utils.py
+++ b/workspace/innate_skills/arm_utils.py
@@ -5,7 +5,7 @@
 Arm Utils Skill - Torque on, torque off, or reboot the arm servos.
 """
 
-from typing import Literal
+from typing import Literal, cast
 
 from brain_client.skills.types import Interface, InterfaceType, Skill, SkillResult
 
@@ -44,7 +44,7 @@ def execute(self, command: ArmCommand):
         if self.manipulation is None:
             return "Manipulation interface not available", SkillResult.FAILURE
 
-        command = command.strip().lower()
+        command = cast(ArmCommand, command.strip().lower())
         if command not in VALID_COMMANDS:
             return (
                 f"Invalid command '{command}'. Must be one of: {', '.join(VALID_COMMANDS)}.",
diff --git a/workspace/innate_skills/detect_opponent_move.py b/workspace/innate_skills/detect_opponent_move.py
index 85fa64221..663111158 100644
--- a/workspace/innate_skills/detect_opponent_move.py
+++ b/workspace/innate_skills/detect_opponent_move.py
@@ -14,7 +14,7 @@
 import json
 import time
 from pathlib import Path
-from typing import Literal
+from typing import Any, Literal, cast
 
 import chess
 from google import genai
@@ -288,6 +288,9 @@ def _ask_gemini_detect_move(self, board_context: str, main_b64: str | None, wris
 
         Returns parsed dict {move_uci, confidence, reasoning} or None.
         """
+        if self.gemini_client is None:
+            return None
+
         prompt = (
             "You are analyzing a physical chess board to detect the opponent's last move.\n\n"
             f"{board_context}\n"
@@ -301,7 +304,7 @@ def _ask_gemini_detect_move(self, board_context: str, main_b64: str | None, wris
             '"reasoning": "brief explanation"}'
         )
 
-        contents = [prompt]
+        contents: list[Any] = [prompt]
         if wrist_b64:
             contents.append(types.Part.from_bytes(data=base64.b64decode(wrist_b64), mime_type="image/jpeg"))
 
@@ -317,7 +320,7 @@ def _ask_gemini_detect_move(self, board_context: str, main_b64: str | None, wris
                     thinking_config=types.ThinkingConfig(thinking_budget=1024),
                 ),
             )
-            result = json.loads(response.text.strip())
+            result = json.loads((response.text or "").strip())
             self.logger.info(f"[DetectOpponentMove] Stage 1 result: {result}")
             self._save_gemini_response("stage1", result)
             return result
@@ -332,6 +335,9 @@ def _ask_gemini_confirm(
 
         Narrows the candidate list and asks Gemini to pick one.
         """
+        if self.gemini_client is None:
+            return None
+
         prompt = (
             "You are analyzing a physical chess board to confirm which move was played.\n\n"
             f"{board_context}\n"
@@ -343,7 +349,7 @@ def _ask_gemini_confirm(
             '"reasoning": "brief explanation"}'
         )
 
-        contents = [prompt]
+        contents: list[Any] = [prompt]
         if wrist_b64:
             contents.append(types.Part.from_bytes(data=base64.b64decode(wrist_b64), mime_type="image/jpeg"))
 
@@ -359,7 +365,7 @@ def _ask_gemini_confirm(
                     thinking_config=types.ThinkingConfig(thinking_budget=512),
                 ),
             )
-            result = json.loads(response.text.strip())
+            result = json.loads((response.text or "").strip())
             self.logger.info(f"[DetectOpponentMove] Stage 2 result: {result}")
             self._save_gemini_response("stage2", result)
             return result
@@ -378,7 +384,7 @@ def execute(self, robot_color: RobotColor = "white"):
                          On first call, initialises the game state.
         """
         self._cancelled = False
-        robot_color = robot_color.strip().lower()
+        robot_color = cast(RobotColor, robot_color.strip().lower())
         if robot_color not in ROBOT_COLORS:
             return f"Invalid robot_color '{robot_color}'. Must be 'white' or 'black'.", SkillResult.FAILURE
 
diff --git a/workspace/innate_skills/head_emotion.py b/workspace/innate_skills/head_emotion.py
index 8f1b313f9..1de80240e 100644
--- a/workspace/innate_skills/head_emotion.py
+++ b/workspace/innate_skills/head_emotion.py
@@ -6,7 +6,7 @@
 """
 
 import time
-from typing import Literal
+from typing import Literal, cast
 
 from brain_client.skills.types import Interface, InterfaceType, Skill, SkillResult
 
@@ -123,7 +123,7 @@ def execute(self, emotion: EmotionName, repeat: int = 1):
         if self.head is None:
             return "Head interface not available", SkillResult.FAILURE
 
-        emotion = emotion.strip().lower()
+        emotion = cast(EmotionName, emotion.strip().lower())
         if emotion not in EMOTIONS:
             available = ", ".join(sorted(EMOTIONS))
             return f"Unknown emotion '{emotion}'. Available: {available}", SkillResult.FAILURE
diff --git a/workspace/innate_skills/navigate_to_position.py b/workspace/innate_skills/navigate_to_position.py
index e435a7184..4e8351d23 100644
--- a/workspace/innate_skills/navigate_to_position.py
+++ b/workspace/innate_skills/navigate_to_position.py
@@ -10,7 +10,9 @@
 from rclpy.duration import Duration
 from rclpy.qos import DurabilityPolicy, QoSProfile
 from rclpy.time import Time
-from tf2_ros import TransformException
+# TransformException is re-exported from the compiled tf2_py module, which
+# pyright cannot introspect.
+from tf2_ros import TransformException  # pyright: ignore[reportAttributeAccessIssue]
 from tf2_ros.buffer import Buffer
 from tf2_ros.transform_listener import TransformListener
 
@@ -68,8 +70,10 @@ def _lookup_fresh_base_pose(self, timeout_sec: float = 2.0, max_age_sec: float =
         """
         navigator = self.navigator
         clock = navigator.get_clock()
-        deadline = clock.now() + Duration(seconds=timeout_sec)
-        min_stamp = clock.now() - Duration(seconds=max_age_sec)
+        # rclpy's Duration accepts float seconds; its unannotated default makes
+        # pyright infer int.
+        deadline = clock.now() + Duration(seconds=timeout_sec)  # pyright: ignore[reportArgumentType]
+        min_stamp = clock.now() - Duration(seconds=max_age_sec)  # pyright: ignore[reportArgumentType]
         while clock.now() < deadline:
             rclpy.spin_once(navigator, timeout_sec=0.05)
             try:
diff --git a/workspace/innate_skills/navigate_with_vision.py b/workspace/innate_skills/navigate_with_vision.py
index 0325e4321..603ea4d67 100644
--- a/workspace/innate_skills/navigate_with_vision.py
+++ b/workspace/innate_skills/navigate_with_vision.py
@@ -100,17 +100,18 @@ def execute(self, instruction: str):
             self._send_feedback(msg)
             return msg, SkillResult.FAILURE
 
-        self._goal_handle = goal_future.result()
-        if not self._goal_handle.accepted:
+        goal_handle = goal_future.result()
+        if goal_handle is None or not goal_handle.accepted:
             msg = "Navigation goal was rejected."
             self.logger.info(msg)
             self._send_feedback(msg)
             return msg, SkillResult.FAILURE
+        self._goal_handle = goal_handle
 
         self.logger.info("Goal accepted — waiting for result …")
         self._send_feedback("Navigation started, waiting for completion …")
 
-        result_future = self._goal_handle.get_result_async()
+        result_future = goal_handle.get_result_async()
 
         # Wait for the result WITHOUT re-spinning self.node — the skills_server's
         # dedicated executor already services the result/feedback callbacks. Register
@@ -125,7 +126,7 @@ def execute(self, instruction: str):
         while not result_ready.wait(timeout=0.25):
             if self._cancel_requested.is_set():
                 self.logger.info("Cancel requested — forwarding to action server")
-                self._goal_handle.cancel_goal_async()
+                goal_handle.cancel_goal_async()
                 # Wait for the server to acknowledge the cancel.
                 result_ready.wait(timeout=10.0)
                 break
diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
index 4a8a266a7..c0fd8a41c 100644
--- a/workspace/innate_skills/pick_any_object.py
+++ b/workspace/innate_skills/pick_any_object.py
@@ -1,49 +1,17 @@
 #!/usr/bin/env python3
 # SPDX-License-Identifier: Apache-2.0
 # Copyright (c) 2026 Innate Inc
-"""
-Pick any object from the floor, given a text prompt.
-
-The key idea is to localize metrically (pixel -> floor plane -> base_link x,y)
-instead of pixel-servoing forever. Once you have a metric fix you can just
-drive there and grasp. No depth camera, no hand-eye calibration — just URDF
-geometry and a pinhole model.
-
-Validated live on mars-the-44th (2026-07-10): found a sock, grasped it,
-proved it kinetically.
-
-Pipeline:
-
-  1. FIND      tilt the head down, ask Gemini for a pixel
-  2. LOCALIZE  back-project that pixel onto z=0 (the floor)
-  3. POSITION  track the detection point with optical flow and servo the base
-               until it sits in a "pick box" on the image (~20 Hz, no Gemini
-               in the loop). Re-detect only to confirm / recover from drift.
-  4. GRASP     IK hover above the estimate, wrist-align (below), descend,
-               close, twist, lift
-     WRIST ALIGN go to the operator's posed search position (up high, elbow
-               ~90°, wrist camera on the object), get a tight box from
-               Gemini, learn a color model of the object vs the floor, then
-               segment every wrist frame (~5 Hz) and CamShift-follow the
-               blob while stepping the arm down with IK — correcting x/y to
-               keep it in the wrist box, descending only while it's inside
-               — until wrist_stop_z, where the blind ladder finishes the
-               approach and the gripper closes.
-  5. VERIFY    back up 15 cm, check the floor is empty (held objects travel
-               with the robot). Also check the gripper joint isn't open.
-
-That's it. Everything else is plumbing and knobs.
+"""Pick an object from the floor by text prompt.
+
+Metric localize (pixel -> floor -> base_link), drive into a pick box,
+grasp (optional wrist visual-servo), verify by backing up.
+No depth camera — URDF + pinhole model.
 """
 
-import base64
 import json
 import math
-import re
 import time
 
-import cv2
-import numpy as np
-from innate_proxy import ProxyClient
 from std_msgs.msg import String
 
 from brain_client.skills.types import (
@@ -54,104 +22,73 @@
     Skill,
     SkillResult,
 )
-from innate.skills import SkillFailed, arm_rest_position
+from innate.skills import SkillCancelled, SkillFailed, arm_rest_position
 from workspace.skill_lib import arm as armlib
+from workspace.skill_lib import gemini as gemlib
+from workspace.skill_lib import vision
 from workspace.skill_lib.geometry import IMG_H, IMG_W, floor_to_pixel, pixel_to_floor
 
-# Vision model, reached through the Innate proxy's OpenAI-compatible endpoint
-# (service "gemini", /v1/chat/completions). The proxy holds the upstream key;
-# the robot authenticates with its service key. NOTE: the service key must be
-# granted access to the "gemini" service or the proxy returns 403.
-GEMINI_SERVICE = "gemini"
-GEMINI_ENDPOINT = "/v1/chat/completions"
-GEMINI_MODEL = "gemini-3.5-flash"
-
-# hardware-tuned constants (not exposed to the live panel)
-GRIPPER_EMPTY_J6 = -0.085  # joint6 when fingers are open / empty
-VERIFY_BACKUP_M = 0.15     # how far to reverse before asking "is it gone?"
-
-# Carry pose after a successful pick — joints 1-5 posed by the operator. j6 is
-# NOT taken from here (the posed value was near-open); the gripper stays firmly
-# CLOSED on the sock — see _rest_arm.
+# Hardware constants (not live-tunable).
+GRIPPER_EMPTY_J6 = -0.085  # open/empty gripper
+VERIFY_BACKUP_M = 0.15
+
+# Post-pick carry pose (j1-5). j6 comes from close_strength, not this pose.
 CARRY_ARM = [0.0537, -0.5031, 0.4157, 0.9434, -0.0077]
 
-# -----------------------------------------------------------------------------
-# live-tunable knobs. Defaults are the hardware-tuned values. The webapp
-# pick-tuning panel publishes JSON overrides on TUNING_TOPIC; we apply them
-# at the next read, mid-run. Keep keys in sync with pickTunePanel.js.
-# -----------------------------------------------------------------------------
+# Live knobs, overridable mid-run via TUNING_TOPIC (String JSON partial dict).
+# The webapp draws the pick/wrist boxes from mirrors of the aim defaults
+# (pickOverlay.js) — keep those in sync when changing them here.
 TUNABLE = {
     # FIND / LOCALIZE
-    "tilt_deg": -20.0,          # head pitch while working (negative = down)
-    "settle_s": 1.2,            # wait after stopping before grabbing a frame
-    # POSITION — the "pick box" on the image
-    "sweet_x": 0.30,            # want the object this far ahead in base_link
-    "box_y": 0.0,               # lateral offset of the box centre (drag in UI)
-    "box_half_px": 40.0,        # half-width of the goal square, image pixels
-    "accept_frac": 0.5,         # stop only when the point is within this
-                                #   fraction of box_half_px of the centre — a
-                                #   concentric inner box. Accepting anywhere in
-                                #   the full box let the arm grasp at an edge,
-                                #   short of the object; center it instead.
+    "tilt_deg": -20.0,          # head pitch (negative = down)
+    "settle_s": 1.2,            # settle before a frame
+    # POSITION
+    "sweet_x": 0.30,            # pick-box range in base_link (m)
+    "box_y": 0.0,               # pick-box lateral offset (m)
+    "box_half_px": 40.0,        # outer box half-width (px)
+    "accept_frac": 0.5,         # inner accept box as fraction of outer
     "box_steps": 6.0,           # max follow / re-detect attempts
-    "bearing_go_deg": 4.0,      # stepwise fallback: fix heading above this
-    "follow_gain_ang": 0.3,     # px-servo: rad/s per 100 px of horizontal error
-    "follow_gain_lin": 0.06,    # px-servo: m/s per 100 px of vertical error
-    # closed-loop base (odometry)
+    "bearing_go_deg": 4.0,      # stepwise: turn above this
+    "follow_gain_ang": 0.3,     # rad/s per 100 px
+    "follow_gain_lin": 0.06,    # m/s per 100 px
+    # base odometry
     "rot_tol_deg": 2.5,
     "rot_kp": 1.2,
     "rot_wz_max": 0.5,
-    "rot_wz_min": 0.15,         # below this the motors just don't move
+    "rot_wz_min": 0.15,         # below this motors don't move
     "drive_tol_m": 0.015,
     "drive_kp": 0.3,
     "drive_v_max": 0.10,
     "drive_v_min": 0.04,
-    # WRIST ALIGN — visual-servo descent over the wrist camera, starting from
-    # the operator's posed search position (WRIST_SEARCH_ARM). Gemini seeds
-    # the object pixel, optical flow tracks it on wrist frames while the arm
-    # steps down; x/y corrected each cycle, z drops only while inside the box.
-    "wrist_steps": 2.0,         # Gemini looks allowed (seed + re-seeds after
-                                #   a tracking loss); 0 disables the stage
-    "wrist_stop_z": 0.04,       # hand off to the blind descend ladder here
-    "wrist_z_step": 0.01,       # descend per verified step, meters
-    "wrist_move_s": 0.5,        # per-cycle arm move duration
-    "wrist_pitch": 0.82,        # ee pitch during the servo — the operator's
-                                #   posed search pose (WRIST_SEARCH_ARM) has
-                                #   the wrist camera looking down at exactly
-                                #   this pitch. The ladder rotates to
-                                #   arm_pitch for the grasp itself; any offset
-                                #   that rotation causes is absorbed by where
-                                #   the wrist box sits on the image.
-    "wrist_box_u": 320.0,       # goal pixel on the wrist image (drag in UI)
+    # WRIST ALIGN (0 wrist_steps = blind grasp)
+    "wrist_steps": 2.0,         # Gemini looks (seed + re-seeds)
+    "wrist_stop_z": 0.04,       # hand off to blind ladder
+    "wrist_z_step": 0.01,
+    "wrist_move_s": 0.5,
+    "wrist_pitch": 0.82,        # match WRIST_SEARCH_ARM camera pitch
+    "wrist_box_u": 320.0,       # wrist goal pixel
     "wrist_box_v": 240.0,
-    "wrist_half_px": 60.0,      # accept half-width, pixels
-    "wrist_kx": -0.04,          # m forward per 100 px of vertical (v) error
-    "wrist_ky": -0.04,          # m left per 100 px of horizontal (u) error.
-                                #   Both SIGNED: the wrist cam is mirrored and
-                                #   the mount is untested — flip one live if a
-                                #   nudge diverges instead of centering. Gains
-                                #   are "at z=0.15" and auto-scale with height.
-    "wrist_step_max": 0.04,     # single-nudge clamp, meters
-    "wrist_settle_s": 0.8,      # settle before a Gemini seed frame
+    "wrist_half_px": 60.0,
+    "wrist_kx": -0.04,          # m/100px v-error (signed; flip if diverges)
+    "wrist_ky": -0.04,          # m/100px u-error; gains at z=0.15, scale w/ height
+    "wrist_step_max": 0.04,
+    "wrist_settle_s": 0.8,
     # GRASP
-    "grasp_x_off": 0.03,        # fingertips land ~3 cm forward of ee_link
+    "grasp_x_off": 0.03,        # fingertips ahead of ee_link
     "hover_z": 0.15,
     "hover_s": 2.0,
-    "descend_z1": 0.10,         # descent ladder, top -> bottom
+    "descend_z1": 0.10,
     "descend_z2": 0.06,
     "descend_z3": 0.03,
-    "floor_z": 0.01,            # deep second attempt goes all the way to 0
+    "floor_z": 0.01,
     "descend_s": 1.2,
-    "descend_abort_z": 0.12,    # if EE is still above this, arm is limp — abort
+    "descend_abort_z": 0.12,    # EE still above this => limp, abort
     "arm_pitch": 1.30,
-    "close_strength": 0.60,     # firm grip held through the lift. NOT higher:
-                                #   0.85 squeezes j6 at max current against finger/
-                                #   object contact and OVERCURRENT-TRIPS the gripper
-                                #   servo, which then won't open on the next grasp.
+    "close_strength": 0.60,     # >~0.6 overcurrent-trips the gripper servo
     "close_s": 1.5,
     "close_settle_s": 0.8,
-    "twist_rad": 0.6,           # wrist roll while closed winds fabric on
-    "lift_rad": 0.6,            # shoulder-up joint delta
+    "twist_rad": 0.6,           # wind fabric onto fingers
+    "lift_rad": 0.6,
 }
 
 DEBUG_TOPIC = "/pick_any_object/debug"
@@ -163,23 +100,63 @@
 WRIST_SEG_MIN_SCORE = 25.0
 WRIST_CAM_ABOVE_EE = 0.07
 WRIST_SEARCH_ARM = [0.1473, -0.0706, -0.4449, 1.3376, -0.0491]
-# Lucas-Kanade defaults — a small patch beats a single point
-_LK_PARAMS = dict(
-    winSize=(21, 21), maxLevel=3,
-    criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 20, 0.03),
-)
 
 
-def _r(v, nd=4):
-    """round that passes None through (absent sensor readings)."""
-    return round(v, nd) if isinstance(v, (int, float)) else None
+def _round_floats(v, nd=4):
+    """Round floats in nested JSON-ish data for telemetry."""
+    if isinstance(v, float):
+        return round(v, nd)
+    if isinstance(v, dict):
+        return {k: _round_floats(x, nd) for k, x in v.items()}
+    if isinstance(v, (list, tuple)):
+        return [_round_floats(x, nd) for x in v]
+    return v
+
+
+def _inside_box(px, cu, cv, half):
+    """True if pixel is within ±half of (cu, cv)."""
+    return abs(px[0] - cu) <= half and abs(px[1] - cv) <= half
+
+
+def _servo_vel(err_px, gain, v_min, v_max, deadband_px):
+    """Pixel P-servo axis: gain per 100 px, clamp to [v_min, v_max], 0 in deadband."""
+    if abs(err_px) <= deadband_px:
+        return 0.0
+    v = max(-v_max, min(v_max, -gain / 100.0 * err_px))
+    return math.copysign(v_min, v) if abs(v) < v_min else v
+
+
+class _BlobTracker:
+    """CamShift color-blob tracker seeded from a Gemini box."""
+
+    def __init__(self, hsv, box, px):
+        self.model = vision.seg_model(hsv, box)
+        self.window = box
+        self.guess = px
+        self.misses = 0
+
+    @property
+    def ok(self):
+        return self.model is not None
+
+    def update(self, hsv):
+        """Blob center, or None on miss (keeps last window for retry)."""
+        pt, window, _score = vision.seg_track(
+            hsv, self.model, self.window, min_score=WRIST_SEG_MIN_SCORE)
+        if pt is not None and math.hypot(pt[0] - self.guess[0],
+                                         pt[1] - self.guess[1]) > WRIST_MAX_JUMP_PX:
+            pt = None
+        if pt is None:
+            self.misses += 1
+            return None
+        self.misses = 0
+        self.window = window
+        self.guess = pt
+        return pt
 
 
-# -----------------------------------------------------------------------------
-# the skill
-# -----------------------------------------------------------------------------
 class PickAnyObject(Skill):
-    """Pick up any object on the floor, specified by a natural-language prompt."""
+    """Pick up a floor object described by a natural-language prompt."""
 
     manipulation = Interface(InterfaceType.MANIPULATION)
     mobility = Interface(InterfaceType.MOBILITY)
@@ -191,13 +168,8 @@ class PickAnyObject(Skill):
 
     def __init__(self, logger):
         super().__init__(logger)
-        self._cancelled = False
-        # Vision runs through the Innate proxy (upstream key managed there);
-        # None when the robot has no proxy credentials configured.
-        self._proxy = ProxyClient()
-        if not self._proxy.is_available():
-            self._proxy = None
-        self._p = dict(TUNABLE)  # live copy; panel mutates this
+        self._proxy = gemlib.make_client()  # None if no credentials
+        self._p = dict(TUNABLE)  # live copy; panel mutates
         self._dbg_pub = None
         self._tuning_sub = None
 
@@ -206,9 +178,7 @@ def name(self):
         return "pick_any_object"
 
     def guidelines(self):
-        # called on every skill-server load/reload — set up topics early so the
-        # webapp panel can subscribe before the first execute()
-        self._ensure_debug_io()
+        self._ensure_debug_io()  # node ready here; not in __init__
         return (
             "Pick up an object lying on the floor, described in natural language "
             "(e.g. prompt='the white sock', 'a red cup'). The robot localizes the "
@@ -217,11 +187,7 @@ def guidelines(self):
             "returned to rest either way."
         )
 
-    # -------------------------------------------------------------------------
-    # debug telemetry + live tuning (webapp pick-tuning panel)
-    # -------------------------------------------------------------------------
     def _ensure_debug_io(self):
-        # node isn't available in __init__; create pubs/subs once we have it
         if self._dbg_pub is not None or self.node is None:
             return
         self._dbg_pub = self.node.create_publisher(String, DEBUG_TOPIC, 10)
@@ -236,7 +202,6 @@ def _on_tuning(self, msg):
             return
         if not isinstance(incoming, dict):
             return
-        # only known float knobs; ignore everything else
         applied = {
             k: float(v)
             for k, v in incoming.items()
@@ -245,62 +210,34 @@ def _on_tuning(self, msg):
         if applied:
             self._p.update(applied)
             self.logger.info(f"[PickAnyObject] tuning applied: {applied}")
-        # ack with the full live set so the panel can confirm sync
         self._dbg("params", params=dict(self._p))
 
     def _dbg(self, ev, **fields):
         if self._dbg_pub is None:
             return
         fields.update(t=round(time.time(), 3), ev=ev)
-        self._dbg_pub.publish(String(data=json.dumps(fields)))
-
-    # -------------------------------------------------------------------------
-    # vision: Gemini finds a pixel, geometry turns it into a floor point
-    # -------------------------------------------------------------------------
-    def _gemini_call(self, image_b64, question, retries=3):
-        """Ask the vision model about an image. Routes through the Innate
-        proxy's OpenAI-compatible chat endpoint (image as a data URI); returns
-        the reply text, or None after `retries` failures."""
-        proxy = self._proxy
-        if proxy is None:
-            return None
-        body = {
-            "model": GEMINI_MODEL,
-            "temperature": 0.0,
-            "messages": [{
-                "role": "user",
-                "content": [
-                    {"type": "text", "text": question},
-                    {"type": "image_url", "image_url": {
-                        "url": f"data:image/jpeg;base64,{image_b64}"}},
-                ],
-            }],
-        }
-        for attempt in range(retries):
-            try:
-                with proxy.request_stream(
-                    GEMINI_SERVICE, GEMINI_ENDPOINT, method="POST", json=body,
-                ) as resp:
-                    resp.raise_for_status()
-                    data = json.loads(resp.read())
-                return data["choices"][0]["message"]["content"] or ""
-            except Exception as e:  # noqa: BLE001
-                self.logger.warning(
-                    f"[PickAnyObject] vision call failed (try {attempt + 1}/{retries}): {e}"
-                )
-                if attempt < retries - 1:
-                    time.sleep(2.0 * (attempt + 1))
-        return None
+        self._dbg_pub.publish(String(data=json.dumps(_round_floats(fields))))
+
+    def _checkpoint(self):
+        """Raise out of the run if cancel() latched. One raise here, one
+        `except SkillCancelled` in execute — no cancelled-as-None plumbing.
+        Deliberately NOT called during close/twist/lift: once the fingers
+        commit, aborting mid-grip would drag the object on the way home."""
+        if self._cancelled:
+            raise SkillCancelled("Pick cancelled")
+
+    def _gemini_call(self, image_b64, question):
+        """Vision Q&A via gemlib."""
+        return gemlib.ask_image(self._proxy, image_b64, question,
+                                logger=self.logger)
 
     def _detect_px(self, prompt):
-        """One fresh head frame -> best grasp pixel for `prompt`, or None."""
+        """Head frame -> best grasp pixel, or None."""
         self._stop_base()
-        time.sleep(self._p["settle_s"])  # blur kills detection
+        time.sleep(self._p["settle_s"])
         img = self.main_image
         if not img:
             return None
-        # ask for the thickest / bunched-up part — that's where two fingers
-        # actually get purchase. Flat middle of a sock is a bad pinch.
         text = self._gemini_call(
             img,
             f"Find '{prompt}' lying on the floor in this image. Match precisely — "
@@ -311,62 +248,10 @@ def _detect_px(self, prompt):
             "highest part of the object — the best spot for a two-finger gripper "
             "to pinch, NOT the flat middle. Empty list if not present.",
         )
-        return self._parse_det_px(text)
-
-    @staticmethod
-    def _parse_dets(text):
-        """Gemini detection reply -> list of detection dicts (may be empty)."""
-        if not text:
-            return []
-        text = re.sub(r"```(?:json)?", "", text)
-        m = re.search(r"\[.*\]", text, re.S)
-        if not m:
-            return []
-        try:
-            dets = json.loads(m.group(0))
-        except json.JSONDecodeError:
-            return []
-        return [d for d in dets if isinstance(d, dict)]
-
-    @classmethod
-    def _parse_det_px(cls, text):
-        """Gemini detection reply -> best (u, v) pixel, or None."""
-        for det in cls._parse_dets(text):
-            gp = det.get("grasp_point")
-            if gp and len(gp) >= 2:
-                # Gemini coords are [y,x] in 0..1000 — flip to (u,v) pixels
-                return (float(gp[1]) / 1000.0 * IMG_W, float(gp[0]) / 1000.0 * IMG_H)
-            b = det.get("box_2d")
-            if b and len(b) >= 4:
-                y0, x0, y1, x1 = [float(v) for v in b[:4]]
-                y0, y1 = sorted((y0, y1))
-                x0, x1 = sorted((x0, x1))
-                return ((x0 + x1) / 2 / 1000.0 * IMG_W, (y0 + y1) / 2 / 1000.0 * IMG_H)
-        return None
-
-    @classmethod
-    def _parse_det_box(cls, text):
-        """Gemini detection reply -> best pixel box (x, y, w, h), or None."""
-        for det in cls._parse_dets(text):
-            b = det.get("box_2d")
-            if b and len(b) >= 4:
-                y0, x0, y1, x1 = [float(v) for v in b[:4]]
-                y0, y1 = sorted((y0, y1))
-                x0, x1 = sorted((x0, x1))
-                x = int(x0 / 1000.0 * IMG_W)
-                y = int(y0 / 1000.0 * IMG_H)
-                w = int((x1 - x0) / 1000.0 * IMG_W)
-                h = int((y1 - y0) / 1000.0 * IMG_H)
-                if w >= 8 and h >= 8:  # a sliver can't seed a color model
-                    return (x, y, w, h)
-        return None
-
-    def _localize(self, prompt):
-        """(x, y) of the object in base_link, or None."""
-        return self._localize_px(prompt)[0]
+        return vision.parse_det_px(text)
 
     def _localize_px(self, prompt):
-        """Detect + back-project. Returns ((x,y)|None, pixel|None)."""
+        """Detect + back-project -> ((x,y)|None, pixel|None)."""
         px = self._detect_px(prompt)
         if px is None:
             self._dbg("localize", px=None, xy=None)
@@ -377,23 +262,14 @@ def _localize_px(self, prompt):
                 f"[PickAnyObject] px=({px[0]:.0f},{px[1]:.0f}) -> "
                 f"base_link ({xy[0]:.3f},{xy[1]:.3f})"
             )
-        self._dbg(
-            "localize",
-            px=[round(px[0], 1), round(px[1], 1)],
-            xy=[round(xy[0], 4), round(xy[1], 4)] if xy else None,
-            tilt_deg=self._p["tilt_deg"],
-        )
+        self._dbg("localize", px=px, xy=xy, tilt_deg=self._p["tilt_deg"])
         return xy, px
 
-    # -------------------------------------------------------------------------
-    # base control, closed-loop on odometry
-    # when odom is missing we fall back to timed open-loop — never a silent no-op
-    # -------------------------------------------------------------------------
     def _stop_base(self):
         self.mobility.send_cmd_vel(0.0, 0.0, 0.1)
 
     def _odom_xyt(self):
-        """(x, y, theta). Accepts both the nested dict and the flat dataclass."""
+        """(x, y, theta) from nested dict or flat dataclass."""
         od = self.odom
         if od is None:
             return None
@@ -407,10 +283,9 @@ def _odom_xyt(self):
             return None
 
     def _rotate_by(self, angle, tol=None, timeout=12.0):
-        self._dbg("rotate", angle_deg=round(math.degrees(angle), 1))
+        self._dbg("rotate", angle_deg=math.degrees(angle))
         od = self._odom_xyt()
         if od is None:
-            # poor man's rotate: open-loop timed yaw
             self.mobility.send_cmd_vel(0.0, math.copysign(0.35, angle),
                                        abs(angle) / 0.35)
             time.sleep(abs(angle) / 0.35 + 0.4)
@@ -418,11 +293,11 @@ def _rotate_by(self, angle, tol=None, timeout=12.0):
         target = od[2] + angle
         t0 = time.time()
         err = angle
-        while time.time() - t0 < timeout and not self._cancelled:
+        while time.time() - t0 < timeout:
+            self._checkpoint()
             od = self._odom_xyt()
             if od is None:
                 break
-            # wrap to [-pi, pi]
             err = math.atan2(math.sin(target - od[2]), math.cos(target - od[2]))
             if abs(err) < (tol if tol is not None
                            else math.radians(self._p["rot_tol_deg"])):
@@ -434,14 +309,13 @@ def _rotate_by(self, angle, tol=None, timeout=12.0):
             self.mobility.send_cmd_vel(0.0, wz, 0.15)
             time.sleep(0.08)
         self._stop_base()
-        self._dbg("rotate_done", err_deg=round(math.degrees(err), 2),
-                  s=round(time.time() - t0, 2))
+        self._dbg("rotate_done", err_deg=math.degrees(err), s=time.time() - t0)
 
     def _drive(self, dist, tol=None, timeout=15.0):
         tol = tol if tol is not None else self._p["drive_tol_m"]
         if abs(dist) < tol:
             return
-        self._dbg("drive", dist_m=round(dist, 3))
+        self._dbg("drive", dist_m=dist)
         od = self._odom_xyt()
         if od is None:
             self.logger.warning("[PickAnyObject] no odom — open-loop drive")
@@ -452,7 +326,8 @@ def _drive(self, dist, tol=None, timeout=15.0):
         x0, y0 = od[0], od[1]
         t0 = time.time()
         err = abs(dist)
-        while time.time() - t0 < timeout and not self._cancelled:
+        while time.time() - t0 < timeout:
+            self._checkpoint()
             od = self._odom_xyt()
             if od is None:
                 break
@@ -468,12 +343,8 @@ def _drive(self, dist, tol=None, timeout=15.0):
             self.mobility.send_cmd_vel(v, 0.0, 0.15)
             time.sleep(0.08)
         self._stop_base()
-        self._dbg("drive_done", err_m=round(err, 4), s=round(time.time() - t0, 2))
+        self._dbg("drive_done", err_m=err, s=time.time() - t0)
 
-    # -------------------------------------------------------------------------
-    # arm. Health-checked moves, recovery, and reach clamps live in
-    # workspace/skill_lib/arm.py (armlib) — thin state accessors stay here.
-    # -------------------------------------------------------------------------
     def _ee_xyz(self):
         return armlib.ee_xyz(self.manipulation)
 
@@ -481,10 +352,7 @@ def _gripper_j6(self):
         return armlib.gripper_j6(self.joint_states)
 
     def _rest_arm(self, keep_grip):
-        """Fold to home. If carrying: go to the operator's CARRY_ARM pose with
-        the gripper held firmly CLOSED (j6 = -close_strength). Command the full
-        close, not the achieved stalled-on-object value, so the squeeze holds
-        while carrying — otherwise the grip relaxes and the sock slips."""
+        """Fold home, or CARRY_ARM with full close_strength if holding."""
         if keep_grip:
             target = CARRY_ARM + [-self._p["close_strength"]]
         else:
@@ -495,152 +363,95 @@ def _rest_arm(self, keep_grip):
             )
             time.sleep(0.3)
 
-    # -------------------------------------------------------------------------
-    # stages
-    # -------------------------------------------------------------------------
     def _search(self, prompt):
-        """Look straight, then right 30°, then left 60°. First hit wins."""
-        # +yaw = left (CCW), -yaw = right (CW)
+        """Scan: straight, right 30°, left 60°. First hit wins. (+yaw=left)"""
         for i, turn in enumerate((0.0, -math.radians(30), math.radians(60))):
-            if self._cancelled:
-                return None
+            self._checkpoint()
             if turn:
                 if i == 1:
                     self.say("Scanning around for it.")
                 self._rotate_by(turn)
-            xy = self._localize(prompt)
+            xy, _px = self._localize_px(prompt)
             if xy is not None:
                 return xy
         return None
 
     def _sweet_box(self):
-        """Pick-box centre (from sweet_x, box_y), outer half-width in pixels,
-        and the inner accept half-width (accept_frac * outer). The base stops
-        only once the tracked point sits inside the INNER box — accepting it
-        anywhere in the outer box let the arm grasp at an edge, short of the
-        object. The webapp draws both squares from the same params."""
+        """(center_px, outer_half, accept_half). Stop only inside accept."""
         c = floor_to_pixel(self._p["sweet_x"], self._p["box_y"],
                            self._p["tilt_deg"])
+        assert c is not None, "pick box off-image — check tilt_deg/sweet_x"
         half = self._p["box_half_px"]
         return c, half, half * self._p["accept_frac"]
 
-    # ---- detection-point following ------------------------------------------
-    # Gemini is slow (~1s). Optical flow is free. So: detect once, track the
-    # pixel at camera rate, and P-servo the base until it's in the pick box.
-    # -------------------------------------------------------------------------
     def _gray_frame(self):
         img = self.main_image
-        if not img:
-            return None
-        try:
-            arr = np.frombuffer(base64.b64decode(img), np.uint8)
-            return cv2.imdecode(arr, cv2.IMREAD_GRAYSCALE)
-        except Exception:  # noqa: BLE001 — a bad frame just skips a cycle
-            return None
-
-    @staticmethod
-    def _grid_pts(u, v, step=12, n=2):
-        """(2n+1)^2 feature points around (u,v). A patch tracks; a point doesn't."""
-        pts = [[u + dx * step, v + dy * step]
-               for dx in range(-n, n + 1) for dy in range(-n, n + 1)]
-        return np.array(pts, dtype=np.float32).reshape(-1, 1, 2)
-
-    def _track_point(self, prev_gray, gray, grid):
-        """LK one step. Median of survivors = object's new pixel. None if lost."""
-        nxt, status, _ = cv2.calcOpticalFlowPyrLK(
-            prev_gray, gray, grid, None, **_LK_PARAMS)
-        if nxt is None or status is None:
-            return None
-        good = nxt[status.flatten() == 1].reshape(-1, 2)
-        if len(good) < 3:
-            return None
-        return float(np.median(good[:, 0])), float(np.median(good[:, 1]))
+        return vision.b64_to_gray(img) if img else None
 
     def _follow_into_box(self, seed_px):
-        """High-rate follow loop. No Gemini. Returns one of:
-        ('in_box', (u,v)) | ('lost', None) | ('timeout', None) | ('noframe', None)
+        """Optical-flow base servo into pick box. No Gemini.
+        Returns ('in_box'|'lost'|'timeout'|'noframe', px|None).
         """
         prev = self._gray_frame()
         if prev is None:
             return "noframe", None
         u, v = seed_px
-        grid = self._grid_pts(u, v)
+        grid = vision.grid_pts(u, v)
         in_box, last_dbg = 0, 0.0
         t0 = time.time()
-        while time.time() - t0 < FOLLOW_TIMEOUT_S and not self._cancelled:
+        while time.time() - t0 < FOLLOW_TIMEOUT_S:
+            self._checkpoint()
             gray = self._gray_frame()
             if gray is None:
                 time.sleep(0.03)
                 continue
-            tracked = self._track_point(prev, gray, grid)
+            tracked = vision.track_point(prev, gray, grid)
             prev = gray
             if tracked is None:
                 self._stop_base()
                 return "lost", None
             u, v = tracked
-            grid = self._grid_pts(u, v)  # recenter the patch
+            grid = vision.grid_pts(u, v)
             if not (0 <= u < IMG_W and 0 <= v < IMG_H):
                 self._stop_base()
                 return "lost", None
 
-            (cu, cv), half, accept = self._sweet_box()  # re-read: box moves live
-            eu, ev = u - cu, v - cv
-            inside = abs(eu) <= accept and abs(ev) <= accept
+            (cu, cv), half, accept = self._sweet_box()
+            inside = _inside_box((u, v), cu, cv, accept)
 
             now = time.time()
-            if now - last_dbg > 0.1:  # ~10 Hz marker for the webapp
-                self._dbg("servo", px=[round(u, 1), round(v, 1)],
-                          box=[round(cu, 1), round(cv, 1), half,
-                               round(accept, 1)], inside=inside)
+            if now - last_dbg > 0.1:
+                self._dbg("servo", px=[u, v], box=[cu, cv, half, accept],
+                          inside=inside)
                 last_dbg = now
 
             if inside:
                 in_box += 1
                 self._stop_base()
-                if in_box >= 3:  # debounce a few frames
+                if in_box >= 3:
                     return "in_box", (u, v)
                 time.sleep(0.03)
                 continue
             in_box = 0
 
-            # per-axis pixel servo. object right of box -> turn CW (-wz);
-            # object low in the image (too close) -> back up (-vx).
-            # gains are "per 100 px" so the numbers stay human-sized.
-            # Deadband on the INNER accept box, not the outer one — otherwise the
-            # servo would stop driving at the outer edge and never reach accept.
-            if abs(eu) <= accept:
-                wz = 0.0
-            else:
-                wz = max(-self._p["rot_wz_max"],
-                         min(self._p["rot_wz_max"],
-                             -self._p["follow_gain_ang"] / 100.0 * eu))
-                if abs(wz) < self._p["rot_wz_min"]:
-                    wz = math.copysign(self._p["rot_wz_min"], wz)
-            if abs(ev) <= accept:
-                vx = 0.0
-            else:
-                vx = max(-self._p["drive_v_max"],
-                         min(self._p["drive_v_max"],
-                             -self._p["follow_gain_lin"] / 100.0 * ev))
-                if abs(vx) < self._p["drive_v_min"]:
-                    vx = math.copysign(self._p["drive_v_min"], vx)
+            # Deadband = accept (inner) box; right -> -wz, too close (low) -> -vx.
+            wz = _servo_vel(u - cu, self._p["follow_gain_ang"],
+                            self._p["rot_wz_min"], self._p["rot_wz_max"], accept)
+            vx = _servo_vel(v - cv, self._p["follow_gain_lin"],
+                            self._p["drive_v_min"], self._p["drive_v_max"], accept)
             self.mobility.send_cmd_vel(vx, wz, 0.15)
             time.sleep(0.03)
         self._stop_base()
         return "timeout", None
 
     def _position_above(self, prompt, xy):
-        """Get the object into the pick box via optical-flow following.
-        Gemini reseeds after a tracking loss and confirms at the end.
-        Falls back to discrete stepwise corrections if there's no camera."""
+        """Flow-follow into pick box; Gemini reseed/confirm. Stepwise if no cam."""
         if self._gray_frame() is None:
             return self._position_stepwise(prompt, xy)
 
-        # seed from the caller's fix — no extra Gemini call
         seed = floor_to_pixel(xy[0], xy[1], self._p["tilt_deg"])
         for attempt in range(int(self._p["box_steps"])):
-            if self._cancelled:
-                return None
+            self._checkpoint()
             if seed is None:
                 seed = self._detect_px(prompt)
                 if seed is None:
@@ -650,50 +461,40 @@ def _position_above(self, prompt, xy):
             if result == "noframe":
                 return self._position_stepwise(prompt, xy)
             if result == "lost":
-                seed = None  # re-detect and try again
+                seed = None
                 continue
-            # in_box or timeout — confirm with one real detection
             xy2, px2 = self._localize_px(prompt)
             if px2 is None:
                 self._dbg("position_done", xy=None, reason="lost")
                 return None
             (cu, cv), half, accept = self._sweet_box()
-            if (xy2 is not None
-                    and abs(px2[0] - cu) <= accept and abs(px2[1] - cv) <= accept):
-                self._dbg("position_done",
-                          xy=[round(xy2[0], 4), round(xy2[1], 4)], attempts=attempt)
+            if xy2 is not None and _inside_box(px2, cu, cv, accept):
+                self._dbg("position_done", xy=xy2, attempts=attempt)
                 return xy2
             seed = px2 if xy2 is not None else None
         self._dbg("position_done", xy=None, reason="never inside the box")
         return None
 
     def _position_stepwise(self, prompt, xy):
-        """Odometry-free / no-camera fallback: one discrete correction per look.
-        Turn OR drive (never both), re-detect, repeat."""
+        """No-camera fallback: turn OR drive, re-detect, repeat."""
         target_bearing = math.atan2(self._p["box_y"], self._p["sweet_x"])
         target_range = math.hypot(self._p["sweet_x"], self._p["box_y"])
         px = floor_to_pixel(xy[0], xy[1], self._p["tilt_deg"])
         for step in range(int(self._p["box_steps"])):
-            if self._cancelled:
-                return None
+            self._checkpoint()
             if px is None:
                 xy, px = self._localize_px(prompt)
                 if px is None:
                     self._dbg("position_done", xy=None, reason="lost")
                     return None
             (cu, cv), half, accept = self._sweet_box()
-            inside = (xy is not None
-                      and abs(px[0] - cu) <= accept and abs(px[1] - cv) <= accept)
-            self._dbg("position", step=step,
-                      px=[round(px[0], 1), round(px[1], 1)],
-                      xy=[round(xy[0], 4), round(xy[1], 4)] if xy else None,
-                      box=[round(cu, 1), round(cv, 1), half, round(accept, 1)],
-                      inside=inside)
+            inside = xy is not None and _inside_box(px, cu, cv, accept)
+            self._dbg("position", step=step, px=px, xy=xy,
+                      box=[cu, cv, half, accept], inside=inside)
             if inside:
-                self._dbg("position_done",
-                          xy=[round(xy[0], 4), round(xy[1], 4)], steps=step)
+                self._dbg("position_done", xy=xy, steps=step)
                 return xy
-            if xy is None:  # pixel above the horizon — bogus, retry
+            if xy is None:
                 px = None
                 continue
             bearing_err = math.atan2(xy[1], xy[0]) - target_bearing
@@ -701,36 +502,15 @@ def _position_stepwise(self, prompt, xy):
                 self._rotate_by(bearing_err)
             else:
                 self._drive(math.hypot(xy[0], xy[1]) - target_range)
-            px = None  # we moved; re-detect before the next correction
+            px = None
         self._dbg("position_done", xy=None, reason="never inside the box")
         return None
 
-    # -------------------------------------------------------------------------
-    # GRASP — everything after the base is parked. Five moves, top to bottom:
-    #
-    #   1. search pose  joint move to the operator's posed arm: up high,
-    #                   elbow ~90°, wrist camera looking down at the floor
-    #   2. seed         ask Gemini for a tight box around the object in the
-    #                   wrist image; learn a color model of it vs the floor
-    #   3. servo down   segment every frame and CamShift-follow the blob;
-    #                   after two verified frames, center it or descend 1 cm
-    #   4. final push   below wrist_stop_z the camera is too close to help —
-    #                   rotate to the grasp pitch and press to the floor
-    #   5. close        squeeze, twist the fabric on, lift
-    #
-    # Steps 1-3 are skipped when wrist_steps is 0 (classic blind grasp).
-    # -------------------------------------------------------------------------
-    def _ee_dbg(self):
-        ee = self._ee_xyz()
-        return [round(v, 4) for v in ee] if ee else None
-
+    # GRASP: search pose -> seed -> servo down -> blind push -> close/twist/lift
+    # (wrist_steps=0 skips to blind hover + push)
     def _wrist_seed(self, prompt, z):
-        """Gemini, where is the object in the wrist image? Returns
-        (center, box) with box = (x, y, w, h) pixels, or (None, None).
-        Asks for a TIGHT bounding box — its center is the object's center,
-        and the box itself seeds the segmentation color model. Gemini places
-        boxes much more reliably than point guesses. Same 640x480 as head."""
-        time.sleep(self._p["wrist_settle_s"])  # let the arm stop swaying
+        """Wrist Gemini box -> (center_px, box) or (None, None)."""
+        time.sleep(self._p["wrist_settle_s"])
         img = self.wrist_image
         text = self._gemini_call(
             img,
@@ -740,127 +520,76 @@ def _wrist_seed(self, prompt, z):
             '{"box_2d":[ymin,xmin,ymax,xmax]} normalized 0-1000, best first, '
             "each box TIGHT around its object. Empty list if not visible.",
         ) if img else None
-        box = self._parse_det_box(text)
+        box = vision.parse_det_box(text)
         px = (box[0] + box[2] / 2.0, box[1] + box[3] / 2.0) if box else None
-        self._dbg("wrist_seed", z=round(z, 3),
-                  px=[round(px[0], 1), round(px[1], 1)] if px else None)
+        self._dbg("wrist_seed", z=z, px=px)
         return px, box
 
     def _next_wrist_hsv(self, last_b64, timeout=1.5):
-        """Wait for a NEW wrist frame (the topic is ~5 Hz) and decode it to
-        HSV. Returns (hsv|None, b64) — b64 unchanged on timeout."""
+        """Wait for a new wrist frame -> (hsv|None, b64)."""
         t0 = time.time()
-        while time.time() - t0 < timeout and not self._cancelled:
+        while time.time() - t0 < timeout:
+            self._checkpoint()
             img = self.wrist_image
             if img and img != last_b64:
-                try:
-                    arr = np.frombuffer(base64.b64decode(img), np.uint8)
-                    bgr = cv2.imdecode(arr, cv2.IMREAD_COLOR)
-                except Exception:  # noqa: BLE001 — a bad frame just skips
-                    bgr = None
-                if bgr is not None:
-                    return cv2.cvtColor(bgr, cv2.COLOR_BGR2HSV), img
+                hsv = vision.b64_to_hsv(img)
+                if hsv is not None:
+                    return hsv, img
             time.sleep(0.04)
         return None, last_b64
 
-    # Why segmentation instead of point tracking: during the descent the
-    # object grows ~2.5x in the image and the fabric deforms — optical-flow
-    # patches don't survive that and slide onto the carpet. A color model is
-    # scale- and deformation-proof: learn what the object looks like COMPARED
-    # to the floor right around it, then find that blob in every frame.
-    _SEG_BINS = [16, 8, 8]                    # H, S, V histogram bins
-    _SEG_RANGES = [0, 180, 0, 256, 0, 256]
-
-    def _seg_model(self, hsv, box):
-        """Likelihood-ratio color model from the seed box: histogram of the
-        object over histogram of a surrounding ring of floor. Bins where the
-        object beats the floor get high weight, shared colors get ~0 — so
-        back-projection lights up the object and stays dark on carpet.
-        Returns a uint8 [16,8,8] lookup table, or None if degenerate."""
-        x, y, w, h = box
-        obj = hsv[y:y + h, x:x + w]
-        rx0, ry0 = max(0, x - w // 2), max(0, y - h // 2)
-        ring = hsv[ry0:y + h + h // 2, rx0:x + w + w // 2]
-        h_obj = cv2.calcHist([obj], [0, 1, 2], None,
-                             self._SEG_BINS, self._SEG_RANGES)
-        h_ring = cv2.calcHist([ring], [0, 1, 2], None,
-                              self._SEG_BINS, self._SEG_RANGES)
-        ratio = h_obj / (np.maximum(h_ring - h_obj, 0.0) + 1.0)
-        if ratio.max() <= 0:
-            return None
-        return (255.0 * ratio / ratio.max()).astype(np.uint8)
-
-    def _seg_track(self, hsv, model, window):
-        """One segmentation step: back-project the color model (a direct
-        numpy bin lookup — cv2.calcBackProject silently returns zeros for
-        3-D histograms on this build) and let CamShift follow the blob from
-        the previous window, adapting it as the object grows during the
-        descent. Returns (center|None, window, score) — None when the
-        likelihood collapsed (lost / occluded) or the window degenerated."""
-        ih = (hsv[:, :, 0].astype(np.int32) * self._SEG_BINS[0]) // 180
-        i_s = (hsv[:, :, 1].astype(np.int32) * self._SEG_BINS[1]) // 256
-        iv = (hsv[:, :, 2].astype(np.int32) * self._SEG_BINS[2]) // 256
-        bp = model[np.clip(ih, 0, self._SEG_BINS[0] - 1), i_s, iv]
-        crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)
-        _rot, window = cv2.CamShift(bp, window, crit)
-        x, y, w, h = window
-        if w < 4 or h < 4 or w * h > 0.4 * IMG_W * IMG_H:
-            return None, window, 0.0
-        score = float(bp[y:y + h, x:x + w].mean())
-        if score < WRIST_SEG_MIN_SCORE:
-            return None, window, score
-        return (x + w / 2.0, y + h / 2.0), window, score
+    def _wrist_done(self, x, y, z, reason):
+        """Telemetry + return value for every _wrist_servo exit."""
+        grab = floor_to_pixel(x + self._p["grasp_x_off"], y, self._p["tilt_deg"])
+        self._dbg("wrist_done", tx=x, ty=y, z=z, reason=reason, grab_px=grab)
+        return x, y, z
+
+    def _wrist_reseed(self, prompt, z, raw):
+        """Persistent tracking loss: one Gemini look + fresh color model
+        (the view changed). Returns (tracker, raw, fail_reason) — tracker
+        is None on failure, fail_reason "" on success."""
+        px, box = self._wrist_seed(prompt, z)
+        if px is None:
+            return None, raw, "lost track"
+        hsv, raw = self._next_wrist_hsv(raw)
+        if hsv is None:
+            return None, raw, "no wrist frames"
+        tracker = _BlobTracker(hsv, box, px)
+        if not tracker.ok:
+            return None, raw, "lost track"
+        return tracker, raw, ""
 
     def _wrist_servo(self, prompt, tx, ty):
-        """Servo the arm down over the object, wrist camera as the eye.
-
-        Watch, then act. Watch: segment the object with a color model
-        (learned once from the Gemini seed box against the floor around it)
-        and follow the blob with CamShift until two consecutive frames
-        agree, arm still. Act: one move — center the blob (nudge x/y toward
-        the wrist box) if it's off, and only once it has been seen INSIDE
-        the box on two consecutive frames descend one wrist_z_step. Center
-        first, then step down; repeat until wrist_stop_z. A failed match
-        gets two frames of patience (blur, mid-move frames, occlusion); a
-        persistent loss spends one Gemini look to re-find the object and
-        relearn the model (wrist_steps looks total, seed included).
-
-        Returns (x, y, z) for the final push. If the object was never seen,
-        the caller's (tx, ty) come back unchanged so the push falls back on
-        the head-camera estimate."""
+        """Wrist CamShift servo: watch until 2 frames agree (arm still),
+        then act — one nudge toward the wrist box, or one wrist_z_step down
+        once it has been seen inside the box twice; repeat to wrist_stop_z.
+        A miss gets 2 frames of patience, then a Gemini re-seed (budget =
+        wrist_steps - 1). Color model, not LK: the object grows/deforms
+        during the descent and optical flow slides off.
+        Returns (x,y,z); falls back to (tx,ty) if never seen."""
         p = self._p
         ee = self._ee_xyz()
         z = ee[2] if ee else p["hover_z"]
-        looks = int(p["wrist_steps"]) - 1  # Gemini budget after the seed
+        looks = int(p["wrist_steps"]) - 1
 
         px, box = self._wrist_seed(prompt, z)
         if px is None:
-            self._dbg("wrist_done", tx=round(tx, 4), ty=round(ty, 4),
-                      z=round(z, 3), reason="not seen")
-            return tx, ty, z
+            return self._wrist_done(tx, ty, z, "not seen")
         x, y = (ee[0], ee[1]) if ee else (tx, ty)  # servo from the real pose
 
         hsv, raw = self._next_wrist_hsv(None)
         if hsv is None:
-            self._dbg("wrist_done", tx=round(tx, 4), ty=round(ty, 4),
-                      z=round(z, 3), reason="no wrist frames")
-            return tx, ty, z
-        model = self._seg_model(hsv, box)  # what the object looks like here
-        if model is None:
-            self._dbg("wrist_done", tx=round(tx, 4), ty=round(ty, 4),
-                      z=round(z, 3), reason="not seen")
-            return tx, ty, z
-        window = box
-        guess = px  # where we expect the blob in the NEXT frame
+            return self._wrist_done(tx, ty, z, "no wrist frames")
+        tracker = _BlobTracker(hsv, box, px)
+        if not tracker.ok:
+            return self._wrist_done(tx, ty, z, "not seen")
+
         deadline = time.time() + WRIST_ALIGN_TIMEOUT_S
         streak = 0    # verified matches since the arm last moved
-        centered = 0  # consecutive verified matches INSIDE the box
-        misses = 0    # consecutive failed matches (blur, mid-move, occlusion)
+        centered = 0  # consecutive matches INSIDE the box
         reason = "reached stop z"
         while z > p["wrist_stop_z"] + 1e-6:
-            if self._cancelled:
-                reason = "cancelled"
-                break
+            self._checkpoint()
             if time.time() > deadline:
                 reason = "timeout"
                 break
@@ -869,87 +598,56 @@ def _wrist_servo(self, prompt, tx, ty):
                 reason = "no wrist frames"
                 break
 
-            pt, window, _score = self._seg_track(hsv, model, window)
-            if pt is not None and math.hypot(
-                    pt[0] - guess[0], pt[1] - guess[1]) > WRIST_MAX_JUMP_PX:
-                pt = None  # a blob elsewhere isn't our object
-            if pt is None:
-                streak = 0
-                centered = 0
-                misses += 1
-                if misses < 3:
-                    window = box  # retry from the last trusted window
-                    continue  # transient (blurred / mid-move frame) — wait
-                if looks <= 0:  # persistent loss — worth one Gemini look?
+            px = tracker.update(hsv)
+            if px is None:
+                streak = centered = 0
+                if tracker.misses < 3:
+                    continue  # transient (blur / mid-move frame) — wait
+                if looks <= 0:
                     reason = "lost track"
                     break
                 looks -= 1
-                pt, box = self._wrist_seed(prompt, z)
-                if pt is None:
-                    reason = "lost track"
-                    break
-                hsv, raw = self._next_wrist_hsv(raw)
-                if hsv is None:
-                    reason = "no wrist frames"
+                tracker, raw, fail = self._wrist_reseed(prompt, z, raw)
+                if tracker is None:
+                    reason = fail
                     break
-                model = self._seg_model(hsv, box)  # the view changed: relearn
-                if model is None:
-                    reason = "lost track"
-                    break
-                window = box
-            misses = 0
-            box = window  # last trusted window
-            px = pt
-            guess = px
+                px = tracker.guess  # the re-seed detection is this frame's fix
             streak += 1
 
             err_u = px[0] - p["wrist_box_u"]
             err_v = px[1] - p["wrist_box_v"]
-            inside = (abs(err_u) <= p["wrist_half_px"]
-                      and abs(err_v) <= p["wrist_half_px"])
+            inside = _inside_box(px, p["wrist_box_u"], p["wrist_box_v"],
+                                 p["wrist_half_px"])
             centered = centered + 1 if inside else 0
-            self._dbg("wrist_servo", px=[round(px[0], 1), round(px[1], 1)],
-                      z=round(z, 3), inside=inside,
-                      tx=round(x, 4), ty=round(y, 4), ee=self._ee_dbg())
+            self._dbg("wrist_servo", px=px, z=z, inside=inside,
+                      tx=x, ty=y, ee=self._ee_xyz())
             if streak < 2:
                 continue  # watch one more frame before trusting it
             if inside and centered < 2:
-                continue  # just entered the box — confirm it stays centered
+                continue  # just entered the box — confirm it stays
 
             if centered >= 2:
                 z = max(p["wrist_stop_z"], z - p["wrist_z_step"])
-                # descending barely moves the (centered) pixel: guess stays px
+                # descent barely moves a centered pixel: guess stays px
             else:
-                # px -> meters: gains are tuned at z=0.15 and shrink as the
-                # camera nears the floor, so scale by the current height.
+                # Gains tuned at z=0.15; scale with camera height.
                 s = (z + WRIST_CAM_ABOVE_EE) / (0.15 + WRIST_CAM_ABOVE_EE)
                 cap = p["wrist_step_max"]
                 x += max(-cap, min(cap, p["wrist_kx"] / 100.0 * err_v * s))
                 y += max(-cap, min(cap, p["wrist_ky"] / 100.0 * err_u * s))
                 x, y = armlib.clamp_reach(x, y)
-                # feed-forward: this correction should land the object at the
-                # box center — tell the tracker to look for it there
-                guess = (p["wrist_box_u"], p["wrist_box_v"])
+                # feed-forward: expect the blob at the box center next frame
+                tracker.guess = (p["wrist_box_u"], p["wrist_box_v"])
             armlib.move_checked(self.manipulation, x, y, z,
                                 pitch=p["wrist_pitch"],
                                 duration=p["wrist_move_s"], logger=self.logger)
             streak = 0
-            centered = 0  # the view shifted — re-confirm centering
+            centered = 0  # view shifted — re-confirm centering
 
-        grab = floor_to_pixel(x + p["grasp_x_off"], y, p["tilt_deg"])
-        self._dbg("wrist_done", tx=round(x, 4), ty=round(y, 4), z=round(z, 3),
-                  reason=reason,
-                  grab_px=[round(grab[0], 1), round(grab[1], 1)]
-                  if grab else None)
-        return x, y, z
+        return self._wrist_done(x, y, z, reason)
 
     def _goto_search_pose(self, bearing):
-        """Joint move to the operator's posed search arm (WRIST_SEARCH_ARM):
-        up high, elbow ~90°, wrist camera on the floor ahead. j1 aims along
-        `bearing`, j4 completes the camera pitch (j2+j3+j4 = wrist_pitch),
-        the gripper keeps its position. Starting here also pins the IK to
-        the elbow-up branch — LMA converges to the solution nearest the
-        current joints — so the whole descent keeps this arm shape."""
+        """WRIST_SEARCH_ARM aimed at bearing; pins IK to elbow-up branch."""
         a = WRIST_SEARCH_ARM
         j6 = self._gripper_j6()
         pose = [bearing, a[1], a[2],
@@ -958,55 +656,46 @@ def _goto_search_pose(self, bearing):
         self.manipulation.move_to_joint_positions(
             joint_positions=pose, duration=self._p["hover_s"], blocking=True)
         time.sleep(0.3)
-        self._dbg("hover", ee=self._ee_dbg())
+        self._dbg("hover", ee=self._ee_xyz())
 
     def _open_gripper_checked(self):
-        """Open the claw, verified (trip recovery) — see armlib.open_checked."""
+        """Open gripper with trip recovery."""
         armlib.open_checked(
             self.manipulation, self._gripper_j6, logger=self.logger,
-            on_reboot=lambda j6: self._dbg("gripper_reboot", j6=_r(j6)),
+            on_reboot=lambda j6: self._dbg("gripper_reboot", j6=j6),
         )
 
     def _push_to_floor(self, x, y, z_from, deep):
-        """The last blind centimeters: rotate to the grasp pitch and descend
-        rung by rung to the floor. A rung that fails is floor contact /
-        overload — recover and grasp there. Raises if the arm never got low
-        enough for a grasp to make sense."""
+        """Blind descent ladder to floor. Failed rung = contact; abort if still high."""
         p = self._p
         rungs = [p["descend_z1"], p["descend_z2"], p["descend_z3"],
                  0.0 if deep else p["floor_z"]]
         for z in rungs:
-            if z >= z_from - 1e-6:  # the servo already descended past this
+            if z >= z_from - 1e-6:
                 continue
-            if self._cancelled:
-                return
+            self._checkpoint()
             ok = self.manipulation.move_to_cartesian_pose(
                 x=x, y=y, z=z, roll=0.0, pitch=p["arm_pitch"], yaw=0.0,
                 duration=p["descend_s"], blocking=True,
             )
-            self._dbg("descend", z=round(z, 3), ok=bool(ok), ee=self._ee_dbg())
+            self._dbg("descend", z=z, ok=bool(ok), ee=self._ee_xyz())
             if not ok:
                 armlib.recover(self.manipulation, self.logger)
                 break
         ee = self._ee_xyz()
         if ee is not None and ee[2] > p["descend_abort_z"]:
-            self._dbg("grasp_abort", reason="arm would not descend",
-                      ee_z=round(ee[2], 4))
+            self._dbg("grasp_abort", reason="arm would not descend", ee_z=ee[2])
             armlib.recover(self.manipulation, self.logger)
             raise armlib.ArmUnhealthy("arm would not descend")
 
     def _close_twist_lift(self, x, y):
-        """Take it: squeeze, wind the fabric onto the fingers, lift. Twist
-        and lift happen in JOINT space — an IK lift would recompute joint5
-        and unwind the object off the fingers. j6 holds the FULL close
-        command throughout: re-commanding the achieved (stalled-on-object)
-        position instead relaxes the squeeze mid-lift and drops socks."""
+        """Close, joint-space twist+lift (IK would unwind j5). Hold full close cmd."""
         p = self._p
         j6_open = self._gripper_j6()
         armlib.close(self.manipulation, strength=p["close_strength"],
                      duration=p["close_s"])
         time.sleep(p["close_settle_s"])
-        self._dbg("close", j6_open=_r(j6_open), j6=_r(self._gripper_j6()),
+        self._dbg("close", j6_open=j6_open, j6=self._gripper_j6(),
                   strength=p["close_strength"])
 
         grip = -p["close_strength"]
@@ -1017,98 +706,85 @@ def _close_twist_lift(self, x, y):
             self.manipulation.move_to_joint_positions(
                 joint_positions=j, duration=1.0, blocking=True)
             time.sleep(0.3)
-            self._dbg("twist", j4=round(j[4], 3))
+            self._dbg("twist", j4=j[4])
             j = list(self.joint_states["position"][:6])
-            j[1] = max(-1.4, j[1] - p["lift_rad"])  # shoulder up = lift
+            j[1] = max(-1.4, j[1] - p["lift_rad"])
             j[5] = grip
             self.manipulation.move_to_joint_positions(
                 joint_positions=j, duration=2.0, blocking=True)
             time.sleep(0.3)
-            self._dbg("lift", ee=self._ee_dbg(), j6=_r(self._gripper_j6()))
-        except (KeyError, IndexError, TypeError):  # no joint state — IK lift
+            self._dbg("lift", ee=self._ee_xyz(), j6=self._gripper_j6())
+        except (KeyError, IndexError, TypeError):
             armlib.move_checked(self.manipulation, x, y, 0.22,
                                 pitch=p["arm_pitch"], duration=2.0, tol=0.10,
                                 logger=self.logger)
-            self._dbg("lift", ee=self._ee_dbg(), j6=_r(self._gripper_j6()),
+            self._dbg("lift", ee=self._ee_xyz(), j6=self._gripper_j6(),
                       ik_fallback=True)
 
     def _grasp_at(self, prompt, xy, deep=False):
-        """The grasp, start to finish — see the section comment above. `xy`
-        is the object on the floor in base_link. Every number reads self._p
-        so the panel can retune a grasp mid-run."""
+        """Full grasp at floor xy (base_link). Reads live self._p knobs."""
         p = self._p
-        # aim short: fingertips land ~grasp_x_off forward of ee_link
         x, y = armlib.clamp_reach(xy[0] - p["grasp_x_off"], xy[1])
 
-        # telemetry: where the object is vs where the fingers will land (they
-        # differ only when the object is outside the reach box — aim clamped)
         grab_px = floor_to_pixel(x + p["grasp_x_off"], y, p["tilt_deg"])
         obj_px = floor_to_pixel(xy[0], xy[1], p["tilt_deg"])
         clamped = (abs((xy[0] - p["grasp_x_off"]) - x) > 1e-4
                    or abs(xy[1] - y) > 1e-4)
-        self._dbg("grasp", xy=[round(xy[0], 4), round(xy[1], 4)],
-                  tx=round(x, 4), ty=round(y, 4), deep=deep,
-                  grab_px=[round(grab_px[0], 1), round(grab_px[1], 1)]
-                  if grab_px else None,
-                  obj_px=[round(obj_px[0], 1), round(obj_px[1], 1)]
-                  if obj_px else None,
-                  clamped=clamped)
+        self._dbg("grasp", xy=xy, tx=x, ty=y, deep=deep,
+                  grab_px=grab_px, obj_px=obj_px, clamped=clamped)
 
         self._open_gripper_checked()
 
         if p["wrist_steps"] >= 1:
             self._goto_search_pose(math.atan2(y, x))
             x, y, z = self._wrist_servo(prompt, x, y)
-        else:  # classic blind grasp: IK hover above the estimate
+        else:
             z = p["hover_z"]
             armlib.move_checked(self.manipulation, x, y, z,
                                 pitch=p["arm_pitch"], duration=p["hover_s"],
                                 logger=self.logger)
-            self._dbg("hover", ee=self._ee_dbg())
+            self._dbg("hover", ee=self._ee_xyz())
 
         self._push_to_floor(x, y, z, deep)
-        if self._cancelled:
-            return
+        self._checkpoint()  # last exit before the fingers commit
         self._close_twist_lift(x, y)
 
-    # -------------------------------------------------------------------------
-    # VERIFY — did we actually get it?
-    # -------------------------------------------------------------------------
     def _grasp_verified(self, prompt):
-        """Back up so a held object travels with us, then ask the head camera
-        if the floor is clear. (Wrist cam is mirrored — don't trust it.)"""
+        """Back up, then check floor clear + gripper not open. Gemini gets
+        BOTH cameras: the head view answers "is it still on the floor?", the
+        wrist view (mirrored) can show the object in the fingers so a held
+        object isn't mistaken for a dropped one."""
         self._drive(-VERIFY_BACKUP_M)
         time.sleep(self._p["settle_s"])
         j6 = self._gripper_j6()
-        img = self.main_image
+        images = [img for img in (self.main_image, self.wrist_image) if img]
+        wrist_note = (
+            " Image 2 is the WRIST camera next to the gripper fingers "
+            "(mirrored) — the object may be visible held in the fingers there."
+            if len(images) > 1 else ""
+        )
         floor_text = self._gemini_call(
-            img,
-            f"Robot head camera looking at the floor. Is '{prompt}' lying ON the "
-            "floor/carpet anywhere in view? Something hanging from the robot's "
-            "gripper does NOT count as on the floor. Answer only YES or NO.",
-        ) if img else None
+            images,
+            f"Robot just tried to pick up '{prompt}'. Image 1 is the head "
+            f"camera looking at the floor.{wrist_note} "
+            f"Is '{prompt}' lying ON the floor/carpet anywhere in view? "
+            "Something hanging from the robot's gripper or held between the "
+            "gripper fingers does NOT count as on the floor. "
+            "Answer only YES or NO.",
+        ) if images else None
         floor_clear = bool(floor_text) and "NO" in floor_text.upper()
         j6_ok = j6 is not None and j6 > GRIPPER_EMPTY_J6 + 0.02
         held = floor_clear and j6_ok
         self.logger.info(
             f"[PickAnyObject] verify: floor={floor_text!r} j6={j6} "
-            f"-> {'HELD' if held else 'NOT HELD'}"
+            f"({len(images)} cams) -> {'HELD' if held else 'NOT HELD'}"
         )
-        self._dbg("verify", floor_clear=floor_clear, j6=_r(j6), held=held)
+        self._dbg("verify", floor_clear=floor_clear, j6=j6, held=held,
+                  cams=len(images))
         return held
 
-    # -------------------------------------------------------------------------
-    # entry point
-    # -------------------------------------------------------------------------
     def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
-        """
-        Pick up the object described by `prompt` from the floor.
-
-        Args:
-            prompt: Natural-language description, e.g. "the white sock".
-            max_base_steps: kept for interface compatibility; unused in v3.
-        """
-        self._cancelled = False
+        """Pick up `prompt` from the floor. max_base_steps unused (compat)."""
         if self._proxy is None:
             return "Innate proxy not configured (INNATE_SERVICE_KEY)", SkillResult.FAILURE
         if self.manipulation is None or self.mobility is None:
@@ -1121,7 +797,7 @@ def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
         try:
             self.head.set_position(int(round(self._p["tilt_deg"])))
             time.sleep(0.5)
-            # Fold the arm to rest BEFORE searching to not hide the camera pov
+            # Rest arm first so it doesn't occlude the head camera.
             try:
                 arm_rest_position()
             except SkillFailed as e:
@@ -1135,8 +811,6 @@ def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
                     SkillResult.FAILURE,
                 )
 
-            if self._cancelled:
-                return "Cancelled", SkillResult.CANCELLED
             xy = self._position_above(prompt, xy)
             if xy is None:
                 return (
@@ -1158,6 +832,8 @@ def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
                 "backing up)",
                 SkillResult.FAILURE,
             )
+        except SkillCancelled:
+            return "Pick cancelled", SkillResult.CANCELLED
         except armlib.ArmUnhealthy as e:
             self.say("My arm isn't responding properly, stopping.")
             return f"Arm servo failure: {e}", SkillResult.FAILURE
diff --git a/workspace/innate_skills/recalibrate_manual.py b/workspace/innate_skills/recalibrate_manual.py
index ba142f72b..75c6f09d2 100644
--- a/workspace/innate_skills/recalibrate_manual.py
+++ b/workspace/innate_skills/recalibrate_manual.py
@@ -12,7 +12,7 @@
 import math
 from datetime import datetime
 from pathlib import Path
-from typing import Literal
+from typing import Literal, cast
 
 from brain_client.skills.types import Interface, InterfaceType, RobotState, RobotStateType, Skill, SkillResult
 
@@ -114,7 +114,7 @@ def execute(self, corner: CalibrationCorner):
         if self.manipulation is None:
             return "Manipulation interface not available", SkillResult.FAILURE
 
-        corner = corner.upper().strip()
+        corner = cast(CalibrationCorner, corner.upper().strip())
         if corner not in ("A8", "H8"):
             return f"Invalid corner '{corner}'. Must be 'A8' or 'H8'.", SkillResult.FAILURE
 
diff --git a/workspace/innate_skills/record_position.py b/workspace/innate_skills/record_position.py
index dae03042c..97a2d9008 100644
--- a/workspace/innate_skills/record_position.py
+++ b/workspace/innate_skills/record_position.py
@@ -9,7 +9,7 @@
 import json
 from datetime import datetime
 from pathlib import Path
-from typing import Literal
+from typing import Literal, cast
 
 from brain_client.skills.types import Interface, InterfaceType, RobotState, RobotStateType, Skill, SkillResult
 
@@ -49,7 +49,7 @@ def execute(self, corner: BoardCorner):
         if self.manipulation is None:
             return "Manipulation interface not available", SkillResult.FAILURE
 
-        corner = corner.lower().replace("-", "_").replace(" ", "_")
+        corner = cast(BoardCorner, corner.lower().replace("-", "_").replace(" ", "_"))
         if corner not in VALID_CORNERS:
             return f"Invalid corner '{corner}'. Must be one of: {VALID_CORNERS}", SkillResult.FAILURE
 
diff --git a/workspace/innate_skills/reset_chess_game.py b/workspace/innate_skills/reset_chess_game.py
index 6886829b2..70c6f195b 100644
--- a/workspace/innate_skills/reset_chess_game.py
+++ b/workspace/innate_skills/reset_chess_game.py
@@ -7,7 +7,7 @@
 
 import json
 from pathlib import Path
-from typing import Literal
+from typing import Literal, cast
 
 from brain_client.skills.types import Skill, SkillResult
 
@@ -72,7 +72,7 @@ def execute(self, robot_color: RobotColor = "white"):
         Args:
             robot_color: Which side the robot plays ('white' or 'black').
         """
-        robot_color = robot_color.strip().lower()
+        robot_color = cast(RobotColor, robot_color.strip().lower())
         if robot_color not in ROBOT_COLORS:
             return f"Invalid robot_color '{robot_color}'. Must be 'white' or 'black'.", SkillResult.FAILURE
         if not self._is_calibrated():
diff --git a/workspace/innate_skills/retrieve_emails.py b/workspace/innate_skills/retrieve_emails.py
index c1ea20344..7dfb64cc8 100644
--- a/workspace/innate_skills/retrieve_emails.py
+++ b/workspace/innate_skills/retrieve_emails.py
@@ -168,7 +168,11 @@ def execute(self, count: int = 5):
                         continue
 
                     # Parse the email
-                    msg = email.message_from_bytes(msg_data[0][1])
+                    payload = msg_data[0]
+                    if not isinstance(payload, tuple):
+                        self.logger.warning(f"Unexpected fetch payload for email {email_id}")
+                        continue
+                    msg = email.message_from_bytes(payload[1])
 
                     # Extract email information
                     subject = self._decode_header_value(msg.get("Subject", "No Subject"))
diff --git a/workspace/innate_skills/send_email.py b/workspace/innate_skills/send_email.py
index 4937b6259..32382f3f3 100644
--- a/workspace/innate_skills/send_email.py
+++ b/workspace/innate_skills/send_email.py
@@ -36,7 +36,7 @@ def guidelines(self):
             "potential emergency is detected and assistance might be required."
         )
 
-    def execute(self, subject: str, message: str, recipients: list[str] | str = None):
+    def execute(self, subject: str, message: str, recipients: list[str] | str | None = None):
         """
         Sends an email to the specified recipient(s) (or default list if none provided).
 
diff --git a/workspace/innate_skills/send_picture_via_email.py b/workspace/innate_skills/send_picture_via_email.py
index d22ab94be..769420aaf 100644
--- a/workspace/innate_skills/send_picture_via_email.py
+++ b/workspace/innate_skills/send_picture_via_email.py
@@ -38,7 +38,7 @@ def guidelines(self):
             "The view will be automatically attached."
         )
 
-    def execute(self, subject: str, message: str, recipient: str = None):
+    def execute(self, subject: str, message: str, recipient: str | None = None):
         """
         Sends an email with the last captured image attached.
 
diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
index 3b2c35e83..5e30e5596 100644
--- a/workspace/skill_lib/arm.py
+++ b/workspace/skill_lib/arm.py
@@ -1,39 +1,32 @@
 #!/usr/bin/env python3
 # SPDX-License-Identifier: Apache-2.0
 # Copyright (c) 2026 Innate Inc
-"""Arm primitives shared by skills. The hardware lessons live here once.
+"""Shared arm primitives (blocking moves, recovery, reach clamp).
 
-Plain functions: pass the manipulation interface (and, where needed, a
-joint-state getter) explicitly — no ambient context, no Skill machinery.
-Rule of thumb: short blocking device commands, recovery sequences, and
-pure math belong here; anything long-running or cancellable stays a Skill.
-
-Import gotcha (applies to all of workspace/skill_lib): import at the TOP of
-a skill file. The skill loader puts the repo root on sys.path only while the
-skill module executes, so a lazy import inside execute() will not resolve.
+Pass interfaces explicitly. Import at TOP of skill files — lazy imports
+inside execute() fail (loader only puts repo root on path during load).
 """
 
 import math
 import time
 
-# The arm's grasp-reach box in base_link meters — beyond it, IK strains or
-# the fingers land short. The webapp draws this box (REACH in pickTunePanel.js).
+# Grasp reach box (base_link m).
 REACH_X = (0.22, 0.40)
 REACH_Y = (-0.10, 0.10)
 
 
 class ArmUnhealthy(RuntimeError):
-    """Servo brownout / refusal — abort loudly, never continue limp."""
+    """Servo brownout/refusal — abort, don't continue limp."""
 
 
 def clamp_reach(x, y):
-    """Clamp a grasp / servo target into the arm's reach box."""
+    """Clamp (x, y) into the arm reach box."""
     return (max(REACH_X[0], min(REACH_X[1], x)),
             max(REACH_Y[0], min(REACH_Y[1], y)))
 
 
 def ee_xyz(manipulation):
-    """Current end-effector position from FK, or None while state is absent."""
+    """FK end-effector (x,y,z), or None."""
     pose = manipulation.get_current_end_effector_pose()
     try:
         p = pose["position"]
@@ -43,7 +36,7 @@ def ee_xyz(manipulation):
 
 
 def gripper_j6(joint_states):
-    """Gripper joint (j6) from a joint_states dict, or None."""
+    """Gripper joint j6, or None."""
     try:
         return joint_states["position"][5] if joint_states else None
     except (KeyError, IndexError, TypeError):
@@ -51,8 +44,7 @@ def gripper_j6(joint_states):
 
 
 def recover(manipulation, logger=None):
-    """Reboot servos + torque on — the only cure for an overcurrent trip or
-    a brownout (torque_on alone can't clear a tripped servo's hardware error)."""
+    """Reboot servos + torque on (clears overcurrent trip / brownout)."""
     if logger:
         logger.warning("[arm] recovering (reboot + torque on)")
     manipulation.reboot_servos()
@@ -62,9 +54,7 @@ def recover(manipulation, logger=None):
 
 
 def move_checked(manipulation, x, y, z, pitch, duration=1.5, tol=0.05, logger=None):
-    """Cartesian move with a health check: verify FK landed within tol,
-    recover + retry once, then raise ArmUnhealthy rather than let a limp
-    arm continue into the floor."""
+    """Cartesian move; verify FK within tol, recover+retry once, else raise."""
     for attempt in (1, 2):
         ok = manipulation.move_to_cartesian_pose(
             x=x, y=y, z=z, roll=0.0, pitch=pitch, yaw=0.0,
@@ -84,11 +74,7 @@ def move_checked(manipulation, x, y, z, pitch, duration=1.5, tol=0.05, logger=No
 
 def open_checked(manipulation, get_j6, percent=100.0, duration=1.0,
                  logger=None, on_reboot=None):
-    """Open the gripper and VERIFY it opened. A prior hard close can
-    overcurrent-TRIP the gripper servo — a hardware error torque_on alone
-    can't clear — after which open silently does nothing and the hand stays
-    shut. If j6 says it didn't open, reboot to clear the trip and retry.
-    on_reboot(j6) is called before the reboot (telemetry hook)."""
+    """Open gripper and verify j6. Reboot+retry if tripped shut. on_reboot(j6) hook."""
     manipulation.torque_on()  # a torque-disabled servo won't move at all
     ok = manipulation.open_gripper(percent=percent, duration=duration, blocking=True)
     j6 = get_j6()
@@ -104,10 +90,7 @@ def open_checked(manipulation, get_j6, percent=100.0, duration=1.0,
 
 
 def close(manipulation, strength=0.0, duration=1.0):
-    """Close the gripper. strength = extra squeeze past the closed stop.
-    Keep it <= ~0.6 against a real object: higher stalls j6 at max current
-    on the fingers and overcurrent-trips the servo (open then no-ops until
-    a reboot)."""
+    """Close gripper. strength = extra squeeze; keep <=~0.6 or servo trips."""
     manipulation.torque_on()
     return bool(manipulation.close_gripper(strength=strength, duration=duration,
                                            blocking=True))
diff --git a/workspace/skill_lib/gemini.py b/workspace/skill_lib/gemini.py
new file mode 100644
index 000000000..6371d330a
--- /dev/null
+++ b/workspace/skill_lib/gemini.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Innate Inc
+"""Gemini vision via Innate proxy (/v1/chat/completions). Service key needs
+"gemini" access or proxy returns 403. Import at TOP of skill files (see arm.py).
+"""
+
+import json
+import time
+
+from innate_proxy import ProxyClient
+
+SERVICE = "gemini"
+ENDPOINT = "/v1/chat/completions"
+MODEL = "gemini-3.5-flash"
+
+
+def make_client():
+    """ProxyClient, or None if credentials missing."""
+    client = ProxyClient()
+    return client if client.is_available() else None
+
+
+def ask_image(client, images_b64, question, logger=None, retries=3):
+    """JPEG(s) + question -> reply text. None if no client / all retries fail.
+    images_b64: one base64 string or a list of them — sent in order, so the
+    question can refer to them as image 1, image 2, ..."""
+    if client is None:
+        return None
+    if isinstance(images_b64, str):
+        images_b64 = [images_b64]
+    content = [{"type": "text", "text": question}]
+    content += [
+        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b}"}}
+        for b in images_b64
+    ]
+    body = {
+        "model": MODEL,
+        "temperature": 0.0,
+        "messages": [{"role": "user", "content": content}],
+    }
+    for attempt in range(retries):
+        try:
+            with client.request_stream(
+                SERVICE, ENDPOINT, method="POST", json=body,
+            ) as resp:
+                resp.raise_for_status()
+                data = json.loads(resp.read())
+            return data["choices"][0]["message"]["content"] or ""
+        except Exception as e:  # noqa: BLE001
+            if logger:
+                logger.warning(
+                    f"[gemini] vision call failed (try {attempt + 1}/{retries}): {e}"
+                )
+            if attempt < retries - 1:
+                time.sleep(2.0 * (attempt + 1))
+    return None
diff --git a/workspace/skill_lib/geometry.py b/workspace/skill_lib/geometry.py
index 16d2e76ca..b832def3e 100644
--- a/workspace/skill_lib/geometry.py
+++ b/workspace/skill_lib/geometry.py
@@ -1,13 +1,7 @@
 #!/usr/bin/env python3
 # SPDX-License-Identifier: Apache-2.0
 # Copyright (c) 2026 Innate Inc
-"""Head-camera <-> floor geometry. Pure math: no ROS, no depth sensor — a
-pinhole model plus the URDF head kinematics is enough to raycast a pixel
-onto the floor plane (base_footprint == base_link, so the floor is z=0).
-
-The webapp mirrors these constants and both projections (pickTunePanel.js)
-so the pick box can be drawn without a skill round trip — keep them in sync.
-"""
+"""Head-camera <-> floor (z=0) via pinhole + URDF. Keep in sync with pickOverlay.js."""
 
 import math
 
@@ -18,7 +12,6 @@
 
 
 def _head_rot(tilt_rad):
-    # pitch about +y: nose down is negative tilt in our convention
     c, s = math.cos(tilt_rad), math.sin(tilt_rad)
     return ((c, 0.0, -s), (0.0, 1.0, 0.0), (s, 0.0, c))
 
@@ -28,26 +21,23 @@ def _rot(R, v):
 
 
 def pixel_to_floor(u, v, head_tilt_deg):
-    """Cast a ray from the camera through pixel (u,v) and intersect z=0.
-    None if the ray misses the floor or lands behind the robot."""
+    """Pixel (u,v) -> floor (x,y) in base_link, or None."""
     fx = IMG_W / (2.0 * math.tan(math.radians(HFOV_DEG) / 2.0))
     cx, cy = IMG_W / 2.0, IMG_H / 2.0
     R = _head_rot(math.radians(head_tilt_deg))
     cam = tuple(HEAD_ORIGIN[i] + _rot(R, CAM_IN_HEAD)[i] for i in range(3))
-    # camera frame in base_link: forward, right, down (optical convention)
     fwd, right, down = _rot(R, (1, 0, 0)), _rot(R, (0, -1, 0)), _rot(R, (0, 0, -1))
     xo, yo = (u - cx) / fx, (v - cy) / fx
     d = tuple(fwd[i] + xo * right[i] + yo * down[i] for i in range(3))
-    if d[2] >= -1e-6:  # ray not pointing at the floor
+    if d[2] >= -1e-6:
         return None
     t = -cam[2] / d[2]
     x, y = cam[0] + t * d[0], cam[1] + t * d[1]
-    return (x, y) if x > 0 else None  # behind the robot = nonsense
+    return (x, y) if x > 0 else None
 
 
 def floor_to_pixel(x, y, head_tilt_deg):
-    """Inverse: floor point (x,y,0) -> image pixel, or None behind the
-    image plane. Exact inverse of pixel_to_floor (round-trips to <0.1 px)."""
+    """Floor (x,y) -> pixel, or None. Inverse of pixel_to_floor."""
     fx = IMG_W / (2.0 * math.tan(math.radians(HFOV_DEG) / 2.0))
     cx, cy = IMG_W / 2.0, IMG_H / 2.0
     R = _head_rot(math.radians(head_tilt_deg))
@@ -55,7 +45,7 @@ def floor_to_pixel(x, y, head_tilt_deg):
     fwd, right, down = _rot(R, (1, 0, 0)), _rot(R, (0, -1, 0)), _rot(R, (0, 0, -1))
     D = (x - cam[0], y - cam[1], -cam[2])
     a = sum(D[i] * fwd[i] for i in range(3))
-    if a <= 1e-6:  # on or behind the image plane
+    if a <= 1e-6:
         return None
     b = sum(D[i] * right[i] for i in range(3))
     c = sum(D[i] * down[i] for i in range(3))
diff --git a/workspace/skill_lib/vision.py b/workspace/skill_lib/vision.py
new file mode 100644
index 000000000..e5d07a86b
--- /dev/null
+++ b/workspace/skill_lib/vision.py
@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Innate Inc
+"""Stateless vision helpers: decode, Gemini parse, LK track, color seg.
+
+Import at the TOP of skill files (see arm.py).
+"""
+
+import base64
+import json
+import re
+from typing import Any
+
+import cv2
+import numpy as np
+
+from workspace.skill_lib.geometry import IMG_H, IMG_W
+
+def b64_to_gray(image_b64):
+    """base64 JPEG -> gray ndarray, or None."""
+    try:
+        arr = np.frombuffer(base64.b64decode(image_b64), np.uint8)
+        return cv2.imdecode(arr, cv2.IMREAD_GRAYSCALE)
+    except Exception:  # noqa: BLE001 — a bad frame just skips a cycle
+        return None
+
+
+def b64_to_hsv(image_b64):
+    """base64 JPEG -> HSV ndarray, or None."""
+    try:
+        arr = np.frombuffer(base64.b64decode(image_b64), np.uint8)
+        bgr = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+    except Exception:  # noqa: BLE001
+        return None
+    return cv2.cvtColor(bgr, cv2.COLOR_BGR2HSV) if bgr is not None else None
+
+
+def parse_dets(text):
+    """Parse Gemini JSON list of detection dicts."""
+    if not text:
+        return []
+    text = re.sub(r"```(?:json)?", "", text)
+    m = re.search(r"\[.*\]", text, re.S)
+    if not m:
+        return []
+    try:
+        dets = json.loads(m.group(0))
+    except json.JSONDecodeError:
+        return []
+    return [d for d in dets if isinstance(d, dict)]
+
+
+def _box_corners_px(det):
+    """box_2d [ymin,xmin,ymax,xmax] 0-1000 -> (x0,y0,x1,y1) px."""
+    b = det.get("box_2d")
+    if not b or len(b) < 4:
+        return None
+    y0, x0, y1, x1 = [float(v) for v in b[:4]]
+    y0, y1 = sorted((y0, y1))
+    x0, x1 = sorted((x0, x1))
+    return (x0 / 1000.0 * IMG_W, y0 / 1000.0 * IMG_H,
+            x1 / 1000.0 * IMG_W, y1 / 1000.0 * IMG_H)
+
+
+def parse_det_px(text):
+    """Best (u, v) from a Gemini detection reply."""
+    for det in parse_dets(text):
+        gp = det.get("grasp_point")
+        if gp and len(gp) >= 2:
+            return (float(gp[1]) / 1000.0 * IMG_W, float(gp[0]) / 1000.0 * IMG_H)
+        c = _box_corners_px(det)
+        if c:
+            return ((c[0] + c[2]) / 2.0, (c[1] + c[3]) / 2.0)
+    return None
+
+
+def parse_det_box(text):
+    """Best (x, y, w, h) from a Gemini detection reply."""
+    for det in parse_dets(text):
+        c = _box_corners_px(det)
+        if not c:
+            continue
+        x, y = int(c[0]), int(c[1])
+        w, h = int(c[2]) - x, int(c[3]) - y
+        if w >= 8 and h >= 8:
+            return (x, y, w, h)
+    return None
+
+
+LK_PARAMS: dict[str, Any] = dict(
+    winSize=(21, 21), maxLevel=3,
+    criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 20, 0.03),
+)
+
+
+def grid_pts(u, v, step=12, n=2):
+    """(2n+1)^2 LK feature patch around (u,v)."""
+    pts = [[u + dx * step, v + dy * step]
+           for dx in range(-n, n + 1) for dy in range(-n, n + 1)]
+    return np.array(pts, dtype=np.float32).reshape(-1, 1, 2)
+
+
+def track_point(prev_gray, gray, grid):
+    """One LK step -> median pixel, or None if lost."""
+    # nextPts=None is the standard cv2 idiom; the stubs demand an array.
+    nxt, status, _ = cv2.calcOpticalFlowPyrLK(prev_gray, gray, grid, None,  # pyright: ignore[reportCallIssue, reportArgumentType]
+                                              **LK_PARAMS)
+    if nxt is None or status is None:
+        return None
+    good = nxt[status.flatten() == 1].reshape(-1, 2)
+    if len(good) < 3:
+        return None
+    return float(np.median(good[:, 0])), float(np.median(good[:, 1]))
+
+
+# Color seg for growing/deforming objects (LK slides off fabric during descent).
+_SEG_BINS = [16, 8, 8]
+_SEG_RANGES = [0, 180, 0, 256, 0, 256]
+
+
+def seg_model(hsv, box):
+    """Object/floor hist-ratio LUT for back-projection, or None."""
+    x, y, w, h = box
+    obj = hsv[y:y + h, x:x + w]
+    rx0, ry0 = max(0, x - w // 2), max(0, y - h // 2)
+    ring = hsv[ry0:y + h + h // 2, rx0:x + w + w // 2]
+    h_obj = cv2.calcHist([obj], [0, 1, 2], None, _SEG_BINS, _SEG_RANGES)
+    h_ring = cv2.calcHist([ring], [0, 1, 2], None, _SEG_BINS, _SEG_RANGES)
+    ratio = h_obj / (np.maximum(h_ring - h_obj, 0.0) + 1.0)
+    if ratio.max() <= 0:
+        return None
+    return (255.0 * ratio / ratio.max()).astype(np.uint8)
+
+
+def seg_track(hsv, model, window, min_score=25.0):
+    """Back-project + CamShift -> (center|None, window, score).
+    Numpy bin lookup (cv2.calcBackProject broken for 3-D hist here)."""
+    ih = (hsv[:, :, 0].astype(np.int32) * _SEG_BINS[0]) // 180
+    i_s = (hsv[:, :, 1].astype(np.int32) * _SEG_BINS[1]) // 256
+    iv = (hsv[:, :, 2].astype(np.int32) * _SEG_BINS[2]) // 256
+    bp = model[np.clip(ih, 0, _SEG_BINS[0] - 1), i_s, iv]
+    crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)
+    _rot, window = cv2.CamShift(bp, window, crit)
+    x, y, w, h = window
+    if w < 4 or h < 4 or w * h > 0.4 * IMG_W * IMG_H:
+        return None, window, 0.0
+    score = float(bp[y:y + h, x:x + w].mean())
+    if score < min_score:
+        return None, window, score
+    return (x + w / 2.0, y + h / 2.0), window, score

From d13b1e066b34a991191435484455530718b27f9c Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Fri, 17 Jul 2026 07:54:07 +0000
Subject: [PATCH 05/19] fix(webapp): pick/wrist boxes track the skill's live
 params again

The pickOverlay rewrite pinned the boxes to hardcoded TUNABLE defaults;
the old panel drew them from params synced off the debug topic (and drag
published updates back). Any live-tuned value left the drawn box lying
about where the skill actually aims.

Seed a live P dict with the defaults and resync it from every run_start
and params event (the skill broadcasts its full dict on both), including
mid-run tuning acks. Non-numeric payload values are ignored.

Verified headlessly (node + DOM stubs, real module): box lands within
0.05px of Python floor_to_pixel for default and tuned params, moves on a
mid-run params ack, size follows box_half_px, hides on run_end.
---
 webapp/js/teleop/pickOverlay.js | 52 +++++++++++++++++++++++----------
 1 file changed, 36 insertions(+), 16 deletions(-)

diff --git a/webapp/js/teleop/pickOverlay.js b/webapp/js/teleop/pickOverlay.js
index cd9fb35bf..94d5e4221 100644
--- a/webapp/js/teleop/pickOverlay.js
+++ b/webapp/js/teleop/pickOverlay.js
@@ -20,16 +20,31 @@
 
 import { PICK_DEBUG_TOPIC } from "../constants.js";
 
-// Display-only mirrors of the skill's aim defaults (TUNABLE in
-// pick_any_object.py) — the boxes are drawn from these, never written.
-const SWEET_X = 0.3;
-const BOX_Y = 0;
-const BOX_HALF_PX = 40;
-const ACCEPT_FRAC = 0.5;
-const TILT_DEG = -20;
-const WRIST_BOX_U = 320;
-const WRIST_BOX_V = 240;
-const WRIST_HALF_PX = 60;
+// Live copies of the skill's aim params, seeded with the TUNABLE defaults
+// from pick_any_object.py. The skill broadcasts its full live dict on every
+// run_start and params debug event — we resync from those so the boxes are
+// drawn where the skill actually aims, not where the defaults say it would
+// (live tuning overrides survive in the running skill between runs).
+// Display-only: never written back.
+const P = {
+  sweet_x: 0.3,
+  box_y: 0,
+  box_half_px: 40,
+  accept_frac: 0.5,
+  tilt_deg: -20,
+  wrist_box_u: 320,
+  wrist_box_v: 240,
+  wrist_half_px: 60,
+};
+
+/** Fold a params payload from the debug topic into P (unknown keys ignored).
+ *  @param {any} params */
+function syncParams(params) {
+  if (!params || typeof params !== "object") return;
+  for (const k of Object.keys(P)) {
+    if (typeof params[k] === "number" && Number.isFinite(params[k])) P[k] = params[k];
+  }
+}
 
 // Head-camera frame size the skill's grasp pixel is expressed in (IMG_W/IMG_H
 // in pick_any_object.py). Only a fallback — the live <video>'s intrinsic size
@@ -213,9 +228,9 @@ export function createPickOverlay(parent, rosClient, session) {
     }
     // The wrist-align goal square.
     if (running && wristG) {
-      const side = 2 * WRIST_HALF_PX * wristG.s;
-      wristBox.style.left = `${wristG.offX + WRIST_BOX_U * wristG.s}px`;
-      wristBox.style.top = `${wristG.offY + WRIST_BOX_V * wristG.s}px`;
+      const side = 2 * P.wrist_half_px * wristG.s;
+      wristBox.style.left = `${wristG.offX + P.wrist_box_u * wristG.s}px`;
+      wristBox.style.top = `${wristG.offY + P.wrist_box_v * wristG.s}px`;
       wristBox.style.width = `${side}px`;
       wristBox.style.height = `${side}px`;
       wristBox.hidden = false;
@@ -223,18 +238,18 @@ export function createPickOverlay(parent, rosClient, session) {
       wristBox.hidden = true;
     }
     // The pick box goal square.
-    const center = running && headG ? floorToPixel(SWEET_X, BOX_Y, TILT_DEG) : null;
+    const center = running && headG ? floorToPixel(P.sweet_x, P.box_y, P.tilt_deg) : null;
     if (!headG || !center) {
       boxGoal.hidden = true;
       return;
     }
-    const side = 2 * BOX_HALF_PX * headG.s;
+    const side = 2 * P.box_half_px * headG.s;
     boxGoal.style.left = `${headG.offX + center.u * headG.s}px`;
     boxGoal.style.top = `${headG.offY + center.v * headG.s}px`;
     boxGoal.style.width = `${side}px`;
     boxGoal.style.height = `${side}px`;
     // Inner accept box, centered, sized as a fraction of the outer.
-    const acceptPct = `${ACCEPT_FRAC * 100}%`;
+    const acceptPct = `${P.accept_frac * 100}%`;
     boxAccept.style.width = acceptPct;
     boxAccept.style.height = acceptPct;
     boxGoal.hidden = false;
@@ -254,6 +269,7 @@ export function createPickOverlay(parent, rosClient, session) {
   function onDebugEvent(ev) {
     switch (ev.ev) {
       case "run_start":
+        syncParams(ev.params); // run_start carries the skill's full live dict
         grabPx = null;
         seenPx = null;
         wristPx = null;
@@ -261,6 +277,10 @@ export function createPickOverlay(parent, rosClient, session) {
         wristBox.classList.remove("inside");
         running = true;
         break;
+      case "params":
+        // Tuning ack (mid-run retunes included) — move the boxes live.
+        syncParams(ev.params);
+        break;
       case "run_end":
         running = false;
         grabPx = null;

From ab2ae764888ab40266c66fe683a48970b9c13a0e Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Fri, 17 Jul 2026 01:27:42 -0700
Subject: [PATCH 06/19] =?UTF-8?q?fix(pick):=20address=20review=20=E2=80=94?=
 =?UTF-8?q?=20retire=20stale=20custom=5Fskills=20copies,=20format,=20overl?=
 =?UTF-8?q?ay=20params?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- post_update: rename superseded workspace/custom_skills copies (arm_rest_position,
  gripper_open, gripper_close, pick_any_object) to *.py.superseded on update, so the
  gitignored local/ copy can't shadow the now-shipped skill via catalog precedence
- ruff check + ruff format clean (CI format check); 'workspace' added to isort
  known-first-party
- pickOverlay: draw boxes from the skill's broadcast params (run_start/params debug
  events) instead of hardcoded mirrors of TUNABLE — live tuning now redraws
- drop orphaned .arm-follower CSS (the readout UI is not in this PR)
- pick_any_object: guard head interface at entry like manipulation/mobility;
  replace -O-strippable assert in _sweet_box with a raise
- catalog: document the reload_selective two-lib-copies invariant
---
 pyproject.toml                                |   2 +-
 .../brain_client/skills/catalog.py            |   7 +-
 scripts/update/migrate_user_data.sh           |  24 ++
 webapp/css/app.css                            |  70 -----
 webapp/js/teleop/pickOverlay.js               |   2 +-
 workspace/innate_skills/arm_rest_position.py  |   9 +-
 workspace/innate_skills/gripper_open.py       |   7 +-
 .../innate_skills/navigate_to_position.py     |   1 +
 workspace/innate_skills/pick_any_object.py    | 258 +++++++++---------
 workspace/skill_lib/arm.py                    |  25 +-
 workspace/skill_lib/gemini.py                 |  14 +-
 workspace/skill_lib/geometry.py               |  31 ++-
 workspace/skill_lib/vision.py                 |  25 +-
 13 files changed, 216 insertions(+), 259 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index a31be185b..3721f8663 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -20,7 +20,7 @@ ignore = [
 ]
 
 [tool.ruff.lint.isort]
-known-first-party = ["mars_nav", "mars_control", "mars_cam", "mars_arm", "brain_client", "manipulation"]
+known-first-party = ["mars_nav", "mars_control", "mars_cam", "mars_arm", "brain_client", "manipulation", "workspace"]
 
 [tool.ruff.format]
 quote-style = "double"
diff --git a/ros2_ws/src/brain/brain_client/brain_client/skills/catalog.py b/ros2_ws/src/brain/brain_client/brain_client/skills/catalog.py
index 4cd6a6bfb..7fa60f138 100644
--- a/ros2_ws/src/brain/brain_client/brain_client/skills/catalog.py
+++ b/ros2_ws/src/brain/brain_client/brain_client/skills/catalog.py
@@ -274,7 +274,12 @@ def _compute_skill_id(self, path: str | Path) -> str:
     def _evict_skill_lib() -> None:
         """Drop cached workspace.skill_lib modules so a skills reload picks up
         lib edits too — skill files re-import the lib as they load. Without
-        this, sys.modules keeps serving the pre-edit lib to reloaded skills."""
+        this, sys.modules keeps serving the pre-edit lib to reloaded skills.
+
+        After a selective reload, skills NOT on the reload list keep the module
+        objects they imported at their own load time — two lib copies coexist.
+        Fine while the lib is stateless helpers; revisit if it ever holds state
+        shared across skills."""
         for name in [m for m in sys.modules if m.startswith("workspace.skill_lib")]:
             del sys.modules[name]
 
diff --git a/scripts/update/migrate_user_data.sh b/scripts/update/migrate_user_data.sh
index b8eb7c1ab..a83e844a6 100755
--- a/scripts/update/migrate_user_data.sh
+++ b/scripts/update/migrate_user_data.sh
@@ -18,6 +18,7 @@
 #   <repo>/maps/*                          -> <repo>/data/maps/
 #   <repo>/.last_mode                      -> <repo>/data/.last_mode
 #   <repo>/.last_map                       -> <repo>/data/.last_map
+#   workspace/custom_skills/<superseded>.py -> <same>.py.superseded (see below)
 #
 # Home-directory skills/agents (~/skills, ~/agents) are NOT handled here; they
 # are migrated at brain startup by
@@ -159,6 +160,28 @@ _migrate_nav_state() {
     done
 }
 
+# Retire custom_skills copies of skills that later became shipped (tracked in
+# workspace/innate_skills/). custom_skills/ is gitignored, so git pull leaves
+# the old copy in place — and the catalog gives local/ precedence for both the
+# bare import name and the plain display name, so the stale copy would silently
+# shadow the shipped skill forever. Rename (never delete: the user may have
+# local edits worth diffing) to *.py.superseded, which the loader ignores.
+_retire_superseded_custom_skills() {
+    local repo="$1"
+    local custom="$repo/workspace/custom_skills"
+    local name src
+    for name in arm_rest_position gripper_close gripper_open pick_any_object; do
+        src="$custom/$name.py"
+        [ -f "$src" ] && [ -f "$repo/workspace/innate_skills/$name.py" ] || continue
+        if [ -e "$src.superseded" ]; then
+            _mig_log "  Kept custom_skills/$name.py ($name.py.superseded already exists — reconcile manually)"
+            continue
+        fi
+        mv "$src" "$src.superseded"
+        _mig_log "Retired custom_skills/$name.py -> $name.py.superseded (now shipped in innate_skills/)"
+    done
+}
+
 run_user_data_migrations() {
     local repo="${1:?run_user_data_migrations: repo dir required}"
     _migrate_dir_into_workspace "$repo" agents     custom_agents
@@ -167,6 +190,7 @@ run_user_data_migrations() {
     _migrate_dir_into_workspace "$repo" inputs     inputs
     _migrate_primitives_models  "$repo"
     _migrate_nav_state          "$repo"
+    _retire_superseded_custom_skills "$repo"
 }
 
 # Execute when run directly (not when sourced).
diff --git a/webapp/css/app.css b/webapp/css/app.css
index 37dfb7f9f..83e21fecc 100644
--- a/webapp/css/app.css
+++ b/webapp/css/app.css
@@ -1640,76 +1640,6 @@ button {
   margin: 2px 0;
 }
 
-/* Live follower-joint readout — a subtle click-to-copy array literal. */
-.arm-follower {
-  position: relative;
-  display: flex;
-  align-items: center;
-  gap: 6px;
-}
-
-/* Copy icon sitting beside the readout. */
-.arm-follower-copy {
-  flex: none;
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  padding: 2px;
-  color: var(--muted);
-  background: transparent;
-  border: 0;
-  cursor: pointer;
-}
-
-.arm-follower-copy:hover:not(:disabled) {
-  color: var(--text);
-}
-
-.arm-follower-copy:disabled {
-  opacity: 0.4;
-  cursor: default;
-}
-
-/* "Copied" confirmation, floated above the readout on click. */
-.arm-follower-tip {
-  position: absolute;
-  bottom: calc(100% + 3px);
-  left: 0;
-  font-size: 9px;
-  color: var(--ok);
-  background: var(--panel);
-  border: 1px solid var(--ok);
-  border-radius: 3px;
-  padding: 1px 5px;
-  pointer-events: none;
-}
-
-.arm-follower-value {
-  flex: 1;
-  min-width: 0;
-  text-align: left;
-  font-size: 9px;
-  line-height: 1.3;
-  color: var(--muted);
-  background: transparent;
-  border: 0;
-  padding: 0;
-  cursor: pointer;
-  word-break: break-word;
-}
-
-.arm-follower-value:hover:not(:disabled) {
-  color: var(--text);
-}
-
-.arm-follower-value:disabled {
-  cursor: default;
-}
-
-.arm-follower-value.copied {
-  color: var(--ok);
-}
-
 .arm-services {
   display: flex;
   flex-direction: column;
diff --git a/webapp/js/teleop/pickOverlay.js b/webapp/js/teleop/pickOverlay.js
index 94d5e4221..2fde50a50 100644
--- a/webapp/js/teleop/pickOverlay.js
+++ b/webapp/js/teleop/pickOverlay.js
@@ -132,7 +132,7 @@ export function createPickOverlay(parent, rosClient, session) {
   const boxGoal = document.createElement("div");
   boxGoal.className = "picktune-boxgoal";
   boxGoal.hidden = true;
-  // Inner accept box (ACCEPT_FRAC of the outer): the point must land in THIS
+  // Inner accept box (accept_frac of the outer): the point must land in THIS
   // to stop positioning. Greens when the skill reports inside; the outer stays
   // a dim guide.
   boxGoal.innerHTML =
diff --git a/workspace/innate_skills/arm_rest_position.py b/workspace/innate_skills/arm_rest_position.py
index 55ffb0196..29abebe7b 100644
--- a/workspace/innate_skills/arm_rest_position.py
+++ b/workspace/innate_skills/arm_rest_position.py
@@ -80,13 +80,8 @@ def execute(self, duration: int = 3, keep_gripper: bool = True):
             except (KeyError, IndexError, TypeError):
                 pass  # no reading — fall back to the captured gripper value
 
-        self.logger.info(
-            f"Moving arm to rest position {[round(j, 3) for j in target]} "
-            f"over {duration}s"
-        )
-        success = self.manipulation.move_to_joint_positions(
-            joint_positions=target, duration=duration, blocking=False
-        )
+        self.logger.info(f"Moving arm to rest position {[round(j, 3) for j in target]} over {duration}s")
+        success = self.manipulation.move_to_joint_positions(joint_positions=target, duration=duration, blocking=False)
         if not success:
             return "Failed to send arm command", SkillResult.FAILURE
 
diff --git a/workspace/innate_skills/gripper_open.py b/workspace/innate_skills/gripper_open.py
index f76bfbd31..cdb1d5406 100644
--- a/workspace/innate_skills/gripper_open.py
+++ b/workspace/innate_skills/gripper_open.py
@@ -46,8 +46,11 @@ def execute(self, percent: float = 100.0, duration: float = 1.0):
         if self.manipulation is None:
             return "Manipulation interface not available", SkillResult.FAILURE
         ok = armlib.open_checked(
-            self.manipulation, lambda: armlib.gripper_j6(self.joint_states),
-            percent=percent, duration=duration, logger=self.logger,
+            self.manipulation,
+            lambda: armlib.gripper_j6(self.joint_states),
+            percent=percent,
+            duration=duration,
+            logger=self.logger,
         )
         if not ok:
             return "Failed to open gripper", SkillResult.FAILURE
diff --git a/workspace/innate_skills/navigate_to_position.py b/workspace/innate_skills/navigate_to_position.py
index 4e8351d23..18edee72b 100644
--- a/workspace/innate_skills/navigate_to_position.py
+++ b/workspace/innate_skills/navigate_to_position.py
@@ -10,6 +10,7 @@
 from rclpy.duration import Duration
 from rclpy.qos import DurabilityPolicy, QoSProfile
 from rclpy.time import Time
+
 # TransformException is re-exported from the compiled tf2_py module, which
 # pyright cannot introspect.
 from tf2_ros import TransformException  # pyright: ignore[reportAttributeAccessIssue]
diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
index c0fd8a41c..86376dde8 100644
--- a/workspace/innate_skills/pick_any_object.py
+++ b/workspace/innate_skills/pick_any_object.py
@@ -12,6 +12,7 @@
 import math
 import time
 
+from innate.skills import SkillCancelled, SkillFailed, arm_rest_position
 from std_msgs.msg import String
 
 from brain_client.skills.types import (
@@ -22,7 +23,6 @@
     Skill,
     SkillResult,
 )
-from innate.skills import SkillCancelled, SkillFailed, arm_rest_position
 from workspace.skill_lib import arm as armlib
 from workspace.skill_lib import gemini as gemlib
 from workspace.skill_lib import vision
@@ -36,45 +36,45 @@
 CARRY_ARM = [0.0537, -0.5031, 0.4157, 0.9434, -0.0077]
 
 # Live knobs, overridable mid-run via TUNING_TOPIC (String JSON partial dict).
-# The webapp draws the pick/wrist boxes from mirrors of the aim defaults
-# (pickOverlay.js) — keep those in sync when changing them here.
+# The webapp overlay (pickOverlay.js) draws the pick/wrist boxes from the
+# params/box fields on run_start/params debug events — nothing mirrored there.
 TUNABLE = {
     # FIND / LOCALIZE
-    "tilt_deg": -20.0,          # head pitch (negative = down)
-    "settle_s": 1.2,            # settle before a frame
+    "tilt_deg": -20.0,  # head pitch (negative = down)
+    "settle_s": 1.2,  # settle before a frame
     # POSITION
-    "sweet_x": 0.30,            # pick-box range in base_link (m)
-    "box_y": 0.0,               # pick-box lateral offset (m)
-    "box_half_px": 40.0,        # outer box half-width (px)
-    "accept_frac": 0.5,         # inner accept box as fraction of outer
-    "box_steps": 6.0,           # max follow / re-detect attempts
-    "bearing_go_deg": 4.0,      # stepwise: turn above this
-    "follow_gain_ang": 0.3,     # rad/s per 100 px
-    "follow_gain_lin": 0.06,    # m/s per 100 px
+    "sweet_x": 0.30,  # pick-box range in base_link (m)
+    "box_y": 0.0,  # pick-box lateral offset (m)
+    "box_half_px": 40.0,  # outer box half-width (px)
+    "accept_frac": 0.5,  # inner accept box as fraction of outer
+    "box_steps": 6.0,  # max follow / re-detect attempts
+    "bearing_go_deg": 4.0,  # stepwise: turn above this
+    "follow_gain_ang": 0.3,  # rad/s per 100 px
+    "follow_gain_lin": 0.06,  # m/s per 100 px
     # base odometry
     "rot_tol_deg": 2.5,
     "rot_kp": 1.2,
     "rot_wz_max": 0.5,
-    "rot_wz_min": 0.15,         # below this motors don't move
+    "rot_wz_min": 0.15,  # below this motors don't move
     "drive_tol_m": 0.015,
     "drive_kp": 0.3,
     "drive_v_max": 0.10,
     "drive_v_min": 0.04,
     # WRIST ALIGN (0 wrist_steps = blind grasp)
-    "wrist_steps": 2.0,         # Gemini looks (seed + re-seeds)
-    "wrist_stop_z": 0.04,       # hand off to blind ladder
+    "wrist_steps": 2.0,  # Gemini looks (seed + re-seeds)
+    "wrist_stop_z": 0.04,  # hand off to blind ladder
     "wrist_z_step": 0.01,
     "wrist_move_s": 0.5,
-    "wrist_pitch": 0.82,        # match WRIST_SEARCH_ARM camera pitch
-    "wrist_box_u": 320.0,       # wrist goal pixel
+    "wrist_pitch": 0.82,  # match WRIST_SEARCH_ARM camera pitch
+    "wrist_box_u": 320.0,  # wrist goal pixel
     "wrist_box_v": 240.0,
     "wrist_half_px": 60.0,
-    "wrist_kx": -0.04,          # m/100px v-error (signed; flip if diverges)
-    "wrist_ky": -0.04,          # m/100px u-error; gains at z=0.15, scale w/ height
+    "wrist_kx": -0.04,  # m/100px v-error (signed; flip if diverges)
+    "wrist_ky": -0.04,  # m/100px u-error; gains at z=0.15, scale w/ height
     "wrist_step_max": 0.04,
     "wrist_settle_s": 0.8,
     # GRASP
-    "grasp_x_off": 0.03,        # fingertips ahead of ee_link
+    "grasp_x_off": 0.03,  # fingertips ahead of ee_link
     "hover_z": 0.15,
     "hover_s": 2.0,
     "descend_z1": 0.10,
@@ -82,12 +82,12 @@
     "descend_z3": 0.03,
     "floor_z": 0.01,
     "descend_s": 1.2,
-    "descend_abort_z": 0.12,    # EE still above this => limp, abort
+    "descend_abort_z": 0.12,  # EE still above this => limp, abort
     "arm_pitch": 1.30,
-    "close_strength": 0.60,     # >~0.6 overcurrent-trips the gripper servo
+    "close_strength": 0.60,  # >~0.6 overcurrent-trips the gripper servo
     "close_s": 1.5,
     "close_settle_s": 0.8,
-    "twist_rad": 0.6,           # wind fabric onto fingers
+    "twist_rad": 0.6,  # wind fabric onto fingers
     "lift_rad": 0.6,
 }
 
@@ -141,10 +141,8 @@ def ok(self):
 
     def update(self, hsv):
         """Blob center, or None on miss (keeps last window for retry)."""
-        pt, window, _score = vision.seg_track(
-            hsv, self.model, self.window, min_score=WRIST_SEG_MIN_SCORE)
-        if pt is not None and math.hypot(pt[0] - self.guess[0],
-                                         pt[1] - self.guess[1]) > WRIST_MAX_JUMP_PX:
+        pt, window, _score = vision.seg_track(hsv, self.model, self.window, min_score=WRIST_SEG_MIN_SCORE)
+        if pt is not None and math.hypot(pt[0] - self.guess[0], pt[1] - self.guess[1]) > WRIST_MAX_JUMP_PX:
             pt = None
         if pt is None:
             self.misses += 1
@@ -191,9 +189,7 @@ def _ensure_debug_io(self):
         if self._dbg_pub is not None or self.node is None:
             return
         self._dbg_pub = self.node.create_publisher(String, DEBUG_TOPIC, 10)
-        self._tuning_sub = self.node.create_subscription(
-            String, TUNING_TOPIC, self._on_tuning, 10
-        )
+        self._tuning_sub = self.node.create_subscription(String, TUNING_TOPIC, self._on_tuning, 10)
 
     def _on_tuning(self, msg):
         try:
@@ -202,15 +198,11 @@ def _on_tuning(self, msg):
             return
         if not isinstance(incoming, dict):
             return
-        applied = {
-            k: float(v)
-            for k, v in incoming.items()
-            if k in self._p and isinstance(v, (int, float))
-        }
+        applied = {k: float(v) for k, v in incoming.items() if k in self._p and isinstance(v, (int, float))}
         if applied:
             self._p.update(applied)
             self.logger.info(f"[PickAnyObject] tuning applied: {applied}")
-        self._dbg("params", params=dict(self._p))
+        self._dbg("params", params=dict(self._p), box=self._box_px())
 
     def _dbg(self, ev, **fields):
         if self._dbg_pub is None:
@@ -228,8 +220,7 @@ def _checkpoint(self):
 
     def _gemini_call(self, image_b64, question):
         """Vision Q&A via gemlib."""
-        return gemlib.ask_image(self._proxy, image_b64, question,
-                                logger=self.logger)
+        return gemlib.ask_image(self._proxy, image_b64, question, logger=self.logger)
 
     def _detect_px(self, prompt):
         """Head frame -> best grasp pixel, or None."""
@@ -258,10 +249,7 @@ def _localize_px(self, prompt):
             return None, None
         xy = pixel_to_floor(px[0], px[1], self._p["tilt_deg"])
         if xy:
-            self.logger.info(
-                f"[PickAnyObject] px=({px[0]:.0f},{px[1]:.0f}) -> "
-                f"base_link ({xy[0]:.3f},{xy[1]:.3f})"
-            )
+            self.logger.info(f"[PickAnyObject] px=({px[0]:.0f},{px[1]:.0f}) -> base_link ({xy[0]:.3f},{xy[1]:.3f})")
         self._dbg("localize", px=px, xy=xy, tilt_deg=self._p["tilt_deg"])
         return xy, px
 
@@ -276,8 +264,7 @@ def _odom_xyt(self):
         try:
             if isinstance(od, dict):
                 p = od["pose"]["pose"]["position"]
-                return (float(p["x"]), float(p["y"]),
-                        math.radians(float(od["theta_degrees"])))
+                return (float(p["x"]), float(p["y"]), math.radians(float(od["theta_degrees"])))
             return (float(od.x), float(od.y), float(od.theta))
         except (KeyError, AttributeError, TypeError):
             return None
@@ -286,8 +273,7 @@ def _rotate_by(self, angle, tol=None, timeout=12.0):
         self._dbg("rotate", angle_deg=math.degrees(angle))
         od = self._odom_xyt()
         if od is None:
-            self.mobility.send_cmd_vel(0.0, math.copysign(0.35, angle),
-                                       abs(angle) / 0.35)
+            self.mobility.send_cmd_vel(0.0, math.copysign(0.35, angle), abs(angle) / 0.35)
             time.sleep(abs(angle) / 0.35 + 0.4)
             return
         target = od[2] + angle
@@ -299,8 +285,7 @@ def _rotate_by(self, angle, tol=None, timeout=12.0):
             if od is None:
                 break
             err = math.atan2(math.sin(target - od[2]), math.cos(target - od[2]))
-            if abs(err) < (tol if tol is not None
-                           else math.radians(self._p["rot_tol_deg"])):
+            if abs(err) < (tol if tol is not None else math.radians(self._p["rot_tol_deg"])):
                 break
             wz_max = self._p["rot_wz_max"]
             wz = max(-wz_max, min(wz_max, self._p["rot_kp"] * err))
@@ -319,8 +304,7 @@ def _drive(self, dist, tol=None, timeout=15.0):
         od = self._odom_xyt()
         if od is None:
             self.logger.warning("[PickAnyObject] no odom — open-loop drive")
-            self.mobility.send_cmd_vel(math.copysign(0.08, dist), 0.0,
-                                       abs(dist) / 0.08)
+            self.mobility.send_cmd_vel(math.copysign(0.08, dist), 0.0, abs(dist) / 0.08)
             time.sleep(abs(dist) / 0.08 + 0.4)
             return
         x0, y0 = od[0], od[1]
@@ -336,8 +320,7 @@ def _drive(self, dist, tol=None, timeout=15.0):
             if err < tol:
                 break
             v = math.copysign(
-                max(self._p["drive_v_min"],
-                    min(self._p["drive_v_max"], self._p["drive_kp"] * err)),
+                max(self._p["drive_v_min"], min(self._p["drive_v_max"], self._p["drive_kp"] * err)),
                 dist,
             )
             self.mobility.send_cmd_vel(v, 0.0, 0.15)
@@ -359,7 +342,9 @@ def _rest_arm(self, keep_grip):
             target = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
         for _ in range(2):
             self.manipulation.move_to_joint_positions(
-                joint_positions=target, duration=3, blocking=True,
+                joint_positions=target,
+                duration=3,
+                blocking=True,
             )
             time.sleep(0.3)
 
@@ -376,13 +361,23 @@ def _search(self, prompt):
                 return xy
         return None
 
+    def _box_px(self):
+        """[cu, cv, half, accept] pick box in image px, or None off-image.
+        Sent on run_start/params events; the webapp overlay draws this box
+        instead of mirroring the aim knobs and camera model in JS."""
+        c = floor_to_pixel(self._p["sweet_x"], self._p["box_y"], self._p["tilt_deg"])
+        if c is None:
+            return None
+        half = self._p["box_half_px"]
+        return [c[0], c[1], half, half * self._p["accept_frac"]]
+
     def _sweet_box(self):
         """(center_px, outer_half, accept_half). Stop only inside accept."""
-        c = floor_to_pixel(self._p["sweet_x"], self._p["box_y"],
-                           self._p["tilt_deg"])
-        assert c is not None, "pick box off-image — check tilt_deg/sweet_x"
-        half = self._p["box_half_px"]
-        return c, half, half * self._p["accept_frac"]
+        box = self._box_px()
+        if box is None:  # reachable via live tuning; assert would vanish under -O
+            raise RuntimeError("pick box off-image — check tilt_deg/sweet_x")
+        cu, cv, half, accept = box
+        return (cu, cv), half, accept
 
     def _gray_frame(self):
         img = self.main_image
@@ -421,8 +416,7 @@ def _follow_into_box(self, seed_px):
 
             now = time.time()
             if now - last_dbg > 0.1:
-                self._dbg("servo", px=[u, v], box=[cu, cv, half, accept],
-                          inside=inside)
+                self._dbg("servo", px=[u, v], box=[cu, cv, half, accept], inside=inside)
                 last_dbg = now
 
             if inside:
@@ -435,10 +429,8 @@ def _follow_into_box(self, seed_px):
             in_box = 0
 
             # Deadband = accept (inner) box; right -> -wz, too close (low) -> -vx.
-            wz = _servo_vel(u - cu, self._p["follow_gain_ang"],
-                            self._p["rot_wz_min"], self._p["rot_wz_max"], accept)
-            vx = _servo_vel(v - cv, self._p["follow_gain_lin"],
-                            self._p["drive_v_min"], self._p["drive_v_max"], accept)
+            wz = _servo_vel(u - cu, self._p["follow_gain_ang"], self._p["rot_wz_min"], self._p["rot_wz_max"], accept)
+            vx = _servo_vel(v - cv, self._p["follow_gain_lin"], self._p["drive_v_min"], self._p["drive_v_max"], accept)
             self.mobility.send_cmd_vel(vx, wz, 0.15)
             time.sleep(0.03)
         self._stop_base()
@@ -467,7 +459,7 @@ def _position_above(self, prompt, xy):
             if px2 is None:
                 self._dbg("position_done", xy=None, reason="lost")
                 return None
-            (cu, cv), half, accept = self._sweet_box()
+            (cu, cv), _half, accept = self._sweet_box()
             if xy2 is not None and _inside_box(px2, cu, cv, accept):
                 self._dbg("position_done", xy=xy2, attempts=attempt)
                 return xy2
@@ -489,8 +481,7 @@ def _position_stepwise(self, prompt, xy):
                     return None
             (cu, cv), half, accept = self._sweet_box()
             inside = xy is not None and _inside_box(px, cu, cv, accept)
-            self._dbg("position", step=step, px=px, xy=xy,
-                      box=[cu, cv, half, accept], inside=inside)
+            self._dbg("position", step=step, px=px, xy=xy, box=[cu, cv, half, accept], inside=inside)
             if inside:
                 self._dbg("position_done", xy=xy, steps=step)
                 return xy
@@ -512,14 +503,18 @@ def _wrist_seed(self, prompt, z):
         """Wrist Gemini box -> (center_px, box) or (None, None)."""
         time.sleep(self._p["wrist_settle_s"])
         img = self.wrist_image
-        text = self._gemini_call(
-            img,
-            f"Wrist camera on a robot gripper, looking down at the floor. "
-            f"Find '{prompt}' on the floor. Ignore the gripper fingers "
-            "themselves. Return ONLY a JSON list of matches, each "
-            '{"box_2d":[ymin,xmin,ymax,xmax]} normalized 0-1000, best first, '
-            "each box TIGHT around its object. Empty list if not visible.",
-        ) if img else None
+        text = (
+            self._gemini_call(
+                img,
+                f"Wrist camera on a robot gripper, looking down at the floor. "
+                f"Find '{prompt}' on the floor. Ignore the gripper fingers "
+                "themselves. Return ONLY a JSON list of matches, each "
+                '{"box_2d":[ymin,xmin,ymax,xmax]} normalized 0-1000, best first, '
+                "each box TIGHT around its object. Empty list if not visible.",
+            )
+            if img
+            else None
+        )
         box = vision.parse_det_box(text)
         px = (box[0] + box[2] / 2.0, box[1] + box[3] / 2.0) if box else None
         self._dbg("wrist_seed", z=z, px=px)
@@ -585,7 +580,7 @@ def _wrist_servo(self, prompt, tx, ty):
             return self._wrist_done(tx, ty, z, "not seen")
 
         deadline = time.time() + WRIST_ALIGN_TIMEOUT_S
-        streak = 0    # verified matches since the arm last moved
+        streak = 0  # verified matches since the arm last moved
         centered = 0  # consecutive matches INSIDE the box
         reason = "reached stop z"
         while z > p["wrist_stop_z"] + 1e-6:
@@ -616,11 +611,9 @@ def _wrist_servo(self, prompt, tx, ty):
 
             err_u = px[0] - p["wrist_box_u"]
             err_v = px[1] - p["wrist_box_v"]
-            inside = _inside_box(px, p["wrist_box_u"], p["wrist_box_v"],
-                                 p["wrist_half_px"])
+            inside = _inside_box(px, p["wrist_box_u"], p["wrist_box_v"], p["wrist_half_px"])
             centered = centered + 1 if inside else 0
-            self._dbg("wrist_servo", px=px, z=z, inside=inside,
-                      tx=x, ty=y, ee=self._ee_xyz())
+            self._dbg("wrist_servo", px=px, z=z, inside=inside, tx=x, ty=y, ee=self._ee_xyz())
             if streak < 2:
                 continue  # watch one more frame before trusting it
             if inside and centered < 2:
@@ -638,9 +631,9 @@ def _wrist_servo(self, prompt, tx, ty):
                 x, y = armlib.clamp_reach(x, y)
                 # feed-forward: expect the blob at the box center next frame
                 tracker.guess = (p["wrist_box_u"], p["wrist_box_v"])
-            armlib.move_checked(self.manipulation, x, y, z,
-                                pitch=p["wrist_pitch"],
-                                duration=p["wrist_move_s"], logger=self.logger)
+            armlib.move_checked(
+                self.manipulation, x, y, z, pitch=p["wrist_pitch"], duration=p["wrist_move_s"], logger=self.logger
+            )
             streak = 0
             centered = 0  # view shifted — re-confirm centering
 
@@ -650,33 +643,37 @@ def _goto_search_pose(self, bearing):
         """WRIST_SEARCH_ARM aimed at bearing; pins IK to elbow-up branch."""
         a = WRIST_SEARCH_ARM
         j6 = self._gripper_j6()
-        pose = [bearing, a[1], a[2],
-                self._p["wrist_pitch"] - a[1] - a[2], a[4],
-                j6 if j6 is not None else 0.0]
-        self.manipulation.move_to_joint_positions(
-            joint_positions=pose, duration=self._p["hover_s"], blocking=True)
+        pose = [bearing, a[1], a[2], self._p["wrist_pitch"] - a[1] - a[2], a[4], j6 if j6 is not None else 0.0]
+        self.manipulation.move_to_joint_positions(joint_positions=pose, duration=self._p["hover_s"], blocking=True)
         time.sleep(0.3)
         self._dbg("hover", ee=self._ee_xyz())
 
     def _open_gripper_checked(self):
         """Open gripper with trip recovery."""
         armlib.open_checked(
-            self.manipulation, self._gripper_j6, logger=self.logger,
+            self.manipulation,
+            self._gripper_j6,
+            logger=self.logger,
             on_reboot=lambda j6: self._dbg("gripper_reboot", j6=j6),
         )
 
     def _push_to_floor(self, x, y, z_from, deep):
         """Blind descent ladder to floor. Failed rung = contact; abort if still high."""
         p = self._p
-        rungs = [p["descend_z1"], p["descend_z2"], p["descend_z3"],
-                 0.0 if deep else p["floor_z"]]
+        rungs = [p["descend_z1"], p["descend_z2"], p["descend_z3"], 0.0 if deep else p["floor_z"]]
         for z in rungs:
             if z >= z_from - 1e-6:
                 continue
             self._checkpoint()
             ok = self.manipulation.move_to_cartesian_pose(
-                x=x, y=y, z=z, roll=0.0, pitch=p["arm_pitch"], yaw=0.0,
-                duration=p["descend_s"], blocking=True,
+                x=x,
+                y=y,
+                z=z,
+                roll=0.0,
+                pitch=p["arm_pitch"],
+                yaw=0.0,
+                duration=p["descend_s"],
+                blocking=True,
             )
             self._dbg("descend", z=z, ok=bool(ok), ee=self._ee_xyz())
             if not ok:
@@ -692,34 +689,29 @@ def _close_twist_lift(self, x, y):
         """Close, joint-space twist+lift (IK would unwind j5). Hold full close cmd."""
         p = self._p
         j6_open = self._gripper_j6()
-        armlib.close(self.manipulation, strength=p["close_strength"],
-                     duration=p["close_s"])
+        armlib.close(self.manipulation, strength=p["close_strength"], duration=p["close_s"])
         time.sleep(p["close_settle_s"])
-        self._dbg("close", j6_open=j6_open, j6=self._gripper_j6(),
-                  strength=p["close_strength"])
+        self._dbg("close", j6_open=j6_open, j6=self._gripper_j6(), strength=p["close_strength"])
 
         grip = -p["close_strength"]
         try:
             j = list(self.joint_states["position"][:6])
             j[4] = max(-1.4, min(1.4, j[4] + p["twist_rad"]))
             j[5] = grip
-            self.manipulation.move_to_joint_positions(
-                joint_positions=j, duration=1.0, blocking=True)
+            self.manipulation.move_to_joint_positions(joint_positions=j, duration=1.0, blocking=True)
             time.sleep(0.3)
             self._dbg("twist", j4=j[4])
             j = list(self.joint_states["position"][:6])
             j[1] = max(-1.4, j[1] - p["lift_rad"])
             j[5] = grip
-            self.manipulation.move_to_joint_positions(
-                joint_positions=j, duration=2.0, blocking=True)
+            self.manipulation.move_to_joint_positions(joint_positions=j, duration=2.0, blocking=True)
             time.sleep(0.3)
             self._dbg("lift", ee=self._ee_xyz(), j6=self._gripper_j6())
         except (KeyError, IndexError, TypeError):
-            armlib.move_checked(self.manipulation, x, y, 0.22,
-                                pitch=p["arm_pitch"], duration=2.0, tol=0.10,
-                                logger=self.logger)
-            self._dbg("lift", ee=self._ee_xyz(), j6=self._gripper_j6(),
-                      ik_fallback=True)
+            armlib.move_checked(
+                self.manipulation, x, y, 0.22, pitch=p["arm_pitch"], duration=2.0, tol=0.10, logger=self.logger
+            )
+            self._dbg("lift", ee=self._ee_xyz(), j6=self._gripper_j6(), ik_fallback=True)
 
     def _grasp_at(self, prompt, xy, deep=False):
         """Full grasp at floor xy (base_link). Reads live self._p knobs."""
@@ -728,10 +720,8 @@ def _grasp_at(self, prompt, xy, deep=False):
 
         grab_px = floor_to_pixel(x + p["grasp_x_off"], y, p["tilt_deg"])
         obj_px = floor_to_pixel(xy[0], xy[1], p["tilt_deg"])
-        clamped = (abs((xy[0] - p["grasp_x_off"]) - x) > 1e-4
-                   or abs(xy[1] - y) > 1e-4)
-        self._dbg("grasp", xy=xy, tx=x, ty=y, deep=deep,
-                  grab_px=grab_px, obj_px=obj_px, clamped=clamped)
+        clamped = abs((xy[0] - p["grasp_x_off"]) - x) > 1e-4 or abs(xy[1] - y) > 1e-4
+        self._dbg("grasp", xy=xy, tx=x, ty=y, deep=deep, grab_px=grab_px, obj_px=obj_px, clamped=clamped)
 
         self._open_gripper_checked()
 
@@ -740,9 +730,9 @@ def _grasp_at(self, prompt, xy, deep=False):
             x, y, z = self._wrist_servo(prompt, x, y)
         else:
             z = p["hover_z"]
-            armlib.move_checked(self.manipulation, x, y, z,
-                                pitch=p["arm_pitch"], duration=p["hover_s"],
-                                logger=self.logger)
+            armlib.move_checked(
+                self.manipulation, x, y, z, pitch=p["arm_pitch"], duration=p["hover_s"], logger=self.logger
+            )
             self._dbg("hover", ee=self._ee_xyz())
 
         self._push_to_floor(x, y, z, deep)
@@ -761,17 +751,22 @@ def _grasp_verified(self, prompt):
         wrist_note = (
             " Image 2 is the WRIST camera next to the gripper fingers "
             "(mirrored) — the object may be visible held in the fingers there."
-            if len(images) > 1 else ""
+            if len(images) > 1
+            else ""
+        )
+        floor_text = (
+            self._gemini_call(
+                images,
+                f"Robot just tried to pick up '{prompt}'. Image 1 is the head "
+                f"camera looking at the floor.{wrist_note} "
+                f"Is '{prompt}' lying ON the floor/carpet anywhere in view? "
+                "Something hanging from the robot's gripper or held between the "
+                "gripper fingers does NOT count as on the floor. "
+                "Answer only YES or NO.",
+            )
+            if images
+            else None
         )
-        floor_text = self._gemini_call(
-            images,
-            f"Robot just tried to pick up '{prompt}'. Image 1 is the head "
-            f"camera looking at the floor.{wrist_note} "
-            f"Is '{prompt}' lying ON the floor/carpet anywhere in view? "
-            "Something hanging from the robot's gripper or held between the "
-            "gripper fingers does NOT count as on the floor. "
-            "Answer only YES or NO.",
-        ) if images else None
         floor_clear = bool(floor_text) and "NO" in floor_text.upper()
         j6_ok = j6 is not None and j6 > GRIPPER_EMPTY_J6 + 0.02
         held = floor_clear and j6_ok
@@ -779,19 +774,18 @@ def _grasp_verified(self, prompt):
             f"[PickAnyObject] verify: floor={floor_text!r} j6={j6} "
             f"({len(images)} cams) -> {'HELD' if held else 'NOT HELD'}"
         )
-        self._dbg("verify", floor_clear=floor_clear, j6=j6, held=held,
-                  cams=len(images))
+        self._dbg("verify", floor_clear=floor_clear, j6=j6, held=held, cams=len(images))
         return held
 
     def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
         """Pick up `prompt` from the floor. max_base_steps unused (compat)."""
         if self._proxy is None:
             return "Innate proxy not configured (INNATE_SERVICE_KEY)", SkillResult.FAILURE
-        if self.manipulation is None or self.mobility is None:
-            return "Manipulation/mobility interface not available", SkillResult.FAILURE
+        if self.manipulation is None or self.mobility is None or self.head is None:
+            return "Manipulation/mobility/head interface not available", SkillResult.FAILURE
 
         self._ensure_debug_io()
-        self._dbg("run_start", prompt=prompt, params=dict(self._p))
+        self._dbg("run_start", prompt=prompt, params=dict(self._p), box=self._box_px())
 
         holding = False
         try:
@@ -828,8 +822,7 @@ def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
                 )
             self.say("I couldn't get a grip on it.")
             return (
-                f"Grasp missed — '{prompt}' is still on the floor (verified after "
-                "backing up)",
+                f"Grasp missed — '{prompt}' is still on the floor (verified after backing up)",
                 SkillResult.FAILURE,
             )
         except SkillCancelled:
@@ -844,8 +837,7 @@ def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
                 self._rest_arm(keep_grip=holding)
             except Exception as e:  # noqa: BLE001
                 self.logger.warning(f"[PickAnyObject] rest-arm failed: {e}")
-            if self.head is not None:
-                self.head.set_position(0)
+            self.head.set_position(0)  # non-None: guarded at entry
 
     def cancel(self):
         self._cancelled = True
diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
index 5e30e5596..b36555dee 100644
--- a/workspace/skill_lib/arm.py
+++ b/workspace/skill_lib/arm.py
@@ -21,8 +21,7 @@ class ArmUnhealthy(RuntimeError):
 
 def clamp_reach(x, y):
     """Clamp (x, y) into the arm reach box."""
-    return (max(REACH_X[0], min(REACH_X[1], x)),
-            max(REACH_Y[0], min(REACH_Y[1], y)))
+    return (max(REACH_X[0], min(REACH_X[1], x)), max(REACH_Y[0], min(REACH_Y[1], y)))
 
 
 def ee_xyz(manipulation):
@@ -57,31 +56,34 @@ def move_checked(manipulation, x, y, z, pitch, duration=1.5, tol=0.05, logger=No
     """Cartesian move; verify FK within tol, recover+retry once, else raise."""
     for attempt in (1, 2):
         ok = manipulation.move_to_cartesian_pose(
-            x=x, y=y, z=z, roll=0.0, pitch=pitch, yaw=0.0,
-            duration=duration, blocking=True,
+            x=x,
+            y=y,
+            z=z,
+            roll=0.0,
+            pitch=pitch,
+            yaw=0.0,
+            duration=duration,
+            blocking=True,
         )
         cur = ee_xyz(manipulation)
         err = math.dist(cur, (x, y, z)) if cur is not None else None
         if ok and err is not None and err <= tol:
             return True
         if logger:
-            logger.warning(f"[arm] not tracking (ok={ok} err={err}) — "
-                           f"{'recovering' if attempt == 1 else 'giving up'}")
+            logger.warning(f"[arm] not tracking (ok={ok} err={err}) — {'recovering' if attempt == 1 else 'giving up'}")
         if attempt == 1:
             recover(manipulation, logger)
     raise ArmUnhealthy(f"arm failed to reach ({x:.2f},{y:.2f},{z:.2f})")
 
 
-def open_checked(manipulation, get_j6, percent=100.0, duration=1.0,
-                 logger=None, on_reboot=None):
+def open_checked(manipulation, get_j6, percent=100.0, duration=1.0, logger=None, on_reboot=None):
     """Open gripper and verify j6. Reboot+retry if tripped shut. on_reboot(j6) hook."""
     manipulation.torque_on()  # a torque-disabled servo won't move at all
     ok = manipulation.open_gripper(percent=percent, duration=duration, blocking=True)
     j6 = get_j6()
     if j6 is not None and j6 < 0.10:
         if logger:
-            logger.warning(f"[arm] gripper did not open (j6={j6:.3f}); "
-                           "rebooting servos to clear a trip, then retrying")
+            logger.warning(f"[arm] gripper did not open (j6={j6:.3f}); rebooting servos to clear a trip, then retrying")
         if on_reboot:
             on_reboot(j6)
         recover(manipulation, logger)
@@ -92,5 +94,4 @@ def open_checked(manipulation, get_j6, percent=100.0, duration=1.0,
 def close(manipulation, strength=0.0, duration=1.0):
     """Close gripper. strength = extra squeeze; keep <=~0.6 or servo trips."""
     manipulation.torque_on()
-    return bool(manipulation.close_gripper(strength=strength, duration=duration,
-                                           blocking=True))
+    return bool(manipulation.close_gripper(strength=strength, duration=duration, blocking=True))
diff --git a/workspace/skill_lib/gemini.py b/workspace/skill_lib/gemini.py
index 6371d330a..b95b45fa4 100644
--- a/workspace/skill_lib/gemini.py
+++ b/workspace/skill_lib/gemini.py
@@ -30,10 +30,7 @@ def ask_image(client, images_b64, question, logger=None, retries=3):
     if isinstance(images_b64, str):
         images_b64 = [images_b64]
     content = [{"type": "text", "text": question}]
-    content += [
-        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b}"}}
-        for b in images_b64
-    ]
+    content += [{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b}"}} for b in images_b64]
     body = {
         "model": MODEL,
         "temperature": 0.0,
@@ -42,16 +39,17 @@ def ask_image(client, images_b64, question, logger=None, retries=3):
     for attempt in range(retries):
         try:
             with client.request_stream(
-                SERVICE, ENDPOINT, method="POST", json=body,
+                SERVICE,
+                ENDPOINT,
+                method="POST",
+                json=body,
             ) as resp:
                 resp.raise_for_status()
                 data = json.loads(resp.read())
             return data["choices"][0]["message"]["content"] or ""
         except Exception as e:  # noqa: BLE001
             if logger:
-                logger.warning(
-                    f"[gemini] vision call failed (try {attempt + 1}/{retries}): {e}"
-                )
+                logger.warning(f"[gemini] vision call failed (try {attempt + 1}/{retries}): {e}")
             if attempt < retries - 1:
                 time.sleep(2.0 * (attempt + 1))
     return None
diff --git a/workspace/skill_lib/geometry.py b/workspace/skill_lib/geometry.py
index b832def3e..c66d7a0f6 100644
--- a/workspace/skill_lib/geometry.py
+++ b/workspace/skill_lib/geometry.py
@@ -1,15 +1,18 @@
 #!/usr/bin/env python3
 # SPDX-License-Identifier: Apache-2.0
 # Copyright (c) 2026 Innate Inc
-"""Head-camera <-> floor (z=0) via pinhole + URDF. Keep in sync with pickOverlay.js."""
+"""Head-camera <-> floor (z=0) via pinhole + URDF."""
 
 import math
 
 HEAD_ORIGIN = (-0.040751, -0.0002, 0.25882)  # base_link -> head joint (URDF)
-CAM_IN_HEAD = (0.04327, 0.0297, -0.000275)   # head -> left camera optical
+CAM_IN_HEAD = (0.04327, 0.0297, -0.000275)  # head -> left camera optical
 IMG_W, IMG_H = 640, 480
 HFOV_DEG = 70.0
 
+FX = IMG_W / (2.0 * math.tan(math.radians(HFOV_DEG) / 2.0))
+CX, CY = IMG_W / 2.0, IMG_H / 2.0
+
 
 def _head_rot(tilt_rad):
     c, s = math.cos(tilt_rad), math.sin(tilt_rad)
@@ -20,14 +23,18 @@ def _rot(R, v):
     return tuple(sum(R[i][k] * v[k] for k in range(3)) for i in range(3))
 
 
+def _cam_pose(head_tilt_deg):
+    """Camera origin + (fwd, right, down) axes in base_link for a head tilt."""
+    R = _head_rot(math.radians(head_tilt_deg))
+    off = _rot(R, CAM_IN_HEAD)
+    cam = tuple(HEAD_ORIGIN[i] + off[i] for i in range(3))
+    return cam, _rot(R, (1, 0, 0)), _rot(R, (0, -1, 0)), _rot(R, (0, 0, -1))
+
+
 def pixel_to_floor(u, v, head_tilt_deg):
     """Pixel (u,v) -> floor (x,y) in base_link, or None."""
-    fx = IMG_W / (2.0 * math.tan(math.radians(HFOV_DEG) / 2.0))
-    cx, cy = IMG_W / 2.0, IMG_H / 2.0
-    R = _head_rot(math.radians(head_tilt_deg))
-    cam = tuple(HEAD_ORIGIN[i] + _rot(R, CAM_IN_HEAD)[i] for i in range(3))
-    fwd, right, down = _rot(R, (1, 0, 0)), _rot(R, (0, -1, 0)), _rot(R, (0, 0, -1))
-    xo, yo = (u - cx) / fx, (v - cy) / fx
+    cam, fwd, right, down = _cam_pose(head_tilt_deg)
+    xo, yo = (u - CX) / FX, (v - CY) / FX
     d = tuple(fwd[i] + xo * right[i] + yo * down[i] for i in range(3))
     if d[2] >= -1e-6:
         return None
@@ -38,15 +45,11 @@ def pixel_to_floor(u, v, head_tilt_deg):
 
 def floor_to_pixel(x, y, head_tilt_deg):
     """Floor (x,y) -> pixel, or None. Inverse of pixel_to_floor."""
-    fx = IMG_W / (2.0 * math.tan(math.radians(HFOV_DEG) / 2.0))
-    cx, cy = IMG_W / 2.0, IMG_H / 2.0
-    R = _head_rot(math.radians(head_tilt_deg))
-    cam = tuple(HEAD_ORIGIN[i] + _rot(R, CAM_IN_HEAD)[i] for i in range(3))
-    fwd, right, down = _rot(R, (1, 0, 0)), _rot(R, (0, -1, 0)), _rot(R, (0, 0, -1))
+    cam, fwd, right, down = _cam_pose(head_tilt_deg)
     D = (x - cam[0], y - cam[1], -cam[2])
     a = sum(D[i] * fwd[i] for i in range(3))
     if a <= 1e-6:
         return None
     b = sum(D[i] * right[i] for i in range(3))
     c = sum(D[i] * down[i] for i in range(3))
-    return (cx + (b / a) * fx, cy + (c / a) * fx)
+    return (CX + (b / a) * FX, CY + (c / a) * FX)
diff --git a/workspace/skill_lib/vision.py b/workspace/skill_lib/vision.py
index e5d07a86b..75971fdd6 100644
--- a/workspace/skill_lib/vision.py
+++ b/workspace/skill_lib/vision.py
@@ -16,6 +16,7 @@
 
 from workspace.skill_lib.geometry import IMG_H, IMG_W
 
+
 def b64_to_gray(image_b64):
     """base64 JPEG -> gray ndarray, or None."""
     try:
@@ -58,8 +59,7 @@ def _box_corners_px(det):
     y0, x0, y1, x1 = [float(v) for v in b[:4]]
     y0, y1 = sorted((y0, y1))
     x0, x1 = sorted((x0, x1))
-    return (x0 / 1000.0 * IMG_W, y0 / 1000.0 * IMG_H,
-            x1 / 1000.0 * IMG_W, y1 / 1000.0 * IMG_H)
+    return (x0 / 1000.0 * IMG_W, y0 / 1000.0 * IMG_H, x1 / 1000.0 * IMG_W, y1 / 1000.0 * IMG_H)
 
 
 def parse_det_px(text):
@@ -88,23 +88,28 @@ def parse_det_box(text):
 
 
 LK_PARAMS: dict[str, Any] = dict(
-    winSize=(21, 21), maxLevel=3,
+    winSize=(21, 21),
+    maxLevel=3,
     criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 20, 0.03),
 )
 
 
 def grid_pts(u, v, step=12, n=2):
     """(2n+1)^2 LK feature patch around (u,v)."""
-    pts = [[u + dx * step, v + dy * step]
-           for dx in range(-n, n + 1) for dy in range(-n, n + 1)]
+    pts = [[u + dx * step, v + dy * step] for dx in range(-n, n + 1) for dy in range(-n, n + 1)]
     return np.array(pts, dtype=np.float32).reshape(-1, 1, 2)
 
 
 def track_point(prev_gray, gray, grid):
     """One LK step -> median pixel, or None if lost."""
     # nextPts=None is the standard cv2 idiom; the stubs demand an array.
-    nxt, status, _ = cv2.calcOpticalFlowPyrLK(prev_gray, gray, grid, None,  # pyright: ignore[reportCallIssue, reportArgumentType]
-                                              **LK_PARAMS)
+    nxt, status, _ = cv2.calcOpticalFlowPyrLK(
+        prev_gray,
+        gray,
+        grid,
+        None,  # pyright: ignore[reportCallIssue, reportArgumentType]
+        **LK_PARAMS,
+    )
     if nxt is None or status is None:
         return None
     good = nxt[status.flatten() == 1].reshape(-1, 2)
@@ -121,9 +126,9 @@ def track_point(prev_gray, gray, grid):
 def seg_model(hsv, box):
     """Object/floor hist-ratio LUT for back-projection, or None."""
     x, y, w, h = box
-    obj = hsv[y:y + h, x:x + w]
+    obj = hsv[y : y + h, x : x + w]
     rx0, ry0 = max(0, x - w // 2), max(0, y - h // 2)
-    ring = hsv[ry0:y + h + h // 2, rx0:x + w + w // 2]
+    ring = hsv[ry0 : y + h + h // 2, rx0 : x + w + w // 2]
     h_obj = cv2.calcHist([obj], [0, 1, 2], None, _SEG_BINS, _SEG_RANGES)
     h_ring = cv2.calcHist([ring], [0, 1, 2], None, _SEG_BINS, _SEG_RANGES)
     ratio = h_obj / (np.maximum(h_ring - h_obj, 0.0) + 1.0)
@@ -144,7 +149,7 @@ def seg_track(hsv, model, window, min_score=25.0):
     x, y, w, h = window
     if w < 4 or h < 4 or w * h > 0.4 * IMG_W * IMG_H:
         return None, window, 0.0
-    score = float(bp[y:y + h, x:x + w].mean())
+    score = float(bp[y : y + h, x : x + w].mean())
     if score < min_score:
         return None, window, score
     return (x + w / 2.0, y + h / 2.0), window, score

From 7a0b43b28ce1b627a9a24f032bb02f532cdc1b1e Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Fri, 17 Jul 2026 01:44:27 -0700
Subject: [PATCH 07/19] revert(update): drop custom_skills retirement migration

custom_skills/ holds user-authored skills only. These four skills were
never tracked outside this PR, so no release ever shipped them under the
legacy skills/ dir and the skills/ -> custom_skills/ migration could not
have deposited them. A copy only exists where someone hand-placed one, so
the migration was dead code on every robot it would ever run on.

Dev robots used during development do have the stale copies; those get
removed directly rather than via a shipped migration.
---
 scripts/update/migrate_user_data.sh | 24 ------------------------
 1 file changed, 24 deletions(-)

diff --git a/scripts/update/migrate_user_data.sh b/scripts/update/migrate_user_data.sh
index a83e844a6..b8eb7c1ab 100755
--- a/scripts/update/migrate_user_data.sh
+++ b/scripts/update/migrate_user_data.sh
@@ -18,7 +18,6 @@
 #   <repo>/maps/*                          -> <repo>/data/maps/
 #   <repo>/.last_mode                      -> <repo>/data/.last_mode
 #   <repo>/.last_map                       -> <repo>/data/.last_map
-#   workspace/custom_skills/<superseded>.py -> <same>.py.superseded (see below)
 #
 # Home-directory skills/agents (~/skills, ~/agents) are NOT handled here; they
 # are migrated at brain startup by
@@ -160,28 +159,6 @@ _migrate_nav_state() {
     done
 }
 
-# Retire custom_skills copies of skills that later became shipped (tracked in
-# workspace/innate_skills/). custom_skills/ is gitignored, so git pull leaves
-# the old copy in place — and the catalog gives local/ precedence for both the
-# bare import name and the plain display name, so the stale copy would silently
-# shadow the shipped skill forever. Rename (never delete: the user may have
-# local edits worth diffing) to *.py.superseded, which the loader ignores.
-_retire_superseded_custom_skills() {
-    local repo="$1"
-    local custom="$repo/workspace/custom_skills"
-    local name src
-    for name in arm_rest_position gripper_close gripper_open pick_any_object; do
-        src="$custom/$name.py"
-        [ -f "$src" ] && [ -f "$repo/workspace/innate_skills/$name.py" ] || continue
-        if [ -e "$src.superseded" ]; then
-            _mig_log "  Kept custom_skills/$name.py ($name.py.superseded already exists — reconcile manually)"
-            continue
-        fi
-        mv "$src" "$src.superseded"
-        _mig_log "Retired custom_skills/$name.py -> $name.py.superseded (now shipped in innate_skills/)"
-    done
-}
-
 run_user_data_migrations() {
     local repo="${1:?run_user_data_migrations: repo dir required}"
     _migrate_dir_into_workspace "$repo" agents     custom_agents
@@ -190,7 +167,6 @@ run_user_data_migrations() {
     _migrate_dir_into_workspace "$repo" inputs     inputs
     _migrate_primitives_models  "$repo"
     _migrate_nav_state          "$repo"
-    _retire_superseded_custom_skills "$repo"
 }
 
 # Execute when run directly (not when sourced).

From 6eb3b3a2fa1d43ef6027481a6b4e2dd5e6ea53bd Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Fri, 17 Jul 2026 01:46:02 -0700
Subject: [PATCH 08/19] docs: trim excessive comments in pick skill + overlay
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Drop comments that narrate the code, recount how a constant was arrived at,
or duplicate a docstring that lives with the implementation. Keep the ones
stating constraints the code can't show (signed wrist gains, close_strength
trip limit, color-model-not-LK, no cancel checkpoint mid-grip).

Also repoint pickOverlay.js at skill_lib/geometry.py for the camera geometry
it mirrors — it still named pick_any_object.py, where that code no longer is.
---
 webapp/js/constants.js                       |   4 +-
 webapp/js/teleop/pickOverlay.js              | 106 ++++++-------------
 workspace/innate_skills/arm_rest_position.py |  13 +--
 workspace/innate_skills/gripper_close.py     |   3 -
 workspace/innate_skills/gripper_open.py      |   4 -
 workspace/innate_skills/pick_any_object.py   |  24 ++---
 workspace/skill_lib/arm.py                   |   1 -
 7 files changed, 49 insertions(+), 106 deletions(-)

diff --git a/webapp/js/constants.js b/webapp/js/constants.js
index 7436b13fa..a599323d2 100644
--- a/webapp/js/constants.js
+++ b/webapp/js/constants.js
@@ -132,8 +132,8 @@ export const PINNED_SKILLS = ["navigate with vision", "navigate with position",
 export const EXECUTE_SKILL_ACTION = "/execute_skill";
 export const EXECUTE_SKILL_ACTION_TYPE = "brain_messages/action/ExecuteSkill";
 
-// Pick overlays (Teleop) <- pick_any_object skill: the skill's stage events
-// (std_msgs/String JSON: {ev, t, ...}) drive the video-stage aim overlays.
+// pick_any_object stage events (std_msgs/String JSON: {ev, t, ...}) — drive
+// the Teleop aim overlays.
 export const PICK_DEBUG_TOPIC = "/pick_any_object/debug";
 
 export const HEAD_MIN_DEG = -40;
diff --git a/webapp/js/teleop/pickOverlay.js b/webapp/js/teleop/pickOverlay.js
index 2fde50a50..2f69ad582 100644
--- a/webapp/js/teleop/pickOverlay.js
+++ b/webapp/js/teleop/pickOverlay.js
@@ -1,30 +1,18 @@
 // @ts-check
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (c) 2026 Innate Inc
-// Pick overlays — live aim feedback for the pick_any_object skill, drawn over
-// the video stage while a run is active (run_start → run_end on
-// /pick_any_object/debug). Nothing shows when the skill is idle.
-//
-// The skill reprojects its grasp target back onto the head frame and sends the
-// pixel (grab_px) on the debug topic. We draw a reticle over the live video at
-// that pixel — the actual spot on the floor the fingers will close on. The
-// detection pixel from each localize event gets its own marker (green box
-// corners) so you see where Gemini found the object vs where the arm will
-// grab; it clears whenever the base starts moving, since a stored pixel no
-// longer matches the shifted view, and reappears on the next localization.
-// The head video is object-fit:contain (letterboxed, never cropped), so the
-// 640×480 pixel maps to the screen with a single uniform scale + centering.
-// When the ARM (wrist) camera is on the big stage instead, the same stage
-// hosts the wrist-align overlays: the goal box in raw wrist-image pixels
-// (wrist_box_u/v) and the skill's wrist detection marker.
+// Pick overlays — aim feedback for the pick_any_object skill, drawn over the
+// video stage between run_start and run_end on /pick_any_object/debug.
+// Head-camera overlays (grasp reticle, detection marker, pick box) only make
+// sense while the "main" stream is on the stage; the wrist-align overlays only
+// while "arm" is.
 
 import { PICK_DEBUG_TOPIC } from "../constants.js";
 
-// Live copies of the skill's aim params, seeded with the TUNABLE defaults
-// from pick_any_object.py. The skill broadcasts its full live dict on every
-// run_start and params debug event — we resync from those so the boxes are
-// drawn where the skill actually aims, not where the defaults say it would
-// (live tuning overrides survive in the running skill between runs).
+// Live copies of the skill's aim params, seeded with the TUNABLE defaults from
+// pick_any_object.py and resynced from every run_start/params debug event —
+// live tuning overrides survive in the running skill between runs, so the
+// defaults alone would draw the boxes where the skill no longer aims.
 // Display-only: never written back.
 const P = {
   sweet_x: 0.3,
@@ -46,13 +34,11 @@ function syncParams(params) {
   }
 }
 
-// Head-camera frame size the skill's grasp pixel is expressed in (IMG_W/IMG_H
-// in pick_any_object.py). Only a fallback — the live <video>'s intrinsic size
-// wins when known.
+// Fallback only — the live <video>'s intrinsic size wins when known.
 const IMG = { w: 640, h: 480 };
 
-// Head-camera geometry, mirrored from pick_any_object.py (URDF values) so the
-// pick box can be drawn without asking the skill.
+// Head-camera geometry, mirrored from workspace/skill_lib/geometry.py (URDF
+// values) so the pick box can be drawn without asking the skill.
 const HEAD_ORIGIN = [-0.040751, -0.0002, 0.25882];
 const CAM_IN_HEAD = [0.04327, 0.0297, -0.000275];
 const HFOV_DEG = 70;
@@ -75,7 +61,7 @@ function camPose(tiltDeg) {
 }
 
 /** Floor point (base_link x,y, z=0) -> image pixel, or null behind the camera.
- *  Mirror of floor_to_pixel in pick_any_object.py.
+ *  Mirror of floor_to_pixel in workspace/skill_lib/geometry.py.
  *  @param {number} x @param {number} y @param {number} tiltDeg */
 function floorToPixel(x, y, tiltDeg) {
   const { cam, fwd, right, down } = camPose(tiltDeg);
@@ -91,16 +77,13 @@ function floorToPixel(x, y, tiltDeg) {
  * @param {HTMLElement} parent cockpit root — must contain the .video-stage.
  * @param {import("../rosClient.js").RosClient} rosClient
  * @param {import("../webrtcSession.js").WebRtcSession} [session]
- *   Video session — tells us which camera fills the big stage: head-camera
- *   overlays (reticle, pick box) only show on "main", wrist-align overlays
- *   only on "arm" (a floor pixel is meaningless on the wrist cam and vice
- *   versa).
+ *   Tells us which camera fills the big stage; overlays hide on the other one.
  * @returns {{ destroy: () => void }}
  */
 export function createPickOverlay(parent, rosClient, session) {
   const videoStage = /** @type {HTMLElement | null} */ (parent.querySelector(".video-stage"));
 
-  // Reticle drawn over the live video at the skill's grasp pixel.
+  // Grasp target: the spot on the floor the fingers will close on.
   const reticle = document.createElement("div");
   reticle.className = "picktune-grab";
   reticle.hidden = true;
@@ -114,8 +97,8 @@ export function createPickOverlay(parent, rosClient, session) {
     '<span class="picktune-grab-tag mono">grasp target</span>';
   if (videoStage) videoStage.appendChild(reticle);
 
-  // Detection marker: box corners around the pixel Gemini reported, in the
-  // detection color, so "seen here" and "grabbing here" read apart at a glance.
+  // Where Gemini reported the object, so "seen here" and "grabbing here" read
+  // apart at a glance.
   const seenMark = document.createElement("div");
   seenMark.className = "picktune-grab picktune-seen";
   seenMark.hidden = true;
@@ -127,31 +110,25 @@ export function createPickOverlay(parent, rosClient, session) {
     '<span class="picktune-grab-tag mono">detected</span>';
   if (videoStage) videoStage.appendChild(seenMark);
 
-  // The pick box: the positioning goal square, shown only while a run is
-  // active. Turns green while the skill reports the detection inside it.
+  // Positioning goal. The detection must land in the inner accept box (not
+  // just the outer guide) for the skill to stop driving.
   const boxGoal = document.createElement("div");
   boxGoal.className = "picktune-boxgoal";
   boxGoal.hidden = true;
-  // Inner accept box (accept_frac of the outer): the point must land in THIS
-  // to stop positioning. Greens when the skill reports inside; the outer stays
-  // a dim guide.
   boxGoal.innerHTML =
     '<span class="picktune-boxgoal-tag mono">pick box</span>' +
     '<div class="picktune-boxaccept"></div>';
   const boxAccept = /** @type {HTMLElement} */ (boxGoal.querySelector(".picktune-boxaccept"));
   if (videoStage) videoStage.appendChild(boxGoal);
 
-  // The wrist box: the wrist-align goal square, shown when the ARM camera is
-  // on the big stage during a run. Same idea as the pick box, but in raw
-  // wrist-image pixels (wrist_box_u/v) — no floor projection, the wrist cam
-  // has none.
+  // Wrist-align goal, in raw wrist-image pixels — no floor projection, the
+  // wrist cam has none.
   const wristBox = document.createElement("div");
   wristBox.className = "picktune-boxgoal";
   wristBox.hidden = true;
   wristBox.innerHTML = '<span class="picktune-boxgoal-tag mono">wrist box</span>';
   if (videoStage) videoStage.appendChild(wristBox);
 
-  // Wrist detection marker: where Gemini found the object on the wrist image.
   const wristMark = document.createElement("div");
   wristMark.className = "picktune-grab picktune-seen";
   wristMark.hidden = true;
@@ -165,32 +142,29 @@ export function createPickOverlay(parent, rosClient, session) {
 
   // ---- state ---------------------------------------------------------------
 
-  /** Skill's grasp target in 640×480 image px, or null when none is active. @type {{ u: number, v: number } | null} */
+  /** @type {{ u: number, v: number } | null} */
   let grabPx = null;
-  /** Latest detection pixel from localize; null after base motion shifts the view. @type {{ u: number, v: number } | null} */
+  /** Detection pixel from localize; null after base motion shifts the view.
+   *  @type {{ u: number, v: number } | null} */
   let seenPx = null;
-  /** Latest wrist-camera detection pixel from wrist_align. @type {{ u: number, v: number } | null} */
+  /** @type {{ u: number, v: number } | null} */
   let wristPx = null;
   let running = false;
 
   // ---- overlays over the live video ----------------------------------------
 
-  /** True when the head camera fills the big stage (a floor pixel only maps
-   *  onto that view). Defaults to true when no session was passed. */
+  /** Defaults to true when no session was passed. */
   function headCamPrimary() {
     return !session || session.primaryCamera?.name === "main";
   }
 
-  /** True when the wrist ("arm") camera fills the big stage — the view the
-   *  wrist-align box and detection marker live on. */
   function wristCamPrimary() {
     return session?.primaryCamera?.name === "arm";
   }
 
   /** Letterbox geometry of the live video inside the stage (object-fit:
    *  contain → one uniform scale + symmetric offsets), or null when no video
-   *  is up. Camera-agnostic — both cams are 640×480 and the video's intrinsic
-   *  size wins; callers gate on WHICH camera is primary.
+   *  is up. Camera-agnostic; callers gate on which camera is primary.
    *  @returns {{ s: number, offX: number, offY: number } | null} */
   function stageGeom() {
     const video = /** @type {HTMLVideoElement | null} */ (videoStage?.querySelector("video"));
@@ -204,10 +178,9 @@ export function createPickOverlay(parent, rosClient, session) {
     return { s, offX: (boxW - iw * s) / 2, offY: (boxH - ih * s) / 2 };
   }
 
-  /** Position (or hide) the image-pixel markers and the goal boxes over the
-   *  video — head-camera overlays when the head cam is primary, wrist-camera
-   *  overlays when the arm cam is. The goal boxes only show while a run is
-   *  active; a stale aim frame over an idle robot reads as noise. */
+  /** Position (or hide) every marker and goal box. The goal boxes only show
+   *  while a run is active; a stale aim frame over an idle robot reads as
+   *  noise. */
   function placeOverlays() {
     const g = stageGeom();
     const headG = g && headCamPrimary() ? g : null;
@@ -226,7 +199,6 @@ export function createPickOverlay(parent, rosClient, session) {
       el.style.top = `${geom.offY + px.v * geom.s}px`;
       el.hidden = false;
     }
-    // The wrist-align goal square.
     if (running && wristG) {
       const side = 2 * P.wrist_half_px * wristG.s;
       wristBox.style.left = `${wristG.offX + P.wrist_box_u * wristG.s}px`;
@@ -237,7 +209,6 @@ export function createPickOverlay(parent, rosClient, session) {
     } else {
       wristBox.hidden = true;
     }
-    // The pick box goal square.
     const center = running && headG ? floorToPixel(P.sweet_x, P.box_y, P.tilt_deg) : null;
     if (!headG || !center) {
       boxGoal.hidden = true;
@@ -248,17 +219,14 @@ export function createPickOverlay(parent, rosClient, session) {
     boxGoal.style.top = `${headG.offY + center.v * headG.s}px`;
     boxGoal.style.width = `${side}px`;
     boxGoal.style.height = `${side}px`;
-    // Inner accept box, centered, sized as a fraction of the outer.
     const acceptPct = `${P.accept_frac * 100}%`;
     boxAccept.style.width = acceptPct;
     boxAccept.style.height = acceptPct;
     boxGoal.hidden = false;
   }
 
-  // Video letterbox geometry shifts on any stage resize; the overlays' validity
-  // also flips when the primary camera or the stream changes (switch to wrist
-  // cam, stream drop). Re-place on both so a mid-grasp camera switch is instant,
-  // not delayed to the next debug event.
+  // Re-place on resize and on camera/stream changes, so a mid-grasp camera
+  // switch is instant rather than delayed to the next debug event.
   const onResize = () => placeOverlays();
   window.addEventListener("resize", onResize);
   const unsubSession = session ? session.onChange(() => placeOverlays()) : null;
@@ -293,8 +261,6 @@ export function createPickOverlay(parent, rosClient, session) {
         seenPx = Array.isArray(ev.px) ? { u: ev.px[0], v: ev.px[1] } : null;
         break;
       case "servo":
-        // High-rate (~10 Hz) optical-flow tracking updates during the follow:
-        // glide the marker to the tracked point and colour the box.
         if (Array.isArray(ev.px)) seenPx = { u: ev.px[0], v: ev.px[1] };
         boxGoal.classList.toggle("inside", ev.inside === true);
         break;
@@ -310,18 +276,14 @@ export function createPickOverlay(parent, rosClient, session) {
         break;
       case "grasp":
         grabPx = Array.isArray(ev.grab_px) ? { u: ev.grab_px[0], v: ev.grab_px[1] } : null;
-        // Pin the "detected" marker to the object point so the amber grasp
-        // target and the green object marker sit side by side — their gap is
-        // the reach clamp (grasp aims short when the object is out of reach).
+        // The gap between the two markers is the reach clamp — grasp aims
+        // short when the object is out of reach.
         if (Array.isArray(ev.obj_px)) seenPx = { u: ev.obj_px[0], v: ev.obj_px[1] };
         break;
       case "wrist_seed":
-        // A Gemini look on the wrist image (initial seed or re-seed on loss).
         wristPx = Array.isArray(ev.px) ? { u: ev.px[0], v: ev.px[1] } : null;
         break;
       case "wrist_servo":
-        // Per-cycle tracking during the servo descent: glide the marker,
-        // colour the box.
         if (Array.isArray(ev.px)) wristPx = { u: ev.px[0], v: ev.px[1] };
         wristBox.classList.toggle("inside", ev.inside === true);
         break;
diff --git a/workspace/innate_skills/arm_rest_position.py b/workspace/innate_skills/arm_rest_position.py
index 29abebe7b..5b990e8fe 100644
--- a/workspace/innate_skills/arm_rest_position.py
+++ b/workspace/innate_skills/arm_rest_position.py
@@ -25,14 +25,10 @@
 )
 
 # joints 1-6 = base yaw, shoulder, elbow, wrist pitch, wrist roll, gripper.
-# The folded rest shape, but with the wrist pitch (j4) lifted to 0.55 so the
-# gripper clears the floor instead of pitching down into it: at the old j4~0.87+
-# the gripper jammed into the ground and tripped/broke a servo when driven here
-# under torque.
-# These are the values the arm actually REACHES and HOLDS (j1/j2 clamp to their
-# limits, so commanding "more folded" just settles here). j4=0.30 lifts the
-# wrist ~2 cm further than the first floor-clearing try (0.55, where the
-# fingertips still grazed the floor) — verified live: ee_link z ~0.042 m.
+# Folded rest shape. j4=0.30 keeps the gripper off the floor (ee_link z ~0.042 m);
+# pitching it further down jams the fingers into the ground and trips a servo.
+# These are the values the arm reaches and HOLDS — j1/j2 sit at their limits, so
+# commanding "more folded" just settles here.
 REST_POSITION = [1.5708, -1.2195, 1.5723, 0.30, 0.0, 0.0031]
 
 
@@ -85,7 +81,6 @@ def execute(self, duration: int = 3, keep_gripper: bool = True):
         if not success:
             return "Failed to send arm command", SkillResult.FAILURE
 
-        # Wait for motion to complete (with cancellation check)
         start_time = time.time()
         while time.time() - start_time < duration:
             if self._cancelled:
diff --git a/workspace/innate_skills/gripper_close.py b/workspace/innate_skills/gripper_close.py
index 4f8b94095..c8bbd0bec 100644
--- a/workspace/innate_skills/gripper_close.py
+++ b/workspace/innate_skills/gripper_close.py
@@ -12,9 +12,6 @@
 
 (also from the agent, the webapp skills menu, and
 `scripts/innate skill run gripper_close`).
-
-The implementation lives in workspace/skill_lib/arm.py (close): torque on
-first so the claw still moves after an overload left the servo disabled.
 """
 
 from brain_client.skills.types import Interface, InterfaceType, Skill, SkillResult
diff --git a/workspace/innate_skills/gripper_open.py b/workspace/innate_skills/gripper_open.py
index cdb1d5406..5d473ca2f 100644
--- a/workspace/innate_skills/gripper_open.py
+++ b/workspace/innate_skills/gripper_open.py
@@ -11,10 +11,6 @@
 
 (also from the agent, the webapp skills menu, and
 `scripts/innate skill run gripper_open`).
-
-The implementation lives in workspace/skill_lib/arm.py (open_checked):
-torque on first, then VERIFY the claw actually opened — an overcurrent-
-tripped servo no-ops silently — rebooting to clear a trip and retrying.
 """
 
 from brain_client.skills.types import (
diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
index 86376dde8..1b7ee4323 100644
--- a/workspace/innate_skills/pick_any_object.py
+++ b/workspace/innate_skills/pick_any_object.py
@@ -114,7 +114,6 @@ def _round_floats(v, nd=4):
 
 
 def _inside_box(px, cu, cv, half):
-    """True if pixel is within ±half of (cu, cv)."""
     return abs(px[0] - cu) <= half and abs(px[1] - cv) <= half
 
 
@@ -211,15 +210,13 @@ def _dbg(self, ev, **fields):
         self._dbg_pub.publish(String(data=json.dumps(_round_floats(fields))))
 
     def _checkpoint(self):
-        """Raise out of the run if cancel() latched. One raise here, one
-        `except SkillCancelled` in execute — no cancelled-as-None plumbing.
-        Deliberately NOT called during close/twist/lift: once the fingers
-        commit, aborting mid-grip would drag the object on the way home."""
+        """Raise out of the run if cancel() latched. Deliberately NOT called
+        during close/twist/lift: once the fingers commit, aborting mid-grip
+        would drag the object on the way home."""
         if self._cancelled:
             raise SkillCancelled("Pick cancelled")
 
     def _gemini_call(self, image_b64, question):
-        """Vision Q&A via gemlib."""
         return gemlib.ask_image(self._proxy, image_b64, question, logger=self.logger)
 
     def _detect_px(self, prompt):
@@ -540,9 +537,8 @@ def _wrist_done(self, x, y, z, reason):
         return x, y, z
 
     def _wrist_reseed(self, prompt, z, raw):
-        """Persistent tracking loss: one Gemini look + fresh color model
-        (the view changed). Returns (tracker, raw, fail_reason) — tracker
-        is None on failure, fail_reason "" on success."""
+        """Persistent tracking loss: one Gemini look + a fresh color model,
+        since the view has changed. -> (tracker|None, raw, fail_reason)."""
         px, box = self._wrist_seed(prompt, z)
         if px is None:
             return None, raw, "lost track"
@@ -555,9 +551,8 @@ def _wrist_reseed(self, prompt, z, raw):
         return tracker, raw, ""
 
     def _wrist_servo(self, prompt, tx, ty):
-        """Wrist CamShift servo: watch until 2 frames agree (arm still),
-        then act — one nudge toward the wrist box, or one wrist_z_step down
-        once it has been seen inside the box twice; repeat to wrist_stop_z.
+        """Wrist CamShift servo down to wrist_stop_z: nudge toward the wrist
+        box, or step down once the object has been seen inside it twice.
         A miss gets 2 frames of patience, then a Gemini re-seed (budget =
         wrist_steps - 1). Color model, not LK: the object grows/deforms
         during the descent and optical flow slides off.
@@ -740,9 +735,8 @@ def _grasp_at(self, prompt, xy, deep=False):
         self._close_twist_lift(x, y)
 
     def _grasp_verified(self, prompt):
-        """Back up, then check floor clear + gripper not open. Gemini gets
-        BOTH cameras: the head view answers "is it still on the floor?", the
-        wrist view (mirrored) can show the object in the fingers so a held
+        """Back up, then check floor clear + gripper not open. Gemini gets both
+        cameras: the wrist view can show the object in the fingers, so a held
         object isn't mistaken for a dropped one."""
         self._drive(-VERIFY_BACKUP_M)
         time.sleep(self._p["settle_s"])
diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
index b36555dee..d8a1a20fc 100644
--- a/workspace/skill_lib/arm.py
+++ b/workspace/skill_lib/arm.py
@@ -20,7 +20,6 @@ class ArmUnhealthy(RuntimeError):
 
 
 def clamp_reach(x, y):
-    """Clamp (x, y) into the arm reach box."""
     return (max(REACH_X[0], min(REACH_X[1], x)), max(REACH_Y[0], min(REACH_Y[1], y)))
 
 

From 920ace3ef8cb3661207db5fb4943b5f7cd2da3de Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Fri, 17 Jul 2026 01:54:23 -0700
Subject: [PATCH 09/19] fix(pick): abort the grasp when the gripper will not
 open
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

_open_gripper_checked discarded open_checked's result, so a gripper that
stayed shut still went on to the wrist descent and close/twist/lift,
squeezing an already-tripped servo. Return the result and abort with
ArmUnhealthy instead.

open_checked could not report that failure either: after the reboot+retry
it returned the retry command's own status, and a tripped servo accepts the
command and no-ops silently — which is the whole reason the j6 check exists.
Re-verify j6 after the retry so the function keeps the promise in its
docstring. Healthy, recovers-after-reboot, and no-j6-reading paths are
unchanged.
---
 workspace/innate_skills/pick_any_object.py | 8 +++++---
 workspace/skill_lib/arm.py                 | 5 +++++
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
index 1b7ee4323..7387b4075 100644
--- a/workspace/innate_skills/pick_any_object.py
+++ b/workspace/innate_skills/pick_any_object.py
@@ -644,8 +644,8 @@ def _goto_search_pose(self, bearing):
         self._dbg("hover", ee=self._ee_xyz())
 
     def _open_gripper_checked(self):
-        """Open gripper with trip recovery."""
-        armlib.open_checked(
+        """Open gripper with trip recovery. False if still shut afterwards."""
+        return armlib.open_checked(
             self.manipulation,
             self._gripper_j6,
             logger=self.logger,
@@ -718,7 +718,9 @@ def _grasp_at(self, prompt, xy, deep=False):
         clamped = abs((xy[0] - p["grasp_x_off"]) - x) > 1e-4 or abs(xy[1] - y) > 1e-4
         self._dbg("grasp", xy=xy, tx=x, ty=y, deep=deep, grab_px=grab_px, obj_px=obj_px, clamped=clamped)
 
-        self._open_gripper_checked()
+        if not self._open_gripper_checked():
+            self._dbg("grasp_abort", reason="gripper would not open", j6=self._gripper_j6())
+            raise armlib.ArmUnhealthy("gripper would not open")
 
         if p["wrist_steps"] >= 1:
             self._goto_search_pose(math.atan2(y, x))
diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
index d8a1a20fc..188b7b65c 100644
--- a/workspace/skill_lib/arm.py
+++ b/workspace/skill_lib/arm.py
@@ -87,6 +87,11 @@ def open_checked(manipulation, get_j6, percent=100.0, duration=1.0, logger=None,
             on_reboot(j6)
         recover(manipulation, logger)
         ok = manipulation.open_gripper(percent=percent, duration=duration, blocking=True)
+        # A tripped servo accepts the command and no-ops, so the retry's own
+        # status proves nothing — j6 is the only evidence the claw moved.
+        j6 = get_j6()
+        if j6 is not None and j6 < 0.10:
+            return False
     return bool(ok)
 
 

From dd1f603b2ea7a628c3329c7376be9109a0b8da6d Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Fri, 17 Jul 2026 01:52:51 -0700
Subject: [PATCH 10/19] feat(webapp): pick tuning panel + draggable wrist box;
 overlay draws the skill's box
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- pickPanel.js: per-stage sliders for all 45 pick_any_object TUNABLE knobs,
  toggled with 'o' (button next to profiling). Each slider publishes a one-key
  partial dict on /pick_any_object/tuning; the skill's params ack drives the
  displayed values. On open the panel publishes {} — a pure echo request — so
  it syncs to the skill's live values with no defaults mirrored in JS; sliders
  stay disabled until that first ack.
- pickOverlay.js: the head-camera pick box is now drawn from the skill's `box`
  telemetry ([cu,cv,half,accept] on run_start/params/servo/position) instead
  of reprojecting sweet_x/box_y/tilt_deg through a JS copy of the camera
  model — camPose/floorToPixel and the mirrored URDF constants are gone. The
  wrist goal box is draggable when the arm camera is primary: dropping it
  publishes wrist_box_u/v as a live tuning override (throttled ~8 Hz while
  dragging, final on release; param echoes are ignored mid-drag so the ack of
  an in-flight value can't yank the box). Marker DOM is built by one helper.
- arm_rest_position: drop the redundant __init__ — the Skill base class
  creates the cancel latch lazily and its setter ignores False.
---
 webapp/css/app.css                           |  94 ++++++
 webapp/js/constants.js                       |   5 +-
 webapp/js/teleop/main.js                     |   2 +
 webapp/js/teleop/pickOverlay.js              | 282 ++++++++++--------
 webapp/js/teleop/pickPanel.js                | 287 +++++++++++++++++++
 workspace/innate_skills/arm_rest_position.py |   4 -
 6 files changed, 546 insertions(+), 128 deletions(-)
 create mode 100644 webapp/js/teleop/pickPanel.js

diff --git a/webapp/css/app.css b/webapp/css/app.css
index 83e21fecc..f3073f476 100644
--- a/webapp/css/app.css
+++ b/webapp/css/app.css
@@ -949,6 +949,100 @@ button {
   color: var(--ok);
 }
 
+/* The wrist goal box is the one interactive overlay: drag it to re-aim the
+   wrist servo (publishes wrist_box_u/v as a live tuning override). */
+.picktune-wristbox {
+  pointer-events: auto;
+  cursor: grab;
+  touch-action: none; /* pointer events own the gesture on touch screens */
+}
+
+.picktune-wristbox.dragging {
+  cursor: grabbing;
+  border-style: solid;
+}
+
+/* ---- pick tuning panel (Teleop) ------------------------------------------ */
+
+/* Slider toggle button sits left of the profiling pulse button. */
+.picktune-panel-toggle {
+  right: 54px;
+}
+
+/* The panel: same glass box as .profiling, but tall — it holds ~40 sliders in
+   stage groups, so it takes the right edge and scrolls. */
+.picktune-panel {
+  position: absolute;
+  top: 54px;
+  right: 14px;
+  bottom: 14px;
+  z-index: 3; /* above the profiling panel and camera strip: it's the active tool when open */
+  width: 262px;
+  padding: 11px 14px;
+  overflow-y: auto;
+  background: rgb(0 0 0 / 66%);
+  backdrop-filter: blur(20px);
+  -webkit-backdrop-filter: blur(20px);
+  border: 1px solid var(--hairline);
+  border-radius: 11px;
+  user-select: none;
+  -webkit-user-select: none;
+}
+
+.picktune-panel-note {
+  margin-bottom: 8px;
+  font-size: 10px;
+  color: var(--muted);
+}
+
+.picktune-panel-body {
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+}
+
+.picktune-panel-stage {
+  margin: 9px 0 2px;
+  padding-bottom: 3px;
+  border-bottom: 1px solid var(--hairline);
+}
+
+.picktune-panel-stage:first-child {
+  margin-top: 0;
+}
+
+.picktune-panel-row {
+  display: grid;
+  grid-template-columns: 92px 1fr 44px;
+  align-items: center;
+  gap: 7px;
+}
+
+.picktune-panel-key {
+  font-size: 9px;
+  color: var(--muted);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.picktune-panel-row input[type="range"] {
+  width: 100%;
+  min-width: 0;
+  accent-color: var(--accent);
+}
+
+.picktune-panel-row input[type="range"]:disabled {
+  opacity: 0.35;
+}
+
+.picktune-panel-value {
+  font-size: 10px;
+  color: var(--text);
+  text-align: right;
+  font-variant-numeric: tabular-nums;
+}
+
 /* ---- record HUD (Collect page) ------------------------------------------ */
 
 .overlay-record {
diff --git a/webapp/js/constants.js b/webapp/js/constants.js
index a599323d2..bdae70131 100644
--- a/webapp/js/constants.js
+++ b/webapp/js/constants.js
@@ -133,8 +133,11 @@ export const EXECUTE_SKILL_ACTION = "/execute_skill";
 export const EXECUTE_SKILL_ACTION_TYPE = "brain_messages/action/ExecuteSkill";
 
 // pick_any_object stage events (std_msgs/String JSON: {ev, t, ...}) — drive
-// the Teleop aim overlays.
+// the Teleop aim overlays. The tuning panel and draggable wrist box publish
+// partial TUNABLE dicts (String JSON) back on the tuning topic; the running
+// skill applies them mid-run and acks with a params event.
 export const PICK_DEBUG_TOPIC = "/pick_any_object/debug";
+export const PICK_TUNING_TOPIC = "/pick_any_object/tuning";
 
 export const HEAD_MIN_DEG = -40;
 export const HEAD_MAX_DEG = 70;
diff --git a/webapp/js/teleop/main.js b/webapp/js/teleop/main.js
index 8bb373456..a3c36f94f 100644
--- a/webapp/js/teleop/main.js
+++ b/webapp/js/teleop/main.js
@@ -24,6 +24,7 @@ import { createTelemetry } from "./telemetry.js";
 import { createArmPanel } from "./armPanel.js";
 import { createProfilingPanel } from "./profilingPanel.js";
 import { createPickOverlay } from "./pickOverlay.js";
+import { createPickPanel } from "./pickPanel.js";
 import { createSkillsMenu } from "./skillsMenu.js";
 import { createCameraSwitch } from "./cameraSwitch.js";
 
@@ -94,6 +95,7 @@ function buildCockpit(root) {
     createArmPanel(armOverlay, ros, { hideServices: !!config.simControls }),
     ...(config.simControls ? [] : [createProfilingPanel(root, session)]),
     createPickOverlay(root, ros, session),
+    createPickPanel(root, ros),
     createCameraSwitch(root, session, ros),
     keyboard,
   );
diff --git a/webapp/js/teleop/pickOverlay.js b/webapp/js/teleop/pickOverlay.js
index 2f69ad582..a8e8493ef 100644
--- a/webapp/js/teleop/pickOverlay.js
+++ b/webapp/js/teleop/pickOverlay.js
@@ -5,26 +5,46 @@
 // video stage between run_start and run_end on /pick_any_object/debug.
 // Head-camera overlays (grasp reticle, detection marker, pick box) only make
 // sense while the "main" stream is on the stage; the wrist-align overlays only
-// while "arm" is.
+// while "arm" is. The wrist goal box is draggable — dropping it publishes
+// wrist_box_u/v on the tuning topic, so aiming the servo is literally dragging
+// the target on the video.
 
-import { PICK_DEBUG_TOPIC } from "../constants.js";
+import { PICK_DEBUG_TOPIC, PICK_TUNING_TOPIC } from "../constants.js";
 
-// Live copies of the skill's aim params, seeded with the TUNABLE defaults from
-// pick_any_object.py and resynced from every run_start/params debug event —
-// live tuning overrides survive in the running skill between runs, so the
-// defaults alone would draw the boxes where the skill no longer aims.
-// Display-only: never written back.
+// Live copies of the skill's wrist-aim params, seeded with the TUNABLE
+// defaults from pick_any_object.py and resynced from every run_start/params
+// debug event — live tuning overrides survive in the running skill between
+// runs, so the defaults alone would draw the box where the skill no longer
+// aims. The head-camera pick box needs no seed and no mirrored camera model:
+// the skill projects it and sends it ready to draw ([cu, cv, half, accept]
+// image px, the `box` event field).
 const P = {
-  sweet_x: 0.3,
-  box_y: 0,
-  box_half_px: 40,
-  accept_frac: 0.5,
-  tilt_deg: -20,
   wrist_box_u: 320,
   wrist_box_v: 240,
   wrist_half_px: 60,
 };
 
+// Fallback only — the live <video>'s intrinsic size wins when known.
+const IMG = { w: 640, h: 480 };
+
+// Publishing every pointermove floods the tuning topic (and the skill logs
+// each applied dict); ~8 Hz while dragging is plenty, plus a final on release.
+const DRAG_PUBLISH_MS = 125;
+
+const SVG_OPEN =
+  '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
+  'stroke-width="1.6" aria-hidden="true">';
+// Crosshair reticle: the "grabbing HERE" shape.
+const RETICLE_SVG =
+  '<circle cx="24" cy="24" r="13"/>' +
+  '<line x1="24" y1="3" x2="24" y2="14"/><line x1="24" y1="34" x2="24" y2="45"/>' +
+  '<line x1="3" y1="24" x2="14" y2="24"/><line x1="34" y1="24" x2="45" y2="24"/>' +
+  '<circle cx="24" cy="24" r="2.2" fill="currentColor" stroke="none"/>';
+// Box corners: the "found it HERE" detection shape.
+const CORNERS_SVG =
+  '<path d="M8 16 V8 H16"/><path d="M32 8 H40 V16"/>' +
+  '<path d="M40 32 V40 H32"/><path d="M16 40 H8 V32"/>';
+
 /** Fold a params payload from the debug topic into P (unknown keys ignored).
  *  @param {any} params */
 function syncParams(params) {
@@ -34,45 +54,6 @@ function syncParams(params) {
   }
 }
 
-// Fallback only — the live <video>'s intrinsic size wins when known.
-const IMG = { w: 640, h: 480 };
-
-// Head-camera geometry, mirrored from workspace/skill_lib/geometry.py (URDF
-// values) so the pick box can be drawn without asking the skill.
-const HEAD_ORIGIN = [-0.040751, -0.0002, 0.25882];
-const CAM_IN_HEAD = [0.04327, 0.0297, -0.000275];
-const HFOV_DEG = 70;
-const FX = IMG.w / (2 * Math.tan(((HFOV_DEG / 2) * Math.PI) / 180));
-
-/** Camera pose (position + axes) for a head tilt. @param {number} tiltDeg */
-function camPose(tiltDeg) {
-  const t = (tiltDeg * Math.PI) / 180;
-  const c = Math.cos(t);
-  const s = Math.sin(t);
-  /** @param {[number, number, number]} v */
-  const rot = (v) => [c * v[0] - s * v[2], v[1], s * v[0] + c * v[2]];
-  const r = rot(/** @type {[number, number, number]} */ (CAM_IN_HEAD));
-  return {
-    cam: [HEAD_ORIGIN[0] + r[0], HEAD_ORIGIN[1] + r[1], HEAD_ORIGIN[2] + r[2]],
-    fwd: rot([1, 0, 0]),
-    right: rot([0, -1, 0]),
-    down: rot([0, 0, -1]),
-  };
-}
-
-/** Floor point (base_link x,y, z=0) -> image pixel, or null behind the camera.
- *  Mirror of floor_to_pixel in workspace/skill_lib/geometry.py.
- *  @param {number} x @param {number} y @param {number} tiltDeg */
-function floorToPixel(x, y, tiltDeg) {
-  const { cam, fwd, right, down } = camPose(tiltDeg);
-  const D = [x - cam[0], y - cam[1], -cam[2]];
-  const a = D[0] * fwd[0] + D[1] * fwd[1] + D[2] * fwd[2];
-  if (a <= 1e-6) return null;
-  const b = D[0] * right[0] + D[1] * right[1] + D[2] * right[2];
-  const cc = D[0] * down[0] + D[1] * down[1] + D[2] * down[2];
-  return { u: IMG.w / 2 + (b / a) * FX, v: IMG.h / 2 + (cc / a) * FX };
-}
-
 /**
  * @param {HTMLElement} parent cockpit root — must contain the .video-stage.
  * @param {import("../rosClient.js").RosClient} rosClient
@@ -83,35 +64,25 @@ function floorToPixel(x, y, tiltDeg) {
 export function createPickOverlay(parent, rosClient, session) {
   const videoStage = /** @type {HTMLElement | null} */ (parent.querySelector(".video-stage"));
 
-  // Grasp target: the spot on the floor the fingers will close on.
-  const reticle = document.createElement("div");
-  reticle.className = "picktune-grab";
-  reticle.hidden = true;
-  reticle.innerHTML =
-    '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
-    'stroke-width="1.6" aria-hidden="true">' +
-    '<circle cx="24" cy="24" r="13"/>' +
-    '<line x1="24" y1="3" x2="24" y2="14"/><line x1="24" y1="34" x2="24" y2="45"/>' +
-    '<line x1="3" y1="24" x2="14" y2="24"/><line x1="34" y1="24" x2="45" y2="24"/>' +
-    '<circle cx="24" cy="24" r="2.2" fill="currentColor" stroke="none"/></svg>' +
-    '<span class="picktune-grab-tag mono">grasp target</span>';
-  if (videoStage) videoStage.appendChild(reticle);
+  /** Marker pinned to an image pixel: an icon + a small tag label.
+   *  @param {string} className @param {string} svgBody @param {string} label */
+  function makeMarker(className, svgBody, label) {
+    const el = document.createElement("div");
+    el.className = className;
+    el.hidden = true;
+    el.innerHTML = `${SVG_OPEN}${svgBody}</svg><span class="picktune-grab-tag mono">${label}</span>`;
+    if (videoStage) videoStage.appendChild(el);
+    return el;
+  }
 
-  // Where Gemini reported the object, so "seen here" and "grabbing here" read
-  // apart at a glance.
-  const seenMark = document.createElement("div");
-  seenMark.className = "picktune-grab picktune-seen";
-  seenMark.hidden = true;
-  seenMark.innerHTML =
-    '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
-    'stroke-width="1.6" aria-hidden="true">' +
-    '<path d="M8 16 V8 H16"/><path d="M32 8 H40 V16"/>' +
-    '<path d="M40 32 V40 H32"/><path d="M16 40 H8 V32"/></svg>' +
-    '<span class="picktune-grab-tag mono">detected</span>';
-  if (videoStage) videoStage.appendChild(seenMark);
+  // The reticle marks where the fingers will close; the corner markers where
+  // Gemini saw the object — "seen here" and "grabbing here" read apart.
+  const reticle = makeMarker("picktune-grab", RETICLE_SVG, "grasp target");
+  const seenMark = makeMarker("picktune-grab picktune-seen", CORNERS_SVG, "detected");
+  const wristMark = makeMarker("picktune-grab picktune-seen", CORNERS_SVG, "wrist detect");
 
-  // Positioning goal. The detection must land in the inner accept box (not
-  // just the outer guide) for the skill to stop driving.
+  // The pick box: the positioning goal square. Greens while the skill reports
+  // the detection inside it; the inner accept box is what actually stops the base.
   const boxGoal = document.createElement("div");
   boxGoal.className = "picktune-boxgoal";
   boxGoal.hidden = true;
@@ -121,50 +92,51 @@ export function createPickOverlay(parent, rosClient, session) {
   const boxAccept = /** @type {HTMLElement} */ (boxGoal.querySelector(".picktune-boxaccept"));
   if (videoStage) videoStage.appendChild(boxGoal);
 
-  // Wrist-align goal, in raw wrist-image pixels — no floor projection, the
-  // wrist cam has none.
+  // The wrist box: the wrist-align goal square in raw wrist-image pixels.
+  // Draggable — releasing it publishes the new center as a tuning override,
+  // which the skill echoes back as a params event.
   const wristBox = document.createElement("div");
-  wristBox.className = "picktune-boxgoal";
+  wristBox.className = "picktune-boxgoal picktune-wristbox";
   wristBox.hidden = true;
   wristBox.innerHTML = '<span class="picktune-boxgoal-tag mono">wrist box</span>';
   if (videoStage) videoStage.appendChild(wristBox);
 
-  const wristMark = document.createElement("div");
-  wristMark.className = "picktune-grab picktune-seen";
-  wristMark.hidden = true;
-  wristMark.innerHTML =
-    '<svg viewBox="0 0 48 48" width="48" height="48" fill="none" stroke="currentColor" ' +
-    'stroke-width="1.6" aria-hidden="true">' +
-    '<path d="M8 16 V8 H16"/><path d="M32 8 H40 V16"/>' +
-    '<path d="M40 32 V40 H32"/><path d="M16 40 H8 V32"/></svg>' +
-    '<span class="picktune-grab-tag mono">wrist detect</span>';
-  if (videoStage) videoStage.appendChild(wristMark);
-
   // ---- state ---------------------------------------------------------------
 
-  /** @type {{ u: number, v: number } | null} */
+  /** Skill's grasp target in 640×480 image px, or null when none is active. @type {{ u: number, v: number } | null} */
   let grabPx = null;
-  /** Detection pixel from localize; null after base motion shifts the view.
-   *  @type {{ u: number, v: number } | null} */
+  /** Latest detection pixel from localize; null after base motion shifts the view. @type {{ u: number, v: number } | null} */
   let seenPx = null;
-  /** @type {{ u: number, v: number } | null} */
+  /** Latest wrist-camera detection pixel from wrist_align. @type {{ u: number, v: number } | null} */
   let wristPx = null;
+  /** Pick box from the skill, [cu, cv, half, accept] head-image px. @type {number[] | null} */
+  let headBox = null;
   let running = false;
 
+  /** Absorb aim info from any box-bearing debug event: the params dict for
+   *  the wrist keys, the skill-projected pick box as is. @param {any} ev */
+  function readAim(ev) {
+    syncParams(ev.params);
+    if (Array.isArray(ev.box) && ev.box.length >= 4) headBox = ev.box;
+  }
+
   // ---- overlays over the live video ----------------------------------------
 
-  /** Defaults to true when no session was passed. */
+  /** True when the head camera fills the big stage (a floor pixel only maps
+   *  onto that view). Defaults to true when no session was passed. */
   function headCamPrimary() {
     return !session || session.primaryCamera?.name === "main";
   }
 
+  /** True when the wrist ("arm") camera fills the big stage. */
   function wristCamPrimary() {
     return session?.primaryCamera?.name === "arm";
   }
 
   /** Letterbox geometry of the live video inside the stage (object-fit:
    *  contain → one uniform scale + symmetric offsets), or null when no video
-   *  is up. Camera-agnostic; callers gate on which camera is primary.
+   *  is up. Camera-agnostic — both cams are 640×480 and the video's intrinsic
+   *  size wins; callers gate on WHICH camera is primary.
    *  @returns {{ s: number, offX: number, offY: number } | null} */
   function stageGeom() {
     const video = /** @type {HTMLVideoElement | null} */ (videoStage?.querySelector("video"));
@@ -178,9 +150,9 @@ export function createPickOverlay(parent, rosClient, session) {
     return { s, offX: (boxW - iw * s) / 2, offY: (boxH - ih * s) / 2 };
   }
 
-  /** Position (or hide) every marker and goal box. The goal boxes only show
-   *  while a run is active; a stale aim frame over an idle robot reads as
-   *  noise. */
+  /** Position (or hide) the image-pixel markers and the goal boxes over the
+   *  video. The goal boxes only show while a run is active; a stale aim frame
+   *  over an idle robot reads as noise. */
   function placeOverlays() {
     const g = stageGeom();
     const headG = g && headCamPrimary() ? g : null;
@@ -199,6 +171,7 @@ export function createPickOverlay(parent, rosClient, session) {
       el.style.top = `${geom.offY + px.v * geom.s}px`;
       el.hidden = false;
     }
+    // The wrist-align goal square.
     if (running && wristG) {
       const side = 2 * P.wrist_half_px * wristG.s;
       wristBox.style.left = `${wristG.offX + P.wrist_box_u * wristG.s}px`;
@@ -209,24 +182,88 @@ export function createPickOverlay(parent, rosClient, session) {
     } else {
       wristBox.hidden = true;
     }
-    const center = running && headG ? floorToPixel(P.sweet_x, P.box_y, P.tilt_deg) : null;
-    if (!headG || !center) {
+    // The pick box goal square — drawn exactly where the skill said it is.
+    if (!running || !headG || !headBox) {
       boxGoal.hidden = true;
       return;
     }
-    const side = 2 * P.box_half_px * headG.s;
-    boxGoal.style.left = `${headG.offX + center.u * headG.s}px`;
-    boxGoal.style.top = `${headG.offY + center.v * headG.s}px`;
+    const [cu, cv, half, accept] = headBox;
+    const side = 2 * half * headG.s;
+    boxGoal.style.left = `${headG.offX + cu * headG.s}px`;
+    boxGoal.style.top = `${headG.offY + cv * headG.s}px`;
     boxGoal.style.width = `${side}px`;
     boxGoal.style.height = `${side}px`;
-    const acceptPct = `${P.accept_frac * 100}%`;
+    const acceptPct = `${(accept / half) * 100}%`;
     boxAccept.style.width = acceptPct;
     boxAccept.style.height = acceptPct;
     boxGoal.hidden = false;
   }
 
-  // Re-place on resize and on camera/stream changes, so a mid-grasp camera
-  // switch is instant rather than delayed to the next debug event.
+  // ---- wrist box dragging ---------------------------------------------------
+
+  /** Pointer-grab offset from the box center (image px), or null when idle.
+   *  @type {{ du: number, dv: number } | null} */
+  let drag = null;
+  let lastDragPublish = 0;
+
+  function publishWristCenter() {
+    rosClient.publish(PICK_TUNING_TOPIC, {
+      data: JSON.stringify({
+        wrist_box_u: Math.round(P.wrist_box_u),
+        wrist_box_v: Math.round(P.wrist_box_v),
+      }),
+    });
+  }
+
+  /** Pointer position -> image px, or null without stage geometry.
+   *  @param {PointerEvent} e */
+  function pointerToImagePx(e) {
+    const g = stageGeom();
+    if (!g || !videoStage) return null;
+    const rect = videoStage.getBoundingClientRect();
+    return {
+      u: (e.clientX - rect.left - g.offX) / g.s,
+      v: (e.clientY - rect.top - g.offY) / g.s,
+    };
+  }
+
+  wristBox.addEventListener("pointerdown", (e) => {
+    const px = pointerToImagePx(e);
+    if (!px) return;
+    e.preventDefault();
+    wristBox.setPointerCapture(e.pointerId);
+    drag = { du: px.u - P.wrist_box_u, dv: px.v - P.wrist_box_v };
+    wristBox.classList.add("dragging");
+  });
+
+  wristBox.addEventListener("pointermove", (e) => {
+    if (!drag) return;
+    const px = pointerToImagePx(e);
+    if (!px) return;
+    P.wrist_box_u = Math.max(0, Math.min(IMG.w, px.u - drag.du));
+    P.wrist_box_v = Math.max(0, Math.min(IMG.h, px.v - drag.dv));
+    placeOverlays();
+    const now = performance.now();
+    if (now - lastDragPublish >= DRAG_PUBLISH_MS) {
+      lastDragPublish = now;
+      publishWristCenter();
+    }
+  });
+
+  /** @param {PointerEvent} e */
+  function endDrag(e) {
+    if (!drag) return;
+    drag = null;
+    wristBox.classList.remove("dragging");
+    wristBox.releasePointerCapture(e.pointerId);
+    publishWristCenter(); // final position always lands, throttle or not
+  }
+  wristBox.addEventListener("pointerup", endDrag);
+  wristBox.addEventListener("pointercancel", endDrag);
+
+  // Letterbox geometry shifts on stage resize; overlay validity flips on
+  // camera/stream changes. Re-place on both so a mid-grasp camera switch is
+  // instant, not delayed to the next debug event.
   const onResize = () => placeOverlays();
   window.addEventListener("resize", onResize);
   const unsubSession = session ? session.onChange(() => placeOverlays()) : null;
@@ -237,35 +274,32 @@ export function createPickOverlay(parent, rosClient, session) {
   function onDebugEvent(ev) {
     switch (ev.ev) {
       case "run_start":
-        syncParams(ev.params); // run_start carries the skill's full live dict
+      case "run_end":
+        running = ev.ev === "run_start";
         grabPx = null;
         seenPx = null;
         wristPx = null;
         boxGoal.classList.remove("inside");
         wristBox.classList.remove("inside");
-        running = true;
+        readAim(ev); // run_start carries the skill's full live dict + box
         break;
       case "params":
-        // Tuning ack (mid-run retunes included) — move the boxes live.
-        syncParams(ev.params);
-        break;
-      case "run_end":
-        running = false;
-        grabPx = null;
-        seenPx = null;
-        wristPx = null;
-        boxGoal.classList.remove("inside");
-        wristBox.classList.remove("inside");
+        // Tuning ack — move the boxes live. Skip while dragging: the echo of
+        // an in-flight drag would yank the box backwards under the pointer.
+        if (!drag) readAim(ev);
         break;
       case "localize":
         seenPx = Array.isArray(ev.px) ? { u: ev.px[0], v: ev.px[1] } : null;
         break;
       case "servo":
+        // ~10 Hz optical-flow tracking during the follow: glide the marker.
         if (Array.isArray(ev.px)) seenPx = { u: ev.px[0], v: ev.px[1] };
         boxGoal.classList.toggle("inside", ev.inside === true);
+        readAim(ev);
         break;
       case "position":
         boxGoal.classList.toggle("inside", ev.inside === true);
+        readAim(ev);
         break;
       case "position_done":
         if (!Array.isArray(ev.xy)) boxGoal.classList.remove("inside");
@@ -276,14 +310,16 @@ export function createPickOverlay(parent, rosClient, session) {
         break;
       case "grasp":
         grabPx = Array.isArray(ev.grab_px) ? { u: ev.grab_px[0], v: ev.grab_px[1] } : null;
-        // The gap between the two markers is the reach clamp — grasp aims
-        // short when the object is out of reach.
+        // Pin the detection marker to the object point: its gap to the grasp
+        // target is the reach clamp (grasp aims short when out of reach).
         if (Array.isArray(ev.obj_px)) seenPx = { u: ev.obj_px[0], v: ev.obj_px[1] };
         break;
       case "wrist_seed":
+        // A Gemini look on the wrist image (initial seed or re-seed on loss).
         wristPx = Array.isArray(ev.px) ? { u: ev.px[0], v: ev.px[1] } : null;
         break;
       case "wrist_servo":
+        // Per-cycle tracking during the servo descent.
         if (Array.isArray(ev.px)) wristPx = { u: ev.px[0], v: ev.px[1] };
         wristBox.classList.toggle("inside", ev.inside === true);
         break;
diff --git a/webapp/js/teleop/pickPanel.js b/webapp/js/teleop/pickPanel.js
new file mode 100644
index 000000000..931c7626d
--- /dev/null
+++ b/webapp/js/teleop/pickPanel.js
@@ -0,0 +1,287 @@
+// @ts-check
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2026 Innate Inc
+// Pick tuning panel — per-stage sliders for pick_any_object's TUNABLE knobs.
+// A wrench button (top-right, next to profiling) toggles it; "o" does too.
+// Hidden by default so the cockpit stays clean for operators.
+//
+// Every slider publishes a one-key partial dict on the tuning topic; the
+// running skill applies it mid-run and acks with a params debug event
+// carrying its full live dict, which is what the sliders display. On open
+// the panel publishes an empty dict — a pure "echo your params" request —
+// so it syncs to the skill's real values (including overrides that survived
+// from earlier runs) without mirroring any defaults in JS. Until that first
+// ack arrives the sliders stay disabled: showing made-up numbers over a
+// robot that acts on different ones is how mis-tunes happen.
+
+import { PICK_DEBUG_TOPIC, PICK_TUNING_TOPIC } from "../constants.js";
+
+const TOGGLE_KEY = "KeyO";
+
+// Publishing every input event floods the topic (and the skill logs each
+// applied dict); trailing-edge throttle per drag, plus a final on change.
+const SLIDE_PUBLISH_MS = 125;
+
+/**
+ * Slider ranges per TUNABLE key, grouped by the same stages as the dict in
+ * pick_any_object.py. Ranges/steps are UI affordances chosen around the
+ * defaults and hardware limits (reach box, head tilt, servo trip points) —
+ * the VALUES always come from the skill's params broadcasts, never from here.
+ * @type {{ stage: string, keys: { [key: string]: [number, number, number] } }[]}
+ */
+const STAGES = [
+  {
+    stage: "find / localize",
+    keys: {
+      tilt_deg: [-40, 0, 1],
+      settle_s: [0, 3, 0.1],
+    },
+  },
+  {
+    stage: "position",
+    keys: {
+      sweet_x: [0.2, 0.45, 0.005],
+      box_y: [-0.1, 0.1, 0.005],
+      box_half_px: [10, 120, 5],
+      accept_frac: [0.2, 1, 0.05],
+      box_steps: [1, 12, 1],
+      bearing_go_deg: [1, 15, 0.5],
+      follow_gain_ang: [0, 1, 0.05],
+      follow_gain_lin: [0, 0.3, 0.01],
+    },
+  },
+  {
+    stage: "base odometry",
+    keys: {
+      rot_tol_deg: [0.5, 10, 0.5],
+      rot_kp: [0.1, 3, 0.1],
+      rot_wz_max: [0.1, 1.5, 0.05],
+      rot_wz_min: [0.05, 0.5, 0.01],
+      drive_tol_m: [0.005, 0.05, 0.005],
+      drive_kp: [0.05, 1, 0.05],
+      drive_v_max: [0.02, 0.3, 0.01],
+      drive_v_min: [0.01, 0.1, 0.005],
+    },
+  },
+  {
+    stage: "wrist align",
+    keys: {
+      wrist_steps: [0, 6, 1],
+      wrist_stop_z: [0.02, 0.12, 0.005],
+      wrist_z_step: [0.005, 0.04, 0.005],
+      wrist_move_s: [0.2, 2, 0.1],
+      wrist_pitch: [0.3, 1.6, 0.02],
+      wrist_box_u: [0, 640, 5],
+      wrist_box_v: [0, 480, 5],
+      wrist_half_px: [20, 160, 5],
+      wrist_kx: [-0.2, 0.2, 0.005],
+      wrist_ky: [-0.2, 0.2, 0.005],
+      wrist_step_max: [0.01, 0.1, 0.005],
+      wrist_settle_s: [0.2, 2, 0.1],
+    },
+  },
+  {
+    stage: "grasp",
+    keys: {
+      grasp_x_off: [0, 0.08, 0.005],
+      hover_z: [0.08, 0.25, 0.005],
+      hover_s: [0.5, 4, 0.25],
+      descend_z1: [0.04, 0.15, 0.005],
+      descend_z2: [0.03, 0.12, 0.005],
+      descend_z3: [0.01, 0.08, 0.005],
+      floor_z: [0, 0.03, 0.002],
+      descend_s: [0.4, 3, 0.1],
+      descend_abort_z: [0.05, 0.2, 0.005],
+      arm_pitch: [0.8, 1.6, 0.02],
+      close_strength: [0, 0.8, 0.05],
+      close_s: [0.5, 3, 0.1],
+      close_settle_s: [0, 2, 0.1],
+      twist_rad: [0, 1.4, 0.05],
+      lift_rad: [0, 1.4, 0.05],
+    },
+  },
+];
+
+/** Display decimals for a slider step (0.005 -> 3, 0.1 -> 1, 1 -> 0).
+ *  @param {number} step */
+function decimalsFor(step) {
+  if (step >= 1) return 0;
+  if (step >= 0.1) return 1;
+  if (step >= 0.01) return 2;
+  return 3;
+}
+
+/**
+ * @param {HTMLElement} parent cockpit root — owns the toggle button + panel.
+ * @param {import("../rosClient.js").RosClient} rosClient
+ * @returns {{ destroy: () => void }}
+ */
+export function createPickPanel(parent, rosClient) {
+  // Discrete toggle: a small glass wrench button, left of the profiling one.
+  const toggleBtn = document.createElement("button");
+  toggleBtn.type = "button";
+  toggleBtn.className = "profiling-toggle picktune-panel-toggle";
+  toggleBtn.title = "Pick tuning (o)";
+  toggleBtn.setAttribute("aria-label", "Toggle pick tuning panel");
+  toggleBtn.innerHTML =
+    '<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" ' +
+    'stroke-width="2" stroke-linecap="round" aria-hidden="true">' +
+    '<line x1="4" y1="7" x2="20" y2="7"/><circle cx="9" cy="7" r="2.2" fill="var(--glass)"/>' +
+    '<line x1="4" y1="12" x2="20" y2="12"/><circle cx="15" cy="12" r="2.2" fill="var(--glass)"/>' +
+    '<line x1="4" y1="17" x2="20" y2="17"/><circle cx="7" cy="17" r="2.2" fill="var(--glass)"/></svg>';
+
+  const wrap = document.createElement("div");
+  wrap.className = "picktune-panel";
+  wrap.hidden = true;
+
+  const head = document.createElement("div");
+  head.className = "profiling-head";
+  const title = document.createElement("span");
+  title.className = "microlabel";
+  title.textContent = "pick tuning";
+  const hint = document.createElement("span");
+  hint.className = "profiling-hint mono";
+  hint.textContent = "o";
+  head.append(title, hint);
+
+  // Sync status: cleared by the first params ack from the skill.
+  const note = document.createElement("div");
+  note.className = "picktune-panel-note";
+  note.textContent = "waiting for skill…";
+
+  const body = document.createElement("div");
+  body.className = "picktune-panel-body";
+
+  wrap.append(head, note, body);
+  parent.append(toggleBtn, wrap);
+
+  /** @type {Map<string, { input: HTMLInputElement, value: HTMLElement, decimals: number }>} */
+  const rows = new Map();
+  let synced = false;
+  /** Key being actively dragged — its row ignores param echoes so the thumb
+   *  doesn't fight the ack of an in-flight value. @type {string | null} */
+  let sliding = null;
+  let lastSlidePublish = 0;
+
+  for (const { stage, keys } of STAGES) {
+    const groupTitle = document.createElement("div");
+    groupTitle.className = "picktune-panel-stage microlabel";
+    groupTitle.textContent = stage;
+    body.append(groupTitle);
+
+    for (const [key, [min, max, step]] of Object.entries(keys)) {
+      const row = document.createElement("div");
+      row.className = "picktune-panel-row";
+
+      const label = document.createElement("span");
+      label.className = "picktune-panel-key mono";
+      label.textContent = key;
+
+      const input = document.createElement("input");
+      input.type = "range";
+      input.min = String(min);
+      input.max = String(max);
+      input.step = String(step);
+      input.disabled = true; // until the skill's first params ack
+
+      const value = document.createElement("span");
+      value.className = "picktune-panel-value mono";
+      value.textContent = "—";
+
+      const decimals = decimalsFor(step);
+      rows.set(key, { input, value, decimals });
+
+      input.addEventListener("input", () => {
+        sliding = key;
+        value.textContent = Number(input.value).toFixed(decimals);
+        const now = performance.now();
+        if (now - lastSlidePublish >= SLIDE_PUBLISH_MS) {
+          lastSlidePublish = now;
+          publishOverride(key, Number(input.value));
+        }
+      });
+      // Release: the definitive value always lands, throttle or not.
+      input.addEventListener("change", () => {
+        sliding = null;
+        publishOverride(key, Number(input.value));
+      });
+
+      row.append(label, input, value);
+      body.append(row);
+    }
+  }
+
+  /** @param {string} key @param {number} val */
+  function publishOverride(key, val) {
+    rosClient.publish(PICK_TUNING_TOPIC, { data: JSON.stringify({ [key]: val }) });
+  }
+
+  /** Ask the running skill to echo its live params (an empty partial dict
+   *  applies nothing but still gets the params ack). */
+  function requestSync() {
+    rosClient.publish(PICK_TUNING_TOPIC, { data: "{}" });
+  }
+
+  /** Fold a params broadcast into the sliders. @param {any} params */
+  function syncSliders(params) {
+    if (!params || typeof params !== "object") return;
+    for (const [key, row] of rows) {
+      if (typeof params[key] !== "number" || key === sliding) continue;
+      row.input.value = String(params[key]);
+      row.input.disabled = false;
+      row.value.textContent = params[key].toFixed(row.decimals);
+    }
+    if (!synced) {
+      synced = true;
+      note.hidden = true;
+    }
+  }
+
+  // Params ride the same debug topic as the overlay events; the panel only
+  // cares about the dict-bearing ones (run_start and the params acks).
+  const unsubDebug = rosClient.subscribe(PICK_DEBUG_TOPIC, (msg) => {
+    if (typeof msg?.data !== "string") return;
+    /** @type {any} */ let ev;
+    try {
+      ev = JSON.parse(msg.data);
+    } catch {
+      return; // not JSON — ignore
+    }
+    if (ev.ev === "params" || ev.ev === "run_start") syncSliders(ev.params);
+  });
+
+  /** @param {boolean} open */
+  function setOpen(open) {
+    wrap.hidden = !open;
+    toggleBtn.classList.toggle("active", open);
+    toggleBtn.setAttribute("aria-pressed", String(open));
+    if (open && !synced) requestSync();
+  }
+
+  function toggle() {
+    setOpen(Boolean(wrap.hidden));
+  }
+
+  toggleBtn.addEventListener("click", toggle);
+
+  /** @param {KeyboardEvent} e */
+  function onKeyDown(e) {
+    if (e.code !== TOGGLE_KEY || e.repeat || e.metaKey || e.ctrlKey || e.altKey) return;
+    const el = document.activeElement;
+    if (el instanceof HTMLElement && (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.isContentEditable)) {
+      return;
+    }
+    toggle();
+  }
+
+  window.addEventListener("keydown", onKeyDown);
+
+  return {
+    destroy() {
+      unsubDebug();
+      window.removeEventListener("keydown", onKeyDown);
+      toggleBtn.remove();
+      wrap.remove();
+    },
+  };
+}
diff --git a/workspace/innate_skills/arm_rest_position.py b/workspace/innate_skills/arm_rest_position.py
index 5b990e8fe..c85129bcc 100644
--- a/workspace/innate_skills/arm_rest_position.py
+++ b/workspace/innate_skills/arm_rest_position.py
@@ -38,10 +38,6 @@ class ArmRestPosition(Skill):
     manipulation = Interface(InterfaceType.MANIPULATION)
     joint_states = RobotState(RobotStateType.LAST_JOINT_STATES)
 
-    def __init__(self, logger):
-        super().__init__(logger)
-        self._cancelled = False
-
     @property
     def name(self):
         return "arm_rest_position"

From e407a3875b085c2c781f86efdd58978989fc6e98 Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Fri, 17 Jul 2026 15:02:36 -0700
Subject: [PATCH 11/19] =?UTF-8?q?fix(pick):=20address=20Greptile=20review?=
 =?UTF-8?q?=20=E2=80=94=20safe=20rest=20pose,=20close=5Fstrength=20cap?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

_rest_arm(keep_grip=False) sent all-zero joints, a completely different
posture from the documented folded rest that risks driving the gripper
into the floor. REST_POSITION moves to skill_lib/arm.py (single source
of truth, hot-reloads with the lib) and both arm_rest_position and the
pick skill's fold-home now use it. A sub-skill call was not an option
here: after a cancel the invoker short-circuits child runs, so the
finally-block rest would never execute.

Also cap the close_strength slider at 0.6 — both arm.py and the TUNABLE
default agree >~0.6 overcurrent-trips the gripper servo.
---
 webapp/js/teleop/pickPanel.js                | 2 +-
 workspace/innate_skills/arm_rest_position.py | 8 +-------
 workspace/innate_skills/pick_any_object.py   | 2 +-
 workspace/skill_lib/arm.py                   | 7 +++++++
 4 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/webapp/js/teleop/pickPanel.js b/webapp/js/teleop/pickPanel.js
index 931c7626d..a359f2381 100644
--- a/webapp/js/teleop/pickPanel.js
+++ b/webapp/js/teleop/pickPanel.js
@@ -93,7 +93,7 @@ const STAGES = [
       descend_s: [0.4, 3, 0.1],
       descend_abort_z: [0.05, 0.2, 0.005],
       arm_pitch: [0.8, 1.6, 0.02],
-      close_strength: [0, 0.8, 0.05],
+      close_strength: [0, 0.6, 0.05],
       close_s: [0.5, 3, 0.1],
       close_settle_s: [0, 2, 0.1],
       twist_rad: [0, 1.4, 0.05],
diff --git a/workspace/innate_skills/arm_rest_position.py b/workspace/innate_skills/arm_rest_position.py
index c85129bcc..8263b9ea6 100644
--- a/workspace/innate_skills/arm_rest_position.py
+++ b/workspace/innate_skills/arm_rest_position.py
@@ -23,13 +23,7 @@
     Skill,
     SkillResult,
 )
-
-# joints 1-6 = base yaw, shoulder, elbow, wrist pitch, wrist roll, gripper.
-# Folded rest shape. j4=0.30 keeps the gripper off the floor (ee_link z ~0.042 m);
-# pitching it further down jams the fingers into the ground and trips a servo.
-# These are the values the arm reaches and HOLDS — j1/j2 sit at their limits, so
-# commanding "more folded" just settles here.
-REST_POSITION = [1.5708, -1.2195, 1.5723, 0.30, 0.0, 0.0031]
+from workspace.skill_lib.arm import REST_POSITION
 
 
 class ArmRestPosition(Skill):
diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
index 7387b4075..54cca0cf8 100644
--- a/workspace/innate_skills/pick_any_object.py
+++ b/workspace/innate_skills/pick_any_object.py
@@ -336,7 +336,7 @@ def _rest_arm(self, keep_grip):
         if keep_grip:
             target = CARRY_ARM + [-self._p["close_strength"]]
         else:
-            target = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+            target = list(armlib.REST_POSITION)
         for _ in range(2):
             self.manipulation.move_to_joint_positions(
                 joint_positions=target,
diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
index 188b7b65c..3a7ac70a8 100644
--- a/workspace/skill_lib/arm.py
+++ b/workspace/skill_lib/arm.py
@@ -14,6 +14,13 @@
 REACH_X = (0.22, 0.40)
 REACH_Y = (-0.10, 0.10)
 
+# joints 1-6 = base yaw, shoulder, elbow, wrist pitch, wrist roll, gripper.
+# Folded rest shape. j4=0.30 keeps the gripper off the floor (ee_link z ~0.042 m);
+# pitching it further down jams the fingers into the ground and trips a servo.
+# These are the values the arm reaches and HOLDS — j1/j2 sit at their limits, so
+# commanding "more folded" just settles here.
+REST_POSITION = [1.5708, -1.2195, 1.5723, 0.30, 0.0, 0.0031]
+
 
 class ArmUnhealthy(RuntimeError):
     """Servo brownout/refusal — abort, don't continue limp."""

From 36cc3e17c9aa8f1e5d3223b8e0e9e6a20f30d9af Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Fri, 17 Jul 2026 15:43:55 -0700
Subject: [PATCH 12/19] fix(pick): loosen move_checked tolerance 0.05 -> 0.07m
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The wrist-servo descent was failing on ~0.051m FK residuals against a
0.05m bar — a marginal miss the reboot recovery can't fix, aborting the
whole pick. 0.07m gives margin at the arm's stretched reach poses.
---
 workspace/skill_lib/arm.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
index 3a7ac70a8..f19558b5c 100644
--- a/workspace/skill_lib/arm.py
+++ b/workspace/skill_lib/arm.py
@@ -58,7 +58,7 @@ def recover(manipulation, logger=None):
     time.sleep(0.5)
 
 
-def move_checked(manipulation, x, y, z, pitch, duration=1.5, tol=0.05, logger=None):
+def move_checked(manipulation, x, y, z, pitch, duration=1.5, tol=0.07, logger=None):
     """Cartesian move; verify FK within tol, recover+retry once, else raise."""
     for attempt in (1, 2):
         ok = manipulation.move_to_cartesian_pose(

From 35769c800b6e5f23dab1fa31529f3921533bc0f6 Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Fri, 17 Jul 2026 15:53:03 -0700
Subject: [PATCH 13/19] =?UTF-8?q?tune(pick):=20raise=20close=5Fstrength=20?=
 =?UTF-8?q?to=200.8=20=E2=80=94=20firmer=20grip=20holds=20better?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bench testing found 0.8 grips more reliably than 0.6. Raises the
default, the panel slider cap, and updates the trip-warning comments
that previously called 0.6 the ceiling.
---
 webapp/js/teleop/pickPanel.js              | 2 +-
 workspace/innate_skills/pick_any_object.py | 2 +-
 workspace/skill_lib/arm.py                 | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/webapp/js/teleop/pickPanel.js b/webapp/js/teleop/pickPanel.js
index a359f2381..931c7626d 100644
--- a/webapp/js/teleop/pickPanel.js
+++ b/webapp/js/teleop/pickPanel.js
@@ -93,7 +93,7 @@ const STAGES = [
       descend_s: [0.4, 3, 0.1],
       descend_abort_z: [0.05, 0.2, 0.005],
       arm_pitch: [0.8, 1.6, 0.02],
-      close_strength: [0, 0.6, 0.05],
+      close_strength: [0, 0.8, 0.05],
       close_s: [0.5, 3, 0.1],
       close_settle_s: [0, 2, 0.1],
       twist_rad: [0, 1.4, 0.05],
diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
index 54cca0cf8..ebcab0848 100644
--- a/workspace/innate_skills/pick_any_object.py
+++ b/workspace/innate_skills/pick_any_object.py
@@ -84,7 +84,7 @@
     "descend_s": 1.2,
     "descend_abort_z": 0.12,  # EE still above this => limp, abort
     "arm_pitch": 1.30,
-    "close_strength": 0.60,  # >~0.6 overcurrent-trips the gripper servo
+    "close_strength": 0.80,  # firmer grip holds better on hardware; watch for servo trips above this
     "close_s": 1.5,
     "close_settle_s": 0.8,
     "twist_rad": 0.6,  # wind fabric onto fingers
diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
index f19558b5c..709c292ea 100644
--- a/workspace/skill_lib/arm.py
+++ b/workspace/skill_lib/arm.py
@@ -103,6 +103,6 @@ def open_checked(manipulation, get_j6, percent=100.0, duration=1.0, logger=None,
 
 
 def close(manipulation, strength=0.0, duration=1.0):
-    """Close gripper. strength = extra squeeze; keep <=~0.6 or servo trips."""
+    """Close gripper. strength = extra squeeze; ~0.8 holds well, watch for trips above."""
     manipulation.torque_on()
     return bool(manipulation.close_gripper(strength=strength, duration=duration, blocking=True))

From 52c03c1a0cd11b34b25d2073ad6751aae983727e Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Fri, 17 Jul 2026 17:24:29 -0700
Subject: [PATCH 14/19] refactor(pick): extract shared mobility + arm helpers
 into skill_lib

Move the odometry-closed rotate/drive loops and pixel P-servo out of
pick_any_object into skill_lib/mobility.py (interfaces passed explicitly,
gains as kwargs, optional cancel predicate + dbg hook), mirroring arm.py.
Also fold the arm rest loop into armlib.rest and switch move_checked to
per-axis tolerances (tol_xy/tol_z).
---
 workspace/innate_skills/arm_rest_position.py |  43 +++---
 workspace/innate_skills/pick_any_object.py   | 130 ++++++------------
 workspace/skill_lib/arm.py                   |  44 +++++-
 workspace/skill_lib/mobility.py              | 134 +++++++++++++++++++
 4 files changed, 233 insertions(+), 118 deletions(-)
 create mode 100644 workspace/skill_lib/mobility.py

diff --git a/workspace/innate_skills/arm_rest_position.py b/workspace/innate_skills/arm_rest_position.py
index 8263b9ea6..d010103b2 100644
--- a/workspace/innate_skills/arm_rest_position.py
+++ b/workspace/innate_skills/arm_rest_position.py
@@ -4,17 +4,15 @@
 """
 Arm Rest Position Skill — move the arm to its resting pose.
 
-Callable from any skill's code as a plain function:
+From skill code, call the library function directly instead of this skill:
 
-    from innate.skills import arm_rest_position
-    arm_rest_position()            # blocks until the arm is resting
+    from workspace.skill_lib import arm as armlib
+    armlib.rest(self.manipulation, self.joint_states)
 
-(also runnable from the agent, the webapp skills menu, and
-`scripts/innate skill run local/arm_rest_position`).
+This class is the door for the agent, the webapp skills menu, and
+`scripts/innate skill run local/arm_rest_position`.
 """
 
-import time
-
 from brain_client.skills.types import (
     Interface,
     InterfaceType,
@@ -23,7 +21,7 @@
     Skill,
     SkillResult,
 )
-from workspace.skill_lib.arm import REST_POSITION
+from workspace.skill_lib import arm as armlib
 
 
 class ArmRestPosition(Skill):
@@ -58,25 +56,18 @@ def execute(self, duration: int = 3, keep_gripper: bool = True):
         if self.manipulation is None:
             return "Manipulation interface not available", SkillResult.FAILURE
 
-        target = list(REST_POSITION)
-        if keep_gripper:
-            js = self.joint_states
-            try:
-                target[5] = float(js["position"][5])
-            except (KeyError, IndexError, TypeError):
-                pass  # no reading — fall back to the captured gripper value
-
-        self.logger.info(f"Moving arm to rest position {[round(j, 3) for j in target]} over {duration}s")
-        success = self.manipulation.move_to_joint_positions(joint_positions=target, duration=duration, blocking=False)
-        if not success:
+        self.logger.info(f"Moving arm to rest position over {duration}s")
+        ok = armlib.rest(
+            self.manipulation,
+            self.joint_states,
+            duration=duration,
+            keep_gripper=keep_gripper,
+            cancelled=lambda: self._cancelled,
+        )
+        if self._cancelled:
+            return "Arm motion cancelled", SkillResult.CANCELLED
+        if not ok:
             return "Failed to send arm command", SkillResult.FAILURE
-
-        start_time = time.time()
-        while time.time() - start_time < duration:
-            if self._cancelled:
-                return "Arm motion cancelled", SkillResult.CANCELLED
-            time.sleep(0.1)
-
         return "Arm moved to rest position", SkillResult.SUCCESS
 
     def cancel(self):
diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
index ebcab0848..e1df2e58a 100644
--- a/workspace/innate_skills/pick_any_object.py
+++ b/workspace/innate_skills/pick_any_object.py
@@ -12,7 +12,7 @@
 import math
 import time
 
-from innate.skills import SkillCancelled, SkillFailed, arm_rest_position
+from innate.skills import SkillCancelled
 from std_msgs.msg import String
 
 from brain_client.skills.types import (
@@ -25,6 +25,7 @@
 )
 from workspace.skill_lib import arm as armlib
 from workspace.skill_lib import gemini as gemlib
+from workspace.skill_lib import mobility as moblib
 from workspace.skill_lib import vision
 from workspace.skill_lib.geometry import IMG_H, IMG_W, floor_to_pixel, pixel_to_floor
 
@@ -117,14 +118,6 @@ def _inside_box(px, cu, cv, half):
     return abs(px[0] - cu) <= half and abs(px[1] - cv) <= half
 
 
-def _servo_vel(err_px, gain, v_min, v_max, deadband_px):
-    """Pixel P-servo axis: gain per 100 px, clamp to [v_min, v_max], 0 in deadband."""
-    if abs(err_px) <= deadband_px:
-        return 0.0
-    v = max(-v_max, min(v_max, -gain / 100.0 * err_px))
-    return math.copysign(v_min, v) if abs(v) < v_min else v
-
-
 class _BlobTracker:
     """CamShift color-blob tracker seeded from a Gemini box."""
 
@@ -251,79 +244,39 @@ def _localize_px(self, prompt):
         return xy, px
 
     def _stop_base(self):
-        self.mobility.send_cmd_vel(0.0, 0.0, 0.1)
+        moblib.stop(self.mobility)
 
     def _odom_xyt(self):
-        """(x, y, theta) from nested dict or flat dataclass."""
-        od = self.odom
-        if od is None:
-            return None
-        try:
-            if isinstance(od, dict):
-                p = od["pose"]["pose"]["position"]
-                return (float(p["x"]), float(p["y"]), math.radians(float(od["theta_degrees"])))
-            return (float(od.x), float(od.y), float(od.theta))
-        except (KeyError, AttributeError, TypeError):
-            return None
-
-    def _rotate_by(self, angle, tol=None, timeout=12.0):
-        self._dbg("rotate", angle_deg=math.degrees(angle))
-        od = self._odom_xyt()
-        if od is None:
-            self.mobility.send_cmd_vel(0.0, math.copysign(0.35, angle), abs(angle) / 0.35)
-            time.sleep(abs(angle) / 0.35 + 0.4)
-            return
-        target = od[2] + angle
-        t0 = time.time()
-        err = angle
-        while time.time() - t0 < timeout:
-            self._checkpoint()
-            od = self._odom_xyt()
-            if od is None:
-                break
-            err = math.atan2(math.sin(target - od[2]), math.cos(target - od[2]))
-            if abs(err) < (tol if tol is not None else math.radians(self._p["rot_tol_deg"])):
-                break
-            wz_max = self._p["rot_wz_max"]
-            wz = max(-wz_max, min(wz_max, self._p["rot_kp"] * err))
-            if abs(wz) < self._p["rot_wz_min"]:
-                wz = math.copysign(self._p["rot_wz_min"], wz)
-            self.mobility.send_cmd_vel(0.0, wz, 0.15)
-            time.sleep(0.08)
-        self._stop_base()
-        self._dbg("rotate_done", err_deg=math.degrees(err), s=time.time() - t0)
-
-    def _drive(self, dist, tol=None, timeout=15.0):
-        tol = tol if tol is not None else self._p["drive_tol_m"]
-        if abs(dist) < tol:
-            return
-        self._dbg("drive", dist_m=dist)
-        od = self._odom_xyt()
-        if od is None:
-            self.logger.warning("[PickAnyObject] no odom — open-loop drive")
-            self.mobility.send_cmd_vel(math.copysign(0.08, dist), 0.0, abs(dist) / 0.08)
-            time.sleep(abs(dist) / 0.08 + 0.4)
-            return
-        x0, y0 = od[0], od[1]
-        t0 = time.time()
-        err = abs(dist)
-        while time.time() - t0 < timeout:
-            self._checkpoint()
-            od = self._odom_xyt()
-            if od is None:
-                break
-            gone = math.hypot(od[0] - x0, od[1] - y0)
-            err = abs(dist) - gone
-            if err < tol:
-                break
-            v = math.copysign(
-                max(self._p["drive_v_min"], min(self._p["drive_v_max"], self._p["drive_kp"] * err)),
-                dist,
-            )
-            self.mobility.send_cmd_vel(v, 0.0, 0.15)
-            time.sleep(0.08)
-        self._stop_base()
-        self._dbg("drive_done", err_m=err, s=time.time() - t0)
+        return moblib.odom_xyt(self.odom)
+
+    def _rotate_by(self, angle):
+        moblib.rotate_by(
+            self.mobility,
+            self._odom_xyt,
+            angle,
+            kp=self._p["rot_kp"],
+            wz_max=self._p["rot_wz_max"],
+            wz_min=self._p["rot_wz_min"],
+            tol=math.radians(self._p["rot_tol_deg"]),
+            cancelled=lambda: self._cancelled,
+            dbg=self._dbg,
+        )
+        self._checkpoint()  # rotate_by returns early on cancel — unwind here
+
+    def _drive(self, dist):
+        moblib.drive(
+            self.mobility,
+            self._odom_xyt,
+            dist,
+            kp=self._p["drive_kp"],
+            v_max=self._p["drive_v_max"],
+            v_min=self._p["drive_v_min"],
+            tol=self._p["drive_tol_m"],
+            cancelled=lambda: self._cancelled,
+            dbg=self._dbg,
+            logger=self.logger,
+        )
+        self._checkpoint()  # drive returns early on cancel — unwind here
 
     def _ee_xyz(self):
         return armlib.ee_xyz(self.manipulation)
@@ -426,8 +379,12 @@ def _follow_into_box(self, seed_px):
             in_box = 0
 
             # Deadband = accept (inner) box; right -> -wz, too close (low) -> -vx.
-            wz = _servo_vel(u - cu, self._p["follow_gain_ang"], self._p["rot_wz_min"], self._p["rot_wz_max"], accept)
-            vx = _servo_vel(v - cv, self._p["follow_gain_lin"], self._p["drive_v_min"], self._p["drive_v_max"], accept)
+            wz = moblib.servo_vel(
+                u - cu, self._p["follow_gain_ang"], self._p["rot_wz_min"], self._p["rot_wz_max"], accept
+            )
+            vx = moblib.servo_vel(
+                v - cv, self._p["follow_gain_lin"], self._p["drive_v_min"], self._p["drive_v_max"], accept
+            )
             self.mobility.send_cmd_vel(vx, wz, 0.15)
             time.sleep(0.03)
         self._stop_base()
@@ -704,7 +661,7 @@ def _close_twist_lift(self, x, y):
             self._dbg("lift", ee=self._ee_xyz(), j6=self._gripper_j6())
         except (KeyError, IndexError, TypeError):
             armlib.move_checked(
-                self.manipulation, x, y, 0.22, pitch=p["arm_pitch"], duration=2.0, tol=0.10, logger=self.logger
+                self.manipulation, x, y, 0.22, pitch=p["arm_pitch"], duration=2.0, tol_xy=0.10, logger=self.logger
             )
             self._dbg("lift", ee=self._ee_xyz(), j6=self._gripper_j6(), ik_fallback=True)
 
@@ -788,10 +745,9 @@ def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
             self.head.set_position(int(round(self._p["tilt_deg"])))
             time.sleep(0.5)
             # Rest arm first so it doesn't occlude the head camera.
-            try:
-                arm_rest_position()
-            except SkillFailed as e:
-                self.logger.warning(f"[PickAnyObject] rest-before-search failed: {e}")
+            if not armlib.rest(self.manipulation, self.joint_states, cancelled=lambda: self._cancelled):
+                self._checkpoint()  # rest() also returns False on cancel — unwind, don't warn
+                self.logger.warning("[PickAnyObject] rest-before-search failed")
 
             self.say(f"Looking for {prompt}.")
             xy = self._search(prompt)
diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
index 709c292ea..05ee2f5f2 100644
--- a/workspace/skill_lib/arm.py
+++ b/workspace/skill_lib/arm.py
@@ -26,6 +26,31 @@ class ArmUnhealthy(RuntimeError):
     """Servo brownout/refusal — abort, don't continue limp."""
 
 
+def rest(manipulation, joint_states=None, duration=3, keep_gripper=True, cancelled=None):
+    """Fold the arm to REST_POSITION (blocking up to `duration` seconds).
+
+    keep_gripper preserves the current j6 closure so a held object isn't
+    released. cancelled: optional predicate polled during the move; when it
+    turns true the wait stops early. Returns False if the command was refused
+    or the move was cancelled, else True.
+    """
+    target = list(REST_POSITION)
+    if keep_gripper:
+        j6 = gripper_j6(joint_states)
+        if j6 is not None:
+            target[5] = j6
+    if cancelled is None:
+        return bool(manipulation.move_to_joint_positions(joint_positions=target, duration=duration, blocking=True))
+    if not manipulation.move_to_joint_positions(joint_positions=target, duration=duration, blocking=False):
+        return False
+    start = time.time()
+    while time.time() - start < duration:
+        if cancelled():
+            return False
+        time.sleep(0.1)
+    return True
+
+
 def clamp_reach(x, y):
     return (max(REACH_X[0], min(REACH_X[1], x)), max(REACH_Y[0], min(REACH_Y[1], y)))
 
@@ -58,8 +83,13 @@ def recover(manipulation, logger=None):
     time.sleep(0.5)
 
 
-def move_checked(manipulation, x, y, z, pitch, duration=1.5, tol=0.07, logger=None):
-    """Cartesian move; verify FK within tol, recover+retry once, else raise."""
+def move_checked(manipulation, x, y, z, pitch, duration=1.5, tol_xy=0.05, tol_z=0.10, logger=None):
+    """Cartesian move; verify FK within per-axis tolerances, recover+retry once, else raise.
+
+    tol_z is looser than tol_xy on purpose: a z shortfall usually means the
+    fingers met the object/floor early (expected while descending), while xy
+    error means the grasp is off target.
+    """
     for attempt in (1, 2):
         ok = manipulation.move_to_cartesian_pose(
             x=x,
@@ -72,11 +102,15 @@ def move_checked(manipulation, x, y, z, pitch, duration=1.5, tol=0.07, logger=No
             blocking=True,
         )
         cur = ee_xyz(manipulation)
-        err = math.dist(cur, (x, y, z)) if cur is not None else None
-        if ok and err is not None and err <= tol:
+        err_xy = math.hypot(cur[0] - x, cur[1] - y) if cur is not None else None
+        err_z = abs(cur[2] - z) if cur is not None else None
+        if ok and err_xy is not None and err_xy <= tol_xy and err_z <= tol_z:
             return True
         if logger:
-            logger.warning(f"[arm] not tracking (ok={ok} err={err}) — {'recovering' if attempt == 1 else 'giving up'}")
+            logger.warning(
+                f"[arm] not tracking (ok={ok} err_xy={err_xy} err_z={err_z}) — "
+                f"{'recovering' if attempt == 1 else 'giving up'}"
+            )
         if attempt == 1:
             recover(manipulation, logger)
     raise ArmUnhealthy(f"arm failed to reach ({x:.2f},{y:.2f},{z:.2f})")
diff --git a/workspace/skill_lib/mobility.py b/workspace/skill_lib/mobility.py
new file mode 100644
index 000000000..35c3f9c0b
--- /dev/null
+++ b/workspace/skill_lib/mobility.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Innate Inc
+"""Shared mobility primitives (odometry-closed rotate/drive, pixel P-servo).
+
+Pass interfaces explicitly. Import at TOP of skill files — lazy imports
+inside execute() fail (loader only puts repo root on path during load).
+"""
+
+import math
+import time
+
+
+def stop(mobility):
+    mobility.send_cmd_vel(0.0, 0.0, 0.1)
+
+
+def odom_xyt(odom):
+    """(x, y, theta) from nested dict or flat dataclass, or None."""
+    if odom is None:
+        return None
+    try:
+        if isinstance(odom, dict):
+            p = odom["pose"]["pose"]["position"]
+            return (float(p["x"]), float(p["y"]), math.radians(float(odom["theta_degrees"])))
+        return (float(odom.x), float(odom.y), float(odom.theta))
+    except (KeyError, AttributeError, TypeError):
+        return None
+
+
+def servo_vel(err_px, gain, v_min, v_max, deadband_px):
+    """Pixel P-servo axis: gain per 100 px, clamp to [v_min, v_max], 0 in deadband."""
+    if abs(err_px) <= deadband_px:
+        return 0.0
+    v = max(-v_max, min(v_max, -gain / 100.0 * err_px))
+    return math.copysign(v_min, v) if abs(v) < v_min else v
+
+
+def rotate_by(
+    mobility,
+    get_xyt,
+    angle,
+    *,
+    kp=1.2,
+    wz_max=0.5,
+    wz_min=0.15,
+    tol=math.radians(2.5),
+    timeout=12.0,
+    cancelled=None,
+    dbg=None,
+):
+    """Rotate in place by `angle` rad, closed on odometry yaw (open-loop if
+    get_xyt yields None). cancelled: optional predicate polled each loop —
+    when it turns true the base stops and the function returns early.
+    dbg: optional callable(event, **fields) for telemetry.
+    """
+    if dbg:
+        dbg("rotate", angle_deg=math.degrees(angle))
+    xyt = get_xyt()
+    if xyt is None:
+        mobility.send_cmd_vel(0.0, math.copysign(0.35, angle), abs(angle) / 0.35)
+        time.sleep(abs(angle) / 0.35 + 0.4)
+        return
+    target = xyt[2] + angle
+    t0 = time.time()
+    err = angle
+    while time.time() - t0 < timeout:
+        if cancelled is not None and cancelled():
+            break
+        xyt = get_xyt()
+        if xyt is None:
+            break
+        err = math.atan2(math.sin(target - xyt[2]), math.cos(target - xyt[2]))
+        if abs(err) < tol:
+            break
+        wz = max(-wz_max, min(wz_max, kp * err))
+        if abs(wz) < wz_min:
+            wz = math.copysign(wz_min, wz)
+        mobility.send_cmd_vel(0.0, wz, 0.15)
+        time.sleep(0.08)
+    stop(mobility)
+    if dbg:
+        dbg("rotate_done", err_deg=math.degrees(err), s=time.time() - t0)
+
+
+def drive(
+    mobility,
+    get_xyt,
+    dist,
+    *,
+    kp=0.3,
+    v_max=0.10,
+    v_min=0.04,
+    tol=0.015,
+    timeout=15.0,
+    cancelled=None,
+    dbg=None,
+    logger=None,
+):
+    """Drive straight by `dist` m, closed on odometry position (open-loop if
+    get_xyt yields None). cancelled: optional predicate polled each loop —
+    when it turns true the base stops and the function returns early.
+    dbg: optional callable(event, **fields) for telemetry.
+    """
+    if abs(dist) < tol:
+        return
+    if dbg:
+        dbg("drive", dist_m=dist)
+    xyt = get_xyt()
+    if xyt is None:
+        if logger:
+            logger.warning("[mobility] no odom — open-loop drive")
+        mobility.send_cmd_vel(math.copysign(0.08, dist), 0.0, abs(dist) / 0.08)
+        time.sleep(abs(dist) / 0.08 + 0.4)
+        return
+    x0, y0 = xyt[0], xyt[1]
+    t0 = time.time()
+    err = abs(dist)
+    while time.time() - t0 < timeout:
+        if cancelled is not None and cancelled():
+            break
+        xyt = get_xyt()
+        if xyt is None:
+            break
+        gone = math.hypot(xyt[0] - x0, xyt[1] - y0)
+        err = abs(dist) - gone
+        if err < tol:
+            break
+        v = math.copysign(max(v_min, min(v_max, kp * err)), dist)
+        mobility.send_cmd_vel(v, 0.0, 0.15)
+        time.sleep(0.08)
+    stop(mobility)
+    if dbg:
+        dbg("drive_done", err_m=err, s=time.time() - t0)

From 7ea6d336dcf0764841ddb8f107a07357193243a8 Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Sat, 18 Jul 2026 00:28:45 +0000
Subject: [PATCH 15/19] wip from the robot side

---
 webapp/js/teleop/pickOverlay.js              |   2 +-
 workspace/innate_skills/arm_rest_position.py |  50 +--
 workspace/innate_skills/arm_zero_position.py |  33 +-
 workspace/innate_skills/pick_any_object.py   | 319 +++++++++----------
 workspace/skill_lib/README.md                |   2 +
 workspace/skill_lib/arm.py                   |  96 ++++++
 6 files changed, 267 insertions(+), 235 deletions(-)

diff --git a/webapp/js/teleop/pickOverlay.js b/webapp/js/teleop/pickOverlay.js
index 94d5e4221..18b6046cf 100644
--- a/webapp/js/teleop/pickOverlay.js
+++ b/webapp/js/teleop/pickOverlay.js
@@ -27,7 +27,7 @@ import { PICK_DEBUG_TOPIC } from "../constants.js";
 // (live tuning overrides survive in the running skill between runs).
 // Display-only: never written back.
 const P = {
-  sweet_x: 0.3,
+  sweet_x: 0.4,
   box_y: 0,
   box_half_px: 40,
   accept_frac: 0.5,
diff --git a/workspace/innate_skills/arm_rest_position.py b/workspace/innate_skills/arm_rest_position.py
index 55ffb0196..7e6092682 100644
--- a/workspace/innate_skills/arm_rest_position.py
+++ b/workspace/innate_skills/arm_rest_position.py
@@ -11,9 +11,9 @@
 
 (also runnable from the agent, the webapp skills menu, and
 `scripts/innate skill run local/arm_rest_position`).
-"""
 
-import time
+Implementation: workspace/skill_lib/arm.py (rest).
+"""
 
 from brain_client.skills.types import (
     Interface,
@@ -23,17 +23,7 @@
     Skill,
     SkillResult,
 )
-
-# joints 1-6 = base yaw, shoulder, elbow, wrist pitch, wrist roll, gripper.
-# The folded rest shape, but with the wrist pitch (j4) lifted to 0.55 so the
-# gripper clears the floor instead of pitching down into it: at the old j4~0.87+
-# the gripper jammed into the ground and tripped/broke a servo when driven here
-# under torque.
-# These are the values the arm actually REACHES and HOLDS (j1/j2 clamp to their
-# limits, so commanding "more folded" just settles here). j4=0.30 lifts the
-# wrist ~2 cm further than the first floor-clearing try (0.55, where the
-# fingertips still grazed the floor) — verified live: ee_link z ~0.042 m.
-REST_POSITION = [1.5708, -1.2195, 1.5723, 0.30, 0.0, 0.0031]
+from workspace.skill_lib import arm as armlib
 
 
 class ArmRestPosition(Skill):
@@ -68,35 +58,19 @@ def execute(self, duration: int = 3, keep_gripper: bool = True):
                 rest gripper value.
         """
         self._cancelled = False
-
         if self.manipulation is None:
             return "Manipulation interface not available", SkillResult.FAILURE
 
-        target = list(REST_POSITION)
-        if keep_gripper:
-            js = self.joint_states
-            try:
-                target[5] = float(js["position"][5])
-            except (KeyError, IndexError, TypeError):
-                pass  # no reading — fall back to the captured gripper value
-
-        self.logger.info(
-            f"Moving arm to rest position {[round(j, 3) for j in target]} "
-            f"over {duration}s"
-        )
-        success = self.manipulation.move_to_joint_positions(
-            joint_positions=target, duration=duration, blocking=False
-        )
-        if not success:
+        try:
+            armlib.rest(
+                self.manipulation, self.joint_states, duration=duration,
+                keep_gripper=keep_gripper, is_cancelled=lambda: self._cancelled,
+                logger=self.logger,
+            )
+        except armlib.ArmCancelled:
+            return "Arm motion cancelled", SkillResult.CANCELLED
+        except armlib.ArmFailed:
             return "Failed to send arm command", SkillResult.FAILURE
-
-        # Wait for motion to complete (with cancellation check)
-        start_time = time.time()
-        while time.time() - start_time < duration:
-            if self._cancelled:
-                return "Arm motion cancelled", SkillResult.CANCELLED
-            time.sleep(0.1)
-
         return "Arm moved to rest position", SkillResult.SUCCESS
 
     def cancel(self):
diff --git a/workspace/innate_skills/arm_zero_position.py b/workspace/innate_skills/arm_zero_position.py
index 1f43cb310..1533d8430 100644
--- a/workspace/innate_skills/arm_zero_position.py
+++ b/workspace/innate_skills/arm_zero_position.py
@@ -2,12 +2,13 @@
 # SPDX-License-Identifier: Apache-2.0
 # Copyright (c) 2026 Innate Inc
 """
-Arm Zero Position Skill - Move arm to all-zeros joint position.
-"""
+Arm Zero Position Skill — move arm to all-zeros joint position.
 
-import time
+Implementation: workspace/skill_lib/arm.py (zero).
+"""
 
 from brain_client.skills.types import Interface, InterfaceType, Skill, SkillResult
+from workspace.skill_lib import arm as armlib
 
 
 class ArmZeroPosition(Skill):
@@ -29,28 +30,18 @@ def guidelines(self):
     def execute(self, duration: int = 3):
         """Execute the arm movement to zero position."""
         self._cancelled = False
-
         if self.manipulation is None:
             return "Manipulation interface not available", SkillResult.FAILURE
 
-        self.logger.info(f"Moving arm to zero position [0,0,0,0,0,0] over {duration}s")
-
-        joint_positions = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-
-        success = self.manipulation.move_to_joint_positions(
-            joint_positions=joint_positions, duration=duration, blocking=False
-        )
-
-        if not success:
+        try:
+            armlib.zero(
+                self.manipulation, duration=duration,
+                is_cancelled=lambda: self._cancelled, logger=self.logger,
+            )
+        except armlib.ArmCancelled:
+            return "Arm motion cancelled", SkillResult.CANCELLED
+        except armlib.ArmFailed:
             return "Failed to send arm command", SkillResult.FAILURE
-
-        # Wait for motion to complete (with cancellation check)
-        start_time = time.time()
-        while time.time() - start_time < duration:
-            if self._cancelled:
-                return "Arm motion cancelled", SkillResult.CANCELLED
-            time.sleep(0.1)
-
         return "Arm moved to zero position", SkillResult.SUCCESS
 
     def cancel(self):
diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
index c0fd8a41c..98bb10342 100644
--- a/workspace/innate_skills/pick_any_object.py
+++ b/workspace/innate_skills/pick_any_object.py
@@ -22,7 +22,7 @@
     Skill,
     SkillResult,
 )
-from innate.skills import SkillCancelled, SkillFailed, arm_rest_position
+from innate.skills import SkillCancelled, SkillFailed
 from workspace.skill_lib import arm as armlib
 from workspace.skill_lib import gemini as gemlib
 from workspace.skill_lib import vision
@@ -40,41 +40,45 @@
 # (pickOverlay.js) — keep those in sync when changing them here.
 TUNABLE = {
     # FIND / LOCALIZE
-    "tilt_deg": -20.0,          # head pitch (negative = down)
-    "settle_s": 1.2,            # settle before a frame
+    "tilt_deg": -20.0,  # head pitch (negative = down)
+    "settle_s": 1.2,  # settle before a frame
     # POSITION
-    "sweet_x": 0.30,            # pick-box range in base_link (m)
-    "box_y": 0.0,               # pick-box lateral offset (m)
-    "box_half_px": 40.0,        # outer box half-width (px)
-    "accept_frac": 0.5,         # inner accept box as fraction of outer
-    "box_steps": 6.0,           # max follow / re-detect attempts
-    "bearing_go_deg": 4.0,      # stepwise: turn above this
-    "follow_gain_ang": 0.3,     # rad/s per 100 px
-    "follow_gain_lin": 0.06,    # m/s per 100 px
+    "sweet_x": 0.40,  # pick-box range in base_link (m). 0.40 = the
+    #   operator's preferred box position (higher
+    #   on the image); ALSO the farthest whose
+    #   grasp stays inside fingertip reach —
+    #   beyond ~0.43 the reach clamp lands short.
+    "box_y": 0.0,  # pick-box lateral offset (m)
+    "box_half_px": 40.0,  # outer box half-width (px)
+    "accept_frac": 0.5,  # inner accept box as fraction of outer
+    "box_steps": 6.0,  # max follow / re-detect attempts
+    "bearing_go_deg": 4.0,  # stepwise: turn above this
+    "follow_gain_ang": 0.3,  # rad/s per 100 px
+    "follow_gain_lin": 0.06,  # m/s per 100 px
     # base odometry
     "rot_tol_deg": 2.5,
     "rot_kp": 1.2,
     "rot_wz_max": 0.5,
-    "rot_wz_min": 0.15,         # below this motors don't move
+    "rot_wz_min": 0.15,  # below this motors don't move
     "drive_tol_m": 0.015,
     "drive_kp": 0.3,
     "drive_v_max": 0.10,
     "drive_v_min": 0.04,
     # WRIST ALIGN (0 wrist_steps = blind grasp)
-    "wrist_steps": 2.0,         # Gemini looks (seed + re-seeds)
-    "wrist_stop_z": 0.04,       # hand off to blind ladder
+    "wrist_steps": 2.0,  # Gemini looks (seed + re-seeds)
+    "wrist_stop_z": 0.04,  # hand off to blind ladder
     "wrist_z_step": 0.01,
     "wrist_move_s": 0.5,
-    "wrist_pitch": 0.82,        # match WRIST_SEARCH_ARM camera pitch
-    "wrist_box_u": 320.0,       # wrist goal pixel
+    "wrist_pitch": 0.82,  # match WRIST_SEARCH_ARM camera pitch
+    "wrist_box_u": 320.0,  # wrist goal pixel
     "wrist_box_v": 240.0,
     "wrist_half_px": 60.0,
-    "wrist_kx": -0.04,          # m/100px v-error (signed; flip if diverges)
-    "wrist_ky": -0.04,          # m/100px u-error; gains at z=0.15, scale w/ height
+    "wrist_kx": -0.04,  # m/100px v-error (signed; flip if diverges)
+    "wrist_ky": -0.04,  # m/100px u-error; gains at z=0.15, scale w/ height
     "wrist_step_max": 0.04,
     "wrist_settle_s": 0.8,
     # GRASP
-    "grasp_x_off": 0.03,        # fingertips ahead of ee_link
+    "grasp_x_off": 0.03,  # fingertips ahead of ee_link
     "hover_z": 0.15,
     "hover_s": 2.0,
     "descend_z1": 0.10,
@@ -82,12 +86,12 @@
     "descend_z3": 0.03,
     "floor_z": 0.01,
     "descend_s": 1.2,
-    "descend_abort_z": 0.12,    # EE still above this => limp, abort
+    "descend_abort_z": 0.12,  # EE still above this => limp, abort
     "arm_pitch": 1.30,
-    "close_strength": 0.60,     # >~0.6 overcurrent-trips the gripper servo
+    "close_strength": 0.60,  # >~0.6 overcurrent-trips the gripper servo
     "close_s": 1.5,
     "close_settle_s": 0.8,
-    "twist_rad": 0.6,           # wind fabric onto fingers
+    "twist_rad": 0.6,  # wind fabric onto fingers
     "lift_rad": 0.6,
 }
 
@@ -141,10 +145,8 @@ def ok(self):
 
     def update(self, hsv):
         """Blob center, or None on miss (keeps last window for retry)."""
-        pt, window, _score = vision.seg_track(
-            hsv, self.model, self.window, min_score=WRIST_SEG_MIN_SCORE)
-        if pt is not None and math.hypot(pt[0] - self.guess[0],
-                                         pt[1] - self.guess[1]) > WRIST_MAX_JUMP_PX:
+        pt, window, _score = vision.seg_track(hsv, self.model, self.window, min_score=WRIST_SEG_MIN_SCORE)
+        if pt is not None and math.hypot(pt[0] - self.guess[0], pt[1] - self.guess[1]) > WRIST_MAX_JUMP_PX:
             pt = None
         if pt is None:
             self.misses += 1
@@ -191,9 +193,7 @@ def _ensure_debug_io(self):
         if self._dbg_pub is not None or self.node is None:
             return
         self._dbg_pub = self.node.create_publisher(String, DEBUG_TOPIC, 10)
-        self._tuning_sub = self.node.create_subscription(
-            String, TUNING_TOPIC, self._on_tuning, 10
-        )
+        self._tuning_sub = self.node.create_subscription(String, TUNING_TOPIC, self._on_tuning, 10)
 
     def _on_tuning(self, msg):
         try:
@@ -202,11 +202,7 @@ def _on_tuning(self, msg):
             return
         if not isinstance(incoming, dict):
             return
-        applied = {
-            k: float(v)
-            for k, v in incoming.items()
-            if k in self._p and isinstance(v, (int, float))
-        }
+        applied = {k: float(v) for k, v in incoming.items() if k in self._p and isinstance(v, (int, float))}
         if applied:
             self._p.update(applied)
             self.logger.info(f"[PickAnyObject] tuning applied: {applied}")
@@ -219,17 +215,17 @@ def _dbg(self, ev, **fields):
         self._dbg_pub.publish(String(data=json.dumps(_round_floats(fields))))
 
     def _checkpoint(self):
-        """Raise out of the run if cancel() latched. One raise here, one
-        `except SkillCancelled` in execute — no cancelled-as-None plumbing.
-        Deliberately NOT called during close/twist/lift: once the fingers
-        commit, aborting mid-grip would drag the object on the way home."""
+        """Raise out of the run if cancel() latched. Failures raise
+        SkillFailed / SkillCancelled and unwind to execute's handlers —
+        no None-as-failure plumbing. Deliberately NOT called during
+        close/twist/lift: once the fingers commit, aborting mid-grip
+        would drag the object on the way home."""
         if self._cancelled:
             raise SkillCancelled("Pick cancelled")
 
     def _gemini_call(self, image_b64, question):
         """Vision Q&A via gemlib."""
-        return gemlib.ask_image(self._proxy, image_b64, question,
-                                logger=self.logger)
+        return gemlib.ask_image(self._proxy, image_b64, question, logger=self.logger)
 
     def _detect_px(self, prompt):
         """Head frame -> best grasp pixel, or None."""
@@ -244,9 +240,9 @@ def _detect_px(self, prompt):
             "not paper/packaging when asked for clothing, and NOT anything held "
             "by the robot arm. Return ONLY a JSON list of matches, each "
             '{"box_2d":[ymin,xmin,ymax,xmax], "grasp_point":[y,x]} normalized '
-            "0-1000, best first. grasp_point is the THICKEST / most bunched-up / "
-            "highest part of the object — the best spot for a two-finger gripper "
-            "to pinch, NOT the flat middle. Empty list if not present.",
+            "0-1000, best first. grasp_point is the CENTER of the object "
+            "(geometric middle of the visible blob), not an edge or tip. "
+            "Empty list if not present.",
         )
         return vision.parse_det_px(text)
 
@@ -258,10 +254,7 @@ def _localize_px(self, prompt):
             return None, None
         xy = pixel_to_floor(px[0], px[1], self._p["tilt_deg"])
         if xy:
-            self.logger.info(
-                f"[PickAnyObject] px=({px[0]:.0f},{px[1]:.0f}) -> "
-                f"base_link ({xy[0]:.3f},{xy[1]:.3f})"
-            )
+            self.logger.info(f"[PickAnyObject] px=({px[0]:.0f},{px[1]:.0f}) -> base_link ({xy[0]:.3f},{xy[1]:.3f})")
         self._dbg("localize", px=px, xy=xy, tilt_deg=self._p["tilt_deg"])
         return xy, px
 
@@ -276,8 +269,7 @@ def _odom_xyt(self):
         try:
             if isinstance(od, dict):
                 p = od["pose"]["pose"]["position"]
-                return (float(p["x"]), float(p["y"]),
-                        math.radians(float(od["theta_degrees"])))
+                return (float(p["x"]), float(p["y"]), math.radians(float(od["theta_degrees"])))
             return (float(od.x), float(od.y), float(od.theta))
         except (KeyError, AttributeError, TypeError):
             return None
@@ -286,8 +278,7 @@ def _rotate_by(self, angle, tol=None, timeout=12.0):
         self._dbg("rotate", angle_deg=math.degrees(angle))
         od = self._odom_xyt()
         if od is None:
-            self.mobility.send_cmd_vel(0.0, math.copysign(0.35, angle),
-                                       abs(angle) / 0.35)
+            self.mobility.send_cmd_vel(0.0, math.copysign(0.35, angle), abs(angle) / 0.35)
             time.sleep(abs(angle) / 0.35 + 0.4)
             return
         target = od[2] + angle
@@ -299,8 +290,7 @@ def _rotate_by(self, angle, tol=None, timeout=12.0):
             if od is None:
                 break
             err = math.atan2(math.sin(target - od[2]), math.cos(target - od[2]))
-            if abs(err) < (tol if tol is not None
-                           else math.radians(self._p["rot_tol_deg"])):
+            if abs(err) < (tol if tol is not None else math.radians(self._p["rot_tol_deg"])):
                 break
             wz_max = self._p["rot_wz_max"]
             wz = max(-wz_max, min(wz_max, self._p["rot_kp"] * err))
@@ -319,8 +309,7 @@ def _drive(self, dist, tol=None, timeout=15.0):
         od = self._odom_xyt()
         if od is None:
             self.logger.warning("[PickAnyObject] no odom — open-loop drive")
-            self.mobility.send_cmd_vel(math.copysign(0.08, dist), 0.0,
-                                       abs(dist) / 0.08)
+            self.mobility.send_cmd_vel(math.copysign(0.08, dist), 0.0, abs(dist) / 0.08)
             time.sleep(abs(dist) / 0.08 + 0.4)
             return
         x0, y0 = od[0], od[1]
@@ -336,8 +325,7 @@ def _drive(self, dist, tol=None, timeout=15.0):
             if err < tol:
                 break
             v = math.copysign(
-                max(self._p["drive_v_min"],
-                    min(self._p["drive_v_max"], self._p["drive_kp"] * err)),
+                max(self._p["drive_v_min"], min(self._p["drive_v_max"], self._p["drive_kp"] * err)),
                 dist,
             )
             self.mobility.send_cmd_vel(v, 0.0, 0.15)
@@ -352,16 +340,14 @@ def _gripper_j6(self):
         return armlib.gripper_j6(self.joint_states)
 
     def _rest_arm(self, keep_grip):
-        """Fold home, or CARRY_ARM with full close_strength if holding."""
-        if keep_grip:
-            target = CARRY_ARM + [-self._p["close_strength"]]
-        else:
-            target = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-        for _ in range(2):
-            self.manipulation.move_to_joint_positions(
-                joint_positions=target, duration=3, blocking=True,
-            )
-            time.sleep(0.3)
+        """Best-effort teardown: carry if holding, else zero. Never raises."""
+        joints = (
+            CARRY_ARM + [-self._p["close_strength"]] if keep_grip else armlib.ZERO
+        )
+        try:
+            armlib.go(self.manipulation, joints, duration=3.0, times=2)
+        except Exception as e:  # noqa: BLE001 — teardown must not mask the run result
+            self.logger.warning(f"[PickAnyObject] rest-arm failed: {e}")
 
     def _search(self, prompt):
         """Scan: straight, right 30°, left 60°. First hit wins. (+yaw=left)"""
@@ -374,12 +360,11 @@ def _search(self, prompt):
             xy, _px = self._localize_px(prompt)
             if xy is not None:
                 return xy
-        return None
+        raise SkillFailed(f"Could not find '{prompt}' on the floor, even after scanning")
 
     def _sweet_box(self):
         """(center_px, outer_half, accept_half). Stop only inside accept."""
-        c = floor_to_pixel(self._p["sweet_x"], self._p["box_y"],
-                           self._p["tilt_deg"])
+        c = floor_to_pixel(self._p["sweet_x"], self._p["box_y"], self._p["tilt_deg"])
         assert c is not None, "pick box off-image — check tilt_deg/sweet_x"
         half = self._p["box_half_px"]
         return c, half, half * self._p["accept_frac"]
@@ -421,8 +406,7 @@ def _follow_into_box(self, seed_px):
 
             now = time.time()
             if now - last_dbg > 0.1:
-                self._dbg("servo", px=[u, v], box=[cu, cv, half, accept],
-                          inside=inside)
+                self._dbg("servo", px=[u, v], box=[cu, cv, half, accept], inside=inside)
                 last_dbg = now
 
             if inside:
@@ -435,17 +419,16 @@ def _follow_into_box(self, seed_px):
             in_box = 0
 
             # Deadband = accept (inner) box; right -> -wz, too close (low) -> -vx.
-            wz = _servo_vel(u - cu, self._p["follow_gain_ang"],
-                            self._p["rot_wz_min"], self._p["rot_wz_max"], accept)
-            vx = _servo_vel(v - cv, self._p["follow_gain_lin"],
-                            self._p["drive_v_min"], self._p["drive_v_max"], accept)
+            wz = _servo_vel(u - cu, self._p["follow_gain_ang"], self._p["rot_wz_min"], self._p["rot_wz_max"], accept)
+            vx = _servo_vel(v - cv, self._p["follow_gain_lin"], self._p["drive_v_min"], self._p["drive_v_max"], accept)
             self.mobility.send_cmd_vel(vx, wz, 0.15)
             time.sleep(0.03)
         self._stop_base()
         return "timeout", None
 
     def _position_above(self, prompt, xy):
-        """Flow-follow into pick box; Gemini reseed/confirm. Stepwise if no cam."""
+        """Flow-follow into pick box; Gemini reseed/confirm. Stepwise if no cam.
+        Raises SkillFailed if the object cannot be centred."""
         if self._gray_frame() is None:
             return self._position_stepwise(prompt, xy)
 
@@ -456,7 +439,7 @@ def _position_above(self, prompt, xy):
                 seed = self._detect_px(prompt)
                 if seed is None:
                     self._dbg("position_done", xy=None, reason="lost")
-                    return None
+                    break
             result, _pt = self._follow_into_box(seed)
             if result == "noframe":
                 return self._position_stepwise(prompt, xy)
@@ -466,17 +449,19 @@ def _position_above(self, prompt, xy):
             xy2, px2 = self._localize_px(prompt)
             if px2 is None:
                 self._dbg("position_done", xy=None, reason="lost")
-                return None
+                break
             (cu, cv), half, accept = self._sweet_box()
             if xy2 is not None and _inside_box(px2, cu, cv, accept):
                 self._dbg("position_done", xy=xy2, attempts=attempt)
                 return xy2
             seed = px2 if xy2 is not None else None
-        self._dbg("position_done", xy=None, reason="never inside the box")
-        return None
+        else:
+            self._dbg("position_done", xy=None, reason="never inside the box")
+        raise SkillFailed(f"Could not centre '{prompt}' in the pick box")
 
     def _position_stepwise(self, prompt, xy):
-        """No-camera fallback: turn OR drive, re-detect, repeat."""
+        """No-camera fallback: turn OR drive, re-detect, repeat.
+        Raises SkillFailed if the object cannot be centred."""
         target_bearing = math.atan2(self._p["box_y"], self._p["sweet_x"])
         target_range = math.hypot(self._p["sweet_x"], self._p["box_y"])
         px = floor_to_pixel(xy[0], xy[1], self._p["tilt_deg"])
@@ -486,11 +471,10 @@ def _position_stepwise(self, prompt, xy):
                 xy, px = self._localize_px(prompt)
                 if px is None:
                     self._dbg("position_done", xy=None, reason="lost")
-                    return None
+                    break
             (cu, cv), half, accept = self._sweet_box()
             inside = xy is not None and _inside_box(px, cu, cv, accept)
-            self._dbg("position", step=step, px=px, xy=xy,
-                      box=[cu, cv, half, accept], inside=inside)
+            self._dbg("position", step=step, px=px, xy=xy, box=[cu, cv, half, accept], inside=inside)
             if inside:
                 self._dbg("position_done", xy=xy, steps=step)
                 return xy
@@ -503,8 +487,9 @@ def _position_stepwise(self, prompt, xy):
             else:
                 self._drive(math.hypot(xy[0], xy[1]) - target_range)
             px = None
-        self._dbg("position_done", xy=None, reason="never inside the box")
-        return None
+        else:
+            self._dbg("position_done", xy=None, reason="never inside the box")
+        raise SkillFailed(f"Could not centre '{prompt}' in the pick box")
 
     # GRASP: search pose -> seed -> servo down -> blind push -> close/twist/lift
     # (wrist_steps=0 skips to blind hover + push)
@@ -512,14 +497,18 @@ def _wrist_seed(self, prompt, z):
         """Wrist Gemini box -> (center_px, box) or (None, None)."""
         time.sleep(self._p["wrist_settle_s"])
         img = self.wrist_image
-        text = self._gemini_call(
-            img,
-            f"Wrist camera on a robot gripper, looking down at the floor. "
-            f"Find '{prompt}' on the floor. Ignore the gripper fingers "
-            "themselves. Return ONLY a JSON list of matches, each "
-            '{"box_2d":[ymin,xmin,ymax,xmax]} normalized 0-1000, best first, '
-            "each box TIGHT around its object. Empty list if not visible.",
-        ) if img else None
+        text = (
+            self._gemini_call(
+                img,
+                f"Wrist camera on a robot gripper, looking down at the floor. "
+                f"Find '{prompt}' on the floor. Ignore the gripper fingers "
+                "themselves. Return ONLY a JSON list of matches, each "
+                '{"box_2d":[ymin,xmin,ymax,xmax]} normalized 0-1000, best first, '
+                "each box TIGHT around its object. Empty list if not visible.",
+            )
+            if img
+            else None
+        )
         box = vision.parse_det_box(text)
         px = (box[0] + box[2] / 2.0, box[1] + box[3] / 2.0) if box else None
         self._dbg("wrist_seed", z=z, px=px)
@@ -585,7 +574,7 @@ def _wrist_servo(self, prompt, tx, ty):
             return self._wrist_done(tx, ty, z, "not seen")
 
         deadline = time.time() + WRIST_ALIGN_TIMEOUT_S
-        streak = 0    # verified matches since the arm last moved
+        streak = 0  # verified matches since the arm last moved
         centered = 0  # consecutive matches INSIDE the box
         reason = "reached stop z"
         while z > p["wrist_stop_z"] + 1e-6:
@@ -616,11 +605,9 @@ def _wrist_servo(self, prompt, tx, ty):
 
             err_u = px[0] - p["wrist_box_u"]
             err_v = px[1] - p["wrist_box_v"]
-            inside = _inside_box(px, p["wrist_box_u"], p["wrist_box_v"],
-                                 p["wrist_half_px"])
+            inside = _inside_box(px, p["wrist_box_u"], p["wrist_box_v"], p["wrist_half_px"])
             centered = centered + 1 if inside else 0
-            self._dbg("wrist_servo", px=px, z=z, inside=inside,
-                      tx=x, ty=y, ee=self._ee_xyz())
+            self._dbg("wrist_servo", px=px, z=z, inside=inside, tx=x, ty=y, ee=self._ee_xyz())
             if streak < 2:
                 continue  # watch one more frame before trusting it
             if inside and centered < 2:
@@ -638,9 +625,9 @@ def _wrist_servo(self, prompt, tx, ty):
                 x, y = armlib.clamp_reach(x, y)
                 # feed-forward: expect the blob at the box center next frame
                 tracker.guess = (p["wrist_box_u"], p["wrist_box_v"])
-            armlib.move_checked(self.manipulation, x, y, z,
-                                pitch=p["wrist_pitch"],
-                                duration=p["wrist_move_s"], logger=self.logger)
+            armlib.move_checked(
+                self.manipulation, x, y, z, pitch=p["wrist_pitch"], duration=p["wrist_move_s"], logger=self.logger
+            )
             streak = 0
             centered = 0  # view shifted — re-confirm centering
 
@@ -650,33 +637,37 @@ def _goto_search_pose(self, bearing):
         """WRIST_SEARCH_ARM aimed at bearing; pins IK to elbow-up branch."""
         a = WRIST_SEARCH_ARM
         j6 = self._gripper_j6()
-        pose = [bearing, a[1], a[2],
-                self._p["wrist_pitch"] - a[1] - a[2], a[4],
-                j6 if j6 is not None else 0.0]
-        self.manipulation.move_to_joint_positions(
-            joint_positions=pose, duration=self._p["hover_s"], blocking=True)
+        pose = [bearing, a[1], a[2], self._p["wrist_pitch"] - a[1] - a[2], a[4], j6 if j6 is not None else 0.0]
+        self.manipulation.move_to_joint_positions(joint_positions=pose, duration=self._p["hover_s"], blocking=True)
         time.sleep(0.3)
         self._dbg("hover", ee=self._ee_xyz())
 
     def _open_gripper_checked(self):
         """Open gripper with trip recovery."""
         armlib.open_checked(
-            self.manipulation, self._gripper_j6, logger=self.logger,
+            self.manipulation,
+            self._gripper_j6,
+            logger=self.logger,
             on_reboot=lambda j6: self._dbg("gripper_reboot", j6=j6),
         )
 
     def _push_to_floor(self, x, y, z_from, deep):
         """Blind descent ladder to floor. Failed rung = contact; abort if still high."""
         p = self._p
-        rungs = [p["descend_z1"], p["descend_z2"], p["descend_z3"],
-                 0.0 if deep else p["floor_z"]]
+        rungs = [p["descend_z1"], p["descend_z2"], p["descend_z3"], 0.0 if deep else p["floor_z"]]
         for z in rungs:
             if z >= z_from - 1e-6:
                 continue
             self._checkpoint()
             ok = self.manipulation.move_to_cartesian_pose(
-                x=x, y=y, z=z, roll=0.0, pitch=p["arm_pitch"], yaw=0.0,
-                duration=p["descend_s"], blocking=True,
+                x=x,
+                y=y,
+                z=z,
+                roll=0.0,
+                pitch=p["arm_pitch"],
+                yaw=0.0,
+                duration=p["descend_s"],
+                blocking=True,
             )
             self._dbg("descend", z=z, ok=bool(ok), ee=self._ee_xyz())
             if not ok:
@@ -692,34 +683,29 @@ def _close_twist_lift(self, x, y):
         """Close, joint-space twist+lift (IK would unwind j5). Hold full close cmd."""
         p = self._p
         j6_open = self._gripper_j6()
-        armlib.close(self.manipulation, strength=p["close_strength"],
-                     duration=p["close_s"])
+        armlib.close(self.manipulation, strength=p["close_strength"], duration=p["close_s"])
         time.sleep(p["close_settle_s"])
-        self._dbg("close", j6_open=j6_open, j6=self._gripper_j6(),
-                  strength=p["close_strength"])
+        self._dbg("close", j6_open=j6_open, j6=self._gripper_j6(), strength=p["close_strength"])
 
         grip = -p["close_strength"]
         try:
             j = list(self.joint_states["position"][:6])
             j[4] = max(-1.4, min(1.4, j[4] + p["twist_rad"]))
             j[5] = grip
-            self.manipulation.move_to_joint_positions(
-                joint_positions=j, duration=1.0, blocking=True)
+            self.manipulation.move_to_joint_positions(joint_positions=j, duration=1.0, blocking=True)
             time.sleep(0.3)
             self._dbg("twist", j4=j[4])
             j = list(self.joint_states["position"][:6])
             j[1] = max(-1.4, j[1] - p["lift_rad"])
             j[5] = grip
-            self.manipulation.move_to_joint_positions(
-                joint_positions=j, duration=2.0, blocking=True)
+            self.manipulation.move_to_joint_positions(joint_positions=j, duration=2.0, blocking=True)
             time.sleep(0.3)
             self._dbg("lift", ee=self._ee_xyz(), j6=self._gripper_j6())
         except (KeyError, IndexError, TypeError):
-            armlib.move_checked(self.manipulation, x, y, 0.22,
-                                pitch=p["arm_pitch"], duration=2.0, tol=0.10,
-                                logger=self.logger)
-            self._dbg("lift", ee=self._ee_xyz(), j6=self._gripper_j6(),
-                      ik_fallback=True)
+            armlib.move_checked(
+                self.manipulation, x, y, 0.22, pitch=p["arm_pitch"], duration=2.0, tol=0.10, logger=self.logger
+            )
+            self._dbg("lift", ee=self._ee_xyz(), j6=self._gripper_j6(), ik_fallback=True)
 
     def _grasp_at(self, prompt, xy, deep=False):
         """Full grasp at floor xy (base_link). Reads live self._p knobs."""
@@ -728,10 +714,8 @@ def _grasp_at(self, prompt, xy, deep=False):
 
         grab_px = floor_to_pixel(x + p["grasp_x_off"], y, p["tilt_deg"])
         obj_px = floor_to_pixel(xy[0], xy[1], p["tilt_deg"])
-        clamped = (abs((xy[0] - p["grasp_x_off"]) - x) > 1e-4
-                   or abs(xy[1] - y) > 1e-4)
-        self._dbg("grasp", xy=xy, tx=x, ty=y, deep=deep,
-                  grab_px=grab_px, obj_px=obj_px, clamped=clamped)
+        clamped = abs((xy[0] - p["grasp_x_off"]) - x) > 1e-4 or abs(xy[1] - y) > 1e-4
+        self._dbg("grasp", xy=xy, tx=x, ty=y, deep=deep, grab_px=grab_px, obj_px=obj_px, clamped=clamped)
 
         self._open_gripper_checked()
 
@@ -740,9 +724,9 @@ def _grasp_at(self, prompt, xy, deep=False):
             x, y, z = self._wrist_servo(prompt, x, y)
         else:
             z = p["hover_z"]
-            armlib.move_checked(self.manipulation, x, y, z,
-                                pitch=p["arm_pitch"], duration=p["hover_s"],
-                                logger=self.logger)
+            armlib.move_checked(
+                self.manipulation, x, y, z, pitch=p["arm_pitch"], duration=p["hover_s"], logger=self.logger
+            )
             self._dbg("hover", ee=self._ee_xyz())
 
         self._push_to_floor(x, y, z, deep)
@@ -761,17 +745,22 @@ def _grasp_verified(self, prompt):
         wrist_note = (
             " Image 2 is the WRIST camera next to the gripper fingers "
             "(mirrored) — the object may be visible held in the fingers there."
-            if len(images) > 1 else ""
+            if len(images) > 1
+            else ""
+        )
+        floor_text = (
+            self._gemini_call(
+                images,
+                f"Robot just tried to pick up '{prompt}'. Image 1 is the head "
+                f"camera looking at the floor.{wrist_note} "
+                f"Is '{prompt}' lying ON the floor/carpet anywhere in view? "
+                "Something hanging from the robot's gripper or held between the "
+                "gripper fingers does NOT count as on the floor. "
+                "Answer only YES or NO.",
+            )
+            if images
+            else None
         )
-        floor_text = self._gemini_call(
-            images,
-            f"Robot just tried to pick up '{prompt}'. Image 1 is the head "
-            f"camera looking at the floor.{wrist_note} "
-            f"Is '{prompt}' lying ON the floor/carpet anywhere in view? "
-            "Something hanging from the robot's gripper or held between the "
-            "gripper fingers does NOT count as on the floor. "
-            "Answer only YES or NO.",
-        ) if images else None
         floor_clear = bool(floor_text) and "NO" in floor_text.upper()
         j6_ok = j6 is not None and j6 > GRIPPER_EMPTY_J6 + 0.02
         held = floor_clear and j6_ok
@@ -779,8 +768,7 @@ def _grasp_verified(self, prompt):
             f"[PickAnyObject] verify: floor={floor_text!r} j6={j6} "
             f"({len(images)} cams) -> {'HELD' if held else 'NOT HELD'}"
         )
-        self._dbg("verify", floor_clear=floor_clear, j6=j6, held=held,
-                  cams=len(images))
+        self._dbg("verify", floor_clear=floor_clear, j6=j6, held=held, cams=len(images))
         return held
 
     def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
@@ -798,52 +786,33 @@ def execute(self, prompt: str = "the sock", max_base_steps: int = 10):
             self.head.set_position(int(round(self._p["tilt_deg"])))
             time.sleep(0.5)
             # Rest arm first so it doesn't occlude the head camera.
-            try:
-                arm_rest_position()
-            except SkillFailed as e:
-                self.logger.warning(f"[PickAnyObject] rest-before-search failed: {e}")
+            armlib.rest(self.manipulation, self.joint_states, logger=self.logger)
 
             self.say(f"Looking for {prompt}.")
             xy = self._search(prompt)
-            if xy is None:
-                return (
-                    f"Could not find '{prompt}' on the floor, even after scanning",
-                    SkillResult.FAILURE,
-                )
-
             xy = self._position_above(prompt, xy)
-            if xy is None:
-                return (
-                    f"Could not centre '{prompt}' in the pick box",
-                    SkillResult.FAILURE,
-                )
             self.say("Picking it up.")
             self._grasp_at(prompt, xy)
-            if self._grasp_verified(prompt):
-                holding = True
-                self.say("Got it.")
-                return (
-                    f"Picked up '{prompt}' (verified: floor clear after backing up)",
-                    SkillResult.SUCCESS,
-                )
-            self.say("I couldn't get a grip on it.")
+            if not self._grasp_verified(prompt):
+                self.say("I couldn't get a grip on it.")
+                raise SkillFailed(f"Grasp missed — '{prompt}' is still on the floor (verified after backing up)")
+            holding = True
+            self.say("Got it.")
             return (
-                f"Grasp missed — '{prompt}' is still on the floor (verified after "
-                "backing up)",
-                SkillResult.FAILURE,
+                f"Picked up '{prompt}' (verified: floor clear after backing up)",
+                SkillResult.SUCCESS,
             )
         except SkillCancelled:
             return "Pick cancelled", SkillResult.CANCELLED
+        except (SkillFailed, armlib.ArmFailed) as e:
+            return str(e), SkillResult.FAILURE
         except armlib.ArmUnhealthy as e:
             self.say("My arm isn't responding properly, stopping.")
             return f"Arm servo failure: {e}", SkillResult.FAILURE
         finally:
             self._dbg("run_end")
             self._stop_base()
-            try:
-                self._rest_arm(keep_grip=holding)
-            except Exception as e:  # noqa: BLE001
-                self.logger.warning(f"[PickAnyObject] rest-arm failed: {e}")
+            self._rest_arm(keep_grip=holding)
             if self.head is not None:
                 self.head.set_position(0)
 
diff --git a/workspace/skill_lib/README.md b/workspace/skill_lib/README.md
index 211e145db..4b74efccf 100644
--- a/workspace/skill_lib/README.md
+++ b/workspace/skill_lib/README.md
@@ -9,6 +9,8 @@ from workspace.skill_lib import arm as armlib
 
 armlib.open_checked(self.manipulation, self._gripper_j6)
 armlib.move_checked(self.manipulation, x, y, z, pitch=1.3, logger=self.logger)
+armlib.rest(self.manipulation, self.joint_states)
+armlib.go(self.manipulation, CARRY if holding else armlib.ZERO, times=2)
 ```
 
 ## What belongs where
diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
index 5e30e5596..49383a09e 100644
--- a/workspace/skill_lib/arm.py
+++ b/workspace/skill_lib/arm.py
@@ -5,6 +5,12 @@
 
 Pass interfaces explicitly. Import at TOP of skill files — lazy imports
 inside execute() fail (loader only puts repo root on path during load).
+
+Poses are plain joint lists. ``go`` / ``rest`` / ``zero`` raise on failure
+so call sites stay declarative:
+
+    armlib.rest(self.manipulation, self.joint_states)
+    armlib.go(self.manipulation, CARRY if holding else armlib.ZERO)
 """
 
 import math
@@ -14,11 +20,30 @@
 REACH_X = (0.22, 0.40)
 REACH_Y = (-0.10, 0.10)
 
+# joints 1-6 = base yaw, shoulder, elbow, wrist pitch, wrist roll, gripper.
+# Folded rest with j4 lifted so the gripper clears the floor (verified live:
+# ee_link z ~0.042 m). j1/j2 clamp to their limits, so this is what the arm
+# actually reaches and holds.
+REST = [1.5708, -1.2195, 1.5723, 0.30, 0.0, 0.0031]
+ZERO = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+
+# Back-compat aliases.
+REST_POSITION = REST
+ZERO_POSITION = ZERO
+
 
 class ArmUnhealthy(RuntimeError):
     """Servo brownout/refusal — abort, don't continue limp."""
 
 
+class ArmFailed(RuntimeError):
+    """Joint/cartesian command rejected or did not complete."""
+
+
+class ArmCancelled(Exception):
+    """Caller-supplied cancel check fired mid-wait."""
+
+
 def clamp_reach(x, y):
     """Clamp (x, y) into the arm reach box."""
     return (max(REACH_X[0], min(REACH_X[1], x)),
@@ -43,6 +68,77 @@ def gripper_j6(joint_states):
         return None
 
 
+def with_gripper(joints, j6):
+    """Copy of joints with j6 set (no-op if j6 is None)."""
+    out = list(joints)
+    if j6 is not None:
+        out[5] = float(j6)
+    return out
+
+
+def rest_joints(joint_states=None, keep_gripper=True):
+    """Joint target for the folded rest pose."""
+    if keep_gripper:
+        return with_gripper(REST, gripper_j6(joint_states))
+    return list(REST)
+
+
+def go(manipulation, joints, duration=3.0, *, times=1, pause=0.3,
+       is_cancelled=None, logger=None):
+    """Move to joint positions. Raises ArmFailed / ArmCancelled.
+
+    ``times`` + ``pause`` repeat the move so the arm can settle (pick teardown).
+    With ``is_cancelled``, the move is non-blocking and polled so a skill
+    cancel can abort the wait; otherwise each move blocks for ``duration``.
+    """
+    joints = list(joints)
+    blocking = is_cancelled is None
+    for i in range(times):
+        if logger:
+            logger.info(
+                f"[arm] joints {[round(j, 3) for j in joints]} over {duration}s"
+            )
+        ok = manipulation.move_to_joint_positions(
+            joint_positions=joints, duration=duration, blocking=blocking,
+        )
+        if not ok:
+            raise ArmFailed("Failed to send arm command")
+        if is_cancelled is not None:
+            t0 = time.time()
+            while time.time() - t0 < duration:
+                if is_cancelled():
+                    raise ArmCancelled("Arm motion cancelled")
+                time.sleep(0.1)
+        if pause and i + 1 < times:
+            time.sleep(pause)
+
+
+# Back-compat name used by earlier call sites.
+go_joints = go
+
+
+def rest(manipulation, joint_states=None, duration=3.0, keep_gripper=True,
+         is_cancelled=None, logger=None, **go_kw):
+    """Fold to REST. keep_gripper preserves current j6 when held."""
+    go(
+        manipulation, rest_joints(joint_states, keep_gripper),
+        duration=duration, is_cancelled=is_cancelled, logger=logger, **go_kw,
+    )
+
+
+def zero(manipulation, duration=3.0, is_cancelled=None, logger=None, **go_kw):
+    """Move all joints to 0."""
+    go(
+        manipulation, ZERO, duration=duration,
+        is_cancelled=is_cancelled, logger=logger, **go_kw,
+    )
+
+
+# Back-compat aliases.
+rest_position = rest
+zero_position = zero
+
+
 def recover(manipulation, logger=None):
     """Reboot servos + torque on (clears overcurrent trip / brownout)."""
     if logger:

From 1eacf39f57c3dfa7ea8061dedb000f86e49b16e9 Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Sat, 18 Jul 2026 02:46:42 +0000
Subject: [PATCH 16/19] Picking last update

---
 webapp/js/teleop/pickOverlay.js            |  4 ++--
 workspace/innate_skills/pick_any_object.py | 14 ++++++--------
 workspace/skill_lib/arm.py                 |  2 +-
 3 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/webapp/js/teleop/pickOverlay.js b/webapp/js/teleop/pickOverlay.js
index a8e8493ef..9d5b3929e 100644
--- a/webapp/js/teleop/pickOverlay.js
+++ b/webapp/js/teleop/pickOverlay.js
@@ -318,8 +318,8 @@ export function createPickOverlay(parent, rosClient, session) {
         // A Gemini look on the wrist image (initial seed or re-seed on loss).
         wristPx = Array.isArray(ev.px) ? { u: ev.px[0], v: ev.px[1] } : null;
         break;
-      case "wrist_servo":
-        // Per-cycle tracking during the servo descent.
+      case "wrist_descend":
+        // Per-cycle tracking during the wrist descent.
         if (Array.isArray(ev.px)) wristPx = { u: ev.px[0], v: ev.px[1] };
         wristBox.classList.toggle("inside", ev.inside === true);
         break;
diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
index 96b228c6a..299e5c79c 100644
--- a/workspace/innate_skills/pick_any_object.py
+++ b/workspace/innate_skills/pick_any_object.py
@@ -89,7 +89,7 @@
     "descend_s": 1.2,
     "descend_abort_z": 0.12,  # EE still above this => limp, abort
     "arm_pitch": 1.30,
-    "close_strength": 0.60,  # >~0.6 overcurrent-trips the gripper servo
+    "close_strength": 0.70,  # firmer grip holds better on hardware; watch for servo trips above this
     "close_s": 1.5,
     "close_settle_s": 0.8,
     "twist_rad": 0.6,  # wind fabric onto fingers
@@ -292,9 +292,7 @@ def _gripper_j6(self):
 
     def _rest_arm(self, keep_grip):
         """Best-effort teardown: carry if holding, else zero. Never raises."""
-        joints = (
-            CARRY_ARM + [-self._p["close_strength"]] if keep_grip else armlib.ZERO
-        )
+        joints = CARRY_ARM + [-self._p["close_strength"]] if keep_grip else armlib.ZERO
         try:
             armlib.go(self.manipulation, joints, duration=3.0, times=2)
         except Exception as e:  # noqa: BLE001 — teardown must not mask the run result
@@ -494,7 +492,7 @@ def _next_wrist_hsv(self, last_b64, timeout=1.5):
         return None, last_b64
 
     def _wrist_done(self, x, y, z, reason):
-        """Telemetry + return value for every _wrist_servo exit."""
+        """Telemetry + return value for every _wrist_descend exit."""
         grab = floor_to_pixel(x + self._p["grasp_x_off"], y, self._p["tilt_deg"])
         self._dbg("wrist_done", tx=x, ty=y, z=z, reason=reason, grab_px=grab)
         return x, y, z
@@ -513,7 +511,7 @@ def _wrist_reseed(self, prompt, z, raw):
             return None, raw, "lost track"
         return tracker, raw, ""
 
-    def _wrist_servo(self, prompt, tx, ty):
+    def _wrist_descend(self, prompt, tx, ty):
         """Wrist CamShift servo down to wrist_stop_z: nudge toward the wrist
         box, or step down once the object has been seen inside it twice.
         A miss gets 2 frames of patience, then a Gemini re-seed (budget =
@@ -571,7 +569,7 @@ def _wrist_servo(self, prompt, tx, ty):
             err_v = px[1] - p["wrist_box_v"]
             inside = _inside_box(px, p["wrist_box_u"], p["wrist_box_v"], p["wrist_half_px"])
             centered = centered + 1 if inside else 0
-            self._dbg("wrist_servo", px=px, z=z, inside=inside, tx=x, ty=y, ee=self._ee_xyz())
+            self._dbg("wrist_descend", px=px, z=z, inside=inside, tx=x, ty=y, ee=self._ee_xyz())
             if streak < 2:
                 continue  # watch one more frame before trusting it
             if inside and centered < 2:
@@ -687,7 +685,7 @@ def _grasp_at(self, prompt, xy, deep=False):
 
         if p["wrist_steps"] >= 1:
             self._goto_search_pose(math.atan2(y, x))
-            x, y, z = self._wrist_servo(prompt, x, y)
+            x, y, z = self._wrist_descend(prompt, x, y)
         else:
             z = p["hover_z"]
             armlib.move_checked(
diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
index b868e1e0b..dfe2897b4 100644
--- a/workspace/skill_lib/arm.py
+++ b/workspace/skill_lib/arm.py
@@ -201,6 +201,6 @@ def open_checked(manipulation, get_j6, percent=100.0, duration=1.0, logger=None,
 
 
 def close(manipulation, strength=0.0, duration=1.0):
-    """Close gripper. strength = extra squeeze; >~0.6 overcurrent-trips the servo."""
+    """Close gripper. strength = extra squeeze; ~0.8 holds well, watch for trips above."""
     manipulation.torque_on()
     return bool(manipulation.close_gripper(strength=strength, duration=duration, blocking=True))

From d9d78c2f6e8c1b40640a9a8557511d84991365ce Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Sat, 18 Jul 2026 03:16:01 +0000
Subject: [PATCH 17/19] =?UTF-8?q?fix(pick):=20address=20Greptile=20review?=
 =?UTF-8?q?=20=E2=80=94=20safe=20REST=20teardown,=20checked=20search-pose?=
 =?UTF-8?q?=20move,=20strength=20docs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- _rest_arm(keep_grip=False) folds to armlib.REST again instead of the
  all-zero posture; the earlier fix (e407a387) was clobbered by the
  robot-side wip commit. Zero-config after a failed descent can sweep
  the gripper through the floor.
- _goto_search_pose now goes through armlib.go so a rejected search-pose
  command raises ArmFailed instead of silently corrupting the wrist
  descent from the REST position.
- gripper_close.py strength docstring updated to the live-tested ~0.8
  ceiling (was a stale <=0.6, contradicting arm.py and the tuned
  defaults). Slider max (0.8) and TUNABLE default (0.70) stay as tuned.
- pickTunePanel.js comments flagged by Greptile are moot: the panel file
  was removed in favor of pickOverlay.js.
- The unchecked-gripper-open finding was already fixed at HEAD.
---
 workspace/innate_skills/gripper_close.py   | 4 ++--
 workspace/innate_skills/pick_any_object.py | 8 +++++---
 workspace/skill_lib/arm.py                 | 2 +-
 3 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/workspace/innate_skills/gripper_close.py b/workspace/innate_skills/gripper_close.py
index c8bbd0bec..12a7f2add 100644
--- a/workspace/innate_skills/gripper_close.py
+++ b/workspace/innate_skills/gripper_close.py
@@ -30,8 +30,8 @@ def name(self):
     def guidelines(self):
         return (
             "Close the gripper/claw. strength adds squeeze (radians past the "
-            "closed stop) for a firmer grip; default 0.0. Keep it <= 0.6 on a "
-            "real object — more overcurrent-trips the servo."
+            "closed stop) for a firmer grip; default 0.0. Up to ~0.8 holds "
+            "well on a real object — watch for overcurrent servo trips above."
         )
 
     def execute(self, strength: float = 0.0, duration: float = 1.0):
diff --git a/workspace/innate_skills/pick_any_object.py b/workspace/innate_skills/pick_any_object.py
index 299e5c79c..ed3b959fe 100644
--- a/workspace/innate_skills/pick_any_object.py
+++ b/workspace/innate_skills/pick_any_object.py
@@ -291,8 +291,10 @@ def _gripper_j6(self):
         return armlib.gripper_j6(self.joint_states)
 
     def _rest_arm(self, keep_grip):
-        """Best-effort teardown: carry if holding, else zero. Never raises."""
-        joints = CARRY_ARM + [-self._p["close_strength"]] if keep_grip else armlib.ZERO
+        """Best-effort teardown: carry if holding, else fold to rest. Never
+        raises. REST, not ZERO: after a failed descent the arm can be near the
+        floor, and the zero posture would sweep the gripper through it."""
+        joints = CARRY_ARM + [-self._p["close_strength"]] if keep_grip else list(armlib.REST)
         try:
             armlib.go(self.manipulation, joints, duration=3.0, times=2)
         except Exception as e:  # noqa: BLE001 — teardown must not mask the run result
@@ -600,7 +602,7 @@ def _goto_search_pose(self, bearing):
         a = WRIST_SEARCH_ARM
         j6 = self._gripper_j6()
         pose = [bearing, a[1], a[2], self._p["wrist_pitch"] - a[1] - a[2], a[4], j6 if j6 is not None else 0.0]
-        self.manipulation.move_to_joint_positions(joint_positions=pose, duration=self._p["hover_s"], blocking=True)
+        armlib.go(self.manipulation, pose, duration=self._p["hover_s"], logger=self.logger)
         time.sleep(0.3)
         self._dbg("hover", ee=self._ee_xyz())
 
diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
index dfe2897b4..e32183a04 100644
--- a/workspace/skill_lib/arm.py
+++ b/workspace/skill_lib/arm.py
@@ -10,7 +10,7 @@
 so call sites stay declarative:
 
     armlib.rest(self.manipulation, self.joint_states)
-    armlib.go(self.manipulation, CARRY if holding else armlib.ZERO)
+    armlib.go(self.manipulation, CARRY if holding else armlib.REST)
 """
 
 import math

From e06f2010aaba36623e534513be3361f00855bd01 Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Fri, 17 Jul 2026 22:48:39 -0700
Subject: [PATCH 18/19] style: apply ruff format (fix CI)

---
 workspace/innate_skills/arm_rest_position.py |  8 ++++--
 workspace/innate_skills/arm_zero_position.py |  6 ++--
 workspace/skill_lib/arm.py                   | 30 ++++++++++++--------
 3 files changed, 27 insertions(+), 17 deletions(-)

diff --git a/workspace/innate_skills/arm_rest_position.py b/workspace/innate_skills/arm_rest_position.py
index 3e48111ff..205235098 100644
--- a/workspace/innate_skills/arm_rest_position.py
+++ b/workspace/innate_skills/arm_rest_position.py
@@ -15,7 +15,6 @@
 Implementation: workspace/skill_lib/arm.py (rest).
 """
 
-
 from brain_client.skills.types import (
     Interface,
     InterfaceType,
@@ -60,8 +59,11 @@ def execute(self, duration: int = 3, keep_gripper: bool = True):
 
         try:
             armlib.rest(
-                self.manipulation, self.joint_states, duration=duration,
-                keep_gripper=keep_gripper, is_cancelled=lambda: self._cancelled,
+                self.manipulation,
+                self.joint_states,
+                duration=duration,
+                keep_gripper=keep_gripper,
+                is_cancelled=lambda: self._cancelled,
                 logger=self.logger,
             )
         except armlib.ArmCancelled:
diff --git a/workspace/innate_skills/arm_zero_position.py b/workspace/innate_skills/arm_zero_position.py
index 1533d8430..2c654a57c 100644
--- a/workspace/innate_skills/arm_zero_position.py
+++ b/workspace/innate_skills/arm_zero_position.py
@@ -35,8 +35,10 @@ def execute(self, duration: int = 3):
 
         try:
             armlib.zero(
-                self.manipulation, duration=duration,
-                is_cancelled=lambda: self._cancelled, logger=self.logger,
+                self.manipulation,
+                duration=duration,
+                is_cancelled=lambda: self._cancelled,
+                logger=self.logger,
             )
         except armlib.ArmCancelled:
             return "Arm motion cancelled", SkillResult.CANCELLED
diff --git a/workspace/skill_lib/arm.py b/workspace/skill_lib/arm.py
index e32183a04..41b6be042 100644
--- a/workspace/skill_lib/arm.py
+++ b/workspace/skill_lib/arm.py
@@ -81,8 +81,7 @@ def rest_joints(joint_states=None, keep_gripper=True):
     return list(REST)
 
 
-def go(manipulation, joints, duration=3.0, *, times=1, pause=0.3,
-       is_cancelled=None, logger=None):
+def go(manipulation, joints, duration=3.0, *, times=1, pause=0.3, is_cancelled=None, logger=None):
     """Move to joint positions. Raises ArmFailed / ArmCancelled.
 
     ``times`` + ``pause`` repeat the move so the arm can settle (pick teardown).
@@ -93,11 +92,11 @@ def go(manipulation, joints, duration=3.0, *, times=1, pause=0.3,
     blocking = is_cancelled is None
     for i in range(times):
         if logger:
-            logger.info(
-                f"[arm] joints {[round(j, 3) for j in joints]} over {duration}s"
-            )
+            logger.info(f"[arm] joints {[round(j, 3) for j in joints]} over {duration}s")
         ok = manipulation.move_to_joint_positions(
-            joint_positions=joints, duration=duration, blocking=blocking,
+            joint_positions=joints,
+            duration=duration,
+            blocking=blocking,
         )
         if not ok:
             raise ArmFailed("Failed to send arm command")
@@ -115,20 +114,27 @@ def go(manipulation, joints, duration=3.0, *, times=1, pause=0.3,
 go_joints = go
 
 
-def rest(manipulation, joint_states=None, duration=3.0, keep_gripper=True,
-         is_cancelled=None, logger=None, **go_kw):
+def rest(manipulation, joint_states=None, duration=3.0, keep_gripper=True, is_cancelled=None, logger=None, **go_kw):
     """Fold to REST. keep_gripper preserves current j6 when held."""
     go(
-        manipulation, rest_joints(joint_states, keep_gripper),
-        duration=duration, is_cancelled=is_cancelled, logger=logger, **go_kw,
+        manipulation,
+        rest_joints(joint_states, keep_gripper),
+        duration=duration,
+        is_cancelled=is_cancelled,
+        logger=logger,
+        **go_kw,
     )
 
 
 def zero(manipulation, duration=3.0, is_cancelled=None, logger=None, **go_kw):
     """Move all joints to 0."""
     go(
-        manipulation, ZERO, duration=duration,
-        is_cancelled=is_cancelled, logger=logger, **go_kw,
+        manipulation,
+        ZERO,
+        duration=duration,
+        is_cancelled=is_cancelled,
+        logger=logger,
+        **go_kw,
     )
 
 

From 84f54bbb78bb435cc5cb8c509945399a241ee4aa Mon Sep 17 00:00:00 2001
From: theo-michel <theo64200@gmail.com>
Date: Mon, 20 Jul 2026 14:44:55 -0700
Subject: [PATCH 19/19] Remove pick tuning panel from teleop cockpit
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Drop the slider panel (wrench button / 'o' toggle) for live-tuning
pick_any_object params — we no longer want to expose that option.
The pick overlay and the skill-side tuning topic stay, since the
overlay's draggable wrist box still publishes to it.
---
 webapp/css/app.css            |  81 ----------
 webapp/js/teleop/main.js      |   2 -
 webapp/js/teleop/pickPanel.js | 287 ----------------------------------
 3 files changed, 370 deletions(-)
 delete mode 100644 webapp/js/teleop/pickPanel.js

diff --git a/webapp/css/app.css b/webapp/css/app.css
index f3073f476..ef6d9a775 100644
--- a/webapp/css/app.css
+++ b/webapp/css/app.css
@@ -962,87 +962,6 @@ button {
   border-style: solid;
 }
 
-/* ---- pick tuning panel (Teleop) ------------------------------------------ */
-
-/* Slider toggle button sits left of the profiling pulse button. */
-.picktune-panel-toggle {
-  right: 54px;
-}
-
-/* The panel: same glass box as .profiling, but tall — it holds ~40 sliders in
-   stage groups, so it takes the right edge and scrolls. */
-.picktune-panel {
-  position: absolute;
-  top: 54px;
-  right: 14px;
-  bottom: 14px;
-  z-index: 3; /* above the profiling panel and camera strip: it's the active tool when open */
-  width: 262px;
-  padding: 11px 14px;
-  overflow-y: auto;
-  background: rgb(0 0 0 / 66%);
-  backdrop-filter: blur(20px);
-  -webkit-backdrop-filter: blur(20px);
-  border: 1px solid var(--hairline);
-  border-radius: 11px;
-  user-select: none;
-  -webkit-user-select: none;
-}
-
-.picktune-panel-note {
-  margin-bottom: 8px;
-  font-size: 10px;
-  color: var(--muted);
-}
-
-.picktune-panel-body {
-  display: flex;
-  flex-direction: column;
-  gap: 5px;
-}
-
-.picktune-panel-stage {
-  margin: 9px 0 2px;
-  padding-bottom: 3px;
-  border-bottom: 1px solid var(--hairline);
-}
-
-.picktune-panel-stage:first-child {
-  margin-top: 0;
-}
-
-.picktune-panel-row {
-  display: grid;
-  grid-template-columns: 92px 1fr 44px;
-  align-items: center;
-  gap: 7px;
-}
-
-.picktune-panel-key {
-  font-size: 9px;
-  color: var(--muted);
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.picktune-panel-row input[type="range"] {
-  width: 100%;
-  min-width: 0;
-  accent-color: var(--accent);
-}
-
-.picktune-panel-row input[type="range"]:disabled {
-  opacity: 0.35;
-}
-
-.picktune-panel-value {
-  font-size: 10px;
-  color: var(--text);
-  text-align: right;
-  font-variant-numeric: tabular-nums;
-}
-
 /* ---- record HUD (Collect page) ------------------------------------------ */
 
 .overlay-record {
diff --git a/webapp/js/teleop/main.js b/webapp/js/teleop/main.js
index a3c36f94f..8bb373456 100644
--- a/webapp/js/teleop/main.js
+++ b/webapp/js/teleop/main.js
@@ -24,7 +24,6 @@ import { createTelemetry } from "./telemetry.js";
 import { createArmPanel } from "./armPanel.js";
 import { createProfilingPanel } from "./profilingPanel.js";
 import { createPickOverlay } from "./pickOverlay.js";
-import { createPickPanel } from "./pickPanel.js";
 import { createSkillsMenu } from "./skillsMenu.js";
 import { createCameraSwitch } from "./cameraSwitch.js";
 
@@ -95,7 +94,6 @@ function buildCockpit(root) {
     createArmPanel(armOverlay, ros, { hideServices: !!config.simControls }),
     ...(config.simControls ? [] : [createProfilingPanel(root, session)]),
     createPickOverlay(root, ros, session),
-    createPickPanel(root, ros),
     createCameraSwitch(root, session, ros),
     keyboard,
   );
diff --git a/webapp/js/teleop/pickPanel.js b/webapp/js/teleop/pickPanel.js
deleted file mode 100644
index 931c7626d..000000000
--- a/webapp/js/teleop/pickPanel.js
+++ /dev/null
@@ -1,287 +0,0 @@
-// @ts-check
-// SPDX-License-Identifier: Apache-2.0
-// Copyright (c) 2026 Innate Inc
-// Pick tuning panel — per-stage sliders for pick_any_object's TUNABLE knobs.
-// A wrench button (top-right, next to profiling) toggles it; "o" does too.
-// Hidden by default so the cockpit stays clean for operators.
-//
-// Every slider publishes a one-key partial dict on the tuning topic; the
-// running skill applies it mid-run and acks with a params debug event
-// carrying its full live dict, which is what the sliders display. On open
-// the panel publishes an empty dict — a pure "echo your params" request —
-// so it syncs to the skill's real values (including overrides that survived
-// from earlier runs) without mirroring any defaults in JS. Until that first
-// ack arrives the sliders stay disabled: showing made-up numbers over a
-// robot that acts on different ones is how mis-tunes happen.
-
-import { PICK_DEBUG_TOPIC, PICK_TUNING_TOPIC } from "../constants.js";
-
-const TOGGLE_KEY = "KeyO";
-
-// Publishing every input event floods the topic (and the skill logs each
-// applied dict); trailing-edge throttle per drag, plus a final on change.
-const SLIDE_PUBLISH_MS = 125;
-
-/**
- * Slider ranges per TUNABLE key, grouped by the same stages as the dict in
- * pick_any_object.py. Ranges/steps are UI affordances chosen around the
- * defaults and hardware limits (reach box, head tilt, servo trip points) —
- * the VALUES always come from the skill's params broadcasts, never from here.
- * @type {{ stage: string, keys: { [key: string]: [number, number, number] } }[]}
- */
-const STAGES = [
-  {
-    stage: "find / localize",
-    keys: {
-      tilt_deg: [-40, 0, 1],
-      settle_s: [0, 3, 0.1],
-    },
-  },
-  {
-    stage: "position",
-    keys: {
-      sweet_x: [0.2, 0.45, 0.005],
-      box_y: [-0.1, 0.1, 0.005],
-      box_half_px: [10, 120, 5],
-      accept_frac: [0.2, 1, 0.05],
-      box_steps: [1, 12, 1],
-      bearing_go_deg: [1, 15, 0.5],
-      follow_gain_ang: [0, 1, 0.05],
-      follow_gain_lin: [0, 0.3, 0.01],
-    },
-  },
-  {
-    stage: "base odometry",
-    keys: {
-      rot_tol_deg: [0.5, 10, 0.5],
-      rot_kp: [0.1, 3, 0.1],
-      rot_wz_max: [0.1, 1.5, 0.05],
-      rot_wz_min: [0.05, 0.5, 0.01],
-      drive_tol_m: [0.005, 0.05, 0.005],
-      drive_kp: [0.05, 1, 0.05],
-      drive_v_max: [0.02, 0.3, 0.01],
-      drive_v_min: [0.01, 0.1, 0.005],
-    },
-  },
-  {
-    stage: "wrist align",
-    keys: {
-      wrist_steps: [0, 6, 1],
-      wrist_stop_z: [0.02, 0.12, 0.005],
-      wrist_z_step: [0.005, 0.04, 0.005],
-      wrist_move_s: [0.2, 2, 0.1],
-      wrist_pitch: [0.3, 1.6, 0.02],
-      wrist_box_u: [0, 640, 5],
-      wrist_box_v: [0, 480, 5],
-      wrist_half_px: [20, 160, 5],
-      wrist_kx: [-0.2, 0.2, 0.005],
-      wrist_ky: [-0.2, 0.2, 0.005],
-      wrist_step_max: [0.01, 0.1, 0.005],
-      wrist_settle_s: [0.2, 2, 0.1],
-    },
-  },
-  {
-    stage: "grasp",
-    keys: {
-      grasp_x_off: [0, 0.08, 0.005],
-      hover_z: [0.08, 0.25, 0.005],
-      hover_s: [0.5, 4, 0.25],
-      descend_z1: [0.04, 0.15, 0.005],
-      descend_z2: [0.03, 0.12, 0.005],
-      descend_z3: [0.01, 0.08, 0.005],
-      floor_z: [0, 0.03, 0.002],
-      descend_s: [0.4, 3, 0.1],
-      descend_abort_z: [0.05, 0.2, 0.005],
-      arm_pitch: [0.8, 1.6, 0.02],
-      close_strength: [0, 0.8, 0.05],
-      close_s: [0.5, 3, 0.1],
-      close_settle_s: [0, 2, 0.1],
-      twist_rad: [0, 1.4, 0.05],
-      lift_rad: [0, 1.4, 0.05],
-    },
-  },
-];
-
-/** Display decimals for a slider step (0.005 -> 3, 0.1 -> 1, 1 -> 0).
- *  @param {number} step */
-function decimalsFor(step) {
-  if (step >= 1) return 0;
-  if (step >= 0.1) return 1;
-  if (step >= 0.01) return 2;
-  return 3;
-}
-
-/**
- * @param {HTMLElement} parent cockpit root — owns the toggle button + panel.
- * @param {import("../rosClient.js").RosClient} rosClient
- * @returns {{ destroy: () => void }}
- */
-export function createPickPanel(parent, rosClient) {
-  // Discrete toggle: a small glass wrench button, left of the profiling one.
-  const toggleBtn = document.createElement("button");
-  toggleBtn.type = "button";
-  toggleBtn.className = "profiling-toggle picktune-panel-toggle";
-  toggleBtn.title = "Pick tuning (o)";
-  toggleBtn.setAttribute("aria-label", "Toggle pick tuning panel");
-  toggleBtn.innerHTML =
-    '<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" ' +
-    'stroke-width="2" stroke-linecap="round" aria-hidden="true">' +
-    '<line x1="4" y1="7" x2="20" y2="7"/><circle cx="9" cy="7" r="2.2" fill="var(--glass)"/>' +
-    '<line x1="4" y1="12" x2="20" y2="12"/><circle cx="15" cy="12" r="2.2" fill="var(--glass)"/>' +
-    '<line x1="4" y1="17" x2="20" y2="17"/><circle cx="7" cy="17" r="2.2" fill="var(--glass)"/></svg>';
-
-  const wrap = document.createElement("div");
-  wrap.className = "picktune-panel";
-  wrap.hidden = true;
-
-  const head = document.createElement("div");
-  head.className = "profiling-head";
-  const title = document.createElement("span");
-  title.className = "microlabel";
-  title.textContent = "pick tuning";
-  const hint = document.createElement("span");
-  hint.className = "profiling-hint mono";
-  hint.textContent = "o";
-  head.append(title, hint);
-
-  // Sync status: cleared by the first params ack from the skill.
-  const note = document.createElement("div");
-  note.className = "picktune-panel-note";
-  note.textContent = "waiting for skill…";
-
-  const body = document.createElement("div");
-  body.className = "picktune-panel-body";
-
-  wrap.append(head, note, body);
-  parent.append(toggleBtn, wrap);
-
-  /** @type {Map<string, { input: HTMLInputElement, value: HTMLElement, decimals: number }>} */
-  const rows = new Map();
-  let synced = false;
-  /** Key being actively dragged — its row ignores param echoes so the thumb
-   *  doesn't fight the ack of an in-flight value. @type {string | null} */
-  let sliding = null;
-  let lastSlidePublish = 0;
-
-  for (const { stage, keys } of STAGES) {
-    const groupTitle = document.createElement("div");
-    groupTitle.className = "picktune-panel-stage microlabel";
-    groupTitle.textContent = stage;
-    body.append(groupTitle);
-
-    for (const [key, [min, max, step]] of Object.entries(keys)) {
-      const row = document.createElement("div");
-      row.className = "picktune-panel-row";
-
-      const label = document.createElement("span");
-      label.className = "picktune-panel-key mono";
-      label.textContent = key;
-
-      const input = document.createElement("input");
-      input.type = "range";
-      input.min = String(min);
-      input.max = String(max);
-      input.step = String(step);
-      input.disabled = true; // until the skill's first params ack
-
-      const value = document.createElement("span");
-      value.className = "picktune-panel-value mono";
-      value.textContent = "—";
-
-      const decimals = decimalsFor(step);
-      rows.set(key, { input, value, decimals });
-
-      input.addEventListener("input", () => {
-        sliding = key;
-        value.textContent = Number(input.value).toFixed(decimals);
-        const now = performance.now();
-        if (now - lastSlidePublish >= SLIDE_PUBLISH_MS) {
-          lastSlidePublish = now;
-          publishOverride(key, Number(input.value));
-        }
-      });
-      // Release: the definitive value always lands, throttle or not.
-      input.addEventListener("change", () => {
-        sliding = null;
-        publishOverride(key, Number(input.value));
-      });
-
-      row.append(label, input, value);
-      body.append(row);
-    }
-  }
-
-  /** @param {string} key @param {number} val */
-  function publishOverride(key, val) {
-    rosClient.publish(PICK_TUNING_TOPIC, { data: JSON.stringify({ [key]: val }) });
-  }
-
-  /** Ask the running skill to echo its live params (an empty partial dict
-   *  applies nothing but still gets the params ack). */
-  function requestSync() {
-    rosClient.publish(PICK_TUNING_TOPIC, { data: "{}" });
-  }
-
-  /** Fold a params broadcast into the sliders. @param {any} params */
-  function syncSliders(params) {
-    if (!params || typeof params !== "object") return;
-    for (const [key, row] of rows) {
-      if (typeof params[key] !== "number" || key === sliding) continue;
-      row.input.value = String(params[key]);
-      row.input.disabled = false;
-      row.value.textContent = params[key].toFixed(row.decimals);
-    }
-    if (!synced) {
-      synced = true;
-      note.hidden = true;
-    }
-  }
-
-  // Params ride the same debug topic as the overlay events; the panel only
-  // cares about the dict-bearing ones (run_start and the params acks).
-  const unsubDebug = rosClient.subscribe(PICK_DEBUG_TOPIC, (msg) => {
-    if (typeof msg?.data !== "string") return;
-    /** @type {any} */ let ev;
-    try {
-      ev = JSON.parse(msg.data);
-    } catch {
-      return; // not JSON — ignore
-    }
-    if (ev.ev === "params" || ev.ev === "run_start") syncSliders(ev.params);
-  });
-
-  /** @param {boolean} open */
-  function setOpen(open) {
-    wrap.hidden = !open;
-    toggleBtn.classList.toggle("active", open);
-    toggleBtn.setAttribute("aria-pressed", String(open));
-    if (open && !synced) requestSync();
-  }
-
-  function toggle() {
-    setOpen(Boolean(wrap.hidden));
-  }
-
-  toggleBtn.addEventListener("click", toggle);
-
-  /** @param {KeyboardEvent} e */
-  function onKeyDown(e) {
-    if (e.code !== TOGGLE_KEY || e.repeat || e.metaKey || e.ctrlKey || e.altKey) return;
-    const el = document.activeElement;
-    if (el instanceof HTMLElement && (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.isContentEditable)) {
-      return;
-    }
-    toggle();
-  }
-
-  window.addEventListener("keydown", onKeyDown);
-
-  return {
-    destroy() {
-      unsubDebug();
-      window.removeEventListener("keydown", onKeyDown);
-      toggleBtn.remove();
-      wrap.remove();
-    },
-  };
-}