@mmmbuto/nexuscrew 0.8.52-rc.8 → 0.8.52

package/lib/fleet/managed.js

@@ -28,18 +28,62 @@ function ollamaContextFor(model) {
   const key = String(model || '');
   return OLLAMA_CONTEXT[key] ?? OLLAMA_CONTEXT[key.split(':')[0]];
 }
+// Rinomini di modello, dichiarati in UN posto solo.
+//
+// Un fornitore che promuove un preview a stabile cambia l'id, e con
+// `strictModels` un id non piu' in catalogo NON e' un avviso: e' una cella che
+// non parte. Le due celle configurate con `qwen3.8-max-preview` si sarebbero
+// fermate al primo avvio dopo l'aggiornamento, senza che nulla dicesse
+// perche'.
+//
+// L'alias risolve il nome vecchio e restituisce quello NUOVO, quindi la
+// configurazione converge da sola alla prima riscrittura invece di restare
+// indietro per sempre.
+const MODEL_ALIASES = Object.freeze({
+  'qwen3.8-max-preview': 'qwen3.8-max',
+});
+
+// Modelli dichiarati in configurazione, indicizzati per PROFILO gestito. La
+// dichiarazione e' per profilo e non per fornitore: gli elenchi di Alibaba per
+// Claude e per Codex differiscono davvero, e generalizzare creerebbe
+// combinazioni che non esistono.
+function declaredFor(extraModels, profileId, model) {
+  if (!extraModels || typeof extraModels.get !== 'function') return false;
+  const set = extraModels.get(profileId);
+  return !!(set && typeof set.has === 'function' && set.has(model));
+}
+
+// Dalle definizioni alla mappa che il gate si aspetta. Sta qui e non nei
+// chiamanti perche' ognuno di loro la ricostruirebbe a modo suo, e basta che
+// uno la dimentichi perche' un modello dichiarato smetta di essere valido
+// proprio nel punto che conta — l'avvio.
+function extraModelsFrom(defs) {
+  const map = new Map();
+  for (const m of (defs && Array.isArray(defs.models) ? defs.models : [])) {
+    if (!m || typeof m.engine !== 'string' || typeof m.id !== 'string') continue;
+    if (!map.has(m.engine)) map.set(m.engine, new Set());
+    map.get(m.engine).add(m.id);
+  }
+  return map;
+}
+
+function canonicalModel(model) {
+  const key = String(model || '');
+  return Object.hasOwn(MODEL_ALIASES, key) ? MODEL_ALIASES[key] : model;
+}
+
 const ALIBABA_TOKEN_PLAN_MODELS = Object.freeze([
-  'qwen3.8-max-preview', 'qwen3.7-plus', 'qwen3.7-max',
+  'qwen3.8-max', 'qwen3.7-plus', 'qwen3.7-max',
   'qwen3.6-flash', 'glm-5.2', 'deepseek-v4-pro',
 ]);
 const ALIBABA_CODEX_MODELS = Object.freeze([
-  'qwen3.8-max-preview', 'qwen3.7-max', 'qwen3.7-plus', 'qwen3.6-flash',
+  'qwen3.8-max', 'qwen3.7-max', 'qwen3.7-plus', 'qwen3.6-flash',
 ]);
 const ALIBABA_TOKEN_PLAN_CONTEXT = 983616;
 const ZERO_COST = Object.freeze({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
 const ALIBABA_PI_MODELS = Object.freeze([
   Object.freeze({
-    id: 'qwen3.8-max-preview', name: 'qwen3.8-max-preview', api: 'openai-responses',
+    id: 'qwen3.8-max', name: 'qwen3.8-max', api: 'openai-responses',
     reasoning: true, thinkingLevelMap: { low: 'low', high: 'high', xhigh: 'xhigh' },
     input: ['text', 'image'], contextWindow: ALIBABA_TOKEN_PLAN_CONTEXT, maxTokens: 131072,
     cost: ZERO_COST,
@@ -89,7 +133,7 @@ function validBaseUrl(value) {
 const CATALOG = Object.freeze([
   // Claude Code
   { id: 'claude.native', client: 'claude', provider: 'native', label: 'Anthropic / Claude account', auth: 'login', endpoint: 'Anthropic account', protocol: 'anthropic_messages', rc: true, default: true, core: true },
-  { id: 'claude.alibaba-token-plan', client: 'claude', provider: 'alibaba-token-plan', label: 'Alibaba Token Plan Personal', auth: 'ALIBABA_CODE_API_KEY', endpoint: 'https://token-plan.ap-southeast-1.maas.aliyuncs.com/apps/anthropic', protocol: 'anthropic_messages', model: 'qwen3.8-max-preview', models: ALIBABA_TOKEN_PLAN_MODELS, strictModels: true, core: true, notice: 'alibaba-token-plan' },
+  { id: 'claude.alibaba-token-plan', client: 'claude', provider: 'alibaba-token-plan', label: 'Alibaba Token Plan Personal', auth: 'ALIBABA_CODE_API_KEY', endpoint: 'https://token-plan.ap-southeast-1.maas.aliyuncs.com/apps/anthropic', protocol: 'anthropic_messages', model: 'qwen3.8-max', models: ALIBABA_TOKEN_PLAN_MODELS, strictModels: true, core: true, notice: 'alibaba-token-plan' },
   { id: 'claude.openrouter', client: 'claude', provider: 'openrouter', label: 'OpenRouter', auth: 'OPENROUTER_API_KEY', endpoint: 'https://openrouter.ai/api', protocol: 'anthropic_messages', requiresModel: true, core: true, notice: 'claude-openrouter' },
   { id: 'claude.kimi-code', client: 'claude', provider: 'kimi-code', label: 'Kimi Code', auth: 'KIMI_API_KEY', endpoint: 'https://api.kimi.com/coding/', protocol: 'anthropic_messages', model: 'k3[1m]', models: ['k3', 'k3[1m]', 'kimi-for-coding', 'kimi-for-coding-highspeed'], strictModels: true, core: true, notice: 'claude-kimi-code' },
   { id: 'claude.bedrock', client: 'claude', provider: 'bedrock', label: 'Amazon Bedrock', auth: 'login', endpoint: 'AWS Bedrock', protocol: 'anthropic_messages', core: true, providerEnv: { CLAUDE_CODE_USE_BEDROCK: '1' } },
@@ -106,7 +150,7 @@ const CATALOG = Object.freeze([
   // Codex family. OpenAI Responses is the only remote custom wire API.
   { id: 'codex.native', client: 'codex', provider: 'native', label: 'OpenAI / ChatGPT account', auth: 'login', endpoint: 'OpenAI account', protocol: 'openai_responses', default: true, core: true },
   { id: 'codex-vl.native', client: 'codex-vl', provider: 'native', label: 'OpenAI / ChatGPT account', auth: 'login', endpoint: 'OpenAI account', protocol: 'openai_responses', default: true, core: true },
-  { id: 'codex-vl.alibaba-token-plan', client: 'codex-vl', provider: 'alibaba-token-plan', label: 'Alibaba Token Plan Personal', auth: 'ALIBABA_CODE_API_KEY', endpoint: 'https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1', protocol: 'openai_responses', model: 'qwen3.8-max-preview', models: ALIBABA_CODEX_MODELS, strictModels: true, core: true, notice: 'alibaba-token-plan' },
+  { id: 'codex-vl.alibaba-token-plan', client: 'codex-vl', provider: 'alibaba-token-plan', label: 'Alibaba Token Plan Personal', auth: 'ALIBABA_CODE_API_KEY', endpoint: 'https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1', protocol: 'openai_responses', model: 'qwen3.8-max', models: ALIBABA_CODEX_MODELS, strictModels: true, core: true, notice: 'alibaba-token-plan' },
   { id: 'codex.openai-api', client: 'codex', provider: 'openai-api', label: 'OpenAI API', auth: 'OPENAI_API_KEY', endpoint: 'https://api.openai.com/v1', protocol: 'openai_responses', core: true },
   { id: 'codex-vl.openai-api', client: 'codex-vl', provider: 'openai-api', label: 'OpenAI API', auth: 'OPENAI_API_KEY', endpoint: 'https://api.openai.com/v1', protocol: 'openai_responses', core: true },
   { id: 'codex-vl.openrouter', client: 'codex-vl', provider: 'openrouter', label: 'OpenRouter', auth: 'OPENROUTER_API_KEY', endpoint: 'https://openrouter.ai/api/v1', protocol: 'openai_responses', requiresModel: true, core: true, notice: 'codex-openrouter' },
@@ -121,7 +165,7 @@ const CATALOG = Object.freeze([
 
   // Pi uses its real provider IDs directly. OAuth providers do not need env keys.
   { id: 'pi.native', client: 'pi', provider: 'native', label: 'Pi configured default', auth: 'login', protocol: 'pi_native', default: true, core: true },
-  { id: 'pi.alibaba-token-plan', client: 'pi', provider: 'alibaba-token-plan', label: 'Alibaba Token Plan Personal', auth: 'ALIBABA_CODE_API_KEY', endpoint: 'https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1', protocol: 'openai-completions', model: 'qwen3.8-max-preview', models: ALIBABA_TOKEN_PLAN_MODELS, strictModels: true, piProvider: 'alibaba-token-plan', piExtension: { baseUrl: 'https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1', models: ALIBABA_PI_MODELS }, delegatePiAuth: false, core: true, notice: 'alibaba-token-plan' },
+  { id: 'pi.alibaba-token-plan', client: 'pi', provider: 'alibaba-token-plan', label: 'Alibaba Token Plan Personal', auth: 'ALIBABA_CODE_API_KEY', endpoint: 'https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1', protocol: 'openai-completions', model: 'qwen3.8-max', models: ALIBABA_TOKEN_PLAN_MODELS, strictModels: true, piProvider: 'alibaba-token-plan', piExtension: { baseUrl: 'https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1', models: ALIBABA_PI_MODELS }, delegatePiAuth: false, core: true, notice: 'alibaba-token-plan' },
   // Device-local shell. Kept after the established default clients so adding
   // it does not change the preselected engine for a newly-created cell.
   { id: 'shell.local', client: 'shell', provider: 'local', label: 'Shell', auth: 'none', protocol: 'shell', default: true, core: true },
@@ -168,7 +212,7 @@ function profileFor(client, provider, credentialProfile) {
     && (p.credentialProfile || '') === (credentialProfile || '')) || null;
 }
 
-function normalizeManagedSpec(value) {
+function normalizeManagedSpec(value, { extraModels = null } = {}) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
   if (Object.keys(value).some((k) => !MANAGED_KEYS.has(k))) return null;
   if (!CLIENT_LABELS[value.client]) return null;
@@ -182,11 +226,23 @@ function normalizeManagedSpec(value) {
   if (typeof provider !== 'string') return null;
   const profile = profileFor(value.client, provider, credentialProfile);
   if (!profile) return null;
-  const model = value.model === undefined ? (profile.model || '') : value.model;
-  if (typeof model !== 'string' || model.length > 128 || /[\x00-\x1f\x7f]/.test(model)) return null;
+  const requested = value.model === undefined ? (profile.model || '') : value.model;
+  if (typeof requested !== 'string' || requested.length > 128 || /[\x00-\x1f\x7f]/.test(requested)) return null;
+  // L'alias si applica PRIMA del gate: un nome legacy deve passare, e deve
+  // passare diventando il nome nuovo.
+  const model = canonicalModel(requested);
   if (value.client === 'shell' && model) return null;
   if (profile.requiresModel && !model) return null;
-  if (profile.strictModels && !(profile.models || []).includes(model)) return null;
+  // Il catalogo del codice e' l'elenco dei modelli NOTI, non il muro di cio' che
+  // esiste: un fornitore pubblica quando vuole, e senza questa via usare un
+  // modello nuovo richiederebbe una release di NexusCrew.
+  //
+  // Un id dichiarato nella configurazione passa perche' e' stato DICHIARATO per
+  // quel profilo, non perche' il controllo e' stato tolto: un id mai visto
+  // resta rifiutato, ed e' cio' che impedisce di far partire una cella con un
+  // modello inesistente e scoprirlo dal fallimento.
+  if (profile.strictModels && !(profile.models || []).includes(model)
+    && !declaredFor(extraModels, profile.id, model)) return null;
   const permissionPolicy = value.permissionPolicy === undefined ? (profile.client === 'claude' ? 'unsafe' : 'standard') : value.permissionPolicy;
   if (permissionPolicy !== 'standard' && permissionPolicy !== 'unsafe') return null;
   if ((value.client === 'pi' || value.client === 'shell') && permissionPolicy !== 'standard') return null;
@@ -596,7 +652,8 @@ async function discoverPiModels(opts = {}) {
 }
 
 function describeManaged(spec, cfg = {}) {
-  const normalized = normalizeManagedSpec(spec);
+  const extraModels = cfg.extraModels || null;
+  const normalized = normalizeManagedSpec(spec, { extraModels });
   if (!normalized) return { configured: false, reason: 'invalid managed profile' };
   const home = cfg.home || require('node:os').homedir();
   const profile = profileFor(normalized.client, normalized.provider, normalized.credentialProfile || '');
@@ -681,6 +738,134 @@ function ensureAlibabaClaudeConfig(home) {
   return ensurePrivateClaudeConfig(home, 'alibaba-token-plan', 'Alibaba Token Plan', false);
 }
 
+// Un profilo Claude privato esiste per separare le CREDENZIALI, ma Claude tiene
+// la configurazione MCP nello STESSO file: isolando l'una si e' isolata anche
+// l'altra, e una cella su quei profili partiva senza nessuno strumento — niente
+// memoria, niente `nc_notify`, niente `webfetch`. Non e' un difetto
+// dell'isolamento: e' una conseguenza di dove Claude tiene le due cose.
+//
+// Si passa il file principale COME SORGENTE invece di copiarne il contenuto.
+// Misurato: quelle definizioni portano `env` con una password Nextcloud e due
+// chiavi API — copiarle avrebbe messo dei segreti in un secondo file, cioe' un
+// altro posto da ruotare e da cui possono uscire, proprio dentro la directory
+// che serve a tenerli separati.
+//
+// Niente `--strict-mcp-config`: la configurazione di progetto deve continuare a
+// valere, ed e' il punto in cui si innestera' un elenco per-cella.
+//
+// UN SOLO TOKEN, con l'uguale. `--mcp-config` e' VARIADICO e nella forma
+// spaziata consuma ogni argomento successivo che non inizi per `-` — compreso
+// il prompt della cella, che viene accodato come posizionale in fondo
+// all'argv. Misurato sul client installato:
+//   --mcp-config <file> ciao-prompt -> «MCP config file not found: .../ciao-prompt»
+//   --mcp-config=<file> ciao-prompt -> nessun errore, un solo file letto
+// Non riportarlo alla forma spaziata «per leggibilita'»: rompe ogni cella che
+// abbia un prompt, cioe' quelle vere.
+//
+// Fail-safe: un file assente, illeggibile o senza `mcpServers` non aggiunge il
+// flag. Senza strumenti si lavora peggio; con un flag che punta al vuoto la
+// cella non parte affatto.
+function sharedMcpArgs(home) {
+  const file = path.join(home, '.claude.json');
+  try {
+    const st = fs.lstatSync(file);
+    if (st.isSymbolicLink() || !st.isFile() || st.size > 8 * 1024 * 1024) return [];
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const servers = parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed.mcpServers : null;
+    if (!servers || typeof servers !== 'object' || Array.isArray(servers)
+      || !Object.keys(servers).length) return [];
+  } catch (_) {
+    return [];
+  }
+  return [`--mcp-config=${file}`];
+}
+
+// Quali server MCP esistono, per NOME. Si guarda dove il client li prende.
+// Non si legge nient'altro di quei file: servono solo i nomi.
+//
+// TRE SORGENTI, non due. Il local scope vive nello STESSO file della
+// configurazione utente ma in un ramo diverso — `projects[<cwd>].mcpServers`,
+// indicizzato sul percorso assoluto — ed e' reale: su questa installazione nove
+// progetti ne hanno, fra cui la directory di lavoro delle celle. Dimenticarlo
+// significava che un elenco parziale non negava server che la sessione carica
+// davvero, e l'operatore avrebbe creduto di averli esclusi. Trovato dall'audit.
+//
+// RESTANO FUORI, e non sono enumerabili da qui: plugin, connettori claude.ai e
+// la configurazione gestita di sistema. Per quelli l'unica esclusione certa e'
+// `mcp: []`, che usa il jolly e non dipende da nessuna enumerazione. La finestra
+// lo dice all'operatore invece di lasciarglielo credere.
+function knownMcpServerNames(home, cwd) {
+  const nomi = new Set();
+  const raccogli = (servers) => {
+    if (servers && typeof servers === 'object' && !Array.isArray(servers)) {
+      for (const nome of Object.keys(servers)) nomi.add(nome);
+    }
+  };
+  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; /* un file assente o illeggibile non e' un errore qui */ }
+  };
+  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 nomi;
+}
+
+// Gli strumenti MCP che questa cella deve avere, per NOME.
+//
+// SI CONCEDE NEGANDO IL COMPLEMENTO, non permettendo l'eccezione. Misurato sul
+// client installato, in tre configurazioni, perche' l'intera funzione poggia su
+// questo — `mcp: []` PROMETTE che non ci sono strumenti:
+//   1. deny e allow nello STESSO file  -> vince il deny;
+//   2. deny e allow in DUE sorgenti `--settings` distinte -> vince il deny;
+//   3. un `allow` di progetto in un workspace non fidato viene ignorato dal
+//      client prima ancora di arrivare al confronto.
+// Non e' provato il caso di un `allow` a livello utente in un workspace fidato:
+// richiederebbe di modificare la configurazione reale dell'operatore. Dato il
+// verso costante delle prime due, l'attesa e' che il deny vinca anche li'.
+//
+// `mcp: []` usa il jolly, e questo caso e' ESATTO: non dipende da quali server
+// esistono ne' da dove arrivano. E' la cella di cui non ci si fida, ed e' giusto
+// che sia il caso senza approssimazioni.
+//
+// Un elenco parziale nega il complemento di cio' che si riesce a enumerare
+// (le tre sorgenti in `knownMcpServerNames`). RESIDUO DICHIARATO: plugin,
+// connettori e configurazione gestita di sistema non sono enumerabili da qui, e
+// un server che arrivasse da li' non verrebbe negato. Non lo nascondo dietro un
+// nome rassicurante: chi vuole la garanzia certa usa `mcp: []`, e la finestra
+// lo dice.
+//
+// Nessun file per cella: la lista viaggia in argv e contiene SOLO NOMI. Le
+// definizioni — e le credenziali che alcune portano nel proprio `env` — restano
+// nell'unico posto dove vivono.
+//
+// Forma con l'uguale, come `--mcp-config`: un solo token, cosi' nessun argomento
+// successivo puo' essere inghiottito.
+function cellMcpArgs(home, cell) {
+  const voluti = cell && Array.isArray(cell.mcp) ? cell.mcp : null;
+  if (!voluti) return [];
+  if (!voluti.length) return [`--settings=${JSON.stringify({ permissions: { deny: ['mcp__*'] } })}`];
+  const concessi = new Set(voluti);
+  const deny = [...knownMcpServerNames(home, cell.cwd)]
+    .filter((nome) => !concessi.has(nome)).sort().map((nome) => `mcp__${nome}`);
+  if (!deny.length) return [];
+  return [`--settings=${JSON.stringify({ permissions: { deny } })}`];
+}
+
 function ensurePrivateClaudeConfig(home, profileId, label, penguinMode) {
   const nexusDir = path.join(home, '.nexuscrew');
   const profilesDir = path.join(nexusDir, 'claude-profiles');
@@ -763,13 +948,27 @@ function writePiProviderExtension(spec, home) {
 }
 
 function resolveManagedEngine(engine, cell, cfg = {}) {
-  const spec = normalizeManagedSpec(engine.managed);
+  // `extraModels` DEVE arrivare fin qui. Threadarlo al chiamante e alla vista
+  // non basta: la normalizzazione che decide se la cella PARTE e' questa, e
+  // senza l'elenco dichiarato un modello legittimo diventa «invalid managed
+  // profile» — cioe' una cella che non si avvia per una ragione invisibile.
+  // E' il difetto che l'audit ha ripreso due volte: la vista diceva di si',
+  // il boot diceva di no, e nessun test guardava il boot.
+  const spec = normalizeManagedSpec(engine.managed, { extraModels: cfg.extraModels || null });
   const info = describeManaged(spec, cfg);
   if (!spec || !info.configured) return { ok: false, reason: info.reason, info };
   const home = cfg.home || require('node:os').homedir();
   const profile = profileFor(spec.client, spec.provider, spec.credentialProfile || '');
   const cred = credential(profile, spec, cfg, home);
-  const env = {}; const args = []; const model = cell?.model || spec.model;
+  // L'override PER-CELLA va canonicalizzato come lo spec: `normalizeManagedSpec`
+  // applica l'alias a `spec.model`, ma `cell.model` lo scavalca DOPO e senza
+  // passare di li'. Senza questo, un nome legacy per-cella finisce in argv e in
+  // env, e i rami di trattamento (che confrontano il nome nuovo) non scattano:
+  // la cella parte, sembra a posto, e gira con i parametri sbagliati.
+  const env = {}; const args = []; const model = canonicalModel(cell?.model || spec.model);
+  // I due profili Claude con configurazione privata: perdono gli MCP del file
+  // principale e vanno ricollegati (vedi `sharedMcpArgs`).
+  let privateProfile = false;
   // Effective permission policy: override PER-CELL PER-ENGINE (remembered) vince sul
   // default dell'engine. Mai si mutationa engine.managed.permissionPolicy (globale).
   // Pi resta sempre 'standard' (lo spec normalized rifiuta gia' unsafe per pi).
@@ -810,6 +1009,7 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
         CLAUDE_CODE_SUBAGENT_MODEL: model, API_TIMEOUT_MS: '3000000',
       });
     } else if (spec.provider === 'kimi-code') {
+      privateProfile = true;
       const contextWindow = model === 'k3[1m]' ? '1048576' : '262144';
       Object.assign(env, {
         CLAUDE_CONFIG_DIR: ensureKimiClaudeConfig(home),
@@ -826,12 +1026,13 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
         env.CLAUDE_CODE_ALWAYS_ENABLE_EFFORT = '1';
       }
     } else if (spec.provider === 'alibaba-token-plan') {
-      const qwen38 = model === 'qwen3.8-max-preview';
+      privateProfile = true;
+      const qwen38 = model === 'qwen3.8-max';
       const aliases = qwen38 ? {
-        ANTHROPIC_MODEL: 'qwen3.8-max-preview',
-        ANTHROPIC_DEFAULT_FABLE_MODEL: 'qwen3.8-max-preview',
-        ANTHROPIC_DEFAULT_OPUS_MODEL: 'qwen3.8-max-preview',
-        ANTHROPIC_DEFAULT_SONNET_MODEL: 'qwen3.8-max-preview',
+        ANTHROPIC_MODEL: 'qwen3.8-max',
+        ANTHROPIC_DEFAULT_FABLE_MODEL: 'qwen3.8-max',
+        ANTHROPIC_DEFAULT_OPUS_MODEL: 'qwen3.8-max',
+        ANTHROPIC_DEFAULT_SONNET_MODEL: 'qwen3.8-max',
         ANTHROPIC_DEFAULT_HAIKU_MODEL: 'qwen3.6-flash',
         CLAUDE_CODE_SUBAGENT_MODEL: 'qwen3.7-max',
       } : {
@@ -869,6 +1070,12 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
       });
     }
     if (model) args.push('--model', model);
+    // 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));
   } 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;
@@ -892,7 +1099,7 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
       env.ALIBABA_CODE_API_KEY = cred.value;
       args.push(...codexProviderArgs('alibaba_token_plan', 'Alibaba Token Plan Personal', profile.endpoint, 'ALIBABA_CODE_API_KEY'));
       args.push('-c', 'model_providers.alibaba_token_plan.stream_idle_timeout_ms=600000');
-      if (model === 'qwen3.8-max-preview') {
+      if (model === 'qwen3.8-max') {
         const localCatalog = path.join(__dirname, 'catalogs', 'alibaba-token-plan-qwen3.8.json');
         args.push('-c', `model_catalog_json=${JSON.stringify(localCatalog)}`);
         args.push('-c', `model_context_window=${ALIBABA_TOKEN_PLAN_CONTEXT}`);
@@ -912,7 +1119,7 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
     }, home));
     if (spec.provider !== 'native') args.push('--provider', spec.provider === 'custom' ? spec.providerId : profile.piProvider);
     if (model) args.push('--model', model);
-    if (spec.provider === 'alibaba-token-plan' && model === 'qwen3.8-max-preview') args.push('--thinking', 'xhigh');
+    if (spec.provider === 'alibaba-token-plan' && model === 'qwen3.8-max') args.push('--thinking', 'xhigh');
   } else if (spec.client === 'agy') {
     // Agy delega l'autenticazione al proprio login locale (auth: 'login'): niente
     // env provider, niente credenziali copiate. Argv diretto: --model prima del
@@ -972,11 +1179,13 @@ function publicCatalog() {
 }
 
 module.exports = {
+  knownMcpServerNames,
   CATALOG, OLLAMA_CLOUD_MODELS, OLLAMA_CONTEXT, ALIBABA_TOKEN_PLAN_MODELS,
   ALIBABA_CODEX_MODELS, ALIBABA_TOKEN_PLAN_CONTEXT, ALIBABA_PI_MODELS,
   CLIENT_LABELS, normalizeManagedSpec, profileFor,
   defaultDefinitions, defaultShellEngine, defaultAgyEngine, defaultKimiEngine, describeManaged, describeCatalogCredential, discoverOllamaModels, resolveManagedEngine, needsExplicitNode,
   discoverPiModels, EXTERNAL_DISCOVERY_TIMEOUT_MS, parseEnvFile, parseProviderShellFile, findBinary, publicCatalog, writePiProviderExtension,
+  extraModelsFrom,
   providerKeyPaths, parseProviderKeyFiles, credentialSources, credential,
   credentialEnvNeutralizeSet, applyStoreNeutralization,
   ensureKimiClaudeConfig, ensureAlibabaClaudeConfig, resolveInteractiveShell,

package/lib/fleet/model-probe.js

@@ -0,0 +1,129 @@
+'use strict';
+// lib/fleet/model-probe.js — «questo modello funziona davvero con questa
+// credenziale?», chiesto all'API invece che indovinato.
+//
+// Oggi un id sbagliato si scopre quando la cella non parte, e il messaggio non
+// dice se il problema e' il nome del modello, la chiave o la rete. Qui la
+// domanda si fa prima, e la risposta e' un enum chiuso.
+//
+// COSTO: si interroga l'elenco dei modelli (`GET .../models`) e nient'altro.
+// Non si genera testo, quindi non si consumano token. Dove il catalogo non
+// esiste l'esito e' `unverified`: NON si ricade su una richiesta di
+// completamento, per quanto minima. Una prova che costa e' una prova che chi
+// la guarda impara a non fare — e allora tanto vale non averla.
+//
+// COSA NON ESCE MAI DA QUI:
+//   - il testo che il modello eventualmente genera: non viene letto, non viene
+//     registrato, non entra nell'esito. Vale la stessa disciplina dei
+//     diagnostici, che rifiutano contenuto grezzo;
+//   - la credenziale: viaggia nell'header e non compare in nessun ritorno,
+//     nemmeno nei dettagli di errore;
+//   - il corpo della risposta remota: se ne estrae al massimo un codice noto.
+//
+// `unverified` NON e' `ok`: una prova non ottenuta non autorizza a dichiarare
+// che il modello funziona. E' la stessa regola per cui un device che ri-poll
+// senza confermare produce `delivery-unknown` e non un successo.
+
+const OUTCOMES = Object.freeze(['ok', 'unknown-model', 'auth', 'unreachable', 'unverified']);
+
+// Un tetto basso: la prova serve a rispondere subito, non a insistere. Chi ha
+// un endpoint lento lo scoprira' dal `unreachable`, che e' un'informazione.
+const DEFAULT_TIMEOUT_MS = 8000;
+
+function joinUrl(base, path) {
+  const b = String(base || '').replace(/\/+$/, '');
+  return `${b}/${String(path || '').replace(/^\/+/, '')}`;
+}
+
+// L'elenco modelli sta sotto `/models` per le API in stile OpenAI. Gli
+// endpoint anthropic-compatibili spesso non lo espongono: e' il caso in cui si
+// ricade sul completamento minimo.
+function modelsUrl(profile) {
+  const endpoint = profile && profile.endpoint;
+  if (typeof endpoint !== 'string' || !/^https?:\/\//.test(endpoint)) return null;
+  return joinUrl(endpoint, 'models');
+}
+
+function authHeaders(profile, credential) {
+  const protocol = profile && profile.protocol;
+  if (protocol === 'anthropic_messages') {
+    return { 'x-api-key': credential, 'anthropic-version': '2023-06-01' };
+  }
+  return { authorization: `Bearer ${credential}` };
+}
+
+// Cerca l'id fra i modelli elencati. Le forme note sono `{data:[{id}]}` (OpenAI)
+// e `{models:[{name|id}]}` (Ollama): non si indovina oltre — un elenco che non
+// si sa leggere produce `unverified`, non un falso negativo.
+function findInCatalog(payload, model) {
+  const rows = Array.isArray(payload && payload.data) ? payload.data
+    : Array.isArray(payload && payload.models) ? payload.models : null;
+  if (!rows) return null;
+  const wanted = String(model);
+  // Il tag fa parte dell'identita' su alcuni fornitori (`deepseek-v4-flash:0731`)
+  // e su altri no: si accetta la corrispondenza esatta o quella sul nome base.
+  const base = wanted.split(':')[0];
+  return rows.some((row) => {
+    const id = typeof row === 'string' ? row : (row && (row.id || row.name));
+    if (typeof id !== 'string') return false;
+    return id === wanted || id === base || id.split(':')[0] === wanted;
+  });
+}
+
+// probeModel({profile, credential, model, fetchImpl, timeoutMs})
+//   -> {outcome, latencyMs, detail?}
+async function probeModel({
+  profile, credential, model, fetchImpl = fetch, timeoutMs = DEFAULT_TIMEOUT_MS,
+} = {}) {
+  if (!profile || typeof model !== 'string' || !model) {
+    return { outcome: 'unverified', latencyMs: 0, detail: 'parametri non validi' };
+  }
+  if (typeof credential !== 'string' || !credential) {
+    // Nessuna chiave: e' un esito, non un errore da nascondere. Dirlo qui
+    // evita una chiamata che sarebbe rifiutata comunque.
+    return { outcome: 'auth', latencyMs: 0, detail: 'credenziale assente' };
+  }
+  const url = modelsUrl(profile);
+  if (!url) {
+    // Endpoint non HTTP (account gestiti, provider locali senza catalogo):
+    // non si inventa una prova.
+    return { outcome: 'unverified', latencyMs: 0, detail: 'endpoint non interrogabile' };
+  }
+
+  const started = Date.now();
+  const controller = new AbortController();
+  const budget = Number.isInteger(timeoutMs) ? Math.max(500, Math.min(timeoutMs, 30000)) : DEFAULT_TIMEOUT_MS;
+  const timer = setTimeout(() => controller.abort(), budget);
+  try {
+    const res = await fetchImpl(url, {
+      method: 'GET', signal: controller.signal, headers: authHeaders(profile, credential),
+    });
+    const latencyMs = Date.now() - started;
+    const status = res && typeof res.status === 'number' ? res.status : 0;
+    if (status === 401 || status === 403) return { outcome: 'auth', latencyMs };
+    // 404/405: questo fornitore non espone il catalogo. Non e' un fallimento
+    // del modello, ed e' scorretto riportarlo come tale.
+    if (status === 404 || status === 405 || status === 501) {
+      return { outcome: 'unverified', latencyMs, detail: 'catalogo non esposto' };
+    }
+    if (status < 200 || status >= 300) return { outcome: 'unverified', latencyMs, detail: `http ${status}` };
+
+    let payload = null;
+    try { payload = typeof res.json === 'function' ? await res.json() : null; } catch (_) { payload = null; }
+    const found = findInCatalog(payload, model);
+    if (found === null) return { outcome: 'unverified', latencyMs, detail: 'catalogo non leggibile' };
+    return found ? { outcome: 'ok', latencyMs } : { outcome: 'unknown-model', latencyMs };
+  } catch (error) {
+    const latencyMs = Date.now() - started;
+    // Un abort e' il nostro timeout, non un rifiuto del fornitore.
+    const aborted = error && (error.name === 'AbortError' || error.code === 'ABORT_ERR');
+    return {
+      outcome: 'unreachable', latencyMs,
+      detail: aborted ? `timeout (${budget}ms)` : 'endpoint non raggiungibile',
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+module.exports = { probeModel, OUTCOMES, findInCatalog, modelsUrl };

package/lib/fleet/routes.js

@@ -152,6 +152,32 @@ function fleetRoutes(fleetP, cfg = {}) {
   r.post('/credentials/remove', guard((f, b) => {
     requireCap(f, 'credentials'); return f.removeLocalCredential(String(b.envKey || ''));
   }, { mutate: true }));
+  // Prova di un modello sull'API del suo profilo. E' nell'allowlist federata:
+  // chi e' accoppiato amministra il nodo remoto come farebbe in locale, e un
+  // modello che non si puo' provare a distanza si finisce per provarlo facendo
+  // partire la cella — cioe' nel modo peggiore. La credenziale si risolve dove
+  // la prova gira e non attraversa il router.
+  // Qui non e' gated da READONLY, per la stessa ragione di `nodes test`: e' una
+  // diagnosi, non una mutazione. Sulla via FEDERATA invece READONLY la blocca,
+  // perche' li' la richiesta autenticata partirebbe da un nodo dichiarato di
+  // sola lettura su comando di qualcun altro.
+  r.post('/model-test', guard((f, b) => {
+    requireCap(f, 'model-test');
+    if (typeof f.testModel !== 'function') {
+      const e = new Error('not supported by this fleet provider'); e.status = 501; throw e;
+    }
+    return f.testModel(String(b.engine || ''), String(b.model || ''));
+  }));
+  r.post('/define-model', guard((f, b) => {
+    requireCap(f, 'define');
+    if (typeof f.defineModel !== 'function') { const e = new Error('not supported by this fleet provider'); e.status = 501; throw e; }
+    return f.defineModel(b.def);
+  }, { mutate: true }));
+  r.post('/remove-model', guard((f, b) => {
+    requireCap(f, 'remove');
+    if (typeof f.removeModel !== 'function') { const e = new Error('not supported by this fleet provider'); e.status = 501; throw e; }
+    return f.removeModel(String(b.id || ''), String(b.engine || ''));
+  }, { mutate: true }));
   r.post('/define-engine', guard((f, b) => { requireCap(f, 'define'); return f.defineEngine(b.def); }, { mutate: true }));
   r.post('/edit-engine', guard((f, b) => { requireCap(f, 'edit'); return f.editEngine(b.id, b.patch, b.envChanges); }, { mutate: true }));
   r.post('/remove-engine', guard((f, b) => { requireCap(f, 'remove'); return f.removeEngine(b.id); }, { mutate: true }));
@@ -162,7 +188,7 @@ function fleetRoutes(fleetP, cfg = {}) {
   r.post('/restore-engines', guard((f, b) => {
     requireCap(f, 'restore');
     if (typeof f.restoreEngines !== 'function') { const e = new Error('not supported by this fleet provider'); e.status = 501; throw e; }
-    return f.restoreEngines(b.engines, { overwrite: b.overwrite === true });
+    return f.restoreEngines(b.engines, { overwrite: b.overwrite === true, models: b.models });
   }, { mutate: true }));
   // Riconciliazione sessione tmux esistente (cella Fleet legacy orfana) in cella
   // gestita fleet.json.

package/lib/fleet/runtime.js

@@ -17,7 +17,7 @@ const {
   loadDefinitions, validateCommandTrust, resolveCwd,
 } = require('./definitions.js');
 const {
-  describeManaged, resolveManagedEngine, discoverOllamaModels, discoverPiModels,
+  describeManaged, resolveManagedEngine, discoverOllamaModels, discoverPiModels, extraModelsFrom,
 } = require('./managed.js');
 const {
   httpError, minimalEnv, tmuxExec,
@@ -125,7 +125,7 @@ function createBuiltinRuntime(ctx) {
       needsPi ? discoverPiModels({ ...cfg, home }) : {},
     ]);
     const engines = cache.defs.engines.map((e) => {
-      const managed = e.managed ? describeManaged(e.managed, { ...cfg, home }) : null;
+      const managed = e.managed ? describeManaged(e.managed, { ...cfg, home, extraModels: extraModelsFrom(cache.defs) }) : null;
       return {
         id: e.id, label: e.label, rc: !!e.rc,
         ...(managed ? {
@@ -164,7 +164,7 @@ 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 });
+      const resolved = resolveManagedEngine(engine, cell, { ...cfg, home, extraModels: extraModelsFrom(defs) });
       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 });