@mmmbuto/nexuscrew 0.9.41 → 0.9.42

package/frontend/dist/index.html

@@ -11,8 +11,8 @@
   <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-DGa2FEN2.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-Ca1Rl40n.css">
+  <script type="module" crossorigin src="/assets/index-DpFbq_tt.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-CPO7bv6-.css">
 </head>
 <body>
   <div id="root"></div>

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.9.41"}
+{"version":"0.9.42"}

package/lib/files/activity.js

@@ -14,13 +14,24 @@
 // Quattro regole, le stesse di telemetry.js ma con esito diverso:
 //   1. TIMESTAMP OBBLIGATORIO e guardato nei DUE versi — oltre la finestra il
 //      dato e' morto, e un ts nel futuro non deve restare fresco per sempre.
-//   2. SCADUTO NON E' IDLE: oltre la finestra si torna `null`, che la UI mostra
-//      come «non verificato». Mai affermare «ferma» su un dato che non
-//      verifica nulla: e' l'unico modo di coprire l'interruzione con Ctrl-C,
-//      che (misurato su Claude Code 2.1.280) NON emette alcun evento.
+//   2. SCADUTO NON E' IDLE — MA NON PER TUTTI. Oltre la finestra si torna
+//      `null`, che la UI mostra come «non verificato»: mai affermare «ferma»
+//      su un dato che non verifica nulla. La finestra copre un caso preciso:
+//      un turno al LAVORO interrotto con Ctrl-C non emette alcun evento
+//      (misurato su Claude Code 2.1.280), quindi senza scadenza resterebbe
+//      «al lavoro» per sempre. Su «ferma» non serve, ed e' anzi dannosa: e'
+//      uno stato che resta vero, e la fine del processo lo invalida gia' con
+//      la generazione (regola 3). Vedi EVENTI_SENZA_SCADENZA.
 //   3. GENERAZIONE: lo stato di un lancio precedente della stessa cella non
 //      vale per quello corrente. La generazione corrente la scrive il launcher
-//      (activity.gen); un file che ne porta un'altra viene scartato.
+//      (activity.gen); se il launcher ne dichiara una, un file che ne porta
+//      un'altra — o che non ne porta AFFATTO — viene scartato: senza
+//      generazione il dato non e' legato ad alcun lancio, e con «ferma» che non
+//      scade piu' resterebbe vero per sempre. Se invece il launcher non ne
+//      dichiara una (formato storico, celle senza hook), il file vale com'e'.
+//      La generazione da sola non basta al RIAVVIO INTERNO del client: quello
+//      avviene dentro lo stesso lancio, quindi la generazione non cambia e il
+//      supervisore deve dichiarare l'uscita (vedi USCITA).
 //   4. LETTURA TOLLERANTE: file assente, illeggibile o JSON rotto -> null, mai
 //      un'eccezione: la lista delle sessioni non deve fallire per questo.
 
@@ -60,10 +71,48 @@ const STATO_PER_EVENTO = Object.freeze({
   SubagentStop: LAVORA,
   Stop: FERMA,
   PermissionRequest: ATTESA,
+  // `Interrupt` NON e' un evento di Claude Code: e' l'equivalente che codex
+  // emette quando il turno viene interrotto, e per le celle codex e' l'unico
+  // segnale che dice «ferma» in quel caso. Sta qui e non in una mappa separata
+  // perche' il significato e' lo stesso — un turno finito senza esito.
+  Interrupt: FERMA,
 });
 
 const TIPO_PERMESSO = 'permission_prompt';
 
