@mmmbuto/nexuscrew 0.9.30 → 0.9.32

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);

package/lib/notify/routes.js

@@ -19,6 +19,10 @@
 // niente Invio, control char rifiutati): qui si sanifica il testo PRIMA.
 const express = require('express');
 const { createAskAnswerService } = require('./ask-answer-service.js');
+// Gli insiemi degli esiti vivono nella coda: il fan-out decide COSA accodare con
+// la stessa definizione con cui la coda decide cosa ritentare. Due copie della
+// stessa regola sono due regole che prima o poi divergono.
+const { CLOSURE_DONE_STATUSES, CLOSURE_FINAL_STATUSES } = require('./closure-retry.js');
 const { isValidSession } = require('../files/store.js');
 const { normalizeNotificationLang } = require('./language.js');
 const { HOP_HEADER } = require('../proxy/hop-proof.js');
@@ -34,7 +38,12 @@ const NOTIFY_KEYS = new Set(['title', 'body', 'urgency', 'session', 'lang', 'tar
 // Chiavi accettate SOLO su un ingresso federato provato: le mette il
 // dispatcher del nodo di origine, non un chiamante locale.
 const FEDERATED_KEYS = new Set(['originCell', 'originNode']);
-const ASK_KEYS = new Set(['question', 'options', 'session']);
+const ASK_KEYS = new Set(['question', 'options', 'session', 'target']);
+// Chiavi accettate SOLO su un ingresso federato provato: le mette il dispatcher
+// del nodo di origine, non un chiamante locale (stessa regola di FEDERATED_KEYS).
+// `ownerNode`/`originNode` qualificano l'identita', `askId` e' l'id con cui
+// l'owner conosce la domanda (serve alla risposta per tornare sul bersaglio).
+const FEDERATED_ASK_KEYS = new Set(['askId', 'ownerNode', 'originNode', 'originCell', 'closeOutcome']);
 const RATE_MAX = 6;
 const RATE_WINDOW_MS = 60 * 1000;
 const RATE_MAX_BUCKETS = 64;
@@ -103,6 +112,84 @@ function replyLabel(cfg) {
   return clean || 'human';
 }
 
+// Destinatari di una domanda: il `target` esplicito se c'e', altrimenti TUTTI i
+// peer autorizzati di questo nodo. L'enumerazione sta qui e non nel dispatcher
+// perche' il dispatcher conosce solo il target esatto: una wildcard implicita
+// sarebbe un modo per parlare a chi non si e' scelto.
+async function resolveFanTargets(peerTargets, target, self) {
+  if (target !== undefined) return target === self ? [] : [String(target)];
+  if (!peerTargets) return [];
+  let list;
+  try { list = await peerTargets(); } catch (_) { return []; }
+  if (!Array.isArray(list)) return [];
+  const seen = new Set();
+  const out = [];
+  for (const raw of list) {
+    const id = raw && typeof raw === 'object' ? (raw.nodeId || raw.instanceId) : raw;
+    const clean = String(id || '');
+    if (!TARGET_RE.test(clean)) continue;
+    if (self && clean === self) continue;
+    if (seen.has(clean)) continue;
+    seen.add(clean); out.push(clean);
+  }
+  return out;
+}
+
+// La CHIUSURA di un ask segue la stessa strada dell'andata: chi ha ricevuto la
+// domanda deve sapere che e' stata chiusa, altrimenti il suo alias resta aperto
+// e ricompare a ogni reload. Vive come funzione a se' — non su una rotta —
+// perche' deve partire dal punto in cui la transizione e' AUTOREVOLE (il
+// servizio: risposta o scarto, locale o federata) e non da una delle sue porte:
+// legarla alle due route locali lasciava fuori la via federata, che e' il caso
+// normale quando a rispondere e' un altro nodo.
+function createClosureFanout({
+  dispatcher = null, peerTargets = null, localNodeId = () => null, log = () => {},
+  // Recapito RECUPERABILE: un peer spento in questo istante non e' una chiusura
+  // persa. La consegna fallita entra nella coda di ritentativi (lato owner,
+  // l'unico lato che puo' riprovare: il ricevente non ha rotta verso l'owner).
+  retry = null,
+} = {}) {
+  async function dispatch({ askId, outcome, session, retryOnFailure = true, targets = null }) {
+    if (!dispatcher) return [];
+    const self = localNodeId();
+    // `targets` esplicito = ritentativo: si va SOLO verso i pendenti, non di
+    // nuovo verso tutti. Senza, si enumerano i peer autorizzati come sempre.
+    const targets2 = Array.isArray(targets) && targets.length
+      ? targets
+      : await resolveFanTargets(peerTargets, undefined, self);
+    const out = [];
+    for (const target of targets2) {
+      try {
+        const r = await dispatcher.dispatch({
+          resource: '/asks',
+          target,
+          origin: { node: self, cell: session || 'unknown' },
+          payload: { askId, closeOutcome: outcome, ownerNode: self },
+        });
+        out.push({ target, status: r && r.status, ...(r && r.reason ? { reason: r.reason } : {}) });
+      } catch (e) {
+        out.push({ target, status: 'unknown', reason: 'dispatch-threw' });
+        try { log(`chiusura ask ${askId} verso ${target} fallita: ${String(e && e.message || e)}`); } catch (_) {}
+      }
+    }
+    // Si accoda ogni chiusura con recapito PARZIALE, con i SOLI target pendenti.
+    // Prima si accodava solo se NESSUNO aveva ricevuto: bastava che un peer
+    // rispondesse perche' il peer spento sparisse dalla coda — e la sua copia
+    // restava aperta per sempre, perche' da quel lato non c'e' modo di
+    // rimediare (il ricevente non ha rotta verso l'owner).
+    // Il tentativo nato DALLA coda non si riaccoda (sarebbe autoalimentata): la
+    // coda aggiorna da se' il proprio insieme con gli esiti che riceve.
+    if (retryOnFailure && retry && out.length) {
+      const pendenti = out
+        .filter((r) => !CLOSURE_DONE_STATUSES.has(r.status) && !CLOSURE_FINAL_STATUSES.has(r.status))
+        .map((r) => r.target);
+      try { retry.enqueue({ askId, outcome, session, targets: pendenti }); } catch (_) {}
+    }
+    return out;
+  }
+  return { dispatch };
+}
+
 function notifyRoutes({
   cfg, notifier, push, asks, paste, sessionExists,
   fleetP = null, instanceId = null, identityMode = 'legacy',
@@ -110,8 +197,19 @@ function notifyRoutes({
   // route resta esattamente quella locale di prima: nessun percorso nuovo si
   // apre per omissione.
   localNodeId = () => null, originResolver = null, acl = null, dispatcher = null,
+  // Elenco dei peer autorizzati di questo nodo, per il fan-out di default.
+  peerTargets = null,
   federatedRate = null,
-  answerService = null, receipts = null,
+  answerService = null, receipts = null, log = () => {},
+  // Recapito della chiusura: iniettato dal server perche' e' lo STESSO oggetto
+  // che il servizio usa nell'hook di transizione (una sola implementazione).
+  closureFanout: closureFanoutDep = null,
+  // Riconciliazione degli alias importati, iniettata dal server: chiede
+  // all'owner lo stato delle domande ancora aperte per questa copia.
+  reconcileImported = null,
+  // Coda dei recapiti di chiusura non riusciti (lato owner). Iniettata dal
+  // server: la stessa che il fan-out alimenta.
+  closureRetry = null,
 }) {
   // The shared answer cycle is built from the local deps when the caller does
   // not inject one: the local route and the federated surface must never drift
@@ -279,6 +377,16 @@ function notifyRoutes({
   });
 
   // --- asks ------------------------------------------------------------------
+  // Destinatari di una domanda (nessun `target` = tutti i nodi dell'owner): il
+  // `target` esplicito se
+  // c'e', altrimenti TUTTI i peer autorizzati di questo nodo — una domanda e'
+  // per l'utente, ovunque sia. L'enumerazione sta QUI e non nel dispatcher
+  // perche' il dispatcher non conosce i broadcast: target esatto soltanto, e
+  // deve restare cosi' (una wildcard implicita e' un modo per parlare a chi non
+  // si e' scelto).
+  const askFanTargets = (target, self) => resolveFanTargets(peerTargets, target, self);
+  const closureFanout = closureFanoutDep || createClosureFanout({ dispatcher, peerTargets, localNodeId, log, retry: closureRetry });
+
   // da revisione: gated READONLY (mutGate) — crea stato durevole (asks.json) e domande
   // che lo stesso server vieterebbe di rispondere. da revisione: rate-limit creazione
   // (globale per token + per sessione) + cap duro dello store -> 429.
@@ -288,25 +396,160 @@ function notifyRoutes({
       if (!b || typeof b !== 'object' || Array.isArray(b)) {
         return res.status(400).json({ error: 'body deve essere un oggetto JSON' });
       }
+      // Come per /notify: un ingresso e' federato solo se porta la prova di hop,
+      // e si stabilisce PRIMA di guardare il body — quali chiavi sono lecite
+      // dipende da come la richiesta e' arrivata, non da cosa dichiara.
+      const federated = !!(originResolver && req.headers && req.headers[HOP_HEADER]);
       for (const k of Object.keys(b)) {
-        if (!ASK_KEYS.has(k)) return res.status(400).json({ error: `chiave non ammessa: "${k}" (schema: question, options?, session)` });
+        if (ASK_KEYS.has(k)) continue;
+        if (federated && FEDERATED_ASK_KEYS.has(k)) continue;
+        return res.status(400).json({ error: `chiave non ammessa: "${k}" (schema: question, options?, session, target?)` });
       }
+      if (b.target !== undefined && !TARGET_RE.test(String(b.target))) {
+        return res.status(400).json({ error: 'target deve essere un instanceId di nodo' });
+      }
+      // Validazione del contenuto PRIMA del rate check: gli input invalidi (400)
+      // non consumano budget; il rate scatta solo su richieste ben formate.
+      // Una CHIUSURA non porta domanda: non c'e' contenuto da validare.
+      const isClosure = b.closeOutcome === 'dismissed' || b.closeOutcome === 'answered';
+      if (!isClosure) {
+        const v = asks.validate({ question: b.question, options: b.options });
+        if (!v.ok) return res.status(400).json({ error: v.error });
+      }
+      const self = localNodeId();
+
+      // --- ingresso FEDERATO: la domanda arriva da un altro nodo -------------
+      if (federated) {
+        const resolved = await originResolver.resolve(req, { requireCell: true });
+        if (!resolved.ok) return res.status(403).json({ status: 'refused', reason: resolved.reason });
+        // Il target e' esatto e va confermato QUI: una route puo' consegnare a
+        // un nodo diverso da quello che il mittente credeva.
+        if (!self || b.target !== self) {
+          return res.status(404).json({ status: 'refused', reason: 'wrong-target' });
+        }
+        const verdict = acl ? acl.allows(resolved) : { allowed: false, reason: 'acl-unavailable' };
+        if (!verdict.allowed) return res.status(403).json({ status: 'refused', reason: verdict.reason });
+        // Budget SEPARATO da quello locale: senza, un peer rumoroso affamerebbe
+        // le domande delle celle di casa, che condividono lo stesso bucket.
+        // Una CHIUSURA non consuma quella quota: non e' una domanda nuova, e
+        // far pagare anche a lei il budget di creazione significa che un burst
+        // di domande legittimo (6 in un minuto, ammesso dal prodotto) lascia
+        // gli alias aperti sui peer — il successo locale nasconderebbe lo stato
+        // falso. Le chiusure sono limitate dal proprio percorso di recapito.
+        if (federatedRate && !isClosure) {
+          const quota = federatedRate.check({ origin: resolved.origin, target: self, urgency: 'high' });
+          if (!quota.allowed) {
+            return res.status(429).json({ status: 'refused', reason: `rate-${quota.bucket}` });
+          }
+        }
+        // --- chiusura di un ask importato: l'owner ha risposto o scartato ---
+        // L'alias locale va chiuso DUREVOLMENTE: senza, la domanda resta aperta
+        // qui e ricompare a ogni reload, e resterebbe pure risponibile su una
+        // cella che non e' la sua.
+        if (isClosure) {
+          const owner = resolved.origin.node;
+          const closed = asks.closeImported({
+            ownerId: owner, ownerAskId: b.askId, outcome: b.closeOutcome,
+          });
+          if (closed.changed && closed.ask) {
+            // Il frame porta l'id LOCALE: e' quello con cui questa UI identifica
+            // la card, e senza di esso la card resterebbe a schermo.
+            notifier.deliverOnlyRaw({
+              type: b.closeOutcome === 'dismissed' ? 'ask-dismissed' : 'ask-answered',
+              id: closed.ask.id,
+              ownerId: owner,
+            });
+          }
+          return res.json({ status: 'delivered', closed: closed.changed });
+        }
+        // La `session` dichiarata NON e' verificabile qui — la cella vive sul
+        // nodo di origine, e `sessionExists` guarderebbe il tmux di QUESTO nodo.
+        // Non si pretende quindi una sessione locale: si registra per
+        // attribuzione, e il paste avverra' sulla cella dell'owner via ask-relay.
+        const owner = resolved.origin.node;
+        const out = asks.create({
+          question: b.question,
+          options: b.options,
+          session: b.session || resolved.origin.cell || 'unknown',
+          // L'ask e' di un ALTRO nodo: `ownerId` e' quello che fa instradare la
+          // risposta al proprietario invece di incollarla qui.
+          ownerId: owner,
+          // L'id con cui l'OWNER conosce la domanda: e' quello che la risposta
+          // deve citare. Il nostro `id` locale resta nostro.
+          ownerAskId: b.askId,
+          originNode: owner,
+          originCell: resolved.origin.cell,
+        });
+        if (!out.ok) {
+          return res.status(out.reason === 'cap' ? 429 : 400).json({ status: 'refused', reason: out.reason, error: out.error });
+        }
+        const ask = out.ask;
+        // deliverOnly: consegna locale alla UI, NIENTE pubblicazione sul feed e
+        // niente ri-esportazione. E' l'invariante che uccide il loop A->B->A per
+        // costruzione — un ask importato non torna mai indietro, esattamente
+        // come una notify federata.
+        notifier.deliverOnlyRaw({ type: 'ask', ask });
+        await notifier.deliverOnly({
+          title: `domanda da ${ask.session}`,
+          body: ask.question,
+          urgency: 'high',
+          session: ask.session,
+          lang: 'it',
+          askId: ask.id,
+          url: `/#ask=${ask.id}`,
+        });
+        return res.json({ status: 'delivered', id: ask.id, ownerId: ask.ownerId });
+      }
+
+      // --- domanda locale ----------------------------------------------------
       // session obbligatoria E viva: la risposta va incollata li' — un ask senza
       // recapito verificabile e' fail-closed subito, non al momento dell'answer.
       if (!isValidSession(b.session)) return res.status(400).json({ error: 'session non valida' });
       if (!sessionExists(b.session)) return res.status(404).json({ error: 'sessione tmux inesistente' });
-      // Validazione del contenuto PRIMA del rate check: gli input invalidi (400)
-      // non consumano budget; il rate scatta solo su richieste ben formate.
-      const v = asks.validate({ question: b.question, options: b.options });
-      if (!v.ok) return res.status(400).json({ error: v.error });
       const binding = await guardBinding(req, b.session);
       if (binding instanceof Error) return bindingRejected(res, binding);
       if (!allowAsk(b.session)) {
         return res.status(429).json({ error: 'rate limit ask superato (limite globale per token + per sessione)' });
       }
+      // NB: un ask LOCALE non porta `ownerId`. Il campo significa «questa
+      // domanda appartiene a un altro nodo», ed e' quello che fa scegliere alla
+      // UI il ritorno federato (ask-relay) invece del paste locale: metterlo
+      // anche qui manderebbe la risposta di casa a cercare un owner inesistente.
       const out = asks.create({ question: b.question, options: b.options, session: b.session });
       if (!out.ok) return res.status(out.reason === 'cap' ? 429 : 400).json({ error: out.error });
       const ask = out.ask;
+      // FAN-OUT **prima** dell'emissione locale. Un peer irraggiungibile e'
+      // un esito da riportare, mai un blocco: la domanda deve nascere su questo
+      // nodo comunque, e il chiamante vede chi ha accettato e chi no.
+      const targets = dispatcher ? await askFanTargets(b.target, self) : [];
+      const fanout = [];
+      for (const target of targets) {
+        try {
+          const r = await dispatcher.dispatch({
+            resource: '/asks',
+            target,
+            // La cella di origine e' quella DICHIARATA dal chiamante locale:
+            // viaggia come attestazione, e il target la trattera' come tale.
+            origin: { node: self, cell: b.session },
+            payload: {
+              question: ask.question,
+              ...(ask.options ? { options: ask.options } : {}),
+              session: ask.session,
+              askId: ask.id,
+              ownerNode: self,
+            },
+          });
+          fanout.push({ target, status: r && r.status, ...(r && r.reason ? { reason: r.reason } : {}) });
+        } catch (e) {
+          fanout.push({ target, status: 'unknown', reason: 'dispatch-threw' });
+          try { log(`ask fan-out verso ${target} fallito: ${String(e && e.message || e)}`); } catch (_) {}
+        }
+      }
+      if (fanout.length) {
+        try {
+          log(`ask ${ask.id}: fan-out verso ${fanout.length} peer → ${fanout.map((f) => `${f.target.slice(0, 8)}:${f.status}`).join(', ')}`);
+        } catch (_) {}
+      }
       // Frame dedicato per le UI aperte (card/badge live, senza aspettare il poll)…
       notifier.emitRaw({ type: 'ask', ask });
       // …e ogni ask emette anche notify (UI+push, urgency high) con deep-link.
@@ -319,13 +562,26 @@ function notifyRoutes({
         askId: ask.id,
         url: `/#ask=${ask.id}`,
       });
-      res.status(201).json({ id: ask.id });
+      res.status(201).json({ id: ask.id, ...(fanout.length ? { fanout } : {}) });
     } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
   });
 
-  r.get('/asks', (req, res) => {
-    try { res.json({ asks: asks.list({ open: String(req.query.open || '') === '1' }) }); }
-    catch (e) { res.status(500).json({ error: String(e.message || e) }); }
+  r.get('/asks', async (req, res) => {
+    try {
+      // Riconciliazione del ricevente: prima di servire l'elenco si chiede
+      // all'owner lo stato degli alias aperti. E' il percorso che recupera una
+      // chiusura mai recapitata (peer spento mentre l'owner chiudeva): senza,
+      // l'alias resta aperto per sempre e la card mente. Best-effort: un owner
+      // irraggiungibile non chiude nulla e non fa fallire la lettura.
+      if (reconcileImported) { try { await reconcileImported(); } catch (_) {} }
+      // Recapito recuperabile, lato OWNER: i peer che erano spenti quando la
+      // chiusura e' partita vengono ritentati ADESSO. Chi legge lo stato sta
+      // guardando le card, ed e' esattamente il momento in cui una card
+      // rimasta aperta per un recapito fallito va rimessa in pari. Best-effort:
+      // un peer ancora irraggiungibile resta in coda, non fa fallire la lettura.
+      if (closureRetry) { try { await closureRetry.drain('read'); } catch (_) {} }
+      res.json({ asks: asks.list({ open: String(req.query.open || '') === '1' }) });
+    } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
   });
 
   // Dismiss (scarta domanda): NON cancella la riga, la marca `dismissed` (lo
@@ -349,6 +605,10 @@ function notifyRoutes({
         return res.status(500).json({ error: 'dismiss non riuscito' });
       }
       notifier.emitRaw({ type: 'ask-dismissed', id });
+      // La chiusura nasce nel SERVIZIO (punto comune di transizione); qui si
+      // aspetta il suo recapito, cosi' la risposta non precede la chiusura sui
+      // peer e un burst di scarti non lascia alias aperti.
+      if (out.closure) { try { await out.closure; } catch (_) {} }
       res.json({ dismissed: true, id });
     } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
   });
@@ -388,6 +648,8 @@ function notifyRoutes({
       // closure event is emitted by the service, not here.
       const out = await askService.answerLocal({ askId: id, text });
       if (!out.ok) return res.status(out.code || 500).json({ error: out.error });
+      // Come per il dismiss: la chiusura nasce nel servizio, qui si aspetta.
+      if (out.closure) { try { await out.closure; } catch (_) {} }
       res.json({ answered: true, id });
     } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
   });
@@ -443,4 +705,4 @@ function notifyRoutes({
   return r;
 }
 
-module.exports = { notifyRoutes, createRateLimiter, sanitizePasteText, replyLabel };
+module.exports = { notifyRoutes, createRateLimiter, sanitizePasteText, replyLabel, createClosureFanout, resolveFanTargets };

package/lib/proxy/federation.js

@@ -181,6 +181,10 @@ function knownResource(resource) {
     // defers an execution, this one shows text and executes nothing.
     // non esegue nulla. `/audio/speak` esce da un altoparlante in una stanza
     // fisica ed e' gia' federato: una notifica e' meno invasiva di cosi'.
+    // La DOMANDA federata (nc_ask): stessa classe operatore di /notify — mostra
+    // testo sui nodi dell'owner e non esegue nulla. La risposta torna per la
+    // write-back degli ask, che era gia' federata.
+    || resource === '/asks'
     || resource === '/notify'
     || resource === '/audio/capability'
     || resource === '/audio/speak'
@@ -290,9 +294,17 @@ function allowedResource(resource, method = 'GET') {
   // mutazione ai fini di READONLY (sotto): un nodo dichiarato di sola lettura
   // non emette richieste autenticate su comando di un peer.
   if (/^\/fleet\/(credentials\/(?:set|remove)|up|down|restart|engine|boot|define-engine|edit-engine|remove-engine|define-model|remove-model|model-test|define-cell|edit-cell|remove-cell|restore-cells|restore-engines)$/.test(resource)) return method === 'POST';
-  // Notify: solo POST. `/events`, `/asks` e `/push/*` restano NON federati —
-  // SSE non puo' autenticarsi col Bearer e un ask ha un canale di ritorno che
-  // e' un paste nel tmux locale, quindi non attraverserebbe comunque.
+  // Notify: solo POST. `/events` e `/push/*` restano NON federati — SSE non
+  // puo' autenticarsi col Bearer.
+  //
+  // La DOMANDA (`/asks`) invece ORA attraversa, e per la stessa ragione per cui
+  // attraversa /notify: e' testo che appare sulla UI dell'owner, non
+  // un'esecuzione. La obiezione di prima — «un ask ha un canale di ritorno che
+  // e' un paste nel tmux locale, quindi non attraverserebbe comunque» — valeva
+  // per la RISPOSTA, non per la domanda: il ritorno era gia' federato
+  // (`ask-relay.js` → `/event-feed/asks/<id>/answer`). A mancare era solo
+  // l'andata, ed e' quella che questa voce apre. POST e basta: la GET resta
+  // locale, perche' lo snapshot degli ask e' autorevole solo sul proprio nodo.
   // Event feed: GET only, no mutation, no upgrade.
   if (resource === '/event-feed' || resource === '/event-feed/snapshot') return method === 'GET';
   if (/^\/event-feed\/[A-Za-z0-9._-]{1,32}$/.test(resource)) return method === 'GET';
@@ -300,6 +312,7 @@ function allowedResource(resource, method = 'GET') {
   if (/^\/event-feed\/asks\/[a-f0-9]{8}\/answer$/.test(resource)) return method === 'POST';
   if (/^\/event-feed\/asks\/[a-f0-9]{8}$/.test(resource)) return method === 'DELETE';
   if (/^\/event-feed\/asks\/[a-f0-9]{8}\/requests\/[0-9a-f-]{16,64}$/.test(resource)) return method === 'GET';
+  if (resource === '/asks') return method === 'POST';
   if (resource === '/notify') return method === 'POST';
   // Audio: only capability read, speak and stop are exposed through Hydra.
   // audio.consent is a LOCAL mutation and MUST stay unreachable federated.

package/lib/proxy/resource-acl.js

@@ -107,6 +107,12 @@ function classifyResource(resource, method = 'GET') {
   if (resource === '/diagnostics/logs') return m === 'GET' || m === 'DELETE' ? 'operator' : null;
   if (resource === '/diagnostics/verbose') return m === 'PATCH' ? 'operator' : null;
   if (resource === '/ws') return m === 'GET' ? 'operator' : null;
+  // La DOMANDA federata (nc_ask): `/asks` e' la superficie operatore come
+  // `/notify` — mostra testo sui nodi dell'owner e non esegue nulla. Solo POST:
+  // la GET resta locale, lo snapshot degli ask e' autorevole solo sul nodo che
+  // li possiede. NB: non va confusa con `^/asks/<cellId>/(answer|dismiss|status)$`
+  // qui sopra, che e' la write-back verso la CELLA e ha un'altra classe.
+  if (resource === '/asks') return m === 'POST' ? 'operator' : null;
   if (resource === '/notify') return m === 'POST' ? 'operator' : null;
   if (resource === '/audio/capability') return m === 'GET' ? 'operator' : null;
   if (resource === '/audio/speak') return m === 'POST' ? 'operator' : null;