@mmmbuto/nexuscrew 0.9.62 → 0.9.64

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-Cq8wINIe.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-fCIoVxeq.css">
+  <script type="module" crossorigin src="/assets/index-oUd5O8W8.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-BC6vO7Zd.css">
 </head>
 <body>
   <div id="root"></div>

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.9.62"}
+{"version":"0.9.64"}

package/lib/cells/routes.js

@@ -4,6 +4,7 @@ const express = require('express');
 const { isValidSession } = require('../files/store.js');
 const { submitTextOk } = require('../tmux/actions.js');
 const { createIdentityBindingGuard } = require('../identity/binding-guard.js');
+const { isReservedLiveName } = require('../live-host/reserved.js');
 
 const CELL_ID_RE = /^[A-Za-z0-9._-]{1,32}$/;
 const CELL_LABEL_MAX = 64;
@@ -29,6 +30,7 @@ function publicCells(status, instanceId, now = Date.now()) {
   const cells = [];
   for (const raw of status.cells) {
     if (!raw || !CELL_ID_RE.test(String(raw.cell || ''))
+      || isReservedLiveName(raw.cell)
       || !isValidSession(raw.tmuxSession) || seen.has(raw.cell)) continue;
     seen.add(raw.cell);
     // Un `tmux:false` esplicito prevale su active:true: la directory globale non
@@ -69,7 +71,15 @@ function validIdentity(value) {
     && isValidSession(value.tmuxSession);
 }
 
-function cellsRoutes({ fleetP, instanceId, submit, readonly = () => false, now = () => Date.now(), diagnostics = null, identityMode = 'legacy' }) {
+const LIVE_HEADER = 'x-nexuscrew-live-thread';
+
+// `liveEntry({ instanceId, now })` -> the Live directory entry or null, and
+// `liveAttest.verify({ ref, fromCell })` -> { ok, hostCell } are optional seams:
+// without them the routes behave as before.
+function cellsRoutes({
+  fleetP, instanceId, submit, readonly = () => false, now = () => Date.now(), diagnostics = null,
+  identityMode = 'legacy', liveEntry = null, liveAttest = null,
+}) {
   const bindingGuard = createIdentityBindingGuard({
     fleetP, instanceId, now,
     sharedRequired: identityMode === 'authority',
@@ -98,11 +108,16 @@ function cellsRoutes({ fleetP, instanceId, submit, readonly = () => false, now =
     try {
       const nodeId = instanceId();
       const st = await status();
+      // The Live is its own entry, never a cell: a failure here must not take
+      // the directory down, it only means the Live is not shown.
+      const live = liveEntry && NODE_ID_RE.test(String(nodeId || ''))
+        ? await Promise.resolve(liveEntry({ instanceId: nodeId, now })).catch(() => null) : null;
+      const cells = publicCells(st, nodeId, now());
       res.json({
         instanceId: NODE_ID_RE.test(String(nodeId || '')) ? nodeId : null,
         available: st.available === true,
         at: now(),
-        cells: publicCells(st, nodeId, now()),
+        cells: live ? [...cells, live] : cells,
       });
     } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
   });
@@ -133,6 +148,11 @@ function cellsRoutes({ fleetP, instanceId, submit, readonly = () => false, now =
       || !submitTextOk(body.message)) {
       return reject(400, 'messaggio cella non valido');
     }
+    // `Live` names the Live, which has no tmux session to paste into: never
+    // fall back to a cell of the same name or to its host.
+    if (isReservedLiveName(body.to.cell)) {
+      return reject(409, 'live-not-addressable: la Live non riceve messaggi da qui; nessuna consegna');
+    }
     const localId = instanceId();
     if (!NODE_ID_RE.test(String(localId || '')) || body.to.instanceId !== localId) {
       return reject(409, 'destinazione non appartiene a questo nodo');
@@ -165,7 +185,21 @@ function cellsRoutes({ fleetP, instanceId, submit, readonly = () => false, now =
         && cell.tmuxSession === body.to.tmuxSession);
       if (!target) return reject(404, 'cella destinataria sconosciuta');
       if (!target.canReceive) return reject(409, 'cella destinataria non attiva');
-      const label = `${body.from.cell}@${body.from.instanceId.slice(0, 8)}`;
+      let label = `${body.from.cell}@${body.from.instanceId.slice(0, 8)}`;
+      // The Live label is earned, not declared: only a local sender whose
+      // declared reference is registered, belongs to this host cell and has a
+      // live thread. Anything else travels as a plain cell message.
+      if (liveAttest && !visited.length) {
+        const rawRef = req.headers[LIVE_HEADER];
+        if (rawRef !== undefined) {
+          const verdict = await Promise.resolve(liveAttest.verify({
+            ref: Array.isArray(rawRef) ? rawRef[0] : rawRef, fromCell: body.from.cell,
+          })).catch(() => ({ ok: false }));
+          if (verdict && verdict.ok === true) {
+            label = `Live(via ${body.from.cell})@${body.from.instanceId.slice(0, 8)}`;
+          }
+        }
+      }
       // End on printable text even when the source message ends in a newline:
       // Pi may auto-submit a bracketed paste that ends with LF. NexusCrew owns
       // the single explicit Enter used by the transport.

package/lib/cli/commands.js

@@ -1287,7 +1287,7 @@ async function dispatchNodes(rest, flags, opts = {}) {
       : String(flags.selected).split(',').map((value) => value.trim()).filter(Boolean);
     return { code: nodesCmds.nodesEdit({ ...opts, log, ref, patch: { visibility, selected } }).code };
   }
-  // Scope celle (NC-E): quali celle di QUESTO nodo il peer puo' vedere.
+  // Scope celle: quali celle di QUESTO nodo il peer puo' vedere.
   // Diverso da `visibility`, che governa il transito e non l'accesso.
   if (sub === 'cells') {
     const arg = rest[3];

package/lib/config.js

@@ -85,7 +85,7 @@ function baseDefaults() {
     // con `nexuscrew autoupdate on`, e resta spento finche' non lo si accende.
     autoUpdate: false,
     sessionPresets: {},
-    // Ponte Live (fetta 3, rev5): isolabile — a false il ponte non si
+    // Ponte Live (fetta 3): isolabile — a false il ponte non si
     // connette mai e ogni avvio di Live resta sul comportamento standard.
     liveBridgeEnabled: true,
     // Socket di controllo dell'app-server (misurato 2026-08-15:

package/lib/fleet/builtin.js

@@ -44,6 +44,7 @@ const {
 const { probeModel, probeCustomEndpoint } = require('./model-probe.js');
 const { sharedProbe: defaultEndpointProbe } = require('./endpoint-probe.js');
 const { validEnvKey } = require('./env-key.js');
+const { isReservedLiveName } = require('../live-host/reserved.js');
 const { setCredential, removeCredential } = require('./credentials.js');
 const { createLaunchBroker } = require('./launch-broker.js');
 const { createLeaseManager } = require('./cell-lease-server.js');
@@ -1057,6 +1058,7 @@ async function createBuiltinFleet(cfg = {}) {
   async function defineCell(def) {
     if (readonly()) throw httpError(403, 'READONLY: define-cell bloccato');
     if (!def || typeof def !== 'object' || Array.isArray(def)) throw httpError(400, 'definizione cell mancante');
+    if (isReservedLiveName(def.id)) throw httpError(400, 'id riservato: Live indica la Live, non una cella');
     if (def.id != null && findCell(reloadDefs(), def.id)) throw httpError(400, `cell esiste già: ${def.id}`);
     // cwd portabile fail-closed: risolve cwd/cwdRel in coppia coerente PRIMA di
     // scrivere (nessuna scrittura parziale su input non portabile).
@@ -1338,6 +1340,7 @@ async function createBuiltinFleet(cfg = {}) {
     }
     let id = typeof b.id === 'string' && b.id.trim() ? b.id.trim() : deriveCellId(tmuxSession, defs.cells);
     if (!CELL_ID_RE.test(id)) throw httpError(400, 'id non valido (A-Za-z0-9._- max 32)');
+    if (isReservedLiveName(id)) throw httpError(400, 'id riservato: Live indica la Live, non una cella');
     if (defs.cells.some((c) => c.id === id)) throw httpError(409, `id cella già usato: ${id}`);
     const cwd = typeof b.cwd === 'string' && b.cwd.trim() ? b.cwd.trim() : home;
     const cellDef = { id, cwd, engine: engineId, boot: b.boot === true, tmuxSession };

package/lib/fleet/cell-lease-server.js

@@ -2,7 +2,7 @@
 
 // LeaseManager lato server per il lease del supervisore di una cella Live host.
 //
-// Fetta 2b (contratto rev1): l'autenticazione del reconnect e' un proof HMAC
+// Fetta 2b: l'autenticazione del reconnect e' un proof HMAC
 // firmato con un verifier PER-INSTALLAZIONE — la capability statica condivisa
 // Della 2a e' REVOCATA, non affiancata (/). Solo il server conosce il
 // Segreto; il supervisore presenta un proof firmato con claims ed expiry (

package/lib/fleet/cell-lease.js

@@ -2,7 +2,7 @@
 
 // Pure state transitions for the supervisor lease of a Live host cell.
 //
-// Contratto rev12 + rev13 + rev22. Il canale lease e' la connessione UDS
+// Il canale lease e' la connessione UDS
 // accettata col nonce one-shot del launch-broker che RESTA APERTA dopo il frame
 // payload; after an EOF the supervisor reconnects to a stable endpoint.
 // Here live ONLY the lease state transitions: the side

package/lib/fleet/lease-client.js

@@ -6,7 +6,7 @@
 // stays OPEN after the payload), sends refreshes every 20s (heartbeat),
 // and on EOF reconnects to the stable endpoint.
 //
-// Fetta 2b (contratto rev1, /): l'autenticazione del reconnect e' un proof
+// Fetta 2b: l'autenticazione del reconnect e' un proof
 // HMAC firmato dal server col verifier per-installazione — la capability statica
 // della 2a e' revocata. Il proof NON arriva nel payload: il server lo consegna
 // sul canale (frame lease all'attach, ack a ogni refresh) e il supervisore lo

package/lib/fleet/lease-verifier.js

@@ -1,7 +1,7 @@
 'use strict';
 
 // Verifier per-installazione e proof HMAC del lease Live (fetta 2b, contratto
-// Contract rev1: the premise and the items below.
+// The premise and the items below.
 //
 // Modello (PREMESSA): la 2a usava un segreto condiviso simmetrico — il
 // supervisore presentava la capability cosi' com'e' e il server la confrontava.

package/lib/live-host/attest.js

@@ -0,0 +1,39 @@
+'use strict';
+// lib/live-host/attest.js — verifica del riferimento Live dichiarato da un mittente.
+//
+// Il server MCP della Live dichiara il riferimento della propria thread; qui si
+// decide se quella dichiarazione regge. Regge solo se il riferimento e' nel
+// registro, appartiene alla cella ospite che sta mandando il messaggio e la
+// thread e' viva adesso. Il risultato porta un motivo nominato, ma chi lo usa
+// non rifiuta il messaggio: lo consegna senza etichetta.
+
+const { REF_RE } = require('./registry.js');
+
+const ALIVE = new Set(['present', 'active']);
+
+function createLiveAttestation({ registry, bridge }) {
+  async function verify({ ref, fromCell } = {}) {
+    if (ref === undefined || ref === null || ref === '') return { ok: false, reason: 'no-ref' };
+    if (typeof ref !== 'string' || !REF_RE.test(ref)) return { ok: false, reason: 'bad-ref' };
+    const entry = registry.findByRef(ref);
+    if (!entry) return { ok: false, reason: 'unknown-ref' };
+    if (entry.cell !== fromCell) return { ok: false, reason: 'wrong-host' };
+    // La tupla (cella, thread, riferimento) e' quella letta ADESSO: e' lei che
+    // si attesta. Lo stato si chiede per quel thread, e dopo l'attesa il
+    // registro si rilegge: se nel frattempo la Live e' stata ruotata, la
+    // risposta non vale piu' per questo riferimento.
+    const captured = { cell: entry.cell, threadId: entry.threadId };
+    let status;
+    try { status = await bridge.threadStatus(captured.cell, captured.threadId); } catch (_) { status = 'unknown'; }
+    // Un thread non vivo non da mai l'etichetta (anche se il ponte lo ha appena tolto dal registro).
+    if (!ALIVE.has(status)) return { ok: false, reason: 'thread-not-alive' };
+    const now = registry.findByRef(ref);
+    if (!now || now.cell !== captured.cell || now.threadId !== captured.threadId) {
+      return { ok: false, reason: 'ref-changed' };
+    }
+    return { ok: true, hostCell: captured.cell };
+  }
+  return { verify };
+}
+
+module.exports = { createLiveAttestation };

package/lib/live-host/bridge.js

@@ -1,5 +1,5 @@
 'use strict';
-// lib/live-host/bridge.js — the Live bridge (contract revision rev6 + rev4 LC).
+// lib/live-host/bridge.js — the Live bridge (contract revisions).
 //
 // Exposure: POST /api/live-host/bridge, mounted in routes.js. Reaching
 // /api/live-host directly stays a local-only path (LOCAL_ONLY_PREFIXES covers
@@ -28,8 +28,7 @@
 //     puntamento, comportamento standard. Un `none` non è un errore HTTP.
 // Il prompt per-cella (LIVE_PROMPT.md accanto ai canonici della
 //     cella) viaggia su developerInstructions di thread/start e SOSTITUISCE
-// Le developer instructions della config per quella Live (rev4
-// Emendata da rev5). La riga che decide è in codex-rs
+// Le developer instructions della config per quella Live. 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.
 //     (verso corretto dopo revisione pre-release): l'identità della
@@ -46,10 +45,10 @@
 //     thread/read e' separata e sola lettura: non modifica il thread ponte ne'
 //     quello della TUI. Per questo l'aggancio funziona anche su una cella che
 //     sta già processando un turno: conversazioni separate, nessuna
-// Interruzione (rev1 /rev2).
+// Interruzione.
 // La connessione al socket di controllo è ON-DEMAND (connect →
 //     handshake → thread/start → close), mai permanente: la fuga notifiche
-//     notata in rev5 riguarda i client permanenti.
+//     notata in precedenza riguarda i client permanenti.
 // Il ponte opera SOLO sulla cella designata — non accetta target
 // Dal chiamante, la designazione è la condizione.
 // Isolabile — cfg.liveBridgeEnabled=false e il ponte non si connette
@@ -66,6 +65,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const os = require('node:os');
+const crypto = require('node:crypto');
 
 // ws+unix:// è supportato nativamente da ws >= 8 (isIpcUrl): il path prima dei
 // `:` è il socket, dopo è la resource. Iniettabile per i test.
@@ -174,7 +174,7 @@ function queryThreadStatusOnControlSocket({
   });
 }
 
-// — Prompt per-cella (rev4, nome fisso confermato il 2026-08-15) ——
+// — Prompt per-cella (nome fisso, confermato il 2026-08-15) ——
 // 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 (identityHeader). NON un prefisso ricostruito a
@@ -248,7 +248,7 @@ function readCellPrompt(filesRoot, tmuxSession) {
 // Senza tmuxSession dichiarata non c'è identità possibile: il testo lo DICE,
 // non suggerisce un comando che fallirebbe comunque (e una sessione indovinata
 // sarebbe l'identità di un'altra cella).
-function identityHeader(cellId, tmuxSession) {
+function identityHeader(cellId, tmuxSession, liveRef = null) {
   if (!tmuxSession) {
     return `Live NexusCrew agganciata alla cella ${cellId}. `
       + 'Il roster non dichiara una sessione tmux per questa cella: senza sessione '
@@ -259,9 +259,10 @@ function identityHeader(cellId, tmuxSession) {
     + 'Questa Live eredita l\'ambiente del daemon, condiviso fra tutte le Live e senza identità: '
     + 'i tool NexusCrew che richiedono la sessione restano chiusi finché non li chiami con la tua. '
     + 'Per usarli avvia il server MCP NexusCrew via stdio con la sessione di questa cella '
-    + `nell'ambiente — NEXUSCREW_MCP_SESSION=${tmuxSession} nexuscrew mcp — e parlagli `
+    + `nell'ambiente — NEXUSCREW_MCP_SESSION=${tmuxSession}${liveRef ? ` NEXUSCREW_MCP_LIVE_THREAD=${liveRef}` : ''} nexuscrew mcp — e parlagli `
     + 'JSON-RPC su stdin (initialize, notifications/initialized, tools/call). '
-    + `Il valore esatto per questa conversazione è ${tmuxSession}: mai un'altra sessione.`;
+    + `Il valore esatto per questa conversazione è ${tmuxSession}: mai un'altra sessione.`
+    + (liveRef ? ' NEXUSCREW_MCP_LIVE_THREAD dichiara questa Live ai messaggi che mandi: tienilo uguale, senza modificarlo.' : '');
 }
 
 // —— Client on-demand del socket di controllo (sezione protocollo sopra) ——
@@ -411,6 +412,18 @@ function startThreadOnControlSocket({
   });
 }
 
+// Registro volatile con la stessa interfaccia di quello persistito.
+function volatileRegistry(now) {
+  const map = new Map();
+  return {
+    get: (cell) => map.get(cell) || null,
+    set: (cell, entry) => { const v = { ...entry, startedAt: now() }; map.set(cell, v); return v; },
+    remove: (cell) => map.delete(cell),
+    entries: () => [...map].map(([cell, entry]) => ({ cell, ...entry })),
+    findByRef: (ref) => [...map].map(([cell, entry]) => ({ cell, ...entry })).find((e) => e.ref === ref) || null,
+  };
+}
+
 // —— Il ponte ——
 function createLiveBridge({
   cfg,
@@ -421,9 +434,12 @@ function createLiveBridge({
   WebSocket,
   now = () => Date.now(),
   log = () => {},
+  registry = null,
 }) {
   const root = filesRoot || cfg.filesRoot || path.join(os.homedir(), 'NexusFiles');
-  const threadIdsByCell = new Map();
+  // The persisted registry survives a restart; without one (tests, partial
+  // setups) the bridge keeps the old behaviour with a volatile store.
+  const reg = registry || volatileRegistry(now);
   const threadStatusCache = new Map();
   const threadStatusInFlight = new Map();
   // Riserve in-process per l'avvio Live. La chiave è la cella host: una
@@ -497,15 +513,28 @@ function createLiveBridge({
     return cells.find((c) => c && c.cell === cellId) || null;
   }
 
-  async function threadStatus(cellId) {
-    const threadId = threadIdsByCell.get(cellId);
+  // Cache e richieste in corso sono per TUPLA (cella, thread), non per sola
+  // cella: la lettura di un thread sostituito non puo' rispondere per il nuovo,
+  // ne' ripopolare la cache dopo la rotazione.
+  const statusKey = (cellId, threadId) => `${cellId}\u0000${threadId}`;
+  function dropStatusFor(cellId) {
+    const prefix = `${cellId}\u0000`;
+    for (const key of [...threadStatusCache.keys()]) if (key.startsWith(prefix)) threadStatusCache.delete(key);
+  }
+
+  // `expectedThreadId`: chi attesta un riferimento chiede lo stato del thread
+  // che ha letto nel registro, non di quello che il registro nomina dopo.
+  async function threadStatus(cellId, expectedThreadId) {
+    const known = reg.get(cellId);
+    const threadId = expectedThreadId || (known && known.threadId);
     if (!threadId) return 'unknown';
+    const key = statusKey(cellId, threadId);
 
     const current = now();
-    const cached = threadStatusCache.get(cellId);
+    const cached = threadStatusCache.get(key);
     if (cached && cached.expiresAt > current) return cached.value;
-    if (cached) threadStatusCache.delete(cellId);
-    if (threadStatusInFlight.has(cellId)) return threadStatusInFlight.get(cellId);
+    if (cached) threadStatusCache.delete(key);
+    if (threadStatusInFlight.has(key)) return threadStatusInFlight.get(key);
 
     const query = queryThreadStatusOnControlSocket({
       socketPath: cfg.liveBridgeSocketPath,
@@ -513,13 +542,17 @@ function createLiveBridge({
       timeoutMs: cfg.liveBridgeTimeoutMs,
       WebSocket,
     }).catch(() => 'unknown').then((value) => {
+      // A definite "gone" ends the entry: the reference stops resolving and the
+      // file does not keep a thread that no longer exists. Anything uncertain
+      // (error, timeout, system error) leaves it alone.
+      if (value === 'absent') reg.remove(cellId, threadId);
       // Anche unknown e' la risposta della query corrente: non riusiamo un
       // valore buono oltre la sua finestra, e il prossimo tick potra' misurare
       // di nuovo il nodo.
-      threadStatusCache.set(cellId, { value, expiresAt: now() + threadStatusCacheMs });
+      threadStatusCache.set(key, { value, expiresAt: now() + threadStatusCacheMs });
       return value;
-    }).finally(() => { threadStatusInFlight.delete(cellId); });
-    threadStatusInFlight.set(cellId, query);
+    }).finally(() => { threadStatusInFlight.delete(key); });
+    threadStatusInFlight.set(key, query);
     return query;
   }
 
@@ -578,7 +611,11 @@ function createLiveBridge({
     // non è mai più assente: senza LIVE_PROMPT.md porta la sola intestazione
     // — e poiché il campo SOSTITUISCE le developer instructions della config
 // (see: the .or() in config/mod.rs), that cell no longer receives them.
-    const intestazione = identityHeader(snap.hostCell, cell.tmuxSession);
+    // The reference the Live declares to NexusCrew tools: made before the
+    // thread exists (the header travels with thread/start) and registered only
+    // at commit, so a discarded start leaves nothing behind.
+    const liveRef = crypto.randomBytes(16).toString('hex');
+    const intestazione = identityHeader(snap.hostCell, cell.tmuxSession, liveRef);
     const developerInstructions = prompt.applied
       ? `${intestazione}\n\n${prompt.text}`
       : intestazione;
@@ -647,8 +684,10 @@ function createLiveBridge({
       socketPath: cfg.liveBridgeSocketPath,
       at: now(),
     };
-    threadIdsByCell.set(snap.hostCell, started.threadId);
-    threadStatusCache.delete(snap.hostCell);
+    reg.set(snap.hostCell, {
+      threadId: started.threadId, ref: liveRef, ...(cell.tmuxSession ? { tmuxSession: cell.tmuxSession } : {}),
+    });
+    dropStatusFor(snap.hostCell);
     // Il puntamento è visibile lato nostro — log con cella, thread e
     // prompt applicato. È il "dirottamento dichiarato" del contratto. Il
     // Campo SOSTITUISCE le developer instructions della config (la
@@ -658,8 +697,29 @@ function createLiveBridge({
     return out;
   }
 
+  // At startup: a registry entry whose thread the daemon reports as gone is
+  // dropped; one the daemon cannot vouch for (error, timeout, system error)
+  // stays, because absence is only ever concluded from a definite answer.
+  async function reconcile() {
+    const removed = [];
+    const kept = [];
+    for (const entry of reg.entries()) {
+      let value;
+      try {
+        value = await queryThreadStatusOnControlSocket({
+          socketPath: cfg.liveBridgeSocketPath, threadId: entry.threadId,
+          timeoutMs: cfg.liveBridgeTimeoutMs, WebSocket,
+        });
+      } catch (_) { value = 'unknown'; }
+      if (value === 'absent' && reg.remove(entry.cell, entry.threadId)) { dropStatusFor(entry.cell); removed.push(entry.cell); }
+      else kept.push(entry.cell);
+    }
+    return { removed, kept };
+  }
+
   return {
     resolveForLive,
+    reconcile,
     threadStatus,
     readCellPrompt: (tmuxSession) => { const { text, ...rest } = readCellPrompt(root, tmuxSession); return rest; },
   };

package/lib/live-host/entry.js

@@ -0,0 +1,49 @@
+'use strict';
+// lib/live-host/entry.js — la voce `<instanceId>:Live` della directory delle celle.
+//
+// La Live compare solo quando c'e' qualcosa di vivo da nominare: un thread
+// nativo presente o attivo, oppure la modalita' tmux con l'ospite attivo. Non
+// ha una sessione tmux propria e non nomina la cella ospite: chi legge la
+// directory non deve poter confondere le due. canReceive resta false finche'
+// non esiste una consegna dedicata alla Live; il motivo dice perche'.
+
+const { isReservedLiveName } = require('./reserved.js');
+
+const NATIVE_ALIVE = new Set(['present', 'active']);
+
+async function buildLiveEntry({ store, bridge, fleetP, instanceId, now = Date.now }) {
+  try {
+    const snap = store.snapshot();
+    if (!snap || snap.hostCell == null || snap.ownerId) return null;
+    const fleet = await fleetP;
+    const statusFn = fleet && (typeof fleet.status === 'function' ? fleet.status : fleet.cellStatus);
+    if (!fleet || fleet.available !== true || typeof statusFn !== 'function') return null;
+    const status = await statusFn.call(fleet);
+    const cells = Array.isArray(status && status.cells) ? status.cells : [];
+    const host = cells.find((c) => c && c.cell === snap.hostCell && !isReservedLiveName(c.cell));
+    if (!host) return null;
+    // The Live works through its host cell (identity, tools, files): with the
+    // host off there is no Live to name, whatever the daemon still holds.
+    if (host.active !== true || host.tmux === false) return null;
+    const base = {
+      id: `${instanceId}:Live`,
+      instanceId,
+      cell: 'Live',
+      kind: 'live',
+      label: 'Live',
+      active: true,
+      canReceive: false,
+      lastSeen: now(),
+    };
+    if (String(host.engine || '').startsWith('codex-vl')) {
+      const thread = await bridge.threadStatus(snap.hostCell);
+      if (!NATIVE_ALIVE.has(thread)) return null;
+      return { ...base, mode: 'native', state: thread, reason: 'live-not-addressable' };
+    }
+    return { ...base, mode: 'tmux', state: 'tmux', reason: 'tmux-mode' };
+  } catch (_) {
+    return null;
+  }
+}
+
+module.exports = { buildLiveEntry };

package/lib/live-host/registry.js

@@ -0,0 +1,111 @@
+'use strict';
+// lib/live-host/registry.js — registro persistito dei thread Live.
+//
+// One entry per host cell: the thread the Live bridge started on the app-server
+// and the reference that thread declares when it calls NexusCrew tools. It lives
+// next to live-host.json so it survives a server restart: the thread itself
+// lives in the daemon, and a restart must not make it look absent.
+//
+// The file is the truth. Every call reads it, so two instances over the same
+// path agree; writes are synchronous read-modify-write (one event loop, no
+// interleaving) and atomic on disk. A damaged file reads as empty and a damaged
+// entry is skipped, never promoted.
+
+const path = require('node:path');
+const os = require('node:os');
+const { readJsonSafe, atomicWriteJson } = require('../notify/persist.js');
+
+const CELL_ID_RE = /^[A-Za-z0-9._-]{1,32}$/;
+const REF_RE = /^[a-f0-9]{32}$/;
+const MAX_THREAD_ID = 128;
+// One entry per host cell, and never more than this many: the oldest go first.
+const MAX_ENTRIES = 64;
+
+function liveThreadsPath(cfg = {}, home = (cfg.home || os.homedir())) {
+  if (cfg.liveThreadsPath) return cfg.liveThreadsPath;
+  if (cfg.tokenPath) return path.join(path.dirname(cfg.tokenPath), 'live-threads.json');
+  return path.join(home, '.nexuscrew', 'live-threads.json');
+}
+
+function validEntry(cell, raw) {
+  if (!CELL_ID_RE.test(String(cell || '')) || !raw || typeof raw !== 'object') return null;
+  if (typeof raw.threadId !== 'string' || !raw.threadId || raw.threadId.length > MAX_THREAD_ID) return null;
+  if (typeof raw.ref !== 'string' || !REF_RE.test(raw.ref)) return null;
+  const out = { threadId: raw.threadId, ref: raw.ref };
+  if (typeof raw.tmuxSession === 'string' && raw.tmuxSession) out.tmuxSession = raw.tmuxSession;
+  out.startedAt = Number.isFinite(raw.startedAt) ? raw.startedAt : 0;
+  return out;
+}
+
+function createLiveThreadRegistry({ filePath, now = () => Date.now() } = {}) {
+  if (!filePath || typeof filePath !== 'string') {
+    throw new Error('createLiveThreadRegistry: filePath richiesto');
+  }
+
+  function readAll() {
+    // Fail closed: a file that cannot be read safely (symlink, permissions wider
+    // than 0600) is treated as empty, never trusted. An empty registry means no
+    // thread is vouched for, which is the safe answer.
+    let raw;
+    try { raw = readJsonSafe(filePath); } catch (_) { return {}; }
+    const threads = raw && typeof raw.threads === 'object' && raw.threads && !Array.isArray(raw.threads)
+      ? raw.threads : {};
+    const out = {};
+    for (const [cell, value] of Object.entries(threads)) {
+      const entry = validEntry(cell, value);
+      if (entry) out[cell] = entry;
+    }
+    return out;
+  }
+
+  function writeAll(threads) {
+    atomicWriteJson(filePath, { version: 1, threads });
+  }
+
+  function get(cell) {
+    return readAll()[cell] || null;
+  }
+
+  function set(cell, entry) {
+    const next = validEntry(cell, { ...entry, startedAt: now() });
+    if (!next) throw new Error('voce del registro Live non valida');
+    const all = readAll();
+    all[cell] = next;
+    const cells = Object.keys(all);
+    if (cells.length > MAX_ENTRIES) {
+      cells.filter((name) => name !== cell)
+        .sort((a, b) => all[a].startedAt - all[b].startedAt)
+        .slice(0, cells.length - MAX_ENTRIES)
+        .forEach((name) => { delete all[name]; });
+    }
+    writeAll(all);
+    return next;
+  }
+
+  // With `expectedThreadId` the entry is removed only if it still names that
+  // thread: a slow read about an old thread must not remove a newer Live that
+  // replaced the entry in the meantime.
+  function remove(cell, expectedThreadId) {
+    const all = readAll();
+    if (!(cell in all)) return false;
+    if (expectedThreadId !== undefined && all[cell].threadId !== expectedThreadId) return false;
+    delete all[cell];
+    writeAll(all);
+    return true;
+  }
+
+  function entries() {
+    return Object.entries(readAll()).map(([cell, entry]) => ({ cell, ...entry }));
+  }
+
+  function findByRef(ref) {
+    if (typeof ref !== 'string' || !REF_RE.test(ref)) return null;
+    return entries().find((entry) => entry.ref === ref) || null;
+  }
+
+  return { get, set, remove, entries, findByRef, filePath };
+}
+
+createLiveThreadRegistry.MAX_ENTRIES = MAX_ENTRIES;
+
+module.exports = { createLiveThreadRegistry, liveThreadsPath, REF_RE };

package/lib/live-host/reserved.js

@@ -0,0 +1,12 @@
+'use strict';
+// lib/live-host/reserved.js — il nome `Live` appartiene alla Live.
+//
+// Una cella con quel nome (in qualunque grafia) si scambierebbe con la voce di
+// directory della Live. Il divieto vale alla scrittura e il nome e' filtrato
+// in uscita, cosi' una definizione gia' presente non puo' sovrapporsi.
+
+function isReservedLiveName(id) {
+  return typeof id === 'string' && id.toLowerCase() === 'live';
+}
+
+module.exports = { isReservedLiveName };