@mmmbuto/nexuscrew 0.9.31 → 0.9.32

package/lib/fleet/model-probe.js

@@ -6,11 +6,20 @@
 // dice se il problema e' il nome del modello, la chiave o la rete. Qui la
 // domanda si fa prima, e la risposta e' un enum chiuso.
 //
-// COSTO: si interroga l'elenco dei modelli (`GET .../models`) e nient'altro.
-// Non si genera testo, quindi non si consumano token. Dove il catalogo non
-// esiste l'esito e' `unverified`: NON si ricade su una richiesta di
-// completamento, per quanto minima. Una prova che costa e' una prova che chi
-// la guarda impara a non fare — e allora tanto vale non averla.
+// COSTO, per gli engine DI CATALOGO: si interroga l'elenco dei modelli
+// (`GET .../models`) e nient'altro. Non si genera testo, quindi non si
+// consumano token. Dove il catalogo non esiste l'esito e' `unverified`: NON si
+// ricade su una richiesta di completamento, per quanto minima. Una prova che
+// costa e' una prova che chi la guarda impara a non fare — e allora tanto vale
+// non averla.
+//
+// COSTO, per un endpoint DICHIARATO A MANO (`probeCustomEndpoint`): la regola
+// sopra vale finche' il catalogo c'e'. Un router locale spesso non espone
+// `GET /models`, e su quel ramo l'alternativa a una richiesta minima non e' una
+// prova gratuita — e' nessuna prova, cioe' un `unverified` su un modello che
+// quasi certamente esiste. Li' si ricade su UN completamento da un token
+// (`max_tokens: 1`) e il testo generato non viene letto ne' registrato: la
+// risposta serve solo a distinguere «c'e'» da «non c'e'».
 //
 // COSA NON ESCE MAI DA QUI:
 //   - il testo che il modello eventualmente genera: non viene letto, non viene
@@ -44,6 +53,98 @@ function modelsUrl(profile) {
   return joinUrl(endpoint, 'models');
 }
 
