@mmmbuto/nexuscrew 0.9.33 → 0.9.34

package/frontend/dist/index.html

@@ -11,7 +11,7 @@
   <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-Uco-EbNb.js"></script>
+  <script type="module" crossorigin src="/assets/index-5eCvm3HF.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-DqCfZFGi.css">
 </head>
 <body>

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.9.33"}
+{"version":"0.9.34"}

package/lib/fleet/builtin.js

@@ -34,11 +34,12 @@ const {
   aggiornaDefinizioni,
   cellIdFromTmuxSession,
   resolveCwd, normalizeCwdRel, deriveCwdRel,
+  effectiveCapabilities,
 } = require('./definitions.js');
 const {
   publicCatalog, describeManaged, describeCatalogCredential, defaultShellEngine, defaultAgyEngine, defaultKimiEngine, defaultGrokEngine, defaultVlEngine,
   CATALOG, credential: resolveProfileCredential, extraModelsFrom, knownMcpServerNames, profileFor,
-  normalizeManagedSpec,
+  normalizeManagedSpec, codexSurfaceNames,
 } = require('./managed.js');
 const { probeModel, probeCustomEndpoint } = require('./model-probe.js');
 const { sharedProbe: defaultEndpointProbe } = require('./endpoint-probe.js');
@@ -1369,6 +1370,43 @@ async function createBuiltinFleet(cfg = {}) {
           ...(c.permissionPolicies ? { permissionPolicies: { ...c.permissionPolicies } } : {}),
           ...(c.commands ? { commands: { ...c.commands } } : {}),
         };
+        // Superficie dichiarata (solo vista): una cella LEGACY (niente
+        // capabilities, niente profilo) e' la cella di sempre — esce con
+        // `legacy: true` e nessun campo capabilities; una cella dichiarata
+        // esce con la fusione profilo+override (sostitutivo per chiave) e con
+        // le chiavi che il materializzatore NON copre per il suo engine
+        // segnate come `unsupported` (motivo leggibile, MAI un errore). Il
+        // materializzatore per engine arriva per fasi: qui la dichiarazione
+        // onesta di cosa viene davvero materializzato.
+        const eff = effectiveCapabilities(c, defs);
+        out.legacy = eff.legacy;
+        if (!eff.legacy) {
+          const client = (defs.engines.find((e) => e.id === c.engine) || {}).managed?.client || null;
+          const materializzaMcp = client === 'claude' || client === 'codex' || client === 'codex-vl';
+          const materializzaOndemand = client === 'codex' || client === 'codex-vl';
+          const nonMaterializzate = {
+            mcp: `nessun materializzatore MCP per questo engine in questa fase (client: ${client || 'sconosciuto'})`,
+            skills: 'le skill non sono ancora materializzate per cella (fase successiva)',
+            ondemand: 'la materializzazione on-demand arriva in una fase successiva',
+          };
+          const unsupported = Object.keys(eff.declared)
+            .filter((key) => !(key === 'mcp' && materializzaMcp) && !(key === 'ondemand' && materializzaOndemand))
+            .map((key) => ({ key, reason: nonMaterializzate[key] }));
+          // Per codex/codex-vl un nome ondemand che NON e' nella config utente
+          // del nodo viene ignorato dal profilo (TOML non scrive tabelle per
+          // server sconosciuti): la vista lo dice al punto, invece di farlo
+          // scoprire all'operatore quando la capability non risponde.
+          if ((client === 'codex' || client === 'codex-vl') && eff.declared.ondemand?.length) {
+            try {
+              const toml = fs.readFileSync(path.join(home, '.codex', 'config.toml'), 'utf8');
+              const noti = new Set(codexSurfaceNames(toml).servers);
+              for (const nome of eff.declared.ondemand.filter((n) => !noti.has(n))) {
+                unsupported.push({ key: 'ondemand', name: nome, reason: `il server on-demand "${nome}" non e' dichiarato nella config utente del nodo: ignorato dal profilo` });
+              }
+            } catch (_) { /* config utente non leggibile: nessuna nota, non e' un errore di vista */ }
+          }
+          out.capabilities = { declared: eff.declared, ...(unsupported.length ? { unsupported } : {}) };
+        }
         // cwdRel portatile derivato (solo vista): per celle valide (cwd reale
         // sotto home) espone il rel canonico; per celle persistite ma non
         // valide/fuori home espone needsRepair:true. NESSUNA mutazione di
