npm - @mmmbuto/nexuscrew - Versions diffs - 0.8.52 → 0.8.54 - Mend

@mmmbuto/nexuscrew 0.8.52 → 0.8.54

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/CHANGELOG.md +140 -0
package/frontend/dist/assets/{index-Cxwpa2Y_.js → index-E5p49uPq.js} +29 -29
package/frontend/dist/index.html +1 -1
package/frontend/dist/version.json +1 -1
package/lib/cli/commands.js +256 -3
package/lib/mcp/server.js +35 -1
package/lib/mcp/tools.js +1 -1
package/lib/proxy/federation.js +29 -2
package/lib/tmux/actions.js +33 -1
package/lib/update/runner.js +27 -0
package/package.json +1 -1
package/skills/nexuscrew-agent/SKILL.md +19 -1

package/frontend/dist/index.html CHANGED Viewed

@@ -11,7 +11,7 @@
   <meta name="apple-mobile-web-app-title" content="NexusCrew" />
   <link rel="manifest" href="/manifest.json" />
   <title>NexusCrew</title>
-  <script type="module" crossorigin src="/assets/index-Cxwpa2Y_.js"></script>
+  <script type="module" crossorigin src="/assets/index-E5p49uPq.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-CYi_lhCg.css">
 </head>
 <body>

package/frontend/dist/version.json CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":"0.8.52"}
1	+ {"version":"0.8.54"}

package/lib/cli/commands.js CHANGED Viewed

@@ -7,6 +7,7 @@ const { execFileSync, spawn } = require('node:child_process');
 const fs = require('node:fs');
 const path = require('node:path');
 const net = require('node:net');
+const crypto = require('node:crypto');
 const { detectPlatform, nodeBin, repoRoot, uid } = require('./platform.js');
 const { installPath: serviceInstallPath, ensureLinuxTmuxSurvival } = require('./service.js');
 const { fleetInstallPath } = require('./fleet-service.js');
@@ -37,7 +38,8 @@ Usage:
   nexuscrew boot     enable startup at boot (use: boot off|status)
   nexuscrew status   show service, port, roles and node status
   nexuscrew stop     stop the background service
-  nexuscrew restart  restart the background service
+  nexuscrew restart  restart the background service (verifies it came back)
+  nexuscrew autoupdate  turn automatic updates on or off (use: autoupdate on|off|status)
   nexuscrew doctor   run local diagnostics
   nexuscrew nodes    list and manage connected peers (use: nodes help)
   nexuscrew help     show this help
@@ -544,6 +546,25 @@ async function probeNexusCrew(port, token, opts = {}) {
   } catch (_) { return false; }
 }
