refactor: cleanup GUI + AI movement controls + depth-correction polish

GUI:
- Rimossa tab "Calibrazione" (sostituita dalla calibrazione via AI con saved
  task `calibrazione_dx`/`calibrazione_sx`, oppure dalla tab "Auto-
  Calibrazione" per il flusso a griglia automatica). Backend
  calibration_routes invariato — tool AI continuano a usarlo.

AI tools:
- Esposto `precise` su `move_wrist_absolute` e `move_wrist_relative`
  (forwarded al campo omonimo del bridge robot, controlla la modalità di
  controllo: false=veloce/tolleranza ampia, true=lento/posa accurata).
- Aggiunto `arms_go_neutral` come tool dedicato (POST /arms/go_neutral del
  bridge): usato dall'AI per "torna a casa / posizione di riposo". Niente
  side, agisce su entrambe le braccia.
- Fix `device_status`: ora wrappa la risposta con `_ok(...)` così il
  dispatcher la classifica correttamente.

Prompt:
- System prompt aggiornato: l'AI ora passa SEMPRE `precise=true` di default
  sui movimenti, escluso quando l'utente chiede esplicitamente velocità.
  Sezione dedicata su come tornare a riposo (arms_go_neutral).
- Documentato che `measured_side_mm` (ritornato da get_marker_3d) viene
  distorto dalla correzione affine sul depth — non usarlo per validare la
  size_mm dichiarata.

Saved tasks:
- `calibrazione_dx` e `calibrazione_sx` ora partono e finiscono con
  `arms_go_neutral`, cancellano i sample preesistenti per quel lato, e
  acquisiscono ≥10 sample con `precise=true` su una griglia ±80mm + ±15° di
  rotazione attorno alla posa home.

Config:
- Marker corrente: id=10, size=40mm (cambiato il tag fisico sul polso).
- Addendum prompt allentato: niente più "max 3 righe", ora chiede di
  riportare il risultato di OGNI tool chiamato.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/presa_mano/agent/prompt.py

@@ -52,11 +52,25 @@ un robot umanoide (Unitree G1 o H1) con una camera depth Nuwa-HP60C fissa.
 - Movimenti **relativi**: `move_wrist_relative(side, delta_position)` —
   delta in metri, frame base. Se l'utente dice "muovi di 200 mm in X+", passa
   delta=[0.2, 0, 0]. Conferma sempre il risultato leggendo la nuova posa.
+- **Modalità precise**: per default passa SEMPRE `precise=true` su
+  `move_wrist_absolute` e `move_wrist_relative`. Imposta `precise=false`
+  solo se l'utente lo chiede esplicitamente (es. "muovi veloce",
+  "avvicinati grossomodo"). Lo `precise=true` garantisce che il controller
+  raggiunga la posa target con accuratezza fine — necessario per
+  acquisizione sample di calibrazione, avvicinamento al grasp, e in generale
+  ogni movimento dove la posa finale conta.
 - Default `dry_run=true` su tutte le operazioni di motion: NON fai mai partire
   un movimento reale senza che l'utente l'abbia chiesto esplicitamente.
 - Le mani: `hand_action(side, action)` con `action ∈
   {{LEFT_OPEN, LEFT_CLOSE, RIGHT_OPEN, RIGHT_CLOSE}}`.
 
+## Posizione di riposo (home) delle braccia
+- Quando l'operatore dice **"torna a casa"**, **"home"**, **"posizione di
+  riposo"** o simili, chiama `arms_go_neutral()`. Agisce su entrambe le
+  braccia simultaneamente (è un comando del bridge, niente side da scegliere).
+- Default `dry_run=true` come per gli altri movimenti — chiedi conferma
+  prima di mandarlo dal vivo.
+
 ## Calibrazione hand-eye (eye-to-hand)
 La calibrazione lega `T_base_camera`. È **specifica per braccio**: dx e sx
 hanno file separati. Procedura completa quando l'utente dice "calibra":

