@noeva/analytics-core 0.4.1 → 0.5.1

package/contenuto/lib/ai/inferenza.py

@@ -0,0 +1,102 @@
+"""L'inferenza NOEVA da Python, per gli strumenti del progetto che girano sul Mac.
+
+Le pagine hanno il loro giro (lib/pagina/inferenza.js, attraverso ai/converse del
+contenitore). Qui c'e' lo stesso servizio per chi non e' una pagina: per esempio
+la traduzione della knowledge base in inglese durante l'export. E' l'unica strada
+di un modello da Python: mai la CLI di Claude ne' un'API di modelli diretta
+(`analytics ci` si ferma se un file del progetto ne usa una).
+
+    testo = converse(radice, sistema, testo_utente, funzione="traduzione")
+
+La chiave e' quella dell'utente tecnico del workspace del progetto, come nel
+secret NOEVA_INFERENZA del contenitore: NOEVA_INFERENZA_CHIAVE nell'ambiente o in
+<radice>/.wren/.env (mai in git, mai stampata). Il workspace e' quello di
+analytics.json; il modello NOEVA_INFERENZA_MODELLO (predefinito Haiku 5.5),
+l'API NOEVA_API (predefinita https://api.noeva.ai).
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+
+MODELLO_PREDEFINITO = "eu.anthropic.claude-haiku-5-5"
+API_PREDEFINITA = "https://api.noeva.ai"
+TENTATIVI = 3
+
+
+class ErroreInferenza(RuntimeError):
+    pass
+
+
+def _dal_file_env(radice: Path, nome: str) -> str:
+    f = radice / ".wren" / ".env"
+    if not f.exists():
+        return ""
+    for riga in f.read_text(encoding="utf-8").splitlines():
+        if riga.strip().startswith(f"{nome}="):
+            return riga.split("=", 1)[1].strip().strip('"').strip("'")
+    return ""
+
+
+def _valore(radice: Path, nome: str, predefinito: str = "") -> str:
+    return os.environ.get(nome) or _dal_file_env(radice, nome) or predefinito
+
+
+def configurazione(radice: Path) -> dict:
+    """Chiave, workspace, modello e API, o ErroreInferenza se manca qualcosa."""
+    radice = Path(radice)
+    chiave = _valore(radice, "NOEVA_INFERENZA_CHIAVE")
+    if not chiave.startswith("noeva_sk_"):
+        raise ErroreInferenza("manca NOEVA_INFERENZA_CHIAVE (la chiave noeva_sk_ dell'utente tecnico del workspace) "
+                              "nell'ambiente o in .wren/.env")
+    try:
+        workspace = json.loads((radice / "analytics.json").read_text(encoding="utf-8")).get("workspace") or ""
+    except (OSError, ValueError):
+        workspace = ""
+    workspace = _valore(radice, "NOEVA_INFERENZA_WORKSPACE", workspace)
+    if not workspace:
+        raise ErroreInferenza("analytics.json senza workspace: l'inferenza NOEVA non sa per chi lavora")
+    return {"chiave": chiave, "workspace": workspace,
+            "modello": _valore(radice, "NOEVA_INFERENZA_MODELLO", MODELLO_PREDEFINITO),
+            "api": _valore(radice, "NOEVA_API", API_PREDEFINITA).rstrip("/")}
+
+
+def converse(radice: Path, sistema: str, testo: str, *, funzione: str, max_token: int = 8000,
+             tempo_max: int = 600) -> str:
+    """Una domanda e la sua risposta in testo, dall'inferenza NOEVA."""
+    c = configurazione(radice)
+    corpo = {
+        "system": [{"text": sistema}],
+        "messages": [{"role": "user", "content": [{"text": testo}]}],
+        "inferenceConfig": {"maxTokens": max_token},
+        "noevaTrace": {"name": f"Analytics: {funzione}", "tags": ["noeva-analytics", funzione],
+                       "metadata": {"prodotto": "analytics", "funzione": funzione}},
+    }
+    richiesta = urllib.request.Request(
+        f"{c['api']}/api/inference/model/{urllib.parse.quote(c['modello'], safe='')}/converse",
+        data=json.dumps(corpo).encode("utf-8"), method="POST",
+        headers={"Authorization": f"Bearer {c['chiave']}", "x-noeva-workspace": c["workspace"],
+                 "Content-Type": "application/json"})
+    for tentativo in range(1, TENTATIVI + 1):
+        try:
+            with urllib.request.urlopen(richiesta, timeout=tempo_max) as r:
+                esito = json.loads(r.read().decode("utf-8"))
+            break
+        except urllib.error.HTTPError as e:
+            # l'orchestratore a volte risponde 500 senza motivo: si riprova; 4xx sono risposte vere
+            if e.code < 500 or tentativo == TENTATIVI:
+                raise ErroreInferenza(f"inferenza NOEVA {e.code}: {e.read().decode(errors='replace')[:300]}")
+        except urllib.error.URLError as e:
+            if tentativo == TENTATIVI:
+                raise ErroreInferenza(f"inferenza NOEVA non raggiungibile: {e.reason}")
+        time.sleep(1.5 * tentativo)
+    blocchi = ((esito.get("output") or {}).get("message") or {}).get("content") or []
+    risposta = "".join(b.get("text", "") for b in blocchi if isinstance(b, dict)).strip()
+    if not risposta:
+        raise ErroreInferenza("risposta vuota dall'inferenza NOEVA")
+    return risposta

