@mmmbuto/nexuscrew 0.8.52-rc.2 → 0.8.52-rc.21

package/lib/cells/scope.js

@@ -0,0 +1,127 @@
+'use strict';
+// lib/cells/scope.js — quali celle di QUESTO nodo un peer federato puo' vedere.
+//
+// Gemello di lib/audio/acl.js, e per le stesse ragioni:
+//   * la sorgente della decisione e' il node store locale, mai il corpo della
+//     richiesta. Un peer non dichiara il proprio scope: lo subisce.
+//   * l'identita' arriva dalla catena `visited` che costruisce il server
+//     (controlledVisited), non da un campo dichiarato.
+//
+// Due invarianti che una versione semplificata romperebbe in silenzio:
+//
+//   1. In multi-hop lo scope e' l'INTERSEZIONE fra chi consegna e chi origina.
+//      `canTransit` autorizza il transito, non l'accesso: un peer B puo'
+//      instradare una richiesta di C. Guardare solo B lascerebbe C ereditare i
+//      permessi di B. lib/audio/acl.js risolve lo stesso caso controllando
+//      entrambi, e qui va replicato invece che semplificato.
+//   2. Una sessione tmux e' concessa solo se lo e' la CELLA a cui appartiene, e
+//      una sessione che non appartiene a nessuna cella non e' "libera": e'
+//      fuori scope. Altrimenti basterebbe una tmux creata a mano per aggirare
+//      il permesso — e `/ws` attacca proprio per nome di sessione.
+//
+// Il permesso e' indicizzato per `nodeId`, non per `name`: il name e' uno slug
+// locale rinominabile, il nodeId e' l'identita' stabile provata dal pairing.
+const nodesStore = require('../nodes/store.js');
+
+// Scope di un singolo nodo, normalizzato. `all` non elenca nulla di proposito:
+// una lista che significa "tutte" invecchierebbe a ogni cella nuova.
+function scopeOf(node) {
+  if (!node) return { mode: 'none', cells: new Set() };
+  const mode = node.cellVisibility || 'all';
+  if (mode === 'all') return { mode: 'all', cells: null };
+  if (mode === 'none') return { mode: 'none', cells: new Set() };
+  return { mode: 'selected', cells: new Set(Array.isArray(node.cells) ? node.cells : []) };
+}
+
+// Intersezione di due scope. `all` e' l'elemento neutro; `none` assorbe.
+function intersect(a, b) {
+  if (a.mode === 'none' || b.mode === 'none') return { mode: 'none', cells: new Set() };
+  if (a.mode === 'all') return b;
+  if (b.mode === 'all') return a;
+  return { mode: 'selected', cells: new Set([...a.cells].filter((c) => b.cells.has(c))) };
+}
+
+function findByNodeId(st, nodeId) {
+  if (!st || !Array.isArray(st.nodes) || !nodeId) return null;
+  return st.nodes.find((n) => n && n.nodeId === nodeId) || null;
+}
+
+// createCellScope(): deps esplicite, nessun accesso globale.
+//   nodesPath       percorso del node store
+//   loadStoreImpl   iniettabile nei test
+//   cellForSession  mappa tmuxSession -> id cella (null se non e' di una cella)
+function createCellScope({ nodesPath, loadStoreImpl = nodesStore.loadStore, cellForSession = () => null } = {}) {
+  // Scope "tutto", usato dal percorso locale: il proprietario della macchina
+  // non si limita da solo, e questo modulo non e' il posto dove decidere
+  // altrimenti.
+  function openScope() {
+    return buildApi({ mode: 'all', cells: null });
+  }
+
+  function buildApi(resolved, localNodeId = null) {
+    const allowsCell = (cell) => {
+      if (resolved.mode === 'all') return true;
+      if (resolved.mode === 'none') return false;
+      return typeof cell === 'string' && resolved.cells.has(cell);
+    };
+    const allowsSession = (session) => {
+      if (resolved.mode === 'all') return true;
+      const cell = cellForSession(session);
+      // Nessuna cella dietro la sessione => fuori scope. Vedi invariante 2.
+      if (!cell) return false;
+      return allowsCell(cell);
+    };
+    // Un tile di deck che punta a un ALTRO nodo non e' una cella di questo
+    // hub: lo scope celle governa le celle locali, e la topologia ha gia' le
+    // sue regole (canTransit, allowlist federata). Quando pero' non sappiamo
+    // chi siamo, un `ownerId` non confrontabile si tratta come LOCALE: e' il
+    // verso fail-closed, perche' l'errore costa un tile in meno invece di un
+    // nome di cella in piu'.
+    const tileIsRemote = (tile) => {
+      if (!tile || typeof tile !== 'object') return false;
+      if (typeof tile.node === 'string' && tile.node) return true;
+      if (typeof tile.ownerId === 'string' && tile.ownerId) {
+        return localNodeId ? tile.ownerId !== localNodeId : false;
+      }
+      return false;
+    };
+    return {
+      mode: resolved.mode,
+      cells: resolved.cells ? [...resolved.cells] : null,
+      allowsCell,
+      allowsSession,
+      allowsTile: (tile) => tileIsRemote(tile) || allowsSession(tile && tile.session),
+      // Filtri: gli elenchi si restringono con lo STESSO predicato che decide
+      // le azioni. Due implementazioni divergenti sarebbero un bug latente.
+      filterCells: (list) => (Array.isArray(list) ? list.filter((c) => allowsCell(c && (c.cell ?? c.id))) : []),
+      filterSessions: (list) => (Array.isArray(list) ? list.filter((s) => allowsSession(s && (s.name ?? s.tmuxSession))) : []),
+    };
+  }
+
+  // resolve({trust, visited}) -> api dello scope.
+  //   trust 'local-bridge' (o assente e non federato) : nessuna restrizione
+  //   trust 'federated'                                : intersezione consegnante ∩ origine
+  function resolve({ trust, visited } = {}) {
+    if (trust !== 'federated') return openScope();
+    const chain = Array.isArray(visited) ? visited : [];
+    // Serve almeno origine + questo nodo. Una catena piu' corta non identifica
+    // nessun peer: fail-closed.
+    if (chain.length < 2) return buildApi({ mode: 'none', cells: new Set() });
+
+    let st;
+    try { st = loadStoreImpl(nodesPath); } catch (_) { st = null; }
+    if (!st) return buildApi({ mode: 'none', cells: new Set() });
+
+    const deliveringId = chain[chain.length - 2];
+    const originId = chain[0];
+    const delivering = scopeOf(findByNodeId(st, deliveringId));
+    // Quando origine e consegnante coincidono (hop singolo) l'intersezione con
+    // se stesso e' identita': nessun caso speciale da mantenere allineato.
+    const origin = originId === deliveringId ? delivering : scopeOf(findByNodeId(st, originId));
+    return buildApi(intersect(delivering, origin), st.nodeId || null);
+  }
+
+  return { resolve };
+}
+
+module.exports = { createCellScope, scopeOf, intersect };

