@mmmbuto/nexuscrew 0.9.40 → 0.9.42

package/lib/fleet/prompt-delivery.js

@@ -190,8 +190,9 @@ async function deliverBootstrapPrompt(opts = {}) {
   const readyWaitMs = clampInt(opts.readyWaitMs, 15000, 0, 120000);
   const pollMs = clampInt(opts.pollMs, 400, 50, 5000);
   const settleMs = clampInt(opts.settleMs, 150, 0, 5000);
-  const done = (delivered, state, notReady, attempts) => ({
+  const done = (delivered, state, notReady, attempts, mcp) => ({
     delivered, state, notReady, attempts, reason: state,
+    ...(mcp ? { mcp } : {}),
   });
   if (!promptCharsOk(prompt)) return done(false, 'prompt-rejected', '', 0);
 
@@ -217,6 +218,25 @@ async function deliverBootstrapPrompt(opts = {}) {
     await sleepImpl(pollMs);
   }
 
+  // (1b) Gate readiness MCP opzionale (solo claude.*): la mcpWait e'
+  // fornita dal supervisore, con deadline ASSOLUTA composta sullo stesso
+  // orologio del launch (tetto MCP dal budget approvato, mai un budget nuovo a
+  // valle). Il composer pronto resta SEMPRE obbligatorio: qui si arriva solo
+  // col pane ready. A budget esaurito senza MCP pronti la consegna prosegue
+  // come AVVIO DEGRADATO VISIBILE: esito submitted/degraded con l'elenco
+  // bounded dei server failed/pending, mai un lancio silenzioso.
+  let mcp = null;
+  if (typeof opts.mcpWait === 'function') {
+    const r = await opts.mcpWait({ isCancelled: cancelled });
+    if (cancelled() || !r || r.cancelled) return done(false, 'cancelled', '', 0);
+    mcp = {
+      state: r.state === 'ready' ? 'ready' : 'degraded',
+      ready: Array.isArray(r.ready) ? r.ready : [],
+      failed: Array.isArray(r.failed) ? r.failed : [],
+      pending: Array.isArray(r.pending) ? r.pending : [],
+    };
+  }
+
   // (2) Consegna AT-MOST-ONCE: un solo paste per generazione. Il retry copre
   // SOLO fallimenti certi pre-paste (resolve/load); dopo qualsiasi tentativo
   // Di paste-buffer non esiste retry automatico.
@@ -239,32 +259,54 @@ async function deliverBootstrapPrompt(opts = {}) {
       if (paneAgain !== stage.paneId) return done(false, 'delivery-unknown', '', attempts);
       if (cancelled()) return done(false, 'delivery-unknown', '', attempts);
       const enter = await exec(tmuxBin, ['send-keys', '-t', stage.paneId, 'Enter'], { env });
-      if (enter.err) return done(false, 'staged-not-submitted', '', attempts);
+      if (enter.err) return done(false, 'staged-not-submitted', '', attempts, mcp);
       // Cancel con Enter appena partito -> la generazione e' morta con un
       // submit in volo: esito incerto (residuo PTY possibile), mai 'submitted'.
       if (cancelled()) return done(false, 'delivery-unknown', '', attempts);
-      return done(true, 'submitted', '', attempts);
+      return done(true, 'submitted', '', attempts, mcp);
     }
     if (stage.stage === 'paste' || stage.stage === 'validate') {
       // Paste tentato (esito incerto) o input rifiutato: zero secondo paste.
-      return done(false, stage.stage === 'validate' ? 'prompt-rejected' : 'delivery-unknown', '', attempts);
+      return done(false, stage.stage === 'validate' ? 'prompt-rejected' : 'delivery-unknown', '', attempts, mcp);
     }
-    if (attempts >= 2) return done(false, 'failed-pre-paste', '', attempts);
+    if (attempts >= 2) return done(false, 'failed-pre-paste', '', attempts, mcp);
     // Fallimento certo PRE-paste: un solo retry, readiness riverificata prima.
     await sleepImpl(pollMs);
     if (cancelled()) return done(false, 'cancelled', '', attempts);
     const text = await capture();
     const again = text === null ? 'unknown' : classifyPane(text, client);
-    if (again !== 'ready') return done(false, 'failed-pre-paste', '', attempts);
+    if (again !== 'ready') return done(false, 'failed-pre-paste', '', attempts, mcp);
   }
 }
 
 // WaitDeliveryReport(tmuxBin, target, opts) -> delivery-like null.
 // Il launcher supervisionato (cell-exec) e' l'UNICO owner della consegna per
-// TUTTE le generazioni degli engine Kimi e pubblica l'esito bounded sull'
-// opzione tmux di pane @nc_delivery ('<state>' o '<state>:<notReady>', solo
-// enum chiusi; muore col pane, nessuno state file). up() la legge con attesa
-// bounded: niente paste dal runtime, niente doppio writer cross-generation.
+// TUTTE le generazioni degli engine Kimi e claude.* e pubblica l'esito bounded
+// sull'opzione tmux di pane @nc_delivery ('<state>' / '<state>:<notReady>' /
+// '<state>:<notReady>:mcp<state>' dal 0.9.41, solo enum chiusi; muore col
+// pane, nessuno state file). Con degrado MCP l'elenco bounded dei server
+// failed/pending viaggia su @nc_mcp_list ('failed=a,b|pending=c', nomi
+// validati). up() la legge con attesa bounded: niente paste dal runtime,
+// niente doppio writer cross-generation.
+const MCP_REPORT_STATES = Object.freeze(['ready', 'degraded']);
+const MCP_NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
+
+function parseMcpListOption(raw) {
+  const out = { failed: [], pending: [] };
+  const text = typeof raw === 'string' ? raw.trim() : '';
+  if (!text) return out;
+  for (const part of text.split('|')) {
+    const eq = part.indexOf('=');
+    if (eq <= 0) continue;
+    const kind = part.slice(0, eq);
+    if (kind !== 'failed' && kind !== 'pending') continue;
+    for (const nome of part.slice(eq + 1).split(',')) {
+      if (nome && MCP_NAME_RE.test(nome) && !out[kind].includes(nome)) out[kind].push(nome);
+    }
+  }
+  return out;
+}
+
 async function waitDeliveryReport(tmuxBin, target, { env, exec, sleepImpl, nowImpl, timeoutMs, pollMs } = {}) {
   const run = exec || tmuxExec;
   const sleepFn = sleepImpl || sleep;
@@ -277,13 +319,24 @@ async function waitDeliveryReport(tmuxBin, target, { env, exec, sleepImpl, nowIm
       { env, timeoutMs: 2000 });
     const raw = r.err ? '' : r.stdout.trim();
     if (raw) {
-      const [state, notReady = ''] = raw.split(':');
+      const [state, notReady = '', mcpTag = ''] = raw.split(':');
       if (!DELIVERY_STATES.includes(state)) return null;   // valore non bounded: mai fidarsi
       const kind = PANE_STATES.includes(notReady) ? notReady : '';
+      const mcpState = mcpTag.startsWith('mcp') && MCP_REPORT_STATES.includes(mcpTag.slice(3))
+        ? mcpTag.slice(3) : '';
+      let mcp = null;
+      if (mcpState) {
+        const r2 = await run(tmuxBin,
+          ['display-message', '-p', '-t', target, '#{@nc_mcp_list}'],
+          { env, timeoutMs: 2000 });
+        const { failed, pending } = parseMcpListOption(r2.err ? '' : r2.stdout);
+        mcp = { state: mcpState, ready: [], failed, pending };
+      }
       return {
         delivered: state === 'submitted',
         state, notReady: state === 'skipped-not-ready' ? kind : '',
         attempts: 0, reason: state,
+        ...(mcp ? { mcp } : {}),
       };
     }
     if (now() >= deadline) return null;
@@ -318,6 +371,6 @@ function actionRequiredFor(client, provider, delivery) {
 }
 
 module.exports = {
-  PANE_STATES, DELIVERY_STATES, ACTION_CODES, RECOVERY_SLUGS,
+  PANE_STATES, DELIVERY_STATES, ACTION_CODES, RECOVERY_SLUGS, MCP_REPORT_STATES, parseMcpListOption,
   classifyPane, deliverBootstrapPrompt, waitDeliveryReport, actionRequiredFor, vlPaneReadiness,
 };

package/lib/fleet/runtime.js

@@ -17,10 +17,13 @@ const crypto = require('node:crypto');
 const {
   loadDefinitions, validateCommandTrust, resolveCwd,
 } = require('./definitions.js');
+const aiDesktop = require('./ai-desktop.js');
 const {
   describeManaged, resolveManagedEngine, discoverOllamaModels, discoverPiModels, extraModelsFrom,
+  knownMcpServerNames,
 } = require('./managed.js');
 const { sharedProbe: defaultEndpointProbe } = require('./endpoint-probe.js');
+const { NC_SUPERVISOR_OPT } = require('../tmux/supervisor-pane.js');
 const {
   httpError, minimalEnv, tmuxExec,
   composeClientInvocation, alternateScreenArgs,
@@ -29,6 +32,55 @@ const {
 } = require('./launch.js');
 const { waitDeliveryReport, actionRequiredFor, vlPaneReadiness } = require('./prompt-delivery.js');
 
+// Insieme MCP MATERIALIZZATO della cella — le chiavi del file che
+// writeCellMcpConfig (managed.js) scrive PRIMA dello spawn. Un server non
+// concesso non esiste per il launch, quindi non e' atteso dal gate.
+const MCP_BUDGET_DEFAULT_MS = 20000; // tetto approvato per il gate MCP
+
+function cellMcpExpectedServers(home, cellId) {
+  const fs = require('node:fs');
+  try {
+    const p = path.join(home, '.nexuscrew', 'cell-mcp', `${cellId}.json`);
+    const st = fs.lstatSync(p);
+    if (st.isSymbolicLink() || !st.isFile()) return [];
+    const parsed = JSON.parse(fs.readFileSync(p, 'utf8'));
+    const servers = parsed && typeof parsed === 'object' && parsed.mcpServers
+      && typeof parsed.mcpServers === 'object' && !Array.isArray(parsed.mcpServers)
+      ? parsed.mcpServers : null;
+    return servers ? Object.keys(servers).sort() : [];
+  } catch (_) { return []; }
+}
+
+// Celle claude LEGACY (nessun materializzato cell-mcp): l'atteso e' la config
+// nota al client (le tre sorgenti di `knownMcpServerNames`) meno cio' che la
+// cella nega con `cell.mcp`. RESIDUO DICHIARATO: plugin, connettori e
+// configurazione gestita di sistema non sono enumerabili e restano fuori
+// dall'atteso — il gate copre cio' che e' enumerabile, mai promette il totale.
+function legacyMcpExpectedServers(home, cwd, cell) {
+  const noti = [...(knownMcpServerNames(home, cwd) || [])];
+  if (!noti.length) return [];
+  const voluti = cell && Array.isArray(cell.mcp) ? cell.mcp : null;
+  if (voluti === null) return [...noti].sort();
+  const concessi = new Set(voluti.filter((n) => typeof n === 'string'));
+  return [...noti].filter((n) => concessi.has(n)).sort();
+}
+
+// Payload readiness per il supervisore: cwd reale della cella + attese + tetto
+// MCP. Priorita' all'insieme MATERIALIZZATO (cell-mcp); per le claude legacy
+// ricade sulla config nota meno i negati. undefined quando la cella non ha
+// server attesi (niente gate: consegna come kimi, che da 0.8.47 non ha gate).
+function buildMcpReadinessPayload(cell, realCwd, home, cfg) {
+  const expectedServers = cellMcpExpectedServers(home, cell.id).length
+    ? cellMcpExpectedServers(home, cell.id)
+    : legacyMcpExpectedServers(home, realCwd, cell);
+  if (!expectedServers.length) return undefined;
+  return {
+    cwd: realCwd,
+    expectedServers,
+    budgetMs: Math.max(0, Math.min(120000, Number(cfg && cfg.mcpReadyBudgetMs) || MCP_BUDGET_DEFAULT_MS)),
+  };
+}
+
 // TTL della cache status (ms): scaduto, status rilegge tmux + defs da disco.
 const STATUS_TTL_MS = 2000;
 
@@ -127,7 +179,12 @@ function createBuiltinRuntime(ctx) {
       // engineDef gia' usata sopra per la permission policy: un valore
       // presente qui e' gia' passato da validPanelUrl a monte (parseEngine/
       // parseCell), quindi si copia, non si ri-valida.
-      const panelUrl = c.panelUrl || engineDef?.panelUrl || '';
+      // La spunta del desktop grafico taglia qui il pannello del container
+      // quando è esplicitamente OFF: il campo non esce dallo stato, quindi il
+      // tasto e la sorgente Pannello spariscono da OGNI superficie senza un
+      // if nel frontend. Solo la chiave esplicita comanda: qui non si
+      // interroga mai docker (percorso caldo a polling).
+      const panelUrl = aiDesktop.pubblicaPanelUrlCaldo(c.panelUrl || engineDef?.panelUrl || '');
       return {
         // `cell` resta l'id: e' la chiave di indirizzamento. `label` e' il nome
         // leggibile e viaggia accanto, senza mai sostituirlo.
@@ -239,9 +296,48 @@ function createBuiltinRuntime(ctx) {
     if (!cell) throw httpError(400, `cella sconosciuta: ${cellId}`);
     const engine = findEngine(defs, cell.engine);
     if (!engine) throw httpError(400, `engine dangling per cella ${cellId}: ${cell.engine}`);
+    // (0) Una cella GIA' VIVA non si rilancia — e soprattutto non si risolve.
+    // Senza questo controllo l'ordine era: si risolve lo spec (che PUBBLICA la
+    // generazione di attivita', managed.js:1696), si chiede il ticket, e solo
+    // alla new-session si scopre che la sessione esiste gia' -> 409. Il file
+    // `activity.gen` restava pero' riscritto con una generazione nuova, mentre
+    // gli hook del lancio vero portano quella vecchia: lo stato di quella cella
+    // veniva scartato (files/activity.js:336-338) e la UI diceva «non
+    // verificata» su una cella che stava lavorando. Lo pagava qualunque `up` su
+    // una cella viva: l'operatore dalla UI, e `fleet-boot` all'avvio del
+    // servizio, che cicla TUTTE le celle boot:true e su quelle gia' in
+    // esecuzione si limitava a saltare (boot.js:49) — dopo aver riscritto il
+    // file.
+    // Il 409 in fondo (new-session) resta come rete per la corsa fra questo
+    // controllo e la creazione della sessione.
+    const vive = await refreshSessions();
+    if (vive.has(String(cell.tmuxSession))) {
+      throw httpError(409, 'sessione già in esecuzione', null,
+        { phase: 'preflight', code: 'SESSION_DUPLICATE' });
+    }
     let launchEngine = engine;
+    // Canale di attivita' della cella: `resolved` vive solo dentro il ramo
+    // managed, e il payload del broker si costruisce FUORI. Portarlo fuori con
+    // una variabile dichiarata qui evita di usare, in un ramo, un nome
+    // dichiarato in un altro: un errore che in produzione fa fallire il lancio
+    // di ogni cella, non una sola asserzione.
+    let activityCanale = null;
     if (engine.managed) {
-      const resolved = resolveManagedEngine(engine, cell, { ...cfg, home, extraModels: extraModelsFrom(defs), capabilityProfiles: defs.capabilityProfiles || null });
+      // Generazione del lancio: identifica QUESTA partenza della cella. Uno
+      // stato di attivita' che ne porta un'altra appartiene a un lancio
+      // precedente e viene scartato — una cella riavviata non eredita il
+      // «lavora» di prima.
+      const generazione = crypto.randomBytes(8).toString('hex');
+      const resolved = resolveManagedEngine(engine, cell, {
+        ...cfg, home, extraModels: extraModelsFrom(defs),
+        capabilityProfiles: defs.capabilityProfiles || null,
+        activityGeneration: generazione,
+        // La generazione NON si scrive qui: viaggia negli argv degli hook e nel
+        // payload del broker, e a scriverla su disco e' `cell-exec`, dentro la
+        // sessione che tmux ha appena creato — quindi solo per chi vince la
+        // new-session. Chi perde la corsa scriverebbe una generazione che non e'
+        // quella di nessun lancio vivo.
+      });
       // Il materializzatore MCP per cella e' FAIL-CLOSED: se il file per cella
       // non si scrive, la cella non parte — mai con la superficie intera dove
       // l'operatore l'ha ristretta.
@@ -253,6 +349,10 @@ function createBuiltinRuntime(ctx) {
         throw httpError(400, `engine managed non configurato (${engine.id}): ${resolved.reason}`, null, { phase: 'preflight', code });
       }
       launchEngine = resolved.engine;
+      // Qui si porta FUORI dal ramo il solo dato che serve al payload: dove e
+      // con quale generazione il supervisore dovra' PUBBLICARLA su disco e
+      // dichiarare l'uscita del client.
+      if (resolved.activityDir) activityCanale = { dir: resolved.activityDir, generation: generazione };
       // A vl cell whose runtime cannot hold the per-cell prompt
       // (VL_SYSTEM_APPEND_FILE, 0.3.1+) DEGRADES by declaring it — same
       // shape as readinessDegraded: the cell starts without its own identity
@@ -327,6 +427,13 @@ function createBuiltinRuntime(ctx) {
         ...(typeof launchEngine.identityChannel === 'boolean'
           ? { identityChannel: launchEngine.identityChannel } : {}),
         ...(leaseInfo ? { lease: { cellId: cell.id, launchEpoch: leaseInfo.launchEpoch, stablePath: leaseInfo.stablePath } } : {}),
+        // Canale di attivita' verso il supervisore: il riavvio del client
+        // avviene DENTRO lo stesso lancio, quindi la generazione non cambia e
+        // l'unico modo di invalidare lo stato del client morto e' che sia
+        // cell-exec a dichiararlo. Presente solo dove gli hook sono davvero
+        // iniettati (`activityDir` lo dice): senza canale non c'e' niente da
+        // invalidare.
+        ...(activityCanale ? { activity: activityCanale } : {}),
         supervise: {
           enabled: !launchEngine.shellOneShot,
           initialReadyMs: Math.max(50, Math.min(30000, Number(readyMs) || 500)),
@@ -342,12 +449,17 @@ function createBuiltinRuntime(ctx) {
             tmuxSession: cell.tmuxSession,
             prompt: cell.prompt,
             readyMs: Math.max(0, Math.min(30000, Number(cfg.sendKeysReadyMs) || readyMs)),
-            // Solo gli engine managed Kimi (kimi.native / claude.kimi-code) hanno
-            // la delivery classificata at-most-once ai restart; gli engine custom
-            // Send-keys conservano il reinject legacy senza Enter (0.8.47).
-            client: engine.managed && engine.managed.client === 'kimi' ? 'kimi'
-              : (engine.managed && engine.managed.provider === 'kimi-code' ? 'claude' : ''),
+            // kimi.* e TUTTE le claude.* hanno la delivery classificata
+            // at-most-once ai restart; gli engine custom send-keys conservano
+            // il reinject legacy senza Enter (0.8.47).
+            client: engine.managed && (engine.managed.client === 'kimi' || engine.managed.client === 'claude')
+              ? engine.managed.client : '',
             readyWaitMs: Math.max(0, Math.min(120000, Number(cfg.bootstrapReadyWaitMs) || 15000)),
+            // Gate readiness MCP solo per le claude.* (budget composto col
+            // readyWaitMs: tetto MCP dal launch, avvio degradato visibile).
+            ...(engine.managed && engine.managed.client === 'claude' ? {
+              mcpReadiness: buildMcpReadinessPayload(cell, realCwd, home, cfg),
+            } : {}),
           },
         } : {}),
       });
@@ -398,6 +510,26 @@ function createBuiltinRuntime(ctx) {
       throw httpError(dup ? 409 : 500, why, null,
         { phase: 'new-session', code: dup ? 'SESSION_DUPLICATE' : 'NEW_SESSION_FAILED' });
     }
+    // Il pane del SUPERVISORE si marca ORA, sul pane che esegue cell-exec: e'
+    // l'identita' stabile della cella viva. Il server cerca questo marcatore
+    // (`list-panes`) perche' `#{pane_dead}` di list-sessions riguarda il pane
+    // ATTIVO — con una seconda finestra viva selezionata direbbe «vivo» anche
+    // con il supervisore morto. L'id ce l'abbiamo gia' da `-P -F` (sotto), non
+    // serve una ricerca. Best effort come le opzioni che seguono: un tmux che
+    // non accetta l'opzione non deve impedire l'avvio — la cella resta senza
+    // marcatore, e per lei il server dira' «non verificato» invece di leggere
+    // uno stato di cui non sa identificare il supervisore.
+    const idPaneLancio = /^%[0-9]+$/.test((create.stdout.trim().split('\n')[0] || '').split('\t')[2] || '')
+      ? (create.stdout.trim().split('\n')[0] || '').split('\t')[2] : '';
+    if (idPaneLancio) {
+      const marcato = await tmuxExec(tmuxBin,
+        ['set-option', '-p', '-t', idPaneLancio, NC_SUPERVISOR_OPT, '1'],
+        { env: minimalEnv(), timeoutMs: 2000 });
+      if (marcato.err) {
+        const log = typeof cfg.log === 'function' ? cfg.log : console.warn;
+        log(`fleet marcatore del pane supervisore non impostato per ${cell.id}; la cella resta non identificabile`);
+      }
+    }
     // Best effort per la sola sessione appena creata: non tocchiamo mai
     // ~/.tmux.conf, opzioni globali o sessioni preesistenti. Un tmux che non
     // accetta una delle opzioni non deve impedire l'avvio della cella.
@@ -557,14 +689,20 @@ function createBuiltinRuntime(ctx) {
     // Paste SENZA Enter, contratto invariato —), target %N esatto.
     let prompt = null;
     let actionRequired = null;
+    let mcpDegraded = null;
     if (launchEngine.promptMode === 'send-keys' && cell.prompt) {
       const managedClient = engine.managed && typeof engine.managed.client === 'string' ? engine.managed.client : '';
       const managedProvider = engine.managed && typeof engine.managed.provider === 'string' ? engine.managed.provider : '';
-      const classified = managedClient === 'kimi' || managedProvider === 'kimi-code';
+      const classified = managedClient === 'kimi' || managedClient === 'claude';
       if (classified) {
         const readyWaitMs = Math.max(0, Math.min(120000, Number(cfg.bootstrapReadyWaitMs) || 15000));
+        // Budget unico composto — il report copre anche il tetto MCP del
+        // gate (l'attesa MCP consuma lo stesso orologio del launch).
+        const mcpBudgetMs = managedClient === 'claude'
+          ? Math.max(0, Math.min(120000, Number(cfg.mcpReadyBudgetMs) || MCP_BUDGET_DEFAULT_MS))
+          : 0;
         const reportWaitMs = Math.max(100, Math.min(150000,
-          (Number(cfg.sendKeysReadyMs) || readyMs) + readyWaitMs + 2000));
+          (Number(cfg.sendKeysReadyMs) || readyMs) + readyWaitMs + mcpBudgetMs + 2000));
         const report = await waitDeliveryReport(tmuxBin,
           paneId.startsWith('%') ? paneId : `=${cell.tmuxSession}`,
           { env: minimalEnv(), timeoutMs: reportWaitMs });
@@ -576,8 +714,17 @@ function createBuiltinRuntime(ctx) {
           delivered: delivery.delivered,
           state: delivery.state,
           reason: delivery.reason,
+          ...(delivery.mcp ? { mcp: delivery.mcp } : {}),
         };
         actionRequired = actionRequiredFor(managedClient, managedProvider, delivery);
+        // Avvio degradato visibile: l'elenco bounded dei server MCP non pronti
+        // sale alla UI con il flag esistente readinessDegraded.
+        if (delivery.mcp && delivery.mcp.state === 'degraded') {
+          mcpDegraded = {
+            failed: Array.isArray(delivery.mcp.failed) ? delivery.mcp.failed : [],
+            pending: Array.isArray(delivery.mcp.pending) ? delivery.mcp.pending : [],
+          };
+        }
       } else {
         const target = paneId.startsWith('%') ? paneId : `=${cell.tmuxSession}`;
         prompt = await injectPrompt(tmuxBin, cell.tmuxSession, cell.prompt, {
@@ -593,6 +740,7 @@ function createBuiltinRuntime(ctx) {
       ok: true, cell: cellId, session: cell.tmuxSession, prompt,
       ...(actionRequired ? { actionRequired } : {}),
       ...(readinessDegraded ? { readinessDegraded: true } : {}),
+      ...(mcpDegraded ? { readinessDegraded: true, mcpDegraded } : {}),
       // Per-cell prompt not delivered to a vl cell (old runtime or
       // unwritable file). Strict boolean like readinessDegraded: the
       // payload may come from a federated node and the text is local i18n.
@@ -630,4 +778,4 @@ function createBuiltinRuntime(ctx) {
   };
 }
 
-module.exports = { createBuiltinRuntime, findCell, findEngine, identityLaunchRefusal, STATUS_TTL_MS };
+module.exports = { createBuiltinRuntime, findCell, findEngine, identityLaunchRefusal, STATUS_TTL_MS, buildMcpReadinessPayload, cellMcpExpectedServers };

package/lib/notify/ask-relay.js

@@ -14,23 +14,66 @@
 // refused locally until verification resolves the attempt.
 
 const crypto = require('node:crypto');
+const { probeReverseSlot } = require('../nodes/reverse-slot-proof.js');
 const IDLE_MS = 15000;
 
-function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = () => {} } = {}) {
+function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = () => {}, probeReverseSlotImpl = probeReverseSlot } = {}) {
   // (ownerId|askId|requestId) -> {state: 'sent'|'committed'|'failed'|'uncertain', requestId}
   const attempts = new Map();
 
   function requestId() { return crypto.randomUUID(); }
 
-  function resolveOwner(ownerId) {
+  // Risoluzione del produttore: peer OUTBOUND (canale proprio, come sempre)
+  // oppure peer INBOUND condiviso con consenso eventi+risposta e slot reverse
+  // attivo. Per gli inbound la porta dello slot DEVE essere verificata con la
+  // stessa sonda dei terminali (secret del peer + instanceId atteso): nessun
+  // fallback sulla localPort senza proof.
+  function candidateOwner(ownerId) {
     const store = loadStore();
     if (!store) return null;
-    return (store.nodes || []).find((n) => n && n.direction === 'outbound'
-      && n.nodeId === ownerId && n.token && n.localPort) || null;
+    const nodes = store.nodes || [];
+    const out = nodes.find((n) => n && n.direction === 'outbound'
+      && n.nodeId === ownerId && n.token && n.localPort);
+    if (out) return { node: out, forwardPort: out.localPort, forwardToken: out.token, kind: 'outbound' };
+    const inbound = nodes.find((n) => n && n.direction === 'inbound'
+      && n.shared === true && n.nodeId === ownerId
+      && (n.token || n.acceptToken)
+      && n.askReplyAccess === true && n.eventsAccess === true
+      && n.cellVisibility !== 'none');
+    if (!inbound) return null;
+    const forwardToken = inbound.token || inbound.acceptToken;
+    const pool = inbound.reversePool;
+    const slot = pool && Array.isArray(pool.slots) ? pool.slots[pool.activeSlot] : null;
+    if (!slot || !Number.isInteger(slot.port)) {
+      return { node: inbound, forwardPort: null, forwardToken, kind: 'inbound-unverified' };
+    }
+    return { node: inbound, forwardPort: slot.port, forwardToken, kind: 'inbound' };
+  }
+
+  function ownerUrl(port, path) {
+    return `http://127.0.0.1:${port}/federation/route/_/${path.replace(/^\//, '')}`;
   }
 
-  function ownerUrl(peer, path) {
-    return `http://127.0.0.1:${peer.localPort}/federation/route/_/${path.replace(/^\//, '')}`;
+  // Preflight del canale reverse per un peer inbound: rifiuto NETTO se lo slot
+  // non e' verificato (non e' un esito incerto: il forward non e' mai partito).
+  async function verifyInboundChannel(candidate) {
+    const { node, forwardPort } = candidate;
+    const pool = node.reversePool;
+    const slot = pool && Array.isArray(pool.slots) ? pool.slots[pool.activeSlot] : null;
+    const proof = await probeReverseSlotImpl({
+      port: forwardPort, secret: node.token,
+      expected: {
+        remotePort: forwardPort,
+        generation: pool && Number.isInteger(pool.activeGeneration) ? pool.activeGeneration : undefined,
+        instanceId: node.nodeId,
+      },
+    });
+    if (proof && proof.owned === true) return { ok: true };
+    return {
+      ok: false, code: 404,
+      error: 'canale reverse non verificato: risposta non inoltrata',
+      reason: 'reverse-slot-unverified',
+    };
   }
 
   function attemptKey(ownerId, askId, rid) { return `${ownerId}|${askId}|${rid}`; }
@@ -47,16 +90,35 @@ function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = ()
     return statusFor(ownerId, askId).some((a) => a.state === 'uncertain');
   }
 
+  // Il blocco precedente rifiuta il nuovo requestId PRIMA di creare la sua
+  // ricevuta: la sola verifica possibile e' sull'ID originale ancora 'sent'
+  // (se esiste), altrimenti resta solo la riconciliazione con l'owner.
+  function originalSentRequestId(ownerId, askId, excludeRid) {
+    const sent = statusFor(ownerId, askId)
+      .filter((a) => (a.state === 'sent' || a.state === 'uncertain') && a.requestId !== excludeRid);
+    return sent.length ? sent[sent.length - 1].requestId : null;
+  }
+
   async function relayAnswer({ ownerId, askId, text, rid: providedRid } = {}) {
     if (!ownerId || !askId || typeof text !== 'string' || !text.trim()) {
       return { ok: false, code: 400, error: 'ownerId, askId e text richiesti' };
     }
-    const peer = resolveOwner(ownerId);
-    if (!peer) return { ok: false, code: 404, error: 'owner non tra i peer autorizzati', reason: 'owner-unknown' };
+    const candidate = candidateOwner(ownerId);
+    if (!candidate) return { ok: false, code: 404, error: 'owner non tra i peer autorizzati', reason: 'owner-unknown' };
+    if (candidate.kind === 'inbound-unverified') {
+      return { ok: false, code: 404, error: 'canale reverse non verificato: risposta non inoltrata', reason: 'reverse-slot-unverified' };
+    }
+    if (candidate.kind === 'inbound') {
+      const gate = await verifyInboundChannel(candidate);
+      if (!gate.ok) return { ok: false, code: gate.code, error: gate.error, reason: gate.reason };
+    }
+    const peer = candidate.node;
     // Local reconciliation FIRST: an uncertain attempt on this ask must be
     // verified before any new paste leaves this node.
     if (isUncertain(ownerId, askId)) {
-      return { ok: false, code: 409, error: 'esito incerto: verifica lo stato prima di rispondere', reason: 'uncertain', uncertain: true };
+      // L'ID originale e' quello verificabile: il nuovo invio non e' mai partito.
+      return { ok: false, code: 409, error: 'esito incerto: verifica lo stato prima di rispondere', reason: 'uncertain', uncertain: true,
+        originalRequestId: originalSentRequestId(ownerId, askId) };
     }
     const rid = providedRid || requestId();
     const key = attemptKey(ownerId, askId, rid);
@@ -65,10 +127,10 @@ function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = ()
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(), IDLE_MS);
     try {
-      const r = await fetchImpl(ownerUrl(peer, `/event-feed/asks/${askId}/answer`), {
+      const r = await fetchImpl(ownerUrl(candidate.forwardPort, `/event-feed/asks/${askId}/answer`), {
         method: 'POST',
         headers: {
-          authorization: `Bearer ${peer.token}`,
+          authorization: `Bearer ${candidate.forwardToken}`,
           'content-type': 'application/json',
           'x-nexuscrew-visited': store.nodeId,
         },
@@ -86,6 +148,13 @@ function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = ()
       // could have pasted (timeout-ish) parks as uncertain, never retried.
       if (r.status === 409) {
         if (entry) entry.state = body.reason === 'delivery-unknown-block' ? 'uncertain' : 'failed';
+        if (body.reason === 'delivery-unknown-block') {
+          // Stesso contratto del ramo 502: la UI riceve 200+uncertain e non
+          // ripete mai il paste. La verifica possibile e' sull'ID originale.
+          return { ok: false, code: 200, uncertain: true, reason: body.reason,
+            originalRequestId: originalSentRequestId(ownerId, askId, rid), requestId: rid,
+            error: 'esito incerto: bloccato da un invio precedente' };
+        }
         return { ok: false, code: 409, error: body.error || 'conflict', reason: body.reason };
       }
       if (r.status === 502) {
@@ -108,13 +177,21 @@ function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = ()
 
   // Remote dismiss: same resolution rules as the answer (DELETE on the owner).
   async function relayDismiss({ ownerId, askId } = {}) {
-    const peer = resolveOwner(ownerId);
-    if (!peer) return { ok: false, code: 404, error: 'owner non tra i peer autorizzati' };
+    const candidate = candidateOwner(ownerId);
+    if (!candidate) return { ok: false, code: 404, error: 'owner non tra i peer autorizzati', reason: 'owner-unknown' };
+    if (candidate.kind === 'inbound-unverified') {
+      return { ok: false, code: 404, error: 'canale reverse non verificato: risposta non inoltrata', reason: 'reverse-slot-unverified' };
+    }
+    if (candidate.kind === 'inbound') {
+      const gate = await verifyInboundChannel(candidate);
+      if (!gate.ok) return { ok: false, code: gate.code, error: gate.error, reason: gate.reason };
+    }
+    const peer = candidate.node;
     const store = loadStore();
     try {
-      const r = await fetchImpl(ownerUrl(peer, `/event-feed/asks/${askId}`), {
+      const r = await fetchImpl(ownerUrl(candidate.forwardPort, `/event-feed/asks/${askId}`), {
         method: 'DELETE',
-        headers: { authorization: `Bearer ${peer.token}`, 'x-nexuscrew-visited': store ? store.nodeId : '' },
+        headers: { authorization: `Bearer ${candidate.forwardToken}`, 'x-nexuscrew-visited': store ? store.nodeId : '' },
       });
       const body = await r.json().catch(() => ({}));
       if (!r.ok) return { ok: false, code: r.status, error: body.error || `HTTP ${r.status}` };
@@ -123,12 +200,20 @@ function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = ()
   }
 
   async function verifyStatus({ ownerId, askId, requestId: rid }) {
-    const peer = resolveOwner(ownerId);
-    if (!peer) return { ok: false, code: 404, error: 'owner non tra i peer autorizzati' };
+    const candidate = candidateOwner(ownerId);
+    if (!candidate) return { ok: false, code: 404, error: 'owner non tra i peer autorizzati', reason: 'owner-unknown' };
+    if (candidate.kind === 'inbound-unverified') {
+      return { ok: false, code: 404, error: 'canale reverse non verificato: risposta non inoltrata', reason: 'reverse-slot-unverified' };
+    }
+    if (candidate.kind === 'inbound') {
+      const gate = await verifyInboundChannel(candidate);
+      if (!gate.ok) return { ok: false, code: gate.code, error: gate.error, reason: gate.reason };
+    }
+    const peer = candidate.node;
     const store = loadStore();
     try {
-      const r = await fetchImpl(ownerUrl(peer, `/event-feed/asks/${askId}/requests/${rid}`), {
-        headers: { authorization: `Bearer ${peer.token}`, 'x-nexuscrew-visited': store ? store.nodeId : '' },
+      const r = await fetchImpl(ownerUrl(candidate.forwardPort, `/event-feed/asks/${askId}/requests/${rid}`), {
+        headers: { authorization: `Bearer ${candidate.forwardToken}`, 'x-nexuscrew-visited': store ? store.nodeId : '' },
       });
       if (!r.ok) return { ok: false, code: r.status };
       const body = await r.json();

package/lib/proxy/panel-proxy.js

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