@mmmbuto/nexuscrew 0.9.31 → 0.9.32

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;

package/lib/server.js

@@ -87,7 +87,8 @@ function sanitizeReplyLabel(raw) {
   return String(raw === undefined || raw === null ? 'human' : raw)
     .replace(/[\x00-\x1f\x7f\]]/g, '').slice(0, 32) || 'human';
 }
-const { notifyRoutes } = require('./notify/routes.js');
+const { notifyRoutes, createClosureFanout } = require('./notify/routes.js');
+const { createClosureRetryQueue } = require('./notify/closure-retry.js');
 const { createNpmUpdater } = require('./update/manager.js');
 const { createDiagnostics } = require('./diagnostics/store.js');
 const { createDropCounter } = require('./ws/drop-counter.js');
@@ -200,11 +201,36 @@ function createServer(opts = {}) {
   // federated ask surface. The closure event flows through the notifier
   // wrapper so the feed gets a qualified ask-closed envelope.
   const askReceipts = createAskReceipts({ filePath: path.join(notifyDir, 'ask-receipts.json') });
+  // Recapito della chiusura di un ask verso i peer che ne hanno un alias.
+  // Assegnato piu' sotto, quando esistono dispatcher e topologia; l'hook lo
+  // legge a runtime, quindi la dichiarazione in avanti basta.
+  let closureFanout = null;
+  // Recapito recuperabile della chiusura (lato owner): la voce si crea dove
+  // esiste il fan-out, ma la coda serve prima, sulla lettura degli ask.
+  let closureRetry = null;
   const askAnswerService = createAskAnswerService({
     asks: asksStore,
     paste: cfg.pasteSeam || ((session, text) => pasteToSession(cfg.tmuxBin, session, text)),
     receipts: askReceipts,
-    onClosure: (kind, info) => { try { notifier.emitRaw({ type: kind, id: info.askId }); } catch (_) {} },
+    // La chiusura esce da QUI: e' il punto in cui OGNI transizione autorevole
+    // passa — risposta e scarto, rotta locale e rotta federata. Emetterla dalle
+    // due route locali lasciava fuori proprio il caso normale, la risposta che
+    // arriva da un altro nodo. Il fan-out e' lo stesso dell'andata e NON parte
+    // per un ask importato: la chiusura di quello la decide il suo owner.
+    onClosure: (kind, info) => {
+      try { notifier.emitRaw({ type: kind, id: info.askId }); } catch (_) {}
+      try {
+        const ask = asksStore.get(info.askId);
+        if (ask && !ask.originNode && closureFanout) {
+          return closureFanout.dispatch({
+            askId: info.askId,
+            outcome: kind === 'ask-dismissed' ? 'dismissed' : 'answered',
+            session: (ask && ask.session) || info.cellSession,
+          });
+        }
+      } catch (_) {}
+      return null;
+    },
     labelPrefix: sanitizeReplyLabel(cfg && cfg.replyLabel),
   });
   const feedSignatures = new Map(); // peerNodeId -> grant signature last seen
@@ -1037,6 +1063,86 @@ function createServer(opts = {}) {
       topology: topology && Array.isArray(topology.nodes) ? topology.nodes : [],
     });
   };