+// Un endpoint dichiarato A MANO non sta nel catalogo pubblico: la prova si fa
+// sul suo indirizzo. Stessa forma di URL della sonda di prontezza (`/v1` non si
+// ripete), stesso verdetto enum della prova di catalogo — chi legge l'esito non
+// deve sapere da quale dei due rami e' arrivato.
+function chatCompletionsUrl(baseUrl) {
+  const b = String(baseUrl || '').trim().replace(/\/+$/, '');
+  if (!/^https?:\/\//i.test(b)) return null;
+  return /\/v1$/.test(b) ? `${b}/chat/completions` : `${b}/v1/chat/completions`;
+}
+
+// Un endpoint locale spesso non espone `GET /models` (o lo espone vuoto). La
+// seconda via e' la richiesta minima: `max_tokens: 1`, nessun testo letto, e il
+// corpo della risposta NON entra nell'esito. Serve a distinguere «il modello
+// c'e'» da «il modello non c'e'», non a misurare la qualita' della risposta.
+const CUSTOM_FALLBACK_TIMEOUT_MS = 10000;
+
+async function probeCustomEndpoint({
+  endpoint, credential = '', model, fetchImpl = fetch,
+  timeoutMs = DEFAULT_TIMEOUT_MS, fallbackTimeoutMs = CUSTOM_FALLBACK_TIMEOUT_MS,
+} = {}) {
+  const listUrl = modelsUrl({ endpoint });
+  if (!listUrl) return { outcome: 'unverified', latencyMs: 0, detail: 'endpoint non interrogabile' };
+
+  const started = Date.now();
+  const headers = credential ? { authorization: `Bearer ${credential}` } : {};
+  const list = await timedFetch({
+    fetchImpl, url: listUrl, method: 'GET', headers, timeoutMs,
+  });
+  if (list.transport === 'timeout') return { outcome: 'unreachable', latencyMs: list.latencyMs, detail: `timeout (${timeoutMs}ms)` };
+  if (list.transport === 'error') return { outcome: 'unreachable', latencyMs: list.latencyMs, detail: 'endpoint non raggiungibile' };
+  if (list.status === 401 || list.status === 403) return { outcome: 'auth', latencyMs: list.latencyMs };
+  if (list.status >= 200 && list.status < 300) {
+    // Un elenco VUOTO non e' «il modello non c'e'»: e' un endpoint che non
+    // espone un catalogo. Trattarlo come assenza darebbe un falso negativo su
+    // un modello che risponde benissimo — il caso tipico dei router locali.
+    const rows = Array.isArray(list.payload && list.payload.data) ? list.payload.data
+      : Array.isArray(list.payload && list.payload.models) ? list.payload.models : null;
+    if (rows && rows.length) {
+      const found = findInCatalog(list.payload, model);
+      if (found === true) return { outcome: 'ok', latencyMs: list.latencyMs };
+      if (found === false) return { outcome: 'unknown-model', latencyMs: list.latencyMs };
+    }
+    // Elenco assente, vuoto o illeggibile: si prova la via minima invece di
+    // dichiarare `unverified` un modello che probabilmente c'e'.
+  } else if (list.status >= 500) {
+    return { outcome: 'unreachable', latencyMs: list.latencyMs, detail: `http ${list.status}` };
+  }
+
+  const chatUrl = chatCompletionsUrl(endpoint);
+  if (!chatUrl) return { outcome: 'unverified', latencyMs: Date.now() - started, detail: 'endpoint non interrogabile' };
+  const chat = await timedFetch({
+    fetchImpl,
+    url: chatUrl,
+    method: 'POST',
+    headers: { 'content-type': 'application/json', ...headers },
+    body: JSON.stringify({ model, max_tokens: 1, messages: [{ role: 'user', content: 'ping' }] }),
+    timeoutMs: fallbackTimeoutMs,
+  });
+  const latencyMs = Date.now() - started;
+  if (chat.transport === 'timeout') return { outcome: 'unreachable', latencyMs, detail: `timeout (${fallbackTimeoutMs}ms)` };
+  if (chat.transport === 'error') return { outcome: 'unreachable', latencyMs, detail: 'endpoint non raggiungibile' };
+  if (chat.status === 401 || chat.status === 403) return { outcome: 'auth', latencyMs };
+  if (chat.status >= 200 && chat.status < 300) return { outcome: 'ok', latencyMs };
+  // 400/404 su un modello chiesto per nome: l'endpoint risponde e non lo
+  // conosce. E' l'esito piu' utile che si possa dare senza leggere il corpo.
+  if (chat.status === 400 || chat.status === 404 || chat.status === 422) return { outcome: 'unknown-model', latencyMs };
+  return { outcome: 'unverified', latencyMs, detail: `http ${chat.status}` };
+}
+
+// Una fetch sola, con budget proprio, che non solleva mai: l'esito e' un valore.
+async function timedFetch({ fetchImpl, url, method, headers, body, timeoutMs }) {
+  const started = Date.now();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, {
+      method, signal: controller.signal, headers, ...(body ? { body } : {}),
+    });
+    const status = res && typeof res.status === 'number' ? res.status : 0;
+    let payload = null;
+    if (status >= 200 && status < 300) {
+      try { payload = typeof res.json === 'function' ? await res.json() : null; } catch (_) { payload = null; }
+    }
+    return { status, payload, latencyMs: Date.now() - started };
+  } catch (error) {
+    const aborted = error && (error.name === 'AbortError' || error.code === 'ABORT_ERR');
+    return { status: 0, payload: null, latencyMs: Date.now() - started, transport: aborted ? 'timeout' : 'error' };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 function authHeaders(profile, credential) {
   const protocol = profile && profile.protocol;
   if (protocol === 'anthropic_messages') {
@@ -126,4 +227,7 @@ async function probeModel({
   }
 }
 
-module.exports = { probeModel, OUTCOMES, findInCatalog, modelsUrl };
+module.exports = {
+  probeModel, OUTCOMES, findInCatalog, modelsUrl,
+  probeCustomEndpoint, chatCompletionsUrl, CUSTOM_FALLBACK_TIMEOUT_MS,
+};

package/lib/fleet/runtime.js

@@ -20,6 +20,7 @@ const {
 const {
   describeManaged, resolveManagedEngine, discoverOllamaModels, discoverPiModels, extraModelsFrom,
 } = require('./managed.js');
+const { sharedProbe: defaultEndpointProbe } = require('./endpoint-probe.js');
 const {
   httpError, minimalEnv, tmuxExec,
   composeClientInvocation, alternateScreenArgs,
@@ -170,12 +171,29 @@ function createBuiltinRuntime(ctx) {
     // Le discovery esterne hanno budget propri. Avviarle in parallelo mantiene
     // il budget dello status sotto quello del bridge invece di sommare i timeout
     // di Ollama e Pi in sequenza.
-    const [ollamaModels, piModels] = await Promise.all([
+    // Stessa logica per gli endpoint dichiarati a mano: la sonda ha un budget
+    // suo (≤ 1,5 s) e va in parallelo alle discovery, non in coda. Si attende
+    // SOLO cio' che non e' in cache: entro il TTL il verdetto e' gia' noto, ed
+    // e' questo che tiene `nc_status` e la UI lontani dal tempestare i router.
+    const endpointProbe = cfg.endpointProbe || defaultEndpointProbe;
+    const customUrls = [...new Set(cache.defs.engines
+      .map((e) => (e.managed && e.managed.baseUrl ? e.managed.baseUrl : null))
+      .filter(Boolean))];
+    const endpointVerdicts = new Map();
+    const probeEndpoints = customUrls.length
+      ? Promise.all(customUrls.map((u) => endpointProbe.status(u).then((v) => [u, v]).catch(() => [u, null])))
+      : Promise.resolve([]);
+    const [ollamaModels, piModels, probedEndpoints] = await Promise.all([
       needsOllama ? discoverOllamaModels({ ...cfg, home }) : [],
       needsPi ? discoverPiModels({ ...cfg, home }) : {},
+      probeEndpoints,
     ]);
+    for (const [u, v] of probedEndpoints) endpointVerdicts.set(u, v);
     const engines = cache.defs.engines.map((e) => {
-      const managed = e.managed ? describeManaged(e.managed, { ...cfg, home, extraModels: extraModelsFrom(cache.defs), engineId: e.id }) : null;
+      const managed = e.managed ? describeManaged(e.managed, {
+        ...cfg, home, extraModels: extraModelsFrom(cache.defs), engineId: e.id,
+        endpointVerdict: e.managed && e.managed.baseUrl ? endpointVerdicts.get(e.managed.baseUrl) || null : null,
+      }) : null;
       return {
         id: e.id, label: e.label, rc: !!e.rc,
         ...(managed ? {
@@ -190,6 +208,15 @@ function createBuiltinRuntime(ctx) {
                   : (piModels[e.managed.provider] || [])))
               : managed.models),
           configured: managed.configured, reason: managed.reason,
+          // Provenienza della credenziale risolta: prima non arrivava affatto
+          // qui, quindi `nc_status` e la vista non potevano distinguere le
+          // origini nemmeno in teoria. Path, mtime e impronta del valore — il
+          // valore non esce mai da `managed.js`.
+          credentialSource: managed.credentialSource || 'missing',
+          credentialPath: managed.credentialPath || '',
+          credentialMtime: managed.credentialMtime || 0,
+          credentialHash8: managed.credentialHash8 || '',
+          credentialConflict: managed.credentialConflict || null,
         } : { kind: 'custom', configured: true, model: e.model?.value || '', models: [] }),
       };
     });

package/lib/notify/ask-answer-service.js

@@ -61,8 +61,12 @@ function createAskAnswerService({ asks, paste, receipts, onClosure, labelPrefix
     const committed = asks.commit(askId, text);
     if (request && receipts) receipts.finalize(request.peerId, askId, request.requestId, 'committed', null);
     const finalAsk = asks.get(askId);
-    emitClosure('ask-answered', { askId, revision: (finalAsk && finalAsk.revision) || 1, cellSession: finalAsk && finalAsk.session });
-    return { ok: true, committed };
+    const closure = emitClosure('ask-answered', { askId, revision: (finalAsk && finalAsk.revision) || 1, cellSession: finalAsk && finalAsk.session });
+    // `closure` e' il lavoro di recapito della chiusura verso i peer. Nasce QUI,
+    // nel punto in cui la transizione e' autorevole, e non su una rotta: legarlo
+    // alle route locali lasciava fuori la via federata, che e' il caso normale
+    // quando a rispondere e' un altro nodo. Chi puo' attendere lo attende.
+    return { ok: true, committed, closure };
   }
 
   // LOCAL answer: validation and binding already happened in the route.
@@ -115,8 +119,10 @@ function createAskAnswerService({ asks, paste, receipts, onClosure, labelPrefix
     }
     const out = asks.dismiss(askId);
     if (!out.ok) return out;
-    emitClosure('ask-dismissed', { askId, revision: (out.ask && out.ask.revision) || 1, cellSession: out.ask && out.ask.session });
-    return out;
+    const closure = emitClosure('ask-dismissed', { askId, revision: (out.ask && out.ask.revision) || 1, cellSession: out.ask && out.ask.session });
+    // Stesso punto comune dell'answer. `dismiss` resta SINCRONO — i chiamanti
+    // esistenti leggono `ok` subito — e il recapito viaggia come promise a parte.
+    return { ...out, closure };
   }
 
   // Operator reconciliation of a delivery-unknown attempt. The revision is a

package/lib/notify/asks.js

@@ -13,6 +13,10 @@ const ASKS_FILE = 'asks.json';
 // RIFIUTATO (reason 'cap'), mai droppato uno aperto. MAX_KEEP pota solo gli
 // answered piu' vecchi dal file.
 const MAX_OPEN = 100;
+// Cap degli ask IMPORTATI, separato da quello locale (stessa cifra): le domande
+// che arrivano da un peer e quelle poste da questo nodo sono due classi
+// distinte, e le prime non devono poter esaurire il budget delle seconde.
+const MAX_OPEN_IMPORTED = 100;
 const MAX_KEEP = 100;          // ask totali persistiti (i piu' vecchi answered si potano)
 const MAX_QUESTION = 2000;
 const MAX_OPTIONS = 8;
@@ -65,19 +69,58 @@ function createAsksStore(opts = {}) {
     return { ok: true, value: { question: question.trim(), options: opts2 } };
   }
 
-  function openCount() {
-    return load().filter((a) => !a.answered && !a.dismissed).length;
+  // Un ask IMPORTATO appartiene a un altro nodo: lo marca `originNode`, che e'
+  // anche il marcatore che ne impedisce la ri-esportazione.
+  function isImported(a) { return !!(a && a.originNode); }
+
+  function openCount(kind = 'local') {
+    return load().filter((a) => !a.answered && !a.dismissed
+      && (kind === 'imported' ? isImported(a) : !isImported(a))).length;
+  }
+
+  // Identita' CANONICA di un ask importato: la coppia (ownerId, ownerAskId).
+  // L'`id` locale e' nostro e all'owner non dice nulla; e' la coppia che nomina
+  // lo STESSO oggetto sui due nodi, quindi e' la chiave con cui si riconcilia.
+  function findImported(ownerId, ownerAskId) {
+    return load().find((a) => isImported(a) && a.ownerId === String(ownerId)
+      && a.ownerAskId === String(ownerAskId)) || null;
+  }
+
+  // Chiusura dell'alias locale quando l'OWNER chiude la domanda. Durevole: la
+  // riga resta nello storico marcata, quindi non ricompare a un reload e non
+  // torna risponibile.
+  function closeImported({ ownerId, ownerAskId, outcome }) {
+    const ask = findImported(ownerId, ownerAskId);
+    if (!ask) return { ok: true, changed: false, ask: null };
+    if (ask.answered || ask.dismissed) return { ok: true, changed: false, ask };
+    if (outcome === 'answered') { ask.answered = true; ask.answeredReconciled = true; }
+    else ask.dismissed = true;
+    ask.revision = (ask.revision || 0) + 1;
+    save();
+    return { ok: true, changed: true, ask };
   }
 
-  function create({ question, options, session }) {
+  function create({ question, options, session, ownerId, ownerAskId, originNode, originCell }) {
     const v = validate({ question, options });
     if (!v.ok) return { ok: false, reason: 'invalid', error: v.error };
-    // da revisione: cap duro sugli aperti — rifiuto esplicito, MAI drop di ask aperti.
-    if (openCount() >= MAX_OPEN) {
+    // DEDUP: la stessa domanda puo' arrivare due volte allo stesso nodo (import
+    // diretto del fan-out e feed dell'owner). L'identita' canonica e' la coppia
+    // (ownerId, ownerAskId): se l'alias esiste gia', si restituisce quello, non
+    // se ne crea un secondo.
+    if (originNode && ownerId && ownerAskId) {
+      const existing = findImported(ownerId, ownerAskId);
+      if (existing) return { ok: true, ask: existing, deduped: true };
+    }
+    // Cap duro sugli aperti, SEPARATO PER CLASSE: gli importati non consumano il
+    // budget dei locali. Con un cap unico, cento domande ricevute da un peer
+    // lasciavano questo nodo senza poter porre la prima domanda propria.
+    const imported = !!originNode;
+    const cap = imported ? MAX_OPEN_IMPORTED : MAX_OPEN;
+    if (openCount(imported ? 'imported' : 'local') >= cap) {
       return {
         ok: false,
         reason: 'cap',
-        error: `cap ask aperti raggiunto (${MAX_OPEN}): rispondi o attendi prima di crearne altri`,
+        error: `cap ask aperti raggiunto (${cap}): rispondi o attendi prima di crearne altri`,
       };
     }
     const ask = {
@@ -85,6 +128,23 @@ function createAsksStore(opts = {}) {
       question: v.value.question,
       ...(v.value.options ? { options: v.value.options } : {}),
       session: String(session),
+      // Identita' QUALIFICATA dell'ask. `ownerId` e' il nodo che possiede la
+      // domanda: la UI identifica una card con la coppia (ownerId, id) — due
+      // proprietari possono usare lo stesso id locale — e instrada la risposta
+      // al proprietario via ask-relay invece di incollarla qui. Assente = ask
+      // di questo nodo (il caso locale storico).
+      ...(ownerId ? { ownerId: String(ownerId) } : {}),
+      // L'id con cui l'OWNER conosce questa domanda. Su un ask importato l'`id`
+      // locale e' nostro e serve solo a noi; la risposta deve invece citare
+      // l'id dell'owner, perche' e' lui che risolve l'ask nel proprio store.
+      // Senza questo campo una risposta a un ask importato colpirebbe un id
+      // inesistente (o, peggio, un ask locale nostro con lo stesso id).
+      ...(ownerAskId ? { ownerAskId: String(ownerAskId) } : {}),
+      // Provenienza di un ask ARRIVATO dalla federazione. E' il marcatore che
+      // rende esplicito l'invariante: un ask con `originNode` non viene mai
+      // ri-esportato (nessun loop A->B->A). Un ask locale non ha questo campo.
+      ...(originNode ? { originNode: String(originNode) } : {}),
+      ...(originCell ? { originCell: String(originCell) } : {}),
       ts: now(),
       revision: 0,
       answered: false,
@@ -190,7 +250,7 @@ function createAsksStore(opts = {}) {
     return commit(id, text);
   }
 
-  return { create, get, list, openCount, claim, release, commit, markAnswered, markReconciled, isAnswering, dismiss, validate, filePath, MAX_OPEN };
+  return { create, get, list, openCount, isImported, findImported, closeImported, claim, release, commit, markAnswered, markReconciled, isAnswering, dismiss, validate, filePath, MAX_OPEN, MAX_OPEN_IMPORTED };
 }
 
 module.exports = { createAsksStore };

package/lib/notify/closure-retry.js

@@ -0,0 +1,201 @@
+'use strict';
+// Coda di RITENTATIVI della chiusura di un ask, lato OWNER.
+//
+// Il problema che risolve: la chiusura di una domanda segue la stessa strada
+// dell'andata, ma il destinatario puo' essere spento in quel momento. Il suo
+// alias locale resta allora aperto — e ricompare a ogni reload — perche' la
+// transizione e' avvenuta altrove. Il ricevente NON puo' rimediare da solo:
+// nella topologia in cui l'owner si e' collegato a lui (peer `inbound`) non ha
+// ne' rotta ne' credenziale per raggiungerlo. L'unico lato che puo' riprovare
+// e' chi ha emesso la transizione.
+//
+// La coda e' DELIBERATAMENTE piccola e limitata su tre assi indipendenti:
+//   - numero di voci (tetto duro, si scarta la piu' vecchia);
+//   - tentativi per voce (backoff esponenziale, tetto esplicito);
+//   - eta' della voce (TTL: oltre, si rinuncia).
+// Ogni timer e' `unref()`: una coda in attesa non tiene vivo il processo.
+//
+// Due modi per far ripartire un tentativo:
+//   1) il timer di backoff (il caso normale, nessuno guarda);
+//   2) una LETTURA locale dell'elenco degli ask: e' il momento in cui qualcuno
+//      sta guardando lo stato, quindi e' il momento naturale per riconciliare
+//      il recapito. Senza questa seconda via una coda con base di 1 s non
+//      coprirebbe mai una finestra di riavvio del peer di pochi millisecondi,
+//      e il backoff non deve essere accorciato fino a diventare un busy loop.
+
+const BASE_MS = 1000;               // primo ritardo fra i tentativi
+const FACTOR = 2;                   // crescita esponenziale
+const MAX_ATTEMPTS = 6;             // tentativi oltre al primo dispatch
+const TTL_MS = 5 * 60 * 1000;       // oltre questa eta' si rinuncia
+const MAX_ENTRIES = 256;            // tetto duro sulle voci in coda
+const NUDGE_FLOOR_MS = 500;         // distanza minima fra due risvegli da lettura
+
+// Esiti che NON meritano un ritentativo: il peer ha risposto, la chiusura e'
+// arrivata (una seconda consegna della stessa chiusura e' un no-op sul peer,
+// che risponde `delivered` con `closed:false`), oppure ha rifiutato — e un
+// rifiuto non cambia da solo col tempo.
+const DONE_STATUSES = new Set(['delivered', 'no-delivery']);
+const FINAL_STATUSES = new Set(['refused']);
+
+function createClosureRetryQueue({
+  run,                       // async ({askId, outcome, session}) -> [{target, status, reason}]
+  now = () => Date.now(),
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+  baseMs = BASE_MS,
+  factor = FACTOR,
+  maxAttempts = MAX_ATTEMPTS,
+  ttlMs = TTL_MS,
+  maxEntries = MAX_ENTRIES,
+  nudgeFloorMs = NUDGE_FLOOR_MS,
+  log = () => {},
+} = {}) {
+  if (typeof run !== 'function') throw new Error('createClosureRetryQueue: run richiesta');
+  const entries = [];
+  let stopped = false;
+  let lastNudge = null;
+
+  function clearEntry(entry) {
+    if (entry.timer) { try { clearTimer(entry.timer); } catch (_) {} entry.timer = null; }
+  }
+
+  function remove(entry) {
+    clearEntry(entry);
+    const i = entries.indexOf(entry);
+    if (i >= 0) entries.splice(i, 1);
+  }
+
+  // Ritardo del prossimo tentativo: esponenziale, con tetto sul TTL.
+  function schedule(entry) {
+    if (stopped) return;
+    const delay = baseMs * Math.pow(factor, entry.attempts);
+    entry.nextAt = now() + delay;
+    entry.timer = setTimer(() => { attempt(entry, 'backoff'); }, delay);
+    // Non blocca la chiusura del processo: una coda in attesa e' solo una coda.
+    if (entry.timer && typeof entry.timer.unref === 'function') entry.timer.unref();
+  }
+
+  function expired(entry) {
+    return entry.attempts >= maxAttempts || (now() - entry.createdAt) >= ttlMs;
+  }
+
+  async function attempt(entry, why = 'backoff') {
+    if (stopped || entry.inFlight) return;
+    clearEntry(entry);
+    if (expired(entry)) {
+      remove(entry);
+      try { log(`chiusura ask ${entry.askId}: rinuncio dopo ${entry.attempts} tentativi (${why})`); } catch (_) {}
+      return;
+    }
+    entry.inFlight = true;
+    let results = [];
+    // Si ritenta SOLO verso i target ancora pendenti: chi ha gia' risposto non
+    // riceve una seconda consegna inutile.
+    const targets = [...entry.targets];
+    try {
+      results = await run({ askId: entry.askId, outcome: entry.outcome, session: entry.session, targets });
+    } catch (e) {
+      results = targets.map((target) => ({ target, status: 'unknown', reason: 'dispatch-threw' }));
+      try { log(`chiusura ask ${entry.askId}: tentativo fallito (${String(e && e.message || e)})`); } catch (_) {}
+    } finally {
+      entry.inFlight = false;
+    }
+    const list = Array.isArray(results) ? results : [];
+    // IL SET SI AGGIORNA QUI, dal lato della coda: ogni target che ha risposto
+    // esce. `delivered` e `no-delivery` sono consegne, `refused` e' un rifiuto —
+    // in tutti e tre i casi riprovare non aggiunge nulla. Restano i pendenti, e
+    // la voce si chiude quando non ne resta nessuno.
+    for (const r of list) {
+      if (!r || !r.target) continue;
+      if (DONE_STATUSES.has(r.status) || FINAL_STATUSES.has(r.status)) entry.targets.delete(r.target);
+    }
+    const refused = list.filter((r) => r && FINAL_STATUSES.has(r.status));
+    if (refused.length) {
+      try { log(`chiusura ask ${entry.askId}: rifiutata (${refused.map((r) => r.reason || r.status).join(',')})`); } catch (_) {}
+    }
+    if (!entry.targets.size) { remove(entry); return; }
+    entry.attempts += 1;
+    if (expired(entry)) {
+      remove(entry);
+      try { log(`chiusura ask ${entry.askId}: tetto raggiunto, alias lasciato al peer`); } catch (_) {}
+      return;
+    }
+    schedule(entry);
+  }
+
+  // Accoda i target NON raggiunti di una chiusura. La voce e' la COPPIA
+  // (chiusura, insieme dei pendenti): un peer che risponde esce dall'insieme, e
+  // la voce si chiude quando l'insieme e' vuoto. Una seconda `enqueue` per la
+  // stessa chiusura UNISCE i target invece di essere buttata via: e' cio' che
+  // impedisce a un peer spento di sparire dalla coda quando un ALTRO peer
+  // risponde, o quando la stessa chiusura viene riprovata piu' tardi.
+  function enqueue({ askId, outcome, session, targets } = {}) {
+    if (stopped || !askId || !outcome) return { ok: false, reason: 'invalid' };
+    const nuovi = [...new Set((Array.isArray(targets) ? targets : []).map((t) => String(t)).filter(Boolean))];
+    if (!nuovi.length) return { ok: false, reason: 'no-targets' };
+    const existing = entries.find((e) => e.askId === askId && e.outcome === outcome);
+    if (existing) {
+      const prima = existing.targets.size;
+      for (const t of nuovi) existing.targets.add(t);
+      // Se il tentativo precedente era in volo, il nuovo target non era nella
+      // sua lista: la voce va risvegliata, o aspetterebbe il backoff per nulla.
+      if (existing.targets.size !== prima && !existing.inFlight && !existing.timer) schedule(existing);
+      return { ok: true, merged: true, added: existing.targets.size - prima, size: entries.length };
+    }
+    if (entries.length >= maxEntries) {
+      const oldest = entries.shift();
+      clearEntry(oldest);
+      try { log(`coda chiusure piena (${maxEntries}): scartata la piu' vecchia (${oldest.askId})`); } catch (_) {}
+    }
+    const entry = {
+      askId, outcome, session, targets: new Set(nuovi),
+      attempts: 0, createdAt: now(), nextAt: 0, timer: null, inFlight: false,
+    };
+    entries.push(entry);
+    schedule(entry);
+    return { ok: true, size: entries.length };
+  }
+
+  // Risveglio su domanda: chi legge lo stato vuole lo stato VERO. Si ritentano
+  // subito le voci in attesa, senza aspettare il backoff — ma non a ogni
+  // lettura: c'e' una distanza minima fra due risvegli, altrimenti un refresh
+  // ripetuto diventerebbe un martellamento del peer.
+  async function drain(why = 'read') {
+    if (stopped || !entries.length) return { attempted: 0 };
+    const t = now();
+    if (lastNudge !== null && (t - lastNudge) < nudgeFloorMs) return { attempted: 0, throttled: true };
+    lastNudge = t;
+    const snapshot = entries.slice();
+    for (const entry of snapshot) await attempt(entry, why);
+    return { attempted: snapshot.length, size: entries.length };
+  }
+
+  // Svuotamento alla chiusura del server: nessun timer sopravvive.
+  function stop() {
+    stopped = true;
+    for (const entry of entries.slice()) remove(entry);
+    return { cleared: true };
+  }
+
+  return {
+    enqueue, drain, stop,
+    pending: () => entries.map((e) => ({
+      askId: e.askId, outcome: e.outcome, attempts: e.attempts, nextAt: e.nextAt,
+      targets: [...e.targets],
+    })),
+    size: () => entries.length,
+    limits: { baseMs, factor, maxAttempts, ttlMs, maxEntries, nudgeFloorMs },
+  };
+}
+
+module.exports = {
+  createClosureRetryQueue,
+  CLOSURE_DONE_STATUSES: DONE_STATUSES,
+  CLOSURE_FINAL_STATUSES: FINAL_STATUSES,
+  CLOSURE_RETRY_BASE_MS: BASE_MS,
+  CLOSURE_RETRY_FACTOR: FACTOR,
+  CLOSURE_RETRY_MAX_ATTEMPTS: MAX_ATTEMPTS,
+  CLOSURE_RETRY_TTL_MS: TTL_MS,
+  CLOSURE_RETRY_MAX_ENTRIES: MAX_ENTRIES,
+  CLOSURE_RETRY_NUDGE_FLOOR_MS: NUDGE_FLOOR_MS,
+};

package/lib/notify/event-feed-asks-routes.js

@@ -88,6 +88,9 @@ function createEventFeedAsksRoutes(deps) {
       askId, text: body.text, peerId: g.peer.nodeId, requestId: body.requestId,
     });
     if (out.ok) {
+      // La chiusura nasce dal servizio; qui si aspetta il recapito, cosi' chi ha
+      // risposto non vede una risposta che precede la chiusura dei peer.
+      if (out.closure) { try { await out.closure; } catch (_) {} }
       return res.json({ status: out.replay ? out.state : 'committed', requestId: body.requestId });
     }
     return res.status(out.code || 500).json({ error: out.error, reason: out.reason });
@@ -114,6 +117,7 @@ function createEventFeedAsksRoutes(deps) {
       if (out.reason === 'answering') return res.status(409).json({ error: 'risposta in corso: non si scarta un ask in answering' });
       return res.status(500).json({ error: 'dismiss non riuscito' });
     }
+    if (out.closure) { try { await out.closure; } catch (_) {} }
     return res.json({ dismissed: true, id: askId, idempotent: out.idempotent === true });
   });
 

package/lib/notify/event-feed-routes.js

@@ -190,8 +190,16 @@ function createEventFeedRoutes(deps) {
     // Asks: open asks of VISIBLE cells only, capped.
     let asks = [];
     try {
+      const self = typeof deps.localNodeId === 'function' ? deps.localNodeId() : null;
       const open = deps.asksStore.list({ open: true }) || [];
       const visible = open
+        // SOLO gli ask di QUESTO nodo. Un ask importato appartiene al nodo che
+        // l'ha posto: pubblicarlo qui lo consegnerebbe a un terzo peer
+        // attribuito a noi, cioe' a un destinatario che chi ha chiesto non
+        // aveva scelto — la domanda uscirebbe dal perimetro del fan-out. La
+        // guardia e' esplicita sui campi di provenienza, non dedotta dalla
+        // visibilita' della cella.
+        .filter((a) => !a.originNode && !(a.ownerId && self && a.ownerId !== self))
         .map((a) => ({ id: a.id, question: a.question, options: a.options, session: a.session, ts: a.ts }))
         .filter((a) => peer.allows({ scope: 'cell', cellId: deps.cellForSession(a.session) }))
         .slice(0, SNAPSHOT_MAX_ASKS);