src/presa_mano/agent/tools.py

@@ -89,7 +89,10 @@ def _h_set_active_robot(args: dict[str, Any]) -> dict[str, Any]:
 def _h_device_status(_: dict[str, Any]) -> dict[str, Any]:
     """Reuses the home_routes implementation to avoid duplicating the ping logic."""
     from ..api.home_routes import status as _status
-    return _status()
+    try:
+        return _ok(**_status())
+    except Exception as e:
+        return _err(str(e))
 
 
 # ----- tool: wrist read/move ------------------------------------------------
@@ -118,11 +121,12 @@ def _h_move_wrist_absolute(args: dict[str, Any]) -> dict[str, Any]:
             return _err("position deve avere 3 float (m), quaternion 4 float (xyzw)")
         dry_run = bool(args.get("dry_run", True))
         timeout_s = float(args.get("timeout_s", 5.0))
+        precise = bool(args.get("precise", False))
         result = _deps.g1(dry_run=dry_run).wrist_absolute(
             side=side, position=position, quaternion=quaternion,
-            wait=True, timeout_s=timeout_s,
+            wait=True, timeout_s=timeout_s, precise=precise,
         )
-        return _ok(dry_run=dry_run, side=side, response=result)
+        return _ok(dry_run=dry_run, side=side, precise=precise, response=result)
     except (G1Unavailable, G1StatusError) as e:
         return _err(f"motion failed: {e}")
     except Exception as e:
@@ -140,19 +144,34 @@ def _h_move_wrist_relative(args: dict[str, Any]) -> dict[str, Any]:
             return _err("delta_quaternion deve avere 4 float (xyzw) o essere null")
         dry_run = bool(args.get("dry_run", True))
         timeout_s = float(args.get("timeout_s", 5.0))
+        precise = bool(args.get("precise", False))
         result = _deps.g1(dry_run=dry_run).wrist_relative(
             side=side,
             delta_position=list(dp) if dp is not None else None,
             delta_quaternion=list(dq) if dq is not None else None,
-            wait=True, timeout_s=timeout_s,
+            wait=True, timeout_s=timeout_s, precise=precise,
         )
-        return _ok(dry_run=dry_run, side=side, response=result)
+        return _ok(dry_run=dry_run, side=side, precise=precise, response=result)
     except (G1Unavailable, G1StatusError) as e:
         return _err(f"motion failed: {e}")
     except Exception as e:
         return _err(str(e))
 
 
+def _h_arms_go_neutral(args: dict[str, Any]) -> dict[str, Any]:
+    """Riporta entrambe le braccia alla posa di home / riposo built-in del
+    bridge (POST /arms/go_neutral). È l'unico modo standard di "tornare a
+    casa" — non serve registrare pose custom."""
+    try:
+        dry_run = bool(args.get("dry_run", True))
+        result = _deps.g1(dry_run=dry_run).arms_go_neutral()
+        return _ok(dry_run=dry_run, response=result)
+    except (G1Unavailable, G1StatusError) as e:
+        return _err(f"go_neutral failed: {e}")
+    except Exception as e:
+        return _err(str(e))
+
+
 def _h_hand_action(args: dict[str, Any]) -> dict[str, Any]:
     try:
         action = str(args.get("action", "")).upper()
