@mmmbuto/nexuscrew 0.8.58 → 0.9.1

package/lib/fleet/managed.js

@@ -57,16 +57,33 @@ function declaredFor(extraModels, profileId, model) {
 // 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.
+//
+// D2: Map<engine, Map<id, model>> — porta il descrittore intero, non solo
+// l'id (stesso motivo del commento gemello in definitions.js: extraModels e'
+// costruita due volte, una dentro parseDefinitions per il parsing, una qui per
+// il runtime che rilegge le definizioni gia' salvate; le due DEVONO restare
+// nella stessa forma).
 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);
+    if (!map.has(m.engine)) map.set(m.engine, new Map());
+    map.get(m.engine).set(m.id, m);
   }
   return map;
 }
 
+// I descrittori dichiarati per UN profilo (client.provider, es.
+// 'codex-vl.custom'), come array. Chi ha bisogno solo del catalogo dei
+// modelli (customCatalogFor, writePiProviderExtension) chiama questa; chi ha
+// bisogno solo di validare un id (declaredFor) continua a usare extraModels
+// direttamente — due bisogni diversi sulla STESSA struttura, non due copie.
+function declaredModelsFor(extraModels, profileId) {
+  if (!extraModels || typeof extraModels.get !== 'function') return [];
+  const byId = extraModels.get(profileId);
+  return byId && typeof byId.values === 'function' ? [...byId.values()] : [];
+}
+
 function canonicalModel(model) {
   const key = String(model || '');
   return Object.hasOwn(MODEL_ALIASES, key) ? MODEL_ALIASES[key] : model;
@@ -120,22 +137,28 @@ const ALIBABA_PI_MODELS = Object.freeze([
 // per distinguere il rifiuto di wire dal payload perso in traduzione).
 //
 // Cosa NON e' in elenco, e perche' non e' una svista:
-//  - kimi-*, deepseek-v4-pro, mimo-v2.5*, hy3 fuori da Messages/Responses: il
-//    gateway inoltra un payload vuoto e l'upstream risponde "messages must not
-//    be empty". E' un difetto loro, reversibile senza preavviso: se un giorno
-//    rispondono, l'id si dichiara per quell'engine senza toccare il codice.
+//  - kimi-*, mimo-v2.5*, hy3 fuori da Messages/Responses: il gateway inoltra
+//    un payload vuoto e l'upstream risponde "messages must not be empty". E' un
+//    difetto loro, reversibile senza preavviso: se un giorno rispondono, l'id
+//    si dichiara per quell'engine senza toccare il codice.
+//  - deepseek-v4-pro: MISURATO 2026-08-13 sul gateway opencode.ai/zen/go ->
+//    200 su /v1/responses (status=completed) e 200 su /v1/messages
+//    (stop_reason=end_turn), auth x-api-key. DeepSeek ha aggiunto la Responses
+//    API a v4-pro il 13/08 (l'11/08 era escluso: "messages must not be empty"):
+//    per questo ora entra in MESSAGES e RESPONSES. Se smettesse di rispondere,
+//    andrebbe rimosso di nuovo — e questo commento va tenuto allineato al codice.
 //  - mimo-v2-pro e mimo-v2-omni: deprecati dall'upstream ("migrate to
 //    xiaomi/mimo-v2.5*"). hy3-preview: "Model is unavailable".
 //    Il catalogo live li pubblicizza comunque; qui non entrano.
 //  - grok-4.5 solo su Responses: su Chat risponde 503 e Messages lo rifiuta
 //    esplicitamente ("not supported for format anthropic").
 const OPENCODE_GO_MESSAGES_MODELS = Object.freeze([
-  'deepseek-v4-flash', 'glm-5.2', 'glm-5.1', 'glm-5',
+  'deepseek-v4-flash', 'deepseek-v4-pro', 'glm-5.2', 'glm-5.1', 'glm-5',
   'minimax-m3', 'minimax-m2.7', 'minimax-m2.5',
   'qwen3.8-max', 'qwen3.7-max', 'qwen3.7-plus', 'qwen3.6-plus', 'qwen3.5-plus',
 ]);
 const OPENCODE_GO_RESPONSES_MODELS = Object.freeze([
-  'deepseek-v4-flash', 'gpt-5.6-luna', 'grok-4.5', 'glm-5.2', 'glm-5.1', 'glm-5',
+  'deepseek-v4-flash', 'deepseek-v4-pro', 'gpt-5.6-luna', 'grok-4.5', 'glm-5.2', 'glm-5.1', 'glm-5',
 ]);
 const OPENCODE_GO_CHAT_MODELS = Object.freeze([
   'deepseek-v4-flash', 'deepseek-v4-pro', 'glm-5.2', 'glm-5.1', 'glm-5',
@@ -206,11 +229,26 @@ const OPENCODE_GO_PI_MODELS = Object.freeze(OPENCODE_GO_CHAT_MODELS.map((id) =>
 })));
 
 const CUSTOM_KEYS = ['displayName', 'protocol', 'baseUrl', 'envKey', 'providerId'];
-const MANAGED_KEYS = new Set(['client', 'provider', 'credentialProfile', 'model', 'permissionPolicy', 'credentialSourcePolicy', ...CUSTOM_KEYS]);
+const MANAGED_KEYS = new Set(['client', 'provider', 'credentialProfile', 'model', 'permissionPolicy', 'credentialSourcePolicy', 'envPassthrough', ...CUSTOM_KEYS]);
+// D3: massimo numero di nomi in `envPassthrough`. L'allowlist e' opt-in e per
+// nome, mai un passthrough in blocco: un tetto basso ferma una lista incontrollata.
+const MAX_ENV_PASSTHROUGH = 32;
 // Explicit credential source policy. Default 'auto' preserves the legacy
 // resolution order (runtime -> store -> shell -> key files -> legacy) so a
 // pre-WP1 fleet.json migrates no-op: no existing cell changes resolution.
 const CREDENTIAL_SOURCES = Object.freeze(['environment', 'nexuscrew-store', 'auto']);
+// I valori che `credential().source` puo' assumere, e che escono verso la UI in
+// `describeManaged().credentialSource` / `describeCatalogCredential()`. La UI li
+// rende con la chiave `fleet-credential-source-<valore>`, e `t()` su chiave
+// assente restituisce LA CHIAVE: un valore nuovo senza traduzione si vede a
+// schermo come stringa tecnica. Questa lista e' l'ancora della sonda in
+// tests/i18n.test.js — la parita' fra le tre lingue e' gia' garantita da un
+// altro test, qui si garantisce la COPERTURA dei valori che il backend produce.
+// Chi aggiunge un valore in credential() aggiunge una riga qui e la stringa nei
+// tre dizionari, oppure il gate lo ferma.
+const CREDENTIAL_SOURCE_VALUES = Object.freeze([
+  'login', 'none', 'environment', 'nexuscrew-store', 'local', 'compatibility', 'missing', 'unreadable',
+]);
 const CLIENT_LABELS = Object.freeze({ claude: 'Claude Code', codex: 'Codex', 'codex-vl': 'Codex-VL', grok: 'Grok', vl: 'VL', pi: 'Pi', agy: 'Agy', kimi: 'Kimi Code CLI', shell: 'Shell' });
 const PROVIDER_ID_RE = /^[a-z][a-z0-9_-]{0,31}$/;
 
@@ -237,7 +275,12 @@ const CATALOG = Object.freeze([
   { 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', models: ALIBABA_TOKEN_PLAN_MODELS, strictModels: true, core: true, notice: 'alibaba-token-plan' },
   { 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.zai', client: 'claude', provider: 'zai', label: 'Z.AI', auth: 'dynamic', credentialEnv: true, defaultEnvKey: 'ZAI_API_KEY', endpoint: 'https://api.z.ai/api/anthropic', protocol: 'anthropic_messages', model: 'glm-5.2[1m]', models: ['glm-5.2[1m]'], core: true },
+  // GLM-5.3 dal 2026-08-15. Sul Coding Plan lo switch e' gia' automatico —
+  // chiedendo `glm-5.2` il server risponde `glm-5.3` — ma il nome scritto qui
+  // deve dire la verita' su cosa stiamo usando. Il suffisso `[1m]` resta: e' un
+  // flag di finestra del CLI e viene tolto prima della richiesta HTTP, dove
+  // `glm-5.3[1m]` letterale darebbe 400 (code 1214, misurato).
+  { id: 'claude.zai', client: 'claude', provider: 'zai', label: 'Z.AI', auth: 'dynamic', credentialEnv: true, defaultEnvKey: 'ZAI_API_KEY', endpoint: 'https://api.z.ai/api/anthropic', protocol: 'anthropic_messages', model: 'glm-5.3[1m]', models: ['glm-5.3[1m]', 'glm-5.2[1m]'], core: true },
   // OpenCode Go su Claude parla Anthropic Messages, e la wire accetta SOLO
   // `x-api-key`: con `Authorization: Bearer` risponde 401 AuthError. Per questo
   // l'endpoint e' la root senza `/v1` (il client aggiunge `/v1/messages`) e il
@@ -317,7 +360,7 @@ const CATALOG = Object.freeze([
   { id: 'pi.github-copilot', client: 'pi', provider: 'github-copilot', label: 'GitHub Copilot', auth: 'login', protocol: 'pi_native', piProvider: 'github-copilot', core: true },
   { id: 'pi.deepseek', client: 'pi', provider: 'deepseek', label: 'DeepSeek', auth: 'DEEPSEEK_API_KEY', protocol: 'pi_native', piProvider: 'deepseek', core: true },
   // Provider Pi NON core: restano fuori dal catalogo UI (publicCatalog filtra
-  // core/default/custom), in attesa di decisione DAG. Vengono risolti solo da
+  // core/default/custom), in attesa di una decisione di progetto. Vengono risolti solo da
   // configurazione esistente via profileFor. Etichette senza prefisso "Pi · ".
   { id: 'pi.fireworks', client: 'pi', provider: 'fireworks', label: 'Fireworks AI', auth: 'FIREWORKS_API_KEY', protocol: 'pi_native', piProvider: 'fireworks' },
   { id: 'pi.huggingface', client: 'pi', provider: 'huggingface', label: 'Hugging Face', auth: 'HF_TOKEN', protocol: 'pi_native', piProvider: 'huggingface' },
@@ -356,8 +399,8 @@ const CATALOG = Object.freeze([
   // --- Sezione legacy --------------------------------------------------------
   // Compatibilita' sola lettura/launch per configurazioni 0.8.0: mai nel catalogo
   // UI (publicCatalog filtra `legacy`). Risolti solo da profileFor/normalizeManagedSpec.
-  { id: 'claude.zai-a', client: 'claude', provider: 'zai', credentialProfile: 'a', label: 'Z.AI legacy profile', auth: 'ZAI_API_KEY_A', endpoint: 'https://api.z.ai/api/anthropic', protocol: 'anthropic_messages', model: 'glm-5.2[1m]', models: ['glm-5.2[1m]'], legacySecrets: true, legacyProvider: 'zai-a', legacy: true },
-  { id: 'claude.zai-p', client: 'claude', provider: 'zai', credentialProfile: 'p', label: 'Z.AI legacy profile', auth: 'ZAI_API_KEY_P', endpoint: 'https://api.z.ai/api/anthropic', protocol: 'anthropic_messages', model: 'glm-5.2[1m]', models: ['glm-5.2[1m]'], legacySecrets: true, legacyProvider: 'zai-p', legacy: true },
+  { id: 'claude.zai-a', client: 'claude', provider: 'zai', credentialProfile: 'a', label: 'Z.AI legacy profile', auth: 'ZAI_API_KEY_A', endpoint: 'https://api.z.ai/api/anthropic', protocol: 'anthropic_messages', model: 'glm-5.3[1m]', models: ['glm-5.3[1m]', 'glm-5.2[1m]'], legacySecrets: true, legacyProvider: 'zai-a', legacy: true },
+  { id: 'claude.zai-p', client: 'claude', provider: 'zai', credentialProfile: 'p', label: 'Z.AI legacy profile', auth: 'ZAI_API_KEY_P', endpoint: 'https://api.z.ai/api/anthropic', protocol: 'anthropic_messages', model: 'glm-5.3[1m]', models: ['glm-5.3[1m]', 'glm-5.2[1m]'], legacySecrets: true, legacyProvider: 'zai-p', legacy: true },
 ]);
 
 function profileFor(client, provider, credentialProfile) {
@@ -428,6 +471,27 @@ function normalizeManagedSpec(value, { extraModels = null } = {}) {
     if (!model || !(profile.protocols || [profile.protocol]).includes(protocol)) return null;
     Object.assign(out, { displayName, baseUrl, envKey, protocol, providerId });
   }
+  // D3: envPassthrough e' un'allowlist di NOMI di variabili d'ambiente che il
+  // child deve ricevere, risolti a runtime dalle credentialSources (dopo i rami
+  // provider in resolveManagedEngine). E' opt-in e per nome: MAI un passthrough
+  // in blocco dell'ambiente, solo i nomi elencati — ciascuno un nome env valido.
+  // E il mezzo con cui una cella vl (auth 'none', ramo senza env provider) riceve
+  // le variabili che il suo runtime legge: il nome non e' fisso nel codice vl
+  // (vivling/src/main.rs), quindi lo dichiara l'operatore che conosce la sua config.
+  if (value.envPassthrough !== undefined) {
+    if (!Array.isArray(value.envPassthrough) || !value.envPassthrough.length
+      || value.envPassthrough.length > MAX_ENV_PASSTHROUGH) return null;
+    const seen = new Set();
+    const names = [];
+    for (const raw of value.envPassthrough) {
+      if (typeof raw !== 'string') return null;
+      const name = raw.trim();
+      if (!ENV_KEY_RE.test(name) || seen.has(name)) return null;
+      seen.add(name);
+      names.push(name);
+    }
+    out.envPassthrough = names;
+  }
   return out;
 }
 
@@ -535,7 +599,17 @@ function safeAllowedRoots(roots = []) {
   return out;
 }
 
-function parseEnvFile(file, opts = {}) {
+// `out.blocked` (accumulatore opzionale) raccoglie i file CHE ESISTONO ma non si
+// sono potuti leggere/verificare (EACCES/ELOOP/ENOTDIR/EIO...). I rifiuti
+// deliberati (symlink fuori roots, mode/uid/size non validi) restano `return {}`
+// espliciti — sono legittimi "questo file non e' una credenziale valida" — e NON
+// finiscono nei blocked. ENOENT nel catch e' "il file non c'e'" (legittimo, niente
+// valore); solo gli altri code sono "non ho potuto guardare", e vanno distinti dal
+// "missing" che il caller altrimenti riporterebbe per una credenziale presente ma
+// illeggibile. Il verdetto (niente valori estratti -> {}) e' invariato; il
+// discriminante e' CHI ha fallito, non che ci sia stata un'eccezione.
+function parseEnvFile(file, opts = {}, out) {
+  const blocked = Array.isArray(out && out.blocked) ? out.blocked : null;
   try {
     const lst = fs.lstatSync(file);
     let target = file;
@@ -549,16 +623,23 @@ function parseEnvFile(file, opts = {}) {
     if (!st.isFile() || st.isSymbolicLink() || (st.mode & 0o077) || st.size > 256 * 1024) return {};
     if (typeof process.getuid === 'function' && st.uid !== process.getuid()) return {};
     return parseAssignments(fs.readFileSync(target, 'utf8'));
-  } catch (_) { return {}; }
+  } catch (e) {
+    if (blocked && e.code !== 'ENOENT') blocked.push({ path: file, code: e.code || e.constructor.name });
+    return {};
+  }
 }
 
-function parseProviderShellFile(file) {
+function parseProviderShellFile(file, out) {
+  const blocked = Array.isArray(out && out.blocked) ? out.blocked : null;
   try {
     const st = fs.lstatSync(file);
     if (!st.isFile() || st.isSymbolicLink() || (st.mode & 0o022) || st.size > 256 * 1024) return {};
     if (typeof process.getuid === 'function' && st.uid !== process.getuid()) return {};
     return parseAssignments(fs.readFileSync(file, 'utf8'));
-  } catch (_) { return {}; }
+  } catch (e) {
+    if (blocked && e.code !== 'ENOENT') blocked.push({ path: file, code: e.code || e.constructor.name });
+    return {};
+  }
 }
 
 function binaryCandidates(client, home) {
@@ -575,14 +656,28 @@ function binaryCandidates(client, home) {
   ].filter(Boolean))];
 }
 
-function findBinary(client, home) {
+// `out.blocked` (accumulatore opzionale) raccoglie i candidati CHE ESISTONO come
+// nome nel PATH ma che non si sono potuti VERIFICARE (EACCES/ELOOP/ENOTDIR...),
+// non i candidati assenti (ENOENT = legittimo "prossimo"). Il verdetto del caller
+// non cambia: findBinary torna comunque null se nessun candidato e' confermato
+// (non possiamo dichiararlo "trovato"); ma chi costruisce il messaggio
+// (describeManaged) puo' ora distinguere "client non trovato" da "non ho potuto
+// verificare un candidato" — il discriminante e' CHI ha fallito, non che ci sia
+// stata un'eccezione. Stesso principio gia' applicato in checkTermuxExec (3134d2f).
+function findBinary(client, home, out) {
+  const blocked = Array.isArray(out && out.blocked) ? out.blocked : null;
   for (const candidate of binaryCandidates(client, home)) {
     try {
       const real = fs.realpathSync(candidate); const st = fs.lstatSync(real);
       if (!st.isFile() || !(st.mode & 0o100) || (st.mode & 0o002)) continue;
       if (typeof process.getuid === 'function' && st.uid !== process.getuid() && st.uid !== 0) continue;
       return real;
-    } catch (_) { /* next */ }
+    } catch (e) {
+      // ENOENT = il candidato non esiste (legittimo "prossimo"); qualsiasi altro
+      // code (EACCES/ELOOP/ENOTDIR/EIO...) = "esiste ma non ho potuto guardarlo",
+      // e va distinto dal "non trovato" finale, non collassato in "prossimo".
+      if (blocked && e.code !== 'ENOENT') blocked.push({ path: candidate, code: e.code || e.constructor.name });
+    }
   }
   return null;
 }
@@ -590,7 +685,7 @@ function findBinary(client, home) {
 // Resolve a device-local interactive shell without persisting a path in
 // fleet.json. Candidates are ordered and fail closed. Symlinks are resolved
 // first, then the existing command trust policy is applied to the real file.
-function resolveInteractiveShell(cfg = {}) {
+function resolveInteractiveShell(cfg = {}, out) {
   const env = cfg.env || process.env;
   const platform = cfg.platform || process.platform;
   const termux = termuxRuntimePaths(env, { platform, home: cfg.home });
@@ -603,11 +698,19 @@ function resolveInteractiveShell(cfg = {}) {
   candidates.push('/bin/bash', '/bin/sh');
   const validate = cfg.validateCommandTrust
     || ((command) => require('./definitions.js').validateCommandTrust(command));
+  const blocked = Array.isArray(out && out.blocked) ? out.blocked : null;
   for (const candidate of [...new Set(candidates)]) {
     try {
       const real = fs.realpathSync(candidate);
       if (validate(real).ok) return real;
-    } catch (_) { /* next candidate */ }
+    } catch (e) {
+      // ENOENT = il candidato non esiste (legittimo "prossimo"); altro code
+      // (EACCES/ELOOP/ENOTDIR...) = "non ho potuto verificare", da distinguere
+      // dal "nessuna shell" finale. validate() che torna ok:false NON e' un
+      // throw: e' un rifiuto legittimo (candidato presente ma non fidato), resta
+      // "prossimo" senza finire nei blocked — il discriminante e' CHI ha fallito.
+      if (blocked && e.code !== 'ENOENT') blocked.push({ path: candidate, code: e.code || e.constructor.name });
+    }
   }
   return null;
 }
@@ -672,34 +775,40 @@ function providerKeyPaths(cfg, home) {
   return [...new Set(paths.filter((file) => typeof file === 'string' && file))];
 }
 
-function parseProviderKeyFiles(cfg, home) {
+function parseProviderKeyFiles(cfg, home, out) {
   const values = {};
   // Match providers.zsh ordering: a later secure file may intentionally
   // override the canonical ai.env value. Files remain data-only and must be
   // private regular files owned by the NexusCrew user.
   const files = providerKeyPaths(cfg, home);
   const roots = [...new Set(files.map((file) => path.dirname(path.resolve(file))))];
-  for (const file of files) Object.assign(values, parseEnvFile(file, { allowSymlinkRoots: roots }));
+  for (const file of files) Object.assign(values, parseEnvFile(file, { allowSymlinkRoots: roots }, out));
   return values;
 }
 
-function credentialSources(cfg, home) {
+// `trackLegacy`: il file legacy viene letto sempre, ma e' una FONTE solo per i
+// profili con legacySecrets. Tracciarne l'illeggibilita' anche per gli altri
+// produce un messaggio che manda l'operatore a sistemare un permesso
+// irrilevante — «non verificabile» su un file che per quella chiave non conta
+// nulla, mentre la chiave e' davvero assente. Il tracciamento segue la fonte,
+// non la lettura.
+function credentialSources(cfg, home, out, { trackLegacy = true } = {}) {
   let local = {};
   try { local = readCredentialStore(cfg, home); } catch (_) { /* unsafe/corrupt store is ignored, never trusted */ }
   return {
     runtime: cfg.env || process.env,
     local,
-    shell: parseProviderShellFile(shellProvidersPath(cfg, home)),
-    keys: parseProviderKeyFiles(cfg, home),
-    legacy: parseEnvFile(secretsPath(cfg, home)),
+    shell: parseProviderShellFile(shellProvidersPath(cfg, home), out),
+    keys: parseProviderKeyFiles(cfg, home, out),
+    legacy: parseEnvFile(secretsPath(cfg, home), {}, trackLegacy ? out : undefined),
   };
 }
 
-function credential(profile, spec, cfg, home) {
+function credential(profile, spec, cfg, home, out) {
   if (profile.auth === 'login' || profile.auth === 'none') return { envKey: profile.auth, value: '', source: profile.auth };
   const envKey = profile.auth === 'dynamic' ? spec.envKey : profile.auth;
   const policy = spec && CREDENTIAL_SOURCES.includes(spec.credentialSourcePolicy) ? spec.credentialSourcePolicy : 'auto';
-  const sources = credentialSources(cfg, home);
+  const sources = credentialSources(cfg, home, out, { trackLegacy: !!profile.legacySecrets });
   // The fixed shell file is already the user's environment source. Values are
   // consumed only in memory and passed to the selected child; never persisted
   // in fleet.json, service files, API responses or logs.
@@ -719,7 +828,15 @@ function credential(profile, spec, cfg, home) {
   if (profile.legacySecrets && sources.legacy[envKey]) {
     return { envKey, value: sources.legacy[envKey], source: 'compatibility' };
   }
-  return { envKey, value: '', source: 'missing' };
+  // auto: nessuna fonte ha la chiave. Se un file credenziale esiste ma non si
+  // e' potuto leggere (EACCES/ELOOP...), non possiamo dichiarare la chiave
+  // "missing" (che implica "mettila su questo device"): e' "unreadable", non
+  // verificata. Il verdetto (niente valore -> authConfigured false) e' invariato;
+  // il messaggio di describeManaged lo distingue. environment/nexuscrew-store
+  // sopra restano 'missing': le loro fonti (runtime env / local store) non
+  // passano per i file parseEnvFile/parseProviderShellFile che tracciamo qui.
+  const unreadable = out && Array.isArray(out.blocked) && out.blocked.length;
+  return { envKey, value: '', source: unreadable ? 'unreadable' : 'missing' };
 }
 
 // The profile's "owned" env set. When the credential source is the local store,
@@ -839,22 +956,54 @@ async function discoverPiModels(opts = {}) {
 function describeManaged(spec, cfg = {}) {
   const extraModels = cfg.extraModels || null;
   const normalized = normalizeManagedSpec(spec, { extraModels });
-  if (!normalized) return { configured: false, reason: 'invalid managed profile' };
+  if (!normalized) {
+    // D2: il rifiuto resta (i descrittori NON appartengono al profilo di una
+    // cella: vengono dalla definizione dell'ENGINE, in `d.models` — due
+    // soggetti diversi, mescolarli renderebbe ambiguo chi dichiara cosa). Ma
+    // se la causa e' proprio questa, il messaggio generico "invalid managed
+    // profile" manda a cercare ovunque tranne che nel posto giusto: dice
+    // dove i descrittori vanno davvero.
+    if (spec && typeof spec === 'object' && !Array.isArray(spec)
+      && Object.prototype.hasOwnProperty.call(spec, 'models')) {
+      return {
+        configured: false,
+        reason: '"models" non e\' un campo del profilo managed della cella — i descrittori dei modelli si dichiarano nella definizione dell\'ENGINE, nell\'array "models" del documento (schemaVersion/engines/cells/models), non qui',
+      };
+    }
+    return { configured: false, reason: 'invalid managed profile' };
+  }
   const home = cfg.home || require('node:os').homedir();
   const profile = profileFor(normalized.client, normalized.provider, normalized.credentialProfile || '');
+  // Tracciamento di candidati (binary) e file credenziali che ESISTONO ma non
+  // si sono potuti VERIFICARE (EACCES/ELOOP/ENOTDIR...). Il verdetto
+  // (configured/authConfigured) non cambia: il discriminante e' CHI ha fallito,
+  // non che ci sia stata un'eccezione. ENOENT = legittimo "non c'e'"; altro code
+  // = "non ho potuto guardare", e il messaggio deve dirlo invece di collassarlo
+  // in "not found" / "missing" (la stessa forma gia' chiusa in checkTermuxExec).
+  const binaryBlocked = [];
+  const credBlocked = [];
   const binary = normalized.client === 'shell'
-    ? resolveInteractiveShell({ ...cfg, home })
-    : findBinary(normalized.client, home);
-  const cred = credential(profile, normalized, cfg, home);
+    ? resolveInteractiveShell({ ...cfg, home }, { blocked: binaryBlocked })
+    : findBinary(normalized.client, home, { blocked: binaryBlocked });
+  const cred = credential(profile, normalized, cfg, home, { blocked: credBlocked });
   // Pi can resolve credentials from its own documented /login auth store. Do
   // not inspect or copy that store; delegate native-provider auth to Pi.
   const delegatedPiAuth = profile.client === 'pi' && profile.provider !== 'custom'
     && profile.delegatePiAuth !== false;
   const authConfigured = delegatedPiAuth || profile.auth === 'login' || profile.auth === 'none' || !!cred.value;
   let configured = !!binary && authConfigured;
-  let reason = !binary ? `client ${profile.client} not found` : (!authConfigured
-    ? `credential ${cred.envKey} missing — set it on this device`
-    : 'ready');
+  let reason;
+  if (!binary) {
+    reason = binaryBlocked.length
+      ? `client ${profile.client} not confirmed: ${binaryBlocked.length === 1 ? 'a candidate could not be verified' : 'some candidates could not be verified'} (${binaryBlocked.map((b) => `${b.path} (${b.code})`).join('; ')}) — not "absent"`
+      : `client ${profile.client} not found`;
+  } else if (!authConfigured) {
+    reason = cred.source === 'unreadable'
+      ? `credential ${cred.envKey} not verifiable (file present but unreadable: ${credBlocked.map((b) => `${b.path} (${b.code})`).join('; ')}) — not "missing"`
+      : `credential ${cred.envKey} missing — set it on this device`;
+  } else {
+    reason = 'ready';
+  }
   // Agy e grok sono client primari supportati solo su Linux/macOS non-Termux.
   // Rilevazione Termux via termuxRuntimePaths (non solo process.platform): un
   // Node che riporta 'linux' sotto proot/Termux viene comunque intercettato.
@@ -872,7 +1021,11 @@ function describeManaged(spec, cfg = {}) {
     permissionPolicy: normalized.permissionPolicy, protocol: normalized.protocol || profile.protocol,
     endpoint: normalized.baseUrl || profile.endpoint || '', auth: cred.envKey, authConfigured,
     credentialSourcePolicy: normalized.credentialSourcePolicy || 'auto',
-    credentialSource: authConfigured ? cred.source : 'missing',
+    // cred.source e' gia' 'missing' quando non c'e' valore: non serve il
+    // ternario che lo forzava. Cosi' una credenziale presente ma illeggibile
+    // (source 'unreadable', authConfigured false) non viene collassata in
+    // 'missing' — il discriminante e' CHI ha fallito, non il esito grezzo.
+    credentialSource: cred.source,
     configured, models: [...(profile.models || [])], defaultModel: profile.model || '',
     binary: binary || '', displayName: normalized.displayName || profile.label,
     reason,
@@ -887,11 +1040,14 @@ function describeCatalogCredential(client, provider, credentialProfile = '', cfg
   if (!profile || profile.auth === 'dynamic' || profile.auth === 'login' || profile.auth === 'none'
     || !ENV_KEY_RE.test(profile.auth || '')) return null;
   const home = cfg.home || require('node:os').homedir();
-  const cred = credential(profile, {}, cfg, home);
+  const cred = credential(profile, {}, cfg, home, { blocked: [] });
   return {
     envKey: cred.envKey,
     authConfigured: !!cred.value,
-    credentialSource: cred.value ? cred.source : 'missing',
+    // cred.source e' gia' 'missing' quando non c'e' valore: non serve il
+    // ternario che lo forzava. Cosi' una credenziale presente ma illeggibile
+    // (source 'unreadable') non viene collassata in 'missing'.
+    credentialSource: cred.source,
   };
 }
 
@@ -1091,7 +1247,41 @@ function ensurePrivateClaudeConfig(home, profileId, label, penguinMode) {
   return configDir;
 }
 
-function writePiProviderExtension(spec, home) {
+// D2 audit: il file .ts generato NON e' il consumatore — Pi lo E'. Un test che
+// legge solo il file resta verde su un'estensione che Pi rifiuta a runtime.
+// CONTRATTO REALE che Pi (@earendil-works/pi-coding-agent 0.80.10) impone a
+// ogni modello di `pi.registerProvider(id, {models: [...]})` — fonte:
+// core/extensions/types.d.ts, interface ProviderModelConfig (JSDoc del pacchetto
+// installato, non dedotto). Campi OBBLIGATORI: id, name, reasoning, input
+// (array "text"|"image"), cost ({input,output,cacheRead,cacheWrite}),
+// contextWindow, maxTokens. `input` mancante fa THROW dentro Pi la prima volta
+// che un tool consulta le capability del modello (es. core/tools/read.js:
+// `model.input.includes("image")` — TypeError su undefined, misurato e
+// riprodotto con il modulo Pi reale). I descrittori grezzi dichiarati
+// dall'operatore in `d.models` (via parseModel: id, engine, label?,
+// contextWindow, maxTokens, reasoning) NON hanno name/input/cost — vanno
+// arricchiti PRIMA di finire nell'estensione, mai passati cosi' come sono.
+function toPiModelConfig(m) {
+  return {
+    id: m.id,
+    name: m.label || m.id,
+    reasoning: m.reasoning === true,
+    input: ['text'],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: m.contextWindow || 128000,
+    maxTokens: m.maxTokens || 16384,
+  };
+}
+
+// D2: `declaredModels` (opzionale) sono i descrittori dichiarati per l'ENGINE
+// (via declaredModelsFor), per il ramo Pi CUSTOM — stesso motivo/stessa fonte
+// di customCatalogFor, mai letti da `spec.models`. Il ramo Pi NON-custom
+// (profile.piExtension) continua a passare `models` dentro l'oggetto spec-like
+// come sempre: e' un catalogo STATICO cablato nel codice (es. alibaba-token-
+// plan), GIA' nella forma completa che Pi si aspetta — un caso diverso, non
+// toccato dal difetto D2. declaredModels, quando presente, ha priorita', ed e'
+// sempre passato per toPiModelConfig (mai i descrittori grezzi cosi' come sono).
+function writePiProviderExtension(spec, home, declaredModels) {
   const dir = path.join(home, '.nexuscrew', 'pi-providers');
   try {
     const st = fs.lstatSync(dir);
@@ -1113,7 +1303,8 @@ function writePiProviderExtension(spec, home) {
     apiKey: spec.apiKey || `$${spec.envKey}`,
     authHeader: true,
     api: spec.protocol,
-    models: Array.isArray(spec.models) && spec.models.length ? spec.models : [{
+    models: (Array.isArray(declaredModels) && declaredModels.length ? declaredModels.map(toPiModelConfig)
+      : (Array.isArray(spec.models) && spec.models.length ? spec.models : null)) || [{
       id: spec.model, name: spec.model, reasoning: false, input: ['text'],
       contextWindow: 128000, maxTokens: 16384,
       cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
@@ -1132,6 +1323,87 @@ function writePiProviderExtension(spec, home) {
   return target;
 }
 
+// D2 (fix definitivo — l'audit del pacchetto aveva bocciato la prima versione:
+// il test costruiva `spec.models` a mano, e in produzione quel campo non
+// esiste mai). `declaredModels` NON viene da `spec`: i descrittori sono
+// proprieta' della definizione dell'ENGINE (`d.models` del documento), non del
+// profilo managed della cella — due soggetti diversi. Il chiamante
+// (resolveManagedEngine) li ricava con declaredModelsFor(extraModels,
+// profile.id) e li passa qui espliciti, cosi' questa funzione non finge mai
+// che `spec` porti qualcosa che semanticamente non gli appartiene.
+// Deriva model_catalog_json e model_context_window dal descrittore, così Codex-VL
+// non ricade sul fallback 272K (-73% finestra) con parallel tool call assenti.
+// Se non ci sono descrittori dichiarati -> null (comportamento invariato,
+// NESSUNA regressione per chi non li usa). NON consacra
+// ~/.codex/custom_provider_model_catalog.json: era una patch locale di una
+// singola installazione, non un contratto; il catalog è generato dai descrittori dichiarati
+// in fleet.json. I valori enum/default rispecchiano i cataloghi spediti
+// (validati dal test fleet-catalog-schema).
+function customCatalogFor(spec, model, declaredModels, home) {
+  const models = Array.isArray(declaredModels) ? declaredModels : [];
+  if (!models.length) return null;
+  const entry = models.find((m) => m && m.id === model) || models[0];
+  const cat = {
+    models: models.map((m) => {
+      const reasoning = m.reasoning === true;
+      return {
+        slug: m.id,
+        display_name: m.label || m.id,
+        description: m.label || m.id,
+        default_reasoning_level: reasoning ? 'high' : 'medium',
+        supported_reasoning_levels: reasoning
+          ? [{ effort: 'low', description: 'Fast responses with lighter reasoning' },
+            { effort: 'high', description: 'Greater reasoning depth for complex problems' },
+            { effort: 'max', description: 'Maximum reasoning depth' }]
+          : [{ effort: 'low', description: 'Fast responses with lighter reasoning' },
+            { effort: 'medium', description: 'Balanced reasoning depth' },
+            { effort: 'high', description: 'Greater reasoning depth for complex problems' }],
+        shell_type: 'default',
+        visibility: 'list',
+        supported_in_api: true,
+        priority: 50,
+        availability_nux: null,
+        upgrade: null,
+        base_instructions: '',
+        supports_reasoning_summaries: true,
+        default_reasoning_summary: 'none',
+        support_verbosity: false,
+        default_verbosity: null,
+        apply_patch_tool_type: null,
+        web_search_tool_type: 'text',
+        truncation_policy: { mode: 'tokens', limit: m.maxTokens || m.contextWindow || 128000 },
+        supports_parallel_tool_calls: false,
+        supports_image_detail_original: false,
+        context_window: m.contextWindow || 128000,
+        effective_context_window_percent: 95,
+        experimental_supported_tools: [],
+        input_modalities: ['text'],
+        supports_search_tool: false,
+      };
+    }),
+  };
+  const dir = path.join(home, '.nexuscrew', 'custom-catalogs');
+  try {
+    const st = fs.lstatSync(dir);
+    if (st.isSymbolicLink() || !st.isDirectory()) throw new Error('unsafe custom catalog directory');
+  } catch (e) {
+    if (e.code === 'ENOENT') fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    else throw e;
+  }
+  fs.chmodSync(dir, 0o700);
+  const target = path.join(dir, `${spec.providerId}.json`);
+  const tmp = path.join(dir, `.${spec.providerId}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(cat), { mode: 0o600 });
+    fs.chmodSync(tmp, 0o600);
+    fs.renameSync(tmp, target);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch (_) {}
+    throw e;
+  }
+  return { catalogPath: target, contextWindow: entry.contextWindow || 128000 };
+}
+
 function resolveManagedEngine(engine, cell, cfg = {}) {
   // `extraModels` DEVE arrivare fin qui. Threadarlo al chiamante e alla vista
   // non basta: la normalizzazione che decide se la cella PARTE e' questa, e
@@ -1144,6 +1416,12 @@ function resolveManagedEngine(engine, cell, 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 || '');
+  // D2: i descrittori dichiarati per QUESTO profilo (client.provider — la
+  // stessa chiave che declaredFor usa dentro normalizeManagedSpec per
+  // validare gli id). Vengono dalla definizione dell'ENGINE (extraModels),
+  // MAI da spec: e' il ponte che customCatalogFor/writePiProviderExtension
+  // (rami custom) usano per emettere catalogo e finestra di contesto.
+  const declaredModels = declaredModelsFor(cfg.extraModels, profile.id);
   const cred = credential(profile, spec, cfg, home);
   // L'override PER-CELLA va canonicalizzato come lo spec: `normalizeManagedSpec`
   // applica l'alias a `spec.model`, ma `cell.model` lo scavalca DOPO e senza
@@ -1209,7 +1487,11 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
         CLAUDE_CODE_MAX_CONTEXT_TOKENS: contextWindow,
         API_TIMEOUT_MS: '3000000',
       });
-      if (model === 'k3' || model === 'k3[1m]') {
+      // Effort massimo di default dove il modello lo sfrutta davvero. Per
+      // GLM-5.3 la misura di Z.AI dice che alzando l'effort l'accuratezza sale
+      // E i token per task scendono rispetto a 5.2: con una finestra a tempo,
+      // spendere di piu' per chiamata rende di piu' per finestra.
+      if (model === 'k3' || model === 'k3[1m]' || model.startsWith('glm-5.3')) {
         env.CLAUDE_CODE_EFFORT_LEVEL = 'max';
         env.CLAUDE_CODE_ALWAYS_ENABLE_EFFORT = '1';
       }
@@ -1336,11 +1618,19 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
     } else if (spec.provider === 'custom') {
       env[spec.envKey] = cred.value;
       args.push(...codexProviderArgs(spec.providerId, spec.displayName, spec.baseUrl, spec.envKey));
+      // D2: onora `models` (engine definition, già validato) come gli altri
+      // provider — deriva model_catalog_json e model_context_window, così
+      // Codex-VL non ricade sul fallback 272K. Senza `models` -> null (no regressione).
+      const customMeta = customCatalogFor(spec, model, declaredModels, home);
+      if (customMeta) {
+        args.push('-c', `model_catalog_json=${JSON.stringify(customMeta.catalogPath)}`);
+        args.push('-c', `model_context_window=${customMeta.contextWindow}`);
+      }
     }
     if (model) args.push('-m', model);
   } 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));
+    if (spec.provider === 'custom') args.push('--extension', writePiProviderExtension(spec, home, declaredModels));
     else if (profile.piExtension) args.push('--extension', writePiProviderExtension({
       providerId: profile.piProvider, displayName: profile.label.replace(/^Pi · /, ''),
       baseUrl: profile.piExtension.baseUrl, apiKey: profile.piExtension.apiKey,
@@ -1394,6 +1684,26 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
   // child env (unset, never empty), so the runtime cannot leak credentials that
   // the local store is meant to own.
   applyStoreNeutralization(env, spec, profile);
+  // D3: resolve envPassthrough AFTER the provider branches. Each declared name is
+  // read from the credentialSources (same order as credential() 'auto': runtime
+  // -> store -> shell -> key files -> legacy) and injected into the child env.
+  // Per nome, mai in blocco. A name that is declared but absent from every source
+  // fails CLOSED but not obscure: the reason names it, so a misconfigured cell
+  // says what is missing instead of starting silent and breaking later. (vl.auth
+  // is 'none': without this, the vl branch composes no provider env at all, yet
+  // the runtime needs its own config vars — whose names are not fixed in the vl
+  // binary, so the operator declares the ones their config uses.)
+  if (spec.envPassthrough && spec.envPassthrough.length) {
+    const sources = credentialSources(cfg, home);
+    for (const name of spec.envPassthrough) {
+      const value = sources.runtime[name] || sources.local[name] || sources.shell[name]
+        || sources.keys[name] || sources.legacy[name];
+      if (!value) {
+        return { ok: false, info, reason: `envPassthrough name "${name}" is not set in any credential source (environment, nexuscrew-store, ${path.basename(shellProvidersPath(cfg, home))}, key files, legacy)` };
+      }
+      env[name] = value;
+    }
+  }
   let command = info.binary;
   if (needsExplicitNode(info.binary, cfg.platform || process.platform, cfg.env || process.env)) {
     command = cfg.nodeExecPath || process.execPath;
@@ -1413,6 +1723,14 @@ function publicCatalog() {
     auth: p.auth, endpoint: p.endpoint || '', model: p.model || '', models: [...(p.models || [])],
     protocols: [...(p.protocols || [p.protocol])], supportsUnsafe: !['pi', 'shell', 'vl'].includes(p.client), requiresModel: !!p.requiresModel || !!p.custom,
     permissionPolicyDefault: p.client === 'claude' ? 'unsafe' : 'standard',
+    // DEC2: solo il client claude riceve MCP gestito da NexusCrew (cellMcpArgs/
+    // sharedMcpArgs nel ramo claude di resolveManagedEngine). Per ogni altro
+    // client (codex, vl, kimi, pi, agy, grok) `cell.mcp` e' INERTE: la cella lo
+    // accetta ma non ha effetto, perche' i server MCP li registra il client nel
+    // proprio file di config nativo, non NexusCrew. La vista lo dice cosi' la
+    // finestra puo' avvertire l'operatore NEL PUNTO in cui sceglie cell.mcp,
+    // invece di confermare un no-op silenzioso.
+    mcpManaged: p.client === 'claude',
     rc: !!p.rc, custom: !!p.custom, default: !!p.default, notice: p.notice || '',
     // 'login'/'none' non sono variabili d'ambiente: nessuna KEY section per gli
     // engine che delegano l'auth al login del CLI (rappresentazione onesta).
@@ -1426,13 +1744,13 @@ module.exports = {
   knownMcpServerNames,
   CATALOG, OLLAMA_CLOUD_MODELS, OLLAMA_CONTEXT, ALIBABA_TOKEN_PLAN_MODELS,
   ALIBABA_CODEX_MODELS, ALIBABA_TOKEN_PLAN_CONTEXT, ALIBABA_PI_MODELS,
-  OPENCODE_GO_MESSAGES_MODELS, OPENCODE_GO_RESPONSES_MODELS, OPENCODE_GO_CHAT_MODELS,
+  OPENCODE_GO_MESSAGES_MODELS, OPENCODE_GO_RESPONSES_MODELS, OPENCODE_GO_CHAT_MODELS, OPENCODE_GO_LIMITS,
   OPENCODE_GO_ANTHROPIC_ROOT, OPENCODE_GO_API_BASE,
   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,
-  extraModelsFrom,
-  providerKeyPaths, parseProviderKeyFiles, credentialSources, credential,
+  discoverPiModels, EXTERNAL_DISCOVERY_TIMEOUT_MS, parseEnvFile, parseProviderShellFile, findBinary, publicCatalog, writePiProviderExtension, customCatalogFor,
+  extraModelsFrom, declaredModelsFor,
+  providerKeyPaths, parseProviderKeyFiles, credentialSources, credential, CREDENTIAL_SOURCE_VALUES,
   credentialEnvNeutralizeSet, applyStoreNeutralization,
   ensureKimiClaudeConfig, ensureAlibabaClaudeConfig, resolveInteractiveShell,
   shellLoginArgs, shellConfiguredCommandArgs, ENV_KEY_RE,