@mmmbuto/nexuscrew 0.9.1 → 0.9.3

package/lib/fleet/definitions.js

@@ -635,6 +635,229 @@ function parseCell(c, engineIds, engineMap = new Map(), { allowLegacyTmuxNames =
   return out;
 }
 
+
+// ---------------------------------------------------------------------------
+// aggiornaDefinizioni(p, trasforma, opts) -> definizioni risultanti
+//
+// Leggi-modifica-scrivi SOTTO LOCK. `atomicWrite` garantisce che il file non
+// resti a meta' — non che nessuno lo abbia cambiato mentre lo tenevi in mano:
+// sono due proprieta' diverse, e la prima non implica la seconda. Un audit ha
+// riprodotto la perdita su SETTE percorsi diversi (i backfill di avvio, la
+// riparazione desktop e la persistenza della migrazione): ognuno salvava,
+// osservava sul disco il valore scritto da un altro, e lo perdeva scrivendo un
+// draft costruito su uno stato precedente.
+//
+// `trasforma(defs)` riceve lo stato letto DENTRO il lock e restituisce il draft
+// da scrivere, oppure `null` per non scrivere nulla. Se il lock non si ottiene
+// entro il tempo concesso si RINUNCIA: per una migrazione opportunistica non
+// fare nulla costa un altro avvio, sovrascrivere costa un dato.
+// ---------------------------------------------------------------------------
+const LOCK_ATTESA_MS = 2000;   // quanto si insiste prima di rinunciare
+const LOCK_STALE_MS = 30000;   // oltre questa eta' il lock e' di un morto
+
+function percorsoLock(p) { return `${p}.lock`; }
+
+// La NASCITA di un processo (starttime, /proc/<pid>/stat campo 22: tick di
+// uptime a cui il processo e' partito). Un pid e' un numero RICICLATO: chiedere
+// «esiste il processo 4711?» non e' la domanda «e' ancora vivo QUEL processo
+// che prese il lock?» — se il proprietario muore e il sistema riassegna il
+// numero, kill(pid, 0) risponde «vivo» per sempre e ogni scrittura rinuncia in
+// silenzio. Due processi con lo stesso numero nascono in istanti diversi: la
+// coppia pid+nascita e' l'identita'. Null quando non e' leggibile (pid assente,
+// o sistema senza /proc: e' il modo in cui il codice vede macOS).
+function leggiStarttimeProc(pid) {
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+    // il campo comm (2) puo' contenere spazi e parentesi: si salta tutto
+    // fino all'ultima ')', i campi seguenti partono dal 3°. Il campo 22
+    // (starttime) e' quindi l'indice 19 della coda.
+    const coda = stat.slice(stat.lastIndexOf(')') + 2);
+    const st = Number(coda.split(' ')[19]);
+    return Number.isFinite(st) ? st : null;
+  } catch (_) { return null; }
+}
+
+function prendiLock(p) {
+  const lock = percorsoLock(p);
+  // La directory puo' non esistere ancora: alla prima creazione delle
+  // definizioni non c'e' nulla. Prima era `atomicWrite` a crearla, e spostando
+  // la scrittura sotto lock quell'effetto si era perso — il lock non si apriva,
+  // si rinunciava, e la creazione falliva in silenzio.
+  try { fs.mkdirSync(path.dirname(p), { recursive: true }); } catch (_) { return null; }
+  const scadenza = Date.now() + LOCK_ATTESA_MS;
+  // Il token identifica QUESTA presa, non il processo: due prese successive
+  // dello stesso pid restano distinguibili, e al rilascio si puo' verificare di
+  // stare togliendo il proprio lock e non quello di chi e' subentrato.
+  // Il TERZO campo e' la nascita di chi prende: e' quello che rende
+  // confrontabile «e' ancora vivo QUEL processo» (pid da solo non basta: e'
+  // un numero riciclato). Senza /proc non c'e' nascita da attestare e il
+  // token resta a due campi — vedere proprietarioVivo per le conseguenze.
+  const nascita = leggiStarttimeProc(process.pid);
+  const token = nascita === null
+    ? `${process.pid}:${crypto.randomBytes(8).toString('hex')}`
+    : `${process.pid}:${crypto.randomBytes(8).toString('hex')}:${nascita}`;
+  for (;;) {
+    try {
+      // 'wx' fallisce se il file esiste: e' l'esclusione mutua, in una syscall.
+      const fd = fs.openSync(lock, 'wx', 0o600);
+      try {
+        fs.writeFileSync(fd, `${token}\n`);
+      } catch (_) {
+        // Il contenuto NON e' informativo: e' l'unica cosa che rende il lock
+        // attribuibile. Se non si puo' scrivere (disco pieno, quota, errore
+        // transitorio) il lock resterebbe VUOTO: nessun pid da interrogare, e
+        // dopo 30s chiunque lo esproprierebbe mentre il presunto titolare —
+        // vivo e al lavoro, convinto di essere protetto — scrive senza mutua
+        // esclusione. Nessuna titolarita' senza token: si chiude il fd e si
+        // toglie il file APPENA CREATO (e' nostro per costruzione: 'wx'), poi
+        // si rinuncia. Un lock vuoto sul disco puo' restare solo dal relitto
+        // di un crash fra open e write — processo che non esiste piu':
+        // recuperarlo dopo la scadenza e' giusto (semantica pinnata da
+        // fleet-lock-edges «illeggibile = abbandonato»).
+        try { fs.closeSync(fd); } catch (_) { /* gia' chiuso */ }
+        try { fs.unlinkSync(lock); } catch (_) { /* gia' rimosso */ }
+        return null;
+      }
+      return { fd, token };
+    } catch (e) {
+      if (e.code !== 'EEXIST') return null; // dir non scrivibile o simili: si rinuncia
+      // Un lock abbandonato non deve bloccare per sempre — ma l'eta' da sola non
+      // dice che il proprietario sia morto: un lavoro lento e' vivo e sta usando
+      // il lock. Espropriarlo per anzianita' ROMPE la mutua esclusione, cioe'
+      // riapre esattamente il difetto che il lock chiude. Si guarda prima se il
+      // processo esiste ancora.
+      try {
+        const eta = Date.now() - fs.statSync(lock).mtimeMs;
+        if (eta > LOCK_STALE_MS && !proprietarioVivo(lock)) { fs.unlinkSync(lock); continue; }
+      } catch (_) { /* sparito nel frattempo: si riprova */ }
+      if (Date.now() >= scadenza) return null;
+      if (!dormiSincrono(25)) return null; // non si sa attendere: meglio rinunciare che consumare CPU
+    }
+  }
+}
+
+// `kill(pid, 0)` non invia nulla: chiede al kernel se quel NUMERO esiste.
+// EPERM significa che esiste e non e' nostro — vivo comunque.
+function vivoPerKernel(pid) {
+  try { process.kill(pid, 0); return true; }
+  catch (e) { return e && e.code === 'EPERM'; }
+}
+
+// Il proprietario del lock e' vivo SOLO se e' ancora vivo QUEL processo.
+// Tre vie, in ordine di forza:
+//   1. token con nascita (pid:hex:starttime) e /proc leggibile: identita'
+//      CONFRONTABILE. vivo <=> il numero esiste ed e' nato nello stesso
+//      istante che il token attesta. Un numero riassegnato nasce in un
+//      istante diverso: il proprietario e' morto anche se il pid esiste.
+//   2. token con nascita ma /proc non leggibile (neanche per QUESTO
+//      processo: e' come il codice vede un sistema senza /proc, es. macOS):
+//      criterio NON CALCOLABILE — nel dubbio il lock resta, decide il kernel.
+//   3. token vecchio (pid:hex, nascita assente — lock scritti prima della
+//      correzione): identita' non confrontabile — nel dubbio il lock resta,
+//      decide il kernel. E' il buco dichiarato che resta per i lock gia'
+//      sul disco: costa una scrittura rimandata, mai un vivo espropriato.
+// L'asimmetria e' la lezione della cura precedente: dichiarare morto un vivo
+// ROMPE la mutua esclusione; dichiarare vivo un morto rimanda una scrittura.
+// `lettore` e' iniettabile per provare la via 2 dove /proc esiste eccome.
+function proprietarioVivo(lock, lettore = leggiStarttimeProc) {
+  let pid;
+  let nascita = null;
+  try {
+    const parti = String(fs.readFileSync(lock, 'utf8')).trim().split(':');
+    pid = Number.parseInt(parti[0], 10);
+    if (parti.length >= 3) {
+      const st = Number(parti[2]);
+      if (Number.isFinite(st)) nascita = st;
+    }
+  } catch (_) { return false; }
+  if (!Number.isInteger(pid) || pid <= 0) return false; // illeggibile: trattato come abbandonato
+  if (nascita !== null) {
+    // /proc leggibile per QUESTO processo? Se no, il criterio non e'
+    // calcolabile su questo sistema (non «il pid e' morto»: NON LO SO).
+    if (lettore(process.pid) === null) return vivoPerKernel(pid);
+    const sua = lettore(pid);
+    if (sua === null) return false; // /proc c'e' e quel pid non esiste: morto
+    return sua === nascita; // stesso numero, stessa nascita: e' ancora LUI
+  }
+  return vivoPerKernel(pid);
+}
+
+// Attesa sincrona senza spawnare nulla: questo percorso e' sincrono per
+// costruzione (gira nel bootstrap), quindi non c'e' un event loop da cedere.
+function dormiSincrono(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    return true;
+  } catch (_) {
+    // Senza SharedArrayBuffer non si puo' attendere senza girare a vuoto: il
+    // ciclo brucerebbe CPU per tutto il tempo concesso. Meglio dirlo al
+    // chiamante e rinunciare subito — l'aggiornamento e' opportunistico.
+    return false;
+  }
+}
+
+function rilasciaLock(p, presa) {
+  try { fs.closeSync(presa.fd); } catch (_) { /* gia' chiuso */ }
+  // Si toglie SOLO il proprio lock. Un unlink cieco, dopo che qualcun altro ha
+  // preso il lock, cancellerebbe il suo — e da li' in avanti nessuno sarebbe
+  // piu' protetto, a cascata.
+  try {
+    const dentro = String(fs.readFileSync(percorsoLock(p), 'utf8')).trim();
+    if (dentro !== presa.token) return; // subentrato qualcun altro: non e' roba nostra
+  } catch (_) { return; }
+  try { fs.unlinkSync(percorsoLock(p)); } catch (_) { /* gia' rimosso */ }
+}
+
+function aggiornaDefinizioni(p, trasforma, opts = {}) {
+  const log = typeof opts.log === 'function' ? opts.log : () => {};
+  // Di default NON si propaga: questi aggiornamenti girano nel bootstrap, dove
+  // un'eccezione non degrada — impedisce l'avvio. Prima della conversione ogni
+  // backfill aveva il suo `try/catch` attorno alla scrittura, e quella rete va
+  // conservata. Chi invece serve una richiesta dell'utente passa
+  // `propaga: true`, perche' li' un errore va riportato a chi ha chiesto.
+  const propaga = opts.propaga === true;
+  const presa = prendiLock(p);
+  if (presa === null) {
+    log('definizioni fleet: lock non ottenuto, aggiornamento rimandato');
+    // Rinunciare NON e' come non aver avuto nulla da fare, e chi propaga deve
+    // poterlo distinguere: restituendo lo stato riletto — che e' truthy — una
+    // mutazione chiesta dall'utente rispondeva OK senza aver scritto niente.
+    // L'errore ha un `code` perche' il chiamante possa dire la cosa giusta
+    // invece di confonderlo con «definizioni non valide».
+    if (propaga) {
+      const e = new Error('definizioni fleet occupate: aggiornamento non eseguito');
+      e.code = 'FLEET_LOCK_BUSY';
+      throw e;
+    }
+    return loadDefinitions(p);
+  }
+  try {
+    // La lettura sta DENTRO il lock: e' l'unico modo perche' il draft nasca da
+    // uno stato che nessun altro puo' cambiare prima che venga scritto.
+    const dentro = loadDefinitions(p);
+    if (!dentro) {
+      // `loadDefinitions` restituisce null sia per «non c'e'» sia per «c'e' ma
+      // non si legge», e la differenza qui e' tutto: creare le definizioni di
+      // default sopra un file esistente ma illeggibile CANCELLA una
+      // configurazione. Si guarda il filesystem, non il valore di ritorno.
+      let assente = false;
+      try { fs.lstatSync(p); } catch (e) { assente = e.code === 'ENOENT'; }
+      if (!assente || typeof opts.seMancante !== 'function') return null;
+      const iniziale = opts.seMancante();
+      return iniziale ? atomicWrite(p, iniziale) : null;
+    }
+    const draft = trasforma(dentro);
+    if (!draft) return dentro; // niente da fare: si esce senza scrivere
+    return atomicWrite(p, draft);
+  } catch (e) {
+    if (propaga) throw e;
+    log(`definizioni fleet: aggiornamento non riuscito (${e && e.code ? e.code : e && e.message ? e.message : 'errore'})`);
+    return loadDefinitions(p);
+  } finally {
+    rilasciaLock(p, presa);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // validateCommandTrust(command) -> {ok, reason}
 // Path assoluto, regular file, owner-executable, NON symlink (lstat), NON
@@ -823,6 +1046,9 @@ const CAPS = {
 module.exports = {
   parseDefinitions,
   validateCommandTrust,
+  aggiornaDefinizioni,
+  proprietarioVivo,
+  leggiStarttimeProc,
   validPanelUrl, PANELURL_LOOPBACK_HOSTS,
   resolveCwd,
   normalizeCwdRel,

package/lib/live-host/bridge.js

@@ -17,10 +17,20 @@
 //     fallimento, la risposta è `none` col motivo: la Live parte senza
 //     puntamento, comportamento standard. Un `none` non è un errore HTTP.
 //   - MC2: il prompt per-cella (LIVE_PROMPT.md accanto ai canonici della
-//     cella) viaggia su developerInstructions di thread/start — quindi
-//     SOSTITUISCE l'iniezione globale per quella Live (rev4 LC2 emendata da
-//     rev5 MC2). Se manca non si passa nulla e l'app-server applica la sua
-//     catena globale/default: nessun gradino è un errore (MC2.4).
+//     cella) viaggia su developerInstructions di thread/start e SOSTITUISCE
+//     le developer instructions della config per quella Live (rev4 LC2
+//     emendata da rev5 MC2). La riga che decide è in codex-rs
+//     core/src/config/mod.rs: `developer_instructions.or(cfg.developer_
+//     instructions)` — l'override Some scarta il valore di config. R2
+//     (2026-08-16, verso corretto dopo audit pre-release): l'identità della
+//     cella designata viaggia SEMPRE come intestazione anteposta al campo,
+//     anche senza prompt. Il campo NON è additivo: una cella senza
+//     LIVE_PROMPT.md, che prima non passava nulla e riceveva le developer
+//     instructions della config, ora passa la sola intestazione e QUELLE
+//     NON le riceve più. Restano fuori da questa sostituzione AGENTS.md e
+//     il world state (fragment user, canale separato) e il prompt base.
+//     La via designata per le istruzioni di lavoro della Live è il
+//     LIVE_PROMPT.md della cella: viaggia nello stesso campo.
 //   - MC3: il ponte crea le proprie conversazioni con thread/start e non
 //     tocca MAI la thread di una TUI — né turn/start né thread/resume: chi
 //     guarda i metodi visti dal server deve vedere solo initialize,
@@ -62,21 +72,41 @@ const CLIENT_NAME = 'nexuscrew-live-bridge';
 const ORPHAN_GRACE_MS = 1500;
 
 // —— Prompt per-cella (rev4 LC2, nome fisso confermato da Dev 2026-08-15) ——
-// Collocazione: filesRoot/cloud-<Cella>/LIVE_PROMPT.md. Tre esiti DISTINTI,
-// perché «file non c'è» e «c'è ma non si può leggere» portano chi indaga in
-// posti diversi:
-//   applied:true                  → il testo va su developerInstructions
-//   applied:false, reason missing → ENOENT: assenza legittima (LC2.3), si
-//                                   procede senza, l'app-server applica il
-//                                   proprio gradino globale
+// Collocazione: filesRoot/<tmuxSession>/LIVE_PROMPT.md — la sessione tmux
+// ESATTA che il roster dichiara per la cella designata, la stessa fonte gia'
+// usata per l'intestazione R2 (identityHeader). NON un prefisso ricostruito a
+// mano: fino al 2026-08-16 questa funzione anteponeva 'cloud-' come default
+// universale quando il cellId non ce l'aveva gia' — su un device che chiama
+// le proprie sessioni con un prefisso diverso il file non veniva MAI trovato,
+// e l'esito era 'missing' ("assenza legittima"): il bug si mascherava
+// esattamente nel ramo che avrebbe dovuto segnalarlo. Bug trovato scrivendo
+// docs/LIVE_PROMPT.md, corretto qui.
+//
+// Quattro esiti DISTINTI, perché «non so nemmeno dove cercare», «ho cercato
+// e non c'è» e «c'è ma non si può leggere» portano chi indaga in posti
+// diversi:
+//   applied:true                        → il testo va su developerInstructions
+//   applied:false, reason session-unknown → il roster non dichiara la sessione
+//                                   tmux per questa cella: NESSUN path viene
+//                                   costruito (mai un prefisso indovinato),
+//                                   quindi non si tenta nemmeno la lettura
+//   applied:false, reason missing       → ENOENT sul path dichiarato: assenza
+//                                   legittima (LC2.3), si procede senza
+//                                   PROMPT (R2: l'intestazione identità
+//                                   viaggia comunque). ATTENZIONE: il campo
+//                                   developerInstructions viene comunque
+//                                   inviato per via dell'intestazione, e il
+//                                   consumer lo SOSTITUISCE alla propria
+//                                   configurazione invece di sommarlo — chi
+//                                   non ha prompt per-cella non riceve le
+//                                   developer instructions globali che
+//                                   riceveva prima (vedi MC2, verificato
+//                                   sulla riga che decide)
 //   applied:false, reason unreadable|empty → presente ma inutilizzabile: va
 //                                   dichiarato, mai silenziato
-function readCellPrompt(filesRoot, cellId) {
-  // Il canonico per-cella vive in filesRoot/cloud-<Cella>/. L'id cella arriva
-  // sia senza prefisso (fleet id) sia con (nome sessione tmux): si normalizza
-  // qui, una volta sola.
-  const dirName = String(cellId).startsWith('cloud-') ? String(cellId) : `cloud-${cellId}`;
-  const file = path.join(filesRoot, dirName, 'LIVE_PROMPT.md');
+function readCellPrompt(filesRoot, tmuxSession) {
+  if (typeof tmuxSession !== 'string' || !tmuxSession) return { applied: false, reason: 'session-unknown' };
+  const file = path.join(filesRoot, tmuxSession, 'LIVE_PROMPT.md');
   let raw;
   try {
     raw = fs.readFileSync(file, 'utf8');
@@ -89,6 +119,22 @@ function readCellPrompt(filesRoot, cellId) {
   return { applied: true, source: 'LIVE_PROMPT.md', text };
 }
 
+// —— Identità della Live (R2, 2026-08-16): la porta il ponte, non il prompt ——
+// Il ponte ha la designazione IN MANO (MC3.4: è la sua condizione di
+// funzionamento) e un prompt può legittimamente mancare (MC2.4): se
+// l'identità dipendesse dal prompt, l'assenza del prompt diventerebbe assenza
+// di identità — è esattamente il difetto visto sul campo (la voce andava a
+// leggere tmux per capire dove si trovava).
+//
+// Il fatto, niente di più: quale cella (id Fleet) e, se il roster la dichiara,
+// la sessione tmux esatta — quella con cui la voce raggiunge i canonici della
+// cella in ~/NexusFiles/<tmuxSession>/. Non un'instruzione di lavoro: quelle
+// vivono nel prompt per-cella, che questa intestazione PRECEDE sempre.
+function identityHeader(cellId, tmuxSession) {
+  const sessione = tmuxSession ? ` (sessione tmux ${tmuxSession})` : '';
+  return `Live NexusCrew agganciata alla cella ${cellId}${sessione}.`;
+}
+
 // —— Client on-demand del socket di controllo (sezione protocollo sopra) ——
 // Una sola richiesta per connessione: aperta, handshake, thread/start, chiusa.
 // Le eventuali notifiche broadcast che arrivano nel frattempo vengono ignorate
@@ -308,7 +354,9 @@ function createLiveBridge({
     // qualunque altro engine la Live lavora ATTRAVERSO la cella e il ponte non
     // ha nulla da creare qui.
     const engine = String(cell.engine || '');
-    const prompt = readCellPrompt(root, snap.hostCell);
+    // Stessa fonte dell'intestazione qui sotto: la sessione tmux che il
+    // roster dichiara, mai il cellId ricostruito con un prefisso indovinato.
+    const prompt = readCellPrompt(root, cell.tmuxSession);
 
     if (!engine.startsWith('codex-vl')) {
       const out = {
@@ -322,12 +370,21 @@ function createLiveBridge({
       return out;
     }
 
+    // R2: l'identità viaggia SEMPRE, anteposta al prompt quando c'è. Il campo
+    // non è mai più assente: senza LIVE_PROMPT.md porta la sola intestazione
+    // — e poiché il campo SOSTITUISCE le developer instructions della config
+    // (vedi MC2: la .or() in config/mod.rs), quella cella non le riceve più.
+    const intestazione = identityHeader(snap.hostCell, cell.tmuxSession);
+    const developerInstructions = prompt.applied
+      ? `${intestazione}\n\n${prompt.text}`
+      : intestazione;
+
     let started;
     try {
       started = await startThreadOnControlSocket({
         socketPath: cfg.liveBridgeSocketPath,
         cwd: cell.cwd,
-        developerInstructions: prompt.applied ? prompt.text : undefined,
+        developerInstructions,
         timeoutMs: cfg.liveBridgeTimeoutMs,
         WebSocket,
         log,
@@ -347,12 +404,15 @@ function createLiveBridge({
       at: now(),
     };
     // LC1.4: il puntamento è visibile lato nostro — log con cella, thread e
-    // prompt applicato. È il "dirottamento dichiarato" del contratto.
-    log(`[live-bridge] Live puntata su ${snap.hostCell}: thread ${started.threadId} (cwd ${started.cwd}, prompt ${prompt.applied ? 'per-cella applicato (sostituisce il globale)' : `non applicato (${promptEcho.reason})`})`);
+    // prompt applicato. È il "dirottamento dichiarato" del contratto. Il
+    // campo SOSTITUISCE le developer instructions della config (MC2, la
+    // .or() in config/mod.rs): il log lo dichiara, perché chi lo legge sappia
+    // cosa quella Live NON riceve.
+    log(`[live-bridge] Live puntata su ${snap.hostCell}: thread ${started.threadId} (cwd ${started.cwd}, identità nell'intestazione, prompt ${prompt.applied ? 'per-cella applicato' : `non applicato (${promptEcho.reason})`}, sostituisce le developer instructions di config)`);
     return out;
   }
 
-  return { resolveForLive, readCellPrompt: (cellId) => { const { text, ...rest } = readCellPrompt(root, cellId); return rest; } };
+  return { resolveForLive, readCellPrompt: (tmuxSession) => { const { text, ...rest } = readCellPrompt(root, tmuxSession); return rest; } };
 }
 
 let cachedVersion = null;

package/lib/proxy/panel-proxy.js

@@ -89,9 +89,23 @@ function stripLocalTokenQuery(search) {
 // sessione del control plane, esattamente cio' che l'Authorization rimossa
 // doveva impedire. E `x-forwarded-*` da un client sono valori che un pannello
 // potrebbe credere veri. Rilievo di un audit indipendente.
-function isStrippedRequestHeader(key) {
+function isStrippedRequestHeader(key, value) {
   if (HOP_BY_HOP.has(key)) return true;
-  if (key === 'authorization' || key === 'cookie' || key === 'host') return true;
+  if (key === 'cookie' || key === 'host') return true;
+  // `authorization` NON si strippa in blocco: lo schema dice di chi e'.
+  //
+  // `Bearer` e' il nostro token del control plane e non deve mai raggiungere il
+  // container — e' la ragione per cui questo strip esiste. Ma un pannello
+  // protetto da password risponde `401 WWW-Authenticate: Basic`, il browser
+  // chiede le credenziali all'utente e le rimanda: buttando via ANCHE quelle,
+  // il pannello ripresentava il prompt all'infinito e il login era impossibile
+  // per costruzione. Sono credenziali che l'utente ha inserito PER il pannello,
+  // in risposta a una sua richiesta: appartengono a lui.
+  //
+  // Dichiarato: se qualcuno mette una basic auth propria davanti a NexusCrew,
+  // quella credenziale raggiungerebbe il pannello. Non e' il nostro schema di
+  // autenticazione e non e' una configurazione che produciamo.
+  if (key === 'authorization') return !credenzialeDelPannello(value);
   // `referer` porterebbe il ticket d'ingresso (viaggiava in query sulla prima
   // richiesta dell'iframe) fino al pannello: al container non deve arrivare
   // NESSUNA credenziale, nemmeno di seconda mano.
@@ -101,10 +115,23 @@ function isStrippedRequestHeader(key) {
   return false;
 }
 
+// ELENCO CHIUSO di cio' che si inoltra, non di cio' che si toglie: un valore
+// sconosciuto non deve poter passare per omissione. Sono gli schemi con cui un
+// server web chiede le credenziali al browser — quelli che l'utente puo' aver
+// inserito in risposta a un `401` del pannello. Tutto il resto, `Bearer`
+// compreso, resta di qua.
+const SCHEMI_DEL_PANNELLO = /^(basic|digest|ntlm|negotiate)\s/i;
+
+function credenzialeDelPannello(value) {
+  const primo = Array.isArray(value) ? value[0] : value;
+  if (typeof primo !== 'string') return false;
+  return SCHEMI_DEL_PANNELLO.test(primo.trim());
+}
+
 function forwardHeaders(headers, targetHost) {
   const out = {};
   for (const [k, v] of Object.entries(headers || {})) {
-    if (isStrippedRequestHeader(k.toLowerCase())) continue;
+    if (isStrippedRequestHeader(k.toLowerCase(), v)) continue;
     out[k] = v;
   }
   // L'host deve essere quello della destinazione: un pannello che genera

package/lib/server.js

@@ -19,6 +19,7 @@ const { loadOrCreateToken, verify } = require('./auth/token.js');
 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 VERSION = require('../package.json').version;
 const { transcribe } = require('./voice/transcribe.js');
 const { selectProvider } = require('./fleet/provider.js');
@@ -753,6 +754,10 @@ function createServer(opts = {}) {
           status: working ? (s.status || sample?.status || '') : '',
           outbox: sum[s.name] || { count: 0, latest: 0 },
           preview: sample?.preview ?? null,
+          // Contesto libero e tier usati, dove la cella li pubblica (celle
+          // Claude via statusline). Null per tutte le altre — assenza
+          // legittima, non un trattino: la riga resta com'era.
+          telemetry: leggiTelemetria(cfg.filesRoot, s.name),
         };
       }));
       res.json({ sessions: enriched });

package/package.json

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

package/skills/live/SKILL.md

@@ -83,6 +83,14 @@ owning node, not a retry from the requester.
   with nothing designated still answers `GET` with `hostCell: null` — a valid
   state, distinct from "not permitted to ask".
 
+## The per-cell voice prompt
+
+Once a session lands on a host cell, a native Live (engine `codex-vl*`)
+always sends `thread/start` an identity header naming the designated cell
+and its exact tmux session, and appends a per-cell prompt file's text after
+it when one exists. See [The Live per-cell prompt](../../docs/LIVE_PROMPT.md)
+for where the file goes and the ready-to-copy IT/EN/ES templates.
+
 ## Dependencies
 
 **Bundled:** this is a NexusCrew core feature. No external MCP companion or