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

@mmmbuto/nexuscrew 0.8.52 → 0.8.53

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 (9) hide show

package/CHANGELOG.md +97 -0
package/frontend/dist/assets/{index-Cxwpa2Y_.js → index-BJ-_5bxw.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/proxy/federation.js +29 -2
package/lib/tmux/actions.js +33 -1
package/package.json +1 -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-BJ-_5bxw.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.53"}

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/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/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscrew",
-  "version": "0.8.52",
+  "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": {