package/lib/cli/commands.js

@@ -61,6 +61,7 @@ Usage:
                          [--persist]
   nexuscrew nodes rename <name|nodeId> --label TEXT
   nexuscrew nodes visibility <name|nodeId> network|relay-only|selected
+  nexuscrew nodes cells <name|nodeId> all|none|Cella1,Cella2
                          [--selected NODE_ID,...]
   nexuscrew nodes share <name|nodeId> on|off [--json]
   nexuscrew nodes invite --ssh TARGET [--ssh-port PORT] [--name SLUG]
@@ -985,11 +986,32 @@ async function dispatchNodes(rest, flags, opts = {}) {
       : String(flags.selected).split(',').map((value) => value.trim()).filter(Boolean);
     return { code: nodesCmds.nodesEdit({ ...opts, log, ref, patch: { visibility, selected } }).code };
   }
+  // Scope celle (NC-E): quali celle di QUESTO nodo il peer puo' vedere.
+  // Diverso da `visibility`, che governa il transito e non l'accesso.
+  if (sub === 'cells') {
+    const arg = rest[3];
+    if (!arg) {
+      log('nodes cells: uso `nodes cells <nodo> all|none|Cella1,Cella2`');
+      return { code: 1 };
+    }
+    if (arg === 'all' || arg === 'none') {
+      return { code: nodesCmds.nodesEdit({ ...opts, log, ref, patch: { cellVisibility: arg, cells: undefined } }).code };
+    }
+    const cells = String(arg).split(',').map((v) => v.trim()).filter(Boolean);
+    if (!cells.length) { log('nodes cells: elenco vuoto — usa `none` se intendi nessuna cella'); return { code: 1 }; }
+    return { code: nodesCmds.nodesEdit({ ...opts, log, ref, patch: { cellVisibility: 'selected', cells } }).code };
+  }
   if (sub === 'remove') {
     if (flags.yes !== true) { log('nodes remove: conferma richiesta con --yes'); return { code: 1 }; }
     return { code: nodesCmds.nodesRemove({ ...opts, log, ref }).code };
   }