+// probeNexusCrew restituisce un BOOLEANO e collassa ogni non-200 su `false`:
+// per i suoi molti chiamanti va bene, e cambiarne il contratto ripercuoterebbe
+// ovunque. Ma «non risponde» e «risponde 401» sono due cose opposte — un 401
+// dice che il servizio E' IN PIEDI e che il token locale non vale — e chi deve
+// spiegare un riavvio ha bisogno di distinguerle, altrimenti dichiara fallito
+// un riavvio riuscito e manda a cercare un processo morto che e' vivo.
+// Rilievo dell'audit: il caso token-assente era gia' coperto, questo no.
+async function probeNexusCrewStatus(port, token, opts = {}) {
+  const fetchImpl = opts.fetchImpl || globalThis.fetch;
+  if (typeof fetchImpl !== 'function') return null;
+  try {
+    const r = await fetchImpl(`http://127.0.0.1:${port}/api/config`, {
+      headers: { authorization: `Bearer ${token || ''}` },
+      signal: AbortSignal.timeout?.(700),
+    });
+    return r.status;
+  } catch (_) { return null; } // nessuna risposta: e' un altro guasto
+}
 async function waitForNexusCrew(port, token, opts = {}) {
   const probe = opts.probeImpl || probeNexusCrew;
   const attempts = opts.waitAttempts === undefined ? 30 : opts.waitAttempts;
@@ -811,6 +832,113 @@ function logs(opts = {}) {
   return { platform, bin, args, follow, keepAlive: true };
 }
+// autoupdate on|off|status — l'aggiornamento automatico si spegne anche da qui.
+//
+// PERCHE' NEL CLI, visto che la casella esiste gia' in Settings. Perche' il
+// momento in cui serve spegnerlo e' quello in cui la PWA non si apre: il nodo
+// si e' aggiornato, il servizio non e' tornato su, e la riga di comando e'
+// l'unica superficie rimasta. Un controllo che vive solo dove il guasto lo
+// rende irraggiungibile e' mezzo assente.
+//
+// A SERVIZIO ACCESO PASSA DALL'API, e non e' un dettaglio: scrivere il file
+// mentre il processo vive lascerebbe il manager in memoria con il vecchio
+// valore, e continuerebbe ad aggiornare all'ora prevista. Un interruttore che
+// risulta spento e non spegne e' peggio di un interruttore che manca. La route
+// invece persiste E chiama `setEnabled`, quindi vale subito.
+function autoUpdateCommand(args, opts = {}) {
+  const log = opts.log || console.log;
+  const azione = String(args[0] || 'status').toLowerCase();
+  if (!['on', 'off', 'status'].includes(azione)) {
+    log('uso: nexuscrew autoupdate on|off|status');
+    return { code: 1 };
+  }
+  const { configPath, tokenPath } = urlmod.resolvePaths(opts);
+  const port = urlmod.loadPort(opts);
+  const token = urlmod.readToken(tokenPath);
+  const attivo = (opts.isServiceRunningImpl || isServiceRunning)({ ...opts });
+  const fetchImpl = opts.fetchImpl || fetch;
+  const daFile = () => {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      return cfg.autoUpdate !== false;
+    } catch (_) { return true; } // default ON, come la configurazione
+  };
+  if (azione === 'status') {
+    // A servizio acceso vince cio' che il processo sta DAVVERO facendo, non
+    // cio' che il file dice: se i due divergono, e' il primo a spegnere o
+    // accendere gli aggiornamenti.
+    if (!attivo) {
+      log(`autoupdate: ${daFile() ? 'on' : 'off'} (da configurazione; servizio non attivo)`);
+      return { code: 0 };
+    }
+    return fetchImpl(`http://127.0.0.1:${port}/api/settings`, {
+      headers: { authorization: `Bearer ${token}` },
+    }).then(async (r) => {
+      if (!r.ok) throw new Error(`HTTP ${r.status}`);
+      const j = await r.json();
+      const acceso = j.autoUpdate !== false;
+      log(`autoupdate: ${acceso ? 'on' : 'off'}`);
+      if (j.update && j.update.latest) log(`  ultima versione vista su npm latest: ${j.update.latest}`);
+      return { code: 0 };
+    }).catch((e) => {
+      log(`autoupdate: ${daFile() ? 'on' : 'off'} (da configurazione; servizio non interrogabile: ${e.message})`);
+      return { code: 0 };
+    });
+  }
+  const acceso = azione === 'on';
+  if (!attivo) {
+    // Servizio spento: si scrive il file, e si DICE che vale al prossimo avvio.
+    // Tacerlo lascerebbe credere che abbia gia' effetto.
+    let cfg = {};
+    try { cfg = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch (_) { /* file nuovo */ }
+    // Scrittura atomica e rifiuto dei symlink, come fa la route che scrive lo
+    // stesso file: tmp nella stessa directory, 0600, rename. Un `writeFileSync`
+    // diretto puo' lasciare un config.json troncato se il processo muore a
+    // meta' — e un config.json illeggibile e' un nodo che non riparte, cioe'
+    // proprio il guasto che questo comando serve a evitare. Rilievo dell'audit.
+    try {
+      if (fs.lstatSync(configPath).isSymbolicLink()) {
+        log('autoupdate: config.json e\' un symlink, non lo scrivo');
+        return { code: 1 };
+      }
+    } catch (e) { if (e.code !== 'ENOENT') throw e; }
+    const dir = path.dirname(configPath);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = path.join(dir, `.${path.basename(configPath)}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+    try {
+      fs.writeFileSync(tmp, `${JSON.stringify({ ...cfg, autoUpdate: acceso }, null, 2)}\n`, { mode: 0o600 });
+      fs.chmodSync(tmp, 0o600);
+      fs.renameSync(tmp, configPath);
+    } catch (e) {
+      try { fs.unlinkSync(tmp); } catch (_) { /* best-effort */ }
+      throw e;
+    }
+    log(`autoupdate: ${azione} (scritto in configurazione; vale al prossimo avvio del servizio)`);
+    return { code: 0 };
+  }
+  return fetchImpl(`http://127.0.0.1:${port}/api/settings/config`, {
+    method: 'POST',
+    headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+    body: JSON.stringify({ autoUpdate: acceso }),
+  }).then(async (r) => {
+    if (!r.ok) {
+      const j = await r.json().catch(() => ({}));
+      log(`autoupdate: non applicato — ${j.error || `HTTP ${r.status}`}`);
+      return { code: 1 };
+    }
+    log(`autoupdate: ${azione} (applicato subito e salvato)`);
+    return { code: 0 };
+  }).catch((e) => {
+    log(`autoupdate: non applicato — ${e.message}`);
+    log('  il servizio risulta attivo ma non risponde: non scrivo il file, perche\' resterebbe');
+    log('  un valore che il processo vivo non conosce.');
+    return { code: 1 };
+  });
+}
 // update: npm i -g @latest + restart se attivo. Fallimento npm -> messaggio chiaro, code 1.
 function update(opts = {}) {
   const execImpl = opts.execImpl || execFileSync;
@@ -1158,9 +1286,134 @@ function dispatch(argv, opts = {}) {
     const result = stop({ ...opts, log });
     return { code: result.stopped || ['not running', 'stale pidfile'].includes(result.reason) ? 0 : 1 };
   }
+  if (cmd === 'autoupdate') {
+    return autoUpdateCommand(rest.slice(1), { ...opts, log });
+  }
   if (cmd === 'restart') {
-    const result = restart({ ...opts, log });
-    return { code: result.restarted ? 0 : 1 };
+    // Seam come negli altri punti del file (`opts.restartImpl || restart`):
+    // serve a poter dichiarare in prova QUALE runtime e' in piedi, perche' il
+    // ritentativo si comporta in modo diverso fra gestito e portatile — e senza
+    // il seam un test finisce per esercitare il ramo che non intendeva.
+    const result = (opts.restartImpl || restart)({ ...opts, log });
+    if (!result.restarted) return { code: 1 };
+    // IL RIAVVIO ORA VERIFICA DI ESSERE TORNATO SU, e prima no. `restart`
+    // dichiarava successo appena `systemctl restart` (o launchctl, o l'avvio
+    // portatile) ritornava: quella e' la conferma che il COMANDO e' partito,
+    // non che il servizio risponda. Su Termux, il 2026-08-07, ha restituito 0
+    // con il servizio morto, e il nodo e' rimasto giu' oltre quattro ore senza
+    // che nessuno lo sapesse — da fuori si vedeva solo un KO generico.
+    //
+    // La verifica esisteva gia' e veniva usata dal percorso di auto-update e
+    // dal bootstrap Fleet («serve un restart verificato»); mancava proprio sul
+    // comando che una persona digita a mano. Con l'auto-update acceso questo
+    // riavvio avviene DA SOLO su ogni nodo, quindi un esito non verificato si
+    // moltiplica per la flotta.
+    //
+    // Il ramo restituisce una PROMESSA e `dispatch` resta sincrona: e' il
+    // disegno che il file ha gia' (dispatchNodes fa lo stesso) e il chiamante
+    // avvolge in `Promise.resolve`. Cambiare la firma di dispatch avrebbe
+    // rotto ottanta test che la chiamano in modo sincrono, per una verifica
+    // che riguarda un comando solo.
+    const { tokenPath } = urlmod.resolvePaths(opts);
+    const port = urlmod.loadPort(opts);
+    const token = urlmod.readToken(tokenPath);
+    // SENZA TOKEN NON SI PUO' DIRE NIENTE SULLA SALUTE, e soprattutto non si
+    // deve dire qualcosa di sbagliato: la sonda fallirebbe per autenticazione e
+    // il messaggio incolperebbe la porta o il processo, mandando a cercare dove
+    // il problema non e'. Rilievo dell'audit. Il riavvio e' comunque partito,
+    // quindi non e' un fallimento: e' una verifica che non si e' potuta fare, e
+    // si dice cosi'.
+    if (!token) {
+      log('restart: comando eseguito, ma la salute NON e\' verificabile senza token locale.');
+      log('  Controlla a mano che il servizio risponda.');
+      return { code: 0 };
+    }
+    const attesa = (sano) => {
+      if (sano) {
+        log(`restart: servizio verificato su 127.0.0.1:${port}`);
+        return { code: 0 };
+      }
+      // NON E' ANCORA UN FALLIMENTO: si prova a capire PERCHE' e, se e' la
+      // causa nota, si rimedia una volta sola.
+      //
+      // LA CAUSA NOTA. Sul percorso portatile — quello di Termux, dove non c'e'
+      // un gestore di servizi che rialzi il processo — `restart` avvia il
+      // nuovo processo SUBITO dopo aver fermato il vecchio, senza aspettare che
+      // muoia ne' che la porta si liberi. Il nuovo non riesce ad ascoltare,
+      // esce, e nessuno se ne accorge: servizio giu', tunnel su (e' un
+      // processo SSH separato), nessun auto-recupero. Misurato il 2026-08-07:
+      // oltre venti minuti in quello stato.
+      //
+      // Il percorso dell'AUTO-UPDATE fa gia' la cosa giusta — aspetta che il
+      // processo sia morto E che la porta sia libera, fino a sei secondi, e
+      // solo allora avvia. Le due strade erano divergenti, e quella che una
+      // persona digita a mano era la meno prudente.
+      //
+      // PRIMA DI DARE LA COLPA A QUALCUNO, si guarda se il servizio risponde
+      // affatto. Un 401 significa che E' IN PIEDI e che il token locale non
+      // vale: il riavvio e' riuscito, e dichiararlo fallito manderebbe a
+      // cercare un processo morto che invece e' vivo.
+      return (opts.probeStatusImpl || probeNexusCrewStatus)(port, token, opts).then((stato) => {
+        if (stato === 401 || stato === 403) {
+          log(`restart: il servizio RISPONDE su 127.0.0.1:${port}, ma il token locale non e' valido.`);
+          log('  Il riavvio e\' riuscito; e\' la credenziale a non funzionare.');
+          log('  Rigenera il token locale, poi riprova a collegarti.');
+          return { code: 1 };
+        }
+        return continua();
+      });
+    };
+    const continua = () => {
+      // SOLO SUL RUNTIME PORTATILE. E' li' che manca un supervisore — ed e'
+      // esattamente la ragione per cui il difetto esiste: su Termux nessuno
+      // rialza il processo. Dove il servizio e' gestito (systemd, launchd) il
+      // supervisore c'e' ed e' suo il compito: avviare noi un processo
+      // portatile accanto significherebbe metterne in piedi uno che il gestore
+      // non conosce, mentre il gestore puo' rialzare la propria unita' — due
+      // processi sulla stessa porta, e il nostro sopravvivrebbe allo stop del
+      // servizio. Li' si riferisce e basta.
+      //
+      // Difetto mio, trovato rileggendo prima dell'audit: la prima stesura
+      // chiamava `startPortable` in ogni caso.
+      if (result.runtimeOwner === 'managed') {
+        log(`restart: il servizio NON risponde su 127.0.0.1:${port} dopo il riavvio.`);
+        log('  Il runtime e\' gestito dal servizio di sistema: non avvio un processo accanto.');
+        log('  Controlla lo stato e i log dell\'unita\' di sistema.');
+        return { code: 1 };
+      }
+      // UN SOLO RITENTATIVO, e solo a porta libera. Se la porta e' ancora
+      // occupata il problema e' un altro (un processo che non muore) e
+      // riprovare lo nasconderebbe; se e' libera e il servizio non c'e', il
+      // nuovo processo e' uscito e riavviarlo e' esattamente il rimedio.
+      // Ripetere all'infinito trasformerebbe un guasto in un ciclo.
+      return (opts.portAvailableImpl || portAvailable)(port, '127.0.0.1').then((libera) => {
+        if (!libera) {
+          log(`restart: il servizio NON risponde su 127.0.0.1:${port} e la porta e' ancora occupata.`);
+          log('  Qualcosa tiene la porta senza servire: non riavvio a vuoto.');
+          log('  Controlla i log del servizio e i processi rimasti.');
+          return { code: 1 };
+        }
+        log(`restart: nessun servizio su ${port} e porta libera — il processo e' uscito. Riprovo una volta.`);
+        (opts.startPortableImpl || startPortable)({ ...opts, spawnImpl: opts.spawnImpl });
+        return (opts.waitForRuntimeImpl || waitForNexusCrew)(port, token, {
+          ...opts, waitAttempts: opts.waitAttempts === undefined ? 60 : opts.waitAttempts,
+          waitDelayMs: opts.waitDelayMs === undefined ? 250 : opts.waitDelayMs,
+        }).then((sanoOra) => {
+          if (sanoOra) {
+            log(`restart: servizio verificato su 127.0.0.1:${port} al secondo tentativo`);
+            return { code: 0 };
+          }
+          log(`restart: il servizio NON risponde su 127.0.0.1:${port} nemmeno dopo un secondo avvio.`);
+          log('  Il comando di riavvio e\' partito, il processo non resta su.');
+          log('  Controlla i log del servizio; su Termux puo\' servire riavviare il dispositivo.');
+          return { code: 1 };
+        });
+      });
+    };
+    return (opts.waitForRuntimeImpl || waitForNexusCrew)(port, token, {
+      ...opts, waitAttempts: opts.waitAttempts === undefined ? 60 : opts.waitAttempts,
+      waitDelayMs: opts.waitDelayMs === undefined ? 250 : opts.waitDelayMs,
+    }).then(attesa);
   }
   // Internal runtime commands used by service managers and MCP clients. They
   // are intentionally omitted from HELP and are not configuration surfaces.

package/lib/mcp/server.js CHANGED Viewed

@@ -215,10 +215,44 @@ function createMcpServer(opts = {}) {
       });
     } catch (e) { throw transportError(baseUrl, e); }
     const j = await r.json().catch(() => ({}));
