@mmmbuto/nexuscrew 0.8.52-rc.9 → 0.8.53

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

package/lib/proxy/federation.js

@@ -60,6 +60,22 @@ function classifyShareFailure(health) {
   return { code: 'share-peer-unreachable', detail };
 }
 
+// Porta del canale reverse realmente in gioco, vista DALL'HUB: lo slot attivo
+// del pool quando c'e', altrimenti la `localPort` del peer — che e' il punto
+// su cui l'hub sonda davvero (cfr. nodes test, ramo inbound). NON
+// `reversePort`: quello e' il campo negoziato che vive sul CLIENT, e sull'hub
+// e' assente. Il test del comportamento ha trovato questo scambio; il valore
+// e' il dato che manca per capire un rifiuto, quindi sbagliarlo lo renderebbe
+// peggio che inutile, mandando a cercare sulla porta sbagliata.
+function activeReversePort(peer) {
+  const pool = peer && peer.reversePool;
+  if (pool && Array.isArray(pool.slots)) {
+    const slot = pool.slots[pool.activeSlot];
+    if (slot && Number.isInteger(slot.port)) return slot.port;
+  }
+  return peer && Number.isInteger(peer.localPort) ? peer.localPort : null;
+}
+
 function peerFromToken(nodesPath, token) {
   const st = store.loadStore(nodesPath);
   if (!st || !token) return null;
@@ -151,11 +167,25 @@ function knownResource(resource) {
     // ADMITS a further node, so leaving it federated would let a peer break the
     // very boundary the owner chose. Minting an invite is done on the hub.
     || resource === '/ws'
+    // Un avviso all'operatore attraversa la federazione con la stessa spina
+    // dorsale dell'audio: origine provata dalla catena `visited`, ACL del
+    // target, budget dedicato. NON e' la coda di NC-NEXT-07 (§5 del modello di
+    // autorita'): quella differisce un'esecuzione, questo mostra del testo e
+    // non esegue nulla. `/audio/speak` esce da un altoparlante in una stanza
+    // fisica ed e' gia' federato: una notifica e' meno invasiva di cosi'.
+    || resource === '/notify'
     || resource === '/audio/capability'
     || resource === '/audio/speak'
     || resource === '/audio/speak/status'
     || resource === '/audio/stop'
-    || /^\/fleet\/(status|schema|definitions|credentials\/status|credentials\/(?:set|remove)|up|down|restart|engine|boot|define-engine|edit-engine|remove-engine|define-cell|edit-cell|remove-cell|restore-cells|restore-engines)$/.test(resource);
+    // I modelli dichiarati seguono gli engine, perche' sono la stessa cosa
+    // vista da un'altra angolazione: un engine gestito NON parte se il suo id
+    // di modello non e' nel catalogo, e un modello dichiarato e' cio' che
+    // estende quel catalogo. `define-engine` federato + `define-model` locale
+    // significava poter creare a distanza un engine che non si puo' rendere
+    // avviabile a distanza — un'asimmetria che rompeva la modifica remota a
+    // meta' strada, senza proteggere nulla.
+    || /^\/fleet\/(status|schema|definitions|credentials\/status|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);
 }
 
 function allowedResource(resource, method = 'GET') {
@@ -187,7 +217,16 @@ function allowedResource(resource, method = 'GET') {
   if (resource === '/diagnostics/verbose') return method === 'PATCH';
   if (resource === '/ws') return method === 'GET';
   if (/^\/fleet\/(status|schema|definitions|credentials\/status)$/.test(resource)) return method === 'GET';
-  if (/^\/fleet\/(credentials\/(?:set|remove)|up|down|restart|engine|boot|define-engine|edit-engine|remove-engine|define-cell|edit-cell|remove-cell|restore-cells|restore-engines)$/.test(resource)) return method === 'POST';
+  // `model-test` e' un POST che non muta niente: interroga il CATALOGO del
+  // fornitore (`GET .../models`) con la credenziale di quel nodo e ne ricava un
+  // enum. Non genera testo, quindi non consuma token. Resta comunque una
+  // 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.
+  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.
   if (resource === '/audio/capability') return method === 'GET';
@@ -312,8 +351,35 @@ async function probeHealth({ port, token, expectedInstanceId = null, fetchImpl =
   } catch (e) {
     out.transport = 'down';
     out.status = 'down';
-    out.detail = (e && (e.name === 'AbortError' || e.code === 'ETIMEDOUT'))
-      ? `peer non raggiungibile (timeout ${timeoutMs}ms)` : 'peer non raggiungibile (tcp refused/down)';
+    // DUE GUASTI DIVERSI, e prima avevano lo stesso messaggio. Con un canale
+    // inverso SSH il listener sull'hub e' sshd: se il dispositivo non e'
+    // connesso non c'e' nessun listener e la connessione viene RIFIUTATA; se
+    // invece il tunnel regge ma NexusCrew sul dispositivo e' morto, sshd
+    // accetta, inoltra, e la connessione viene AZZERATA dall'altro capo.
+    //
+    // MISURATO il 2026-08-07 sui tre casi reali contemporaneamente presenti:
+    //   tunnel su + servizio giu'  -> ECONNRESET
+    //   nessun listener            -> ECONNREFUSED
+    //   tutto su                   -> HTTP (401)
+    //
+    // Perche' vale la pena distinguerli: «peer non raggiungibile» ha mandato
+    // l'indagine nella federazione e nel pairing per quattro ore, mentre il
+    // difetto era un servizio che non era ripartito sul dispositivo. Sono due
+    // guasti con due rimedi diversi — uno si risolve sulla rete, l'altro
+    // andando sul dispositivo — e un messaggio unico li fa cercare nel posto
+    // sbagliato la meta' delle volte.
+    const codice = (e && (e.code || (e.cause && e.cause.code))) || '';
+    if (e && (e.name === 'AbortError' || codice === 'ETIMEDOUT')) {
+      out.detail = `peer non raggiungibile (timeout ${timeoutMs}ms)`;
+    } else if (codice === 'ECONNREFUSED') {
+      out.detail = `canale inverso non attivo sulla porta ${port}: il dispositivo non e' connesso`;
+      out.layer = 'tunnel';
+    } else if (codice === 'ECONNRESET' || codice === 'ECONNABORTED' || codice === 'EPIPE') {
+      out.detail = `canale inverso attivo sulla porta ${port}, ma NexusCrew non risponde sul dispositivo`;
+      out.layer = 'service';
+    } else {
+      out.detail = 'peer non raggiungibile (tcp refused/down)';
+    }
     return out;
   } finally {
     if (timer) clearTimeout(timer);
@@ -806,7 +872,7 @@ async function probeReverseOwner(peer, fetchImpl = fetch) {
   });
 }
 
-function peerRouter({ nodesPath, localPort, localCredential, fetchImpl, readonly = () => false, version = null, roles = null, hopSecret = null }) {
+function peerRouter({ nodesPath, localPort, localCredential, fetchImpl, readonly = () => false, version = null, roles = null, hopSecret = null, diagnostics = null }) {
   const r = express.Router();
   r.use((req, res, next) => {
     const peer = peerFromToken(nodesPath, bearerFrom(req));
@@ -1042,6 +1108,21 @@ function peerRouter({ nodesPath, localPort, localCredential, fetchImpl, readonly
           // guasto definitivo senza interpretare una stringa. Solo il canale
           // non ancora salito e' ritentabile.
           const failure = classifyShareFailure(health);
+          // L'hub sa di aver rifiutato e sa perche', e finora non lo scriveva
+          // da nessuna parte: l'errore viveva solo nel toast del dispositivo,
+          // che e' l'unico posto dove chi amministra l'hub non puo' guardarlo.
+          // Un rifiuto ripetuto diventava cosi' un mistero — e' costato ore su
+          // un caso reale, risolto solo leggendo i log di sshd con i privilegi
+          // di root. Meta bounded: nome nodo, codice tipizzato, porta tentata.
+          // Nessun testo remoto, nessuna credenziale.
+          if (diagnostics && typeof diagnostics.record === 'function') {
+            diagnostics.record('warn', 'share', 'SHARE_CHANNEL_REFUSED',
+              'Share refused: the reverse channel did not come up', {
+                node: req.peer.name,
+                code: failure.code,
+                port: activeReversePort(req.peer),
+              });
+          }
           return res.status(409).json({
             error: 'canale share non raggiungibile',
             code: failure.code,
@@ -1073,7 +1154,7 @@ function localRouter({ nodesPath, localPort, localCredential, readonly, hopSecre
   return r;
 }
 
-function forwardUpgrade({ req, socket, head, nodesPath, localPort, localCredential, ingress, readonly = () => false, activeSockets = null }) {
+function forwardUpgrade({ req, socket, head, nodesPath, localPort, localCredential, ingress, readonly = () => false, activeSockets = null, hopSecret = null }) {
   if (readonly()) return reject(socket, 403);
   const parsed = parseRoute(req.url.replace(/^\/(?:api\/route|federation\/route)/, ''));
   if (!parsed || parsed.resource !== '/ws') return reject(socket, 404);
@@ -1092,7 +1173,18 @@ function forwardUpgrade({ req, socket, head, nodesPath, localPort, localCredenti
   }
   const up = net.connect({ host: '127.0.0.1', port });
   up.once('connect', () => {
-    const headers = cleanHeaders(req.headers, credential, parsed.route.length ? visited : null);
+    // Ultimo hop: l'upgrade rientra nell'API locale col Bearer locale e da li'
+    // in poi sarebbe indistinguibile da un attach diretto di chi possiede quel
+    // token. La catena PIU' la prova di hop sono cio' che lo distingue —
+    // esattamente come fa routeHandler per il percorso HTTP. Senza, il nodo che
+    // possiede la sessione non sa quale peer stia aprendo il suo PTY, e ogni
+    // permesso per-cella diventa decorativo: `/ws` attacca per NOME di
+    // sessione, quindi basta indovinarlo.
+    const secret = typeof hopSecret === 'function' ? hopSecret() : hopSecret;
+    const hopProof = !parsed.route.length && secret
+      ? signHop(secret, { method: req.method || 'GET', path, visited })
+      : null;
+    const headers = cleanHeaders(req.headers, credential, visited, hopProof);
     const lines = [`GET ${path} HTTP/1.1`, `Host: 127.0.0.1:${port}`];
     for (const [k, v] of Object.entries(headers)) lines.push(`${k}: ${Array.isArray(v) ? v.join(', ') : v}`);
     lines.push('Connection: Upgrade', 'Upgrade: websocket', '', '');
@@ -1110,7 +1202,7 @@ function forwardUpgrade({ req, socket, head, nodesPath, localPort, localCredenti
 function reject(socket, code) { try { socket.end(`HTTP/1.1 ${code} Error\r\nConnection: close\r\n\r\n`); } catch (_) {} }
 
 module.exports = {
-  MAX_HOPS, ROUTE_DELIMITER, TOPOLOGY_PEER_TIMEOUT_MS, SHARE_NOT_READY_CODE, classifyShareFailure,
+  MAX_HOPS, ROUTE_DELIMITER, TOPOLOGY_PEER_TIMEOUT_MS, SHARE_NOT_READY_CODE, classifyShareFailure, activeReversePort,
   peerFromToken, peerAllows, canTransit, parseRoute, knownResource, allowedResource, allowedQuery, readonlyBlocksFederated,
   collectTopology, collectTopologyDetailed, collectLocalTopology, peerRouter, localRouter, forwardUpgrade,
   probeHealth, waitForHealthyPeer, canListenLoopback, preflightHubReverse, notifyHubShare, reconcilePeerShare, runShareRevokeBoot, probeReverseOwner,

package/lib/server.js

@@ -39,12 +39,20 @@ const { isConsent: isAudioConsent } = require('./audio/consent.js');
 const { createOriginResolver } = require('./audio/origin.js');
 const { createAudioAcl } = require('./audio/acl.js');
 const { createDispatcher } = require('./audio/dispatch.js');
+const { createCellScopeGuard } = require('./cells/scope-guard.js');
+const { createCellScope } = require('./cells/scope.js');
+const { cellIdFromTmuxSession } = require('./fleet/definitions.js');
+// Budget a tre finestre, riusato dalle notifiche federate: e' gia' scritto per
+// limitare il danno di un nodo che mente sulla propria cella (il tetto per
+// target si calcola sul NODO, che la catena visited verifica).
+const { createSpeakRateLimiter } = require('./audio/rate-limit.js');
 const { createSpeakQueue } = require('./audio/queue.js');
 const { createReceiptStore } = require('./audio/receipt.js');
 const audioAdapters = require('./audio/adapters.js');
 const audioGroups = require('./audio/groups.js');
 const { bridgeSecretPath, loadOrCreateBridgeSecret, createNonceCache } = require('./audio/bridge-auth.js');
-const { createHopSecret } = require('./proxy/hop-proof.js');
+const { createHopSecret, verifyHop, HOP_HEADER } = require('./proxy/hop-proof.js');
+const { parseVisitedChain } = require('./audio/origin.js');
 const { settingsRoutes, publicPeeringRoutes } = require('./settings/routes.js');
 const decksStore = require('./decks/store.js');
 const { decksRoutes } = require('./decks/routes.js');
@@ -105,6 +113,10 @@ function createServer(opts = {}) {
   // alla porta sbagliata (bug reale: 401/"unauthorized" dal servizio su cfg.port).
   let server = null;
   const previews = createPreviewSampler(cfg.tmuxBin);
+  // Seam di test per l'esistenza di una sessione: senza, un test sullo scope
+  // dell'attach non discrimina, perche' ogni sessione risulta assente e il
+  // rifiuto arriverebbe comunque — un verde che non prova nulla.
+  const sessionExistsImpl = cfg.sessionExistsSeam || ((name) => sessionExists(cfg.tmuxBin, name));
   // MCP bridge (notify/ask/push): lo stato vive accanto al token (dirname del
   // tokenPath = ~/.nexuscrew di default) cosi' le istanze isolate via opts/env
   // nei test NON scrivono mai nella home reale. Tutto lazy: vapid.json/asks.json
@@ -541,6 +553,51 @@ function createServer(opts = {}) {
   // ma il token chiude anche altri processi locali della stessa macchina.
   const api = express.Router();
   api.use(requireToken(tokenStore));
+  // Origine per lo scope celle: stessa prova di hop usata da audio e notify.
+  // requireCell:false perche' qui interessa QUALE NODO parla, non quale cella
+  // dichiari — la cella e' solo attestata e non deve decidere un permesso.
+  const cellScopeOrigin = createOriginResolver({
+    localNodeId: () => (nodesStore.loadStore(nodesPath) || {}).nodeId || null,
+    hopSecret: () => hopSecret,
+  });
+  const cellScoper = createCellScope({
+    nodesPath,
+    cellForSession: (session) => cellIdFromTmuxSession(session),
+  });
+  // Variante SINCRONA per l'upgrade WebSocket: verifica la prova di hop e la
+  // catena senza passare dal resolver async. Un upgrade non federato — o con
+  // una prova che non regge — resta senza restrizioni, esattamente come una
+  // richiesta locale: la prova la costruisce il proxy, un peer non puo' ne'
+  // toglierla ne' falsificarla.
+  const wsCellScope = (req) => {
+    try {
+      const headers = (req && req.headers) || {};
+      const proof = headers[HOP_HEADER];
+      if (!proof) return cellScoper.resolve({ trust: 'local-bridge' });
+      const self = (nodesStore.loadStore(nodesPath) || {}).nodeId || null;
+      const visited = parseVisitedChain(headers['x-nexuscrew-visited'], self);
+      if (!visited) return cellScoper.resolve({ trust: 'federated', visited: [] });
+      const ok = verifyHop(hopSecret, {
+        method: req.method || 'GET', path: '/ws', visited,
+      }, proof);
+      if (!ok) return cellScoper.resolve({ trust: 'federated', visited: [] });
+      return cellScoper.resolve({ trust: 'federated', visited });
+    } catch (_) {
+      // Fail-closed: se non si riesce a stabilire l'origine, nessuna sessione.
+      return cellScoper.resolve({ trust: 'federated', visited: [] });
+    }
+  };
+  // Scope celle (NC-E): un punto solo decide cosa un peer federato vede e puo'
+  // toccare. Sta qui, prima di ogni route, perche' i canali da cui una cella
+  // trapela sono molti e crescono: filtrarli uno per uno significa dimenticarne
+  // uno, e un permesso che vale su quasi tutti i canali non e' un permesso.
+  // Le richieste locali non lo attraversano: il proprietario della macchina non
+  // si limita da solo.
+  api.use(createCellScopeGuard({
+    nodesPath,
+    cellForSession: (session) => cellIdFromTmuxSession(session),
+    resolveOrigin: (req) => cellScopeOrigin.resolve(req, { requireCell: false }),
+  }));
   api.get('/sessions', async (_req, res) => {
     try {
       const sessions = await listSessions(cfg.tmuxBin);
@@ -615,6 +672,19 @@ function createServer(opts = {}) {
   }));
   // MCP bridge (design §2): /notify, /push/*, /asks — dietro lo stesso Bearer
   // del router /api; gate READONLY sui mutanti dentro notifyRoutes.
+  // Identita' e instradamento condivisi con l'audio: stessa fonte (node store),
+  // stesso segreto di hop, stessa inventory. Due modelli di provenienza
+  // divergenti sarebbero un bug latente.
+  const federatedNodeId = () => (nodesStore.loadStore(nodesPath) || {}).nodeId || null;
+  const federatedPeers = async () => {
+    const st = nodesStore.loadStore(nodesPath);
+    if (!st) return [];
+    const topology = await federation.collectLocalTopology({ nodesPath, cachePath: topologyCachePath, fetchImpl: healthFetch });
+    return nodesInventory.buildInventory({
+      direct: nodesStore.redactStore(st).nodes,
+      topology: topology && Array.isArray(topology.nodes) ? topology.nodes : [],
+    });
+  };
   api.use(notifyRoutes({
     cfg,
     notifier,
@@ -622,6 +692,22 @@ function createServer(opts = {}) {
     asks: asksStore,
     paste: (session, text) => pasteToSession(cfg.tmuxBin, session, text),
     sessionExists: (name) => sessionExists(cfg.tmuxBin, name),
+    localNodeId: federatedNodeId,
+    // requireCell resta true: una notifica federata porta sempre una cella
+    // attestata, che serve ad attribuirla e a calcolarne il budget.
+    originResolver: createOriginResolver({
+      localNodeId: federatedNodeId,
+      hopSecret: () => hopSecret,
+    }),
+    acl: createAudioAcl({ nodesPath }),
+    dispatcher: createDispatcher({
+      localNodeId: federatedNodeId,
+      peers: federatedPeers,
+      localPort: () => (server && server.address() ? server.address().port : cfg.port),
+      localToken: () => tokenHolder.value,
+      statuses: new Set(['delivered', 'refused', 'unreachable', 'unknown']),
+    }),
+    federatedRate: createSpeakRateLimiter(),
   }));
   api.use('/fleet', fleetRoutes(fleetP, { ...cfg, diagnostics }));
   // Audio Share. L'identita' del nodo NON e' un campo di cfg: si legge dal node
@@ -787,6 +873,7 @@ function createServer(opts = {}) {
     nodesPath, localPort: () => (server && server.address() ? server.address().port : cfg.port), localCredential: () => tokenHolder.value, readonly: proxyReadonly, version: VERSION,
     fetchImpl: healthFetch, hopSecret: () => hopSecret,
     roles: () => require('./cli/commands.js').readRoles(cfg.configPath || configJsonPath()),
+    diagnostics,
   }));
 
   // Reverse-proxy single-origin /node/<name>/… (design §4b(2)). Auth locale PRIMA
@@ -868,13 +955,13 @@ function createServer(opts = {}) {
       let u; try { u = new URL(req.url, 'http://127.0.0.1'); } catch (_) { return socket.destroy(); }
       const given = bearerFrom(req) || u.searchParams.get('token') || '';
       if (!verify(tokenHolder.value, given)) return socket.destroy();
-      federation.forwardUpgrade({ req, socket, head, nodesPath, localPort: runtimePort, localCredential: () => tokenHolder.value, ingress: null, readonly: proxyReadonly, activeSockets: proxySockets });
+      federation.forwardUpgrade({ req, socket, head, nodesPath, localPort: runtimePort, localCredential: () => tokenHolder.value, ingress: null, readonly: proxyReadonly, activeSockets: proxySockets, hopSecret: () => hopSecret });
       return;
     }
     if (pathname.startsWith('/federation/route/')) {
       const ingress = federation.peerFromToken(nodesPath, bearerFrom(req));
       if (!ingress) return socket.destroy();
-      federation.forwardUpgrade({ req, socket, head, nodesPath, localPort: runtimePort, localCredential: () => tokenHolder.value, ingress, readonly: proxyReadonly, activeSockets: proxySockets });
+      federation.forwardUpgrade({ req, socket, head, nodesPath, localPort: runtimePort, localCredential: () => tokenHolder.value, ingress, readonly: proxyReadonly, activeSockets: proxySockets, hopSecret: () => hopSecret });
       return;
     }
     if (pathname === '/node' || pathname.startsWith('/node/')) {
@@ -900,10 +987,19 @@ function createServer(opts = {}) {
     // non possono settare header sui WS -> il flusso locale resta identico
     // (token nel frame attach, mai in URL).
     const preauth = req ? verify(tokenHolder.value, bearerFrom(req)) : false;
+    // Scope celle sull'ATTACH. Calcolato in modo sincrono di proposito: rendere
+    // async questo handler rischierebbe di perdere i frame che arrivano prima
+    // di bindWs. `/ws` attacca per NOME DI SESSIONE e senza questo gate ogni
+    // filtro sugli elenchi sarebbe decorativo — basterebbe indovinare
+    // `cloud-Dev`.
+    const wsScope = wsCellScope(req);
     bindWs(ws, {
       openAttach,
       verifyToken: (t) => preauth || verify(tokenHolder.value, t),
-      isValidSession: (name) => sessionExists(cfg.tmuxBin, name),
+      // Una sessione fuori scope viene trattata come inesistente: il client
+      // riceve 4404, lo stesso codice di una sessione che non c'e'. Dire "esiste
+      // ma non puoi" rivelerebbe proprio cio' che lo scope nasconde.
+      isValidSession: (name) => sessionExistsImpl(name) && wsScope.allowsSession(name),
       runAction: (sess, action) => runAction(cfg.tmuxBin, sess, action),
       countClients: (sess) => attachedClients(cfg.tmuxBin, sess),
       defaults: { readonlyDefault: cfg.readonlyDefault, tmuxBin: cfg.tmuxBin },

package/lib/settings/pairing-coordinator.js

@@ -32,6 +32,7 @@ const os = require('node:os');
 const crypto = require('node:crypto');
 
 const nodesStore = require('../nodes/store.js');
+const identity = require('../nodes/identity.js');
 const nodesCmds = require('../nodes/commands.js');
 const nodesTunnel = require('../nodes/tunnel.js');
 const peering = require('../nodes/peering.js');
@@ -223,6 +224,15 @@ function createPairHandler(deps) {
             // Pairing establishes a private client-to-hub connection. Sharing
             // this device back through the hub is a separate explicit action.
             shared: false,
+            // La nostra pubblica, passo 1 del modello di autorita'. Se non si
+            // riesce a leggerla si accoppia senza: il passo 1 non ha effetti, e
+            // un guasto sulla chiave non deve togliere la capacita' di
+            // accoppiare un dispositivo.
+            ...(() => {
+              try {
+                return { publicKey: identity.ensureNodeKey({ keyPath: identity.keyPathNextTo(nodesPath) }).publicKey };
+              } catch (_) { return {}; }
+            })(),
             roles: readRoles(configPath),
           }),
         });
@@ -295,6 +305,12 @@ function createPairHandler(deps) {
       st = nodesStore.updateNode(st, b.name, {
         token: joined.credential, nodeId: joined.instanceId, reversePort: joined.reversePort,
         shared: false,
+        // L'altra meta' dello scambio. Un hub piu' vecchio non manda la sua
+        // pubblica e il pairing riesce lo stesso — nessun campo, nessun
+        // cambiamento di comportamento.
+        ...(identity.isPublicKey(joined.publicKey)
+          ? { publicKey: joined.publicKey, keySource: 'pairing', keyBoundAt: new Date().toISOString() }
+          : {}),
         ...(joinedPool ? { reversePool: joinedPool } : {}),
         ...(joinedRoles ? { roles: joinedRoles, rolesKnown: true } : {}),
       });

package/lib/settings/public-peering-routes.js

@@ -13,6 +13,7 @@ const express = require('express');
 
 const nodesStore = require('../nodes/store.js');
 const peering = require('../nodes/peering.js');
+const identity = require('../nodes/identity.js');
 const reversePool = require('../nodes/reverse-pool.js');
 const { readRoles } = require('../cli/commands.js');
 const { configJsonPath } = require('../config.js');
@@ -27,6 +28,15 @@ function publicPeeringRoutes(deps = {}) {
   const invitesPath = cfg.invitesPath || peering.defaultInvitesPath(home);
   const pendingPath = cfg.pendingPairingsPath || peering.defaultPendingPath(home);
   const reversePoolLedgerPath = deps.reversePoolLedgerPath || cfg.reversePoolLedgerPath || reversePool.defaultLedgerPath(home);
+  // La pubblica di questa installazione, per il passo 1 del modello di
+  // autorita'. Si legge PIGRAMENTE e non all'avvio del router: un errore sul
+  // file di chiave non deve impedire di montare le route di pairing — il passo
+  // 1 non ha effetti, e «non riesco a leggere la mia chiave» non e' una buona
+  // ragione per non poter piu' accoppiare un dispositivo.
+  const localPublicKey = () => {
+    try { return identity.ensureNodeKey({ keyPath: identity.keyPathNextTo(nodesPath) }).publicKey; }
+    catch (_) { return null; }
+  };
   const r = express.Router();
   const attempts = new Map();
   r.use(express.json({ limit: '8kb' }));
@@ -150,15 +160,23 @@ function publicPeeringRoutes(deps = {}) {
         name, remotePort: b.port, reversePort, reversePool: assignedPool, instanceId: b.instanceId, acceptToken: b.acceptToken,
         shared: false,
         label: nodesStore.sanitizeLabel(b.label, name),
+        // La pubblica del peer, se la manda. Un peer piu' vecchio non la manda
+        // e si accoppia come sempre: il passo 1 osserva, non pretende.
+        ...(identity.isPublicKey(b.publicKey) ? { publicKey: b.publicKey } : {}),
         ...(peerRoles ? { roles: { ...peerRoles, node: false }, rolesKnown: true } : { rolesKnown: false }),
       } });
       if (!peering.consumeInvite({ invitesPath, invite: b.invite, now })) {
         peering.consumePending({ pendingPath, credential, now });
         return res.status(410).json({ error: 'invito scaduto o gia usato' });
       }
+      const mia = localPublicKey();
       res.json({ paired: true, instanceId: poolStore.nodeId, reversePort,
         reversePool: { base: assignedPool.base, slots: assignedPool.slots.map((slot) => slot.port) },
-        credential, roles: readRoles(configPath) });
+        credential, roles: readRoles(configPath),
+        // Lo scambio e' simmetrico e avviene QUI, dentro l'atto che consuma
+        // l'invito monouso: e' il solo momento in cui l'operatore ha deciso,
+        // su entrambe le macchine, che questi due nodi si conoscono.
+        ...(mia ? { publicKey: mia } : {}) });
     } catch (e) {
       if (credential) try { peering.consumePending({ pendingPath, credential, now }); } catch (_) {}
       res.status(e.status || 500).json({ error: String(e.message || e), ...(e.code ? { code: e.code } : {}) });
@@ -188,6 +206,11 @@ function publicPeeringRoutes(deps = {}) {
         direction: 'inbound', transport: 'inbound', autostart: true,
         visibility: 'network', shared: pending.shared === true, nodeId: pending.instanceId,
         token: pending.acceptToken, acceptToken: b.credential,
+        // Legata al pairing, non asserita: e' `keySource` a dire la differenza,
+        // e al passo 3 un grant potra' pretendere questa e non l'altra.
+        ...(identity.isPublicKey(pending.publicKey)
+          ? { publicKey: pending.publicKey, keySource: 'pairing', keyBoundAt: new Date().toISOString() }
+          : {}),
         ...(pending.roles ? { roles: pending.roles } : {}),
         rolesKnown: pending.rolesKnown === true,
         ...(pending.label ? { label: pending.label } : {}),

package/lib/settings/routes.js

@@ -72,7 +72,7 @@ const { publicPeeringRoutes } = require('./public-peering-routes.js');
 const CONFIG_KEYS = new Set(['roles', 'port', 'wizardDone', 'autoUpdate', 'alternateScreen']);
 const ROLE_KEYS = new Set(['client', 'node']);
 const ADD_KEYS = new Set(['name', 'ssh', 'sshPort', 'remotePort', 'localPort', 'keyPath', 'label']);
-const EDIT_KEYS = new Set(['label', 'ssh', 'sshPort', 'autostart', 'visibility', 'selected']);
+const EDIT_KEYS = new Set(['label', 'ssh', 'sshPort', 'autostart', 'visibility', 'selected', 'cellVisibility', 'cells']);
 const LOCAL_AUDIO_TEST_TEXT = 'NexusCrew audio test.';
 
 // Default sensato per il "nome dispositivo" proposto nei form (pairing/invite).

package/lib/tmux/actions.js

@@ -157,7 +157,39 @@ async function submitToSession(tmuxBin, session, text, opts = {}) {
     // inside the composer. C-e is sent as its own tmux command after the paste,
     // then the pane is revalidated before the separate Enter. Other clients
     // still receive a short separation between paste and submit.
-    await delay(codexComposer ? 400 : 150);
+    //
+    // NC-Q: L'ATTESA SCALA COL PAYLOAD, e prima era una costante. Il tempo che
+    // un TUI impiega a ingerire un bracketed paste cresce con la lunghezza —
+    // Claude Code sopra una certa taglia lo COLLASSA («paste again to expand»)
+    // — mentre l'attesa era fissa. Oltre quella soglia l'Enter arriva mentre il
+    // client sta ancora digerendo e viene mangiato: il testo resta nel
+    // composer, la cella non si muove, e il mittente riceve `submitted`. E'
+    // una perdita silenziosa, ed e' la peggiore: chi manda crede di aver
+    // consegnato.
+    //
+    // MISURATO il 2026-08-07, stesso bersaglio a 11 minuti di distanza: ~2900
+    // caratteri -> mai elaborato per NOVE ORE; ~60 caratteri -> in lavorazione
+    // dopo dodici secondi. Lo stesso era successo con `claude.zai-a` a 150 ms e
+    // con `codex-vl` a 400: la costante piu' alta non bastava, perche' il
+    // problema non e' quale costante ma che sia una costante.
+    //
+    // I numeri sono un'EURISTICA, non una misura del tempo di ingestione: 150
+    // ms ogni 500 caratteri oltre i primi 500, col vecchio valore come minimo.
+    // Il gradino usa `floor` di proposito: sotto i 500 caratteri non cambia
+    // NIENTE, perche' quei messaggi erano gia' affidabili e rallentarli sarebbe
+    // stato un costo pagato da tutti per un difetto che non li riguarda.
+    //
+    // Nessun tetto esplicito: il testo e' gia' limitato a MAX_SUBMIT, quindi
+    // l'attesa non puo' superare i ~2,5 s per costruzione. Un `Math.min` qui
+    // sarebbe un ramo che non si esegue mai — e un ramo irraggiungibile e' un
+    // pezzo di codice che promette di proteggere da qualcosa che non puo'
+    // accadere.
+    //
+    // Riduce di molto la finestra; non la chiude. `submitted` continua a
+    // significare paste+Enter, non accettazione — e resta vero che dopo un
+    // messaggio lungo conviene verificare che la cella si sia mossa.
+    const attesaBase = codexComposer ? 400 : 150;
+    await delay(attesaBase + Math.floor(text.length / 500) * 150);
     if (!(await paneAlive())) return { submitted: false, reason: 'sessione terminata durante la consegna' };
     if (codexComposer) {
       const flush = await execTmux(execFileImpl, tmuxBin, ['send-keys', '-t', paneId, 'C-e']);

package/package.json

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