@mmmbuto/nexuscrew 0.8.52-rc.9 → 0.8.52

package/lib/fleet/builtin.js

@@ -35,7 +35,9 @@ const {
 } = require('./definitions.js');
 const {
   publicCatalog, describeManaged, describeCatalogCredential, defaultShellEngine, defaultAgyEngine, defaultKimiEngine,
+  CATALOG, credential: resolveProfileCredential, extraModelsFrom, knownMcpServerNames,
 } = require('./managed.js');
+const { probeModel } = require('./model-probe.js');
 const { validEnvKey } = require('./env-key.js');
 const { setCredential, removeCredential } = require('./credentials.js');
 const { createLaunchBroker } = require('./launch-broker.js');
@@ -55,6 +57,14 @@ const {
 function draftFrom(defs) {
   return {
     schemaVersion: defs.schemaVersion,
+    // I modelli dichiarati vanno RIPORTATI nella bozza: ogni mutazione
+    // ricostruisce il file da qui, e un campo non copiato sparisce senza che
+    // nessuno lo chieda. Trovato da un test — dichiaravo un modello, salvavo
+    // un engine che lo usava, e il salvataggio falliva perche' la
+    // dichiarazione non c'era piu'.
+    ...(Array.isArray(defs.models) && defs.models.length
+      ? { models: defs.models.map((m) => ({ ...m })) }
+      : {}),
     engines: defs.engines.map((e) => ({
       ...e,
       ...(e.managed ? { managed: { ...e.managed } } : {}),
@@ -371,6 +381,50 @@ async function createBuiltinFleet(cfg = {}) {
     await mutate(reloadDefs(), (d) => { d.engines.push(def); });
     return { ok: true, id: def.id };
   }
+  // --- modelli dichiarati ---------------------------------------------------
+  // Vivono in fleet.json accanto agli engine: stesso file, stesso backup,
+  // stessa esportazione. La validazione e' quella del parser (schema chiuso):
+  // qui si aggiunge e si toglie, non si reinterpreta.
+  async function defineModel(def) {
+    if (readonly()) throw httpError(403, 'READONLY: define-model bloccato');
+    if (!def || typeof def !== 'object' || Array.isArray(def)) throw httpError(400, 'definizione modello mancante');
+    const id = String(def.id || '').trim();
+    const engine = String(def.engine || '').trim();
+    if (!id || !engine) throw httpError(400, 'id e engine sono obbligatori');
+    const defs = reloadDefs();
+    const esistente = (defs.models || []).some((m) => m.id === id && m.engine === engine);
+    if (esistente) throw httpError(400, `modello gia' dichiarato: ${id} su ${engine}`);
+    // La scrittura passa da `mutate`, che rilegge e RIVALIDA l'intero file: un
+    // campo fuori schema non entra, e non serve duplicare qui le regole.
+    await mutate(defs, (d) => { d.models = [...(d.models || []), def]; });
+    return { ok: true, id, engine };
+  }
+
+  async function removeModel(id, engine) {
+    if (readonly()) throw httpError(403, 'READONLY: remove-model bloccato');
+    const wantedId = String(id || '').trim();
+    const wantedEngine = String(engine || '').trim();
+    if (!wantedId || !wantedEngine) throw httpError(400, 'id e engine sono obbligatori');
+    const defs = reloadDefs();
+    if (!(defs.models || []).some((m) => m.id === wantedId && m.engine === wantedEngine)) {
+      throw httpError(404, `modello non dichiarato: ${wantedId} su ${wantedEngine}`);
+    }
+    // Se un engine sta USANDO questo modello, toglierlo lo renderebbe invalido
+    // al prossimo avvio — e il messaggio arriverebbe a chi non sa cosa e'
+    // cambiato. Meglio rifiutare adesso, dicendo chi lo usa.
+    const usato = (defs.engines || [])
+      .filter((e) => e.managed && e.managed.model === wantedId)
+      .map((e) => e.id);
+    if (usato.length) {
+      throw httpError(409, `modello in uso: ${usato.join(', ')}`);
+    }
+    await mutate(defs, (d) => {
+      d.models = (d.models || []).filter((m) => !(m.id === wantedId && m.engine === wantedEngine));
+      if (!d.models.length) delete d.models;
+    });
+    return { ok: true, id: wantedId, engine: wantedEngine };
+  }
+
   async function editEngine(id, patch, envChanges) {
     if (readonly()) throw httpError(403, 'READONLY: edit-engine bloccato');
     if (!id) throw httpError(400, 'id engine mancante');
@@ -566,6 +620,18 @@ async function createBuiltinFleet(cfg = {}) {
   // conserva gli eventuali valori write-only già configurati sul target.
   async function restoreEngines(engines, opts = {}) {
     if (readonly()) throw httpError(403, 'READONLY: restore-engines bloccato');
+    // I modelli dichiarati arrivano INSIEME agli engine e vanno scritti PRIMA,
+    // nella stessa mutazione: un engine che usa un modello dichiarato viene
+    // rifiutato se la dichiarazione non c'e' ancora — fail-closed corretto, ma
+    // che al ripristino si legge come «il backup era rotto».
+    const models = Array.isArray(opts.models) ? opts.models : [];
+    if (models.length > 64) throw httpError(400, 'troppi modelli nel backup');
+    for (const m of models) {
+      if (!m || typeof m !== 'object' || Array.isArray(m)) throw httpError(400, 'definizione modello non valida');
+      if (typeof m.id !== 'string' || !m.id.trim() || typeof m.engine !== 'string' || !m.engine.trim()) {
+        throw httpError(400, 'modello senza id o engine');
+      }
+    }
     if (!Array.isArray(engines) || engines.length < 1 || engines.length > 24) {
       throw httpError(400, 'engines deve contenere 1..24 definizioni');
     }
@@ -601,6 +667,10 @@ async function createBuiltinFleet(cfg = {}) {
     const sessions = await refreshSessions();
     const affected = defs.cells.filter((cell) => conflicts.includes(cell.engine) && sessions.has(cell.tmuxSession)).map((cell) => cell.id);
     await mutate(defs, (draft) => {
+      for (const portable of models) {
+        const esiste = (draft.models || []).some((m) => m.id === portable.id && m.engine === portable.engine);
+        if (!esiste) draft.models = [...(draft.models || []), portable];
+      }
       for (const portable of engines) {
         const index = draft.engines.findIndex((current) => current.id === portable.id);
         const current = index >= 0 ? draft.engines[index] : null;
@@ -725,7 +795,7 @@ async function createBuiltinFleet(cfg = {}) {
       engines: defs.engines.map((e) => {
         const out = { ...e, envKeys: Object.keys(e.env || {}).sort() };
         delete out.env;
-        if (e.managed) out.managedInfo = describeManaged(e.managed, { ...cfg, home });
+        if (e.managed) out.managedInfo = describeManaged(e.managed, { ...cfg, home, extraModels: extraModelsFrom(defs) });
         return out;
       }),
       cells: defs.cells.map((c) => {
@@ -756,7 +826,16 @@ async function createBuiltinFleet(cfg = {}) {
         }
         return out;
       }),
+      // I modelli dichiarati devono uscire dalla VISTA, non solo stare nel file:
+      // la finestra li legge da qui, e senza questa riga l'elenco era sempre
+      // vuoto — si poteva dichiarare un modello e non vederlo mai, ne' ritirarlo.
+      // I test CRUD non se ne accorgevano perche' leggevano fleet.json diretto.
+      ...(Array.isArray(defs.models) && defs.models.length ? { models: defs.models } : {}),
       managedCatalog,
+      // I NOMI dei server MCP disponibili, per la finestra che sceglie quali
+      // strumenti dare a una cella. Solo nomi: le definizioni non escono di qui,
+      // e non devono — alcune portano credenziali nel proprio `env`.
+      mcpServers: [...knownMcpServerNames(home)].sort(),
       managedConfig: {
         providerSecretsPath: cfg.providerSecretsPath || path.join(home, '.nexuscrew', 'providers.env'),
         providerShellPath: cfg.providerShellPath || path.join(home, '.config', 'ai-shell', 'providers.zsh'),
@@ -771,7 +850,7 @@ async function createBuiltinFleet(cfg = {}) {
     const defs = existingDefs || reloadDefs(); const map = new Map();
     for (const engine of defs.engines) {
       if (!engine.managed) continue;
-      const info = describeManaged(engine.managed, { ...cfg, home });
+      const info = describeManaged(engine.managed, { ...cfg, home, extraModels: extraModelsFrom(reloadDefs()) });
       const envKey = info.auth;
       if (!validEnvKey(envKey) || envKey === 'login' || envKey === 'none') continue;
       const current = map.get(envKey) || {
@@ -856,6 +935,20 @@ async function createBuiltinFleet(cfg = {}) {
         promptMode: { type: 'enum', required: true, values: ['flag', 'send-keys'] },
         promptFlag: { type: 'string', requiredIf: 'promptMode=flag', singleArgv: true, max: CAPS.MAX_PROMPTFLAG_LEN },
       },
+      // Modello dichiarato: estende il catalogo interno per UN profilo. Vive
+      // nello schema perche' `define-model` e' federato — un client che
+      // amministra un nodo remoto ricava di qui la forma da compilare, invece
+      // di indovinarla e scoprire il vincolo da un rifiuto.
+      model: {
+        id: { type: 'string', required: true, max: CAPS.MAX_MODEL_VAL_LEN, noControlChars: true },
+        engine: { type: 'catalog', required: true, source: 'managedCatalog', max: 64 },
+        label: { type: 'string', required: false, max: 64 },
+        // Fuori da questa scala e' quasi sempre un errore di battitura, e
+        // arriverebbe al client come comportamento inspiegabile.
+        contextWindow: { type: 'integer', required: false, min: 1024, max: 100000000 },
+        maxTokens: { type: 'integer', required: false, min: 1024, max: 100000000 },
+        reasoning: { type: 'boolean', required: false },
+      },
       cell: {
         id: { type: 'string', required: true, pattern: '^[A-Za-z0-9._-]{1,32}$', max: 32 },
         cwd: { type: 'string', required: true, max: CAPS.MAX_CWD_LEN, underHome: true },
@@ -867,6 +960,9 @@ async function createBuiltinFleet(cfg = {}) {
         permissionPolicies: { type: 'object', required: false, keyRef: 'engine.id', valueEnum: ['standard', 'unsafe'] },
         commands: { type: 'object', required: false, keyRef: 'engine.id', valueMax: CAPS.MAX_CELL_COMMAND_LEN, managedClient: 'shell' },
         prompt: { type: 'string', required: false, max: CAPS.MAX_PROMPT_LEN },
+        // Quali strumenti MCP ha la cella, per NOME. Assente = tutti (come
+        // sempre); `[]` = nessuno. Solo nomi: le definizioni restano dove sono.
+        mcp: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$' },
         // 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 },
@@ -875,7 +971,35 @@ async function createBuiltinFleet(cfg = {}) {
   }
 
   function capabilities() {
-    return ['status', 'up', 'down', 'restart', 'engine', 'boot', 'define', 'edit', 'remove', 'import', 'restore', 'schema', 'definitions', 'credentials'];
+    return ['status', 'up', 'down', 'restart', 'engine', 'boot', 'define', 'edit', 'remove', 'import', 'restore', 'schema', 'definitions', 'credentials', 'model-test'];
+  }
+
+  // «questo modello funziona con questa credenziale?», chiesto all'API invece
+  // che scoperto quando la cella non parte. Vive qui e non nelle route perche'
+  // la credenziale si risolve dove gia' si risolve per l'avvio: la chiave non
+  // attraversa il router e non compare in nessuna risposta.
+  async function testModel(engineId, model, opts = {}) {
+    const profile = CATALOG.find((p) => p.id === String(engineId || ''));
+    if (!profile) {
+      const e = new Error(`profilo sconosciuto "${engineId}"`); e.status = 404; throw e;
+    }
+    const wanted = typeof model === 'string' ? model.trim() : '';
+    if (!wanted || wanted.length > 128 || /[\x00-\x1f\x7f]/.test(wanted)) {
+      const e = new Error('modello non valido'); e.status = 400; throw e;
+    }
+    const spec = {
+      client: profile.client,
+      provider: profile.provider,
+      ...(profile.credentialProfile ? { credentialProfile: profile.credentialProfile } : {}),
+    };
+    let value = '';
+    try { value = (resolveProfileCredential(profile, spec, cfg, home) || {}).value || ''; } catch (_) { value = ''; }
+    const out = await probeModel({
+      profile, credential: value, model: wanted, fetchImpl: opts.fetchImpl,
+    });
+    // Si riporta anche COSA si e' provato, perche' un esito senza il suo
+    // soggetto e' inservibile in una schermata con piu' modelli.
+    return { engine: profile.id, model: wanted, ...out };
   }
 
   async function close() { await launchBroker.close(); }
@@ -887,7 +1011,8 @@ async function createBuiltinFleet(cfg = {}) {
     defineEngine, editEngine, removeEngine,
     defineCell, editCell, removeCell, importCell, restoreCells, restoreEngines,
     schema, definitions, capabilities,
-    credentialStatus, setLocalCredential, removeLocalCredential, close,
+    credentialStatus, setLocalCredential, removeLocalCredential, testModel,
+    defineModel, removeModel, close,
   };
 }
 

package/lib/fleet/catalogs/alibaba-token-plan-qwen3.8.json

@@ -1,9 +1,9 @@
 {
   "models": [
     {
-      "slug": "qwen3.8-max-preview",
-      "display_name": "qwen3.8-max-preview",
-      "description": "Alibaba Token Plan Personal: qwen3.8-max-preview",
+      "slug": "qwen3.8-max",
+      "display_name": "qwen3.8-max",
+      "description": "Alibaba Token Plan Personal: qwen3.8-max",
       "default_reasoning_level": "xhigh",
       "supported_reasoning_levels": [
         {

package/lib/fleet/definitions.js

@@ -29,6 +29,11 @@ const MAX_MODEL_FLAG_LEN = 32;
 const MAX_MODEL_VAL_LEN = 128;
 const MAX_PROMPTFLAG_LEN = 32;
 const MAX_PROMPT_LEN = 8192;   // 8 KB
+// Nomi di server MCP dichiarabili per cella. Il tetto e' generoso rispetto agli
+// otto configurati qui, e la forma e' quella di un identificatore perche' il
+// nome finisce in un prefisso di tool passato al client.
+const MAX_MCP_NAMES = 64;
+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;
 
@@ -131,7 +136,49 @@ function cellIdFromTmuxSession(session) {
 }
 
 // ---------------------------------------------------------------------------
-// parseDefinitions(raw) -> {schemaVersion, engines, cells} | null
+// Modelli dichiarati dall'operatore, accanto agli engine e persistiti con loro.
+//
+// Perche' esistono: il catalogo dei modelli vive nel pacchetto, e un fornitore
+// che pubblica un id nuovo lo rende inutilizzabile fino alla release
+// successiva. Qui si dichiara l'id per un profilo gestito, con i dati che il
+// client si aspetta — gli stessi campi che il catalogo interno gia' porta.
+//
+// Un modello dichiarato NON aggira il controllo: lo estende in modo esplicito.
+// Un id mai dichiarato resta rifiutato.
+const MAX_MODELS = 64;
+const MODEL_ID_MAX = 128;
+
+function parseModel(m) {
+  if (!m || typeof m !== 'object' || Array.isArray(m)) return null;
+  const allowed = new Set(['id', 'engine', 'label', 'contextWindow', 'maxTokens', 'reasoning']);
+  if (Object.keys(m).some((k) => !allowed.has(k))) return null;
+  const id = typeof m.id === 'string' ? m.id.trim() : '';
+  // Stessa forma accettata dal gate dei modelli: nessun byte di controllo, un
+  // limite di lunghezza, e nulla di piu' — l'id lo decide il fornitore, non noi.
+  if (!id || id.length > MODEL_ID_MAX || /[\x00-\x1f\x7f]/.test(id)) return null;
+  const engine = typeof m.engine === 'string' ? m.engine.trim() : '';
+  if (!engine || engine.length > 64 || !/^[a-z0-9][a-z0-9._-]*$/.test(engine)) return null;
+  const out = { id, engine };
+  if (m.label !== undefined) {
+    if (typeof m.label !== 'string' || m.label.length > 64) return null;
+    if (m.label.trim()) out.label = m.label.trim();
+  }
+  for (const key of ['contextWindow', 'maxTokens']) {
+    if (m[key] === undefined) continue;
+    // Una finestra plausibile: un numero fuori scala e' quasi sempre un errore
+    // di battitura, e passerebbe fino al client sotto forma di comportamento
+    // inspiegabile.
+    if (!Number.isSafeInteger(m[key]) || m[key] < 1024 || m[key] > 100000000) return null;
+    out[key] = m[key];
+  }
+  if (m.reasoning !== undefined) {
+    if (typeof m.reasoning !== 'boolean') return null;
+    out.reasoning = m.reasoning;
+  }
+  return out;
+}
+
+// parseDefinitions(raw) -> {schemaVersion, engines, cells, models} | null
 // Accetta stringa JSON o oggetto gia' parsato. Strict + fail-closed.
 // ---------------------------------------------------------------------------
 function parseDefinitions(raw, { allowLegacyTmuxNames = true } = {}) {
@@ -151,11 +198,32 @@ function parseDefinitions(raw, { allowLegacyTmuxNames = true } = {}) {
     if (!Array.isArray(d.cells)) return null;            // cells obbligatorio (array)
     if (d.cells.length > MAX_CELLS) return null;
 
+    // I modelli si leggono PRIMA degli engine: un engine puo' riferirsi a un id
+    // dichiarato qui, e leggerli dopo lo farebbe rifiutare per un dato che in
+    // realta' c'e'. `models` e' opzionale: una configurazione che non lo ha
+    // resta valida esattamente com'era.
+    const models = [];
+    const extraModels = new Map();
+    if (d.models !== undefined) {
+      if (!Array.isArray(d.models) || d.models.length > MAX_MODELS) return null;
+      const seen = new Set();
+      for (const m of d.models) {
+        const model = parseModel(m);
+        if (!model) return null;
+        const key = `${model.engine}::${model.id}`;
+        if (seen.has(key)) return null;   // stesso id due volte per lo stesso profilo
+        seen.add(key);
+        if (!extraModels.has(model.engine)) extraModels.set(model.engine, new Set());
+        extraModels.get(model.engine).add(model.id);
+        models.push(model);
+      }
+    }
+
     const engineIds = new Set();
     const engineMap = new Map();
     const engines = [];
     for (const e of d.engines) {
-      const eng = parseEngine(e);
+      const eng = parseEngine(e, { extraModels });
       if (!eng) return null;
       if (engineIds.has(eng.id)) return null;            // id engine univoco
       engineIds.add(eng.id);
@@ -169,7 +237,7 @@ function parseDefinitions(raw, { allowLegacyTmuxNames = true } = {}) {
     const cellIds = new Set();
     const cells = [];
     for (const c of d.cells) {
-      const cell = parseCell(c, engineIds, engineMap, { allowLegacyTmuxNames });
+      const cell = parseCell(c, engineIds, engineMap, { allowLegacyTmuxNames, extraModels });
       if (!cell) return null;
       if (cellIds.has(cell.id)) return null;             // id cell univoco
       cellIds.add(cell.id);
@@ -183,7 +251,11 @@ function parseDefinitions(raw, { allowLegacyTmuxNames = true } = {}) {
       cells.push(cell);
     }
 
-    const parsed = { schemaVersion: SCHEMA_VERSION, engines, cells };
+    // `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 };
     // 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', {
@@ -195,7 +267,7 @@ function parseDefinitions(raw, { allowLegacyTmuxNames = true } = {}) {
   }
 }
 
-function parseEngine(e) {
+function parseEngine(e, { extraModels = null } = {}) {
   if (!e || typeof e !== 'object' || Array.isArray(e)) return null;
 
   // id
@@ -219,7 +291,7 @@ function parseEngine(e) {
   // Managed: NexusCrew conosce client/provider e compone internamente il
   // processo. Nessun command/env/argv o segreto vive nella definizione.
   if (e.managed !== undefined) {
-    const managed = normalizeManagedSpec(e.managed);
+    const managed = normalizeManagedSpec(e.managed, { extraModels });
     if (!managed) return null;
     for (const key of ['command', 'args', 'env', 'promptMode', 'promptFlag', 'model']) {
       if (e[key] !== undefined) return null;
@@ -285,7 +357,25 @@ function parseEngine(e) {
   return out;
 }
 
-function parseCell(c, engineIds, engineMap = new Map(), { allowLegacyTmuxNames = true } = {}) {
+// Un modello scelto PER CELLA deve superare lo stesso controllo di un modello
+// scelto per l'engine. Senza, il gate `strictModels` — che vale su
+// define-engine, edit-engine, restore-engines e sulla scrittura diretta —
+// resta aggirabile da questa via, che per giunta e' FEDERATA (`/fleet/engine`
+// e' nell'allowlist): un peer poteva mettere un id arbitrario in una cella di
+// questa installazione, e il boot lo usava senza ricontrollarlo.
+//
+// Rilievo dell'audit indipendente, provato con probe su due profili distinti.
+// Il controllo e' quello vero, non una copia: si passa dalla stessa
+// `normalizeManagedSpec` con le stesse dichiarazioni.
+function cellModelAllowed(engineId, model, engineMap, extraModels) {
+  const engine = engineMap.get(engineId);
+  // Engine custom (non gestito): il modello e' un argomento del comando, non un
+  // id di catalogo, e qui non c'e' nulla da validare.
+  if (!engine || !engine.managed) return true;
+  return !!normalizeManagedSpec({ ...engine.managed, model }, { extraModels });
+}
+
+function parseCell(c, engineIds, engineMap = new Map(), { allowLegacyTmuxNames = true, extraModels = null } = {}) {
   if (!c || typeof c !== 'object' || Array.isArray(c)) return null;
 
   // id
@@ -320,6 +410,7 @@ function parseCell(c, engineIds, engineMap = new Map(), { allowLegacyTmuxNames =
   let model;
   if (c.model !== undefined) {
     if (typeof c.model !== 'string' || c.model.length > MAX_MODEL_VAL_LEN) return null;
+    if (!cellModelAllowed(c.engine, c.model, engineMap, extraModels)) return null;
     model = c.model;
   }
 
@@ -332,6 +423,9 @@ function parseCell(c, engineIds, engineMap = new Map(), { allowLegacyTmuxNames =
     if (entries.length > MAX_ENGINES) return null;
     for (const [engineId, value] of entries) {
       if (!engineIds.has(engineId) || typeof value !== 'string' || !value || value.length > MAX_MODEL_VAL_LEN) return null;
+      // Anche la memoria per-engine passa dal gate: e' un valore che tornera'
+      // in uso appena si ritorna su quell'engine.
+      if (!cellModelAllowed(engineId, value, engineMap, extraModels)) return null;
       models[engineId] = value;
     }
   }
@@ -378,6 +472,32 @@ function parseCell(c, engineIds, engineMap = new Map(), { allowLegacyTmuxNames =
     prompt = c.prompt;
   }
 
+  // mcp (opzionale): QUALI strumenti MCP ha questa cella, per NOME.
+  //
+  // Solo nomi, mai definizioni. Le definizioni vivono in un posto solo — la
+  // configurazione del client — e li' restano: duplicarle per cella
+  // significherebbe moltiplicare le credenziali che alcuni server portano nel
+  // proprio `env` (una password, due chiavi API su questa installazione), in un
+  // file per cella invece che in uno.
+  //
+  // ASSENTE non e' come VUOTO. Assente = la cella eredita tutti gli strumenti,
+  // che e' il comportamento di sempre. `[]` = nessuno strumento, ed e'
+  // esattamente cio' che serve per una cella di cui non ci si fida: oggi quel
+  // risultato si ottiene solo per caso, come effetto collaterale
+  // dell'isolamento per credenziale.
+  let mcp;
+  if (c.mcp !== undefined) {
+    if (!Array.isArray(c.mcp) || c.mcp.length > MAX_MCP_NAMES) return null;
+    const visti = new Set();
+    for (const nome of c.mcp) {
+      // Il nome finisce in un prefisso di tool (`mcp__<nome>`) passato al
+      // client: si delimita come un identificatore, non come testo libero.
+      if (typeof nome !== 'string' || !MCP_NAME_RE.test(nome) || visti.has(nome)) return null;
+      visti.add(nome);
+    }
+    mcp = [...visti];
+  }
+
   // 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
@@ -437,6 +557,7 @@ function parseCell(c, engineIds, engineMap = new Map(), { allowLegacyTmuxNames =
   if (permissionPolicies) out.permissionPolicies = permissionPolicies;
   if (commands && Object.keys(commands).length) out.commands = commands;
   if (prompt !== undefined) out.prompt = prompt;
+  if (mcp !== undefined) out.mcp = mcp;
   if (label !== undefined) out.label = label;
   if (legacyTmuxSession) {
     Object.defineProperty(out, 'legacyTmuxSession', {