@mmmbuto/nexuscrew 0.9.14 → 0.9.16

package/lib/live-host/bridge.js

@@ -32,10 +32,10 @@
 //     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,
-//     initialized e thread/start. Per questo l'aggancio funziona anche su una
-//     cella che sta già processando un turno: conversazioni separate, nessuna
+//     tocca MAI la thread di una TUI — né turn/start né thread/resume. La sonda
+//     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 HC2/rev2 JC4).
 //   - MC3.3: la connessione al socket di controllo è ON-DEMAND (connect →
 //     handshake → thread/start → close), mai permanente: la fuga notifiche
@@ -49,7 +49,8 @@
 // WebSocket (text frame) sopra unix socket, JSON-RPC. Handshake: request
 // `initialize` → response {userAgent, codexHome} → notifica `initialized`
 // (senza params). Poi `thread/start` {cwd, developerInstructions?} → response
-// {thread:{id}, cwd}. Il socket è 0600 dell'utente: il confine è quello
+// {thread:{id}, cwd}, oppure `thread/read` {threadId, includeTurns:false} per
+// leggere il runtime. Il socket è 0600 dell'utente: il confine è quello
 // (MC1.3), non c'è autenticazione applicativa.
 
 const fs = require('node:fs');
@@ -70,6 +71,98 @@ const CLIENT_NAME = 'nexuscrew-live-bridge';
 // chiudiamo. Breve di proposito — non allunga la risposta a chi ha chiesto il
 // ponte, che e' gia' stata data.
 const ORPHAN_GRACE_MS = 1500;
+const THREAD_STATUS_CACHE_MS = 1500;
+
+function normalizedThreadStatus(status) {
+  const type = typeof status === 'string' ? status : status && status.type;
+  switch (String(type || '').toLowerCase()) {
+    case 'notloaded': return 'absent';
+    case 'idle': return 'present';
+    case 'active': return 'active';
+    // A server-reported system error is not evidence that the thread is absent.
+    case 'systemerror': return 'unknown';
+    default: return null;
+  }
+}
+
+// Query on-demand del runtime del thread. La connessione e' dedicata a una
+// sola lettura: ogni uscita, inclusi timeout ed errore di protocollo, chiude il
+// WebSocket prima di risolvere la Promise. Il valore restituito e' volutamente
+// piu' stretto del protocollo: presente/attivo/assente, oppure il chiamante
+// classifica il fallimento come unknown.
+function queryThreadStatusOnControlSocket({
+  socketPath, threadId, timeoutMs, WebSocket = defaultWebSocket(),
+}) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let nextId = 0;
+    let ws;
+    const close = (force = false) => {
+      try {
+        if (!ws) return;
+        if (!force && ws.readyState === WebSocket.OPEN) ws.close(1000); else ws.terminate();
+      } catch (_) { /* best effort: il socket verra' raccolto dal peer */ }
+    };
+    const done = (error, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      close(!!error);
+      if (error) reject(error); else resolve(value);
+    };
+    const timer = setTimeout(() => {
+      done(Object.assign(new Error('control socket thread/read timeout'), { code: 'ETIMEOUT' }));
+    }, timeoutMs);
+
+    try {
+      ws = new WebSocket(`ws+unix://${socketPath}:/`, { handshakeTimeout: timeoutMs });
+    } catch (e) {
+      done(Object.assign(new Error(`control socket: ${e.message}`), { code: 'ESOCKET' }));
+      return;
+    }
+
+    const send = (obj) => ws.send(JSON.stringify(obj));
+    const request = (method, params) => new Promise((res, rej) => {
+      const id = ++nextId;
+      ws.pending = ws.pending || new Map();
+      ws.pending.set(id, { res, rej });
+      send({ jsonrpc: '2.0', id, method, params });
+    });
+
+    ws.on('open', async () => {
+      if (settled) { close(); return; }
+      try {
+        await request('initialize', {
+          clientInfo: { name: CLIENT_NAME, title: 'NexusCrew Thread Status', version: bridgeVersion() },
+          capabilities: { experimentalApi: true },
+        });
+        send({ jsonrpc: '2.0', method: 'initialized' });
+        const out = await request('thread/read', { threadId, includeTurns: false });
+        const value = normalizedThreadStatus(out && out.thread && out.thread.status);
+        if (!value) throw Object.assign(new Error('thread/read senza stato thread riconoscibile'), { code: 'EPROTO' });
+        done(null, value);
+      } catch (e) {
+        done(e);
+      }
+    });
+
+    ws.on('message', (data) => {
+      let msg;
+      try { msg = JSON.parse(String(data)); } catch (_) { return; }
+      if (msg && msg.id != null && ws.pending && ws.pending.has(msg.id)) {
+        const waiter = ws.pending.get(msg.id);
+        ws.pending.delete(msg.id);
+        if (msg.error) waiter.rej(Object.assign(new Error(msg.error.message || 'jsonrpc error'), { code: 'ERPC', detail: msg.error }));
+        else waiter.res(msg.result);
+      }
+    });
+
+    ws.on('error', (e) => done(Object.assign(new Error(`control socket: ${e.message}`), { code: 'ESOCKET' })));
+    ws.on('close', () => {
+      if (!settled) done(Object.assign(new Error('control socket chiuso prima della risposta'), { code: 'ESOCKET' }));
+    });
+  });
+}
 
 // —— Prompt per-cella (rev4 LC2, nome fisso confermato il 2026-08-15) ——
 // Collocazione: filesRoot/<tmuxSession>/LIVE_PROMPT.md — la sessione tmux