@@ -1530,6 +1568,27 @@ async function createBuiltinFleet(cfg = {}) {
         // Nome leggibile, distinto dall'id: quest'ultimo resta la chiave di
         // indirizzamento e l'unica origine della sessione tmux.
         label: { type: 'string', required: false, max: CAPS.MAX_LABEL_LEN },
+        // Superficie operativa dichiarata della cella. Assenti entrambi = cella
+        // legacy (comportamento di sempre). Il profilo alimenta le chiavi che
+        // la cella non copre; l'override della cella sostituisce PER CHIAVE.
+        capabilities: {
+          type: 'object', required: false,
+          mcp: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$' },
+          skills: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-z0-9][a-z0-9._-]{0,63}$' },
+          ondemand: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-z0-9][a-z0-9._-]{0,63}$' },
+        },
+        capabilityProfile: { type: 'string', required: false, ref: 'capabilityProfiles.id', max: 32 },
+      },
+      // Profili di ruolo condivisi del documento (top-level, accanto a
+      // engines/cells): stessa forma del set di cella, referenziabili per nome.
+      capabilityProfiles: {
+        type: 'object', required: false, maxKeys: 32,
+        keyPattern: '^[A-Za-z0-9._-]{1,32}$',
+        valueShape: {
+          mcp: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$' },
+          skills: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-z0-9][a-z0-9._-]{0,63}$' },
+          ondemand: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-z0-9][a-z0-9._-]{0,63}$' },
+        },
       },
     };
   }

package/lib/fleet/causes.js

@@ -37,6 +37,9 @@ const CODES = [
   'CWD_INVALID',
   'ENGINE_UNCONFIGURED',
   'SHELL_NOT_AVAILABLE',
+  'MCP_CELL_FILE_UNWRITABLE',
+  'CAPABILITY_PROFILE_UNWRITABLE',
+  'CAPABILITY_UNKNOWN_NAME',
   // launch-broker
   'LAUNCH_BROKER_UNSAFE',
   'LAUNCH_BROKER_PAYLOAD',

package/lib/fleet/cell-exec.js

@@ -632,10 +632,10 @@ async function main(argv = process.argv.slice(2), seams = {}) {
           ? ['inherit', 'inherit', 'inherit', 'pipe', 'pipe']
           : ['inherit', 'inherit', 'inherit'],
       });