-  if (sub === 'test') return { code: (await nodesCmds.nodesTest({ ...opts, log, ref })).code };
+  // Senza riferimento non e' un errore: e' la domanda "quali nodi sono davvero
+  // condivisi?", che prima si poteva fare solo un nodo alla volta.
+  if (sub === 'test') {
+    return ref
+      ? { code: (await nodesCmds.nodesTest({ ...opts, log, ref })).code }
+      : { code: (await nodesCmds.nodesTestAll({ ...opts, log })).code };
+  }
   if (['up', 'down', 'connect', 'disconnect', 'restart', 'reconnect'].includes(sub)) {
     const fn = sub === 'up' || sub === 'connect' ? nodesCmds.nodesUp
       : sub === 'restart' || sub === 'reconnect' ? nodesCmds.nodesRestart : nodesCmds.nodesDown;

package/lib/mcp/tools.js

@@ -237,6 +237,10 @@ const TOOLS = [
           type: 'string',
           description: 'lingua opzionale del testo: it, en, es o locale BCP-47 equivalente (es. it-IT)',
         },
+        target: {
+          type: 'string',
+          description: 'instanceId ESATTO del nodo su cui sta l\'operatore, per avvisarlo quando non e\' su questo nodo. Ottienilo da nc_cells/nc_status; niente wildcard. Omesso = questo nodo.',
+        },
       },
       required: ['title'],
     },
@@ -245,6 +249,10 @@ const TOOLS = [
       const body = argString(args, 'body', { max: 2000 });
       const urgency = argString(args, 'urgency', { max: 16 });
       const rawLang = argString(args, 'lang', { max: 35 });
+      const target = argString(args, 'target', { max: 64 });
+      if (target !== undefined && !/^[a-f0-9]{32}$/i.test(target)) {
+        throw new Error('target deve essere un instanceId di nodo (32 hex)');
+      }
       if (urgency !== undefined && urgency !== 'normal' && urgency !== 'high') {
         throw new Error('urgency deve essere "normal" o "high"');
       }
@@ -258,9 +266,18 @@ const TOOLS = [
         ...(body ? { body } : {}),
         ...(urgency ? { urgency } : {}),
         ...(lang ? { lang } : {}),
+        ...(target ? { target } : {}),
       };
       if (session) payload.session = session;
       const j = await ctx.api('POST', '/api/notify', payload);
+      // Con un target remoto l'esito e' quello del nodo che ha consegnato:
+      // `delivered` da solo direbbe "0 tentativi qui", che e' vero e inutile.
+      // Restituirlo cosi' evita di far leggere un successo dove c'e' un rifiuto.
+      // Nessun conteggio: il dispatcher non lo propaga, e un ramo che non puo'
+      // mai essere vero e' codice morto travestito da informazione
+      // (rilievo R1 di DevAuditor su rc.14). Se un giorno servira' il dettaglio,
+      // va fatto propagare da forward(), non dedotto qui.
+      if (target) return { status: j.status, ...(j.reason ? { reason: j.reason } : {}) };
       return { delivered: j.delivered };
     },
   },

package/lib/nodes/commands.js

@@ -252,6 +252,15 @@ function nodesInspect(opts) {
     log(`tipo:      ${peer.kind} · ${peer.relation}`);
     log(`route:     ${peer.route.join(' -> ')}`);
     if (peer.tunnel) log(`status:    ${peer.tunnel.status}`);
+    // Uno scope celle ristretto e' una limitazione che l'operatore ha imposto
+    // e che poi non vede piu' da nessuna parte: si dimentica, e il giorno che
+    // un peer "non trova" una cella la causa e' invisibile. Il caso `all` non
+    // si stampa: e' il default, e una riga per dire "nessun limite" e' rumore.
+    if (peer.cellVisibility === 'none') log('celle:     nessuna (scope: none)');
+    else if (peer.cellVisibility === 'selected') {
+      const cells = Array.isArray(peer.cells) ? peer.cells : [];
+      log(`celle:     ${cells.length ? cells.join(', ') : 'nessuna (elenco vuoto)'} (scope: selected)`);
+    }
     log(`azioni:    ${Object.keys(peer.actions || {}).filter((key) => peer.actions[key]).join(', ')}`);
   }
   return { code: 0, peer: found.peer };
