@noeva/analytics-core 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -3,6 +3,46 @@
 Le versioni del pacchetto che i repository dei progetti installano (ADR 0005). Prima di
 `analytics upgrade` si legge cosa cambia fra la versione installata e la nuova.
 
+## 0.5.0 — 12 novembre 2026
+
+- **L'AI passa solo da NOEVA.** I moduli di pagina non offrono piu' la CLI di Claude:
+  `inferenza.js` ha solo NOEVA · database e NOEVA · snapshot, `chat.js` risponde solo
+  dall'inferenza NOEVA (o NOEVA Agents), `commento.js` fa il tour solo con l'inferenza
+  (il tour di prova, `?commento=prova`, si costruisce nella pagina, senza AI).
+- **La presentazione con l'inferenza NOEVA**: scaletta e modifiche in chat passano da
+  `ai/converse` come tour e chat, anche sul sito pubblicato; le partenze arrivano col
+  prompt. `lib/snapshot/ai.py` scrive anche
+  `apps/dati/ai/presentazione-<pagina>.<lingua>.json` da `presentazione.py`
+  (`istruzioni`, `LINGUE`, `SCHEMA`, `SCHEMA_MODIFICA`, `PRESET`, `MODIFICA`). Le
+  scalette gia' pronte restano buone e si usano prima.
+- `analytics ci` si ferma se un file del progetto lancia la CLI di Claude, chiama
+  un'API di modelli diretta (Anthropic, OpenAI, Bedrock, Gemini) o se `serve-app.py`
+  serve `/ai/chat`, `/ai/chat/storia`, `/ai/tour`, `/ai/presentazione/modifica`. Non
+  c'e' eccezione da dichiarare.
+- Prima di aggiornare, nel progetto: `chat.py`, `commento.py` e `presentazione.py`
+  tengono solo prompt, regole e schema (niente `subprocess`, niente `claude`);
+  `serve-app.py` toglie le rotte della CLI; si rilancia `ai.py` per i prompt della
+  presentazione. Le frasi nuove da tradurre in `en.js`: «Tappa di prova, senza AI.»,
+  «Tour di prova», «Sistema con l'AI», «Sto scrivendo la scaletta…», «Sto scrivendo la
+  scaletta: di solito uno o due minuti, tre per l'analisi completa.», «la presentazione
+  non ha slide», «il prompt della presentazione di questa pagina non è pronto»,
+  «partenza sconosciuta: {p}», «la richiesta è troppo lunga: massimo 2000 caratteri»,
+  «l'AI di questo progetto non è configurata», «per questa vista non c'è una scaletta
+  pronta e l'AI di questo progetto non è attiva», «per questa vista non c'è un commento
+  pronto e l'AI di questo progetto non è attiva», «La presentazione è pronta: {n} slide.
+  Qui la sfogli, la presenti e generi il PowerPoint; la chat per sistemarla c'è dove
+  l'AI del progetto è attiva.».
+- Tolto `lib/snapshot/misura-memoria.py` (lanciava la CLI).
+- `lib/ai/inferenza.py` (in `contenuto/lib/ai/`): l'inferenza NOEVA da Python per gli
+  strumenti del progetto sul Mac che non sono pagine (es. la traduzione della knowledge
+  base). `converse(radice, sistema, testo, funzione=...)`; la chiave
+  `NOEVA_INFERENZA_CHIAVE` sta nell'ambiente o in `.wren/.env`, il workspace in
+  `analytics.json`, il modello in `NOEVA_INFERENZA_MODELLO` (predefinito Haiku 5.5).
+- Anche, da lavori di altre sessioni dopo la 0.4.1: `vista.js` scrive il titolo della
+  barra senza il separatore iniziale («· Vendite e CRM» → «Vendite e CRM»); il worker
+  degli snapshot ha `ultimi-giri.ps1` (gli ultimi giri e il loro esito sulla macchina del
+  cliente) e `installa.ps1` chiede la password Windows in console.
+
 ## 0.4.1 — 10 novembre 2026
 
 - `voce.js`: `montaSceltaVoce("#voce", { lingue: ["it"] })` mostra solo le lingue in cui

package/contenuto/assets/chat.js

@@ -9,17 +9,17 @@
  * nella testa e ricordati nel browser per tutte le pagine (VISTE): laterale (il
  * default), meta' schermo con il report che si stringe accanto, schermo intero, e
  * finestra mobile da trascinare e ridimensionare sopra il report. Sotto i 768 px
- * e' sempre a schermo intero. Ogni domanda va a
- * serve-app.py (/ai/chat, chat.py) con i filtri e il contesto della pagina, come
- * per il commento; la risposta arriva in streaming e si vede mentre viene scritta,
- * con le query eseguite in chiaro sotto ogni risposta. La sessione e' vera: la
- * CLI ricorda le domande precedenti, e ricaricando la pagina si riprende
- * l'ultima conversazione (l'id sta in localStorage, la storia sul server).
+ * e' sempre a schermo intero. Ogni domanda va all'inferenza NOEVA (ai/converse
+ * del contenitore) con i filtri e il contesto della pagina e il prompt di chat.py
+ * esportato da lib/snapshot/ai.py; la pagina tiene il giro, con run_sql sullo
+ * snapshot o sul database vivo (serve-app.py, Mac), e mostra le query eseguite
+ * sotto ogni risposta. Mai la CLI di Claude. La conversazione sta nel browser e
+ * ricaricando la pagina si riprende.
  *
- * Solo sul Mac: dietro il cancello il server non c'e' e il pulsante non compare.
+ * Senza inferenza la chat passa a NOEVA Agents, se c'e'; altrimenti non compare.
  */
 import { contesto } from "./commento.js";
-import { conServer, rotta, fileDati, sha256 } from "./servizio.js";
+import { fileDati, sha256 } from "./servizio.js";
 import { giro, nuovaSessione, motori, motoreScelto, selettoreMotore } from "./inferenza.js";
 import { t, LINGUA } from "./lingua.js";
 import { PROGETTO } from "./progetto.js";