-      // R1a (fix5): exit/error del figlio contano SUBITO, prima di qualunque
-      // await — se il figlio esce durante l'handshake di generazione, l'evento
-      // non deve andare perso (prima i listener arrivavano solo con waitChild,
-      // e il supervisore restava appeso).
+      // exit/error del figlio contano SUBITO, prima di qualunque await — se
+      // il figlio esce durante l'handshake di generazione, l'evento non deve
+      // andare perso (prima i listener arrivavano solo con waitChild, e il
+      // supervisore restava appeso).
       let childSettled = false;
       const childExit = new Promise((resolve) => {
         current.once('exit', (code, signal) => {
@@ -649,16 +649,16 @@ async function main(argv = process.argv.slice(2), seams = {}) {
       });
       // Transizione di generazione comunicata al lease PRIMA di aprire il
       // canale identita' della generazione nuova. L'exit del figlio ha la
-      // precedenza sull'annuncio; FAIL-CLOSED (R1b): solo un annuncio
-      // RISOLTO con ok === true E generazione corrispondente apre il canale —
-      // ok:false (lease-down, identity-unverified), rifiuto, timeout ed exit
-      // restano tutti negativi, con sola diagnostica: il figlio parte
-      // comunque, senza identita'.
+      // precedenza sull'annuncio; fail-closed: solo un annuncio RISOLTO con
+      // ok === true E generazione corrispondente apre il canale — ok:false
+      // (lease-down, identity-unverified), rifiuto, timeout ed exit restano
+      // tutti negativi, con sola diagnostica: il figlio parte comunque,
+      // senza identita'.
       if (leaseCtl && generation > 0) {
         const raced = await Promise.race([
-          // fix 6 (R1b-bis): il valore RISOLTO va ispezionato.
-          // Prima: .then(() => 'ok', ...) scartava il valore e trattava un
-          // annuncio risolto {ok:false} come successo, aprendo il canale.
+          // Il valore RISOLTO va ispezionato: .then(() => 'ok', ...) scartava
+          // il valore e trattava un annuncio risolto {ok:false} come successo,
+          // aprendo il canale.
           leaseCtl.announceGeneration(generation).then(
             (announced) => (announced && announced.ok === true && announced.generation === generation
               ? 'ok'

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

@@ -426,10 +426,10 @@ function createLeaseManager(cfg = {}, seams = {}) {
       writeSafe(socket, { type: 'generationDeny', generation: msg.generation });
       return;
     }
-    // R1b: l'avanzamento PRIMA dell'ACK e' voluto (at-least-once): se l'ACK
-    // si perde, il client ritenta con la STESSA generazione e qui e'
-    // idempotente (== corrente -> ACK). L'ordine inverso lascerebbe il server
-    // stantio con un client che crede di aver transizionato.
+    // L'avanzamento PRIMA dell'ACK e' voluto (at-least-once): se l'ACK si
+    // perde, il client ritenta con la STESSA generazione e qui e' idempotente
+    // (== corrente -> ACK). L'ordine inverso lascerebbe il server stantio con
+    // un client che crede di aver transizionato.
     entry.lease.generation = msg.generation;
     writeSafe(socket, { type: 'generationAck', generation: msg.generation });
   }

package/lib/fleet/definitions.js

@@ -39,6 +39,18 @@ const MCP_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
 const MAX_CELL_COMMAND_LEN = 4096;
 const MAX_TMUXSESSION_LEN = 64;
 
+// Capacita' dichiarate di una cella, per NOME (come `mcp`, che ne e' il caso
+// particolare e l'alias legacy). Tre chiavi: `mcp` (server MCP), `skills`,
+// `ondemand`. Profili di ruolo condivisi in `capabilityProfiles` (top-level del
+// documento); la cella riferisce un profilo e puo' sostituire SINGOLE CHIAVI
+// con il proprio set: l'override e' sostitutivo, non additivo, perche' unire
+// non saprebbe togliere.
+const MAX_CAPABILITIES = 64;       // nomi per singola chiave
+const MAX_CAPABILITY_PROFILES = 32; // profili dichiarabili nel documento
+const CAPABILITY_KEYS = ['mcp', 'skills', 'ondemand'];
+const CAPABILITY_NAME_RE = /^[a-z0-9][a-z0-9._-]{0,63}$/;  // skill/ondemand: slug
+const CAPABILITY_KEY_RES = { mcp: MCP_NAME_RE, skills: CAPABILITY_NAME_RE, ondemand: CAPABILITY_NAME_RE };
+
 const ENGINE_ID_RE = /^[a-z0-9._-]{1,32}$/;   // engine id: lowercase (design 4a/9f)
 const CELL_ID_RE = /^[A-Za-z0-9._-]{1,32}$/;   // cell id: ammette maiuscole (il punto e' un id umano valido)
 const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/; // identificatore env POSIX-like
@@ -279,6 +291,30 @@ function parseDefinitions(raw, { allowLegacyTmuxNames = true, onReject = null, o
       engines.push(eng);
     }
 
+    // I profili di capability si leggono PRIMA delle celle: una cella riferisce
+    // un profilo per NOME, e leggerli dopo la farebbe rifiutare per un dato che
+    // in realta' c'e'. `capabilityProfiles` e' opzionale: senza, il documento
+    // resta com'era (chiave assente, non vuota).
+    let capabilityProfiles;
+    if (d.capabilityProfiles !== undefined) {
+      if (!d.capabilityProfiles || typeof d.capabilityProfiles !== 'object' || Array.isArray(d.capabilityProfiles)) return null;
+      const voci = Object.entries(d.capabilityProfiles);
+      if (voci.length > MAX_CAPABILITY_PROFILES) {
+        if (typeof onIssue === 'function') onIssue({ field: 'capabilityProfiles', value: voci.length, rule: `troppi profili di capability dichiarati, cap ${MAX_CAPABILITY_PROFILES}` });
+        return reject(`fleet.json rifiutato: ${voci.length} profili di capability dichiarati, cap ${MAX_CAPABILITY_PROFILES}; riduci i profili a ${MAX_CAPABILITY_PROFILES} o meno`);
+      }
+      capabilityProfiles = {};
+      for (const [nome, profilo] of voci) {
+        // Il nome e' un identificatore (finira' in riferimento per cella e, poi,
+        // in un nome di file generato): stessa forma chiusa dell'id cella.
+        if (typeof nome !== 'string' || !CELL_ID_RE.test(nome) || capabilityProfiles[nome] !== undefined) return null;
+        const set = parseCapabilitySet(profilo, onIssue);
+        if (!set) return null;
+        capabilityProfiles[nome] = set;
+      }
+    }
+    const capabilityProfileNames = capabilityProfiles ? new Set(Object.keys(capabilityProfiles)) : null;
+
     const tmuxSeen = new Set();
     const legacyTmuxSeen = new Set();
     const legacyTmuxSessions = new Map();
@@ -286,7 +322,7 @@ function parseDefinitions(raw, { allowLegacyTmuxNames = true, onReject = null, o
     const cells = [];
     for (const c of d.cells) {
       const cell = parseCell(c, engineIds, engineMap, {
-        allowLegacyTmuxNames, extraModels, onReject: reject, onIssue,
+        allowLegacyTmuxNames, extraModels, onReject: reject, onIssue, capabilityProfileNames,
       });
       if (!cell) return null;
       if (cellIds.has(cell.id)) return null;             // id cell univoco
@@ -301,11 +337,12 @@ function parseDefinitions(raw, { allowLegacyTmuxNames = true, onReject = null, o
       cells.push(cell);
     }
 
-    // `models` compare solo se dichiarato: una configurazione senza modelli
-    // resta byte-identica a prima, e l'aggiornamento non riscrive nulla.
-    const parsed = models.length
-      ? { schemaVersion: SCHEMA_VERSION, engines, cells, models }
-      : { schemaVersion: SCHEMA_VERSION, engines, cells };
+    // `models` e `capabilityProfiles` compaiono solo se dichiarati: una
+    // configurazione senza resta byte-identica a prima, e l'aggiornamento non
+    // riscrive nulla.
+    const parsed = { schemaVersion: SCHEMA_VERSION, engines, cells };
+    if (models.length) parsed.models = models;
+    if (capabilityProfiles) parsed.capabilityProfiles = capabilityProfiles;
     // Metadato solo in memoria: serve al bootstrap per rinominare una sessione
     // legacy PRIMA di persistere il nome safe. Non entra in JSON, draft o API.
     Object.defineProperty(parsed, 'legacyTmuxSessions', {
@@ -462,8 +499,50 @@ function cellModelAllowed(engineId, model, engineMap, extraModels, onIssue) {
   return !!normalizeManagedSpec({ ...engine.managed, model }, { extraModels, engineId, onIssue });
 }
 
+// Un set di capability (di profilo o di cella): oggetto le cui chiavi ammesse
+// sono CAPABILITY_KEYS, ciascuna un array di nomi VALIDATI PER CHIAVE, senza
+// duplicati, sotto cap. Chiave non ammessa -> rifiuto dell'intero set: come
+// per panelUrl, due esiti opposti che si assomigliano non collassano in uno.
+function parseCapabilitySet(v, onIssue = null) {
+  if (!v || typeof v !== 'object' || Array.isArray(v)) return null;
+  const out = {};
+  for (const key of Object.keys(v)) {
+    if (!CAPABILITY_KEYS.includes(key)) return null;
+    const arr = v[key];
+    if (!Array.isArray(arr) || arr.length > MAX_CAPABILITIES) {
+      if (typeof onIssue === 'function') onIssue({ field: `capabilities.${key}`, value: Array.isArray(arr) ? arr.length : -1, rule: `troppi nomi, cap ${MAX_CAPABILITIES}` });
+      return null;
+    }
+    const visti = new Set();
+    for (const nome of arr) {
+      if (typeof nome !== 'string' || !CAPABILITY_KEY_RES[key].test(nome) || visti.has(nome)) return null;
+      visti.add(nome);
+    }
+    out[key] = [...visti];
+  }
+  return out;
+}
+
+// La superficie effettiva di una cella: il profilo alimenta le chiavi che la
+// cella non copre, e l'override della cella SOSTITUISCE per chiave (unire non
+// saprebbe togliere). LEGACY = nessun campo: la cella di sempre, comportamento
+// invariato. Pura: la vista e i materializzatori la usano senza toccare nulla.
+function effectiveCapabilities(cell, defs) {
+  const profili = (defs && defs.capabilityProfiles) || {};
+  const profilo = cell && cell.capabilityProfile !== undefined ? profili[cell.capabilityProfile] : undefined;
+  const declared = {};
+  let any = false;
+  for (const key of CAPABILITY_KEYS) {
+    const source = (cell && cell.capabilities && cell.capabilities[key] !== undefined) ? cell.capabilities[key]
+      : (profilo && profilo[key] !== undefined) ? profilo[key] : undefined;
+    if (source !== undefined) { declared[key] = [...source]; any = true; }
+  }
+  return { legacy: cell?.capabilities === undefined && cell?.capabilityProfile === undefined, declared };
+}
+
 function parseCell(c, engineIds, engineMap = new Map(), {
   allowLegacyTmuxNames = true, extraModels = null, onReject = null, onIssue = null,
+  capabilityProfileNames = null,
 } = {}) {
   const reject = (message) => {
     if (typeof onReject === 'function') onReject(message);
@@ -609,6 +688,26 @@ function parseCell(c, engineIds, engineMap = new Map(), {
     mcp = [...visti];
   }
 
+  // capabilities / capabilityProfile: la superficie operativa DICHIARATA della
+  // cella. `capabilities` e' un set per chiave (`mcp`/`skills`/`ondemand`,
+  // parseCapabilitySet sopra); `capabilityProfile` riferisce un profilo
+  // top-level del documento — DEVE esistere: un profilo dangling rifiuta la
+  // cella, non collassa in "niente profilo" (stesso motivo di panelUrl).
+  // Assenti entrambi = cella legacy: comportamento invariato (effectiveCapabilities).
+  let capabilities;
+  if (c.capabilities !== undefined) {
+    capabilities = parseCapabilitySet(c.capabilities, onIssue);
+    if (!capabilities) return null;
+  }
+  let capabilityProfile;
+  if (c.capabilityProfile !== undefined) {
+    if (typeof c.capabilityProfile !== 'string' || !CELL_ID_RE.test(c.capabilityProfile)) return null;
+    if (!capabilityProfileNames || !capabilityProfileNames.has(c.capabilityProfile)) {
+      return reject(`fleet.json rifiutato: la cella ${c.id} riferisce il profilo di capability "${c.capabilityProfile}" che non e' dichiarato in capabilityProfiles`);
+    }
+    capabilityProfile = c.capabilityProfile;
+  }
+
   // label (opzionale): nome LEGGIBILE della cella, distinto dall'id.
   // L'id resta la chiave stabile con cui si indirizza una cella e con cui si
   // deriva la sessione tmux; la label e' solo cio' che un umano legge. Senza
@@ -670,6 +769,8 @@ function parseCell(c, engineIds, engineMap = new Map(), {
   if (prompt !== undefined) out.prompt = prompt;
   if (panelUrl !== undefined) out.panelUrl = panelUrl;
   if (mcp !== undefined) out.mcp = mcp;
+  if (capabilities !== undefined) out.capabilities = capabilities;
+  if (capabilityProfile !== undefined) out.capabilityProfile = capabilityProfile;
   if (label !== undefined) out.label = label;
   if (legacyTmuxSession) {
     Object.defineProperty(out, 'legacyTmuxSession', {
@@ -1098,6 +1199,8 @@ const CAPS = {
 
 module.exports = {
   parseDefinitions,
+  effectiveCapabilities,
+  parseCapabilitySet,
   validateCommandTrust,
   aggiornaDefinizioni,
   proprietarioVivo,

package/lib/fleet/managed.js

@@ -1612,6 +1612,188 @@ function cellMcpArgs(home, cell) {
   return [`--settings=${JSON.stringify({ permissions: { deny } })}`];
 }
 
+// Definizioni MCP note, per NOME -> definizione (la prima sorgente che dichiara
+// il nome vince). Le SORGENTI sono le stesse dei nomi in `knownMcpServerNames`
+// (config utente, suo ramo per-progetto, .mcp.json della cwd), precedute da
+// eventuali file extra — per i profili Claude isolati la propria config, che
+// altrimenti sparirebbe dall'enumerazione. Solo LETTURA: le definizioni non
+// vengono mai modificate, riprese e ridistribuite tali quali.
+function collectMcpServerDefs(home, cwd, extraFiles = []) {
+  const leggi = (file) => {
+    try {
+      const st = fs.lstatSync(file);
+      if (st.isSymbolicLink() || !st.isFile() || st.size > 8 * 1024 * 1024) return null;
+      const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+      return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    } catch (_) { return null; /* assente o illeggibile non e' un errore qui */ }
+  };
+  const defs = new Map();
+  const raccogli = (servers) => {
+    if (servers && typeof servers === 'object' && !Array.isArray(servers)) {
+      for (const [nome, def] of Object.entries(servers)) {
+        if (def && typeof def === 'object' && !Array.isArray(def) && !defs.has(nome)) defs.set(nome, def);
+      }
+    }
+  };
+  for (const file of extraFiles) {
+    const parsed = typeof file === 'string' ? leggi(file) : null;
+    if (parsed) raccogli(parsed.mcpServers);
+  }
+  const utente = leggi(path.join(home, '.claude.json'));
+  if (utente) {
+    raccogli(utente.mcpServers);
+    const progetti = utente.projects;
+    if (typeof cwd === 'string' && cwd && progetti && typeof progetti === 'object' && !Array.isArray(progetti)) {
+      const voce = progetti[cwd];
+      if (voce && typeof voce === 'object' && !Array.isArray(voce)) raccogli(voce.mcpServers);
+    }
+  }
+  if (typeof cwd === 'string' && cwd) {
+    const progetto = leggi(path.join(cwd, '.mcp.json'));
+    if (progetto) raccogli(progetto.mcpServers);
+  }
+  return defs;
+}
+
+// Il file MCP PER CELLA del materializzatore: contiene le definizioni dei SOLO
+// server concessi, copiate tali quali dalle sorgenti (che portano `env` con
+// credenziali per alcuni server). Duplicare quelle definizioni e' il prezzo
+// del sottoinsieme esatto — il file per profilo unico non puo' esprimere un
+// sottoinsieme per cella senza un allowlist del client, e l'allowlist esclusiva
+// vuole proprio un file. Il prezzo si paga nel regime di permessi piu' stretto
+// che esiste fuori dallo store credenziali: directory 0700, file 0600, tutto
+// sotto ~/.nexuscrew (la stessa classe di privacy di providers.env), scritto
+// atomicamente e RIGENERATO a ogni up (nessun valore accumulato, nessuna
+// copia stantia), mai loggato: il contenuto non tocca nessun log né output.
+// DICHARIAZIONE DI PROVENIENZA: questo file e' DERIVATO — la fonte di verita'
+// restano le sorgenti originali, e la provenienza delle credenziali (doctor)
+// non lo elenca e non lo considerera' mai una sorgente di conflitto.
+function writeCellMcpConfig(cellId, concessi, home, defs) {
+  const dir = path.join(home, '.nexuscrew', 'cell-mcp');
+  try {
+    const st = fs.lstatSync(dir);
+    if (st.isSymbolicLink() || !st.isDirectory()) throw new Error('unsafe per-cell MCP directory');
+    // Strettisce, mai allarga: permessi piu' larghi di 0700 tornano a 0700; una
+    // directory resa NON scrivibile (operatore, manutenzione) resta tale — e
+    // il fallimento di scrittura e' il rifiuto del launch, non un launch con
+    // la superficie sbagliata.
+    if (st.mode & 0o077) fs.chmodSync(dir, 0o700);
+  } catch (e) {
+    if (e.code === 'ENOENT') fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    else throw e;
+  }
+  const servers = {};
+  // Il canale operatore (nexuscrew) e' CORE: entra nel file anche se la cella
+  // non lo ha nominato — senza, la cella dichiarata perderebbe `nc_*`.
+  const nomi = new Set(concessi);
+  if (defs.has('nexuscrew')) nomi.add('nexuscrew');
+  for (const nome of [...nomi].sort()) {
+    const def = defs.get(nome);
+    if (!def) continue; // difesa residua: il preflight ora rifiuta i nomi dichiarati sconosciuti prima di arrivare qui
+    servers[nome] = def;
+  }
+  const target = path.join(dir, `${cellId}.json`);
+  const tmp = path.join(dir, `.${cellId}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+  try {
+    fs.writeFileSync(tmp, `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`, { mode: 0o600 });
+    fs.chmodSync(tmp, 0o600);
+    fs.renameSync(tmp, target);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch (_) {}
+    throw e;
+  }
+  return target;
+}
+
+// La superficie codex NOTA alla config utente, letta con un parse TOML
+// minimale e DELIBERATAMENTE superficie: servono solo i NOMI dei server
+// (`[mcp_servers.<nome>]`) e delle skill (`[[skills.config]]` con name) da
+// poter spegnere nel profilo per cella. La config utente non viene mai
+// toccata: il profilo e' un LAYER di riduzione che la legge e basta.
+function codexSurfaceNames(configToml) {
+  const testo = typeof configToml === 'string' ? configToml : '';
+  const servers = [...testo.matchAll(/^[ \t]*\[mcp_servers\.([A-Za-z0-9_-]+)\][ \t]*$/gm)].map((m) => m[1]);
+  const skills = [...testo.matchAll(/\[\[skills\.config\]\]([^[]*)/g)]
+    .map((m) => (m[1].match(/^[ \t]*name[ \t]*=[ \t]*"([^"]+)"/m) || [])[1])
+    .filter(Boolean);
+  return { servers: [...new Set(servers)], skills: [...new Set(skills)] };
+}
+
+// Il profilo per cella di codex/codex-vl (profilo v2: <CODEX_HOME>/<nome>
+// .config.toml, lanciato con -p). STESSA SEMANTICA DEL CLAUDE, tradotta nei
+// meccanismi nativi del client: la chiave `mcp` spegne i server NON concessi
+// (enabled = false — i concessi non si ridichiarano, ereditano dal layer
+// base); `ondemand` mette omit_tools_from = ["direct"] (scopribili via tool
+// search, non attivi); `skills` spegne le skill NON concesse enumerate nella
+// config. Chiave assente = nessuna riduzione per quella chiave. RESIDUO
+// DICHIARATO: server/skill definiti fuori dalla config utente (config di
+// progetto, config gestita) non sono enumerabili da qui e restano — come per
+// il claude legacy, chi vuole il caso esatto dichiara e verifica. Il file e'
+// atomico, 0600, rigenerato a ogni up, mai loggato; la config utente non e'
+// mai modificata.
+// La config utente di codex letta con gli stessi criteri del materializzatore:
+// mai modificata, mai loggata; assente/symlink/oversize = catalogo vuoto.
+function readCodexUserToml(codexHome) {
+  try {
+    const st = fs.lstatSync(path.join(codexHome, 'config.toml'));
+    if (!st.isSymbolicLink() && st.isFile() && st.size <= 8 * 1024 * 1024) {
+      return fs.readFileSync(path.join(codexHome, 'config.toml'), 'utf8');
+    }
+  } catch (_) { /* config assente: niente da enumerare, il profilo e' vuoto */ }
+  return '';
+}
+
+function writeCellCodexProfile(cellId, declared, codexHome) {
+  const nome = `nexuscrew-${String(cellId).replace(/\./g, '_')}`;
+  const target = path.join(codexHome, `${nome}.config.toml`);
+  const configToml = readCodexUserToml(codexHome);
+  const { servers, skills } = codexSurfaceNames(configToml);
+  const mcpConcessi = new Set(declared.mcp || []);
+  const ondemand = new Set(declared.ondemand || []);
+  const skillConcesse = new Set(declared.skills || []);
+  const righe = [
+    '# Generated by NexusCrew for this cell: reduces (never widens) the surface',
+    '# declared in config.toml, which NexusCrew never modifies.',
+  ];
+  if (declared.mcp !== undefined) {
+    for (const s of servers.filter((n) => !mcpConcessi.has(n)).sort()) {
+      righe.push('', `[mcp_servers.${s}]`, 'enabled = false');
+    }
+  }
+  // `omit_tools_from` NON e' una chiave di root: in codex e' un campo della
+  // tabella del SINGOLO server (codex-rs/config/src/mcp_types.rs:223/:364) —
+  // a root viene ignorato in silenzio e l'on-demand non funzionerebbe mai.
+  // Un server on-demand e' CONCESSO ma differito: enabled resta il default e
+  // si scrive solo la chiave di differimento; uno spento (non concesso con
+  // `mcp` dichiarata) non prende una seconda tabella: TOML vieta i duplicati
+  // e enabled = false resta il volere piu' restrittivo. Nomi ondemand non
+  // presenti nella config utente non generano tabelle (ignorati; la vista li
+  // segnala).
+  if (ondemand.size) {
+    const spenti = declared.mcp !== undefined
+      ? new Set(servers.filter((n) => !mcpConcessi.has(n)))
+      : new Set();
+    for (const s of servers.filter((n) => ondemand.has(n) && !spenti.has(n)).sort()) {
+      righe.push('', `[mcp_servers.${s}]`, 'omit_tools_from = ["direct"]');
+    }
+  }
+  if (declared.skills !== undefined) {
+    for (const s of skills.filter((n) => !skillConcesse.has(n)).sort()) {
+      righe.push('', '[[skills.config]]', `name = "${s}"`, 'enabled = false');
+    }
+  }
+  const tmp = path.join(codexHome, `.${nome}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+  try {
+    fs.writeFileSync(tmp, `${righe.join('\n')}\n`, { mode: 0o600 });
+    fs.chmodSync(tmp, 0o600);
+    fs.renameSync(tmp, target);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch (_) {}
+    throw e;
+  }
+  return target;
+}
+
 function ensurePrivateClaudeConfig(home, profileId, label, penguinMode) {
   const nexusDir = path.join(home, '.nexuscrew');
   const profilesDir = path.join(nexusDir, 'claude-profiles');
@@ -2082,9 +2264,43 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
     // In coda di proposito: `--mcp-config` e' variadico e consuma ogni token
     // che non inizi per `-`. Messo qui non ha nulla da inghiottire.
     if (privateProfile) args.push(...sharedMcpArgs(home));
-    // Vale per OGNI cella Claude, non solo per i profili isolati: il filtro
-    // agisce sui nomi dei tool, non su dove i server sono definiti.
-    args.push(...cellMcpArgs(home, cell));
+    // Tre strade. LEGACY (niente capabilities, niente profilo): il filtro per
+    // NEGAZIONE di oggi, che agisce sui nomi dei tool e lascia le sorgenti
+    // dove sono. CELLA DICHIARATA con `mcp` (anche vuoto): allowlist ESCLUSIVA
+    // — un file per cella con i soli server concessi (+ il canale operatore,
+    // sempre) e `--strict-mcp-config`, che esclude anche cio' che il deny non
+    // sa enumerare (plugin, connettori). CHIAVE `mcp` ASSENTE ma cella
+    // dichiarata (solo skills/ondemand): comportamento di sempre per QUESTA
+    // chiave — l'alias `cell.mcp` resta il filtro per negazione, in linea con
+    // l'override sostitutivo per chiave del modello.
+    // FAIL-CLOSED: se il file per cella non si scrive la cella NON parte.
+    // Partire senza la allowlist esporrebbe l'intera superficie proprio dove
+    // l'operatore l'ha ristretta: peggio della legacy, e senza che nessuno
+    // l'abbia chiesto.
+    const { effectiveCapabilities } = require('./definitions.js');
+    const eff = effectiveCapabilities(cell || {}, { capabilityProfiles: cfg.capabilityProfiles || null });
+    if (eff.legacy || eff.declared.mcp === undefined) {
+      args.push(...cellMcpArgs(home, cell));
+    } else {
+      let file;
+      try {
+        const extraFiles = typeof env.CLAUDE_CONFIG_DIR === 'string'
+          ? [path.join(env.CLAUDE_CONFIG_DIR, '.claude.json')] : [];
+        const defs = collectMcpServerDefs(home, cell?.cwd, extraFiles);
+        // Un nome dichiarato che il client non definisce sparisce in silenzio
+        // dal file strict: rifiuta qui, prima di scrivere qualsiasi cosa.
+        const sconosciute = eff.declared.mcp.filter((n) => !defs.has(n));
+        if (sconosciute.length) {
+          const motivo = `capability mcp sconosciuta al client: ${sconosciute.join(', ')}`;
+          return { ok: false, reason: motivo, mcpCellRefused: motivo, mcpCellRefusedCode: 'CAPABILITY_UNKNOWN_NAME' };
+        }
+        file = writeCellMcpConfig(String(cell?.id || 'cella'), eff.declared.mcp, home, defs);
+      } catch (e) {
+        const motivo = `file MCP per cella non scrivibile: ${e.message}`;
+        return { ok: false, reason: motivo, mcpCellRefused: motivo };
+      }
+      args.push('--strict-mcp-config', `--mcp-config=${file}`);
+    }
   } else if (spec.client === 'codex' || spec.client === 'codex-vl') {
     if (profile.localProvider) args.push('--oss', '--local-provider', profile.localProvider);
     else if (spec.provider === 'openai-api') env.OPENAI_API_KEY = cred.value;
@@ -2180,6 +2396,43 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
       }
     }
     if (model) args.push('-m', model);
+    // Materializzatore per cella (stesse regole del ramo claude, meccanismi
+    // nativi del client): profilo v2 sotto CODEX_HOME lanciato con -p. Il
+    // profilo RIDUCE la superficie della config utente (mai toccata);
+    // FAIL-CLOSED come il claude: profilo non scrivibile = launch rifiutato,
+    // mai una cella con la superficie intera dove l'operatore ha ristretto.
+    {
+      const { effectiveCapabilities } = require('./definitions.js');
+      const eff = effectiveCapabilities(cell || {}, { capabilityProfiles: cfg.capabilityProfiles || null });
+      const daMaterializzare = eff.declared.mcp !== undefined || eff.declared.skills !== undefined || eff.declared.ondemand !== undefined;
+      if (!eff.legacy && daMaterializzare) {
+        // Stessa regola del ramo claude: un nome dichiarato che la config
+        // utente non definisce sparisce in silenzio dal profilo — rifiuta
+        // qui, prima di scrivere qualsiasi cosa. Catalogo vuoto (config
+        // assente/vuota) + nomi dichiarati = nomi sconosciuti; `mcp: []`
+        // resta valido (niente nomi da confrontare).
+        const { servers, skills } = codexSurfaceNames(readCodexUserToml(path.join(home, '.codex')));
+        const parti = [];
+        const sconosciuteMcp = (eff.declared.mcp || []).filter((n) => !servers.includes(n));
+        const sconosciuteOndemand = (eff.declared.ondemand || []).filter((n) => !servers.includes(n));
+        const sconosciuteSkills = (eff.declared.skills || []).filter((n) => !skills.includes(n));
+        if (sconosciuteMcp.length) parti.push(`capability mcp sconosciuta al client: ${sconosciuteMcp.join(', ')}`);
+        if (sconosciuteOndemand.length) parti.push(`capability ondemand sconosciuta al client: ${sconosciuteOndemand.join(', ')}`);
+        if (sconosciuteSkills.length) parti.push(`capability skills sconosciuta al client: ${sconosciuteSkills.join(', ')}`);
+        if (parti.length) {
+          const motivo = parti.join('; ');
+          return { ok: false, reason: motivo, mcpCellRefused: motivo, mcpCellRefusedCode: 'CAPABILITY_UNKNOWN_NAME' };
+        }
+        let file;
+        try {
+          file = writeCellCodexProfile(String(cell?.id || 'cella'), eff.declared, path.join(home, '.codex'));
+        } catch (e) {
+          const motivo = `profilo per cella non scrivibile: ${e.message}`;
+          return { ok: false, reason: motivo, mcpCellRefused: motivo, mcpCellRefusedCode: 'CAPABILITY_PROFILE_UNWRITABLE' };
+        }
+        args.push('-p', path.basename(file).replace(/\.config\.toml$/, ''));
+      }
+    }
   } else if (spec.client === 'pi') {
     if (profile.auth !== 'none' && profile.auth !== 'login' && cred.value) env[cred.envKey] = cred.value;
     if (spec.provider === 'custom') args.push('--extension', writePiProviderExtension(spec, home, declaredModels));
@@ -2434,6 +2687,7 @@ module.exports = {
   CLIENT_LABELS, normalizeManagedSpec, profileFor,
   defaultDefinitions, defaultShellEngine, defaultAgyEngine, defaultKimiEngine, defaultGrokEngine, defaultVlEngine, describeManaged, describeCatalogCredential, discoverOllamaModels, resolveManagedEngine, needsExplicitNode,
   discoverPiModels, EXTERNAL_DISCOVERY_TIMEOUT_MS, parseEnvFile, parseProviderShellFile, findBinary, publicCatalog, writePiProviderExtension, customCatalogFor,
+  codexSurfaceNames, writeCellCodexProfile,
   writeVlCellPrompt, vlSystemAppendGate,
   extraModelsFrom, declaredModelsFor, declaredFor,
   providerKeyPaths, parseProviderKeyFiles, credentialSources, credential, CREDENTIAL_SOURCE_VALUES,

package/lib/fleet/runtime.js

@@ -241,7 +241,13 @@ function createBuiltinRuntime(ctx) {
     if (!engine) throw httpError(400, `engine dangling per cella ${cellId}: ${cell.engine}`);
     let launchEngine = engine;
     if (engine.managed) {
-      const resolved = resolveManagedEngine(engine, cell, { ...cfg, home, extraModels: extraModelsFrom(defs) });
+      const resolved = resolveManagedEngine(engine, cell, { ...cfg, home, extraModels: extraModelsFrom(defs), capabilityProfiles: defs.capabilityProfiles || null });
+      // 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.
+      if (resolved.mcpCellRefused) {
+        throw httpError(500, resolved.mcpCellRefused, null, { phase: 'preflight', code: resolved.mcpCellRefusedCode || 'MCP_CELL_FILE_UNWRITABLE' });
+      }
       if (!resolved.ok) {
         const code = engine.managed.client === 'shell' ? 'SHELL_NOT_AVAILABLE' : 'ENGINE_UNCONFIGURED';
         throw httpError(400, `engine managed non configurato (${engine.id}): ${resolved.reason}`, null, { phase: 'preflight', code });