package/contenuto/lib/mcp-locale/costruisci.py

@@ -261,6 +261,10 @@ def argomenti_pyinstaller(nome: str, build: pathlib.Path) -> list:
         # e dal repository si compila con le trasformazioni di lib/modello/consegna.py.
         "--paths", QUI / "server", "--paths", QUI.parent / "modello",
         "--hidden-import", "modello_locale", "--hidden-import", "consegna", "--hidden-import", "scheda",
+        # Le query in thread, col tempo massimo e l'annullamento (server/esecuzione.py);
+        # la scheda legge le regole delle query da istruzioni.json, che sta accanto al modulo.
+        "--hidden-import", "esecuzione", "--hidden-import", "istruzioni",
+        "--add-data", f"{QUI.parent / 'modello' / 'istruzioni.json'}{os.pathsep}.",
         QUI / "server" / "noeva_mcp.py",
     ]
 

package/contenuto/lib/mcp-locale/server/esecuzione.py

@@ -0,0 +1,405 @@
+"""Come il servizio locale esegue le query: piu' connessioni, un tempo massimo, l'annullamento.
+
+L'11/11/2026 il connettore di un cliente e' rimasto fermo mezz'ora: quattro query pesanti
+lanciate in parallelo, nessuna finita, e nel frattempo nessuna risposta, nemmeno
+alle richieste piu' semplici. Il motivo: nel server MCP di Wren (wrenai 0.15) gli
+strumenti sono funzioni sincrone, e FastMCP (mcp 1.30) le chiama dentro l'event
+loop. Una query lunga fermava tutto il processo: le altre richieste, i ping e
+l'annullamento di Claude. Da fuori sembrava spento.
+
+Qui gli strumenti che toccano il database (run_sql, dry_run, query_cube) diventano
+asincroni e girano in un gruppo di thread, ognuno con il suo motore e la sua
+connessione:
+
+- una query lenta occupa un thread, le altre passano sugli altri (`connessioni`,
+  3 per il database vivo);
+- ogni query ha un tempo massimo (`limite_query_s`, 120 s): lo fa rispettare il
+  driver ODBC (il timeout della connessione, che su SQL Server annulla davvero la
+  query sul server); se non bastasse, allo scadere piu' un margine il servizio
+  annulla il cursore lui stesso e risponde comunque;
+- quando Claude annulla la richiesta MCP (notifications/cancelled) il servizio
+  annulla il cursore: la query si ferma anche sul database;
+- l'errore del tempo scaduto dice a Claude cosa fare: ridurre il periodo, non
+  rilanciare la stessa query ne' spezzarla in parallelo.
+
+Le query in corso stanno in un file di stato nella cartella temporanea, riscritto
+ogni pochi secondi da un thread a parte: `--verifica` lo legge e dice se una query
+e' in corso da troppo tempo (stato_in_corso).
+
+Niente qui importa mcp o wren: si prova con un motore finto (test/test_esecuzione.py).
+Niente stampa su stdout: e' il canale MCP.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import pathlib
+import tempfile
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Callable
+
+LIMITE_S = 120
+CONNESSIONI = 3
+# Oltre il limite del driver: il tempo che il driver ha per annullare e rispondere
+# prima che il servizio annulli il cursore da se'.
+MARGINE_S = 15
+# Ogni quanto il file di stato si riscrive; oltre STATO_VECCHIO_S il servizio che lo
+# scriveva non c'e' piu'.
+BATTITO_S = 5
+STATO_VECCHIO_S = 60
+
+# Gli strumenti di Wren che vanno sul database.
+STRUMENTI_DB = ("run_sql", "dry_run", "query_cube")
+
+REGOLE = (
+    "Il database e' quello di produzione, che usa anche il gestionale: ogni query ha un tempo "
+    "massimo di {minuti}. Prima prova la query su un mese, poi allarga all'anno. Una query pesante "
+    "alla volta, mai in parallelo. Aggrega ogni tabella (GROUP BY) prima di unirla alle altre: mai "
+    "un join riga per riga tra tabelle grandi (per esempio listino e fatture). Se una query va in "
+    "timeout riduci il periodo o le colonne, non spezzarla in piu' query in parallelo."
+)
+
+
+def minuti(secondi: float) -> str:
+    if secondi % 60 == 0:
+        m = int(secondi // 60)
+        return "1 minuto" if m == 1 else f"{m} minuti"
+    return f"{int(secondi)} secondi"
+
+
+def regole_testo(limite_s: float = LIMITE_S) -> str:
+    return REGOLE.format(minuti=minuti(limite_s))
+
+
+class TempoScaduto(Exception):
+    """La query ha superato il tempo massimo ed e' stata annullata."""
+
+    def __init__(self, limite_s: float):
+        super().__init__(
+            f"NOEVA ha fermato la query dopo {minuti(limite_s)}, il tempo massimo, e l'ha annullata anche "
+            "sul database. Non rilanciarla uguale e non dividerla in piu' query da lanciare in parallelo: "
+            "finirebbero in coda e scadrebbero anche quelle. Riducila: prova su un solo mese, poi allarga; "
+            "aggrega ogni tabella (GROUP BY) prima di unirla alle altre, mai un join riga per riga "
+            "(per esempio listino con fatture); togli le colonne che non servono."
+        )
+
+
+def e_un_timeout(e: BaseException | None) -> bool:
+    """Il timeout del driver, dentro gli errori che Wren avvolge (WrenError, DatabaseTimeoutError)."""
+    visti = 0
+    while e is not None and visti < 10:
+        if isinstance(e, (TimeoutError, TempoScaduto)) or type(e).__name__ == "DatabaseTimeoutError":
+            return True
+        testo = str(e)
+        if "HYT00" in testo or "timeout expired" in testo.lower():
+            return True
+        e = e.__cause__ or e.__context__
+        visti += 1
+    return False
+
+
+def connessione_persa(e: BaseException | None) -> bool:
+    """Errori dopo i quali la connessione non serve piu' (rete, server riavviato)."""
+    visti = 0
+    while e is not None and visti < 10:
+        testo = str(e)
+        if any(s in testo for s in ("08S01", "08003", "08001", "Communication link failure")):
+            return True
+        e = e.__cause__ or e.__context__
+        visti += 1
+    return False
+
+
+class Annullabile:
+    """Una connessione pyodbc che ricorda il cursore in uso, per annullarlo da un altro thread.
+
+    Il connettore MSSQL di Wren apre un cursore per query e non lo espone;
+    pyodbc permette Cursor.cancel() da un altro thread, ed e' il modo di fermare
+    la query sul server."""
+
+    def __init__(self, connessione: Any):
+        object.__setattr__(self, "_connessione", connessione)
+        object.__setattr__(self, "corrente", None)
+
+    def cursor(self, *a, **k):
+        c = self._connessione.cursor(*a, **k)
+        object.__setattr__(self, "corrente", c)
+        return c
+
+    def annulla(self) -> None:
+        c = self.corrente
+        if c is not None:
+            try:
+                c.cancel()
+            except Exception:  # noqa: BLE001 - cursore gia' chiuso: niente da annullare
+                pass
+
+    def __getattr__(self, nome: str):
+        return getattr(self._connessione, nome)
+
+    def __setattr__(self, nome: str, valore: Any) -> None:
+        setattr(self._connessione, nome, valore)
+
+
+def annulla_motore(motore: Any) -> None:
+    """Ferma la query in corso sul motore: il cursore su SQL Server, interrupt() su DuckDB."""
+    connettore = getattr(motore, "_connector", None)
+    conn = getattr(connettore, "connection", None)
+    if isinstance(conn, Annullabile):
+        conn.annulla()
+    elif conn is not None and hasattr(conn, "interrupt"):
+        try:
+            conn.interrupt()
+        except Exception:  # noqa: BLE001
+            pass
+
+
+def rendi_annullabile(motore: Any) -> Any:
+    """Avvolge la connessione del motore appena si apre (il connettore di Wren e' pigro)."""
+    originale = motore._get_connector
+
+    def apri():
+        c = originale()
+        conn = getattr(c, "connection", None)
+        if conn is not None and hasattr(conn, "cursor") and not hasattr(conn, "interrupt") \
+                and not isinstance(conn, Annullabile):
+            c.connection = Annullabile(conn)
+        return c
+
+    motore._get_connector = apri
+    return motore
+
+
+class Lavoro:
+    def __init__(self, descrizione: str):
+        self.descrizione = descrizione
+        self.creato = time.time()
+        self.inizio: float | None = None  # time.monotonic() quando un thread lo prende
+        self.inizio_epoch: float | None = None
+        self.annullato = False
+        self.motore: Any = None
+
+    def annulla(self) -> None:
+        self.annullato = True
+        if self.motore is not None:
+            annulla_motore(self.motore)
+
+
+def _lascia(futuro: asyncio.Future) -> None:
+    """Un lavoro che non si attende piu': il suo errore (l'annullamento) non va nel log."""
+    futuro.add_done_callback(lambda f: f.cancelled() or f.exception())
+
+
+class Postazioni:
+    """I thread che eseguono le query, ognuno col suo motore e la sua connessione.
+
+    `crea_motore()` fa un motore nuovo (senza aprire la connessione: Wren la apre
+    alla prima query). `motore()` e' quello del thread corrente: nei thread delle
+    query il suo, altrove quello di base, che serve agli strumenti senza database
+    (dry_plan, list_functions) e non apre mai una connessione."""
+
+    def __init__(self, crea_motore: Callable[[], Any], connessioni: int = CONNESSIONI,
+                 limite_s: float = LIMITE_S, margine_s: float = MARGINE_S,
+                 stato: pathlib.Path | None = None, server: str = ""):
+        self._crea = crea_motore
+        self.connessioni = max(1, int(connessioni))
+        self.limite_s = float(limite_s)
+        self.margine_s = float(margine_s)
+        self._locale = threading.local()
+        self._motori: list[Any] = []
+        self._blocco = threading.Lock()
+        self._lavori: set[Lavoro] = set()
+        self._pool = ThreadPoolExecutor(max_workers=self.connessioni, thread_name_prefix="noeva-query")
+        self.base = crea_motore()
+        self.server = server
+        self.stato = stato
+        self._fermo = threading.Event()
+        if stato is not None:
+            threading.Thread(target=self._battito, name="noeva-stato", daemon=True).start()
+
+    # --- i motori ---------------------------------------------------------------
+    def motore(self) -> Any:
+        m = getattr(self._locale, "motore", None)
+        return m if m is not None else self.base
+
+    def _motore_del_thread(self) -> Any:
+        m = getattr(self._locale, "motore", None)
+        if m is None:
+            m = rendi_annullabile(self._crea())
+            self._locale.motore = m
+            with self._blocco:
+                self._motori.append(m)
+        return m
+
+    # --- l'esecuzione -------------------------------------------------------------
+    def _lavora(self, lavoro: Lavoro, fn: Callable[[], Any]) -> Any:
+        if lavoro.annullato:
+            raise asyncio.CancelledError("annullata prima di partire")
+        m = self._motore_del_thread()
+        lavoro.motore = m
+        lavoro.inizio = time.monotonic()
+        lavoro.inizio_epoch = time.time()
+        try:
+            return fn()
+        except Exception as e:
+            if connessione_persa(e):
+                # La prossima query riapre la connessione invece di fallire per sempre.
+                try:
+                    m.close()
+                except Exception:  # noqa: BLE001
+                    pass
+            if e_un_timeout(e):
+                raise TempoScaduto(self.limite_s) from e
+            raise
+        finally:
+            lavoro.motore = None
+
+    async def esegui(self, fn: Callable[[], Any], descrizione: str = "") -> Any:
+        """Esegue fn in un thread delle query; fn usa motore(), cioe' il motore di quel thread.
+
+        Il tempo si conta da quando un thread prende il lavoro, non dalla coda: in
+        coda si aspetta che una query finisca o scada."""
+        lavoro = Lavoro(descrizione)
+        with self._blocco:
+            self._lavori.add(lavoro)
+        futuro = asyncio.wrap_future(self._pool.submit(self._lavora, lavoro, fn))
+        try:
+            while True:
+                fatti, _ = await asyncio.wait({futuro}, timeout=0.5)
+                if fatti:
+                    return futuro.result()
+                if lavoro.inizio is not None and time.monotonic() - lavoro.inizio > self.limite_s + self.margine_s:
+                    # Il driver non l'ha fermata (la lettura delle righe, un driver
+                    # senza timeout): la si annulla da qui e si risponde comunque.
+                    lavoro.annulla()
+                    _lascia(futuro)
+                    raise TempoScaduto(self.limite_s)
+        except asyncio.CancelledError:
+            # Claude ha annullato la richiesta: la query si ferma anche sul database.
+            lavoro.annulla()
+            futuro.cancel()
+            _lascia(futuro)
+            raise
+        finally:
+            with self._blocco:
+                self._lavori.discard(lavoro)
+
+    def chiudi(self) -> None:
+        self._fermo.set()
+        with self._blocco:
+            lavori = list(self._lavori)
+            motori = list(self._motori)
+        for lv in lavori:
+            lv.annulla()
+        self._pool.shutdown(wait=False, cancel_futures=True)
+        for m in [*motori, self.base]:
+            try:
+                m.close()
+            except Exception:  # noqa: BLE001
+                pass
+        if self.stato is not None:
+            try:
+                self.stato.unlink()
+            except OSError:
+                pass
+
+    # --- lo stato per --verifica ----------------------------------------------------
+    def fotografia(self) -> dict:
+        with self._blocco:
+            lavori = list(self._lavori)
+        return {
+            "server": self.server,
+            "pid": os.getpid(),
+            "aggiornato": time.time(),
+            "limite_s": self.limite_s,
+            "connessioni": self.connessioni,
+            "lavori": [
+                {"in_coda": lv.inizio_epoch is None, "dal": lv.inizio_epoch or lv.creato,
+                 "query": lv.descrizione[:300]}
+                for lv in sorted(lavori, key=lambda x: x.creato)
+            ],
+        }
+
+    def _battito(self) -> None:
+        while not self._fermo.is_set():
+            scrivi_stato(self.stato, self.fotografia())
+            self._fermo.wait(BATTITO_S)
+
+
+class MotoreCorrente:
+    """Al posto di ctx.engine negli strumenti di Wren: il motore del thread che li esegue."""
+
+    def __init__(self, postazioni: Postazioni):
+        object.__setattr__(self, "_postazioni", postazioni)
+
+    def __getattr__(self, nome: str):
+        return getattr(self._postazioni.motore(), nome)
+
+
+def rendi_asincroni(server: Any, postazioni: Postazioni, regole: bool = True) -> list[str]:
+    """Gli strumenti di Wren che vanno sul database, eseguiti nei thread delle query.
+
+    FastMCP chiama `fn(**argomenti)` e la attende se `is_async`: la funzione
+    sincrona di Wren resta quella, con lo stesso schema degli argomenti, e gira in
+    Postazioni.esegui. A run_sql si aggiungono le regole delle query."""
+    strumenti = server._tool_manager._tools
+    fatti = []
+    for nome in STRUMENTI_DB:
+        t = strumenti.get(nome)
+        if t is None:
+            continue
+
+        def avvolgi(sincrona: Callable[..., Any]) -> Callable[..., Any]:
+            async def asincrona(**argomenti):
+                descrizione = argomenti.get("sql") or json.dumps(argomenti, ensure_ascii=False, default=str)
+                return await postazioni.esegui(lambda: sincrona(**argomenti), str(descrizione))
+            return asincrona
+
+        t.fn = avvolgi(t.fn)
+        t.is_async = True
+        if nome == "run_sql" and regole:
+            t.description = f"{t.description.rstrip()}\n\n{regole_testo(postazioni.limite_s)}"
+        fatti.append(nome)
+    return fatti
+
+
+def cartella_stato() -> pathlib.Path:
+    return pathlib.Path(os.environ.get("NOEVA_STATO") or tempfile.gettempdir()) / "noeva-stato"
+
+
+def file_stato(server: str, pid: int | None = None) -> pathlib.Path:
+    return cartella_stato() / f"{server}-{pid or os.getpid()}.json"
+
+
+def scrivi_stato(percorso: pathlib.Path, dati: dict) -> None:
+    try:
+        percorso.parent.mkdir(parents=True, exist_ok=True)
+        tmp = percorso.with_suffix(".tmp")
+        tmp.write_text(json.dumps(dati, ensure_ascii=False), encoding="utf-8")
+        os.replace(tmp, percorso)
+    except OSError:
+        pass  # lo stato serve a --verifica, non al servizio
+
+
+def stato_in_corso(server: str, ora: float | None = None) -> list[dict]:
+    """Gli stati dei servizi vivi di questo server; quelli fermi da tempo si cancellano."""
+    ora = ora or time.time()
+    vivi = []
+    for f in sorted(cartella_stato().glob(f"{server}-*.json")):
+        try:
+            dati = json.loads(f.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            continue
+        if dati.get("server") != server:
+            continue  # un altro server con un nome che comincia allo stesso modo
+        if ora - float(dati.get("aggiornato") or 0) > STATO_VECCHIO_S:
+            try:
+                f.unlink()
+            except OSError:
+                pass
+            continue
+        vivi.append(dati)
+    return vivi

package/contenuto/lib/mcp-locale/server/noeva_mcp.py

@@ -18,7 +18,14 @@ dashboard su DuckDB come ripiego offline.
     noeva-<id> --sorgente erp       serve MCP su stdio (lo lancia Claude Code)
     noeva-<id> --verifica           controlla driver, password e connessione di
                                     tutte le sorgenti e dice cosa manca: si lancia
-                                    a mano dal PowerShell quando /mcp dice "failed"
+                                    a mano dal PowerShell quando /mcp dice "failed";
+                                    dice anche se il servizio aperto in Claude ha una
+                                    query in corso da troppo tempo
+
+Le query girano in piu' thread, ognuno con la sua connessione, con un tempo
+massimo e l'annullamento sul database (esecuzione.py): una query lenta non ferma
+piu' le altre. In noeva.json, per sorgente: `limite_query_s` (default 120) e
+`connessioni` (default 3; 1 per lo snapshot). NOEVA_LIMITE_QUERY_S forza il limite.
 
 Su stdio lo stdout e' il canale del protocollo: fuori da --verifica qui non si
 stampa niente, i log vanno su stderr.
@@ -31,6 +38,7 @@ import json
 import os
 import pathlib
 import sys
+import time
 
 # Congelato da PyInstaller la cartella e' quella dell'eseguibile; da sorgente,
 # quella sopra server/. NOEVA_DIR la forza (per provare da un'altra macchina).
@@ -53,6 +61,13 @@ class Problema(Exception):
     """Un errore di configurazione da spiegare a chi installa, non uno stack."""
 
 
+def limite_query(s: dict) -> float:
+    """Il tempo massimo di una query, in secondi."""
+    import esecuzione
+
+    return float(os.environ.get("NOEVA_LIMITE_QUERY_S") or s.get("limite_query_s") or esecuzione.LIMITE_S)
+
+
 def configurazione() -> dict:
     p = QUI / "noeva.json"
     if not p.is_file():
@@ -95,11 +110,20 @@ def connessione_mssql(s: dict) -> dict:
         "user": utente or None,
         "password": password or None,
         "driver": driver,
-        "kwargs": {"TrustServerCertificate": "yes", **(s.get("opzioni") or {})},
+        # statement_timeout diventa il timeout della connessione pyodbc: allo
+        # scadere il driver annulla la query sul server (esecuzione.py).
+        "kwargs": {"TrustServerCertificate": "yes", "statement_timeout": str(int(limite_query(s))),
+                   **(s.get("opzioni") or {})},
     }
 
 
 def motore(s: dict):
