@mmmbuto/nexuscrew 0.9.41 → 0.9.42

package/lib/fleet/codex-hooks.js

@@ -0,0 +1,253 @@
+'use strict';
+// Canale di attivita' per le celle codex e codex-vl.
+//
+// Perche' esiste: le celle Claude pubblicano il proprio stato di turno con gli
+// hook di Claude Code (bin/nc-activity-hook.js, iniettato via --settings). Gli
+// engine codex non hanno quel meccanismo, quindi fino a oggi la UI le mostrava
+// «non verificate» — che era la verita', ma anche un'informazione che si poteva
+// avere. Codex ha un sistema di hook proprio, con una differenza che conta:
+// un hook iniettato da riga di comando NON e' fidato finche' il suo hash non
+// compare in `hooks.state`, altrimenti il client apre un dialogo di revisione e
+// non lo esegue.
+//
+// Questo modulo costruisce i due pezzi che servono, e nient'altro:
+//  1. gli argomenti `-c hooks.<Evento>=[...]` che DEFINISCONO l'hook;
+//  2. gli argomenti `-c hooks.state={...}` che lo FIDANO, con l'hash che il
+//     client si aspetta di trovare.
+//
+// L'hash non e' lo sha256 del testo del comando: e' lo sha256 del JSON CANONICO
+// di un'identita' normalizzata (evento + handler normalizzato). Replicato da
+// codex-rs/hooks/src/engine/discovery.rs (`hook_hash`) e
+// codex-rs/config/src/fingerprint.rs (`version_for_toml`).
+//
+// La forma `-c hooks.state.<chiave>.trusted_hash=...` NON funziona: il parser
+// di `-c` spezza il path sui punti (codex-rs/config/src/overrides.rs) e la
+// chiave dell'hook ne contiene. Percio' `hooks.state` si passa come TABELLA
+// inline. Verificato in una prova isolata su TUI reale, su entrambe le
+// versioni in uso.
+
+const crypto = require('node:crypto');
+const { termuxRuntimePaths } = require('../runtime/env.js');
+
+// Etichette usate nelle chiavi di stato — codex-rs/hooks/src/lib.rs,
+// `hook_event_key_label`. Solo gli eventi che iniettiamo.
+const ETICHETTA_EVENTO = Object.freeze({
+  PreToolUse: 'pre_tool_use',
+  PostToolUse: 'post_tool_use',
+  SessionStart: 'session_start',
+  SessionEnd: 'session_end',
+  UserPromptSubmit: 'user_prompt_submit',
+  Stop: 'stop',
+  Interrupt: 'interrupt',
+});
+
+// Timeout normalizzato — codex-rs/hooks/src/engine/discovery.rs,
+// `normalize_command_hook`: dieci minuti per tutti, UN SECONDO per SessionEnd e
+// Interrupt (che hanno anche un tetto di tre). Il valore entra nell'hash,
+// quindi sbagliarlo qui farebbe ricomparire il dialogo di revisione.
+const TIMEOUT_STANDARD_SEC = 600;
+const TIMEOUT_FINE_SEC = 1;
+
+// La fonte sintetica da cui il client crede che l'hook provenga: e' il layer
+// `SessionFlags`, cioe' proprio cio' che passiamo con `-c`
+// (discovery.rs:402-422).
+const KEY_SOURCE_SESSION_FLAGS = '/<session-flags>/config.toml';
+
+function etichetta(evento) {
+  const label = ETICHETTA_EVENTO[evento];
+  if (!label) throw new Error(`evento hook non gestito: ${evento}`);
+  return label;
+}
+
+function timeoutPerEvento(evento) {
+  return evento === 'SessionEnd' || evento === 'Interrupt'
+    ? TIMEOUT_FINE_SEC
+    : TIMEOUT_STANDARD_SEC;
+}
+
+// Riordina le chiavi in modo ricorsivo: `version_for_toml` serializza il JSON
+// CANONICO, e due identita' con le stesse chiavi in ordine diverso devono dare
+// lo stesso hash.
+function ordinaChiavi(valore) {
+  if (Array.isArray(valore)) return valore.map(ordinaChiavi);
+  if (valore && typeof valore === 'object') {
+    const out = {};
+    for (const chiave of Object.keys(valore).sort()) out[chiave] = ordinaChiavi(valore[chiave]);
+    return out;
+  }
+  return valore;
+}
+
+function jsonCanonico(valore) {
+  return JSON.stringify(ordinaChiavi(valore));
+}
+
+/**
+ * Hash atteso da codex per questo handler su questo evento.
+ * Replica `hook_hash` -> `version_for_toml`.
+ */
+function hashHook(evento, comando) {
+  const identita = {
+    event_name: etichetta(evento),
+    hooks: [{
+      async: false,
+      command: comando,
+      timeout: timeoutPerEvento(evento),
+      type: 'command',
+    }],
+  };
+  const digest = crypto.createHash('sha256').update(jsonCanonico(identita), 'utf8').digest('hex');
+  return `sha256:${digest}`;
+}
+
+/** Chiave dello stato per un handler: `hook_key` (hooks/src/lib.rs). */
+function chiaveHook(evento, gruppo = 0, handler = 0) {
+  return `${KEY_SOURCE_SESSION_FLAGS}:${etichetta(evento)}:${gruppo}:${handler}`;
+}
+
+// Stringa TOML. I valori qui sono percorsi e comandi unix, senza backslash:
+// JSON.stringify produce una basic string corretta per questi contenuti.
+function tomlString(valore) {
+  return JSON.stringify(String(valore));
+}
+
+/** Definizione di UN hook: `hooks.<Evento>=[{hooks=[{type,command}]}]`. */
+function definizioneHook(evento, comando) {
+  return `hooks.${evento}=[{hooks=[{type="command",command=${tomlString(comando)}}]}]`;
+}
+
+/** `hooks.state` come tabella inline con un trusted_hash per chiave. */
+function tabellaStato(voci) {
+  const parti = voci.map(({ chiave, hash }) => `${tomlString(chiave)}={trusted_hash=${tomlString(hash)}}`);
+  return `hooks.state={${parti.join(',')}}`;
+}
+
+/**
+ * Argomenti da appendere alla riga di lancio di una cella codex/codex-vl.
+ * `comandoPerEvento(evento)` ritorna il comando dell'hook per quell'evento.
+ * Ritorna [] se non c'e' niente da iniettare.
+ */
+function argomentiHookCodex(eventi, comandoPerEvento) {
+  if (!Array.isArray(eventi) || eventi.length === 0) return [];
+  const args = [];
+  const voci = [];
+  for (const evento of eventi) {
+    const comando = comandoPerEvento(evento);
+    if (!comando) continue;
+    args.push('-c', definizioneHook(evento, comando));
+    voci.push({ chiave: chiaveHook(evento), hash: hashHook(evento, comando) });
+  }
+  if (voci.length === 0) return [];
+  args.push('-c', tabellaStato(voci));
+  return args;
+}
+
+// ── Guardia di versione ────────────────────────────────────────────────
+//
+// L'hash dipende dalla normalizzazione, dalla serializzazione e dal source
+// path sintetico di UNA versione di codex. Se il binario cambia quelle regole,
+// l'hash non combacia piu', il client apre il dialogo «Hooks need review» e la
+// cella resta BLOCCATA su una domanda che nessuno vede. Il costo di sbagliare
+// non e' «hook che non parte»: e' una cella che non lavora.
+//
+// Quindi si inietta SOLO su versioni effettivamente provate, e su ogni altra
+// non si inietta niente: la cella torna «non verificato» come oggi, che e' il
+// comportamento di prima — un degrado dichiarato, non un guasto introdotto.
+const VERSIONI_PROVATE = Object.freeze({
+  codex: ['0.156.1'],
+  'codex-vl': ['0.155.1'],
+});
+
+// Probe della versione, con lo stesso seam del ramo vl (cfg.vlVersionProbe):
+// i test non devono dipendere da un binario vero. Ritorna l'output GREZZO.
+// `binary` e' il percorso RISOLTO del binario della cella, non il nome del
+// client: si esegue quello, senza shell e con un tetto di tempo breve.
+function versionOutput(binary, cfg) {
+  const probe = cfg && typeof cfg.codexVersionProbe === 'function' ? cfg.codexVersionProbe : null;
+  if (probe) {
+    const out = probe(binary);
+    return out === null || out === undefined ? null : String(out);
+  }
+  const { spawnSync } = require('node:child_process');
+  const r = spawnSync(binary, ['--version'], { encoding: 'utf8', timeout: 3000, shell: false });
+  if (r.error || r.status !== 0) return null;
+  return `${r.stdout || ''}${r.stderr || ''}`;
+}
+
+/**
+ * Si puo' iniettare su questo binario? Ritorna { ok, versione } oppure
+ * { ok: false, reason } — il motivo e' per la riga di log, mai per l'utente.
+ * `client` sceglie l'elenco delle versioni provate; `binary` e' cio' che si
+ * esegue davvero. Sono due cose diverse: se coincidono e' una coincidenza.
+ */
+function gateVersione(client, binary, cfg) {
+  const ammesse = VERSIONI_PROVATE[client];
+  if (!ammesse) return { ok: false, reason: `client ${client} non gestito dal canale hook` };
+  if (!binary) {
+    return { ok: false, reason: `binario di ${client} non risolto sul nodo: nessun hook iniettato` };
+  }
+  const out = versionOutput(binary, cfg);
+  if (out === null) {
+    return { ok: false, reason: `versione di ${client} non determinabile (${binary} --version non risponde): nessun hook iniettato` };
+  }
+  const m = out.match(/(\d+\.\d+\.\d+)/);
+  if (!m) {
+    return { ok: false, reason: `versione di ${client} non riconosciuta da "${String(out).trim().slice(0, 60)}": nessun hook iniettato` };
+  }
+  if (!ammesse.includes(m[1])) {
+    return { ok: false, reason: `versione ${client} ${m[1]} non provata con gli hook (provate: ${ammesse.join(', ')}): nessun hook iniettato` };
+  }
+  return { ok: true, versione: m[1] };
+}
+
+// La chiave di fiducia di questi hook e' Unix: `key_source` e'
+// `/<session-flags>/config.toml` e il comando e' quotato in stile POSIX. Il
+// sorgente di codex sintetizza quella fonte con `C:\` su Windows
+// (`hooks/src/engine/discovery.rs:402-435`), quindi la' la chiave che il
+// client calcola NON coincide con quella che generiamo: si inietterebbe un
+// hook non fidato, cioe' esattamente il dialogo che la guardia esiste per
+// evitare. Finche' non c'e' una prova su Windows, li' non si inietta.
+//
+// Termux e' un caso diverso e piu' stretto: il probe esegue il binario
+// direttamente, mentre il launcher lo lancia tramite Node quando lo shim ha
+// uno shebang senza `/usr/bin/env` (`managed.js:1006-1028`). Il gate
+// fallirebbe chiuso, e una cella «non verificata» senza motivo e' un limite
+// che si dichiara qui invece di lasciarlo scoprire.
+function gatePiattaforma(cfg) {
+  const platform = (cfg && cfg.platform) || process.platform;
+  const env = (cfg && cfg.env) || process.env;
+  const termux = platform === 'android'
+    || termuxRuntimePaths(env, { platform, home: cfg && cfg.home }) !== null;
+  if (termux) {
+    return { ok: false, reason: 'termux: il probe della versione non segue il percorso di lancio' };
+  }
+  if (platform !== 'linux' && platform !== 'darwin') {
+    return { ok: false, reason: `piattaforma ${platform}: chiave di fiducia e quoting degli hook non provati qui` };
+  }
+  return { ok: true };
+}
+
+// Eventi iniettati per una cella codex, nell'ordine in cui il client li emette.
+const EVENTI_CODEX = Object.freeze([
+  'SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'Stop', 'Interrupt', 'SessionEnd',
+]);
+
+module.exports = {
+  ETICHETTA_EVENTO,
+  TIMEOUT_STANDARD_SEC,
+  TIMEOUT_FINE_SEC,
+  KEY_SOURCE_SESSION_FLAGS,
+  VERSIONI_PROVATE,
+  EVENTI_CODEX,
+  etichetta,
+  timeoutPerEvento,
+  jsonCanonico,
+  hashHook,
+  chiaveHook,
+  definizioneHook,
+  tabellaStato,
+  argomentiHookCodex,
+  versionOutput,
+  gateVersione,
+  gatePiattaforma,
+};

package/lib/fleet/managed.js

@@ -10,6 +10,7 @@ const { execFile } = require('node:child_process');
 const { ENV_KEY_RE } = require('./env-key.js');
 const { termuxRuntimePaths } = require('../runtime/env.js');
 const { readCredentialStore, safePrivateDir } = require('./credentials.js');
+const { argomentiHookCodex, gateVersione, gatePiattaforma, EVENTI_CODEX } = require('./codex-hooks.js');
 
 const OLLAMA_CLOUD_MODELS = Object.freeze([
   'glm-5.2', 'kimi-k2.7-code', 'deepseek-v4-pro', 'minimax-m3',
@@ -1621,9 +1622,13 @@ function cellMcpDeny(home, cell) {
 // un solo token composto, non due sorgenti distinte. Dove quel token oggi non
 // esiste (ramo strict) ne nasce uno che porta SOLO gli hook.
 //
-// Solo il client `claude` ha questi eventi. Gli altri motori (codex-vl, pi,
-// shell) restano senza canale: la UI li mostra «non verificati», che e' cio'
-// che si sa di loro. Non si inventa uno stato che nessuno pubblica.
+// Il client `claude` li riceve via `--settings` (sotto). Il client codex e
+// codex-vl li riceve in forma `-c` (lib/fleet/codex-hooks.js), con la stessa
+// matrice evento->stato e lo stesso scrittore — e li riceve SOLO su versioni
+// provate, perche' la fiducia dell'hook dipende dall'hash di quella versione.
+// Gli altri motori (pi, shell) restano senza canale: la UI li mostra «non
+// verificati», che e' cio' che si sa di loro. Non si inventa uno stato che
+// nessuno pubblica.
 
 // Gli eventi REGISTRATI, quelli misurati su 2.1.280 nel Gate A. `StopFailure`
 // non compare perche' su quella versione NON esiste: registrarlo sarebbe una
@@ -1683,6 +1688,14 @@ function cellActivityHooks(cell, cfg) {
   const dirSessione = path.join(root, cell.tmuxSession);
   const generazione = cfg && typeof cfg.activityGeneration === 'string' && cfg.activityGeneration
     ? cfg.activityGeneration : null;
+  // QUI NON SI SCRIVE NIENTE SU DISCO. La generazione viaggia negli argv degli
+  // hook e nel payload del broker; a scriverla e' `cell-exec`, che gira DENTRO
+  // la sessione tmux appena creata — quindi solo per il vincitore della
+  // new-session — e lo fa prima di avviare il client (cell-exec.js: la
+  // generazione su disco e' quella del client che gira davvero). Scriverla qui
+  // significava scriverla anche per chi stava per perdere la corsa: sul disco
+  // restava la generazione del perdente, che non e' quella di nessun lancio
+  // vivo, e ogni evento del vincitore veniva scartato al lettore.
   const hooks = {};
   for (const evento of EVENTI_ATTIVITA) {
     const voce = { hooks: [{ type: 'command', command: comandoHook(evento, script, dirSessione, generazione) }] };
@@ -1694,7 +1707,9 @@ function cellActivityHooks(cell, cfg) {
     if (evento === 'PreToolUse' || evento === 'PostToolUse') voce.matcher = '*';
     hooks[evento] = [voce];
   }
-  return { hooks, dirSessione };
+  // `script` e `generazione` escono insieme agli hooks perche' servono anche al
+  // canale codex, che ricompone lo stesso comando in forma `-c`.
+  return { hooks, dirSessione, script, generazione };
 }
 
 // L'argomento `--settings` della cella: deny MCP e hook in UN SOLO oggetto.
@@ -2496,6 +2511,40 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
       if (attivita) args.push(`--settings=${JSON.stringify({ hooks: attivita.hooks })}`);
     }
   } else if (spec.client === 'codex' || spec.client === 'codex-vl') {
+    // Canale di attivita' per le celle codex: gli stessi eventi che le celle
+    // Claude pubblicano via `--settings`, qui come hook `-c` con la fiducia che
+    // il client pretende (senza, apre un dialogo di revisione e la cella resta
+    // ferma su una domanda). Vince SOLO su versioni provate: su ogni altra non
+    // si inietta niente e la cella torna «non verificato» come prima — un
+    // degrado dichiarato, mai un dialogo che blocca il turno.
+    {
+      // `attivita` e' dichiarata nel ramo claude e qui non e' in scope: si
+      // ricalcola. E' pura e non scrive niente su disco: calcola gli stessi
+      // argv (stessa generazione) per il client codex.
+      const attivita = cellActivityHooks(cell, cfg);
+      // Il gate riceve il binario RISOLTO per questa cella (`info.binary`,
+      // lo stesso che finisce in argv a fine funzione), non il nome del
+      // client: col nome si interrogherebbe il PATH del processo, che puo'
+      // essere un eseguibile DIVERSO da quello che la cella lancera'. La
+      // guardia esiste per non far bloccare la cella su un dialogo di
+      // revisione, e una guardia che guarda un altro binario da' il via
+      // libero sbagliato: e' il caso che deve impedire.
+      const piattaforma = gatePiattaforma(cfg);
+      const gate = piattaforma.ok ? gateVersione(spec.client, info.binary, cfg) : piattaforma;
+      if (!gate.ok) {
+        if (typeof cfg.log === 'function') cfg.log(`hook codex non iniettati: ${gate.reason}`);
+      } else if (attivita) {
+        args.push(...argomentiHookCodex(EVENTI_CODEX,
+          (evento) => comandoHook(evento, attivita.script, attivita.dirSessione, attivita.generazione)));
+        // Qui si dichiara che QUESTA cella ha un canale di attivita': e' il
+        // `dir` che fa viaggiare verso il supervisore il dove e il
+        // con-che-generazione dell'evento di uscita (runtime.js) e la
+        // scrittura di `activity.gen` da parte di cell-exec, e senza di esso un
+        // `Stop` dell'ultimo turno sopravviverebbe al riavvio interno del
+        // client.
+        activityDir = attivita.dirSessione;
+      }
+    }
     if (profile.localProvider) args.push('--oss', '--local-provider', profile.localProvider);
     else if (spec.provider === 'openai-api') env.OPENAI_API_KEY = cred.value;
     else if (spec.provider === 'ollama-cloud') {

package/lib/fleet/runtime.js

@@ -17,11 +17,13 @@ const crypto = require('node:crypto');
 const {
   loadDefinitions, validateCommandTrust, resolveCwd,
 } = require('./definitions.js');
+const aiDesktop = require('./ai-desktop.js');
 const {
   describeManaged, resolveManagedEngine, discoverOllamaModels, discoverPiModels, extraModelsFrom,
   knownMcpServerNames,
 } = require('./managed.js');
 const { sharedProbe: defaultEndpointProbe } = require('./endpoint-probe.js');
+const { NC_SUPERVISOR_OPT } = require('../tmux/supervisor-pane.js');
 const {
   httpError, minimalEnv, tmuxExec,
   composeClientInvocation, alternateScreenArgs,
@@ -29,7 +31,6 @@ const {
   redactSecrets, sanitizeEarlyDiagnostic,
 } = require('./launch.js');
 const { waitDeliveryReport, actionRequiredFor, vlPaneReadiness } = require('./prompt-delivery.js');
-const { scriviGenerazione } = require('../files/activity.js');
 
 // Insieme MCP MATERIALIZZATO della cella — le chiavi del file che
 // writeCellMcpConfig (managed.js) scrive PRIMA dello spawn. Un server non
@@ -178,7 +179,12 @@ function createBuiltinRuntime(ctx) {
       // engineDef gia' usata sopra per la permission policy: un valore
       // presente qui e' gia' passato da validPanelUrl a monte (parseEngine/
       // parseCell), quindi si copia, non si ri-valida.
-      const panelUrl = c.panelUrl || engineDef?.panelUrl || '';
+      // La spunta del desktop grafico taglia qui il pannello del container
+      // quando è esplicitamente OFF: il campo non esce dallo stato, quindi il
+      // tasto e la sorgente Pannello spariscono da OGNI superficie senza un
+      // if nel frontend. Solo la chiave esplicita comanda: qui non si
+      // interroga mai docker (percorso caldo a polling).
+      const panelUrl = aiDesktop.pubblicaPanelUrlCaldo(c.panelUrl || engineDef?.panelUrl || '');
       return {
         // `cell` resta l'id: e' la chiave di indirizzamento. `label` e' il nome
         // leggibile e viaggia accanto, senza mai sostituirlo.
@@ -290,7 +296,32 @@ function createBuiltinRuntime(ctx) {
     if (!cell) throw httpError(400, `cella sconosciuta: ${cellId}`);
     const engine = findEngine(defs, cell.engine);
     if (!engine) throw httpError(400, `engine dangling per cella ${cellId}: ${cell.engine}`);
+    // (0) Una cella GIA' VIVA non si rilancia — e soprattutto non si risolve.
+    // Senza questo controllo l'ordine era: si risolve lo spec (che PUBBLICA la
+    // generazione di attivita', managed.js:1696), si chiede il ticket, e solo
+    // alla new-session si scopre che la sessione esiste gia' -> 409. Il file
+    // `activity.gen` restava pero' riscritto con una generazione nuova, mentre
+    // gli hook del lancio vero portano quella vecchia: lo stato di quella cella
+    // veniva scartato (files/activity.js:336-338) e la UI diceva «non
+    // verificata» su una cella che stava lavorando. Lo pagava qualunque `up` su
+    // una cella viva: l'operatore dalla UI, e `fleet-boot` all'avvio del
+    // servizio, che cicla TUTTE le celle boot:true e su quelle gia' in
+    // esecuzione si limitava a saltare (boot.js:49) — dopo aver riscritto il
+    // file.
+    // Il 409 in fondo (new-session) resta come rete per la corsa fra questo
+    // controllo e la creazione della sessione.
+    const vive = await refreshSessions();
+    if (vive.has(String(cell.tmuxSession))) {
+      throw httpError(409, 'sessione già in esecuzione', null,
+        { phase: 'preflight', code: 'SESSION_DUPLICATE' });
+    }
     let launchEngine = engine;
+    // Canale di attivita' della cella: `resolved` vive solo dentro il ramo
+    // managed, e il payload del broker si costruisce FUORI. Portarlo fuori con
+    // una variabile dichiarata qui evita di usare, in un ramo, un nome
+    // dichiarato in un altro: un errore che in produzione fa fallire il lancio
+    // di ogni cella, non una sola asserzione.
+    let activityCanale = null;
     if (engine.managed) {
       // Generazione del lancio: identifica QUESTA partenza della cella. Uno
       // stato di attivita' che ne porta un'altra appartiene a un lancio
@@ -301,6 +332,11 @@ function createBuiltinRuntime(ctx) {
         ...cfg, home, extraModels: extraModelsFrom(defs),
         capabilityProfiles: defs.capabilityProfiles || null,
         activityGeneration: generazione,
+        // La generazione NON si scrive qui: viaggia negli argv degli hook e nel
+        // payload del broker, e a scriverla su disco e' `cell-exec`, dentro la
+        // sessione che tmux ha appena creato — quindi solo per chi vince la
+        // new-session. Chi perde la corsa scriverebbe una generazione che non e'
+        // quella di nessun lancio vivo.
       });
       // Il materializzatore MCP per cella e' FAIL-CLOSED: se il file per cella
       // non si scrive, la cella non parte — mai con la superficie intera dove
@@ -313,11 +349,10 @@ function createBuiltinRuntime(ctx) {
         throw httpError(400, `engine managed non configurato (${engine.id}): ${resolved.reason}`, null, { phase: 'preflight', code });
       }
       launchEngine = resolved.engine;
-      // La generazione si scrive PRIMA che il client parta: gli hook possono
-      // scattare appena il processo e' vivo, e uno stato che arrivasse prima
-      // della generazione verrebbe scartato come se fosse di un lancio
-      // precedente. Solo per le celle che hanno davvero gli hook.
-      if (resolved.activityDir) scriviGenerazione(resolved.activityDir, generazione);
+      // Qui si porta FUORI dal ramo il solo dato che serve al payload: dove e
+      // con quale generazione il supervisore dovra' PUBBLICARLA su disco e
+      // dichiarare l'uscita del client.
+      if (resolved.activityDir) activityCanale = { dir: resolved.activityDir, generation: generazione };
       // A vl cell whose runtime cannot hold the per-cell prompt
       // (VL_SYSTEM_APPEND_FILE, 0.3.1+) DEGRADES by declaring it — same
       // shape as readinessDegraded: the cell starts without its own identity
@@ -392,6 +427,13 @@ function createBuiltinRuntime(ctx) {
         ...(typeof launchEngine.identityChannel === 'boolean'
           ? { identityChannel: launchEngine.identityChannel } : {}),
         ...(leaseInfo ? { lease: { cellId: cell.id, launchEpoch: leaseInfo.launchEpoch, stablePath: leaseInfo.stablePath } } : {}),
+        // Canale di attivita' verso il supervisore: il riavvio del client
+        // avviene DENTRO lo stesso lancio, quindi la generazione non cambia e
+        // l'unico modo di invalidare lo stato del client morto e' che sia
+        // cell-exec a dichiararlo. Presente solo dove gli hook sono davvero
+        // iniettati (`activityDir` lo dice): senza canale non c'e' niente da
+        // invalidare.
+        ...(activityCanale ? { activity: activityCanale } : {}),
         supervise: {
           enabled: !launchEngine.shellOneShot,
           initialReadyMs: Math.max(50, Math.min(30000, Number(readyMs) || 500)),
@@ -468,6 +510,26 @@ function createBuiltinRuntime(ctx) {
       throw httpError(dup ? 409 : 500, why, null,
         { phase: 'new-session', code: dup ? 'SESSION_DUPLICATE' : 'NEW_SESSION_FAILED' });
     }
+    // Il pane del SUPERVISORE si marca ORA, sul pane che esegue cell-exec: e'
+    // l'identita' stabile della cella viva. Il server cerca questo marcatore
+    // (`list-panes`) perche' `#{pane_dead}` di list-sessions riguarda il pane
+    // ATTIVO — con una seconda finestra viva selezionata direbbe «vivo» anche
+    // con il supervisore morto. L'id ce l'abbiamo gia' da `-P -F` (sotto), non
+    // serve una ricerca. Best effort come le opzioni che seguono: un tmux che
+    // non accetta l'opzione non deve impedire l'avvio — la cella resta senza
+    // marcatore, e per lei il server dira' «non verificato» invece di leggere
+    // uno stato di cui non sa identificare il supervisore.
+    const idPaneLancio = /^%[0-9]+$/.test((create.stdout.trim().split('\n')[0] || '').split('\t')[2] || '')
+      ? (create.stdout.trim().split('\n')[0] || '').split('\t')[2] : '';
+    if (idPaneLancio) {
+      const marcato = await tmuxExec(tmuxBin,
+        ['set-option', '-p', '-t', idPaneLancio, NC_SUPERVISOR_OPT, '1'],
+        { env: minimalEnv(), timeoutMs: 2000 });
+      if (marcato.err) {
+        const log = typeof cfg.log === 'function' ? cfg.log : console.warn;
+        log(`fleet marcatore del pane supervisore non impostato per ${cell.id}; la cella resta non identificabile`);
+      }
+    }
     // Best effort per la sola sessione appena creata: non tocchiamo mai
     // ~/.tmux.conf, opzioni globali o sessioni preesistenti. Un tmux che non
     // accetta una delle opzioni non deve impedire l'avvio della cella.

package/lib/proxy/panel-proxy.js

@@ -219,6 +219,20 @@ function respond(res, code, body) {
   res.end(payload);
 }
 
+// Il frame NON deve finire carico-bianco su un pannello morto: il 502 qui è
+// UNA PAGINA (l'iframe spara `load` anche sulle risposte d'errore), quindi la
+// pagina dice sé stessa a chi la monta — un postMessage con la causa. Il
+// contenuto è fisso e NON sensibile (un tipo, nessun dato), quindi il
+// targetOrigin è '*': può nascere un padre di origine diversa (il frame viaggia
+// sulla porta pannello separata proprio per isolare le origini). La fiducia la
+// mette chi RICEVE: source del frame attivo + origine del frame + tipo atteso.
+function respondPaginaNonRaggiungibile(res) {
+  res.writeHead(502, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
+  res.end('<!doctype html><html><body><p>pannello non raggiungibile</p><script>('
+    + 'function(){try{window.parent.postMessage({type:"nc-panel-unreachable"},"*");}catch(_){}}'
+    + ')()</script></body></html>');
+}
+
 function createPanelProxy({ resolveCellPanel, log = () => {}, requestImpl }) {
   return async function panelProxy(req, res) {
     const parsed = splitPanelPath(req.url);
@@ -248,13 +262,13 @@ function createPanelProxy({ resolveCellPanel, log = () => {}, requestImpl }) {
       });
     } catch (_) {
       log({ event: 'panel-proxy', outcome: 'error', reason: 'request-failed', cell: parsed.cellId });
-      if (!res.headersSent) respond(res, 502, { error: 'pannello non raggiungibile' });
+      if (!res.headersSent) respondPaginaNonRaggiungibile(res);
       return;
     }
     upstream.setTimeout(PANEL_TIMEOUT_MS, () => upstream.destroy(new Error('panel timeout')));
     upstream.on('error', () => {
       log({ event: 'panel-proxy', outcome: 'error', reason: 'upstream-error', cell: parsed.cellId });
-      if (!res.headersSent) respond(res, 502, { error: 'pannello non raggiungibile' });
+      if (!res.headersSent) respondPaginaNonRaggiungibile(res);
       else res.destroy();
     });
     req.on('aborted', () => upstream.destroy());

package/lib/server.js

@@ -8,7 +8,8 @@ const express = require('express');
 const { WebSocketServer } = require('ws');
 const { defaults, loadConfig, assertLoopback, configJsonPath } = require('./config.js');
 const { writeConfigAtomic } = require('./cli/init.js');
-const { listSessions, attachedClients, setSessionVisibility } = require('./tmux/list.js');
+const { listSessions, listPanes, attachedClients, setSessionVisibility } = require('./tmux/list.js');
+const { statiSupervisore: statiSupervisoreDi, senzaSupervisore } = require('./tmux/supervisor-pane.js');
 const { runAction, pasteToSession, submitToSession } = require('./tmux/actions.js');
 const { createSession, killSession, isProtectedSession } = require('./tmux/lifecycle.js');
 const { createPreviewSampler } = require('./tmux/preview.js');
@@ -20,7 +21,7 @@ const { requireToken, bearerFrom } = require('./auth/middleware.js');
 const { filesRoutes } = require('./files/routes.js');
 const { createOutboxWatcher } = require('./files/watcher.js');
 const { leggiTelemetria } = require('./files/telemetry.js');
-const { leggiAttivita } = require('./files/activity.js');
+const { leggiAttivita, leggiGenerazione } = require('./files/activity.js');
 const VERSION = require('../package.json').version;
 const { transcribe } = require('./voice/transcribe.js');
 const { selectProvider } = require('./fleet/provider.js');
@@ -976,6 +977,10 @@ function createServer(opts = {}) {
   api.get('/sessions', async (_req, res) => {
     try {
       const sessions = await listSessions(cfg.tmuxBin);
+      // UNA chiamata per giro per sapere chi ha ancora il suo supervisore.
+      const statiSupervisore = sessions.length
+        ? statiSupervisoreDi(await listPanes(cfg.tmuxBin))
+        : new Map();
       const sum = watcher.getSummary();
       const enriched = await Promise.all(sessions.map(async (s) => {
         const sample = await previews.getState(s.name);
@@ -983,6 +988,7 @@ function createServer(opts = {}) {
         // the capture fallback. This prevents a quoted "• Working (...)" line
         // inside another agent's transcript from becoming a false positive.
         const piTitle = /^(?:π|pi)(?:\s+-|$)/iu.test(s.paneTitle);
+        const statoDelSupervisore = statiSupervisore.get(s.name) || 'assente';
         const working = s.working === true || (piTitle && sample?.working === true);
         return {
           ...s,
@@ -999,7 +1005,28 @@ function createServer(opts = {}) {
           // nessun evento entro la finestra, oppure una cella che non ha questo
           // canale (codex-vl, pi, shell). La UI non deve dedurre «ferma» da un
           // silenzio: e' esattamente l'errore che il titolo del pane fa oggi.
-          attivita: leggiAttivita(cfg.filesRoot, s.name),
+          //
+          // E SI LEGGE SOLO SE IL SUPERVISORE DELLA CELLA ESISTE ANCORA. Con
+          // `remain-on-exit` (runtime.js) la sessione sopravvive al suo
+          // processo: un supervisore ucciso (SIGKILL, OOM) lascia la sessione
+          // «attiva», e lo `Stop` con `exit:1` scritto prima resterebbe «ferma»
+          // per sempre — mentre non c'e' nessun client a cui quello stato si
+          // riferisca. La verita' e' il pane che esegue cell-exec, marcato al
+          // lancio: `#{pane_dead}` della sessione riguarda il pane ATTIVO, e con
+          // una seconda finestra viva selezionata direbbe «vivo» a supervisore
+          // morto (misurato). La decisione completa sta in
+          // `lib/tmux/supervisor-pane.js`: qui si passa lo stato del pane e — per
+          // il solo caso «nessun marcatore» — il segno `exit:1` del file, che
+          // distingue un lancio nuovo con marcatura fallita (non si legge: il
+          // suo `Stop` non scadrebbe) da un lancio VECCHIO (si legge, e il
+          // lettore fa scadere tutto a 5 minuti). E' quello che evita di
+          // mostrare «non verificato» su ogni cella viva di ogni nodo appena
+          // aggiornato.
+          attivita: statoDelSupervisore === 'vivo'
+            ? leggiAttivita(cfg.filesRoot, s.name)
+            : (senzaSupervisore(statoDelSupervisore, leggiGenerazione(path.join(cfg.filesRoot, s.name)).uscitaGarantita)
+              ? null
+              : leggiAttivita(cfg.filesRoot, s.name)),
         };
       }));
       res.json({ sessions: enriched });