+// Gli eventi che NON scadono con l'eta'. Sono quelli che dicono «ferma»: un
+// turno finito resta finito, e non c'e' nessun Ctrl-C da coprire — se il
+// processo muore, `activity.gen` cambia e lo stato viene scartato comunque
+// dalla regola 3. Farli scadere significava mostrare «non verificata» una
+// cella che aveva appena finito il turno, per il solo passare del tempo.
+const EVENTI_SENZA_SCADENZA = Object.freeze(['Stop', 'Interrupt']);
+
+// L'evento con cui il SUPERVISORE dichiara che il client e' uscito. Non e' un
+// evento del client — il client che muore non ha modo di scriverlo — e non e'
+// una transizione: dice che il processo che pubblicava lo stato non c'e' piu',
+// quindi che il dato precedente non e' piu' verificabile. `statoDaEvento` lo
+// mappa a null, e non e' registrabile dagli hook (`daRegistrare` lo ignora): lo
+// scrive `cell-exec` con `scriviStato`.
+//
+// Perche' serve, ora che «ferma» non scade: il supervisore riavvia il client
+// DENTRO lo stesso lancio (cell-exec.js:781-830), quindi `activity.gen` non
+// cambia e la regola 3 non puo' accorgersi che il client precedente e' morto.
+// Senza questo evento uno `Stop` dell'ultimo turno resterebbe «ferma» per tutto
+// il backoff — e per sempre, se il nuovo client non emette hook.
+const USCITA = 'ClientExit';
+
+// L'evento di LANCIO: lo scrive `cell-exec` all'avvio del lancio, PRIMA di
+// pubblicare la generazione. Non dichiara uno stato — invalida quello che c'e'
+// (il lettore lo mappa a null, come l'uscita): senza, lo stato lasciato dal
+// client precedente sopravviverebbe al lancio nuovo.
+const AVVIO = 'Launch';
+
+// La seconda riga del file di generazione dichiara che il supervisore di questo
+// lancio GARANTISCE l'evento di uscita. Senza quel segno — un lancio di un
+// supervisore vecchio (0.9.41, 0.9.42-dev.0) — «ferma» e «interrotta» tornano a
+// scadere come prima.
+const SEGNO_USCITA = 'exit:1';
+
 /**
  * Stato dichiarato da un evento, oppure null se l'evento non autorizza nessuna
  * transizione (o non e' un evento noto). Non lancia mai.
@@ -74,6 +123,9 @@ function statoDaEvento(evento, tipoNotifica) {
     return tipoNotifica === TIPO_PERMESSO ? ATTESA : null;
   }
   if (evento === 'SessionEnd') return null;
+  // L'uscita del client e il lancio non dichiarano uno stato: invalidano
+  // quello che c'e'.
+  if (evento === USCITA || evento === AVVIO) return null;
   return Object.prototype.hasOwnProperty.call(STATO_PER_EVENTO, evento)
     ? STATO_PER_EVENTO[evento]
     : null;
@@ -105,19 +157,41 @@ function daRegistrare(evento, tipoNotifica) {
   return Object.prototype.hasOwnProperty.call(STATO_PER_EVENTO, evento);
 }
 
-function leggiGenerazioneCorrente(dirSessione) {
+// Il file di generazione per intero: la PRIMA riga e' la generazione, e la
+// presenza del segno `exit:1` dice se il supervisore di questo lancio garantisce
+// l'invalidazione all'uscita.
+//
+// LA SECONDA RIGA NON VIENE FRAINTESA DA UN LETTORE VECCHIO. La 0.9.41 legge il
+// file con un `trim()` del contenuto intero e lo confronta con la generazione
+// dell'evento: con due righe il confronto non torna, quindi gli eventi vengono
+// scartati e la cella risulta «non verificato». Degrada, non crede a uno stato
+// vecchio — ed e' la direzione giusta. Provato in
+// tests/fleet-activity-genfile-compat.test.js col lettore della 0.9.41 vero.
+function leggiGenerazione(dirSessione) {
   try {
-    const raw = fs.readFileSync(path.join(dirSessione, NOME_GENERAZIONE), 'utf8').trim();
-    return raw || null;
-  } catch (_) { return null; }
+    const righe = fs.readFileSync(path.join(dirSessione, NOME_GENERAZIONE), 'utf8').split('\n');
+    const generazione = String(righe[0] || '').trim();
+    if (!generazione) return { generazione: null, uscitaGarantita: false };
+    return {
+      generazione,
+      uscitaGarantita: righe.slice(1).some((riga) => riga.trim() === SEGNO_USCITA),
+    };
+  } catch (_) { return { generazione: null, uscitaGarantita: false }; }
+}
+
+function leggiGenerazioneCorrente(dirSessione) {
+  return leggiGenerazione(dirSessione).generazione;
 }
 
 /**
  * Scrive la generazione corrente della cella. Chiamata dal launcher al momento
  * del lancio: e' l'unico scrittore di questo file.
  */