@@ -267,9 +276,12 @@ function nodesEdit(opts) {
   const node = resolveStoredNode(st, opts.ref || opts.name);
   if (!node) { log(`nodes edit: nodo sconosciuto "${opts.ref || opts.name || ''}"`); return { code: 1, reason: 'unknown-node' }; }
   const supplied = opts.patch && typeof opts.patch === 'object' ? opts.patch : {};
+  // Lo scope celle vale per QUALUNQUE peer accoppiato, in entrambe le
+  // direzioni: riguarda chi accede alle celle di questo nodo, non chi ha
+  // aperto il tunnel.
   const allowed = node.direction === 'inbound'
-    ? new Set(['label', 'visibility', 'selected'])
-    : new Set(['label', 'ssh', 'sshPort', 'autostart']);
+    ? new Set(['label', 'visibility', 'selected', 'cellVisibility', 'cells'])
+    : new Set(['label', 'ssh', 'sshPort', 'autostart', 'cellVisibility', 'cells']);
   const keys = Object.keys(supplied);
   const invalid = keys.find((key) => !allowed.has(key));
   if (invalid) {
@@ -298,6 +310,13 @@ function nodesEdit(opts) {
     log('nodes edit: visibility non valida'); return { code: 1, reason: 'invalid-visibility' };
   }
   if (patch.visibility !== 'selected') delete patch.selected;
+  // Stessa simmetria per lo scope celle. `delete` non basterebbe: updateNode
+  // fonde patch e nodo esistente, quindi le celle concesse prima
+  // sopravviverebbero alla modalita' che le revoca — e tornerebbero buone al
+  // primo ritorno a `selected`, concedendo in silenzio cio' che l'operatore
+  // credeva di aver tolto. `undefined` invece le fa sparire, perche' parseNode
+  // ricostruisce il nodo da zero.
+  if (Object.hasOwn(patch, 'cellVisibility') && patch.cellVisibility !== 'selected') patch.cells = undefined;
 
   let next;
   try { next = store.updateNode(st, node.name, patch); }
@@ -475,6 +494,70 @@ async function nodesTest(opts) {
   };
 }
 
+// `nodes test` senza riferimento: prova TUTTI i peer diretti e chiude con le
+// incoerenze.
+//
+// Nasce da un caso reale: tre peer su quattro risultavano "Share enabled" e uno
+// solo aveva davvero il canale inverso attivo. La diagnosi c'era gia' —
+// `nodes test <nodo>` distingue OK, KO e passivo con precisione — ma andava
+// lanciata un nodo alla volta, sapendo gia' di doverlo fare. Uno stato che
+// mostra il DESIDERIO ("Share enabled") accanto a nessuna verifica non e' una
+// bugia del codice: e' una domanda che nessuno pensa di fare.
+//
+// Il valore non e' l'elenco, che si otteneva anche prima: e' l'ultima riga.
+async function nodesTestAll(opts) {
+  const log = opts.log || console.log;
+  const { nodesPath } = resolveNodePaths(opts);
+  const st = store.loadStore(nodesPath);
+  const nodes = st && Array.isArray(st.nodes) ? st.nodes : [];
+  if (!nodes.length) {
+    log('nodes test: nessun nodo configurato');
+    return { code: 0, results: [] };
+  }
+  // In parallelo: un peer irraggiungibile consuma il proprio timeout, e in
+  // sequenza quattro nodi spenti farebbero sembrare rotto il comando.
+  const results = await Promise.all(nodes.map(async (node) => {
+    const lines = [];
+    let outcome;
+    try {
+      outcome = await nodesTest({ ...opts, ref: node.name, log: (line) => lines.push(String(line)) });
+    } catch (e) {
+      outcome = { code: 1, result: 'errore', detail: String(e && e.message || e) };
+    }
+    return {
+      name: node.name,
+      shared: node.shared === true,
+      result: outcome.result || 'sconosciuto',
+      line: lines.length ? lines[lines.length - 1] : `nodes test [${node.name}]: esito non riportato`,
+    };
+  }));
+  for (const entry of results) log(entry.line);
+
+  // L'incoerenza che conta: dichiarato condiviso, canale non verificabile.
+  // Non e' per forza un difetto — un dispositivo spento finisce qui — ma e'
+  // esattamente cio' che lo stato mostrato non dice.
+  const declaredNotProven = results.filter((entry) => entry.shared && entry.result !== 'ok');
+  if (declaredNotProven.length) {
+    log('');
+    log(`nodes test: ${declaredNotProven.length} nodo/i risultano condivisi ma il canale inverso non risponde: ${declaredNotProven.map((entry) => entry.name).join(', ')}`);
+    // La riga esiste per essere letta da chi ha il problema. Dice DOVE
+    // guardare (qui, sull'hub), COSA deve esserci (le porte del pool di quel
+    // dispositivo) e la parola da cercare (permitlisten).
+    //
+    // La concessione sta sull'HUB, non sul dispositivo: il dispositivo CHIEDE
+    // il bind reverse, ma e' lo sshd di questa macchina a concederlo o negarlo
+    // in base alla riga di `authorized_keys` che porta la sua chiave. Mandare
+    // l'operatore a cercare sul dispositivo sarebbe peggio di una riga vaga —
+    // lo si manderebbe dalla parte sbagliata, che e' esattamente il modo in cui
+    // questo difetto e' rimasto aperto per giorni.
+    log('nodes test: "Share attivo" e\' lo stato desiderato, non una verifica. Un dispositivo spento finisce qui; se e\' acceso, il bind inverso viene rifiutato prima di salire: su QUESTO hub, la chiave di quel dispositivo in ~/.ssh/authorized_keys deve concedere le porte del suo pool (opzione SSH permitlisten).');
+  }
+  // Esito 0 anche con incoerenze: questo comando RIFERISCE, non giudica. Un
+  // codice diverso da zero farebbe fallire ogni script che lo usa per stampare
+  // lo stato, e un dispositivo spento non e' un errore dell'installazione.
+  return { code: 0, results, declaredNotProven: declaredNotProven.map((entry) => entry.name) };
+}
+
 // probe HTTP di default (fetch built-in, Node >=18). Ritorna {ok, status}.
 async function defaultHttpProbe(url, headers) {
   const res = await fetch(url, { headers, redirect: 'manual' });
@@ -576,7 +659,7 @@ function nodesSetToken(opts) {
 }
 
 module.exports = {
-  nodesAdd, nodesList, nodesInspect, nodesEdit, nodesRemove, nodesTest,
+  nodesAdd, nodesList, nodesInspect, nodesEdit, nodesRemove, nodesTest, nodesTestAll,
   nodesUp, nodesDown, nodesRestart, nodesSetToken,
   // helper esposti per test/riuso
   assignLocalPort, bindLocalPort, reserveLocalPort, defaultKeyPath, ensureKey, readSecretToken,

package/lib/nodes/store.js

@@ -108,8 +108,17 @@ const NODE_KEYS = new Set([
   'name', 'ssh', 'sshPort', 'remotePort', 'localPort', 'keyPath', 'identityFile',
   'roles', 'rolesKnown', 'token', 'acceptToken', 'nodeId', 'transport', 'autostart', 'visibility', 'selected',
   'direction', 'reversePort', 'shared', 'label', 'reversePool',
+  // Quali CELLE di questo nodo il peer puo' vedere. Distinto da `visibility`,
+  // che governa il TRANSITO (attraverso chi passa il traffico) e non l'accesso.
+  'cellVisibility', 'cells',
 ]);
 
+// Nome di cella: stessa forma usata da fleet/definitions.js, cells/routes.js e
+// mcp/cells.js. E' `cell` la chiave del permesso — unica nel nodo e immutabile —
+// non `tmuxSession`, che e' derivata e ammette override non canonici.
+const CELL_ID_RE = /^[A-Za-z0-9._-]{1,32}$/;
+const MAX_CELLS = 128;
+
 const REVERSE_POOL_SLOT_STATES = new Set(['active', 'ready', 'reserved', 'draining', 'quarantined', 'retired']);
 const REVERSE_POOL_VERIFICATIONS = new Set(['verified', 'unverifiable', 'missing', 'invalidated']);
 const REVERSE_POOL_PHASES = new Set(['active', 'prepared', 'switched', 'abandoned']);
@@ -265,6 +274,28 @@ function parseNode(n, schemaVersion = SCHEMA_VERSION) {
     if (selected.some((id) => typeof id !== 'string' || !NODE_ID_RE.test(id))) return null;
     out.selected = selected;
   }
+  // Scope celle. Il default e' `all` quando il campo e' ASSENTE: un default
+  // fail-closed renderebbe muta l'intera flotta al primo aggiornamento, senza
+  // che nessuno abbia deciso nulla. Restringere deve restare un atto esplicito.
+  // `selected` con lista vuota significa invece "nessuna cella", ed e' proprio
+  // per distinguerlo da "campo assente" che la modalita' e' un campo a parte.
+  if (n.cellVisibility !== undefined) {
+    if (!['all', 'none', 'selected'].includes(n.cellVisibility)) return null;
+    out.cellVisibility = n.cellVisibility;
+  } else {
+    out.cellVisibility = 'all';
+  }
+  if (n.cells !== undefined) {
+    // Elencare celle senza dichiarare la modalita' e' ambiguo: l'elenco
+    // sembrerebbe un permesso mentre non lo e'. Meglio rifiutare che indovinare.
+    if (out.cellVisibility !== 'selected') return null;
+    if (!Array.isArray(n.cells) || n.cells.length > MAX_CELLS) return null;
+    const cells = [...new Set(n.cells)];
+    if (cells.some((id) => typeof id !== 'string' || !CELL_ID_RE.test(id))) return null;
+    out.cells = cells;
+  } else if (out.cellVisibility === 'selected') {
+    out.cells = [];
+  }
   // Campo opzionale per compatibilita' con gli store 0.8.0: se assente, ssh
   // continua a usare la porta risolta da ~/.ssh/config o il default OpenSSH.
   if (n.sshPort !== undefined) out.sshPort = n.sshPort;
@@ -577,6 +608,10 @@ function redactNode(n) {
   };
   if (n.identityFile || n.keyPath) out.hasIdentity = true;
   if (n.visibility === 'selected') out.selected = [...(n.selected || [])];
+  // Lo scope celle non e' un segreto: e' una decisione dell'operatore e va
+  // mostrata, come `selected`. La Settings UI deve poterla leggere per dirla.
+  out.cellVisibility = n.cellVisibility || 'all';
+  if (out.cellVisibility === 'selected') out.cells = [...(n.cells || [])];
   if (n.sshPort !== undefined) out.sshPort = n.sshPort;
   if (n.nodeId) out.nodeId = n.nodeId;
   if (n.reversePool) {

package/lib/notify/asks.js

@@ -66,7 +66,7 @@ function createAsksStore(opts = {}) {
   }
 
   function openCount() {
-    return load().filter((a) => !a.answered).length;
+    return load().filter((a) => !a.answered && !a.dismissed).length;
   }
 
   function create({ question, options, session }) {
@@ -99,7 +99,7 @@ function createAsksStore(opts = {}) {
 
   function list({ open = false } = {}) {
     const all = load();
-    return (open ? all.filter((a) => !a.answered) : all.slice())
+    return (open ? all.filter((a) => !a.answered && !a.dismissed) : all.slice())
       .map((a) => ({ ...a, ...(a.options ? { options: a.options.slice() } : {}) }));
   }
 
@@ -114,6 +114,10 @@ function createAsksStore(opts = {}) {
   function claim(id) {
     const ask = get(id);
     if (!ask) return { ok: false, reason: 'unknown' };
+    // Un ask dismissato non e' piu' risponibile: senza questa guardia la
+    // sequenza dismiss -> claim -> commit lascia lo stato ibrido
+    // `dismissed && answered` (F-02).
+    if (ask.dismissed) return { ok: false, reason: 'dismissed' };
     if (ask.answered) return { ok: false, reason: 'answered' };
     if (answering.has(id)) return { ok: false, reason: 'answering' };
     answering.add(id);
@@ -137,6 +141,22 @@ function createAsksStore(opts = {}) {
     return true;
   }
 
+  // Dismiss (scarta la domanda): NON cancella la riga — la marca `dismissed`,
+  // perche' lo storico serve (come `answered`). Non compete con una answer in
+  // corso: 409 se c'e' un claim attivo (answering). Idempotente: scartare due
+  // volte non e' un errore. Un ask dismissato non e' piu' open (non appare in
+  // list({open:true})/openCount) ma resta nello storico (list({open:false})).
+  function dismiss(id) {
+    const ask = get(id);
+    if (!ask) return { ok: false, reason: 'unknown' };
+    if (answering.has(id)) return { ok: false, reason: 'answering' };
+    if (ask.dismissed) return { ok: true, ask: { ...ask }, idempotent: true };
+    ask.dismissed = true;
+    ask.dismissedTs = now();
+    save();
+    return { ok: true, ask: { ...ask } };
+  }
+
   // Retrocompat (usata nei test di store): claim+commit in un colpo.
   function markAnswered(id, text) {
     const c = claim(id);
@@ -144,7 +164,7 @@ function createAsksStore(opts = {}) {
     return commit(id, text);
   }
 
-  return { create, get, list, openCount, claim, release, commit, markAnswered, validate, filePath, MAX_OPEN };
+  return { create, get, list, openCount, claim, release, commit, markAnswered, dismiss, validate, filePath, MAX_OPEN };
 }
 
 module.exports = { createAsksStore };

package/lib/notify/notifier.js

@@ -13,6 +13,13 @@ function createNotifier({ hub, push }) {
       urgency: frame.urgency === 'high' ? 'high' : 'normal',
       ...(frame.session ? { session: String(frame.session) } : {}),
       ...(frame.lang ? { lang: String(frame.lang) } : {}),
+      // Provenienza federata. `originNode` e' VERIFICATO (catena visited
+      // costruita dal server); `originCell` e' soltanto ATTESTATO dal nodo di
+      // origine, che l'ha verificata da se'. La differenza va fino alla UI: chi
+      // guarda deve poter distinguere cio' che e' provato da cio' che e'
+      // dichiarato, altrimenti il mittente diventa un campo di phishing.
+      ...(frame.originNode ? { originNode: String(frame.originNode) } : {}),
+      ...(frame.originCell ? { originCell: String(frame.originCell) } : {}),
       ts: Date.now(),
     });
     let pushed = 0;

package/lib/notify/routes.js

@@ -20,8 +20,18 @@
 const express = require('express');
 const { isValidSession } = require('../files/store.js');
 const { normalizeNotificationLang } = require('./language.js');
+const { HOP_HEADER } = require('../proxy/hop-proof.js');
 
-const NOTIFY_KEYS = new Set(['title', 'body', 'urgency', 'session', 'lang']);
+const TARGET_RE = /^[a-f0-9]{32}$/i;
+
+// `url` NON e' ammesso, ne' in locale ne' federato: sw.js fa
+// clients.openWindow(url) sul click, quindi accettarlo da un peer sarebbe un
+// open-redirect dentro la PWA autenticata. Il solo url legittimo lo genera in
+// casa la route degli ask (deep-link /#ask=<id>), che non passa da qui.
+const NOTIFY_KEYS = new Set(['title', 'body', 'urgency', 'session', 'lang', 'target']);
+// 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 RATE_MAX = 6;
 const RATE_WINDOW_MS = 60 * 1000;
@@ -91,7 +101,14 @@ function replyLabel(cfg) {
   return clean || 'human';
 }
 
-function notifyRoutes({ cfg, notifier, push, asks, paste, sessionExists }) {
+function notifyRoutes({
+  cfg, notifier, push, asks, paste, sessionExists,
+  // Federazione delle notifiche. Assenti (test unitari, montaggi parziali) la
+  // route resta esattamente quella locale di prima: nessun percorso nuovo si
+  // apre per omissione.
+  localNodeId = () => null, originResolver = null, acl = null, dispatcher = null,
+  federatedRate = null,
+}) {
   const r = express.Router();
   const json = express.json({ limit: '16kb' });
 
@@ -110,8 +127,14 @@ function notifyRoutes({ cfg, notifier, push, asks, paste, sessionExists }) {
       if (!b || typeof b !== 'object' || Array.isArray(b)) {
         return res.status(400).json({ error: 'body deve essere un oggetto JSON' });
       }
+      // Un ingresso e' federato solo se porta la prova di hop. 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 (!NOTIFY_KEYS.has(k)) return res.status(400).json({ error: `chiave non ammessa: "${k}" (schema: title, body?, urgency?, session?, lang?)` });
+        if (NOTIFY_KEYS.has(k)) continue;
+        if (federated && FEDERATED_KEYS.has(k)) continue;
+        return res.status(400).json({ error: `chiave non ammessa: "${k}" (schema: title, body?, urgency?, session?, lang?, target?)` });
       }
       if (typeof b.title !== 'string' || !b.title.trim()) {
         return res.status(400).json({ error: 'title deve essere una stringa non vuota' });
@@ -130,6 +153,55 @@ function notifyRoutes({ cfg, notifier, push, asks, paste, sessionExists }) {
       if (b.session !== undefined && !isValidSession(b.session)) {
         return res.status(400).json({ error: 'session non valida' });
       }
+      if (b.target !== undefined && !TARGET_RE.test(String(b.target))) {
+        return res.status(400).json({ error: 'target deve essere un instanceId di nodo' });
+      }
+      const self = localNodeId();
+
+      // --- ingresso FEDERATO: la notifica 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 non solo
+        // spamma ma affama le notifiche delle celle di casa, che condividono
+        // lo stesso bucket da 6/60s.
+        if (federatedRate) {
+          const quota = federatedRate.check({ origin: resolved.origin, target: self, urgency: b.urgency });
+          if (!quota.allowed) {
+            return res.status(429).json({ status: 'refused', reason: `rate-${quota.bucket}` });
+          }
+        }
+        const delivered = await notifier.emit({
+          title: b.title.trim(), body: b.body, urgency: b.urgency, lang,
+          // Il mittente NON e' `b.session`: quel campo lo dichiara il chiamante.
+          // Qui vale solo cio' che la catena ha provato, piu' la cella che il
+          // nodo di origine attesta.
+          originNode: resolved.origin.node,
+          originCell: resolved.origin.cell,
+        });
+        return res.json({ status: 'delivered', delivered });
+      }
+
+      // --- target remoto: instrada, non consegnare qui -----------------------
+      if (b.target !== undefined && dispatcher && self && b.target !== self) {
+        const out = await dispatcher.dispatch({
+          resource: '/notify',
+          target: b.target,
+          // La cella di origine e' quella DICHIARATA dal chiamante locale: viene
+          // trasmessa come attestazione, e il target la trattera' come tale.
+          origin: { node: self, cell: b.session || 'unknown' },
+          payload: { title: b.title.trim(), ...(b.body ? { body: b.body } : {}), ...(b.urgency ? { urgency: b.urgency } : {}), ...(lang ? { lang } : {}) },
+        });
+        return res.json(out);
+      }
+
       const sender = b.session || 'unknown';
       if (!allowNotify(sender)) {
         return res.status(429).json({ error: 'rate limit notify superato (limite globale per token + per sessione)' });
@@ -214,6 +286,25 @@ function notifyRoutes({ cfg, notifier, push, asks, paste, sessionExists }) {
     catch (e) { res.status(500).json({ error: String(e.message || e) }); }
   });
 
+  // Dismiss (scarta domanda): NON cancella la riga, la marca `dismissed` (lo
+  // storico serve). Stesso mutGate degli altri mutanti (F3: scrittura durevole).
+  // Idempotente; 404 se id inesistente; 409 se answering (claim attivo: non si
+  // scarta una risposta in corso). Emette il frame per le UI aperte come fa
+  // POST /asks con emitRaw: la card sparisce senza aspettare il poll.
+  r.delete('/asks/:id', mutGate, (req, res) => {
+    try {
+      const id = String(req.params.id || '');
+      const out = asks.dismiss(id);
+      if (!out.ok) {
+        if (out.reason === 'unknown') return res.status(404).json({ error: 'ask inesistente' });
+        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' });
+      }
+      notifier.emitRaw({ type: 'ask-dismissed', id });
+      res.json({ dismissed: true, id });
+    } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
+  });
+
   // Answer: READONLY floor (il paste e' una scrittura PTY). F2 (audit): il
   // ciclo e' claim atomico (open -> answering, sincrono, PRIMA dell'await del
   // paste) -> paste -> commit su successo / release su fallimento. Una sola
@@ -230,6 +321,7 @@ function notifyRoutes({ cfg, notifier, push, asks, paste, sessionExists }) {
       const claim = asks.claim(id);
       if (!claim.ok) {
         if (claim.reason === 'unknown') return res.status(404).json({ error: 'ask inesistente' });
+        if (claim.reason === 'dismissed') return res.status(409).json({ error: 'ask gia\' scartato (dismissed)' });
         if (claim.reason === 'answering') return res.status(409).json({ error: 'risposta gia\' in corso da un\'altra richiesta' });
         return res.status(409).json({ error: 'ask gia\' risposto' });
       }