@@ -127,9 +127,9 @@ export function montaChat({ pagina }) {
   if (document.getElementById("chat")) return;
   const barra = document.querySelector(".topbar");
   if (!barra) return;
-  // Il pannello compare dove qualcuno puo' rispondere: NOEVA Agents (ADR 0006,
-  // dove il contenitore lo offre), l'inferenza NOEVA del contenitore (anche sul
-  // sito pubblicato) o, senza, il server sul Mac.
+  // Il pannello compare dove qualcuno puo' rispondere, sempre da NOEVA: NOEVA
+  // Agents (ADR 0006, dove il contenitore lo offre) o l'inferenza NOEVA del
+  // contenitore. Senza nessuno dei due la chat non c'e'.
   // Al caricamento basta sapere se NOEVA Agents c'e': il token si chiede quando
   // la chat si apre (NW-1279).
   agentiDisponibili().then(async (a) => {
@@ -168,8 +168,7 @@ export function montaChat({ pagina }) {
     let montato = null;
     if (agenti) for (const s of ["#ch-msgs", "#ch-stato", "#ch-form", "#ch-nuova"]) $(s).remove();
     const CHIAVE = `${PROGETTO.id}-chat-${pagina}-${LINGUA}`;
-    const st = { sessione: null, inCorso: null, msgs: [] };
-    try { st.sessione = localStorage.getItem(CHIAVE); } catch { /* niente memoria */ }
+    const st = { inCorso: null, msgs: [] };
     // Con l'inferenza la conversazione sta nel browser: i turni (quello che si
     // e' mandato al modello e quello che ha risposto), l'impronta del contesto
     // dell'ultima domanda e l'id di sessione del trace.
@@ -178,8 +177,7 @@ export function montaChat({ pagina }) {
     const scriviAI = (c) => { try { localStorage.setItem(CHIAVE_AI, JSON.stringify(c)); } catch { /* piena: si perde la memoria, non la risposta */ } };
     const nuovaAI = () => ({ sessione: nuovaSessione("chat", pagina), impronta: "", turni: [] });
     // Il motore si legge a ogni domanda: il selettore (sul Mac) lo puo' cambiare.
-    // Le due modalita' NOEVA condividono la conversazione; la CLI ha la sua.
-    const conNoeva = async () => (await motoreScelto())?.startsWith("noeva");
+    // Le due modalita' NOEVA condividono la conversazione.
     if (!agenti) {
       selettoreMotore({ classe: "ch" }).then((sel) => sel && $("#ch-nuova").before(sel));
       addEventListener("noeva-motore", () => { if (!st.inCorso) riprendi(); });
@@ -208,30 +206,15 @@ export function montaChat({ pagina }) {
 
     async function riprendi() {
       $("#ch-msgs").innerHTML = "";
-      if (await conNoeva()) {
-        const c = leggiAI();
-        for (const x of c?.turni || []) {
-          if (x.ruolo === "utente") utente(x.testo); else await claude(messaggio("claude"), x.testo, x.strumenti || []);
-        }
-        if (c?.turni?.length) { stato(t("conversazione ripresa")); return; }
-        suggerimenti();
-        return;
-      }
-      if (st.sessione) {
-        try {
-          const r = await fetch(rotta(`ai/chat/storia?sessione=${encodeURIComponent(st.sessione)}`), { cache: "no-store" });
-          const j = await r.json();
-          if (!r.ok || j.errore) throw new Error(j.errore || r.status);
-          for (const x of j.messaggi || []) {
-            if (x.ruolo === "utente") utente(x.testo); else await claude(messaggio("claude"), x.testo, x.strumenti || []);
-          }
-          if ((j.messaggi || []).length) { stato(t("conversazione ripresa")); return; }
-        } catch { nuova(false); }
+      const c = leggiAI();
+      for (const x of c?.turni || []) {
+        if (x.ruolo === "utente") utente(x.testo); else await claude(messaggio("claude"), x.testo, x.strumenti || []);
       }
+      if (c?.turni?.length) { stato(t("conversazione ripresa")); return; }
       suggerimenti();
     }
     function nuova(pulisci = true) {
-      st.sessione = null;
+      // CHIAVE era l'id della sessione della CLI, nelle versioni prima della 0.5.0
       try { localStorage.removeItem(CHIAVE); localStorage.removeItem(CHIAVE_AI); } catch { /* */ }
       if (pulisci) { $("#ch-msgs").innerHTML = ""; suggerimenti(); stato(""); $("#ch-testo").focus(); }
     }
@@ -337,39 +320,12 @@ export function montaChat({ pagina }) {
       stato(t("Claude legge la pagina…"));
       const t0 = performance.now();
       const orologio = setInterval(() => stato(`${t("Claude sta rispondendo…")} ${Math.round((performance.now() - t0) / 1000)} s`), 1000);
-      let testo = "", strumenti = [], fine = null, errore = null;
       try {
         const motore = await motoreScelto();
-        if (motore?.startsWith("noeva")) {
-          const g = await domandaAI(domanda, motore === "noeva-vivo" ? "vivo" : "snapshot", ctrl.signal, (s) => { strumenti.push(s); stato(t("interrogo il modello…")); });
-          await claude(m, g.risultato, g.strumenti);
-          stato(`${Math.round((performance.now() - t0) / 1000)} s` + (g.turni > 1 ? ` · ${t("{n} passaggi", { n: g.turni })}` : ""));
-          return;
-        }
-        const r = await fetch(rotta("ai/chat"), { method: "POST", headers: { "content-type": "application/json" }, signal: ctrl.signal,
-          body: JSON.stringify({ pagina, lingua: LINGUA, sessione: st.sessione, domanda, contesto: contesto() }) });
-        if (!r.ok) throw new Error(`${r.status}`);
-        const lettore = r.body.getReader(), dec = new TextDecoder();
-        let resto = "";
-        for (;;) {
-          const { value, done } = await lettore.read();
-          if (done) break;
-          resto += dec.decode(value, { stream: true });
-          const righe = resto.split("\n"); resto = righe.pop();
-          for (const riga of righe) {
-            if (!riga.trim()) continue;
-            let ev; try { ev = JSON.parse(riga); } catch { continue; }
-            if (ev.tipo === "sessione") { st.sessione = ev.sessione; try { localStorage.setItem(CHIAVE, ev.sessione); } catch { /* */ } }
-            else if (ev.tipo === "testo") { testo += ev.testo; m.textContent = testo; giu(); }
-            else if (ev.tipo === "strumento") { strumenti.push(ev); stato(ev.sql ? t("interrogo il modello…") : `${ev.nome}…`); }
-            else if (ev.tipo === "fine") fine = ev;
-            else if (ev.tipo === "errore") errore = ev.errore;
-          }
-        }
-        if (errore) throw new Error(errore);
-        if (!fine && !testo) throw new Error(t("nessuna risposta"));
-        await claude(m, fine?.testo || testo, strumenti);
-        stato(`${Math.round((performance.now() - t0) / 1000)} s` + (fine?.turni > 1 ? ` · ${t("{n} passaggi", { n: fine.turni })}` : ""));
+        if (!motore?.startsWith("noeva")) throw new Error(t("l'AI di questo progetto non è configurata"));
+        const g = await domandaAI(domanda, motore === "noeva-vivo" ? "vivo" : "snapshot", ctrl.signal, () => stato(t("interrogo il modello…")));
+        await claude(m, g.risultato, g.strumenti);
+        stato(`${Math.round((performance.now() - t0) / 1000)} s` + (g.turni > 1 ? ` · ${t("{n} passaggi", { n: g.turni })}` : ""));
       } catch (err) {
         m.classList.remove("scrive"); m.classList.add("errore");
         m.textContent = err.name === "AbortError" ? t("Fermata.") : t("Non ci sono riuscito: {errore}", { errore: err.message || err });

package/contenuto/assets/commento.js

@@ -13,10 +13,10 @@
  * tappa puo' indicare. Cosi' quello che Claude commenta e' esattamente quello
  * che il cliente vede, con i filtri di quel momento.
  *
- * Tour e voce li fa serve-app.py (/ai/tour, /ai/voce, vedi commento.py), con la
- * cache su disco: la vista iniziale, preparata prima, parte subito e senza rete.
- * Dietro il cancello il server non c'e': restano i tour e le voci gia' pronti,
- * trovati con la stessa chiave del server (servizio.js), e la voce la fa il
+ * Il tour lo scrive l'inferenza NOEVA (ai/converse del contenitore), con il
+ * prompt di commento.py esportato da lib/snapshot/ai.py: mai la CLI di Claude.
+ * I tour gia' pronti (dati/commento/, trovati con la chiave di servizio.js)
+ * partono prima e senza rete. La voce la fa serve-app.py sul Mac (/ai/voce) o il
  * contenitore (ai/voci, voce.js) con la voce scelta nella home del progetto.
  */
 import { conServer, chiaveServer, sha256, fileDati, urlDati, conLingua, rotta } from "./servizio.js";
@@ -223,12 +223,29 @@ tr.evid > td { background: color-mix(in srgb, var(--primary) 16%, var(--surface)
 @media (max-width: 560px) { #commento { right: 0; bottom: 0; max-width: 100vw; width: 100vw; } }
 `;
 
-// ?commento=prova nell'indirizzo: tour fisso costruito dai numeri della pagina, senza Claude
+// ?commento=prova nell'indirizzo: tour fisso costruito dai numeri della pagina, senza AI
 const PROVA = new URLSearchParams(location.search).get("commento") === "prova";
 
+/* Il tour di prova: per provare evidenziazioni e voce senza rete e senza
+ * inferenza. Due indicatori e un elemento per i grafici e le tabelle, al
+ * massimo quattro tappe. */
+export function tourDiProva(ctx) {
+  const tappe = [];
+  for (const r of ctx.riquadri || []) {
+    if (r.tipo === "indicatore" && tappe.length < 2) {
+      tappe.push({ target: r.id, valore: "", titolo: r.titolo, testo: `${r.titolo}: ${r.testo || ""}. ${t("Tappa di prova, senza AI.")}` });
+    } else if ((r.tipo === "grafico mensile" || r.tipo === "tabella") && r.elementi?.length) {
+      const el = r.elementi[Math.min(1, r.elementi.length - 1)];
+      tappe.push({ target: r.id, valore: el, titolo: `${r.titolo}: ${el}`, testo: `${r.titolo}: ${el}. ${t("Tappa di prova, senza AI.")}` });
+    }
+    if (tappe.length >= 4) break;
+  }
+  return { titolo: t("Tour di prova"), tappe, _motore: { tipo: "prova" } };
+}
+
 /* Il tour dall'inferenza NOEVA: il prompt di commento.py (esportato da
  * lib/snapshot/ai.py in dati/ai/), il contesto della pagina come richiesta,
- * e il giro con run_sql sullo snapshot. Come genera_tour sul Mac, le tappe su
+ * e il giro con run_sql sullo snapshot. Le tappe su
  * riquadri che la pagina non ha si scartano. */
 async function tourConInferenza(pagina, modo, ctx, dati, alPasso) {
   const p = await fileDati(`ai/commento-${pagina}.${LINGUA}.json`);
@@ -405,10 +422,13 @@ export function montaCommento({ pagina }) {
       // configurato) il tour si prepara qui, su qualunque vista; i tour gia'
       // pronti restano buoni e si usano prima, salvo Maiusc+Avvia.
       // Chi risponde: la modalita' scelta nel selettore (inferenza NOEVA sul
-      // database o sullo snapshot, o la CLI sul Mac); senza nessuna, i
-      // commenti gia' pronti. La prova (?commento=prova) passa dal server.
-      const motore = PROVA ? ((await conServer()) ? "cli" : null) : await motoreScelto();
-      if (motore?.startsWith("noeva")) {
+      // database o sullo snapshot); senza nessuna, i commenti gia' pronti.
+      // La prova (?commento=prova) si costruisce qui, senza AI.
+      const motore = PROVA ? "prova" : await motoreScelto();
+      if (motore === "prova") {
+        j = tourDiProva(ctx);
+        if (!j.tappe.length) throw new Error(t("il tour non ha tappe su riquadri della pagina"));
+      } else if (motore?.startsWith("noeva")) {
         const chiave = await chiaveServer(conLingua([pagina, st.modo, ctx]));
         j = forza ? null : await fileDati(`commento/tour-${pagina}-${st.modo}-${chiave}.json`);
         if (j) j._da_cache = true;
@@ -416,16 +436,11 @@ export function montaCommento({ pagina }) {
           if (gen !== st.gen) return;
           $("#cm-tappa").textContent = t("passaggio {n}", { n: p.turno }) + (p.query ? ` · ${t("{n} query", { n: p.query })}` : "");
         });
-      } else if (motore === "cli") {
-        const r = await fetch(rotta("ai/tour"), { method: "POST", headers: { "content-type": "application/json" },
-          body: JSON.stringify({ pagina, modo: st.modo, contesto: ctx, forza, lingua: LINGUA, ...(PROVA ? { motore: "prova" } : {}) }) });
-        j = await r.json();
-        if (!r.ok || j.errore) throw new Error(j.errore || r.status);
       } else {
         // dietro il cancello: solo i commenti gia' pronti, con la chiave che calcola il server
         const chiave = await chiaveServer(conLingua([pagina, st.modo, ctx]));
         j = await fileDati(`commento/tour-${pagina}-${st.modo}-${chiave}.json`);
-        if (!j) throw new Error(t("per questa vista non c'è un commento pronto: si prepara dal Mac, con questi filtri"));
+        if (!j) throw new Error(t("per questa vista non c'è un commento pronto e l'AI di questo progetto non è attiva"));
         j._da_cache = true;
       }
       if (gen !== st.gen) return;

package/contenuto/assets/inferenza.js

@@ -31,16 +31,16 @@ export function inferenza() {
 }
 
 /* --- il motore: chi risponde e su quali dati ---------------------------------------
- * Tre modalita', offerte solo se ci sono i pezzi:
+ * L'AI passa solo dall'inferenza NOEVA (ai/converse del contenitore): nessun
+ * modulo chiama la CLI di Claude o un'API di modelli diretta, e `analytics ci`
+ * si ferma se un progetto lo fa. Due modalita', offerte solo se ci sono i pezzi:
  *   noeva-vivo      inferenza NOEVA, run_sql sul database vivo via serve-app.py (Mac)
  *   noeva-snapshot  inferenza NOEVA, run_sql sullo snapshot nel browser (Mac e sito)
- *   cli             la CLI di Claude con l'MCP del progetto, via serve-app.py (Mac)
  * La scelta si ricorda nel browser; senza scelta vale la prima disponibile in
  * quest'ordine. Senza nessuna, la pagina resta ai commenti gia' pronti. */
 export const MOTORI = {
   "noeva-vivo": "NOEVA · database",
   "noeva-snapshot": "NOEVA · snapshot",
-  cli: "Claude CLI · database",
 };
 const CHIAVE_MOTORE = "noeva-analytics-motore";
 
@@ -57,8 +57,7 @@ let _motori = null;
 export function motori() {
   _motori ||= Promise.all([inferenza(), conServer()]).then(async ([ai, vivo]) => {
     const db = vivo ? await sqlVivo() : null;
-    return Object.keys(MOTORI).filter((m) =>
-      m === "noeva-vivo" ? ai && db : m === "noeva-snapshot" ? ai : vivo);
+    return Object.keys(MOTORI).filter((m) => (m === "noeva-vivo" ? ai && db : ai));
   });
   return _motori;
 }

package/contenuto/assets/presentazione.js

@@ -5,13 +5,15 @@
  *   montaPresentazione({ pagina: "venduto" });
  *
  * Un pulsante nella barra in alto apre una finestra: due partenze pronte (sintesi
- * per la direzione, analisi completa) o un prompt libero. Claude, dalla CLI sul
- * Mac (presentazione.py), scrive la scaletta: titoli, punti, note del relatore e
+ * per la direzione, analisi completa) o un prompt libero. L'inferenza NOEVA
+ * (ai/converse del contenitore, con il prompt di presentazione.py esportato da
+ * lib/snapshot/ai.py; mai la CLI di Claude) scrive la scaletta: titoli, punti, note del relatore e
  * quale riquadro mostrare in ogni slide. La scaletta si vede subito come slide
  * nella pagina (gli stessi KPI, grafici e tabelle dello schermo), si presenta a
  * tutto schermo con la regia di animazione.js, si corregge a mano o in chat ("accorcia la terza", "aggiungi una
- * slide sui mercati che perdono"): ogni richiesta torna a Claude con la scaletta
- * e la conversazione. Il .pptx lo costruisce questa pagina solo alla fine, con
+ * slide sui mercati che perdono"): ogni richiesta torna all'inferenza con la scaletta
+ * e la conversazione. Le scalette gia' pronte (dati/presentazioni/) si usano prima,
+ * anche senza AI. Il .pptx lo costruisce questa pagina solo alla fine, con
  * PptxGenJS, dalla scaletta sistemata: grafici (l'SVG della dashboard, reso in
  * immagine), tabelle (vere tabelle PowerPoint, modificabili) e KPI vengono dallo
  * schermo, con i filtri di quel momento.
@@ -22,6 +24,7 @@
 import { contesto, trovaRiquadro, pulisci, evidenzia, pulito } from "./commento.js";
 import { animaSlide } from "./animazione.js";
 import { conServer, chiaveServer, fileDati, conLingua, rotta } from "./servizio.js";
+import { giro, nuovaSessione, motoreScelto } from "./inferenza.js";
 import { t, LINGUA, LOCALE } from "./lingua.js";
 import { PROGETTO } from "./progetto.js";
 
@@ -29,6 +32,68 @@ const PIATTO = (s) => String(s ?? "").replace(/\s+/g, " ").trim();
 const esc = (s) => String(s ?? "").replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c]));
 const asset = (f) => new URL(f, import.meta.url).href;
 
+/* --- l'AI: il prompt di presentazione.py e il giro con l'inferenza NOEVA ---------- */
+
+// {sistema, sistema_modifica, schema, schema_modifica, partenze}, scritto da lib/snapshot/ai.py
+const promptPpt = (pagina) => fileDati(`ai/presentazione-${pagina}.${LINGUA}.json`);
+const datiDi = (motore) => (motore === "noeva-vivo" ? "vivo" : "snapshot");
+
+/* I riquadri che la pagina non ha si tolgono: la slide mostrerebbe un vuoto
+ * (come _ripulisci di presentazione.py). */
+function ripulisci(ppt, ctx) {
+  const validi = new Set((ctx.riquadri || []).map((r) => r.id));
+  const slide = (ppt?.slide || []).map((sl) => {
+    const x = { ...sl, riquadri: (sl.riquadri || []).filter((r) => validi.has(r)) };
+    if ((x.tipo === "numeri" || x.tipo === "riquadro") && !x.riquadri.length) x.tipo = "punti";
+    if (x.tipo === "riquadro") x.riquadri = x.riquadri.slice(0, 1);
+    return x;
+  });
+  if (!slide.length) throw new Error(t("la presentazione non ha slide"));
+  return { ...ppt, slide };
+}
+
+const CONTESTO = (ctx) => `Contesto della pagina, come la vede ora il cliente (JSON):\n\n${JSON.stringify(ctx, null, 1)}`;
+
+async function scalettaConInferenza({ pagina, partenza, prompt, ctx, motore, alPasso }) {
+  const p = await promptPpt(pagina);
+  if (!p?.sistema || !p.schema) throw new Error(t("il prompt della presentazione di questa pagina non è pronto"));
+  const preset = (p.partenze || []).find((x) => x.id === partenza);
+  const richiestaPreset = partenza === "libera"
+    ? `Presentazione su richiesta, 4-12 slide oltre alla copertina. Ecco cosa chiede chi la presenta:\n\n<richiesta>\n${prompt}\n</richiesta>`
+    : preset?.richiesta;
+  if (!richiestaPreset) throw new Error(t("partenza sconosciuta: {p}", { p: partenza }));
+  const g = await giro({
+    funzione: "presentazione", pagina, sistema: p.sistema, sessione: nuovaSessione("presentazione", pagina), dati: datiDi(motore),
+    richiesta: `Pagina: ${pagina}. ${richiestaPreset}\n\n${CONTESTO(ctx)}`,
+    consegna: { nome: "consegna_scaletta", descrizione: "Consegna la scaletta finita: il titolo, il sottotitolo e le slide, nell'ordine.", schema: p.schema },
+    maxQuery: partenza === "analisi" ? 6 : 4, alPasso,
+  });
+  return { ...ripulisci(g.risultato, ctx), _partenza: partenza, _lingua: LINGUA,
+    _motore: { tipo: "noeva", dati: g.dati, modello: g.modello, turni: g.turni, query: g.query, token: g.token } };
+}
+
+/* La scaletta sistemata secondo la richiesta, con la conversazione finora (come
+ * modifica() di presentazione.py: la copertina e' la slide 1). */
+async function modificaConInferenza({ pagina, scaletta, richiesta, storia, ctx, motore }) {
+  const p = await promptPpt(pagina);
+  if (!p?.sistema_modifica || !p.schema_modifica) throw new Error(t("il prompt della presentazione di questa pagina non è pronto"));
+  const attuale = Object.fromEntries(Object.entries(scaletta).filter(([k]) => !k.startsWith("_")));
+  attuale.slide = (attuale.slide || []).map((sl, i) => ({ numero: i + 2, ...sl }));
+  const conversazione = (storia || []).slice(-12)
+    .map((m) => `- ${m.ruolo === "utente" ? "Chi presenta" : "Tu"}: ${String(m.testo || "").slice(0, 600)}`).join("\n") || "(nessuna)";
+  const g = await giro({
+    funzione: "presentazione", pagina, sistema: p.sistema_modifica, sessione: nuovaSessione("presentazione", pagina), dati: datiDi(motore),
+    richiesta: `Pagina: ${pagina}.\n\nScaletta attuale (JSON):\n\n${JSON.stringify(attuale, null, 1)}\n\n`
+      + `Conversazione finora:\n${conversazione}\n\nNuova richiesta di chi presenta:\n<richiesta>\n${richiesta}\n</richiesta>\n\n${CONTESTO(ctx)}`,
+    consegna: { nome: "consegna_scaletta", descrizione: "Consegna la scaletta completa aggiornata e la risposta per chi presenta.", schema: p.schema_modifica },
+    maxQuery: 3,
+  });
+  const nuova = ripulisci(g.risultato, ctx);
+  for (const k of ["_partenza", "_file", "_lingua"]) if (k in scaletta) nuova[k] = scaletta[k];
+  nuova._motore = { tipo: "noeva", dati: g.dati, modello: g.modello, turni: g.turni, query: g.query, token: g.token };
+  return nuova;
+}
+
 /* --- PptxGenJS si carica solo quando serve: 470 kB ------------------------------- */
 let caricamento = null;
 function pptxgen() {
@@ -462,7 +527,7 @@ function montaAnteprima({ pagina, titoloPagina }) {
             <button type="button" id="an-av" aria-label="${esc(t("Slide successiva"))}">▶</button></div></div>
       </div>
       <aside class="an-lato" id="an-lato" aria-label="${esc(t("Sistema la presentazione in chat"))}">
-        <h3>${t("Sistema con Claude")}</h3>
+        <h3>${t("Sistema con l'AI")}</h3>
         <div class="an-msgs" id="an-msgs" aria-live="polite"></div>
         <div class="an-stato" id="an-stato" role="status"></div>
         <form id="an-form"><textarea id="an-testo" aria-label="${esc(t("Cosa cambiare"))}" placeholder="${esc(t("Es.: accorcia la slide 3, aggiungi una slide sui mercati che perdono di più, togli i Service Items"))}"></textarea>
@@ -557,7 +622,7 @@ function montaAnteprima({ pagina, titoloPagina }) {
   });
   addEventListener("resize", () => { if (!an.hidden) scala(); });
 
-  /* --- la chat con la CLI --- */
+  /* --- la chat con l'inferenza NOEVA --- */
   $("#an-form").onsubmit = async (e) => {
     e.preventDefault();
     const richiesta = $("#an-testo").value.trim();
@@ -568,10 +633,10 @@ function montaAnteprima({ pagina, titoloPagina }) {
     const t0 = performance.now();
     const orologio = setInterval(() => (attesa.textContent = `${t("Sto sistemando la scaletta…")} ${Math.round((performance.now() - t0) / 1000)} s`), 1000);
     try {
-      const r = await fetch(rotta("ai/presentazione/modifica"), { method: "POST", headers: { "content-type": "application/json" },
-        body: JSON.stringify({ pagina, scaletta: st.sc, richiesta, storia: st.storia, contesto: st.ctx, lingua: LINGUA }) });
-      const j = await r.json();
-      if (!r.ok || j.errore) throw new Error(j.errore || r.status);
+      if (richiesta.length > 2000) throw new Error(t("la richiesta è troppo lunga: massimo 2000 caratteri"));
+      const motore = await motoreScelto();
+      if (!motore) throw new Error(t("l'AI di questo progetto non è configurata"));
+      const j = await modificaConInferenza({ pagina, scaletta: st.sc, richiesta, storia: st.storia, ctx: st.ctx, motore });
       const risposta = j.risposta || t("Fatto.");
       delete j.risposta;
       st.sc = j; st.storia.push({ ruolo: "utente", testo: richiesta }, { ruolo: "claude", testo: risposta });
@@ -601,13 +666,15 @@ function montaAnteprima({ pagina, titoloPagina }) {
     finally { b.disabled = false; }
   };
 
-  function apri(scaletta, ctx, daDove, vivo = true) {
+  // ai: l'inferenza NOEVA c'e' (la chat per sistemarla); vivo: serve-app.py sul
+  // Mac, che salva la scaletta sistemata al posto di quella gia' pronta
+  function apri(scaletta, ctx, daDove, { ai = false, vivo = false } = {}) {
     st.sc = scaletta; st.ctx = ctx; st.i = -1; st.storia = []; st.daDove = daDove; st.vivo = vivo;
     $("#an-msgs").innerHTML = ""; stato("");
-    $("#an-form").hidden = !vivo;
-    messaggio(vivo
+    $("#an-form").hidden = !ai;
+    messaggio(ai
       ? t("La presentazione è pronta: {n} slide. Sfogliala, correggi a mano quello che vuoi o dimmi cosa cambiare. Il file si genera alla fine.", { n: scaletta.slide.length + 1 })
-      : t("La presentazione è pronta: {n} slide. Qui la sfogli, la presenti e generi il PowerPoint; la chat per sistemarla c'è nella versione sul Mac.", { n: scaletta.slide.length + 1 }), "claude");
+      : t("La presentazione è pronta: {n} slide. Qui la sfogli, la presenti e generi il PowerPoint; la chat per sistemarla c'è dove l'AI del progetto è attiva.", { n: scaletta.slide.length + 1 }), "claude");
     an.hidden = false; document.body.style.overflow = "hidden";
     disegna(); $("#an-av").focus();
   }
@@ -686,7 +753,7 @@ export function montaPresentazione({ pagina }) {
   document.body.append(d);
   const $ = (s) => d.querySelector(s);
 
-  // le partenze del server (presentazione.py) arrivano nella lingua della pagina
+  // le partenze di presentazione.py arrivano col prompt, nella lingua della pagina
   const scelte = [
     { id: "direzione", nome: t("Sintesi per la direzione"), descrizione: "6-7 slide" },
     { id: "analisi", nome: t("Analisi completa della pagina"), descrizione: "10-14 slide" },
@@ -702,7 +769,7 @@ export function montaPresentazione({ pagina }) {
     }));
   };
   disegnaScelte(scelte);
-  fetch(rotta(`ai/presentazione?lingua=${LINGUA}`)).then((r) => r.json()).then((j) => Array.isArray(j) && disegnaScelte(j)).catch(() => {});
+  promptPpt(pagina).then((p) => Array.isArray(p?.partenze) && p.partenze.length && disegnaScelte(p.partenze)).catch(() => {});
   const partenza = () => d.querySelector('input[name="partenza"]:checked')?.value;
 
   const stato = (t, errore = false) => { $("#ppt-stato").textContent = t; $("#ppt-stato").classList.toggle("errore", errore); };
@@ -718,24 +785,21 @@ export function montaPresentazione({ pagina }) {
     const p = partenza(), prompt = $("#ppt-prompt").value.trim();
     if (p === "libera" && prompt.length < 10) { stato(t("Scrivi cosa deve raccontare la presentazione."), true); $("#ppt-prompt").focus(); return; }
     inCorso = true; $("#ppt-genera").disabled = true;
-    stato(t("Claude sta scrivendo la scaletta: di solito uno o due minuti, tre per l'analisi completa."));
     try {
       const ctx = contesto();
-      const vivo = await conServer();
-      let j;
-      if (vivo) {
-        const r = await fetch(rotta("ai/presentazione"), { method: "POST", headers: { "content-type": "application/json" },
-          body: JSON.stringify({ pagina, partenza: p, prompt, contesto: ctx, forza: e.shiftKey, lingua: LINGUA }) });
-        j = await r.json();
-        if (!r.ok || j.errore) throw new Error(j.errore || r.status);
-      } else {
-        // dietro il cancello: solo le scalette gia' pronte, con la chiave che calcola il server
-        const chiave = await chiaveServer(conLingua(["presentazione", pagina, p, p === "libera" ? prompt : "", ctx]));
-        j = await fileDati(`presentazioni/ppt-${pagina}-${p}-${chiave}.json`);
-        if (!j) throw new Error(t("per questa vista non c'è una scaletta pronta: si prepara dal Mac, con questi filtri"));
-      }
+      const [motore, vivo] = await Promise.all([motoreScelto(), conServer()]);
+      // prima la scaletta gia' pronta di questa vista (salvo Maiusc), poi l'inferenza NOEVA
+      const chiave = await chiaveServer(conLingua(["presentazione", pagina, p, p === "libera" ? prompt : "", ctx]));
+      const file = `ppt-${pagina}-${p}-${chiave}.json`;
+      let j = e.shiftKey && motore ? null : await fileDati(`presentazioni/${file}`);
+      if (j) j = { ...j, _file: file, _da_cache: true };
+      else if (motore) {
+        stato(t("Sto scrivendo la scaletta: di solito uno o due minuti, tre per l'analisi completa."));
+        j = await scalettaConInferenza({ pagina, partenza: p, prompt, ctx, motore,
+          alPasso: (x) => stato(t("Sto scrivendo la scaletta…") + ` ${t("passaggio {n}", { n: x.turno })}` + (x.query ? ` · ${t("{n} query", { n: x.query })}` : "")) });
+      } else throw new Error(t("per questa vista non c'è una scaletta pronta e l'AI di questo progetto non è attiva"));
       stato(""); d.close();
-      anteprima.apri(j, ctx, btn, vivo);
+      anteprima.apri(j, ctx, btn, { ai: !!motore, vivo });
     } catch (err) {
       stato(t("La presentazione non è disponibile: {errore}", { errore: err.message || err }), true);
     } finally { inCorso = false; $("#ppt-genera").disabled = false; }

package/contenuto/assets/vista.js

@@ -43,6 +43,8 @@ export const EVENTO = "noeva-vista";
 /* --- la vista come dato ------------------------------------------------------------ */
 
 const pulito = (s) => String(s ?? "").replace(/[▸▾✕]/g, "").replace(/\s+/g, " ").trim();
+// Il titolo della barra: in alcuni progetti l'h1 comincia con un separatore («· Vendite e CRM»)
+const titoloDi = (s) => pulito(s).replace(/^[·•|–—-]\s*/, "");
 
 /* I filtri dalla query dell'URL, nell'ordine dei dichiarati (poi gli altri, se
  * non ce ne sono di dichiarati). `dichiarati`: { chiave: "Nome" } oppure
@@ -192,7 +194,7 @@ export function montaVista({ dashboard, meta = {}, filtri = null, provenienza =
   function aggiorna() {
     attuale = componiVista({
       progetto: { id: meta.progetto || PROGETTO.id, nome: PROGETTO.nome },
-      dashboard: { id: dashboard, titolo: titolo || pulito(document.querySelector(".topbar h1")?.textContent) || pulito(document.title) },
+      dashboard: { id: dashboard, titolo: titolo || titoloDi(document.querySelector(".topbar h1")?.textContent) || titoloDi(document.title) },
       lingua: LINGUA,
       url: location.href,
       filtri: filtriDaUrl(location.search, filtri),

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/modello/pubblica.py

@@ -80,6 +80,20 @@ def estrai_da_head(radice: pathlib.Path, dest: pathlib.Path) -> None:
             tar.extractall(dest, filter="data")
 
 
+def costruisci(radice: pathlib.Path, tmp: pathlib.Path) -> tuple[pathlib.Path, dict]:
+    """Il modello consegnato dal commit di `radice`, compilato, in `tmp`/modello.
+
+    E' il modello pubblicato: lo usa main() per caricarlo e il backend del gateway
+    (lib/gateway/backend/modello.py) per metterlo nell'immagine, cosi' le due strade
+    non possono divergere. Restituisce la cartella e i conteggi delle trasformazioni."""
+    sorgente, dest = tmp / "sorgente", tmp / "modello"
+    estrai_da_head(radice, sorgente)
+    # Le trasformazioni di consegna.yml anche loro dal commit, non dal disco.
+    conta = modello_di_consegna(sorgente, dest, leggi_consegna(sorgente))
+    compila(dest)
+    return dest, conta
+
+
 def file_della_versione(dest: pathlib.Path) -> list[pathlib.Path]:
     return sorted(p for p in dest.rglob("*") if p.is_file() and not p.name.startswith("."))
 
@@ -99,11 +113,7 @@ def main(argv: list[str]) -> int:
     versione = versione_di(radice)
 
     with tempfile.TemporaryDirectory() as tmp:
-        sorgente, dest = pathlib.Path(tmp) / "sorgente", pathlib.Path(tmp) / "modello"
-        estrai_da_head(radice, sorgente)
-        # Le trasformazioni di consegna.yml anche loro dal commit, non dal disco.
-        conta = modello_di_consegna(sorgente, dest, leggi_consegna(sorgente))
-        compila(dest)
+        dest, conta = costruisci(radice, pathlib.Path(tmp))
         file = file_della_versione(dest)
         byte = sum(p.stat().st_size for p in file)
         print(f"▸ {progetto}: modello {versione}, {numero_modelli(dest)} modelli, {len(file)} file, "

package/contenuto/lib/snapshot/ai.py

@@ -9,6 +9,12 @@ dalle stesse funzioni di commento.py, cosi' le regole restano in un posto solo.
 
   apps/dati/ai/commento-<pagina>.<lingua>.json   {sistema, modi, schema, generato}
   apps/dati/ai/chat-<pagina>.<lingua>.json       {sistema, testi, generato}   se c'e' chat.py
+  apps/dati/ai/presentazione-<pagina>.<lingua>.json
+      {sistema, sistema_modifica, schema, schema_modifica, partenze, generato}   se c'e' presentazione.py
+
+Questi file sono l'unica strada dell'AI delle pagine: chat.py, commento.py e
+presentazione.py del progetto tengono solo prompt e regole, mai una chiamata a un
+modello (la CLI di Claude non si usa; `analytics ci` lo controlla).
 
 Le pagine sono le cartelle di apps/ con un index.html, piu' l'indice; le lingue
 quelle di commento.LINGUE (apps/en/ non e' una pagina: e' la gemella inglese, che
@@ -73,6 +79,35 @@ def carica_chat(progetto: pathlib.Path):
     return modulo
 
 
+def carica_presentazione(progetto: pathlib.Path):
+    """presentazione.py del progetto, o None: il PowerPoint e' facoltativo."""
+    if not (progetto / "presentazione.py").exists():
+        return None
+    spec = importlib.util.spec_from_file_location(f"presentazione_{progetto.name}", progetto / "presentazione.py")
+    modulo = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(modulo)
+    for nome in ("istruzioni", "LINGUE", "SCHEMA", "SCHEMA_MODIFICA", "PRESET", "MODIFICA"):
+        if not hasattr(modulo, nome):
+            raise SystemExit(f"{progetto.name}/presentazione.py non ha {nome}: non e' allineato allo standard")
+    return modulo
+
+
+def prompt_presentazione(ppt, c, pagina: str, lingua: str) -> dict:
+    """Il prompt delle slide come lo costruiva presentazione.py sul Mac: per scriverle
+    (istruzioni) e per sistemarle in chat (istruzioni piu' MODIFICA), con la knowledge base."""
+    kb = "\n\n# Knowledge base del progetto\n\n" + c.conoscenza(pagina)
+    risposta = ppt.LINGUE[lingua].get("risposta", "nella lingua della pagina")
+    return {
+        "sistema": ppt.istruzioni(lingua) + kb,
+        "sistema_modifica": ppt.istruzioni(lingua) + "\n\n" + ppt.MODIFICA.replace("{RISPOSTA}", risposta) + kb,
+        "schema": ppt.SCHEMA,
+        "schema_modifica": ppt.SCHEMA_MODIFICA,
+        "partenze": [{"id": k, "nome": v["nome"].get(lingua) or v["nome"]["it"],
+                      "descrizione": v["descrizione"].get(lingua) or v["descrizione"]["it"],
+                      "richiesta": v["richiesta"]} for k, v in ppt.PRESET.items()],
+    }
+
+
 def pagine(progetto: pathlib.Path) -> list[str]:
     apps = progetto / "apps"
     trovate = sorted(p.name for p in apps.iterdir()
@@ -110,9 +145,19 @@ def main(argv: list[str]) -> int:
                      "generato": adesso},
                     ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
                 n_chat += 1
+    ppt = carica_presentazione(progetto)
+    n_ppt = 0
+    if ppt:
+        for pagina in pagine(progetto):
+            for lingua in ppt.LINGUE:
+                (uscita / f"presentazione-{pagina}.{lingua}.json").write_text(json.dumps(
+                    {**prompt_presentazione(ppt, c, pagina, lingua), "generato": adesso},
+                    ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
+                n_ppt += 1
     if not scritti and not n_chat:
         raise SystemExit(f"{progetto.name}: ne' commento guidato ne' chat, nessun prompt da scrivere")
-    print(f"  apps/dati/ai: {scritti} prompt del commento, {n_chat} della chat ({len(c.LINGUE)} lingue)")
+    print(f"  apps/dati/ai: {scritti} prompt del commento, {n_chat} della chat, {n_ppt} della presentazione"
+          f" ({len(c.LINGUE)} lingue)")
     return 0
 
 

package/contenuto/lib/snapshot/worker/installa.ps1

@@ -310,8 +310,13 @@ if ($SoloControllo) {
 } else {
     Write-Host "  Ogni $minuti minuti lancia 'ascolta --una-volta' come $env:USERNAME, anche senza sessione aperta:"
     Write-Host '  per questo Windows chiede la password di questo utente (quella di Windows, non del database).'
-    $credenziali = Get-Credential -UserName "$env:USERDOMAIN\$env:USERNAME" -Message "Password Windows di $env:USERNAME"
-    if (-not $credenziali) { Ferma 'attivita''' 'nessuna password Windows: senza, l''attivita'' non gira a sessione chiusa' }
+    # In console, non con Get-Credential: in desktop remoto la finestrella finisce dietro e lo
+    # script sembra fermo (12/11/2026, sulla VM di un cliente).
+    $utenteWin = "$env:USERDOMAIN\$env:USERNAME"
+    $pwWin = ChiediSegreto "Password Windows di $utenteWin (non si vede mentre scrivi, poi Invio)"
+    if (-not $pwWin) { Ferma 'attivita''' 'nessuna password Windows: senza, l''attivita'' non gira a sessione chiusa' }
+    $credenziali = [pscustomobject]@{ UserName = $utenteWin }
+    Write-Host '  Registro l''attivita'' con Windows...'
     $log = Join-Path $destinazione 'lavoro\ascolta.log'
     $azione = New-ScheduledTaskAction -Execute 'cmd.exe' -WorkingDirectory $destinazione `
         -Argument "/c `"`"$exe`" ascolta --config `"$(Join-Path $destinazione 'worker.json')`" --una-volta >> `"$log`" 2>&1`""
@@ -320,13 +325,13 @@ if ($SoloControllo) {
         -StartWhenAvailable -DontStopIfGoingOnBatteries -AllowStartIfOnBatteries
     try {
         Register-ScheduledTask -TaskName $attivita -Action $azione -Trigger $quando -Settings $regole `
-            -User $credenziali.UserName -Password $credenziali.GetNetworkCredential().Password -RunLevel Limited -Force | Out-Null
+            -User $credenziali.UserName -Password $pwWin -RunLevel Limited -Force -ErrorAction Stop | Out-Null
         Enable-ScheduledTask -TaskName $attivita | Out-Null
         Esito 'attivita''' 'ok' "ogni $minuti minuti come $($credenziali.UserName); registro in $log"
     } catch {
         Esito 'attivita''' 'NO' "Windows l'ha rifiutata (password giusta?): $($_.Exception.Message)"
     }
-    $credenziali = $null
+    $credenziali = $null; $pwWin = $null
 }
 
 # 8. La dashboard ------------------------------------------------------------------------------

package/contenuto/lib/snapshot/worker/ultimi-giri.ps1

@@ -0,0 +1,202 @@
+# Gli ultimi giri del worker degli snapshot e il loro esito, senza cambiare niente.
+#
+#   powershell -ExecutionPolicy Bypass -File C:\NOEVA\snapshot\ultimi-giri.ps1
+#   powershell -ExecutionPolicy Bypass -File C:\NOEVA\snapshot\ultimi-giri.ps1 -Giri 20
+#
+# Legge l'attivita' pianificata, lavoro\ascolta.log (tutti i giri, con l'esito) e il
+# giro.json degli ultimi giri tenuti in lavoro\<progetto>\ (le cifre di controllo che
+# hanno avvisato o fermato). Non legge chiavi ne' password e non chiama NOEVA.
+# Lo lancia l'utente del worker, o chiunque possa leggere C:\NOEVA\snapshot.
+
+param(
+    [int]$Giri = 10,
+    [string]$Cartella = ''
+)
+
+# Di solito accanto a noeva-snapshot (C:\NOEVA\snapshot); copiato altrove, guarda li'.
+if (-not $Cartella) {
+    $Cartella = if ($PSScriptRoot -and (Test-Path (Join-Path $PSScriptRoot 'worker.json'))) { $PSScriptRoot } else { 'C:\NOEVA\snapshot' }
+}
+
+$ErrorActionPreference = 'Continue'
+# Il nome lo da' installa.ps1: "NOEVA snapshot <progetto>", dal progetto di worker.json.
+$attivita = 'NOEVA snapshot'
+$log = Join-Path $Cartella 'lavoro\ascolta.log'
+$conf = Join-Path $Cartella 'worker.json'
+
+function Riga([string]$etichetta, [string]$stato, [string]$testo) {
+    $colore = switch ($stato) { 'ok' { 'Green' } 'avviso' { 'Yellow' } 'NO' { 'Red' } default { 'Gray' } }
+    Write-Host ('  {0,-8}' -f $stato) -ForegroundColor $colore -NoNewline
+    Write-Host (' {0,-22} {1}' -f $etichetta, $testo)
+}
+
+function Durata([timespan]$d) {
+    if ($d.TotalMinutes -lt 1) { return '{0} s' -f [int]$d.TotalSeconds }
+    if ($d.TotalHours -lt 1) { return '{0} min' -f [int]$d.TotalMinutes }
+    if ($d.TotalDays -lt 1) { return '{0:0.#} ore' -f $d.TotalHours }
+    return '{0:0.#} giorni' -f $d.TotalDays
+}
+
+if (Test-Path $conf) {
+    try {
+        $w = Get-Content $conf -Raw | ConvertFrom-Json
+        $progetti = @($w.pipeline.PSObject.Properties | ForEach-Object { $_.Value.progetto })
+        if ($progetti.Count -eq 1) { $attivita = "NOEVA snapshot $($progetti[0])" }
+    } catch { }
+}
+# Senza worker.json leggibile: la prima attivita' del worker che c'e' su questa macchina.
+if ($attivita -eq 'NOEVA snapshot' -and (Get-Command Get-ScheduledTask -ErrorAction SilentlyContinue)) {
+    $trovata = Get-ScheduledTask -TaskName 'NOEVA snapshot *' -ErrorAction SilentlyContinue | Select-Object -First 1
+    if ($trovata) { $attivita = $trovata.TaskName }
+}
+
+Write-Host ''
+Write-Host "NOEVA Analytics - gli ultimi giri del worker degli snapshot" -ForegroundColor Cyan
+Write-Host ("macchina {0} - {1} - {2}" -f $env:COMPUTERNAME, $Cartella, (Get-Date -Format 'dd/MM/yyyy HH:mm'))
+
+# --- l'attivita' pianificata ------------------------------------------------------
+Write-Host ''
+Write-Host "== L'attivita' pianificata '$attivita'"
+$t = if (Get-Command Get-ScheduledTask -ErrorAction SilentlyContinue) { Get-ScheduledTask -TaskName $attivita -ErrorAction SilentlyContinue }
+if (-not $t) {
+    Riga 'attivita''' 'NO' "non c'e': va rilanciato installa.ps1"
+} else {
+    $info = Get-ScheduledTaskInfo -TaskName $attivita
+    $codici = @{
+        '0'          = 'ok'
+        '267009'     = 'in corso adesso'
+        '267011'     = 'non e'' mai partita'
+        '2147943785' = 'Windows rifiuta l''accesso: manca il diritto "Accesso come processo batch"'
+        '2147942402' = 'file non trovato: la cartella e'' cambiata, rilancia installa.ps1'
+        '2147943726' = 'password Windows sbagliata o cambiata: rilancia installa.ps1'
+    }
+    $r = [int64]$info.LastTaskResult
+    if ($r -lt 0) { $r += 4294967296 }
+    $significato = if ($codici.ContainsKey("$r")) { $codici["$r"] } else { 'codice 0x{0:X8}' -f $r }
+    $stato = if ($t.State -eq 'Disabled') { 'NO' } elseif ($r -in 0, 267009) { 'ok' } elseif ($r -eq 267011) { 'avviso' } else { 'NO' }
+    Riga 'stato' $stato ("{0}, ultimo avvio {1:dd/MM HH:mm}, {2}" -f $t.State, $info.LastRunTime, $significato)
+    if ($t.State -eq 'Disabled') {
+        Riga 'disattivata' 'NO' "non parte finche' non si riaccende: i giri di NOEVA restano in coda"
+        Write-Host "           Enable-ScheduledTask -TaskName '$attivita'; Start-ScheduledTask -TaskName '$attivita'" -ForegroundColor Yellow
+        Write-Host "           (installa.ps1 la spegne durante un aggiornamento e la riaccende al passo 7)" -ForegroundColor Yellow
+    }
+    Riga 'prossimo avvio' 'info' ("{0:dd/MM HH:mm} (ogni 5 minuti chiede a NOEVA se c'e' un giro)" -f $info.NextRunTime)
+}
+
+# --- ascolta.log ------------------------------------------------------------------
+Write-Host ''
+Write-Host "== I giri in ascolta.log"
+if (-not (Test-Path $log)) {
+    Riga 'ascolta.log' 'avviso' "non c'e' ancora: nessun giro"
+    Write-Host ''
+    exit 0
+}
+
+$righe = Get-Content $log -Encoding UTF8
+$reTs = '^(\d{4}-\d\d-\d\d \d\d:\d\d:\d\d) '
+$tutti = New-Object System.Collections.ArrayList
+$corrente = $null
+$ultimoAscolto = $null
+$erroriApi = New-Object System.Collections.ArrayList
+
+foreach ($riga in $righe) {
+    if ($riga -match ($reTs + 'in ascolto per')) {
+        $ultimoAscolto = [datetime]$Matches[1]
+    } elseif ($riga -match ($reTs + 'non riesco a chiedere lavoro all''API: (.*)$')) {
+        [void]$erroriApi.Add([pscustomobject]@{ Quando = [datetime]$Matches[1]; Testo = $Matches[2] })
+    } elseif ($riga -match ($reTs + '(\S+): processo (\S+), giro in (.+)$')) {
+        $corrente = [pscustomobject]@{
+            Inizio = [datetime]$Matches[1]; Pipeline = $Matches[2]; Processo = $Matches[3]
+            Cartella = $Matches[4].Trim(); Fine = $null; Esito = 'interrotto'; Dettaglio = ''
+            Versione = ''; DataDato = ''; Avvisi = 0
+        }
+        [void]$tutti.Add($corrente)
+    } elseif ($corrente -and $riga -match '^\s+data del dato: (\S+)') {
+        $corrente.DataDato = $Matches[1]
+    } elseif ($corrente -and $riga -match '^\s+(\d+) cifre di controllo spostate entro la tolleranza') {
+        $corrente.Avvisi = [int]$Matches[1]
+    } elseif ($corrente -and $riga -match ($reTs + '\S+: pubblicata (\S+) in ([\d.]+)s')) {
+        $corrente.Fine = [datetime]$Matches[1]; $corrente.Esito = 'pubblicato'; $corrente.Versione = $Matches[2]
+        $corrente = $null
+    } elseif ($corrente -and $riga -match ($reTs + '\S+: FALLITO, (.*)$')) {
+        $corrente.Fine = [datetime]$Matches[1]; $corrente.Esito = 'FALLITO'; $corrente.Dettaglio = $Matches[2]
+        $corrente = $null
+    }
+}
+
+$ok = @($tutti | Where-Object Esito -eq 'pubblicato')
+$ko = @($tutti | Where-Object Esito -eq 'FALLITO')
+Riga 'giri nel log' 'info' ("{0} in tutto: {1} pubblicati, {2} falliti, dal {3:dd/MM/yyyy}" -f $tutti.Count, $ok.Count, $ko.Count, $(if ($tutti.Count) { $tutti[0].Inizio } else { Get-Date }))
+
+if ($ultimoAscolto) {
+    $fa = (Get-Date) - $ultimoAscolto
+    $stato = if ($fa.TotalMinutes -le 15) { 'ok' } else { 'NO' }
+    $nota = if ($stato -eq 'ok') { '' } else { ': l''attivita'' non parte, guarda lo stato qui sopra' }
+    Riga 'ultimo controllo' $stato ("{0:dd/MM HH:mm}, {1} fa{2}" -f $ultimoAscolto, (Durata $fa), $nota)
+}
+if ($ok.Count) {
+    $u = $ok[-1]
+    $fa = (Get-Date) - $u.Fine
+    Riga 'ultimo pubblicato' $(if ($fa.TotalHours -le 26) { 'ok' } else { 'avviso' }) ("{0:dd/MM HH:mm}, {1} fa, versione {2}, dato al {3}" -f $u.Fine, (Durata $fa), $u.Versione, $u.DataDato)
+} else {
+    Riga 'ultimo pubblicato' 'NO' 'nessun giro pubblicato in ascolta.log'
+}
+$recenti = @($erroriApi | Where-Object { $_.Quando -gt (Get-Date).AddDays(-1) })
+if ($recenti.Count) {
+    Riga 'errori verso NOEVA' 'avviso' ("{0} nelle ultime 24 ore, l'ultimo {1:dd/MM HH:mm}: {2}" -f $recenti.Count, $recenti[-1].Quando, $recenti[-1].Testo)
+}
+
+Write-Host ''
+Write-Host ("== Gli ultimi {0} giri (il piu' recente in alto)" -f [Math]::Min($Giri, $tutti.Count))
+if (-not $tutti.Count) { Write-Host '  nessun giro ancora' }
+$mostrati = @($tutti | Select-Object -Last $Giri)
+[array]::Reverse($mostrati)
+foreach ($g in $mostrati) {
+    $durata = if ($g.Fine) { Durata ($g.Fine - $g.Inizio) } else { '-' }
+    switch ($g.Esito) {
+        'pubblicato' {
+            $avv = if ($g.Avvisi) { ", $($g.Avvisi) avvisi" } else { '' }
+            Riga ('{0:ddd dd/MM HH:mm}' -f $g.Inizio) 'ok' ("pubblicato {0}, dato al {1}, {2}{3}" -f $g.Versione, $g.DataDato, $durata, $avv)
+        }
+        'FALLITO' {
+            Riga ('{0:ddd dd/MM HH:mm}' -f $g.Inizio) 'NO' ("FALLITO dopo {0}: {1}" -f $durata, $g.Dettaglio)
+        }
+        default {
+            $inCorso = ((Get-Date) - $g.Inizio).TotalMinutes -lt 30 -and $g -eq $tutti[-1]
+            Riga ('{0:ddd dd/MM HH:mm}' -f $g.Inizio) $(if ($inCorso) { 'info' } else { 'avviso' }) $(if ($inCorso) { 'in corso adesso' } else { 'interrotto senza esito (macchina spenta o processo chiuso?)' })
+        }
+    }
+}
+
+# --- le cifre di controllo degli ultimi giri ----------------------------------------
+# giro.json resta per gli ultimi 5 giri di ogni progetto (ascolta.py, GIRI_TENUTI).
+$ultimi = @($tutti | Where-Object { $_.Cartella -and (Test-Path -LiteralPath ([IO.Path]::Combine($_.Cartella, 'giro.json'))) } | Select-Object -Last 1)
+if ($ultimi.Count) {
+    $g = $ultimi[0]
+    Write-Host ''
+    Write-Host ("== Le cifre di controllo del giro del {0:dd/MM HH:mm}" -f $g.Inizio)
+    try {
+        $rep = Get-Content -LiteralPath ([IO.Path]::Combine($g.Cartella, 'giro.json')) -Raw -Encoding UTF8 | ConvertFrom-Json
+        $controlli = @($rep.controlli | Where-Object { $_.PSObject.Properties.Name -contains 'esito' })
+        $fuori = @($controlli | Where-Object { $_.esito -ne 'ok' })
+        Riga 'controlli' $(if (@($fuori | Where-Object esito -eq 'diverso').Count) { 'NO' } elseif ($fuori.Count) { 'avviso' } else { 'ok' }) ("{0} in tutto, {1} ok" -f $controlli.Count, ($controlli.Count - $fuori.Count))
+        foreach ($c in $fuori) {
+            $scarto = if ([double]$c.atteso -ne 0) { ' ({0:+0.00;-0.00}%)' -f ((([double]$c.trovato - [double]$c.atteso) / [Math]::Abs([double]$c.atteso)) * 100) } else { '' }
+            $stato = if ($c.esito -eq 'diverso') { 'NO' } else { 'avviso' }
+            Write-Host ('  {0,-8}' -f $stato) -ForegroundColor $(if ($stato -eq 'NO') { 'Red' } else { 'Yellow' }) -NoNewline
+            Write-Host (" {0}" -f $c.nome)
+            Write-Host ("           trovato {0:N2}, atteso {1:N2}{2}" -f [double]$c.trovato, [double]$c.atteso, $scarto)
+        }
+        if (@($fuori | Where-Object esito -eq 'diverso').Count) {
+            Write-Host ''
+            Write-Host '  Una cifra fuori tolleranza ferma la pubblicazione: online resta lo snapshot di prima.' -ForegroundColor Yellow
+            Write-Host '  Si guarda la cifra (snapshot.yml del progetto), non si forza.' -ForegroundColor Yellow
+        }
+    } catch {
+        Riga 'giro.json' 'avviso' "non leggibile: $($_.Exception.Message)"
+    }
+}
+
+Write-Host ''
+Write-Host "Il log completo: $log"
+Write-Host ''

package/core.js

@@ -209,6 +209,47 @@ export const ASSETSIGNORE = [
 const ROTTE_DEL_CONTENITORE = new Set(['', 'vendor', 'sessione', 'logout']);
 const RIFERIMENTO = /(?:(?:href|src)=["']|fetch\(\s*["'`]|from\s+["']|import\(\s*["'`]|url\(\s*["']?)\/([^"'`)/?#\s]*)/g;
 
+// L'AI passa solo da NOEVA (inferenza NOEVA o NOEVA Agents, ADR 0006): nessun file
+// del progetto lancia la CLI di Claude o chiama un'API di modelli diretta, e
+// serve-app.py non espone le rotte che la lanciavano. Non c'e' eccezione da
+// dichiarare: un token AI che non passa da NOEVA ferma la verifica.
+export const AI_FUORI_DA_NOEVA = [
+  [/\bwhich\(\s*["'`]claude["'`]/, 'cerca la CLI di Claude'],
+  [/["'`]claude["'`]\s*,\s*["'`]-(?:p|-print|-resume|-session-id|-output-format)\b/, 'lancia la CLI di Claude'],
+  [/\bclaude\s+(?:-p|--print)\b/, 'lancia la CLI di Claude'],
+  [/\.local\/bin\/claude\b/, 'cerca la CLI di Claude'],
+  [/\bapi\.anthropic\.com\b|@anthropic-ai\/|^\s*(?:import|from)\s+anthropic\b|\bANTHROPIC_API_KEY\b/m, "chiama l'API di Anthropic diretta"],
+  [/\bapi\.openai\.com\b|^\s*(?:import|from)\s+openai\b|\bOPENAI_API_KEY\b/m, "chiama l'API di OpenAI diretta"],
+  [/\bbedrock-runtime\b|generativelanguage\.googleapis\.com/, 'chiama un servizio di modelli diretto'],
+  [/["'`]\/ai\/(?:chat|chat\/storia|tour|presentazione\/modifica)["'`]/, 'serve una rotta che lanciava la CLI di Claude'],
+];
+const FUORI_DALLA_RICERCA = new Set(['node_modules', '.git', '.wren', '.venv', 'venv', '__pycache__', 'target', 'dist',
+  'vendor', '.claude', '.wrangler', 'dati']);
+
+function fileDelCodice(cartella) {
+  const fuori = [];
+  for (const voce of readdirSync(cartella, { withFileTypes: true })) {
+    if (voce.isDirectory()) {
+      if (!FUORI_DALLA_RICERCA.has(voce.name)) fuori.push(...fileDelCodice(join(cartella, voce.name)));
+    } else if (/\.(py|js|mjs|cjs|ts|sh|ps1|html)$/.test(voce.name)) fuori.push(join(cartella, voce.name));
+  }
+  return fuori;
+}
+
+export function aiFuoriDaNoeva(radice) {
+  const trovati = new Map();
+  for (const f of fileDelCodice(radice)) {
+    const testo = readFileSync(f, 'utf8');
+    for (const [re, cosa] of AI_FUORI_DA_NOEVA) {
+      const m = re.exec(testo);
+      if (!m) continue;
+      const dove = `${posix(relative(radice, f))}:${testo.slice(0, m.index).split('\n').length}`;
+      if (!trovati.has(dove)) trovati.set(dove, `${dove} ${cosa}: l'AI passa solo da NOEVA (inferenza o Agents)`);
+    }
+  }
+  return [...trovati.values()];
+}
+
 function trackedDaGit(radice) {
   if (!existsSync(join(radice, '.git'))) return null;
   try {
@@ -258,6 +299,8 @@ export function verifica(radice, config) {
     }
   }
 
+  errori.push(...aiFuoriDaNoeva(radice));
+
   const tracciati = trackedDaGit(radice);
   if (tracciati) {
     for (const f of tracciati) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noeva/analytics-core",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Gli strumenti di un progetto NOEVA Analytics nel suo repository: moduli di pagina, snapshot, verifica dello standard e kit dell'agente (ADR 0005).",
   "type": "module",
   "bin": {