-function scriviGenerazione(dirSessione, generazione) {
+function scriviGenerazione(dirSessione, generazione, { uscitaGarantita = false } = {}) {
   if (typeof generazione !== 'string' || !generazione) return false;
+  // Il chiamante che non dice niente scrive il formato storico (una riga): e' il
+  // caso di un lancio di cui non si garantisce l'invalidazione all'uscita.
+  const contenuto = uscitaGarantita ? `${generazione}\n${SEGNO_USCITA}` : generazione;
   const destinazione = path.join(dirSessione, NOME_GENERAZIONE);
   let tmp = null;
   try {
@@ -126,7 +200,7 @@ function scriviGenerazione(dirSessione, generazione) {
     // scrittura di chi arriva secondo. Qui il rischio e' piu' basso (il
     // launcher e' l'unico scrittore), ma il difetto sarebbe identico.
     tmp = tmpUnivoco(dirSessione, NOME_GENERAZIONE);
-    fs.writeFileSync(tmp, generazione, { encoding: 'utf8', mode: 0o600 });
+    fs.writeFileSync(tmp, contenuto, { encoding: 'utf8', mode: 0o600 });
     fs.renameSync(tmp, destinazione);
     return true;
   } catch (_) {
@@ -208,10 +282,18 @@ function tsPubblicato(dirSessione) {
  * il `ts`: un evento piu' vecchio non riporta indietro lo stato, altrimenti una
  * `Stop` gia' registrata verrebbe cancellata da un `PreToolUse` in ritardo.
  *
- * Ritorna `true` quando il deposito riflette ALMENO questo evento — scritto, o
- * superato da uno piu' recente — e `false` solo su un guasto reale. La
- * differenza conta per chi chiama: `false` significa «il tuo evento non e' nel
- * deposito», mai «il tuo evento era vecchio».
+ * USCITA DEL CLIENT: `ClientExit` e' AUTOREVOLE e vince SEMPRE sull'ordine dei
+ * timestamp. Quando il client esce, ogni stato gia' pubblicato — anche uno
+ * `Stop` con un ts nel futuro tollerato, che descriveva lo stesso client —
+ * descrive una cosa che non esiste piu'. Se un ts pubblicato e' piu' avanti di
+ * quello dell'uscita, l'uscita si ripubblica con `ts = max(ora, ts
+ * pubblicato + 1)`: subito dopo lo stato da invalidare, mai nel futuro che il
+ * lettore scarta. Un hook ordinario invece NON vince: viene scartato.
+ *
+ * Ritorna `true` quando l'evento e' stato SCRITTO, `false` quando e' stato
+ * SCARTATO — «il tuo evento non e' nel deposito». Chi chiama puo' quindi
+ * distinguere, e l'uscita del client registrata a mano in cell-exec segnala
+ * il caso invece di perderlo.
  *
  * LIMITE DICHIARATO: se il lock non e' ottenibile entro il budget — caso
  * patologico, non misurato in esercizio — si scrive comunque, e allora resta la
@@ -235,7 +317,17 @@ function scriviStato(dirSessione, { evento, tipo, sessionId, generazione, ora =
     let tmp = null;
     try {
       const pubblicato = tsPubblicato(dirSessione);
-      if (pubblicato !== null && pubblicato > ora) return true;
+      if (pubblicato !== null && pubblicato > ora) {
+        if (evento === USCITA || evento === AVVIO) {
+          // L'uscita del client vince sull'ordine: subito dopo lo stato
+          // pubblicato, mai nel futuro che il lettore scarta.
+          dato.ts = pubblicato + 1;
+        } else {
+          // Un hook piu' vecchio dello stato pubblicato non lo riporta
+          // indietro: scartato, e lo scarto e' un esito, non un successo.
+          return false;
+        }
+      }
       tmp = tmpUnivoco(dirSessione, NOME_FILE);
       fs.writeFileSync(tmp, `${JSON.stringify(dato)}\n`, { encoding: 'utf8', mode: 0o600 });
       fs.renameSync(tmp, destinazione);
@@ -267,17 +359,37 @@ function leggiAttivita(root, sessione, ora = Date.now()) {
     if (!dato || typeof dato !== 'object' || Array.isArray(dato)) return null;
     const ts = Number(dato.ts);
     if (!Number.isFinite(ts)) return null;
-    if (ora - ts > MASSIMA_ETA_MS) return null;
+    // Il futuro resta scartato per TUTTI: un ts avanti non deve restare fresco
+    // per sempre, e vale anche per gli eventi che non scadono.
     if (ts - ora > FUTURO_TOLLERATO_MS) return null;
 
-    // Generazione: se il launcher ne ha dichiarata una e il file ne porta
-    // un'altra, lo stato appartiene a un lancio precedente della stessa cella.
-    const corrente = leggiGenerazioneCorrente(dir);
+    // Generazione: se il launcher ne ha dichiarata una, il file deve portare
+    // ESATTAMENTE quella. Non basta il mismatch: un file SENZA generazione non
+    // e' legato ad alcun lancio, e finche' ogni stato scadeva il caso era
+    // coperto dalla finestra — ora che «ferma» non scade piu', un vecchio `Stop`
+    // senza generazione resterebbe vero attraverso i lanci successivi.
+    // La generazione la DEVE dichiarare l'evento, e deve essere quella su disco.
+    // Un evento senza generazione non e' legato ad alcun lancio (gli hook la
+    // dichiarano nel comando dell'hook): nessuno puo' invalidarlo, e con «ferma» che non scade
+    // resterebbe vero per sempre. Non c'e' piu' compatibilita' col formato
+    // senza generazione: quel formato non esiste piu' sul campo.
+    const { generazione: corrente, uscitaGarantita } = leggiGenerazione(dir);
     const dalFile = typeof dato.generation === 'string' && dato.generation ? dato.generation : null;
-    if (corrente && dalFile && corrente !== dalFile) return null;
+    if (!dalFile) return null;
+    if (!corrente || corrente !== dalFile) return null;
 
     const stato = statoDaEvento(dato.event, dato.notification_type);
     if (!stato) return null;
+    // La scadenza si applica DOPO aver conosciuto l'evento: serve sapere se
+    // questo stato e' uno di quelli che restano veri («ferma») o uno che senza
+    // rinnovo non verifica piu' niente (lavoro, attesa).
+    // «ferma» e «interrotta» non scadono SOLO dove il supervisore del lancio
+    // garantisce l'evento di uscita: e' quella garanzia a invalidarle quando il
+    // client muore. Senza (supervisore vecchio) scadono come nella 0.9.41, e la
+    // cella torna «non verificato» invece di dire «ferma» per ore su un client
+    // che nessuno invalidera'.
+    if (!(EVENTI_SENZA_SCADENZA.includes(dato.event) && uscitaGarantita)
+      && ora - ts > MASSIMA_ETA_MS) return null;
     return {
       stato,
       ts,
@@ -288,7 +400,8 @@ function leggiAttivita(root, sessione, ora = Date.now()) {
 }
 
 module.exports = {
-  leggiAttivita, scriviStato, scriviGenerazione, statoDaEvento, daRegistrare,
+  leggiAttivita, scriviStato, scriviGenerazione, leggiGenerazione, leggiGenerazioneCorrente,
+  statoDaEvento, daRegistrare, AVVIO, SEGNO_USCITA,
   NOME_FILE, NOME_GENERAZIONE, MASSIMA_ETA_MS, FUTURO_TOLLERATO_MS,
-  LAVORA, FERMA, ATTESA, TIPO_PERMESSO, STATO_PER_EVENTO,
+  LAVORA, FERMA, ATTESA, TIPO_PERMESSO, STATO_PER_EVENTO, USCITA,
 };

package/lib/fleet/ai-desktop.js

@@ -0,0 +1,123 @@
+'use strict';
+// Il desktop grafico come servizio GOVERNATO: un container con nome fisso
+// (`ai-desktop`, lo stesso che l'engine desktop.local esegue con docker exec)
+// e un pannello web su porta propria (KasmVNC). La spunta in Impostazioni
+// decide se esiste come funzione della UI: ON → il container gira e il tasto
+// appare; OFF → il container si ferma e il pannello esce da ogni superficie.
+//
+// Contratti:
+//   - DOCKER SENZA SHELL: execFile con argomenti vettore, nome del container
+//     COSTANTE (mai stringhe costruite da input), timeout, esito sempre
+//     riportato {ok, error}. Il binario e' 'docker' salvo override esplicito
+//     (per i test: un finto binario via `dockerBin`, mai un docker vero).
+//   - LA CHIAVE COMANDA, IL DEFAULT SI DERIVA: `aiDesktop` esplicita in
+//     config.json vince sempre; se assente, `chiaveEsplicita` risponde null e
+//     il chiamante deriva dal container (running → true) DOVE ha senso —
+//     nelle impostazioni, in una chiamata esplicita. MAI nel percorso caldo
+//     del fleetStatus: li' conta solo la chiave esplicita (false taglia il
+//     pannello del desktop; assente = comportamento di sempre, nessuno perde
+//     un tasto senza aver mai toccato la spunta).
+//   - IL PANNELLO DEL DESKTOP si riconosce dalla porta (KasmVNC 6901): e' la
+//     porta che l'engine desktop.local precompila e la sola cosa che il
+//     pannello del container e un altro pannello hanno di diverso.
+
+const { execFile } = require('node:child_process');
+const { readConfigJson, configJsonPath } = require('../config.js');
+
+const CONTAINER = 'ai-desktop';
+const PANEL_PORT = 6901;
+const TIMEOUT_MS = 15_000;
+// La config e' piccola ma il chiamante caldo (cellStatus) gira a ogni giro di
+// polling: un mtime guard evita di riparsare il file ad ogni lettura.
+const CACHE_MS = 3000;
+let cacheConfig = null; // {path, mtimeMs, valore}
+
+function leggiConfig(pathConfig = configJsonPath()) {
+  if (pathConfig) {
+    try {
+      const mtime = require('node:fs').statSync(pathConfig).mtimeMs;
+      if (cacheConfig && cacheConfig.path === pathConfig && cacheConfig.mtimeMs === mtime) {
+        return cacheConfig.valore;
+      }
+      const valore = readConfigJson(pathConfig) || {};
+      cacheConfig = { path: pathConfig, mtimeMs: mtime, valore };
+      return valore;
+    } catch (_) { /* config assente o illeggibile: come assente */ }
+  }
+  return {};
+}
+
+// La chiave esplicita: true/false quando l'utente ha toccato la spunta,
+// null quando non l'ha mai toccata (il chiamante deriva o non taglia).
+function chiaveEsplicita(config) {
+  if (!config || typeof config !== 'object') return null;
+  return typeof config.aiDesktop === 'boolean' ? config.aiDesktop : null;
+}
+
+function leggiChiave(pathConfig = configJsonPath()) {
+  return chiaveEsplicita(leggiConfig(pathConfig));
+}
+
+// Il pannello del desktop: porta KasmVNC del container, nessun altro caso.
+function isDesktopPanelUrl(url) {
+  try {
+    return Number(new URL(String(url)).port) === PANEL_PORT;
+  } catch (_) { return false; }
+}
+
+// Il taglio nel percorso caldo: SOLO la chiave esplicita false nasconde il
+// pannello del desktop. Chiave assente o true: il pannello passa come sempre —
+// una lettura di docker qui sarebbe una dipendenza nuova su un percorso a poll,
+// la classe di difetto gia' scartata per l'engine (builtin.js).
+function pubblicaPanelUrl(url, config) {
+  const urlClean = typeof url === 'string' ? url.trim() : '';
+  if (!urlClean) return '';
+  if (chiaveEsplicita(config) === false && isDesktopPanelUrl(urlClean)) return '';
+  return urlClean;
+}
+
+// Variante per il chiamante caldo (cellStatus): la config arriva dal guard su
+// mtime (cache interna), non da una lettura per cella né da un probe docker.
+function pubblicaPanelUrlCaldo(url) {
+  return pubblicaPanelUrl(url, leggiConfig());
+}
+
+// Docker senza shell: execFile vettoriale, timeout, esito mai lanciato.
+function eseguiDocker(args, opts = {}) {
+  const bin = opts.dockerBin || 'docker';
+  return new Promise((resolve) => {
+    execFile(bin, args, { timeout: opts.timeout ?? TIMEOUT_MS, encoding: 'utf8' }, (err, stdout, stderr) => {
+      resolve({
+        ok: !err,
+        stdout: String(stdout || ''),
+        stderr: String(stderr || ''),
+        timeout: !!(err && err.killed),
+      });
+    });
+  });
+}
+
+// Il container esiste e gira? `docker inspect` risponde anche da fermo; se
+// non risponde proprio, il container e' assente (o docker lo nega): in tutti
+// i casi `running:false` con la causa, mai un lancio.
+async function containerRunning(opts = {}) {
+  const r = await eseguiDocker(['inspect', '-f', '{{.State.Running}}', CONTAINER], opts);
+  if (!r.ok) return { running: false, exists: false, error: r.stderr.trim() || 'container non ispezionabile' };
+  return { running: r.stdout.trim() === 'true', exists: true };
+}
+
+async function avvia(opts = {}) {
+  const r = await eseguiDocker(['start', CONTAINER], opts);
+  return r.ok ? { ok: true, running: true } : { ok: false, running: false, error: r.stderr.trim() || 'start fallito', timeout: r.timeout };
+}
+
+async function ferma(opts = {}) {
+  const r = await eseguiDocker(['stop', CONTAINER], opts);
+  return r.ok ? { ok: true, running: false } : { ok: false, running: null, error: r.stderr.trim() || 'stop fallito', timeout: r.timeout };
+}
+
+module.exports = {
+  CONTAINER, PANEL_PORT, TIMEOUT_MS,
+  chiaveEsplicita, leggiChiave, leggiConfig, isDesktopPanelUrl, pubblicaPanelUrl, pubblicaPanelUrlCaldo,
+  containerRunning, avvia, ferma,
+};

package/lib/fleet/cell-exec.js

@@ -8,6 +8,7 @@ const net = require('node:net');
 const path = require('node:path');
 const { spawn } = require('node:child_process');
 const { MAX_PAYLOAD } = require('./launch-broker.js');
+const { scriviStato, scriviGenerazione, AVVIO, USCITA } = require('../files/activity.js');
 const {
   validDaemonChallenge, validVerifyExpected, identityErrorCode,
   IDENTITY_FRAME_LIMIT, IDENTITY_TIMEOUT_MS,
@@ -129,9 +130,24 @@ function validLease(value) {
     && typeof value.stablePath === 'string' && value.stablePath.length > 0 && value.stablePath.length <= 4096;
 }
 
+// Canale di attivita' della cella: dove il supervisore deve dichiarare l'uscita
+// del client, e con quale generazione. Presente SOLO quando il launcher ha
+// davvero iniettato gli hook (managed.js pubblica la generazione prima di
+// costruire gli argv): senza canale non c'e' niente da invalidare, e un payload
+// senza il campo conserva il comportamento di prima.
+function validActivity(value) {
+  if (value === undefined) return true;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  if (Object.keys(value).some((key) => !['dir', 'generation'].includes(key))) return false;
+  return typeof value.dir === 'string' && value.dir.length > 0 && value.dir.length <= 4096
+    && !/[\0\r\n]/.test(value.dir)
+    && typeof value.generation === 'string' && value.generation.length > 0 && value.generation.length <= 128
+    && !/[\0\r\n]/.test(value.generation);
+}
+
 function validPayload(payload) {
   if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return false;
-  if (Object.keys(payload).some((key) => !['command', 'args', 'env', 'supervise', 'restartPrompt', 'lease', 'identity', 'identityChannel'].includes(key))) return false;
+  if (Object.keys(payload).some((key) => !['command', 'args', 'env', 'supervise', 'restartPrompt', 'lease', 'identity', 'identityChannel', 'activity'].includes(key))) return false;
   if (typeof payload.command !== 'string' || !payload.command || !Array.isArray(payload.args)) return false;
   if (!payload.env || typeof payload.env !== 'object' || Array.isArray(payload.env)) return false;
   // Il launcher decide se il canale identita' esiste (managed.js) e lo dichiara
@@ -144,6 +160,7 @@ function validPayload(payload) {
     && validSupervise(payload.supervise)
     && validRestartPrompt(payload.restartPrompt)
     && validLease(payload.lease)
+    && validActivity(payload.activity)
     && validIdentity(payload.identity);
 }
 
@@ -590,6 +607,20 @@ async function main(argv = process.argv.slice(2), seams = {}) {
   const sleep = seams.sleep || ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const proc = seams.process || process;
   const writeError = seams.writeError || seams.stderrWrite || ((message) => process.stderr.write(message));
+  const activity = payload.activity || null;
+  // Uscita del client: il supervisore DICHIARA che il processo che pubblicava lo
+  // stato non c'e' piu'. Serve perche' il riavvio avviene DENTRO lo stesso
+  // lancio (loop sotto): `activity.gen` non cambia, quindi la generazione non
+  // puo' accorgersi che il client precedente e' morto. Senza questa riga uno
+  // `Stop` dell'ultimo turno resterebbe «ferma» per tutto il backoff — e per
+  // sempre, ora che «ferma» non scade — mentre il client e' morto e il prossimo
+  // non e' pronto. Il lettore mappa l'evento a null: «non verificato».
+  const dichiaraUscita = () => {
+    if (!activity) return;
+    if (scriviStato(activity.dir, { evento: USCITA, generazione: activity.generation, ora: now() }) !== true) {
+      writeError('nexuscrew cell: uscita del client non registrata nello stato di attivita\n');
+    }
+  };
   // Il canale identita' nasce SOLO se il launcher lo ha deciso: la stessa
   // risoluzione che decide CODEX_APP_SERVER_IDENTITY_REQUIRED in managed.js
   // viaggia nel payload come `identityChannel`. Derivarlo qui (aggiungere
@@ -679,6 +710,55 @@ async function main(argv = process.argv.slice(2), seams = {}) {
     for (const [signal, handler] of handlers) proc.off?.(signal, handler);
   };
 
+  // LA GENERAZIONE SI SCRIVE QUI, E SOLO QUI.
+  //
+  // Questo processo gira DENTRO la sessione tmux appena creata: chi perde la
+  // corsa sulla new-session non arriva mai a un cell-exec e quindi non scrive
+  // niente. Scriverla prima (nella risoluzione) significava scriverla anche per
+  // il perdente: sul disco restava la generazione di chi non aveva lanciato
+  // nulla, mentre gli hook del vincitore portavano la loro — e ogni suo evento
+  // veniva scartato al lettore, cioe' «non verificato» su una cella che
+  // lavorava.
+  //
+  // Prima del primo spawn, non dentro il ciclo: la generazione identifica il
+  // LANCIO, e i riavvii interni del client (il ciclo sotto) restano lo stesso
+  // lancio. Il client parte DOPO questa scrittura: mai un hook che scrive una
+  // generazione che non e' ancora su disco.
+  if (activity) {
+    // (1) INVALIDA lo stato lasciato dal client precedente, PRIMA di pubblicare
+    // la generazione. Un evento di lancio porta la generazione nuova e il
+    // lettore lo mappa a null: senza, un «ferma» dell'ultimo turno del client
+    // precedente sopravviverebbe al lancio — e con «ferma» che non scade
+    // resterebbe vero finche' un hook non lo rinnova, cioe' per sempre su una
+    // cella appena partita. Scrivo prima della generazione di proposito:
+    // l'invalidazione non deve dipendere dalla pubblicazione riuscita.
+    if (scriviStato(activity.dir, {
+      evento: AVVIO, generazione: activity.generation, ora: now(),
+    }) !== true) {
+      // LIMITE DICHIARATO (accettato come tale, non un percorso normale): se la
+      // directory e' diventata non scrivibile fra due lanci, QUI non si scrive
+      // niente e lo stato che la UI mostra puo' essere QUELLO DEL LANCIO
+      // PRECEDENTE — un «ferma» dell'ultimo turno di un client che non c'e'
+      // piu'. Il lettore non puo' accorgersene: la generazione su disco e'
+      // ancora la vecchia, e gli eventi nuovi non arrivano finche' un hook non
+      // scrive. E' un guasto del filesystem durante la vita della cella (la
+      // directory e' stata resa non scrivibile), non un esito che il codice
+      // possa riparare da qui: si dichiara nel log, con la conseguenza.
+      writeError("nexuscrew cell: stato di attivita' precedente non invalidato (directory non scrivibile); "
+        + "lo stato mostrato puo' essere quello del lancio precedente\n");
+    }
+    // (2) PUBBLICA la generazione, e con essa il segno che questo supervisore
+    // garantisce l'evento di uscita: e' quel segno a permettere la non scadenza
+    // di «ferma»/«interrotta» nel lettore.
+    if (scriviGenerazione(activity.dir, activity.generation, { uscitaGarantita: true }) !== true) {
+      // Scrittura fallita: si avvia lo stesso, e lo si dichiara. Il client
+      // scrivera' eventi con una generazione che non e' quella su disco, quindi
+      // verranno scartati e la cella risultera' «non verificato» — l'esito
+      // sicuro, mai «ferma» senza fondamento.
+      writeError("nexuscrew cell: generazione di attivita' non pubblicata, stato non verificabile\n");
+    }
+  }
+
   let delayMs = supervise.restartDelayMs;
   let rapid = [];
   try {
@@ -782,6 +862,11 @@ async function main(argv = process.argv.slice(2), seams = {}) {
       childState.exited = true;
       closeIdentityChannel();
       current = null;
+      // Il client non c'e' piu': QUALUNQUE sia la causa (uscita normale, segnale,
+      // errore di spawn, stop dell'operatore) lo stato pubblicato non e' piu'
+      // verificabile. Prima di ogni return del supervisore, cosi' nessuna delle
+      // uscite resta con lo stato del client morto.
+      dichiaraUscita();
       // : la generazione e' finita. Cancella la delivery in volo e ATTESA
       // Del suo termine PRIMA di qualunque nuovo spawn.: se l'esito e' un
       // post-paste incerto (delivery-unknown / staged-not-submitted) i byte del