@@ -422,6 +441,7 @@ _HANDLERS: dict[str, Callable[[dict[str, Any]], dict[str, Any]]] = {
     "move_wrist_absolute": _h_move_wrist_absolute,
     "move_wrist_relative": _h_move_wrist_relative,
     "hand_action": _h_hand_action,
+    "arms_go_neutral": _h_arms_go_neutral,
     "get_marker": _h_get_marker,
     "get_marker_3d": _h_get_marker_3d,
     "detect_object": _h_detect_object,
@@ -479,7 +499,13 @@ TOOL_DEFINITIONS: list[dict[str, Any]] = [
         "type": "function",
         "function": {
             "name": "move_wrist_absolute",
-            "description": "Sposta il polso a una posa assoluta nel frame base. Default dry_run=true: il robot NON si muove davvero finché dry_run=false.",
+            "description": (
+                "Sposta il polso a una posa assoluta nel frame base. Default dry_run=true: "
+                "il robot NON si muove davvero finché dry_run=false. Usa precise=true per "
+                "movimenti che richiedono accuratezza fine (es. acquisizione sample di "
+                "calibrazione, avvicinamento finale al grasp); precise=false è il default, "
+                "più veloce ma con tolleranza maggiore."
+            ),
             "parameters": {
                 "type": "object",
                 "required": ["side", "position", "quaternion"],
@@ -490,6 +516,8 @@ TOOL_DEFINITIONS: list[dict[str, Any]] = [
                     "quaternion": {"type": "array", "items": {"type": "number"}, "minItems": 4, "maxItems": 4,
                                     "description": "x,y,z,w"},
                     "dry_run": {"type": "boolean", "default": True},
+                    "precise": {"type": "boolean", "default": False,
+                                "description": "true = controllo accurato (più lento)"},
                     "timeout_s": {"type": "number", "default": 5.0},
                 },
             },
@@ -499,7 +527,11 @@ TOOL_DEFINITIONS: list[dict[str, Any]] = [
         "type": "function",
         "function": {
             "name": "move_wrist_relative",
-            "description": "Sposta il polso di un delta rispetto alla posa attuale. delta_position in metri (frame base), delta_quaternion opzionale. Default dry_run=true.",
+            "description": (
+                "Sposta il polso di un delta rispetto alla posa attuale. delta_position "
+                "in metri (frame base), delta_quaternion opzionale. Default dry_run=true. "
+                "Usa precise=true se serve accuratezza fine."
+            ),
             "parameters": {
                 "type": "object",
                 "required": ["side"],
@@ -508,11 +540,27 @@ TOOL_DEFINITIONS: list[dict[str, Any]] = [
                     "delta_position": {"type": "array", "items": {"type": "number"}, "minItems": 3, "maxItems": 3},
                     "delta_quaternion": {"type": "array", "items": {"type": "number"}, "minItems": 4, "maxItems": 4},
                     "dry_run": {"type": "boolean", "default": True},
+                    "precise": {"type": "boolean", "default": False},
                     "timeout_s": {"type": "number", "default": 5.0},
                 },
             },
         },
     },
+    {
+        "type": "function",
+        "function": {
+            "name": "arms_go_neutral",
+            "description": (
+                "Riporta ENTRAMBE le braccia alla posa di home/riposo del robot "
+                "(POST /arms/go_neutral sul bridge). Usa quando l'utente dice "
+                "'torna a casa', 'home', 'posizione di riposo'. Default dry_run=true."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {"dry_run": {"type": "boolean", "default": True}},
+            },
+        },
+    },
     {
         "type": "function",
         "function": {

src/presa_mano/clients/g1.py

@@ -70,8 +70,11 @@ class G1Client:
 
     def wrist_relative(self, side: str, delta_position: list[float] | None = None,
                        delta_quaternion: list[float] | None = None, wait: bool = True,
-                       timeout_s: float = 5.0) -> dict[str, Any]:
-        body: dict[str, Any] = {"side": side, "wait": wait, "timeout_s": timeout_s}
+                       timeout_s: float = 5.0, precise: bool = False) -> dict[str, Any]:
+        # `precise` is forwarded but the bridge silently ignores it on
+        # /wrist/relative if not supported — safer to always send it.
+        body: dict[str, Any] = {"side": side, "wait": wait, "timeout_s": timeout_s,
+                                 "precise": precise}
         if delta_position is not None:
             body["delta_position"] = delta_position
         if delta_quaternion is not None: