@mmmbuto/nexuscrew 0.9.63 → 0.9.65

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 };

package/lib/mcp/cells.js

@@ -100,12 +100,49 @@ function parseCellTarget(value) {
   return NODE_ID_RE.test(instanceId) && CELL_ID_RE.test(cell) ? { instanceId, cell } : null;
 }
 
+const LIVE_MODES = new Set(['native', 'tmux']);
+const LIVE_STATES = new Set(['present', 'active', 'tmux']);
+const LIVE_REASONS = new Set(['live-not-addressable', 'tmux-mode']);
+
+function normalizeLiveEntry(raw, owner, route) {
+  if (raw.instanceId !== owner.instanceId || raw.cell !== 'Live'
+    || !LIVE_MODES.has(raw.mode) || !LIVE_STATES.has(raw.state)) return null;
+  return {
+    id: `${owner.instanceId}:Live`,
+    instanceId: owner.instanceId,
+    owner: owner.label,
+    route,
+    cell: 'Live',
+    kind: 'live',
+    label: 'Live',
+    labelReported: false,
+    mode: raw.mode,
+    state: raw.state,
+    reason: LIVE_REASONS.has(raw.reason) ? raw.reason : 'live-not-addressable',
+    engine: '',
+    model: '',
+    active: raw.active === true,
+    // Not receivable until a dedicated delivery exists.
+    canReceive: false,
+    lastSeen: Number.isFinite(raw.lastSeen) ? raw.lastSeen : null,
+    self: false,
+  };
+}
+
 function normalizeCellPayload(payload, owner, callerSession = null) {
   if (!payload || payload.instanceId !== owner.instanceId || !Array.isArray(payload.cells)) return [];
   const route = owner.route.length ? owner.route.join('/') : 'local';
   const seen = new Set();
   const out = [];
   for (const raw of payload.cells) {
+    if (raw && raw.kind === 'live') {
+      // The Live is not a cell: it has no tmux session. A federated payload is
+      // untrusted, so the entry is rebuilt from known values only and is never
+      // receivable, whatever the peer says.
+      const live = normalizeLiveEntry(raw, owner, route);
+      if (live && !seen.has('\0live')) { seen.add('\0live'); out.push(live); }
+      continue;
+    }
     if (!raw || raw.instanceId !== owner.instanceId || !CELL_ID_RE.test(String(raw.cell || ''))
       || typeof raw.tmuxSession !== 'string' || !isValidSession(raw.tmuxSession)
       || seen.has(raw.cell)) continue;

package/lib/mcp/server.js

@@ -255,6 +255,11 @@ function createMcpServer(opts = {}) {
   // (config.json + env NEXUSCREW_CONFIG_FILE/PORT/TOKEN_FILE). opts.config per test.
   const cfg = opts.config || loadConfig();
   const baseUrl = `http://127.0.0.1:${cfg.port}`;
+  // The Live declares the reference of its own thread; the server decides
+  // whether the declaration holds (registry, host cell, live thread). A value
+  // that is not a well-formed reference is never sent.
+  const liveRefRaw = typeof env.NEXUSCREW_MCP_LIVE_THREAD === 'string' ? env.NEXUSCREW_MCP_LIVE_THREAD.trim() : '';
+  const liveThreadHeader = /^[a-f0-9]{32}$/.test(liveRefRaw) ? { 'x-nexuscrew-live-thread': liveRefRaw } : {};
 
   // Identita' locale storica: risolta una volta e cacheata — ma solo se riesce.
   //
@@ -375,6 +380,7 @@ function createMcpServer(opts = {}) {
           authorization: `Bearer ${token}`,
           ...signed,
           ...identityBinding,
+          ...liveThreadHeader,
           ...(payload !== undefined ? { 'content-type': 'application/json' } : {}),
         },
         ...(payload !== undefined ? { body: payload } : {}),
@@ -389,7 +395,7 @@ function createMcpServer(opts = {}) {
     return j;
   }
 
-  // NC-R. Aggiornare NexusCrew NON cambia il codice gia' caricato dai bridge
+  // Aggiornare NexusCrew NON cambia il codice gia' caricato dai bridge
   // MCP delle celle attive: ogni processo resta sulla versione con cui e' stato
   // avviato fino al riavvio della cella. Dopo una correzione installata, un
   // bridge ancora attivo puo' quindi restituire l'errore precedente; prima di

package/lib/mcp/tools.js

@@ -656,6 +656,7 @@ const TOOLS = [
       const target = directory.cells.find((cell) => cell.instanceId === targetRef.instanceId
         && cell.cell === targetRef.cell);
       if (!target) throw new Error('nc_cell_diagnostics: cella locale non trovata');
+      if (target.kind === 'live') throw new Error('nc_cell_diagnostics: la Live non e\' una cella e non ha diagnostica');
 
       const [definitions, diagnostics] = await Promise.all([
         ctx.api('GET', '/api/fleet/definitions'), recentDiagnostics(ctx),
@@ -712,6 +713,11 @@ const TOOLS = [
       const target = directory.cells.find((cell) => cell.instanceId === targetRef.instanceId
         && cell.cell === targetRef.cell);
       if (!target) throw new Error(cellLookupFailure(directory, targetRef));
+      // The Live is addressable by id but has no delivery yet: say so, and never
+      // let the message land on its host cell or any other.
+      if (target.kind === 'live') {
+        throw new Error(`live-not-addressable: la Live non riceve ancora messaggi da nc_send_cell (${target.reason || 'live-not-addressable'}); nessun messaggio inviato`);
+      }
       if (!target.canReceive) throw new Error('cella destinataria non attiva; nessun messaggio accodato');
       const apiPath = target.route === 'local'
         ? '/api/cells/send' : routePath(target.route.split('/'), 'cells/send');
@@ -923,7 +929,7 @@ const TOOLS = [
       return { receipt };
     },
   },
-  // -- lease Live del child (fetta 2b, contratto rev1) ----------------------
+  // -- lease Live del child (fetta 2b) ----------------------
   // Tre metodi DISTINTI perche' i valori di ritorno non mentono l'uno con l'altro:
   // solo register puo' rispondere {status:'pending'} (join non ancora tracciato);
   // refresh su registration viva risponde {status:'live', proof} e non ha stati