loadProductionRun mostra il detail del server; START ACTIVITY in inglese (#61 #62 )

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Schermate operatore: un solo Completato grande, Fermo linea solo con run aperto, AVVIA ATTIVITA, pannello lotto/seriale dopo la scelta (#60 #61 #62 #63 #64 )
2026-10-07 12:26:33 +02:00 · 2026-10-07 12:25:56 +02:00 · 2026-10-07 11:55:42 +02:00
20 changed files with 591 additions and 718 deletions
@@ -92,8 +92,6 @@ SESSION_COOKIE_SECURE=true
 VISION_RUN_TIMEOUT_S=100
 # Quante esecuzioni di visione in parallelo accetta il worker.
 VISION_MAX_CONCURRENCY=2
-# #46: radice sotto cui il worker legge le cartelle ricetta (recipe_dir relativo).
-VISION_RECIPES_ROOT=/app/uploads

 # --- Docker ---
 # DB_ROOT_PASSWORD: in produzione (docker-compose.yml) obbligatoria, senza default.
@@ -289,8 +289,6 @@ Nginx (dev): gzip abilitato, `client_max_body_size 50M`, `proxy_read_timeout 120

 Il runner di visione (`src/vision/`) e il suo worker FastAPI (`src/vision_worker/`) dipendono da `vendor/visionsuite`, un **submodule** su `ssh://git.tielogic.xyz:222`: un `git clone` senza `--recurse-submodules` lascia la cartella vuota (chi ha già clonato: `git submodule update --init`). Le librerie di VisionSuite richiedono **Python 3.13**, mentre backend e frontend restano su Python 3.11 — è un albero a parte nel monorepo, isolato con il proprio extra `uv`.

-Regola (Adriano, 07/10/2026): il submodule `vendor/visionsuite` segue `origin/main`: a ogni integrazione si porta all'ultimo commit (`git -C vendor/visionsuite fetch origin && git -C vendor/visionsuite checkout origin/main`) e si rilanciano i test della visione. Pin attuale: bc0df16.
-
 Il worker gira in un container separato (`Dockerfile.vision`), non pubblica porte verso l'esterno ed è raggiungibile solo dal server all'indirizzo interno `http://vision:8100`. Il container non ha accesso al repository Git del progetto principale, quindi il commit di VisionSuite in uso (`engine_version`) non può essere scoperto dentro l'immagine: va stampato al momento del build leggendo il commit dalla macchina che esegue `docker compose build`, con la variabile `VISION_ENGINE_VERSION`. Una build senza questa variabile fallisce subito, invece di produrre un worker che risponde con una versione indovinata:

 ```bash
@@ -71,9 +71,6 @@ services:
        VISION_ENGINE_VERSION: ${VISION_ENGINE_VERSION:-}
    container_name: tmflow-vision
    restart: unless-stopped
-    environment:
-      # #46: radice delle cartelle ricetta (volume uploads, sola lettura)
-      VISION_RECIPES_ROOT: /app/uploads
    volumes:
      - upload_data:/app/uploads:ro
    healthcheck:
@@ -63,8 +63,6 @@ vision = [
    "vs-task; python_version>='3.13'",
    "vs-measure; python_version>='3.13'",
    "vs-pm2d; python_version>='3.13'",
-    # #46: tutti gli strumenti della suite (locate/MatchPattern e dxf/CompareDxf)
-    "vs-tools[locate,dxf]; python_version>='3.13'",
    "numpy; python_version>='3.13'",
 ]

@@ -103,8 +101,6 @@ visionsuite = { path = "vendor/visionsuite/packages/vs-core", editable = true }
 vs-task     = { path = "vendor/visionsuite/packages/vs-task", editable = true }
 vs-measure  = { path = "vendor/visionsuite/packages/vs-measure", editable = true }
 vs-pm2d     = { path = "vendor/visionsuite/packages/vs-pm2d", editable = true }
-vs-tools    = { path = "vendor/visionsuite/packages/vs-tools", editable = true }  # #46
-vs-dxf      = { path = "vendor/visionsuite/packages/vs-dxf", editable = true }  # #46

 [tool.pytest.ini_options]
 asyncio_mode = "auto"
@@ -1,8 +1,10 @@
 """MeasurementTec blueprint - recipe selection and measurement execution."""
 import urllib.parse

+import requests as http_requests
+
 from flask import (
-    Blueprint, abort, flash, jsonify, redirect, render_template,
+    Blueprint, Response, abort, flash, jsonify, redirect, render_template,
    request, session, url_for,
 )
 from flask_babel import gettext as _
@@ -820,3 +822,67 @@ def api_close_production(run_id: int):
 def api_get_file(file_path: str):
    """Proxy: Serve file from API server (browser can't send X-API-Key)."""
    return proxy_file(file_path)
+
+
+# ---------------------------------------------------------------------------
+# Route: vision execute (#46) - the browser sends an image, we relay it to
+# POST /api/vision/execute (multipart) because it cannot send X-API-Key itself.
+# ---------------------------------------------------------------------------
+@measure_bp.route("/api/vision/execute", methods=["POST"])
+@login_required
+@role_required("MeasurementTec")
+def api_vision_execute():
+    """Proxy: run the task's VisionSuite recipe on the uploaded image."""
+    image = request.files.get("image")
+    task_id = request.form.get("task_id")
+    if image is None or not task_id:
+        return jsonify({
+            "error": True,
+            "detail": _("Dati mancanti: task_id e image sono obbligatori"),
+        }), 400
+
+    # Same context fields as the manual flow; empty ones are left out so the
+    # backend sees them as absent rather than as "".
+    form = {"task_id": task_id}
+    for key in ("task_type", "lot_number", "serial_number", "production_run_id"):
+        val = request.form.get(key)
+        if val:
+            form[key] = val
+    form.setdefault("lot_number", session.get("lot_number", ""))
+    form.setdefault("serial_number", session.get("serial_number", ""))
+
+    resp = api_client.post(
+        "/api/vision/execute",
+        data=form,
+        files={"image": (
+            image.filename or "capture.jpg",
+            image.read(),
+            image.mimetype or "application/octet-stream",
+        )},
+    )
+    if resp.get("error"):
+        status_code = resp.get("status_code", 500)
+        body = {"error": True, "detail": resp.get("detail", _("Errore nell'esecuzione"))}
+        if resp.get("session_expired"):
+            body["session_expired"] = True
+        return jsonify(body), status_code if status_code >= 400 else 500
+    return jsonify(resp), 200
+
+
+@measure_bp.route("/api/vision/results/<int:result_id>/image", methods=["GET"])
+@login_required
+@role_required("MeasurementTec")
+def api_vision_result_image(result_id: int):
+    """Proxy: the image saved with a vision result (needs X-API-Key)."""
+    base_url = Config.API_SERVER_URL.rstrip("/")
+    resp = http_requests.get(
+        f"{base_url}/api/vision/results/{result_id}/image",
+        headers={"X-API-Key": session.get("api_key", "")},
+        timeout=30,
+    )
+    if resp.status_code != 200:
+        return Response(resp.text, status=resp.status_code)
+    return Response(
+        resp.content,
+        content_type=resp.headers.get("content-type", "application/octet-stream"),
+    )
@@ -0,0 +1,125 @@
+/**
+ * Vision execute - Alpine component for camera_measure / dxf_compare tasks (#46).
+ *
+ * The operator takes (or picks) an image, `acquire(blob)` sends it to the Flask
+ * proxy, and the result - quote table, outcome, failures, overlay - is shown on
+ * the image. `acquire(blob)` is the single entry point on purpose: the agent
+ * camera (#3) will call it with its own blob and reuse everything below.
+ *
+ * Config comes from window.__visionCfg (set by the template):
+ *   executeUrl, imageUrlTpl (with a 0 placeholder for the result id), taskId,
+ *   taskType, subtasks, labels.
+ * Run context (lot, serial, production run) is read lazily through `ctx()`,
+ * which the template binds to the parent task component.
+ */
+function visionExecute() {
+  // Overlay colour per role (VisionSuite roles: reference, roi, found).
+  const ROLE_COLORS = { reference: '#2563eb', found: '#16a34a', roi: '#f59e0b' };
+
+  return {
+    busy: false,
+    error: '',
+    result: null,      // last execute response
+    imageSrc: '',      // object URL of the acquired image (shown under the overlay)
+    ctx: () => ({}),   // replaced by the template: {lot, serial, runId}
+
+    // Entry point shared with the future agent camera.
+    async acquire(blob) {
+      if (!blob || this.busy) return;
+      const cfg = window.__visionCfg || {};
+      this.busy = true;
+      this.error = '';
+      this.result = null;
+      // Show the picked image at once: the overlay is drawn on top when the result arrives.
+      if (this.imageSrc) URL.revokeObjectURL(this.imageSrc);
+      this.imageSrc = URL.createObjectURL(blob);
+      try {
+        const c = this.ctx() || {};
+        const fd = new FormData();
+        fd.append('task_id', cfg.taskId);
+        fd.append('task_type', cfg.taskType || '');
+        fd.append('image', blob, blob.name || 'capture.jpg');
+        fd.append('lot_number', c.lot || '');
+        fd.append('serial_number', c.serial || '');
+        if (c.runId) fd.append('production_run_id', c.runId);
+        const csrf = document.querySelector('meta[name=csrf-token]')?.content || '';
+        const resp = await fetch(cfg.executeUrl, {
+          method: 'POST', headers: { 'X-CSRFToken': csrf }, body: fd,
+        });
+        const body = await resp.json().catch(() => ({}));
+        if (!resp.ok || body.error) {
+          this.error = body.detail || (cfg.labels && cfg.labels.requestFailed) || 'Error';
+          return;
+        }
+        this.result = body;
+        // Draw once Alpine has rendered the canvas.
+        this.$nextTick(() => this.drawOverlay());
+      } catch (e) {
+        this.error = (cfg.labels && cfg.labels.requestFailed) || 'Error';
+      } finally {
+        this.busy = false;
+      }
+    },
+
+    // Input change: take the file and allow picking the same one again.
+    onPick(ev) {
+      const f = ev.target.files && ev.target.files[0];
+      ev.target.value = '';
+      if (f) this.acquire(f);
+    },
+
+    // Image shown: the saved one from the server when available, else the local one.
+    get shownImage() {
+      const cfg = window.__visionCfg || {};
+      if (this.result && this.result.vision_result_id && cfg.imageUrlTpl) {
+        return cfg.imageUrlTpl.replace('/0/', '/' + this.result.vision_result_id + '/');
+      }
+      return this.imageSrc;
+    },
+
+    // Quote rows: server measurements joined with the subtask names.
+    get rows() {
+      const cfg = window.__visionCfg || {};
+      const subs = cfg.subtasks || [];
+      return ((this.result && this.result.measurements) || []).map((m) => {
+        const st = subs.find((s) => s.id === m.subtask_id) || {};
+        return {
+          label: (st.marker_number ? st.marker_number + '. ' : '') + (st.measurement_type || st.name || '#' + m.subtask_id),
+          value: m.value,
+          unit: st.unit || 'mm',
+          status: m.pass_fail,
+        };
+      });
+    },
+
+    statusClass(s) {
+      // Same palette as the measurement markers of the manual flow.
+      if (s === 'pass') return 'bg-measure-pass/20 text-measure-pass border border-measure-pass/40';
+      if (s === 'fail') return 'bg-red-100 dark:bg-red-900/30 text-measure-fail border border-measure-fail/40';
+      if (s === 'warning') return 'bg-amber-100 dark:bg-amber-900/30 text-measure-warning border border-measure-warning/40';
+      return 'bg-[var(--bg-secondary)] text-[var(--text-muted)] border border-[var(--border-color)]';
+    },
+
+    // Canvas is sized to the natural image, so overlay coordinates (image px)
+    // are used as they are and CSS scales the whole thing to the displayed size.
+    drawOverlay() {
+      const img = this.$refs.img, cv = this.$refs.overlay;
+      if (!img || !cv || !img.naturalWidth) return;
+      cv.width = img.naturalWidth;
+      cv.height = img.naturalHeight;
+      const g = cv.getContext('2d');
+      g.clearRect(0, 0, cv.width, cv.height);
+      g.lineWidth = Math.max(2, cv.width / 400);
+      g.lineJoin = 'round';
+      for (const item of ((this.result && this.result.overlay) || [])) {
+        const rows = item.rows || [], cols = item.cols || [];
+        if (!rows.length || rows.length !== cols.length) continue;
+        g.strokeStyle = ROLE_COLORS[item.role] || '#ef4444';
+        g.beginPath();
+        g.moveTo(cols[0], rows[0]);
+        for (let i = 1; i < rows.length; i++) g.lineTo(cols[i], rows[i]);
+        g.stroke();
+      }
+    },
+  };
+}
@@ -13,6 +13,15 @@
       barcodeInput: '',
       barcodeLoading: false,
       barcodeError: '',
+       /* #63/#64: ricetta scelta che richiede lotto/seriale; il pannello compare solo allora. */
+       selected: null,
+       needsTrace(recipe) {
+         return !!(recipe && (recipe.requires_lot || recipe.requires_serial));
+       },
+       choose(recipe) {
+         this.selected = recipe;
+         this.$nextTick(() => { const el = document.getElementById('trace-panel'); if (el) el.scrollIntoView({ behavior: 'smooth', block: 'center' }); });
+       },
       get filteredRecipes() {
         if (!this.search) return this.recipes;
         const q = this.search.toLowerCase();
@@ -62,9 +71,12 @@
             // The scanner is a way in like any other: a recipe that demands a lot
             // demands it here too, or the rule would last exactly as long as it
             // took someone to reach for the barcode reader.
-             const missing = this.missingTraceability(data);
-             if (missing.length) {
-               this.barcodeError = {{ _("Compila prima:")|tojson_attr }} + ' ' + missing.join(', ');
+             // #63/#64: se la ricetta chiede lotto/seriale mancanti, la si sceglie e
+             // compare il pannello con i soli campi richiesti.
+             if (this.missingTraceability(data).length) {
+               this.barcodeModal = false;
+               this.barcodeInput = '';
+               this.choose(data);
               return;
             }
             this.barcodeModal = false;
@@ -149,50 +161,6 @@
    </div>
  </div>

-  <!-- Traceability (data entry, NOT a search filter) -->
-  <div class="tmf-card mb-6 border-l-4 border-l-primary">
-    <div class="p-4 sm:p-5">
-      <div class="flex items-center gap-2 mb-3">
-        <svg class="w-5 h-5 text-primary shrink-0" fill="none" stroke="currentColor" stroke-width="1.75" viewBox="0 0 24 24">
-          <path stroke-linecap="round" stroke-linejoin="round" d="M20 7l-8-4-8 4m16 0l-8 4m8-4v10l-8 4m0-10L4 7m8 4v10M4 7v10l8 4"/>
-        </svg>
-        <div>
-          <h2 class="text-sm font-semibold text-[var(--text-primary)] leading-tight">{{ _('Tracciabilità') }}</h2>
-          <p class="text-xs text-[var(--text-muted)] leading-tight">{{ _('Dati del pezzo da misurare — compila prima di selezionare la ricetta') }}</p>
-        </div>
-      </div>
-      <div class="grid grid-cols-1 sm:grid-cols-2 gap-4">
-        <!-- Lot Number -->
-        <div>
-          <label class="tmf-label flex items-center gap-1.5">
-            <svg class="w-3.5 h-3.5 text-amber-500" fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24">
-              <path stroke-linecap="round" stroke-linejoin="round" d="M20 7l-8-4-8 4m16 0l-8 4m8-4v10l-8 4m0-10L4 7m8 4v10M4 7v10l8 4"/>
-            </svg>
-            {{ _('Numero Lotto') }}
-          </label>
-          <input type="text"
-                 x-model="lot_number"
-                 placeholder="{{ _('Es. LOT-2026-001') }}"
-                 class="tmf-input font-mono">
-        </div>
-
-        <!-- Serial Number -->
-        <div>
-          <label class="tmf-label flex items-center gap-1.5">
-            <svg class="w-3.5 h-3.5 text-indigo-500" fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24">
-              <path stroke-linecap="round" stroke-linejoin="round" d="M7 20l4-16m2 16l4-16M6 9h14M4 15h14"/>
-            </svg>
-            {{ _('Numero Seriale') }}
-          </label>
-          <input type="text"
-                 x-model="serial_number"
-                 placeholder="{{ _('Es. SN-000123') }}"
-                 class="tmf-input font-mono">
-        </div>
-      </div>
-    </div>
-  </div>
-
  <!-- Results Count -->
  <div class="flex items-center justify-between mb-4">
    <p class="text-sm text-[var(--text-secondary)]">
@@ -269,30 +237,25 @@
        <div class="px-5 py-3.5 border-t border-[var(--border-color)] bg-[var(--bg-secondary)]
                    rounded-b-xl">

-          {# What this recipe insists on before anyone measures. Said on the card
-             rather than after the fact: a measurement taken without its lot cannot
-             be traced back, and finding that out later is finding it out too late. #}
-          <template x-if="missingTraceability(recipe).length">
-            <p class="mb-2 flex items-start gap-1.5 text-xs text-amber-700 dark:text-amber-300">
-              <svg class="w-3.5 h-3.5 shrink-0 mt-px" fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24">
-                <path stroke-linecap="round" stroke-linejoin="round" d="M12 9v3.75m-9.303 3.376c-.866 1.5.217 3.374 1.948 3.374h14.71c1.73 0 2.813-1.874 1.948-3.374L13.949 3.378c-.866-1.5-3.032-1.5-3.898 0L2.697 16.126zM12 15.75h.007v.008H12v-.008z"/>
-              </svg>
-              <span x-text="{{ _('Compila prima:')|tojson_attr }} + ' ' + missingTraceability(recipe).join(', ')"></span>
-            </p>
+          {# #63/#64: una ricetta con lotto/seriale obbligatori si sceglie prima
+             (il pannello compare sotto la griglia); le altre partono subito. #}
+          <template x-if="needsTrace(recipe)">
+            <button type="button" @click="choose(recipe)"
+                    :class="selected && selected.id === recipe.id ? 'ring-2 ring-primary' : ''"
+                    class="btn btn-primary w-full justify-center text-sm font-semibold">
+              {{ _('Seleziona') }}
+            </button>
+          </template>
+          <template x-if="!needsTrace(recipe)">
+            <a :href="buildTaskUrl(recipe.id)"
+               class="btn btn-primary w-full justify-center text-sm font-semibold
+                      transition-shadow duration-200 group-hover:shadow-md">
+              <svg class="w-4 h-4" fill="none" stroke="currentColor" stroke-width="2.5" viewBox="0 0 24 24">
+                <path stroke-linecap="round" stroke-linejoin="round" d="M5 3l14 9-14 9V3z"/>
+              </svg>
+              {{ _('AVVIA ATTIVITÀ') }}
+            </a>
          </template>
-
-          <a :href="missingTraceability(recipe).length ? null : buildTaskUrl(recipe.id)"
-             :aria-disabled="missingTraceability(recipe).length > 0"
-             :class="missingTraceability(recipe).length
-               ? 'opacity-40 cursor-not-allowed pointer-events-none'
-               : 'group-hover:shadow-md'"
-             class="btn btn-primary w-full justify-center text-sm font-semibold
-                    transition-shadow duration-200">
-            <svg class="w-4 h-4" fill="none" stroke="currentColor" stroke-width="2.5" viewBox="0 0 24 24">
-              <path stroke-linecap="round" stroke-linejoin="round" d="M5 3l14 9-14 9V3z"/>
-            </svg>
-            {{ _('AVVIA IN SEQUENZA') }}
-          </a>

          {# The whole list, for when the operator wants to see it or go back to a
             task left unfinished. Deliberately the quiet one of the two. #}
@@ -306,6 +269,41 @@
    </template>
  </div>

+  <!-- Traceability (#63/#64): compare solo dopo aver scelto una ricetta con
+       requires_lot / requires_serial, con i soli campi richiesti. -->
+  <div id="trace-panel" x-show="selected && needsTrace(selected)" x-cloak
+       class="tmf-card mt-6 border-l-4 border-l-primary">
+    <div class="p-4 sm:p-5">
+      <div class="flex items-center gap-2 mb-3">
+        <svg class="w-5 h-5 text-primary shrink-0" fill="none" stroke="currentColor" stroke-width="1.75" viewBox="0 0 24 24">
+          <path stroke-linecap="round" stroke-linejoin="round" d="M20 7l-8-4-8 4m16 0l-8 4m8-4v10l-8 4m0-10L4 7m8 4v10M4 7v10l8 4"/>
+        </svg>
+        <div>
+          <h2 class="text-sm font-semibold text-[var(--text-primary)] leading-tight">{{ _('Tracciabilità') }}: <span x-text="selected ? selected.name : ''"></span></h2>
+          <p class="text-xs text-[var(--text-muted)] leading-tight">{{ _('Dati del pezzo da misurare — compila prima di selezionare la ricetta') }}</p>
+        </div>
+      </div>
+      <div class="grid grid-cols-1 sm:grid-cols-2 gap-4">
+        <div x-show="selected && selected.requires_lot">
+          <label class="tmf-label">{{ _('Numero Lotto') }}</label>
+          <input type="text" x-model="lot_number"
+                 placeholder="{{ _('Es. LOT-2026-001') }}" class="tmf-input font-mono">
+        </div>
+        <div x-show="selected && selected.requires_serial">
+          <label class="tmf-label">{{ _('Numero Seriale') }}</label>
+          <input type="text" x-model="serial_number"
+                 placeholder="{{ _('Es. SN-000123') }}" class="tmf-input font-mono">
+        </div>
+      </div>
+      <a :href="selected && !missingTraceability(selected).length ? buildTaskUrl(selected.id) : null"
+         :aria-disabled="!selected || missingTraceability(selected).length > 0"
+         :class="(!selected || missingTraceability(selected).length) ? 'opacity-40 cursor-not-allowed pointer-events-none' : ''"
+         class="btn btn-primary w-full justify-center text-sm font-semibold mt-4">
+        {{ _('AVVIA ATTIVITÀ') }}
+      </a>
+    </div>
+  </div>
+
  <!-- Empty State -->
  <div x-show="filteredRecipes.length === 0" x-cloak
       class="text-center py-16">
@@ -115,20 +115,12 @@
          </svg>
          {{ _('Lista task') }}
        </a>
-        <button @click="goToNextTask()"
-                :disabled="!canLeaveTask"
-                :title="canLeaveTask ? '' : blockedReason"
-                :class="canLeaveTask ? '' : 'opacity-40 cursor-not-allowed'"
-                class="btn btn-secondary text-xs py-1 px-2.5 gap-1">
-          <svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24">
-            <path stroke-linecap="round" stroke-linejoin="round" d="M5 13l4 4L19 7"/>
-          </svg>
-          {{ _('Completato') }}
-        </button>
+        {# #60: un solo «Completato», quello grande in fondo (touch); qui resta solo la lista. #}
      </div>

      {# Fermo linea + Fine produzione (measurement tasks only) #}
-      <template x-if="isMeasureTask">
+      <template x-if="isMeasureTask && productionRun">
+        {# #61: Fermo linea / Fine produzione solo con una produzione aperta #}
        <div class="shrink-0 flex items-center gap-1.5">
          {# While the line is stopped this becomes the way to restart it, so the
             capoturno never has to hunt for a second control. #}
@@ -191,7 +183,8 @@
  {# ================================================================
     MAIN — 3-column layout
     ================================================================ #}
-  <div class="flex-1 flex overflow-hidden">
+  {# #46: camera_measure / dxf_compare get the acquisition panel below instead of the manual layout #}
+  <div class="flex-1 flex overflow-hidden" x-show="!isVisionTask">

    {# ──────────────────────────────────────────────
       LEFT SIDEBAR — Marker list (vertical, hidden when no subtasks)
@@ -451,6 +444,63 @@

  </div>

+  {# ================================================================
+     VISION PANEL (#46) - acquire an image, run the recipe server-side, show the
+     quotes and the overlay. acquire(blob) is the entry point the agent camera
+     (#3) will reuse.
+     ================================================================ #}
+  <div x-show="isVisionTask" x-cloak
+       x-data="visionExecute()"
+       x-init="ctx = () => ({ lot: lotNumber, serial: serialNumber, runId: productionRun ? productionRun.id : null })"
+       class="flex-1 overflow-auto p-3 flex flex-col lg:flex-row gap-3">
+
+    <div class="flex-1 min-w-0 flex flex-col gap-2">
+      <div class="flex items-center gap-2 flex-wrap">
+        {# On a tablet this opens the camera; on a PC it picks a file. «Riprova» reuses the same input. #}
+        <label class="btn btn-primary text-sm gap-1.5 cursor-pointer" :class="busy ? 'opacity-50 pointer-events-none' : ''">
+          <span x-text="result ? '{{ _('Riprova') }}' : '{{ _('Acquisisci immagine') }}'"></span>
+          <input type="file" accept="image/*" capture="environment" class="hidden"
+                 @change="onPick($event)" :disabled="busy">
+        </label>
+        <span x-show="busy" class="text-sm text-[var(--text-muted)]">{{ _('Elaborazione in corso...') }}</span>
+      </div>
+
+      <div x-show="error" class="p-2 rounded-lg bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 text-sm text-measure-fail" x-text="error"></div>
+
+      <div x-show="shownImage" class="relative border border-[var(--border-color)] rounded-lg overflow-hidden bg-black/5">
+        <img x-ref="img" :src="shownImage" @load="drawOverlay()" alt="" class="block w-full h-auto">
+        <canvas x-ref="overlay" class="absolute inset-0 w-full h-full pointer-events-none"></canvas>
+      </div>
+      <div x-show="!shownImage" class="text-sm text-[var(--text-muted)]">
+        {{ _('Nessuna immagine acquisita: premi «Acquisisci immagine».') }}
+      </div>
+    </div>
+
+    <div class="lg:w-80 shrink-0 flex flex-col gap-2" x-show="result">
+      <div class="text-sm font-bold text-[var(--text-primary)]">
+        {{ _('Esito') }}: <span x-text="(result && result.outcome) || '-'"></span>
+      </div>
+
+      <table class="w-full text-sm" x-show="rows.length">
+        <template x-for="r in rows" :key="r.label">
+          <tr>
+            <td class="py-1 pr-2 text-[var(--text-secondary)]" x-text="r.label"></td>
+            <td class="py-1 pr-2 font-mono text-right" x-text="Number(r.value).toFixed(3) + ' ' + r.unit"></td>
+            <td class="py-1"><span class="inline-block px-2 py-0.5 rounded text-xs font-bold" :class="statusClass(r.status)" x-text="r.status"></span></td>
+          </tr>
+        </template>
+      </table>
+
+      <div x-show="result && result.failures && result.failures.length"
+           class="p-2 rounded-lg bg-amber-50 dark:bg-amber-900/20 border border-amber-300 dark:border-amber-700 text-xs">
+        <div class="font-bold mb-1">{{ _('Strumenti falliti') }}</div>
+        <template x-for="f in ((result && result.failures) || [])" :key="f.tool_id">
+          <div><span class="font-mono" x-text="f.tool_name || f.tool_id"></span>: <span x-text="f.error"></span></div>
+        </template>
+      </div>
+    </div>
+  </div>
+
  {# ================================================================
     MEASUREMENT TIMER BANNER
     ================================================================ #}
@@ -698,10 +748,12 @@
        </div>
      </template>
      <template x-if="!isMeasureTask || subtasks.length === 0">
+        {# #60: unico «Completato», largo e alto almeno 64 px per il touch. #}
        <button @click="goToNextTask()"
-                class="btn text-xs shrink-0 gap-1 py-1.5 px-3 shadow-md
+                :disabled="!canLeaveTask"
+                class="btn text-lg font-bold flex-1 w-full min-h-[64px] justify-center gap-2 shadow-md
                       bg-measure-pass text-white hover:opacity-90">
-          <svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24">
+          <svg class="w-5 h-5" fill="none" stroke="currentColor" stroke-width="2" viewBox="0 0 24 24">
            <path stroke-linecap="round" stroke-linejoin="round" d="M5 13l4 4L19 7"/>
          </svg>
          {{ _('Completato') }}
@@ -787,6 +839,10 @@
        </div>
      </div>

+      {# #61: se il server rifiuta l'avvio produzione, l'errore si vede qui, nell'overlay #}
+      <p x-show="productionError" x-cloak
+         class="mb-2 text-sm text-red-700 dark:text-red-300 text-center" x-text="productionError"></p>
+
      <div class="flex gap-2">
        <button @click="goToSummary()"
                class="btn btn-secondary flex-1 justify-center gap-2">
@@ -912,6 +968,18 @@
 <script src="{{ url_for('static', filename='js/numpad.js') }}"></script>
 <script src="{{ url_for('static', filename='js/annotation-viewer.js') }}?v=6"></script>
 <script src="{{ url_for('static', filename='js/caliper.js') }}"></script>
+{# #46: acquisition + overlay for camera_measure / dxf_compare #}
+<script>
+  window.__visionCfg = {
+    executeUrl: '{{ url_for("measure.api_vision_execute") }}',
+    imageUrlTpl: '{{ url_for("measure.api_vision_result_image", result_id=0) }}',
+    taskId: {{ task.id|tojson }},
+    taskType: {{ (task.task_type or '')|tojson }},
+    subtasks: window.__taskSubtasks,
+    labels: { requestFailed: {{ _('Richiesta non riuscita')|tojson }} },
+  };
+</script>
+<script src="{{ url_for('static', filename='js/vision_execute.js') }}"></script>
 {# The clock's rules - how a delay reads, when the buzzer goes, where the
   measurement lives - are shared with the other screens rather than restated. #}
 <script src="{{ url_for('static', filename='js/production-clock.js') }}"></script>
@@ -1180,11 +1248,18 @@ function taskExecute() {
    async loadProductionRun() {
      try {
        const resp = await fetch('{{ url_for("measure.api_current_production") }}');
-        if (!resp.ok) return;
+        if (!resp.ok) {
+          // #61: si mostra il detail del server (es. 503 "Stazione non configurata"),
+          // che e' la causa vera; fallback generico se il corpo non e' JSON.
+          const errBody = await resp.json().catch(() => null);
+          this.productionError = (errBody && errBody.detail) || '{{ _("Errore di comunicazione con il server") }}';
+          return;
+        }
        const run = await resp.json();
        if (run && run.id) this.adoptProductionRun(run);
      } catch (e) {
-        // Offline or server down: leave the page usable, just without the timer.
+        // #61: offline o server giu: pagina usabile, ma l'errore e' visibile.
+        this.productionError = '{{ _("Errore di connessione") }}';
      }
    },

@@ -1697,13 +1772,9 @@ function taskExecute() {
      this.showCompletionOverlay = false;
      const opened = await this.startProduction();
      if (!opened) {
-        // Server refused: keep the operator working rather than stranding them
-        // mid-shift, but productionError is on screen so it is not silent.
-        this.cycleConfirmed = true;
-        this.cycleCount++;
-        if (this.measurementIntervalMinutes && this.measurementIntervalMinutes > 0) {
-          this.startCountdownFrom(this.measurementIntervalMinutes * 60);
-        }
+        // #61: server rifiuta -> niente timer locale finto; si riapre l'overlay
+        // con l'errore (productionError) cosi' l'operatore puo' riprovare.
+        this.showCompletionOverlay = true;
        return;
      }
      // The START-phase measurements have just been taken: record them as the first
@@ -1751,6 +1822,12 @@ function taskExecute() {

    // ---- Open/close supervisor modal (always reset fields) ----
    openSupervisorModal(action) {
+      // #61: fermo/ripresa/fine produzione agiscono su un run: senza run aperto
+      // si dice subito, prima di chiedere le credenziali.
+      if (['fermo_linea', 'ripresa', 'fine_produzione'].includes(action) && !this.productionRun) {
+        this.productionError = '{{ _("Nessuna produzione aperta su questa stazione") }}';
+        return;
+      }
      this.supervisorAction = action;
      this.supervisorUsername = '';
      this.supervisorPassword = '';
@@ -1776,6 +1853,12 @@ function taskExecute() {
      return declared === 'measure' || declared === 'camera_measure';
    },

+    /* #46: image-based tasks run a VisionSuite recipe on the server. */
+    get isVisionTask() {
+      const t = this.task.task_type;
+      return t === 'camera_measure' || t === 'dxf_compare';
+    },
+
    /* A measurement task with no quotes yet: the recipe is unfinished. Said out
       loud rather than silently rendering an empty screen. */
    get isMeasureTaskWithoutQuotes() {
@@ -104,7 +104,7 @@
            <svg class="w-6 h-6" fill="none" stroke="currentColor" stroke-width="2.5" viewBox="0 0 24 24">
              <path stroke-linecap="round" stroke-linejoin="round" d="M5 3l14 9-14 9V3z"/>
            </svg>
-            {{ _('AVVIA IN SEQUENZA') }}
+            {{ _('AVVIA ATTIVITÀ') }}
          </a>
          {% endif %}
          {% endif %}
@@ -0,0 +1,86 @@
+"""gitea:Adriano/TieMeasureFlow#46 - operator side of the vision tasks.
+
+The backend of contract B is not merged yet: api_client is mocked.
+"""
+import io
+from unittest.mock import MagicMock, patch
+
+from tests.conftest import api_get_router
+
+TASK = {
+    "id": 12, "recipe_id": 3, "version_id": 5, "task_type": "camera_measure",
+    "title": "Foto", "directive": None, "description": None, "file_path": None,
+    "file_type": None, "annotations_json": None, "subtasks": [],
+}
+RECIPE = {
+    "id": 3, "code": "REC-1", "name": "Ricetta",
+    "measurement_interval_minutes": 30, "allow_manual_input": True,
+    "current_version": {"id": 5, "version_number": 1},
+}
+
+
+def test_execute_page_has_acquire_input(logged_in_client, mock_api_client, monkeypatch):
+    """camera_measure screen offers the file/camera input and the acquire entry point."""
+    monkeypatch.setattr("blueprints.measure.Config.STATION_CODE", "ST-TEST")
+    mock_api_client.get_station_recipes.return_value = {"items": [{"id": 3}]}
+    mock_api_client.get.side_effect = api_get_router({
+        "/api/tasks/12": TASK,
+        "/api/recipes/3/tasks": [{"id": 12, "order_index": 0}],
+        "/api/recipes/3": RECIPE,
+    })
+    html = logged_in_client.get("/measure/execute/12").get_data(as_text=True)
+    assert 'capture="environment"' in html
+    assert 'accept="image/*"' in html
+    assert "visionExecute()" in html
+    assert "/measure/api/vision/execute" in html
+
+
+def test_vision_execute_proxy_forwards_multipart(logged_in_client, mock_api_client):
+    mock_api_client.post.return_value = {
+        "vision_result_id": 7, "outcome": "ok", "overlay": [], "failures": [],
+        "measurements": [{"subtask_id": 1, "value": 9.9, "pass_fail": "pass"}],
+    }
+    resp = logged_in_client.post(
+        "/measure/api/vision/execute",
+        data={
+            "task_id": "12", "lot_number": "L1", "serial_number": "S1",
+            "production_run_id": "4",
+            "image": (io.BytesIO(b"\xff\xd8\xff fake"), "shot.jpg", "image/jpeg"),
+        },
+        content_type="multipart/form-data",
+    )
+    assert resp.status_code == 200
+    assert resp.get_json()["vision_result_id"] == 7
+    args, kwargs = mock_api_client.post.call_args
+    assert args[0] == "/api/vision/execute"
+    assert kwargs["data"]["task_id"] == "12"
+    assert kwargs["data"]["lot_number"] == "L1"
+    assert kwargs["data"]["production_run_id"] == "4"
+    name, content, mime = kwargs["files"]["image"]
+    assert name == "shot.jpg" and mime == "image/jpeg" and content.startswith(b"\xff\xd8")
+
+
+def test_vision_execute_proxy_requires_image(logged_in_client, mock_api_client):
+    resp = logged_in_client.post("/measure/api/vision/execute", data={"task_id": "12"})
+    assert resp.status_code == 400
+    mock_api_client.post.assert_not_called()
+
+
+def test_vision_execute_proxy_relays_backend_error(logged_in_client, mock_api_client):
+    mock_api_client.post.return_value = {"error": True, "status_code": 422, "detail": "bad"}
+    resp = logged_in_client.post(
+        "/measure/api/vision/execute",
+        data={"task_id": "12", "image": (io.BytesIO(b"x"), "a.jpg", "image/jpeg")},
+        content_type="multipart/form-data",
+    )
+    assert resp.status_code == 422
+    assert resp.get_json()["detail"] == "bad"
+
+
+def test_vision_result_image_proxy(logged_in_client):
+    fake = MagicMock(status_code=200, content=b"IMG", headers={"content-type": "image/jpeg"})
+    with patch("blueprints.measure.http_requests.get", return_value=fake) as g:
+        resp = logged_in_client.get("/measure/api/vision/results/7/image")
+    assert resp.status_code == 200 and resp.data == b"IMG"
+    assert g.call_args[0][0].endswith("/api/vision/results/7/image")
+    assert g.call_args[1]["headers"]["X-API-Key"] == "test-api-key-12345"
@@ -104,7 +104,7 @@ def test_the_selection_screen_starts_the_sequence(
 def test_avvia_on_the_list_starts_the_sequence(logged_in_client, mock_api_client):
    html = _list_page(logged_in_client, mock_api_client)
    assert "/measure/start/3" in html
-    assert "AVVIA IN SEQUENZA" in html
+    assert "AVVIA ATTIVITÀ" in html


 # ---------------------------------------------------------------------------
@@ -163,6 +163,32 @@ def test_the_header_offers_completato_not_the_summary(
    assert '@click="goToNextTask()"' in html


+def test_only_one_completato_and_it_is_big(
+    logged_in_client, mock_api_client, monkeypatch,
+):
+    """#60: «Completato» una sola volta (in basso), largo e alto per il touch."""
+    html = _execute_page(logged_in_client, mock_api_client, monkeypatch)
+    # the label as a button text on its own line (comments in the JS also name it)
+    assert [l.strip() for l in html.splitlines()].count("Completato") == 1
+    assert "min-h-[64px]" in html
+
+
+def test_no_open_run_means_no_fermo_linea_and_no_fake_timer(
+    logged_in_client, mock_api_client, monkeypatch,
+):
+    """#61: senza produzione aperta i pulsanti non si vedono, la modale non si
+    apre e un rifiuto del server non avvia un timer locale finto."""
+    html = _execute_page(logged_in_client, mock_api_client, monkeypatch)
+    assert 'x-if="isMeasureTask && productionRun"' in html
+    assert "!this.productionRun" in html
+    # #61: loadProductionRun mostra il detail del server, non solo il messaggio generico
+    assert "errBody.detail" in html
+    assert "Nessuna produzione aperta su questa stazione" in html
+    # il vecchio ripiego locale non c'e' piu'
+    assert "this.startCountdownFrom(this.measurementIntervalMinutes * 60)" not in html.split(
+        "async startProductionFromOverlay()")[1].split("async confirmCycle")[0]
+
+
 def test_fine_ciclo_is_shown_before_it_can_be_used(
    logged_in_client, mock_api_client, monkeypatch,
 ):
@@ -196,3 +222,27 @@ def test_the_operator_flow_never_links_to_the_statistics(
    ]
    for html in pages:
        assert "/statistics" not in html
+
+
+def test_trace_panel_only_for_recipes_that_require_it(
+    logged_in_client, mock_api_client, monkeypatch,
+):
+    """#63/#64: ricerca+griglia in alto, pannello lotto/seriale solo dopo la
+    scelta di una ricetta che lo richiede, con i soli campi richiesti."""
+    _italian(logged_in_client)
+    monkeypatch.setattr("blueprints.measure.Config.STATION_CODE", "ST-TEST")
+    mock_api_client.get_station_recipes.return_value = [
+        {"id": 1, "code": "A", "name": "Con lotto", "requires_lot": True,
+         "requires_serial": False},
+        {"id": 2, "code": "B", "name": "Libera"},
+    ]
+    html = logged_in_client.get("/measure/select").get_data(as_text=True)
+    assert 'id="trace-panel"' in html
+    assert 'x-show="selected && needsTrace(selected)"' in html
+    assert 'x-show="selected && selected.requires_lot"' in html
+    assert 'x-show="selected && selected.requires_serial"' in html
+    # la ricerca e la griglia precedono il pannello
+    assert html.index("Cerca ricetta") < html.index('id="trace-panel"')
+    assert html.index("Recipe Grid") < html.index('id="trace-panel"')
+    # le ricette senza obblighi partono direttamente
+    assert 'x-if="!needsTrace(recipe)"' in html
@@ -1862,8 +1862,8 @@ msgstr "No description available"

 #: templates/measure/select_recipe.html:294
 #: templates/measure/task_list.html:107
-msgid "AVVIA IN SEQUENZA"
-msgstr "START THE SEQUENCE"
+msgid "AVVIA ATTIVITÀ"
+msgstr "START ACTIVITY"

 # Maker - Task Editor
 #: templates/measure/select_recipe.html:302
@@ -1864,8 +1864,8 @@ msgstr "Nessuna descrizione disponibile"

 #: templates/measure/select_recipe.html:294
 #: templates/measure/task_list.html:107
-msgid "AVVIA IN SEQUENZA"
-msgstr "AVVIA IN SEQUENZA"
+msgid "AVVIA ATTIVITÀ"
+msgstr "AVVIA ATTIVITÀ"

 # Maker - Task Editor
 #: templates/measure/select_recipe.html:302
@@ -1825,7 +1825,7 @@ msgstr ""

 #: templates/measure/select_recipe.html:294
 #: templates/measure/task_list.html:107
-msgid "AVVIA IN SEQUENZA"
+msgid "AVVIA ATTIVITÀ"
 msgstr ""

 #: templates/measure/select_recipe.html:302
@@ -9,7 +9,6 @@ from __future__ import annotations
 import math
 import os
 import subprocess
-import tempfile
 import time
 from dataclasses import dataclass, field
 from functools import lru_cache
@@ -19,9 +18,6 @@ from typing import Any
 import numpy as np
 from visionsuite.core.image import Image
 from visionsuite.task import Task
-from visionsuite.task.graph import RecipeError  # #46: errori di ricetta v2
-from visionsuite.task.registry import load_tools
-from visionsuite.task.session import Session

 _SUBMODULE = Path(__file__).resolve().parents[2] / "vendor" / "visionsuite"

@@ -53,10 +49,6 @@ class RunOutcome:
    # Kept apart from `failures`: the tool did not raise, it just produced a
    # number the caller must not measure a part by. Value is the reason.
    invalid_outputs: dict[str, str] = field(default_factory=dict)
-    # #46: contorni di tutti gli strumenti (px immagine, con tool_id) e esito
-    # del TaskReport (informativo: il verdetto quote lo dà il backend).
-    overlay: list[dict] = field(default_factory=list)
-    outcome: str | None = None


@lru_cache(maxsize=1)
@@ -105,46 +97,12 @@ def engine_version() -> str:
    return _engine_version_from_git()


-def _scale_calibration(calibration: dict | None):
-    """Dict {"mm_per_px"|"px_per_mm"} -> ScaleCalibration (gli strumenti di
-    quota convertono con `in_millimetres`, che non accetta un dict)."""
-    if calibration is None:
-        return None
-    from visionsuite.calibration import ScaleCalibration
-
-    if not isinstance(calibration, dict) or not (
-        calibration.get("mm_per_px") or calibration.get("px_per_mm")
-    ):
-        raise GraphBuildError(
-            "calibration must be {'mm_per_px': float} or {'px_per_mm': float}"
-        )
-    key = "mm_per_px" if calibration.get("mm_per_px") else "px_per_mm"
-    return ScaleCalibration(**{key: float(calibration[key])})
-
-
-def _open_session(graph: dict, recipe_dir: Any, calibration: dict | None,
-                  workdir: str) -> Session:
-    """Costruisce la Session v2; RecipeError e grafo malformato -> GraphBuildError."""
-    cal = _scale_calibration(calibration)
-    try:
-        return Session.from_dict(
-            graph, Path(recipe_dir) if recipe_dir else Path(workdir), cal,
-        )
-    except RecipeError as exc:
-        raise GraphBuildError(f"malformed graph: {exc}") from exc
-    except (KeyError, TypeError, AttributeError, ValueError) as exc:
-        raise GraphBuildError(
-            f"malformed graph: {type(exc).__name__}: {exc}"
-        ) from exc
-
-
 def run_graph(
    image: Any,
    graph: dict,
    calibration: dict | None = None,
-    recipe_dir: Any = None,
 ) -> RunOutcome:
-    """Run a serialised vs-task v2 graph against one image.
+    """Run a serialised vs-task graph against one image.

    A tool that fails does not stop the others - on a crooked piece an edge may
    simply not be there, and the other quotes are still wanted. Failures come
@@ -154,35 +112,33 @@ def run_graph(
    wrapped into the `visionsuite.core.image.Image` that vs-measure's tools
    actually read via `.pixels`; an `Image` passed in is used as-is.

-    `recipe_dir` is the folder of the recipe's files (meta.dxf, meta.models,
-    ...); without it an empty temporary folder is used, so a recipe that needs
-    a file fails as a malformed graph instead of reading from the CWD.
-
-    Two phases, on purpose: building the session can fail on nothing but the
-    caller's input (a bad schema version, a tool with no "kind", a missing
-    file) - that is `GraphBuildError`, a 422 for the worker. Once it exists,
-    running is the engine's own business; an exception from there is not the
-    caller's mistake, and the worker must not call it one.
+    Two phases, on purpose: building the task from `graph` can fail on
+    nothing but the caller's input (a bad schema version, a tool with no
+    "kind", a graph that is not a dict at all) - that is `GraphBuildError`,
+    a 422 for the worker. Once the task exists, `task.run()` is the engine's
+    own business; an exception from there is not the caller's mistake, and
+    the worker must not call it one.
    """
-    load_tools()  # #46: registra gli strumenti degli entry point di vs-tools
-    with tempfile.TemporaryDirectory() as empty_dir:
-        session = _open_session(graph, recipe_dir, calibration, empty_dir)
-        wrapped_image = (
-            image if isinstance(image, Image) else Image(pixels=np.asarray(image))
-        )
-        started = time.monotonic()
-        report = session.run(wrapped_image)
-        elapsed_ms = int((time.monotonic() - started) * 1000)
+    try:
+        task = Task.from_dict(graph)
+    except (KeyError, TypeError, AttributeError, ValueError) as exc:
+        raise GraphBuildError(
+            f"malformed graph: {type(exc).__name__}: {exc}"
+        ) from exc
+
+    wrapped_image = image if isinstance(image, Image) else Image(pixels=np.asarray(image))
+    context: dict[str, Any] = {"image": wrapped_image}
+    if calibration is not None:
+        context["calibration"] = calibration
+
+    started = time.monotonic()
+    report = task.run(context=context)
+    elapsed_ms = int((time.monotonic() - started) * 1000)

    outputs: dict[str, float] = {}
    failures: list[ToolFailure] = []
    invalid_outputs: dict[str, str] = {}
-    overlay: list[dict] = []
    for result in report:
-        # #46: overlay di ogni strumento, con il tool_id di chi lo ha prodotto
-        for item in result.overlay or []:
-            if isinstance(item, dict):
-                overlay.append({**item, "tool_id": result.tool_id})
        if not result.ok:
            failures.append(ToolFailure(
                tool_id=result.tool_id,
@@ -208,55 +164,4 @@ def run_graph(
        engine_version=engine_version(),
        duration_ms=elapsed_ms,
        invalid_outputs=invalid_outputs,
-        overlay=overlay,
-        outcome=report.outcome,
    )
-
-
-def _is_number(value: Any) -> bool:
-    return isinstance(value, (int, float)) and not isinstance(value, bool)
-
-
-def validate_graph(
-    graph: dict, recipe_dir: Any = None
-) -> tuple[bool, list[str], list[dict]]:
-    """Validate a v2 recipe without an image: (ok, errors, numeric outputs).
-
-    Not a draft: a missing meta file is an error. `outputs` lists the numeric
-    outputs the tools declare (OUT properties with a numeric default, plus the
-    `values` of dimension tools), with quantity/unit when declared.
-    """
-    load_tools()
-    if not isinstance(graph, dict):
-        return False, ["graph must be a JSON object"], []
-    try:
-        task = Task.from_dict(
-            graph, recipe_dir=Path(recipe_dir) if recipe_dir else None
-        )
-    except RecipeError as exc:
-        return False, list(exc.errors), []
-    except (KeyError, TypeError, AttributeError, ValueError) as exc:
-        return False, [f"{type(exc).__name__}: {exc}"], []
-
-    outputs: list[dict] = []
-    for tool in task.tools:
-        value_quantities = getattr(tool, "value_quantities", None) or {}
-        values = tuple(getattr(tool, "values", ()) or ())
-        for prop in tool.outputs():
-            if not (_is_number(prop.default) or prop.name in values):
-                continue
-            quantity = value_quantities.get(prop.name, getattr(tool, "quantity", None))
-            if not isinstance(quantity, str):
-                quantity = None
-            unit = None
-            if quantity == "length":
-                nominal_unit = getattr(tool, "nominal_unit", None)
-                unit = nominal_unit if isinstance(nominal_unit, str) else None
-            elif quantity == "angle":
-                unit = "deg"
-            outputs.append({
-                "key": f"{tool.id}.{prop.name}",
-                "quantity": quantity,
-                "unit": unit,
-            })
-    return True, [], outputs
@@ -34,16 +34,14 @@ def a_disc(radius: int = 60, size: int = 400) -> np.ndarray:
 def a_circle_graph() -> dict:
    """A two-tool graph, built with vs-task's own API."""
    from visionsuite.task import Task
-    from visionsuite.tools.detect import DetectCircle
-    from visionsuite.tools.dimensions import Diameter
+    from visionsuite.task.tools import DetectCircleTool, DiameterTool

    task = Task(name="prova")
-    found = task.add(DetectCircle(name="disco"))
+    found = task.add(DetectCircleTool(name="disco"))
    found.center_row, found.center_col, found.radius = 200.0, 200.0, 60.0
    found.scan_size = 30.0

-    quota = task.add(Diameter(name="diametro"))
-    quota.nominal_unit = "px"  # #46: v2, senza calibrazione la quota resta in px
+    quota = task.add(DiameterTool(name="diametro"))
    quota.link("circle", found, "circle")
    return task.to_dict()

@@ -65,7 +63,7 @@ def test_a_broken_tool_does_not_sink_the_others():
    graph = a_circle_graph()
    graph["tools"].append(
        {"id": "ghost", "kind": "DetectCircle", "name": "assente",
-         "values": {"center_row": 5.0, "center_col": 5.0, "radius": 900.0}}
+         "properties": {"center_row": 5.0, "center_col": 5.0, "radius": 900.0}}
    )

    outcome = run_graph(a_disc(), graph)
@@ -83,21 +81,14 @@ class _FakeResult:
        self.ok = ok
        self.outputs = outputs or {}
        self.error = error
-        self.overlay = []  # #46: v2, ogni risultato porta l'overlay
-
-
-class _FakeReport(list):
-    """#46: run_graph ora legge `.outcome` dal report di Session.run."""
-
-    outcome = "pass"


 def test_a_nan_output_is_dropped_not_measured(monkeypatch):
    """vs-measure emits NaN on an empty slice (caliper.py:112 per the
    revisione) - a NaN must not become a quote's value (#16)."""
-    def fake_run(self, image, tag=None):
-        return _FakeReport([_FakeResult("t1", "diametro", True, outputs={"diameter": float("nan")})])
-    monkeypatch.setattr(runner.Session, "run", fake_run)
+    def fake_run(self, context=None):
+        return [_FakeResult("t1", "diametro", True, outputs={"diameter": float("nan")})]
+    monkeypatch.setattr(runner.Task, "run", fake_run)

    outcome = run_graph(a_disc(), a_circle_graph())

@@ -106,9 +97,9 @@ def test_a_nan_output_is_dropped_not_measured(monkeypatch):


 def test_an_infinite_output_is_dropped_not_measured(monkeypatch):
-    def fake_run(self, image, tag=None):
-        return _FakeReport([_FakeResult("t1", "diametro", True, outputs={"diameter": float("inf")})])
-    monkeypatch.setattr(runner.Session, "run", fake_run)
+    def fake_run(self, context=None):
+        return [_FakeResult("t1", "diametro", True, outputs={"diameter": float("inf")})]
+    monkeypatch.setattr(runner.Task, "run", fake_run)

    outcome = run_graph(a_disc(), a_circle_graph())

@@ -118,9 +109,9 @@ def test_an_infinite_output_is_dropped_not_measured(monkeypatch):

 def test_a_bool_output_is_not_treated_as_a_measurable_number(monkeypatch):
    """bool is a subclass of int - a flag output must not become a quote."""
-    def fake_run(self, image, tag=None):
-        return _FakeReport([_FakeResult("t1", "flag", True, outputs={"present": True})])
-    monkeypatch.setattr(runner.Session, "run", fake_run)
+    def fake_run(self, context=None):
+        return [_FakeResult("t1", "flag", True, outputs={"present": True})]
+    monkeypatch.setattr(runner.Task, "run", fake_run)

    outcome = run_graph(a_disc(), a_circle_graph())

@@ -164,127 +155,3 @@ def test_engine_version_raises_rather_than_inventing_one(monkeypatch):
            engine_version()
    finally:
        runner._engine_version_from_git.cache_clear()
-
-
-# ---------------------------------------------------------------------------
-# #46: ricette v2 complete - overlay, calibrazione, recipe_dir con DXF.
-# ---------------------------------------------------------------------------
-
-import hashlib
-import shutil
-from pathlib import Path
-
-import cv2
-
-_VS = Path(__file__).resolve().parents[3] / "vendor" / "visionsuite"
-_SAMPLE_DXF = _VS / "packages" / "vs-dxf" / "tests" / "fixtures" / "sample.dxf"
-# Il disegno di prova: rettangolo 200x100 mm con foro r=10 mm.
-_PX_PER_MM = 4.0
-
-
-def _dxf_scene() -> np.ndarray:
-    """Il pezzo del disegno rasterizzato a 4 px/mm, margine 60 mm."""
-    margin = 60.0
-    w = int((200.0 + 2 * margin) * _PX_PER_MM)
-    h = int((100.0 + 2 * margin) * _PX_PER_MM)
-    img = np.full((h, w), 255, dtype=np.uint8)
-    cx, cy = w // 2, h // 2
-    hw, hh = 200.0 * _PX_PER_MM / 2, 100.0 * _PX_PER_MM / 2
-    cv2.rectangle(img, (int(cx - hw), int(cy - hh)), (int(cx + hw), int(cy + hh)), 0, -1)
-    cv2.circle(img, (cx, cy), int(10.0 * _PX_PER_MM), 255, -1)
-    return img
-
-
-def _dxf_recipe() -> dict:
-    """CompareDxf con ancora a due punti, collegati a due DetectPointScan.
-
-    Le due scansioni trovano i bordi sinistro e destro del pezzo una riga
-    sopra il lato in basso: origine del disegno = angolo in basso a sinistra,
-    direzione a -> b = asse x del disegno.
-    """
-    h, w = _dxf_scene().shape
-    cx, cy = w // 2, h // 2
-    hw, hh = 200.0 * _PX_PER_MM / 2, 100.0 * _PX_PER_MM / 2
-    row = cy + hh - 1.0
-
-    def scan(tid: str, col: float) -> dict:
-        return {"id": tid, "name": tid, "kind": "DetectPointScan",
-                "values": {"start_row": row, "start_col": col - 30.0,
-                           "end_row": row, "end_col": col + 30.0,
-                           "width": 5.0, "select": "first"},
-                "links": {}}
-
-    return {
-        "schema_version": 2,
-        "name": "dxf",
-        "meta": {"dxf": {"disegno": {  # sha256 obbligatorio in meta (v2)
-            "path": "disegno.dxf",
-            "sha256": hashlib.sha256(_SAMPLE_DXF.read_bytes()).hexdigest()}}},
-        "tools": [
-            scan("t-a", cx - hw),
-            scan("t-b", cx + hw),
-            {"id": "t-dxf", "name": "confronto", "kind": "CompareDxf",
-             "values": {"dxf": "disegno", "mm_per_px": 1.0 / _PX_PER_MM,
-                        "anchor": "two_points",
-                        "band_plus": 8.0, "band_minus": 8.0},
-             "links": {"point_a": {"tool": "t-a", "property": "point"},
-                       "point_b": {"tool": "t-b", "property": "point"}}},
-        ],
-    }
-
-
-def test_a_circle_recipe_returns_overlay_and_outcome():
-    outcome = run_graph(a_disc(), a_circle_graph())
-
-    assert outcome.outcome in ("pass", "warning", "fail")
-    assert outcome.overlay, "DetectCircle must draw something"
-    assert all("tool_id" in item for item in outcome.overlay)
-
-
-def test_calibration_dict_gives_mm_quotes():
-    graph = a_circle_graph()
-    for tool in graph["tools"]:
-        if tool["kind"] == "Diameter":
-            tool["values"]["nominal_unit"] = "mm"
-
-    outcome = run_graph(a_disc(), graph, calibration={"mm_per_px": 0.5})
-
-    assert outcome.failures == []
-    diameter = next(v for k, v in outcome.outputs.items() if k.endswith(".value"))
-    assert diameter == pytest.approx(60.0, abs=2.0)  # 120 px * 0.5 mm/px
-
-
-def test_compare_dxf_two_points_with_recipe_dir(tmp_path):
-    shutil.copy(_SAMPLE_DXF, tmp_path / "disegno.dxf")
-
-    outcome = run_graph(_dxf_scene(), _dxf_recipe(), recipe_dir=tmp_path)
-
-    assert outcome.failures == []
-    assert outcome.outputs["t-dxf.n_points"] > 1000
-    assert outcome.outputs["t-dxf.points_in_pct"] > 95.0
-    roles = {item.get("role") for item in outcome.overlay}
-    assert {"reference", "found"} <= roles
-    assert "t-dxf" in {item["tool_id"] for item in outcome.overlay}
-
-
-def test_missing_meta_file_is_a_graph_build_error(tmp_path):
-    with pytest.raises(runner.GraphBuildError):
-        run_graph(_dxf_scene(), _dxf_recipe(), recipe_dir=tmp_path)
-
-
-def test_validate_lists_numeric_outputs(tmp_path):
-    shutil.copy(_SAMPLE_DXF, tmp_path / "disegno.dxf")
-    graph = _dxf_recipe()
-
-    ok, errors, outputs = runner.validate_graph(graph, tmp_path)
-
-    assert ok, errors
-    keys = {o["key"] for o in outputs}
-    assert {"t-dxf.points_in_pct", "t-dxf.n_points"} <= keys
-    assert all(set(o) == {"key", "quantity", "unit"} for o in outputs)
-
-
-def test_validate_reports_a_missing_file(tmp_path):
-    ok, errors, outputs = runner.validate_graph(_dxf_recipe(), tmp_path)
-
-    assert not ok and errors and outputs == []
@@ -10,19 +10,12 @@ import asyncio
 import io
 import json
 import os
-from pathlib import Path

 import numpy as np
 from fastapi import FastAPI, File, Form, HTTPException, UploadFile, status
 from PIL import Image, UnidentifiedImageError

-from src.vision.runner import (
-    GraphBuildError,
-    RunOutcome,
-    engine_version,
-    run_graph,
-    validate_graph,
-)
+from src.vision.runner import GraphBuildError, RunOutcome, engine_version, run_graph

 app = FastAPI(title="TieMeasureFlow Vision Worker", version="0.1.0")

@@ -38,67 +31,6 @@ _MAX_CONCURRENCY = int(os.environ.get("VISION_MAX_CONCURRENCY", "2"))
 _run_slots = asyncio.Semaphore(_MAX_CONCURRENCY)


-# #46: radice sotto cui vivono le cartelle delle ricette (volume uploads,
-# montato in sola lettura nel worker). `recipe_dir` e' relativo a questa radice.
-_RECIPES_ROOT_DEFAULT = "/app/uploads"
-
-
-def _unprocessable(detail: str) -> HTTPException:
-    return HTTPException(
-        status_code=status.HTTP_422_UNPROCESSABLE_CONTENT, detail=detail
-    )
-
-
-def _resolve_recipe_dir(recipe_dir: str | None) -> Path | None:
-    """Percorso RELATIVO sotto VISION_RECIPES_ROOT -> cartella assoluta.
-
-    Assoluto, `..` o fuori radice (anche via symlink) -> 422. Vuoto -> None.
-    """
-    if recipe_dir is None or not recipe_dir.strip():
-        return None
-    rel = recipe_dir.strip()
-    # Letto a ogni richiesta (non a import) cosi' i test possono cambiarlo.
-    root = Path(os.environ.get("VISION_RECIPES_ROOT", _RECIPES_ROOT_DEFAULT)).resolve()
-    if (
-        Path(rel).is_absolute()
-        or rel.startswith(("/", "\\"))
-        or ".." in Path(rel.replace("\\", "/")).parts
-    ):
-        raise _unprocessable("recipe_dir must be a relative path under the recipes root")
-    resolved = (root / rel).resolve()
-    if resolved != root and root not in resolved.parents:
-        raise _unprocessable("recipe_dir is outside the recipes root")
-    return resolved
-
-
-def _parse_graph(graph: str) -> dict:
-    try:
-        parsed = json.loads(graph)
-    except json.JSONDecodeError as exc:
-        raise _unprocessable(f"graph is not valid JSON: {exc}") from exc
-    if not isinstance(parsed, dict):
-        raise _unprocessable(
-            f"graph must be a JSON object, got {type(parsed).__name__}"
-        )
-    return parsed
-
-
-def _parse_calibration(calibration: str | None) -> dict | None:
-    if calibration is None or not calibration.strip():
-        return None
-    try:
-        parsed = json.loads(calibration)
-    except json.JSONDecodeError as exc:
-        raise _unprocessable(f"calibration is not valid JSON: {exc}") from exc
-    if not isinstance(parsed, dict) or not (
-        parsed.get("mm_per_px") or parsed.get("px_per_mm")
-    ):
-        raise _unprocessable(
-            "calibration must be {'mm_per_px': float} or {'px_per_mm': float}"
-        )
-    return parsed
-
-
 class _ImageDecodeError(Exception):
    """The upload is not a decodable image - raised inside the worker thread
    so it survives the trip through `asyncio.to_thread`."""
@@ -112,12 +44,7 @@ async def health() -> dict:
    return {"status": "ok", "engine_version": engine_version()}


-def _decode_and_run(
-    content: bytes,
-    graph: dict,
-    calibration: dict | None = None,
-    recipe_dir: Path | None = None,
-) -> RunOutcome:
+def _decode_and_run(content: bytes, graph: dict) -> RunOutcome:
    """The synchronous, CPU/IO-bound half of a request: PIL decode plus
    `run_graph`. Runs in a worker thread (see `run` below) so the event loop -
    and therefore `/health` - stays responsive while it executes. Once this
@@ -129,19 +56,27 @@ def _decode_and_run(
        frame = np.array(Image.open(io.BytesIO(content)).convert("L"))
    except (UnidentifiedImageError, OSError) as exc:
        raise _ImageDecodeError(str(exc)) from exc
-    return run_graph(frame, graph, calibration=calibration, recipe_dir=recipe_dir)
+    return run_graph(frame, graph)


@app.post("/run")
 async def run(
    image: UploadFile = File(...),
    graph: str = Form(...),
-    recipe_dir: str | None = Form(None),
-    calibration: str | None = Form(None),
 ) -> dict:
-    parsed_graph = _parse_graph(graph)
-    resolved_dir = _resolve_recipe_dir(recipe_dir)
-    parsed_calibration = _parse_calibration(calibration)
+    try:
+        parsed_graph = json.loads(graph)
+    except json.JSONDecodeError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=f"graph is not valid JSON: {exc}",
+        ) from exc
+
+    if not isinstance(parsed_graph, dict):
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=f"graph must be a JSON object, got {type(parsed_graph).__name__}",
+        )

    content = await image.read()

@@ -154,13 +89,7 @@ async def run(
    async with _run_slots:
        try:
            outcome = await asyncio.wait_for(
-                asyncio.to_thread(
-                    _decode_and_run,
-                    content,
-                    parsed_graph,
-                    parsed_calibration,
-                    resolved_dir,
-                ),
+                asyncio.to_thread(_decode_and_run, content, parsed_graph),
                timeout=_RUN_TIMEOUT_S,
            )
        except asyncio.TimeoutError as exc:
@@ -201,22 +130,4 @@ async def run(
        "engine_version": outcome.engine_version,
        "duration_ms": outcome.duration_ms,
        "invalid_outputs": outcome.invalid_outputs,
-        # #46: contorni per l'overlay sull'immagine e esito VisionSuite.
-        "overlay": outcome.overlay,
-        "outcome": outcome.outcome,
    }
-
-
-@app.post("/validate")
-async def validate(
-    graph: str = Form(...),
-    recipe_dir: str | None = Form(None),
-) -> dict:
-    """Validates a v2 recipe (not a draft: a missing meta file is an error)
-    and lists its numeric outputs. No image, so it is cheap: no run slot."""
-    parsed_graph = _parse_graph(graph)
-    resolved_dir = _resolve_recipe_dir(recipe_dir)
-    ok, errors, outputs = await asyncio.to_thread(
-        validate_graph, parsed_graph, resolved_dir
-    )
-    return {"ok": ok, "errors": errors, "outputs": outputs}
@@ -45,15 +45,13 @@ def a_disc_png(radius: int = 60, size: int = 400) -> bytes:

 def a_circle_graph() -> dict:
    from visionsuite.task import Task
-    from visionsuite.tools.detect import DetectCircle
-    from visionsuite.tools.dimensions import Diameter
+    from visionsuite.task.tools import DetectCircleTool, DiameterTool

    task = Task(name="prova")
-    found = task.add(DetectCircle(name="disco"))
+    found = task.add(DetectCircleTool(name="disco"))
    found.center_row, found.center_col, found.radius = 200.0, 200.0, 60.0
    found.scan_size = 30.0
-    quota = task.add(Diameter(name="diametro"))
-    quota.nominal_unit = "px"  # #46: v2, senza calibrazione la quota resta in px
+    quota = task.add(DiameterTool(name="diametro"))
    quota.link("circle", found, "circle")
    return task.to_dict()

@@ -142,7 +140,7 @@ async def test_a_graph_that_is_not_an_object_is_refused():

@pytest.mark.asyncio
 async def test_a_tool_without_a_kind_is_refused_not_crashed():
-    graph = {"schema_version": 2, "name": "p", "tools": [{"id": "a", "name": "x"}]}
+    graph = {"schema_version": 1, "name": "p", "tools": [{"id": "a", "name": "x"}]}
    transport = ASGITransport(app=app)
    async with AsyncClient(transport=transport, base_url="http://worker") as client:
        response = await client.post(
@@ -153,7 +151,7 @@ async def test_a_tool_without_a_kind_is_refused_not_crashed():

    assert response.status_code == 422
    assert "malformed graph" in response.json()["detail"].lower()
-    assert "tipo sconosciuto" in response.json()["detail"].lower()  # #46: messaggio v2
+    assert "kind" in response.json()["detail"].lower()


 # ---------------------------------------------------------------------------
@@ -169,7 +167,7 @@ async def test_a_run_past_its_budget_answers_504_and_health_still_answers(
 ):
    monkeypatch.setattr(worker_main, "_RUN_TIMEOUT_S", 0.1)

-    def slow_run_graph(frame, graph, **kwargs):
+    def slow_run_graph(frame, graph):
        time.sleep(0.5)  # off the event loop - it runs inside asyncio.to_thread
        return runner.RunOutcome(engine_version="a" * 40)

@@ -199,7 +197,7 @@ async def test_a_third_concurrent_run_is_refused_not_queued(monkeypatch):
    monkeypatch.setattr(worker_main, "_run_slots", asyncio.Semaphore(1))
    monkeypatch.setattr(worker_main, "_RUN_TIMEOUT_S", 2.0)

-    def slow_run_graph(frame, graph, **kwargs):
+    def slow_run_graph(frame, graph):
        time.sleep(0.3)
        return runner.RunOutcome(engine_version="a" * 40)

@@ -224,88 +222,3 @@ async def test_a_third_concurrent_run_is_refused_not_queued(monkeypatch):

    assert second_response.status_code == 503
    assert first_response.status_code == 200
-
-
-# ---------------------------------------------------------------------------
-# #46: recipe_dir, calibration, overlay, /validate.
-# ---------------------------------------------------------------------------
-
-
-async def _post(path: str, **kwargs):
-    transport = ASGITransport(app=app)
-    async with AsyncClient(transport=transport, base_url="http://worker") as client:
-        return await client.post(path, **kwargs)
-
-
-@pytest.mark.asyncio
-async def test_run_returns_overlay_and_outcome():
-    response = await _post(
-        "/run",
-        files={"image": ("piece.png", a_disc_png(), "image/png")},
-        data={"graph": json.dumps(a_circle_graph())},
-    )
-
-    body = response.json()
-    assert response.status_code == 200
-    assert body["overlay"] and "tool_id" in body["overlay"][0]
-    assert body["outcome"] in ("pass", "warning", "fail")
-
-
-@pytest.mark.asyncio
-async def test_run_accepts_a_calibration():
-    graph = a_circle_graph()
-    for tool in graph["tools"]:
-        if tool["kind"] == "Diameter":
-            tool["values"]["nominal_unit"] = "mm"
-    response = await _post(
-        "/run",
-        files={"image": ("piece.png", a_disc_png(), "image/png")},
-        data={"graph": json.dumps(graph),
-              "calibration": json.dumps({"px_per_mm": 2.0})},
-    )
-
-    body = response.json()
-    assert response.status_code == 200, body
-    assert body["failures"] == []
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("bad", ["../etc", "a/../../b", "/abs/path", "C:/x/y"])
-async def test_a_recipe_dir_outside_the_root_is_refused(bad, monkeypatch, tmp_path):
-    monkeypatch.setenv("VISION_RECIPES_ROOT", str(tmp_path))
-    response = await _post(
-        "/run",
-        files={"image": ("piece.png", a_disc_png(), "image/png")},
-        data={"graph": json.dumps(a_circle_graph()), "recipe_dir": bad},
-    )
-    assert response.status_code == 422
-
-    response = await _post(
-        "/validate", data={"graph": json.dumps(a_circle_graph()), "recipe_dir": bad}
-    )
-    assert response.status_code == 422
-
-
-@pytest.mark.asyncio
-async def test_validate_ok_and_with_a_missing_file(monkeypatch, tmp_path):
-    monkeypatch.setenv("VISION_RECIPES_ROOT", str(tmp_path))
-    response = await _post("/validate", data={"graph": json.dumps(a_circle_graph())})
-    body = response.json()
-    assert response.status_code == 200 and body["ok"] is True
-    assert any(o["key"].endswith(".diameter") for o in body["outputs"])
-
-    (tmp_path / "r1").mkdir()
-    graph = {
-        "schema_version": 2, "name": "d",
-        "meta": {"dxf": {"d": {"path": "mancante.dxf"}}},
-        "tools": [{"id": "t", "name": "c", "kind": "CompareDxf",
-                   "values": {"dxf": "d", "mm_per_px": 0.25,
-                              "band_plus": 8.0, "band_minus": 8.0},
-                   "links": {}}],
-    }
-    response = await _post(
-        "/validate", data={"graph": json.dumps(graph), "recipe_dir": "r1"}
-    )
-    body = response.json()
-    assert response.status_code == 200
-    assert body["ok"] is False and body["errors"] and body["outputs"] == []
@@ -626,45 +626,6 @@ wheels = [
    { url = "https://files.pythonhosted.org/packages/21/0e/8459ca4413e1a21a06c97d134bfaf18adfd27cea068813dc0faae06cbf00/cssselect2-0.9.0-py3-none-any.whl", hash = "sha256:6a99e5f91f9a016a304dd929b0966ca464bcfda15177b6fb4a118fc0fb5d9563", size = 15453, upload-time = "2026-02-12T17:16:38.317Z" },
 ]

-[[package]]
-name = "ezdxf"
-version = "1.4.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "fonttools" },
-    { name = "numpy" },
-    { name = "pyparsing" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5e/d7/1b7be8db364f1c4838dfc1a40ca96577aba405deabf896a4eb3aaeb15a62/ezdxf-1.4.4.tar.gz", hash = "sha256:da5a5e0e6bdbb6656f9c017b47edc7eafceb419d61a2b5de64ffb344c168e593", size = 1866886, upload-time = "2026-05-14T09:19:19.511Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8f/d0/bc515b7f5596bc3d55b93fc9f2c2b4926e2587af6bfae0486ef7cc7ddf43/ezdxf-1.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:39aadab5bc7a05deddbd0db9b984c8a4bd28bd4c1ac2c5ee03f0d1b096272a88", size = 3553590, upload-time = "2026-05-14T09:25:28.042Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/73/207132f13a5280d186f2441d9125639fdc7ddeabf56c2d5da4d691e81ce6/ezdxf-1.4.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2ed65b191113a82133ba47daa6ebdd540b487b17394b1e327e9511dde87ad924", size = 3008276, upload-time = "2026-05-14T09:25:29.424Z" },
-    { url = "https://files.pythonhosted.org/packages/82/73/b01af87269726e3719abc5ff694b843b710ef8fc345d21013e90d70e44d8/ezdxf-1.4.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c3c8f2c2b62fe5b6c9b62ab8257b697535d62b0c79acf3a5040bd95edfab451", size = 3001750, upload-time = "2026-05-14T09:25:31.146Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/92/284d7ca6a9da107966c7bd9d81c92245985235bc432fe0837982ef80630a/ezdxf-1.4.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d68d5ab9e1071319030da3af27590f34c38c8544a5ea638d9a4a800a96abb3c2", size = 5802382, upload-time = "2026-05-14T09:27:28.462Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/fe/e4f37730ca5b5bf7de3a968a26126b404f60324d0b8ae9d59d11d6e55740/ezdxf-1.4.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f75a4f2924ebdda0f5b2779ff2135ba92de2596c95a8fa9b1d9ebcabea1be41", size = 5794671, upload-time = "2026-05-14T09:27:09.867Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/3f/c3e7ab74f58cb69ef985fb71eda859b5c287cc506c65cbffe7e55c7cf2d4/ezdxf-1.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0eec8a2095b645420a67560e99041c0d25afefd39eab5bff8c736fdb32211a75", size = 5767366, upload-time = "2026-05-14T09:27:30.108Z" },
-    { url = "https://files.pythonhosted.org/packages/66/7a/b7070bf05e75b3e709a6fe5ae5bcd3bd899e987ef84ff25cf28327519c03/ezdxf-1.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d87a85052e92b9c28e54605dbad65f779a3b61e6288e992d6ef00df7bde4bed3", size = 5830221, upload-time = "2026-05-14T09:27:12.074Z" },
-    { url = "https://files.pythonhosted.org/packages/78/cf/a990289808c261c52f5b219484d136a8748773c99a6d25c84f55a0353fea/ezdxf-1.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:473d68c8f2b04ace513efa290a1cd0d3a4a589cdff48124f015f0e51034668b2", size = 2957599, upload-time = "2026-05-14T09:23:46.571Z" },
-    { url = "https://files.pythonhosted.org/packages/18/3d/98648d221ffa047b5ba898c8e152010861dc71a66b531dcf15053075010e/ezdxf-1.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d723d35d08223318c17080a32a05192a1449e544dee867c9d9c6f25998fac303", size = 3563916, upload-time = "2026-05-14T09:25:32.879Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/f1/84bbaa571412f840c22deeae185e54d4a67aa52f03e1728fd8425748c548/ezdxf-1.4.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6b0c73b46085521bdbd4a3e7d88998da7bec5713ba89bbb502fdeffe6b42fc7e", size = 3016857, upload-time = "2026-05-14T09:25:34.607Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/ff/f2eb77d22d26aa98abbe0961470871d8b85ef4e73e5527f544d25f958d6e/ezdxf-1.4.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ac3e83a70c1f866dd5114192a6fab6e75cc83b75e907bc08c5d94b98cce14cc0", size = 3003336, upload-time = "2026-05-14T09:25:35.947Z" },
-    { url = "https://files.pythonhosted.org/packages/65/7d/2a6ddd6beef5d9a8593078619f3920a0cd76b1db4c6a974ac37045543219/ezdxf-1.4.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8ebe09717ab6636bf48780eabdab51e3ab2135f7963bb52452444b6d95e03d12", size = 5788485, upload-time = "2026-05-14T09:27:32.176Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/29/2094fd7719146ca7bb236be9751b5929d431f643cbab669aed89cf121883/ezdxf-1.4.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:44af248af0860fe8b1a39ca40e1cd2fa8ac37b22142b14b20c6a0caf1b50f932", size = 5816781, upload-time = "2026-05-14T09:27:13.96Z" },
-    { url = "https://files.pythonhosted.org/packages/19/8d/669b8047cca162204c53b874183d73b5f6c4b1d5d48fa1e515a32d56f5ac/ezdxf-1.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:02a097794625e9fc948e637dfe07057e98167b4fe215357a59645759fef6db3f", size = 5754006, upload-time = "2026-05-14T09:27:33.858Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/44/b753997173327250e43ae50f11f0c69016b1e78482e0bd3857c3495236e7/ezdxf-1.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f093bd2228f5782d483aed3bd89cdb74b672b5f90c677c4125cd236ee5649151", size = 5861860, upload-time = "2026-05-14T09:27:15.758Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/99/2e81cb168e0f09adfb05fb40e5f890ff87ac2c00e98079cf09837dd76330/ezdxf-1.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:3e518d9ed4dcbe525d57f14c25c5e592f82660a690fdec39b03b092e6cdc4771", size = 2963238, upload-time = "2026-05-14T09:23:47.924Z" },
-    { url = "https://files.pythonhosted.org/packages/be/ed/97aa3ba1ba923e4098169de5bca380ee1430e2b34d0dd85b73007e34df16/ezdxf-1.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:278a09a845d67a4f893aebe9ef8dcd8894ece9f255d7d8bb21719ffd902109b8", size = 3555283, upload-time = "2026-05-14T09:25:37.346Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/b1/8ca9408a2b382a806837e72d35f10931fdd9f53fe66cf208a6340358fbc5/ezdxf-1.4.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b0a787f8ebcbdcb9798c6fcfe90c23afd1a0993c8d4302b6cce5d8f19ae052ae", size = 3012646, upload-time = "2026-05-14T09:25:39.01Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/aa/1e8d3130eaabb780c5e8adfdc1ead023bb04468779b18169d60f7ce5b291/ezdxf-1.4.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c451d1c20f08b30c735ca4d650fee5b44147402f4b5662f8550053ed8a3009c2", size = 2999048, upload-time = "2026-05-14T09:25:40.348Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/ca/1dd390b79df9c104c2d4b5964e80db25362edf704ac742c9db9b279658a5/ezdxf-1.4.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d3d9a6663993fc644751647fd7843057b51742ffac27c48ce28ea9f81239613", size = 5747890, upload-time = "2026-05-14T09:27:36.028Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/1e/226a6e636ae533e0bc0afe4435d1058fac173564e4af4102862f055a46d9/ezdxf-1.4.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82c022cf094d21ad3db68557aa83628e4152355e8a8bef0fffd4f71a9ea325df", size = 5774707, upload-time = "2026-05-14T09:27:17.625Z" },
-    { url = "https://files.pythonhosted.org/packages/24/a3/7e33c9036de944b5446982bb629d698356e48b00c4d173768f52bdeeff4b/ezdxf-1.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3be59c2a3a93585412a2a37af29b3ad7574fa3e429e624924c3285d0573388b3", size = 5713753, upload-time = "2026-05-14T09:27:37.55Z" },
-    { url = "https://files.pythonhosted.org/packages/36/9e/ac0cdc3a8623fc38aa16670f6537aa810bc1381217a51ac3481299bbc986/ezdxf-1.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:44a9716860b59dddd49a3708c04ff4580ad1e7de92ac93bb3213d85fba5ac93f", size = 5813895, upload-time = "2026-05-14T09:27:19.514Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/22/b511a8d9ea8f23447a67fe8977213fac5e4e69df30130a3ef31043613eaf/ezdxf-1.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:207eed544417464ffaf2570880d58a792ecd2534c9c2dede45e895f3200b77e6", size = 2960937, upload-time = "2026-05-14T09:23:49.361Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/09/5ecb6f82d35a2f4a4334d0a608fcf764827fa69dccdf5987ce309c16b6c1/ezdxf-1.4.4-py3-none-any.whl", hash = "sha256:666edda631ba717270293b734f5d58dd97a1d1aba4787187f09d0cc584645865", size = 1331217, upload-time = "2026-05-14T09:19:26.601Z" },
-]
-
 [[package]]
 name = "fastapi"
 version = "0.136.1"
@@ -1118,8 +1079,8 @@ name = "numba"
 version = "0.67.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "llvmlite" },
-    { name = "numpy" },
+    { name = "llvmlite", marker = "python_full_version >= '3.13'" },
+    { name = "numpy", marker = "python_full_version >= '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7a/90/2544f4e3a61e501d6c9a5418fd4b905323222693d54a02cab0106a0af865/numba-0.67.0.tar.gz", hash = "sha256:cd75aa535b33fa05d9d930b1ae8af9f97a2881e96d72dfb38ec9b78284d9f851", size = 2836515, upload-time = "2026-08-11T23:04:00.174Z" }
 wheels = [
@@ -1224,7 +1185,7 @@ name = "opencv-python"
 version = "5.0.0.93"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy" },
+    { name = "numpy", marker = "python_full_version >= '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/79/4c/a438d23e09ce2033c09f7b784ad2fbdb0adf529e434101ed28f142226f98/opencv_python-5.0.0.93.tar.gz", hash = "sha256:66aac3e5b5faa48d4025816592f3af19e4bfc2c68dec067bae2dbb4ca10aa9e2", size = 81802749, upload-time = "2026-07-02T06:59:53.815Z" }
 wheels = [
@@ -1609,15 +1570,6 @@ wheels = [
    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
 ]

-[[package]]
-name = "pyparsing"
-version = "3.3.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e4/11/b213bebff182584360cb8d17c72c1677fec5c5c228de439e63bcf8ab1c8f/pyparsing-3.3.3.tar.gz", hash = "sha256:928ae7e20211f3b6f3915a72f06a0cfd29ab9d24279dd6346b6b1a7146397d36", size = 1050487, upload-time = "2026-09-20T20:59:05.609Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/38/bb/d215ee7c73b61497b28a5503f9f53523f294fcc936762b7caf90e0c1c2b5/pyparsing-3.3.3-py3-none-any.whl", hash = "sha256:ece8c00a69cf01b45d0b1dedabb469c90d8caf996d4fda40f147627a122849a4", size = 126420, upload-time = "2026-09-20T20:59:04.025Z" },
-]
-
 [[package]]
 name = "pypdfium2"
 version = "5.8.0"
@@ -1799,7 +1751,7 @@ name = "scipy"
 version = "1.18.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy" },
+    { name = "numpy", marker = "python_full_version >= '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a7/25/c2700dfaf6442b4effaa91af24ebce5dc9d31bb4a69706313aae70d72cd0/scipy-1.18.0.tar.gz", hash = "sha256:67b2ad2ad54c72ca6d04975a9b2df8c3638c34ddd5b28738e94fc2b57929d378", size = 30774447, upload-time = "2026-06-19T15:01:43.456Z" }
 wheels = [
@@ -2028,7 +1980,6 @@ vision = [
    { name = "vs-measure", marker = "python_full_version >= '3.13'" },
    { name = "vs-pm2d", marker = "python_full_version >= '3.13'" },
    { name = "vs-task", marker = "python_full_version >= '3.13'" },
-    { name = "vs-tools", extra = ["dxf", "locate"], marker = "python_full_version >= '3.13'" },
 ]
 vision-worker = [
    { name = "fastapi", marker = "python_full_version >= '3.13'" },
@@ -2040,7 +1991,6 @@ vision-worker = [
    { name = "vs-measure", marker = "python_full_version >= '3.13'" },
    { name = "vs-pm2d", marker = "python_full_version >= '3.13'" },
    { name = "vs-task", marker = "python_full_version >= '3.13'" },
-    { name = "vs-tools", extra = ["dxf", "locate"], marker = "python_full_version >= '3.13'" },
 ]

 [package.metadata]
@@ -2082,7 +2032,6 @@ requires-dist = [
    { name = "vs-measure", marker = "python_full_version >= '3.13' and extra == 'vision'", editable = "vendor/visionsuite/packages/vs-measure" },
    { name = "vs-pm2d", marker = "python_full_version >= '3.13' and extra == 'vision'", editable = "vendor/visionsuite/packages/vs-pm2d" },
    { name = "vs-task", marker = "python_full_version >= '3.13' and extra == 'vision'", editable = "vendor/visionsuite/packages/vs-task" },
-    { name = "vs-tools", extras = ["locate", "dxf"], marker = "python_full_version >= '3.13' and extra == 'vision'", editable = "vendor/visionsuite/packages/vs-tools" },
    { name = "weasyprint", marker = "extra == 'server'", specifier = ">=62.0" },
 ]
 provides-extras = ["server", "client", "dev", "vision", "vision-worker"]
@@ -2208,14 +2157,8 @@ name = "visionsuite"
 version = "0.0.1"
 source = { editable = "vendor/visionsuite/packages/vs-core" }
 dependencies = [
-    { name = "numpy" },
-    { name = "opencv-python" },
-    { name = "pillow" },
-]
-
-[package.optional-dependencies]
-dxf = [
-    { name = "ezdxf" },
+    { name = "numpy", marker = "python_full_version >= '3.13'" },
+    { name = "opencv-python", marker = "python_full_version >= '3.13'" },
 ]

 [package.metadata]
@@ -2225,70 +2168,42 @@ requires-dist = [
    { name = "numba", marker = "extra == 'fast'", specifier = ">=0.59" },
    { name = "numpy", specifier = ">=1.24" },
    { name = "opencv-python", specifier = ">=4.8" },
-    { name = "pillow", specifier = ">=12.2.0" },
    { name = "pytest", marker = "extra == 'dev'", specifier = ">=7" },
 ]
 provides-extras = ["dev", "fast", "dxf"]

-[[package]]
-name = "vs-dxf"
-version = "0.1.0"
-source = { editable = "vendor/visionsuite/packages/vs-dxf" }
-dependencies = [
-    { name = "numpy" },
-    { name = "opencv-python" },
-    { name = "pydantic" },
-    { name = "scipy" },
-    { name = "visionsuite", extra = ["dxf"] },
-    { name = "vs-measure" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "numpy", specifier = ">=1.26" },
-    { name = "opencv-python", specifier = ">=4.9" },
-    { name = "pydantic", specifier = ">=2.6" },
-    { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0" },
-    { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.1" },
-    { name = "scipy", specifier = ">=1.12" },
-    { name = "visionsuite", extras = ["dxf"], editable = "vendor/visionsuite/packages/vs-core" },
-    { name = "vs-measure", editable = "vendor/visionsuite/packages/vs-measure" },
-]
-provides-extras = ["dev"]
-
 [[package]]
 name = "vs-measure"
 version = "0.1.0"
 source = { editable = "vendor/visionsuite/packages/vs-measure" }
 dependencies = [
-    { name = "numpy" },
-    { name = "scipy" },
-    { name = "visionsuite" },
+    { name = "numpy", marker = "python_full_version >= '3.13'" },
+    { name = "scipy", marker = "python_full_version >= '3.13'" },
+    { name = "visionsuite", marker = "python_full_version >= '3.13'" },
 ]

 [package.metadata]
 requires-dist = [
-    { name = "numba", marker = "extra == 'fast'", specifier = ">=0.59" },
    { name = "numpy", specifier = ">=1.24" },
    { name = "pytest", marker = "extra == 'dev'", specifier = ">=7" },
    { name = "scipy", specifier = ">=1.11" },
    { name = "visionsuite", editable = "vendor/visionsuite/packages/vs-core" },
 ]
-provides-extras = ["dev", "fast"]
+provides-extras = ["dev"]

 [[package]]
 name = "vs-pm2d"
 version = "0.1.0"
 source = { editable = "vendor/visionsuite/packages/vs-pm2d" }
 dependencies = [
-    { name = "fastapi" },
-    { name = "numba" },
-    { name = "numpy" },
-    { name = "opencv-python" },
-    { name = "pillow" },
-    { name = "python-multipart" },
-    { name = "uvicorn", extra = ["standard"] },
-    { name = "visionsuite" },
+    { name = "fastapi", marker = "python_full_version >= '3.13'" },
+    { name = "numba", marker = "python_full_version >= '3.13'" },
+    { name = "numpy", marker = "python_full_version >= '3.13'" },
+    { name = "opencv-python", marker = "python_full_version >= '3.13'" },
+    { name = "pillow", marker = "python_full_version >= '3.13'" },
+    { name = "python-multipart", marker = "python_full_version >= '3.13'" },
+    { name = "uvicorn", extra = ["standard"], marker = "python_full_version >= '3.13'" },
+    { name = "visionsuite", marker = "python_full_version >= '3.13'" },
 ]

 [package.metadata]
@@ -2311,54 +2226,19 @@ name = "vs-task"
 version = "0.1.0"
 source = { editable = "vendor/visionsuite/packages/vs-task" }
 dependencies = [
-    { name = "numpy" },
-    { name = "visionsuite" },
+    { name = "numpy", marker = "python_full_version >= '3.13'" },
+    { name = "visionsuite", marker = "python_full_version >= '3.13'" },
+    { name = "vs-measure", marker = "python_full_version >= '3.13'" },
 ]

 [package.metadata]
 requires-dist = [
-    { name = "fastapi", marker = "extra == 'server'", specifier = ">=0.132" },
-    { name = "httpx", marker = "extra == 'dev'", specifier = ">=0.27" },
-    { name = "numpy", specifier = ">=1.24" },
-    { name = "pytest", marker = "extra == 'dev'", specifier = ">=7" },
-    { name = "uvicorn", marker = "extra == 'server'", specifier = ">=0.34" },
-    { name = "visionsuite", editable = "vendor/visionsuite/packages/vs-core" },
-    { name = "vs-stat", marker = "extra == 'stat'", editable = "vendor/visionsuite/packages/vs-stat" },
-]
-provides-extras = ["dev", "stat", "server"]
-
-[[package]]
-name = "vs-tools"
-version = "0.1.0"
-source = { editable = "vendor/visionsuite/packages/vs-tools" }
-dependencies = [
-    { name = "numpy" },
-    { name = "visionsuite" },
-    { name = "vs-measure" },
-    { name = "vs-task" },
-]
-
-[package.optional-dependencies]
-dxf = [
-    { name = "vs-dxf" },
-]
-locate = [
-    { name = "vs-pm2d" },
-]
-
-[package.metadata]
-requires-dist = [
-    { name = "ezdxf", marker = "extra == 'dev'", specifier = ">=1.0" },
    { name = "numpy", specifier = ">=1.24" },
    { name = "pytest", marker = "extra == 'dev'", specifier = ">=7" },
    { name = "visionsuite", editable = "vendor/visionsuite/packages/vs-core" },
-    { name = "vs-dxf", marker = "extra == 'dxf'", editable = "vendor/visionsuite/packages/vs-dxf" },
    { name = "vs-measure", editable = "vendor/visionsuite/packages/vs-measure" },
-    { name = "vs-pm2d", marker = "extra == 'locate'", editable = "vendor/visionsuite/packages/vs-pm2d" },
-    { name = "vs-task", editable = "vendor/visionsuite/packages/vs-task" },
-    { name = "vs-tools", extras = ["locate", "dxf"], marker = "extra == 'dev'", editable = "vendor/visionsuite/packages/vs-tools" },
 ]
-provides-extras = ["locate", "dxf", "dev"]
+provides-extras = ["dev"]

 [[package]]
 name = "watchfiles"
Author	SHA1	Message	Date
Adriano	2d03577165	loadProductionRun mostra il detail del server; START ACTIVITY in inglese (#61 #62 ) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>	2026-10-07 12:26:33 +02:00
Adriano	27dc5e77af	Schermate operatore: un solo Completato grande, Fermo linea solo con run aperto, AVVIA ATTIVITA, pannello lotto/seriale dopo la scelta (#60 #61 #62 #63 #64 ) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>	2026-10-07 12:25:56 +02:00
Adriano	3856ee335a	operatore: acquisizione immagine, proxy execute e overlay per camera_measure/dxf_compare (#46 ) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>	2026-10-07 11:55:42 +02:00