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/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/catalog.py b/ros2_ws/src/brain/brain_client/brain_client/skills/catalog.py
index 9c69cb555..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
@@ -15,6 +15,7 @@
 import os
 import re
 import shutil
+import sys
 import threading
 import time
 import types
@@ -269,8 +270,22 @@ 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.
+
+        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]
+
     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 +306,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/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 bf5ae931f..ef6d9a775 100644
--- a/webapp/css/app.css
+++ b/webapp/css/app.css
@@ -872,6 +872,96 @@ button {
   color: var(--accent);
 }
 
+/* ---- 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
+   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. */
+.picktune-boxgoal {
+  position: absolute;
+  z-index: 1;
+  transform: translate(-50%, -50%);
+  border: 1.5px dashed var(--accent-dim);
+  border-radius: 2px;
+  pointer-events: none;
+}
+
+/* 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);
+}
+
+/* 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;
+}
+
 /* ---- record HUD (Collect page) ------------------------------------------ */
 
 .overlay-record {
diff --git a/webapp/js/constants.js b/webapp/js/constants.js
index c52d6e2d1..bdae70131 100644
--- a/webapp/js/constants.js
+++ b/webapp/js/constants.js
@@ -132,6 +132,13 @@ 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_any_object stage events (std_msgs/String JSON: {ev, t, ...}) — drive
+// 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 37d636718..8bb373456 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 { createPickOverlay } from "./pickOverlay.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)]),
+    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..9d5b3929e
--- /dev/null
+++ b/webapp/js/teleop/pickOverlay.js
@@ -0,0 +1,357 @@
+// @ts-check
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2026 Innate Inc
+// 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. 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, PICK_TUNING_TOPIC } from "../constants.js";
+
+// 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 = {
+  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) {
+  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];
+  }
+}
+
+/**
+ * @param {HTMLElement} parent cockpit root — must contain the .video-stage.
+ * @param {import("../rosClient.js").RosClient} rosClient
+ * @param {import("../webrtcSession.js").WebRtcSession} [session]
+ *   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"));
+
+  /** 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;
+  }
+
+  // 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");
+
+  // 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;
+  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 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 picktune-wristbox";
+  wristBox.hidden = true;
+  wristBox.innerHTML = '<span class="picktune-boxgoal-tag mono">wrist box</span>';
+  if (videoStage) videoStage.appendChild(wristBox);
+
+  // ---- 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;
+  /** 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 ----------------------------------------
+
+  /** 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 — 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. 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 * 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;
+    } else {
+      wristBox.hidden = true;
+    }
+    // The pick box goal square — drawn exactly where the skill said it is.
+    if (!running || !headG || !headBox) {
+      boxGoal.hidden = true;
+      return;
+    }
+    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 = `${(accept / half) * 100}%`;
+    boxAccept.style.width = acceptPct;
+    boxAccept.style.height = acceptPct;
+    boxGoal.hidden = false;
+  }
+
+  // ---- 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;
+
+  // ---- debug feed ---------------------------------------------------------
+
+  /** @param {any} ev */
+  function onDebugEvent(ev) {
+    switch (ev.ev) {
+      case "run_start":
+      case "run_end":
+        running = ev.ev === "run_start";
+        grabPx = null;
+        seenPx = null;
+        wristPx = null;
+        boxGoal.classList.remove("inside");
+        wristBox.classList.remove("inside");
+        readAim(ev); // run_start carries the skill's full live dict + box
+        break;
+      case "params":
+        // 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");
+        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 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_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;
+      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/workspace/innate_skills/arm_rest_position.py b/workspace/innate_skills/arm_rest_position.py
new file mode 100644
index 000000000..205235098
--- /dev/null
+++ b/workspace/innate_skills/arm_rest_position.py
@@ -0,0 +1,78 @@
+#!/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.
+
+From skill code, call the library function directly instead of this skill:
+
+    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`).
+
+Implementation: workspace/skill_lib/arm.py (rest).
+"""
+
+from brain_client.skills.types import (
+    Interface,
+    InterfaceType,
+    RobotState,
+    RobotStateType,
+    Skill,
+    SkillResult,
+)
+from workspace.skill_lib import arm as armlib
+
+
+class ArmRestPosition(Skill):
+    """Move the arm to the resting position."""
+
+    manipulation = Interface(InterfaceType.MANIPULATION)
+    joint_states = RobotState(RobotStateType.LAST_JOINT_STATES)
+
+    @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
+
+        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
+        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/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/arm_zero_position.py b/workspace/innate_skills/arm_zero_position.py
index 1f43cb310..2c654a57c 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,20 @@ 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/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/gripper_close.py b/workspace/innate_skills/gripper_close.py
new file mode 100644
index 000000000..12a7f2add
--- /dev/null
+++ b/workspace/innate_skills/gripper_close.py
@@ -0,0 +1,46 @@
+#!/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 gripper_close`).
+"""
+
+from brain_client.skills.types import Interface, InterfaceType, Skill, SkillResult
+from workspace.skill_lib import arm as armlib
+
+
+class GripperClose(Skill):
+    """Close the gripper (claw)."""
+
+    manipulation = Interface(InterfaceType.MANIPULATION)
+
+    @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. 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):
+        """Close the claw. strength = extra radians of squeeze past closed."""
+        if self.manipulation is None:
+            return "Manipulation interface not available", SkillResult.FAILURE
+        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):
+        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..5d473ca2f
--- /dev/null
+++ b/workspace/innate_skills/gripper_open.py
@@ -0,0 +1,56 @@
+#!/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 gripper_open`).
+"""
+
+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)
+    joint_states = RobotState(RobotStateType.LAST_JOINT_STATES)
+
+    @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
+        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):
+        return "Gripper motion cancelled"
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..18edee72b 100644
--- a/workspace/innate_skills/navigate_to_position.py
+++ b/workspace/innate_skills/navigate_to_position.py
@@ -10,7 +10,10 @@
 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 +71,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
new file mode 100644
index 000000000..ed3b959fe
--- /dev/null
+++ b/workspace/innate_skills/pick_any_object.py
@@ -0,0 +1,787 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Innate Inc
+"""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 json
+import math
+import time
+
+from innate.skills import SkillCancelled, SkillFailed
+from std_msgs.msg import String
+
+from brain_client.skills.types import (
+    Interface,
+    InterfaceType,
+    RobotState,
+    RobotStateType,
+    Skill,
+    SkillResult,
+)
+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
+
+# 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 knobs, overridable mid-run via TUNING_TOPIC (String JSON partial dict).
+# 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
+    # POSITION
+    "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
+    "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_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,
+    "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
+    "hover_z": 0.15,
+    "hover_s": 2.0,
+    "descend_z1": 0.10,
+    "descend_z2": 0.06,
+    "descend_z3": 0.03,
+    "floor_z": 0.01,
+    "descend_s": 1.2,
+    "descend_abort_z": 0.12,  # EE still above this => limp, abort
+    "arm_pitch": 1.30,
+    "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
+    "lift_rad": 0.6,
+}
+
+DEBUG_TOPIC = "/pick_any_object/debug"
+TUNING_TOPIC = "/pick_any_object/tuning"
+
+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
+WRIST_SEARCH_ARM = [0.1473, -0.0706, -0.4449, 1.3376, -0.0491]
+
+
+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):
+    return abs(px[0] - cu) <= half and abs(px[1] - cv) <= half
+
+
+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
+
+
+class PickAnyObject(Skill):
+    """Pick up a floor object described 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._proxy = gemlib.make_client()  # None if no credentials
+        self._p = dict(TUNABLE)  # live copy; panel mutates
+        self._dbg_pub = None
+        self._tuning_sub = None
+
+    @property
+    def name(self):
+        return "pick_any_object"
+
+    def guidelines(self):
+        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 "
+            "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."
+        )
+
+    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)
+
+    def _on_tuning(self, msg):
+        try:
+            incoming = json.loads(msg.data)
+        except json.JSONDecodeError:
+            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))}
+        if applied:
+            self._p.update(applied)
+            self.logger.info(f"[PickAnyObject] tuning applied: {applied}")
+        self._dbg("params", params=dict(self._p), box=self._box_px())
+
+    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(_round_floats(fields))))
+
+    def _checkpoint(self):
+        """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):
+        return gemlib.ask_image(self._proxy, image_b64, question, logger=self.logger)
+
+    def _detect_px(self, prompt):
+        """Head frame -> best grasp pixel, or None."""
+        self._stop_base()
+        time.sleep(self._p["settle_s"])
+        img = self.main_image
+        if not img:
+            return None
+        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 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)
+
+    def _localize_px(self, prompt):
+        """Detect + back-project -> ((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}) -> base_link ({xy[0]:.3f},{xy[1]:.3f})")
+        self._dbg("localize", px=px, xy=xy, tilt_deg=self._p["tilt_deg"])
+        return xy, px
+
+    def _stop_base(self):
+        moblib.stop(self.mobility)
+
+    def _odom_xyt(self):
+        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)
+
+    def _gripper_j6(self):
+        return armlib.gripper_j6(self.joint_states)
+
+    def _rest_arm(self, keep_grip):
+        """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
+            self.logger.warning(f"[PickAnyObject] rest-arm failed: {e}")
+
+    def _search(self, prompt):
+        """Scan: straight, right 30°, left 60°. First hit wins. (+yaw=left)"""
+        for i, turn in enumerate((0.0, -math.radians(30), math.radians(60))):
+            self._checkpoint()
+            if turn:
+                if i == 1:
+                    self.say("Scanning around for it.")
+                self._rotate_by(turn)
+            xy, _px = self._localize_px(prompt)
+            if xy is not None:
+                return xy
+        raise SkillFailed(f"Could not find '{prompt}' on the floor, even after scanning")
+
+    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."""
+        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
+        return vision.b64_to_gray(img) if img else None
+
+    def _follow_into_box(self, seed_px):
+        """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 = vision.grid_pts(u, v)
+        in_box, last_dbg = 0, 0.0
+        t0 = time.time()
+        while time.time() - t0 < FOLLOW_TIMEOUT_S:
+            self._checkpoint()
+            gray = self._gray_frame()
+            if gray is None:
+                time.sleep(0.03)
+                continue
+            tracked = vision.track_point(prev, gray, grid)
+            prev = gray
+            if tracked is None:
+                self._stop_base()
+                return "lost", None
+            u, v = tracked
+            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()
+            inside = _inside_box((u, v), cu, cv, accept)
+
+            now = time.time()
+            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:
+                    return "in_box", (u, v)
+                time.sleep(0.03)
+                continue
+            in_box = 0
+
+            # Deadband = accept (inner) box; right -> -wz, too close (low) -> -vx.
+            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()
+        return "timeout", None
+
+    def _position_above(self, prompt, xy):
+        """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)
+
+        seed = floor_to_pixel(xy[0], xy[1], self._p["tilt_deg"])
+        for attempt in range(int(self._p["box_steps"])):
+            self._checkpoint()
+            if seed is None:
+                seed = self._detect_px(prompt)
+                if seed is None:
+                    self._dbg("position_done", xy=None, reason="lost")
+                    break
+            result, _pt = self._follow_into_box(seed)
+            if result == "noframe":
+                return self._position_stepwise(prompt, xy)
+            if result == "lost":
+                seed = None
+                continue
+            xy2, px2 = self._localize_px(prompt)
+            if px2 is None:
+                self._dbg("position_done", xy=None, reason="lost")
+                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
+        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.
+        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"])
+        for step in range(int(self._p["box_steps"])):
+            self._checkpoint()
+            if px is None:
+                xy, px = self._localize_px(prompt)
+                if px is None:
+                    self._dbg("position_done", xy=None, reason="lost")
+                    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)
+            if inside:
+                self._dbg("position_done", xy=xy, steps=step)
+                return xy
+            if xy is None:
+                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
+        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)
+    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
+        )
+        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)
+        return px, box
+
+    def _next_wrist_hsv(self, last_b64, timeout=1.5):
+        """Wait for a new wrist frame -> (hsv|None, b64)."""
+        t0 = time.time()
+        while time.time() - t0 < timeout:
+            self._checkpoint()
+            img = self.wrist_image
+            if img and img != last_b64:
+                hsv = vision.b64_to_hsv(img)
+                if hsv is not None:
+                    return hsv, img
+            time.sleep(0.04)
+        return None, last_b64
+
+    def _wrist_done(self, x, y, z, reason):
+        """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
+
+    def _wrist_reseed(self, prompt, z, raw):
+        """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"
+        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_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 =
+        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
+
+        px, box = self._wrist_seed(prompt, z)
+        if px is None:
+            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:
+            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 matches INSIDE the box
+        reason = "reached stop z"
+        while z > p["wrist_stop_z"] + 1e-6:
+            self._checkpoint()
+            if time.time() > deadline:
+                reason = "timeout"
+                break
+            hsv, raw = self._next_wrist_hsv(raw)
+            if hsv is None:
+                reason = "no wrist frames"
+                break
+
+            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
+                tracker, raw, fail = self._wrist_reseed(prompt, z, raw)
+                if tracker is None:
+                    reason = fail
+                    break
+                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 = _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_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:
+                continue  # just entered the box — confirm it stays
+
+            if centered >= 2:
+                z = max(p["wrist_stop_z"], z - p["wrist_z_step"])
+                # descent barely moves a centered pixel: guess stays px
+            else:
+                # 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: 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  # view shifted — re-confirm centering
+
+        return self._wrist_done(x, y, z, reason)
+
+    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]
+        armlib.go(self.manipulation, pose, duration=self._p["hover_s"], logger=self.logger)
+        time.sleep(0.3)
+        self._dbg("hover", ee=self._ee_xyz())
+
+    def _open_gripper_checked(self):
+        """Open gripper with trip recovery. False if still shut afterwards."""
+        return armlib.open_checked(
+            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"]]
+        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,
+            )
+            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=ee[2])
+            armlib.recover(self.manipulation, self.logger)
+            raise armlib.ArmUnhealthy("arm would not descend")
+
+    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"])
+        time.sleep(p["close_settle_s"])
+        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)
+            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)
+            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_xy=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."""
+        p = self._p
+        x, y = armlib.clamp_reach(xy[0] - p["grasp_x_off"], xy[1])
+
+        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)
+
+        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))
+            x, y, z = self._wrist_descend(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
+            )
+            self._dbg("hover", ee=self._ee_xyz())
+
+        self._push_to_floor(x, y, z, deep)
+        self._checkpoint()  # last exit before the fingers commit
+        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 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"])
+        j6 = self._gripper_j6()
+        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(
+                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"({len(images)} cams) -> {'HELD' if held else 'NOT HELD'}"
+        )
+        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 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), box=self._box_px())
+
+        holding = False
+        try:
+            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.
+            armlib.rest(self.manipulation, self.joint_states, logger=self.logger)
+
+            self.say(f"Looking for {prompt}.")
+            xy = self._search(prompt)
+            xy = self._position_above(prompt, xy)
+            self.say("Picking it up.")
+            self._grasp_at(prompt, xy)
+            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"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()
+            self._rest_arm(keep_grip=holding)
+            self.head.set_position(0)  # non-None: guarded at entry
+
+    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"
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/README.md b/workspace/skill_lib/README.md
new file mode 100644
index 000000000..4b74efccf
--- /dev/null
+++ b/workspace/skill_lib/README.md
@@ -0,0 +1,33 @@
+# 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)
+armlib.rest(self.manipulation, self.joint_states)
+armlib.go(self.manipulation, CARRY if holding else armlib.ZERO, times=2)
+```
+
+## 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..41b6be042
--- /dev/null
+++ b/workspace/skill_lib/arm.py
@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Innate Inc
+"""Shared arm primitives (blocking moves, recovery, reach clamp).
+
+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.REST)
+"""
+
+import math
+import time
+
+# Grasp reach box (base_link m).
+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):
+    return (max(REACH_X[0], min(REACH_X[1], x)), max(REACH_Y[0], min(REACH_Y[1], y)))
+
+
+def ee_xyz(manipulation):
+    """FK end-effector (x,y,z), or None."""
+    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, or None."""
+    try:
+        return joint_states["position"][5] if joint_states else None
+    except (KeyError, IndexError, TypeError):
+        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:
+        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_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,
+            y=y,
+            z=z,
+            roll=0.0,
+            pitch=pitch,
+            yaw=0.0,
+            duration=duration,
+            blocking=True,
+        )
+        cur = ee_xyz(manipulation)
+        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_z 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_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})")
+
+
+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")
+        if on_reboot:
+            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)
+
+
+def close(manipulation, strength=0.0, duration=1.0):
+    """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))
diff --git a/workspace/skill_lib/gemini.py b/workspace/skill_lib/gemini.py
new file mode 100644
index 000000000..b95b45fa4
--- /dev/null
+++ b/workspace/skill_lib/gemini.py
@@ -0,0 +1,55 @@
+#!/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
new file mode 100644
index 000000000..c66d7a0f6
--- /dev/null
+++ b/workspace/skill_lib/geometry.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Innate Inc
+"""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
+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)
+    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 _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."""
+    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
+    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
+
+
+def floor_to_pixel(x, y, head_tilt_deg):
+    """Floor (x,y) -> pixel, or None. Inverse of pixel_to_floor."""
+    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)
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)
diff --git a/workspace/skill_lib/vision.py b/workspace/skill_lib/vision.py
new file mode 100644
index 000000000..75971fdd6
--- /dev/null
+++ b/workspace/skill_lib/vision.py
@@ -0,0 +1,155 @@
+#!/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