+  // UN SOLO dispatcher per le domande e per le chiusure: sono la stessa strada
+  // percorsa in due momenti, e il recapito della chiusura deve usare lo stesso
+  // instradamento dell'andata, non una copia con la sua topologia.
+  const askDispatcher = createDispatcher({
+    localNodeId: federatedNodeId,
+    peers: federatedPeers,
+    localPort: () => (server && server.address() ? server.address().port : cfg.port),
+    localToken: () => tokenHolder.value,
+    // 'no-delivery' (-): esito legittimo del target — richiesta accettata
+    // ma nessun canale raggiunto (0 UI, 0 push). Senza questa voce forward()
+    // lo degraderebbe a 'unknown/unreadable-endpoint-result', nascondendo
+    // proprio il silenzio che l'esito esiste per rivelare.
+    statuses: new Set(['delivered', 'no-delivery', 'refused', 'unreachable', 'unknown']),
+  });
+  const askPeerTargets = async () => {
+    const list = await federatedPeers();
+    return (Array.isArray(list) ? list : []).map((p) => p && (p.nodeId || p.instanceId)).filter(Boolean);
+  };
+  // Riconciliazione del RICEVENTE: per ogni alias ancora aperto si chiede
+  // all'owner quali domande sono ancora aperte. Se l'alias non c'e' piu' la'
+  // (l'owner ha risposto o scartato mentre questo nodo era spento), l'alias si
+  // chiude qui. E' la via minima al recapito recuperabile: niente coda
+  // persistente con backoff, un confronto con la fonte autorevole. Sotto il
+  // tetto dello snapshot non si conclude nulla, perche' un'assenza potrebbe
+  // essere un taglio della lista e non una chiusura.
+  const SNAPSHOT_FULL = 100;
+  async function reconcileImportedAsks() {
+    const store = nodesStore.loadStore(nodesPath);
+    if (!store) return;
+    const open = asksStore.list({ open: true }).filter((a) => a.originNode && a.ownerId && a.ownerAskId);
+    if (!open.length) return;
+    const byOwner = new Map();
+    for (const a of open) {
+      if (!byOwner.has(a.ownerId)) byOwner.set(a.ownerId, []);
+      byOwner.get(a.ownerId).push(a);
+    }
+    for (const [ownerId, aliases] of byOwner) {
+      const peer = (store.nodes || []).find((n) => n && n.nodeId === ownerId && n.token && n.localPort);
+      if (!peer) continue;
+      let snap = null;
+      try {
+        const res = await fetch(`http://127.0.0.1:${peer.localPort}/federation/route/_/event-feed/snapshot`, {
+          headers: { authorization: `Bearer ${peer.token}` }, signal: AbortSignal.timeout(3000),
+        });
+        if (!res.ok) continue;
+        snap = await res.json();
+      } catch (_) { continue; }
+      const live = new Set((snap && Array.isArray(snap.asks) ? snap.asks : []).map((x) => String(x.id)));
+      if (live.size >= SNAPSHOT_FULL) continue;
+      for (const alias of aliases) {
+        if (live.has(String(alias.ownerAskId))) continue;
+        try {
+          const closed = asksStore.closeImported({ ownerId, ownerAskId: alias.ownerAskId, outcome: 'dismissed' });
+          if (closed.changed && closed.ask) {
+            try { notifier.deliverOnlyRaw({ type: 'ask-dismissed', id: closed.ask.id, ownerId }); } catch (_) {}
+          }
+        } catch (_) { /* un alias non chiudibile non ferma gli altri */ }
+      }
+    }
+  }
+  // Assegnato ORA che dispatcher e topologia esistono (l'hook lo legge a runtime).
+  closureRetry = createClosureRetryQueue({
+    log: opts.log || console.log,
+    // Il tentativo nasce DALLA coda: non si riaccoda (sarebbe autoalimentata).
+    // `targets` e' l'insieme dei pendenti della voce: il ritentativo va SOLO
+    // verso quelli. Senza, ogni ritentativo rimanderebbe la chiusura anche a chi
+    // l'ha gia' ricevuta — rumore, non danno, ma nemmeno una coda che sa cosa
+    // le manca.
+    run: ({ askId, outcome, session, targets }) => (closureFanout
+      ? closureFanout.dispatch({ askId, outcome, session, retryOnFailure: false, targets })
+      : Promise.resolve([])),
+  });
+  closureFanout = createClosureFanout({
+    dispatcher: askDispatcher,
+    peerTargets: askPeerTargets,
+    localNodeId: federatedNodeId,
+    log: opts.log || console.log,
+    retry: closureRetry,
+  });
+
   api.use(notifyRoutes({
     cfg,
     notifier,
@@ -1056,20 +1162,24 @@ function createServer(opts = {}) {
       hopSecret: () => hopSecret,
     }),
     acl: createAudioAcl({ nodesPath }),
-    dispatcher: createDispatcher({
-      localNodeId: federatedNodeId,
-      peers: federatedPeers,
-      localPort: () => (server && server.address() ? server.address().port : cfg.port),
-      localToken: () => tokenHolder.value,
-      // 'no-delivery' (-): esito legittimo del target — richiesta accettata
-      // ma nessun canale raggiunto (0 UI, 0 push). Senza questa voce forward()
-      // lo degraderebbe a 'unknown/unreadable-endpoint-result', nascondendo
-      // proprio il silenzio che l'esito esiste per rivelare.
-      statuses: new Set(['delivered', 'no-delivery', 'refused', 'unreachable', 'unknown']),
-    }),
+    dispatcher: askDispatcher,
+    closureFanout,
+    peerTargets: askPeerTargets,
+    reconcileImported: reconcileImportedAsks,
+    closureRetry,
     federatedRate: createSpeakRateLimiter(),
     answerService: askAnswerService,
     receipts: askReceipts,
+    // Elenco dei peer autorizzati per il fan-out di default della domanda
+    // (nessun `target` → tutti i nodi dell'owner). Il
+    // dispatcher resta a target esatto: l'enumerazione la fa la route.
+    peerTargets: async () => {
+      const list = await federatedPeers();
+      return (Array.isArray(list) ? list : [])
+        .map((p) => p && (p.nodeId || p.instanceId))
+        .filter(Boolean);
+    },
+    log: opts.log || console.log,
   }));
   // Event feed: the closed SSE/JSON surface, mounted inside the
   // authenticated API. Its own gate demands a proven federated origin and an
@@ -1113,7 +1223,13 @@ function createServer(opts = {}) {
     loadStore: () => nodesStore.loadStore(nodesPath),
     log: opts.log || console.log,
   });
-  api.post('/asks-relay', async (req, res) => {
+  // Il body va parsato QUI: il router `api` non monta un parser globale, ogni
+  // rotta porta il suo (`express.json`) — vedi /sessions, /notify, /asks.
+  // Senza, `req.body` e' undefined, il relay legge un body vuoto e risponde
+  // 400 «ownerId, askId e text richiesti» a OGNI richiesta: la risposta
+  // federata non ha mai potuto attraversare, e nessun test copriva questa
+  // rotta. Difetto preesistente, trovato scrivendo il test del ritorno federato.
+  api.post('/asks-relay', express.json({ limit: '8kb' }), async (req, res) => {
     try {
       const b = req.body || {};
       if (b.action === 'dismiss') {
@@ -1500,6 +1616,8 @@ function createServer(opts = {}) {
   server.on('close', () => {
     diagnostics.record('info', 'server', 'SERVER_STOPPED', 'NexusCrew server stopped', { reason: 'close' });
     watcher.close(); previews.close(); eventsHub.closeAll(); updater.close(); ptyGrace.close();
+    // Nessun timer di ritentativo sopravvive alla chiusura del server.
+    if (closureRetry) { try { closureRetry.stop(); } catch (_) {} }
     for (const timer of reverseWatchers.values()) clearInterval(timer);
     reverseWatchers.clear(); rotatableReverse.clear(); void reverseSlotListeners?.closeAll();
     // Il pannello non sopravvive al control plane: senza requireToken sopra,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscrew",
-  "version": "0.9.31",
+  "version": "0.9.32",
   "description": "Faithful browser tmux client — attach to live sessions over a real PTY, localhost-only, mobile-easy",
   "main": "lib/server.js",
   "bin": {