@@ -167,6 +260,7 @@ function identityHeader(cellId, tmuxSession) {
 // e la finestra resta minima.
 function startThreadOnControlSocket({
   socketPath, cwd, developerInstructions, timeoutMs,
+  declaredSession,
   WebSocket = defaultWebSocket(), now = () => Date.now(), log = () => {},
 }) {
   return new Promise((resolve, reject) => {
@@ -244,7 +338,17 @@ function startThreadOnControlSocket({
       if (settled) { chiudi(); return; }
       try {
         await request('initialize', {
-          clientInfo: { name: CLIENT_NAME, title: 'NexusCrew Live Bridge', version: bridgeVersion() },
+          clientInfo: {
+            name: CLIENT_NAME,
+            title: 'NexusCrew Live Bridge',
+            version: bridgeVersion(),
+            // Identita della connessione: la sessione gia' risolta della cella
+            // designata (mai env grezzi, mai guess — roster MC3.4). Se assente
+            // il campo SI OMETTE (Option None lato protocollo): il resolver a
+            // valle classifica MISSING nominando la causa; sanitizzare qui la
+            // duplicherebbe senza guadagno.
+            ...(declaredSession ? { nexuscrewSession: declaredSession } : {}),
+          },
           capabilities: { experimentalApi: true },
         });
         send({ jsonrpc: '2.0', method: 'initialized' }); // notifica, senza params
@@ -309,6 +413,11 @@ function createLiveBridge({
   log = () => {},
 }) {
   const root = filesRoot || cfg.filesRoot || path.join(os.homedir(), 'NexusFiles');
+  const threadIdsByCell = new Map();
+  const threadStatusCache = new Map();
+  const threadStatusInFlight = new Map();
+  const threadStatusCacheMs = Number.isFinite(cfg.liveThreadStatusCacheMs)
+    ? Math.max(0, cfg.liveThreadStatusCacheMs) : THREAD_STATUS_CACHE_MS;
 
   const none = (reason, extra) => ({ mode: 'none', reason, ...(extra || {}), at: now() });
 
@@ -345,6 +454,32 @@ function createLiveBridge({
     return cells.find((c) => c && c.cell === cellId) || null;
   }
 
+  async function threadStatus(cellId) {
+    const threadId = threadIdsByCell.get(cellId);
+    if (!threadId) return 'unknown';
+
+    const current = now();
+    const cached = threadStatusCache.get(cellId);
+    if (cached && cached.expiresAt > current) return cached.value;
+    if (cached) threadStatusCache.delete(cellId);
+    if (threadStatusInFlight.has(cellId)) return threadStatusInFlight.get(cellId);
+
+    const query = queryThreadStatusOnControlSocket({
+      socketPath: cfg.liveBridgeSocketPath,
+      threadId,
+      timeoutMs: cfg.liveBridgeTimeoutMs,
+      WebSocket,
+    }).catch(() => 'unknown').then((value) => {
+      // 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 });
+      return value;
+    }).finally(() => { threadStatusInFlight.delete(cellId); });
+    threadStatusInFlight.set(cellId, query);
+    return query;
+  }
+
   // Risolve il puntamento per l'avvio di una Live. Sempre una risposta utile:
   // i `none` sono modi legittimi di non puntare, e il reason distingue le
   // cause (designazione assente, cella non idonea, fallback su fallimento).
@@ -411,6 +546,10 @@ function createLiveBridge({
         socketPath: cfg.liveBridgeSocketPath,
         cwd: cell.cwd,
         developerInstructions,
+        // Stessa fonte dell'intestazione e del prompt per-cella (roster:
+        // MC3.4). Dichiarata per connessione: batte qualunque ambiente
+        // ereditato, anche quando e' popolato ma stantio (B1-bis).
+        declaredSession: cell.tmuxSession,
         timeoutMs: cfg.liveBridgeTimeoutMs,
         WebSocket,
         log,
@@ -429,6 +568,8 @@ function createLiveBridge({
       socketPath: cfg.liveBridgeSocketPath,
       at: now(),
     };
+    threadIdsByCell.set(snap.hostCell, started.threadId);
+    threadStatusCache.delete(snap.hostCell);
     // LC1.4: 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 (MC2, la
@@ -438,7 +579,11 @@ function createLiveBridge({
     return out;
   }
 
-  return { resolveForLive, readCellPrompt: (tmuxSession) => { const { text, ...rest } = readCellPrompt(root, tmuxSession); return rest; } };
+  return {
+    resolveForLive,
+    threadStatus,
+    readCellPrompt: (tmuxSession) => { const { text, ...rest } = readCellPrompt(root, tmuxSession); return rest; },
+  };
 }
 
 let cachedVersion = null;
@@ -452,4 +597,7 @@ function bridgeVersion() {
   return cachedVersion;
 }
 
-module.exports = { createLiveBridge, readCellPrompt, startThreadOnControlSocket, CLIENT_NAME };
+module.exports = {
+  createLiveBridge, readCellPrompt, startThreadOnControlSocket,
+  queryThreadStatusOnControlSocket, CLIENT_NAME,
+};

package/lib/live-host/routes.js

@@ -75,7 +75,9 @@ function eligibleOf(fleet, cell, hostCell) {
 function liveHostRoutes({ fleetP, store, readonly = () => false, now = () => Date.now(), bridge = null }) {
   const r = express.Router();
 
-  // GET /api/live-host — { hostCell, revision, eligible, host: {lease}, at }.
+  // GET /api/live-host — { hostCell, revision, eligible, threadStatus,
+  // host: {lease}, at }. threadStatus misura il runtime del thread ponte:
+  // absent/present/active/unknown; non dichiara la presenza del client Live.
   // hostCell e revision vengono dallo store (preservato); eligible e' la verita'
   // COMPOSTA roster+lease (si veda hostLeaseState sopra); host.lease espone lo
   // stato del lease della cella designata, distinto, perche' chi legge distingue.
@@ -84,14 +86,20 @@ function liveHostRoutes({ fleetP, store, readonly = () => false, now = () => Dat
       const snap = store.snapshot();
       let eligible = false;
       let lease = null;
+      let threadStatus = 'absent';
       if (snap.hostCell != null) {
         const fleet = await fleetP.catch(() => null);
         const cells = await localCells(fleetP).catch(() => []);
         const cell = Array.isArray(cells) ? cells.find((c) => c && c.cell === snap.hostCell) : null;
         lease = hostLeaseState(fleet, snap.hostCell);
         eligible = eligibleOf(fleet, cell, snap.hostCell);
+        if (bridge && typeof bridge.threadStatus === 'function') {
+          threadStatus = await Promise.resolve(bridge.threadStatus(snap.hostCell)).catch(() => 'unknown');
+        } else {
+          threadStatus = 'unknown';
+        }
       }
-      res.json({ hostCell: snap.hostCell, revision: snap.revision, eligible, host: { lease }, at: now() });
+      res.json({ hostCell: snap.hostCell, revision: snap.revision, eligible, threadStatus, host: { lease }, at: now() });
     } catch (e) {
       res.status(500).json({ error: String(e && e.message || e) });
     }

package/lib/mcp/server.js

@@ -202,13 +202,35 @@ function createMcpServer(opts = {}) {
   const cfg = opts.config || loadConfig();
   const baseUrl = `http://127.0.0.1:${cfg.port}`;
 
-  // Identita' risolta una volta e cacheata (la sessione tmux non cambia a runtime).
-  // Una sola risoluzione condivisa: `identity()` per la diagnostica completa
-  // (source/code/presence), `session()` estrae solo il nome per gli handler
-  // storici (compatibilita'). Nessuna API/token coinvolta qui.
-  let identityP = null;
+  // Identita' risolta una volta e cacheata — ma solo se riesce.
+  //
+  // Perche' il successo e il fallimento hanno vita diversa: una sessione
+  // risolta non cambia per la vita del processo (cache storica, invariata);
+  // un FALLIMENTO invece non deve restare bloccato per sempre. Il caso reale:
+  // questo server MCP parte in un daemon avviato da systemd PRIMA che il
+  // server tmux sia raggiungibile, `display-message` fallisce, e con la cache
+  // a vita l'identita' restava assente anche dopo che tmux era su. Un
+  // fallimento viene quindi ri-tentato, con anti-hammering: al piu' una
+  // risoluzione ogni IDENTITY_RETRY_MS finche' non riesce (un tmux rotto non
+  // puo' trasformare ogni tool call in una execFile da 3 s).
+  // `identity()` per la diagnostica completa (source/code/presence),
+  // `session()` estrae solo il nome per gli handler storici (compatibilita').
+  // Nessuna API/token coinvolta qui.
+  // Iniettabile nei test per non attendere 30 s reali (opts.identityRetryMs).
+  const IDENTITY_RETRY_MS = opts.identityRetryMs ?? 30_000;
+  let identityP = null;          // promise condivisa in corso/cacheata
+  let identityOk = false;        // solo un esito OK resta cacheato a vita
+  let identityAttemptAt = 0;     // istante dell'ultimo tentativo (anti-spam)
   const identity = () => {
-    if (!identityP) identityP = resolveIdentity({ env, tmuxBin: cfg.tmuxBin || 'tmux', execFileImpl });
+    if (identityOk) return identityP;
+    const now = Date.now();
+    if (identityP && now - identityAttemptAt < IDENTITY_RETRY_MS) return identityP;
+    identityAttemptAt = now;
+    identityP = resolveIdentity({ env, tmuxBin: cfg.tmuxBin || 'tmux', execFileImpl })
+      .then((i) => {
+        identityOk = i.code === IDENTITY_CODE.OK;
+        return i;
+      });
     return identityP;
   };
   const session = () => identity().then((i) => i.session);

package/lib/mcp/tools.js

@@ -100,15 +100,33 @@ function vlLookupFailure(directory, { instanceId, nodeId = null }) {
     + ' — copia l\'id esatto da nc_vl_nodes invece di ribatterlo';
 }
 
+// Perche' il messaggio nomina la causa invece della sola remediation.
+//
+// `resolveIdentity` distingue quattro modi di non identificarsi (STALE_PANE,
+// SESSION_MISMATCH, INVALID, MISSING) e `nc_identity` li mostra — ma il tool
+// che si blocca e' quello che il modello sta chiamando, e il suo errore era
+// ridotto a MISSING con la remediation generica. Chi lo leggeva andava a
+// allowlistare variabili che erano gia' allowlistate: il pane era morto, o le
+// due fonti discordavano. Ogni causa porta un'azione diversa: il messaggio del
+// tool che si blocca deve dire quale e' la sua.
+const IDENTITY_CAUSE = Object.freeze({
+  [IDENTITY_CODE.STALE_PANE]: 'il pane tmux del chiamante non risponde (morto o non verificabile)',
+  [IDENTITY_CODE.SESSION_MISMATCH]: 'tmux e NEXUSCREW_MCP_SESSION dichiarano due sessioni diverse: identita ambigua, nessuna delle due viene attribuita',
+  [IDENTITY_CODE.INVALID]: 'una fonte di identita e presente ma invalida',
+  [IDENTITY_CODE.MISSING]: 'nessuna fonte di identita: serve $TMUX (dentro tmux) o NEXUSCREW_MCP_SESSION',
+});
+
 function requireSession(session, tool, code = IDENTITY_CODE.MISSING) {
   if (session) return session;
-  const stableCode = code === IDENTITY_CODE.INVALID ? IDENTITY_CODE.INVALID : IDENTITY_CODE.MISSING;
-  // Errore umano per il modello: messaggio chiaro + codice stabile fra parentesi
-  // quadre. isError=true e' impostato dal server (toolsCall); qui si propaga
-  // solo il testo. La regex storica /NEXUSCREW_MCP_SESSION/ resta soddisfatta.
+  const stableCode = Object.values(IDENTITY_CODE).includes(code) ? code : IDENTITY_CODE.MISSING;
+  const cause = IDENTITY_CAUSE[stableCode];
+  // Errore umano per il modello: causa nominata + remediation + codice stabile
+  // fra parentesi quadre. isError=true e' impostato dal server (toolsCall);
+  // qui si propaga solo il testo. La regex storica /NEXUSCREW_MCP_SESSION/
+  // resta soddisfatta (presente nella remediation e nel caso MISSING).
   throw new Error(
-    `${tool}: sessione tmux non identificata — serve $TMUX (dentro tmux) o `
-    + `NEXUSCREW_MCP_SESSION [${stableCode}]`,
+    `${tool}: sessione tmux non identificata — ${cause}. `
+    + `${IDENTITY_REMEDIATION} [${stableCode}]`,
   );
 }
 

package/lib/nodes/health.js

@@ -20,9 +20,40 @@ const nodesTunnel = require('./tunnel.js');
 const { probeHealth } = require('../proxy/federation.js');
 
 const TTL_MS = 5000;
+const FAILURE_THRESHOLD = 3;
 const cache = new Map(); // name -> { health, at }
+const probeFailures = new Map(); // cache key -> consecutive transport probe failures
 
-function clearHealthCache() { cache.clear(); }
+function clearHealthCache() { cache.clear(); probeFailures.clear(); }
+
+// A single late probe is not evidence that a still-up tunnel has died. Keep
+// the last authoritative health while the threshold is pending; once reached,
+// expose the real down result. Recovery is immediate on the first good probe.
+function applyProbeHysteresis(key, probed, previous, now, threshold) {
+  if (probed.transport !== 'down') {
+    probeFailures.delete(key);
+    return probed;
+  }
+  const failures = (probeFailures.get(key) || 0) + 1;
+  probeFailures.set(key, failures);
+  if (failures >= threshold) return { ...probed, consecutiveFailures: failures };
+  if (previous && previous.transport === 'up') {
+    return {
+      ...previous,
+      at: now,
+      probePending: true,
+      consecutiveFailures: failures,
+      detail: `health probe transitorio (${failures}/${threshold})`,
+    };
+  }
+  // No previous authoritative 'up' to protect: the first measurement is the
+  // real one. A node that has never been seen answering and does not answer
+  // now is simply down — reporting 'unknown' would keep a declared-dead peer
+  // out of the down state forever (one probe per process, never reaching the
+  // threshold unless someone keeps probing). The hysteresis only exists to
+  // protect a measured up state from jitter, per 239e2e6.
+  return { ...probed, consecutiveFailures: failures };
+}
 
 // Compatibilita' tunnel per il frontend attuale (che legge tunnel.status): deriva
 // uno {status, managed} retro-compatibile dal model health, senza reintrodurre il
@@ -39,11 +70,14 @@ function tunnelFromHealth(h) {
   return { status: 'unknown', managed: false }; // inbound / unknown
 }
 
-async function nodeHealth({ node, home, fetchImpl, now = Date.now(), force = false }) {
+async function nodeHealth({ node, home, fetchImpl, now = Date.now(), force = false, failureThreshold = FAILURE_THRESHOLD }) {
   if (!node || typeof node !== 'object') return null;
   const cacheKey = `${home || ''}\0${node.direction || 'outbound'}\0${node.name}\0${node.localPort}\0${node.nodeId || ''}\0${node.shared === true}\0${node.rolesKnown === true}\0${node.roles?.node === true}`;
-  const cached = !force && cache.get(cacheKey);
-  if (cached && (now - cached.at) < TTL_MS) return cached.health;
+  const cached = cache.get(cacheKey);
+  if (!force && cached && (now - cached.at) < TTL_MS) return cached.health;
+  const previous = cached?.health || null;
+  const threshold = Number.isSafeInteger(failureThreshold) && failureThreshold > 0
+    ? failureThreshold : FAILURE_THRESHOLD;
 
   let health;
   if (node.direction === 'inbound') {
@@ -91,7 +125,7 @@ async function nodeHealth({ node, home, fetchImpl, now = Date.now(), force = fal
           detail: node.rolesKnown === true ? 'client peer offline (expected)' : 'inbound peer offline',
         };
       } else {
-        health = { ...probed, managed: false };
+        health = { ...applyProbeHysteresis(cacheKey, probed, previous, now, threshold), managed: false };
       }
     }
   } else {
@@ -115,16 +149,16 @@ async function nodeHealth({ node, home, fetchImpl, now = Date.now(), force = fal
       const probed = await probeHealth({
         port: node.localPort, token: node.token, expectedInstanceId: node.nodeId || null, fetchImpl, now,
       });
-      health = { ...probed, transportEngine: ts.transport || 'ssh', managed: true };
+      health = { ...applyProbeHysteresis(cacheKey, probed, previous, now, threshold), transportEngine: ts.transport || 'ssh', managed: true };
     }
   }
   cache.set(cacheKey, { health, at: now });
   return health;
 }
 
-async function nodesHealth({ nodes, home, fetchImpl, now = Date.now() }) {
+async function nodesHealth({ nodes, home, fetchImpl, now = Date.now(), failureThreshold = FAILURE_THRESHOLD }) {
   if (!Array.isArray(nodes) || nodes.length === 0) return [];
-  return Promise.all(nodes.map((node) => nodeHealth({ node, home, fetchImpl, now })));
+  return Promise.all(nodes.map((node) => nodeHealth({ node, home, fetchImpl, now, failureThreshold })));
 }
 
-module.exports = { nodeHealth, nodesHealth, tunnelFromHealth, clearHealthCache, TTL_MS };
+module.exports = { nodeHealth, nodesHealth, tunnelFromHealth, clearHealthCache, TTL_MS, FAILURE_THRESHOLD };

package/lib/server.js

@@ -14,7 +14,7 @@ const { createSession, killSession, isProtectedSession } = require('./tmux/lifec
 const { createPreviewSampler } = require('./tmux/preview.js');
 const { requireSharedTmuxProtection } = require('./tmux/shared-server.js');
 const { openAttach } = require('./pty/attach.js');
-const { bindWs } = require('./ws/bridge.js');
+const { bindWs, createPtyGraceStore } = require('./ws/bridge.js');
 const { loadOrCreateToken, verify } = require('./auth/token.js');
 const { requireToken, bearerFrom } = require('./auth/middleware.js');
 const { filesRoutes } = require('./files/routes.js');
@@ -71,6 +71,7 @@ const { createNotifier } = require('./notify/notifier.js');
 const { notifyRoutes } = require('./notify/routes.js');
 const { createNpmUpdater } = require('./update/manager.js');
 const { createDiagnostics } = require('./diagnostics/store.js');
+const { createDropCounter } = require('./ws/drop-counter.js');
 const { diagnosticsRoutes } = require('./diagnostics/routes.js');
 const vlNodeStore = require('./vl-nodes/store.js');
 const { createBroker: createVlNodeBroker } = require('./vl-nodes/broker.js');
@@ -105,6 +106,11 @@ function createServer(opts = {}) {
   // wss viene creato piu' sotto; closeSessions lo raggiunge a request-time (mai durante
   // createServer) per chiudere le sessioni WS attive sulla rotazione token (§4b(3)).
   let wss = null;
+  const ptyGrace = createPtyGraceStore({
+    graceMs: cfg.ptyGraceMs,
+    maxSessions: cfg.ptyGraceMaxSessions,
+    maxMemoryBytes: cfg.ptyGraceMaxMemoryBytes,
+  });
   const closeSessions = () => {
     if (wss) {
       for (const ws of wss.clients) { try { ws.close(4001, 'token rotated'); } catch (_) { /* best-effort */ } }
@@ -141,6 +147,8 @@ function createServer(opts = {}) {
   const asksStore = createAsksStore({ dir: notifyDir });
   const notifier = createNotifier({ hub: eventsHub, push: pushSvc });
   const diagnostics = opts.diagnostics || createDiagnostics();
+  // Contatore cadute WS (rolling 10 min): alimenta i meta dei log di bridge.
+  const wsDropCounter = createDropCounter();
   const updater = opts.updateManager || createNpmUpdater({
     currentVersion: VERSION,
     home: cfg.home || os.homedir(),
@@ -937,6 +945,7 @@ function createServer(opts = {}) {
   }));
   api.use('/cells', cellsRoutes({
     fleetP,
+    diagnostics,
     instanceId: () => (nodesStore.loadStore(nodesPath) || {}).nodeId || null,
     submit: opts.cellSubmit || ((session, text, meta) => submitToSession(cfg.tmuxBin, session, text, {
       engine: meta && meta.engine,
@@ -983,6 +992,7 @@ function createServer(opts = {}) {
       const view = nodesStore.redactStore(st);
       const healths = await nodesHealth.nodesHealth({
         nodes: st.nodes, home: cfg.home || os.homedir(), fetchImpl: healthFetch, now: Date.now(),
+        failureThreshold: cfg.nodeHealthFailureThreshold,
       });
       const nodes = view.nodes.map((n, i) => {
         const h = healths[i] || null;
@@ -1006,6 +1016,7 @@ function createServer(opts = {}) {
       const direct = nodesStore.redactStore(st).nodes;
       const healths = await nodesHealth.nodesHealth({
         nodes: st.nodes, home: cfg.home || os.homedir(), fetchImpl: healthFetch, now: Date.now(),
+        failureThreshold: cfg.nodeHealthFailureThreshold,
       });
       const extras = new Map(direct.map((node, index) => {
         const health = healths[index] || null;
@@ -1115,7 +1126,7 @@ function createServer(opts = {}) {
   });
   server.on('close', () => {
     diagnostics.record('info', 'server', 'SERVER_STOPPED', 'NexusCrew server stopped', { reason: 'close' });
-    watcher.close(); previews.close(); eventsHub.closeAll(); updater.close();
+    watcher.close(); previews.close(); eventsHub.closeAll(); updater.close(); ptyGrace.close();
     for (const timer of reverseWatchers.values()) clearInterval(timer);
     reverseWatchers.clear(); rotatableReverse.clear(); void reverseSlotListeners?.closeAll();
     // Il pannello non sopravvive al control plane: senza requireToken sopra,
@@ -1132,7 +1143,13 @@ function createServer(opts = {}) {
   // lato browser, che il client riconnette senza richiedere refresh pagina.
   const heartbeat = setInterval(() => {
     for (const client of wss.clients) {
-      if (client.isAlive === false) { try { client.terminate(); } catch (_) {} continue; }
+      if (client.isAlive === false) {
+        // Marca il motivo PRIMA del terminate: il close event (1006) nel bridge
+        // lo classifichera' come heartbeat-timeout invece di «drop TCP generico».
+        try { client.__ncCloseReason = 'heartbeat-timeout'; } catch (_) {}
+        try { client.terminate(); } catch (_) {}
+        continue;
+      }
       client.isAlive = false;
       try { client.ping(); } catch (_) { try { client.terminate(); } catch (_e) {} }
     }
@@ -1225,7 +1242,10 @@ function createServer(opts = {}) {
       runAction: (sess, action) => runAction(cfg.tmuxBin, sess, action),
       countClients: (sess) => attachedClients(cfg.tmuxBin, sess),
       defaults: { readonlyDefault: cfg.readonlyDefault, tmuxBin: cfg.tmuxBin },
+      ptyGrace,
       onAttach: (sess) => attachedWs.set(ws, sess),
+      diagnostics,
+      dropCounter: wsDropCounter,
     });
     ws.on('close', () => attachedWs.delete(ws));
   });