-    if (!r.ok) throw new Error(j.error ? `API ${r.status}: ${j.error}` : `API ${r.status}`);
+    if (!r.ok) {
+      const base = j.error ? `API ${r.status}: ${j.error}` : `API ${r.status}`;
+      throw new Error(base + await disallineamentoDiVersione());
+    }
     return j;
   }
+  // NC-R. Aggiornare NexusCrew NON aggiorna il bridge MCP delle celle gia' in
+  // piedi: quel processo e' partito col codice di prima e ci resta fino al
+  // riavvio della cella. Il sintomo e' crudele — si installa una correzione, si
+  // riprova, e si riceve l'errore VECCHIO — e chi lo subisce conclude che la
+  // correzione non funziona. E' successo il 2026-08-07 su rc.26, a me, e ci ho
+  // messo un giro intero a capirlo.
+  //
+  // Il momento in cui serve saperlo e' esattamente quello in cui qualcosa
+  // fallisce, quindi la verifica sta SOLO sul ramo d'errore: a regime non costa
+  // niente, e non si puo' nemmeno mettere in cache all'avvio — la versione che
+  // cambia e' quella dell'hub, e cambia proprio mentre questo processo vive.
+  //
+  // Non trasforma mai un errore in un altro: se la verifica fallisce, l'errore
+  // originale esce come sarebbe uscito comunque.
+  async function disallineamentoDiVersione() {
+    try {
+      const r = await fetchImpl(`${baseUrl}/api/config`, {
+        headers: { authorization: `Bearer ${readToken()}` },
+        signal: AbortSignal.timeout(HTTP_TIMEOUT_MS),
+      });
+      if (!r.ok) return '';
+      const cfg = await r.json();
+      if (typeof cfg.version !== 'string' || cfg.version === VERSION) return '';
+      return `\n\nNOTA: questo bridge MCP e' la versione ${VERSION}, l'hub e' la ${cfg.version}.`
+        + ' Aggiornare NexusCrew non aggiorna il bridge di una cella gia\' avviata:'
+        + ' riavvia questa cella se ti aspettavi un comportamento diverso.';
+    } catch (_) {
+      return '';
+    }
+  }
   const ctx = {
     session,
     identity,

package/lib/mcp/tools.js CHANGED Viewed

@@ -321,7 +321,7 @@ const TOOLS = [
       // 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,
+      // (rilievo R1 di un audit indipendente 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/proxy/federation.js CHANGED Viewed

@@ -351,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);

package/lib/tmux/actions.js CHANGED Viewed

@@ -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/lib/update/runner.js CHANGED Viewed

@@ -36,6 +36,33 @@ async function restartRuntime(opts = {}) {
     }
     mode = 'service';
   } else {
+    // I TUNNEL SI FERMANO PRIMA, come fa il riavvio manuale — e prima qui non
+    // accadeva. `commands.restart` chiama `stopManagedTunnels` sul ramo
+    // gestito (commands.js), quindi il percorso di sopra e' coperto; questo
+    // ramo portatile — quello di un dispositivo senza gestore di servizi —
+    // uccideva il servizio e lasciava vivi i supervisori dei tunnel.
+    //
+    // COSA PRODUCE, osservato sul campo il 2026-08-07: al riavvio il servizio
+    // nuovo trova un supervisore ancora vivo che non riesce ad attribuirsi
+    // — gli servono runId, uid, start-time e un file di stato concorde — e
+    // allora NON lo ferma e NON ne avvia uno suo (`lib/nodes/tunnel.js`:
+    // «unattributable existing supervisor», «orphan tunnel cleanup failed»).
+    // Il canale inverso resta appeso a un orfano che nessuno riconcilia: il
+    // peer risulta giu' finche' qualcuno non interviene a mano.
+    //
+    // La correlazione che lo ha isolato, misurata su un dispositivo reale:
+    // riavvii via `nexuscrew restart` -> peer su, 2 su 2; riavvii per
+    // aggiornamento automatico -> peer giu', 2 su 2. La differenza fra i due
+    // percorsi era esattamente questa riga.
+    //
+    // Best-effort: un errore nel fermare i tunnel non deve impedire
+    // l'aggiornamento, che e' il compito principale. Ma tacerlo lo
+    // renderebbe irrintracciabile la prossima volta.
+    try {
+      (opts.stopTunnelsImpl || commands.stopManagedTunnels)({ home, platform });
+    } catch (e) {
+      if (opts.log) opts.log(`restart portatile: stop tunnel non riuscito — ${e && e.message ? e.message : e}`);
+    }
     const pidPath = pidf.defaultPidfilePath(home);
     const meta = pidf.readPidfile(pidPath);
     if (meta && pidf.isAlive(meta)) {

package/package.json CHANGED Viewed

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

package/skills/nexuscrew-agent/SKILL.md CHANGED Viewed

@@ -1,6 +1,6 @@
 ---
 name: nexuscrew-agent
-description: Use when an AI agent connected to NexusCrew must notify or ask the human, inspect runtime or deck context, manage exact authorized VL micro-device nodes, list authorized Fleet cells, message an exact active cell, read its inbox, deliver a file, recover from local tmux messages that remain unsubmitted or garbled, or when a drag in the web terminal does not scroll a full-screen TUI. Prefer nc_notify, nc_ask, nc_status, nc_deck, nc_cells, nc_vl_nodes, nc_vl_command, nc_send_cell, nc_inbox, and nc_send_file; use bundled tmux/file helpers only as a declared compatibility fallback.
+description: Use when an AI agent connected to NexusCrew must notify or ask the human, inspect runtime, identity or deck context, diagnose a Fleet cell that will not start, manage exact authorized VL micro-device nodes, list authorized Fleet cells, message an exact active cell, speak on a target node or audio group, read its inbox, deliver a file, recover from local tmux messages that remain unsubmitted or garbled, or when a drag in the web terminal does not scroll a full-screen TUI. Prefer nc_notify, nc_ask, nc_status, nc_identity, nc_deck, nc_cells, nc_cell_diagnostics, nc_vl_nodes, nc_vl_command, nc_send_cell, nc_speak, nc_speak_group, nc_inbox, and nc_send_file; use bundled tmux/file helpers only as a declared compatibility fallback.
 ---
 # NexusCrew Agent I/O
@@ -25,6 +25,12 @@ When the client exposes the NexusCrew MCP server, use these tools directly:
 | Revoke an exact VL pairing | `nc_vl_revoke` |
 | List files received for the current session | `nc_inbox` |
 | Deliver an absolute file path under the user's home | `nc_send_file` |
+| Speak an utterance on an exact target node | `nc_speak` |
+| Speak to a named local audio group | `nc_speak_group` |
+| Check or stop an utterance you started | `nc_speak_status`, `nc_speak_stop` |
+| Check or stop a group utterance you started | `nc_speak_group_status`, `nc_speak_group_stop` |
+| Read who the caller is, without a session or token | `nc_identity` |
+| Read why a local Fleet cell failed to start | `nc_cell_diagnostics` |
 Apply these rules:
@@ -37,6 +43,11 @@ Apply these rules:
 - Use `nc_vl_nodes` immediately before VL mutation. Mutation tools require an active local Fleet caller and the full owner-qualified VL ID. `nc_vl_command` `submitted` means live-poll delivery only; require the same ID in `lastAck`. No offline queue exists.
 - Use `nc_inbox` instead of guessing an inbox path when the tool is available.
 - Pass `nc_send_file` an existing absolute regular-file path below the user's home. Let NexusCrew choose and sanitize the outbox name.
+- Speak only when audio is the point. `nc_speak` needs an exact target instance id and returns a caller-scoped receipt with a per-endpoint status (`refused`, `unreachable`, `accepted`) — accepted means the node took the utterance, not that a human heard it. Keep the text short: a spoken line that runs long is worse than no line, and the detail belongs in a file or a notification. A status or stop call only ever reaches an utterance you started; you cannot inspect or silence someone else's.
+- `nc_speak_group` expands a named local group into exact instance ids. `primary-failover` tries one endpoint at a time; `fanout` is explicit. Neither receipt reports text, language or voice back to you — that is deliberate, and it means the receipt cannot be used to read what another caller said.
+- Consent to use a room's speaker is granted locally on the node that owns it and never across the federation. Speaking and stopping travel; granting does not.
+- `nc_identity` answers "who am I to this bridge" with non-sensitive data only, and works without a tmux session or a token. Use it when a tool refuses you and you are not sure which caller the server sees, instead of guessing from the environment.
+- `nc_cell_diagnostics` returns the redacted shell command and the last bounded spawn or start failure for one local Fleet cell. Use it when a cell will not come up, before reading state files.
 - Do not treat an MCP notification as a substitute for the final response required by the active client.
 The MCP server is the stdio command `nexuscrew mcp` and must be registered in the host AI client. If the `nc_*` tools are not exposed, report that the bridge is not configured in that session and use the fallback flows below where applicable.
@@ -134,6 +145,10 @@ work. The setting is also applied to windows created later in that session.
 | Discover authorized cells across nodes | `nc_cells` |
 | Submit to an exact active Fleet cell | `nc_send_cell` |
 | Discover/manage a paired VL micro-device | `nc_vl_nodes`, then `nc_vl_command` |
+| Say something out loud on a node or group | `nc_speak`, `nc_speak_group` (short text) |
+| Stop something you are saying | `nc_speak_stop`, `nc_speak_group_stop` |
+| Find out which caller the bridge sees | `nc_identity` |
+| Find out why a local cell will not start | `nc_cell_diagnostics` |
 | Give the human a file | `nc_send_file` or fallback `nc-deliver <file>...` |
 | Read a file the human sent | `nc_inbox` or fallback to the path in the prompt |
 | Send a prompt/command to a session | `nc-send <session> "text"` |
@@ -150,4 +165,7 @@ work. The setting is also applied to windows created later in that session.
 - **Delivering to a guessed session name** → file lands in an orphan folder with no badge. Use `nc-deliver` (it reads the real session).
 - **Sending to an ambiguous cell name** → call `nc_cells` and use the full owner-qualified ID.
 - **Calling `submitted` a completed task** → it is only a transport receipt; require an explicit result callback.
+- **Concluding a cell is stuck because it looks idle** → a terminal interface queues an incoming message while it is busy, which is healthy; text sitting in the composer of a cell that is *not* working is the defect. To tell them apart, read CPU time from the **child** of the pane process: the pane's own pid is often a wrapper that never burns CPU, so measuring it reports "idle" for a cell working at full tilt.
+- **Assuming a node listens on the port you know** → NexusCrew selects a free port per installation, and a peer's remote port is not the port that node listens on locally. Read it from `nexuscrew status` on that node; a health check aimed at the wrong port reports a dead service that is perfectly alive.
+- **Writing a reply into a local inbox directory** → the inbox is per-installation and is not synchronised between nodes. Answering a remote caller by dropping a file in your own inbox reaches nobody; reply through the tool that addressed you.
 - **Treating a dead scroll gesture as a web-terminal bug** → the pane is in the alternate buffer. Check whether it predates the NexusCrew setting or opted out with `alternateScreen:true`; never send raw page keys to a TUI to work around it.