+    progetto, crea = fabbrica(s)
+    return progetto, crea()
+
+
+def fabbrica(s: dict):
+    """(progetto, crea_motore): il modello si cerca una volta, i motori si fanno uguali."""
     from wren.engine import WrenEngine
 
     import modello_locale
@@ -119,27 +143,36 @@ def motore(s: dict):
             raise Problema(f"nessun .duckdb in {dati}")
         # Il connettore DuckDB attacca in sola lettura ogni .duckdb della
         # cartella, con alias = nome del file: e' il catalogo del modello.
-        eng = WrenEngine(manifest_str=manifest, data_source="duckdb",
-                         connection_info={"url": str(dati), "format": "duckdb"})
-    else:
-        eng = WrenEngine(manifest_str=manifest, data_source="mssql", connection_info=connessione_mssql(s))
-    return progetto, eng
+        return progetto, lambda: WrenEngine(manifest_str=manifest, data_source="duckdb",
+                                            connection_info={"url": str(dati), "format": "duckdb"})
+    info = connessione_mssql(s)
+    return progetto, lambda: WrenEngine(manifest_str=manifest, data_source="mssql", connection_info=info)
 
 
 def servi(conf: dict, nome: str) -> None:
     s = conf["sorgenti"][nome]
-    progetto, eng = motore(s)
+    progetto, crea = fabbrica(s)
+    import esecuzione
+    import modello_locale
     from wren.mcp_server import ServeContext, build_server
 
-    server = build_server(ServeContext(project=progetto, engine=eng, allow_write=False, no_connect=False))
+    limite = limite_query(s)
+    postazioni = esecuzione.Postazioni(
+        crea, connessioni=s.get("connessioni") or (esecuzione.CONNESSIONI if s["tipo"] == "mssql" else 1),
+        limite_s=limite, stato=esecuzione.file_stato(s["server"]), server=s["server"])
+    # Gli strumenti di Wren leggono ctx.engine: il motore del thread che li esegue.
+    server = build_server(ServeContext(project=progetto, engine=esecuzione.MotoreCorrente(postazioni),
+                                       allow_write=False, no_connect=False))
+    esecuzione.rendi_asincroni(server, postazioni, regole=s["tipo"] == "mssql")
     # FastMCP non espone un setter: nome e istruzioni stanno sul server di basso
     # livello, ed e' quello che il client legge all'initialize.
     server._mcp_server.name = s["server"]
     server._mcp_server.instructions = s["istruzioni"]
+    modello_locale.log(f"{s['server']}: {postazioni.connessioni} connessioni, query fermate dopo {int(limite)} s")
     try:
         server.run(transport="stdio")
     finally:
-        eng.close()
+        postazioni.chiudi()
 
 
 def verifica(conf: dict, nomi: list[str]) -> int:
@@ -170,10 +203,48 @@ def verifica(conf: dict, nomi: list[str]) -> int:
                 falliti += 1
                 break
         eng.close()
+        if not query_in_corso(s):
+            falliti += 1
     print("\ntutto a posto" if not falliti else f"\n{falliti} sorgente/i con problemi")
     return 1 if falliti else 0
 
 
+def query_in_corso(s: dict) -> bool:
+    """Le query del servizio aperto in Claude (il file di stato di esecuzione.py).
+
+    Falso se una e' in corso da oltre il tempo massimo: il servizio dovrebbe
+    averla gia' fermata, quindi e' bloccato."""
+    import esecuzione
+
+    vivi = esecuzione.stato_in_corso(s["server"])
+    if not vivi:
+        print("  ..  servizio in Claude: non aperto, o di una versione che non lo dice")
+        return True
+    ora = time.time()
+    bene = True
+    for st in vivi:
+        lavori = st.get("lavori") or []
+        limite = float(st.get("limite_s") or esecuzione.LIMITE_S)
+        if not lavori:
+            print(f"  ok  servizio in Claude (processo {st.get('pid')}): nessuna query in corso")
+            continue
+        in_coda = sum(1 for lv in lavori if lv.get("in_coda"))
+        for lv in lavori:
+            if lv.get("in_coda"):
+                continue
+            durata = ora - float(lv.get("dal") or ora)
+            testo = " ".join(str(lv.get("query") or "").split())[:160]
+            if durata > limite + esecuzione.MARGINE_S + esecuzione.BATTITO_S:
+                bene = False
+                print(f"  NO  query in corso da {int(durata // 60)} min {int(durata % 60)} s, oltre il massimo "
+                      f"di {esecuzione.minuti(limite)}: il servizio e' bloccato, chiudi e riapri Claude. Query: {testo}")
+            else:
+                print(f"  ..  query in corso da {int(durata)} s: {testo}")
+        if in_coda:
+            print(f"  ..  {in_coda} query in coda (connessioni: {st.get('connessioni')})")
+    return bene
+
+
 def main(argv: list[str] | None = None) -> int:
     ap = argparse.ArgumentParser(prog=pathlib.Path(sys.argv[0]).stem)
     ap.add_argument("--sorgente", help="quale database servire (default: la prima di noeva.json)")