@mmmbuto/nexuscrew 0.9.31 → 0.9.32

package/frontend/dist/index.html

@@ -11,7 +11,7 @@
   <meta name="apple-mobile-web-app-title" content="NexusCrew" />
   <link rel="manifest" href="/manifest.json" />
   <title>NexusCrew</title>
-  <script type="module" crossorigin src="/assets/index-DaAL7P-m.js"></script>
+  <script type="module" crossorigin src="/assets/index-CH2iAu6y.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-DqCfZFGi.css">
 </head>
 <body>

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.9.31"}
+{"version":"0.9.32"}

package/lib/cli/doctor.js

@@ -393,6 +393,24 @@ function checkTermuxExec(runtimeEnv, opts = {}) {
   };
 }
 
+// «Server assente» e «non ho potuto guardare» sono due cose diverse, e vanno
+// dette diverse. La prima e' uno stato normale — il server non c'e' ancora, la
+// probe si rinvia al primo avvio. La seconda e' un'informazione che manca:
+// collassarla nella prima significa dichiarare sano cio' che non si e'
+// verificato, che e' esattamente il modo in cui un permesso sbagliato resta
+// invisibile. E' la stessa distinzione gia' fatta fra «manca» e «non
+// verificabile» altrove nel prodotto.
+function classifyTmuxProbeCause(error) {
+  const code = String((error && error.code) || '');
+  const message = String((error && error.message) || error || '');
+  if (code === 'ENOENT'
+    || /no server running|no such file or directory|connection refused|no sessions/i.test(message)) {
+    return 'absent';
+  }
+  const cause = (code || message.trim() || 'errore non nominato');
+  return cause.length > 120 ? `${cause.slice(0, 117)}...` : cause;
+}
+
 // Read-only probe of the long-lived tmux server cwd. A server that retained an
 // unlinked runtime directory keeps accepting clients but makes later children
 // fail getcwd(3). Never reports the path itself; only stable state.
@@ -403,8 +421,15 @@ function checkTmuxServerCwd(platform, execImpl, opts = {}) {
   let rawPid = '';
   try {
     rawPid = String(execImpl(opts.tmuxBin || 'tmux', ['display-message', '-p', '#{pid}'], { encoding: 'utf8' }) || '').trim();
-  } catch (_) {
-    return { name: 'tmux server cwd', ok: true, warn: true, detail: 'server tmux non attivo; probe rinviato al primo avvio' };
+  } catch (error) {
+    const cause = classifyTmuxProbeCause(error);
+    if (cause === 'absent') {
+      return { name: 'tmux server cwd', ok: true, warn: true, detail: 'server tmux non attivo; probe rinviato al primo avvio' };
+    }
+    return {
+      name: 'tmux server cwd', ok: false, warn: true,
+      detail: `probe non verificabile: ${cause}`,
+    };
   }
   if (!/^\d+$/.test(rawPid)) {
     return { name: 'tmux server cwd', ok: true, warn: true, detail: 'server tmux non rilevato' };
@@ -620,6 +645,51 @@ function checkFleetDefinitions(home, fleetDefsPath, enabled = true) {
   };
 }
 
+// Sezione «engine credentials»: per ogni engine che risolve una credenziale,
+// DA DOVE viene. Prima non esisteva alcun controllo di questo tipo: l'unico
+// blocco credenziali del doctor era quello dell'identita' (daemon/launcher), e
+// la provenienza delle chiavi degli engine non era visibile da nessuna parte —
+// una diagnosi sul campo e' arrivata a un confronto manuale di hash.
+// Non si stampa MAI un valore: solo la sorgente, il path, l'mtime e l'impronta
+// del valore troncata a 8. Un conflitto fra i file di chiavi su un engine che
+// una cella USA e' un fallimento; su un engine che nessuna cella usa e' un
+// avviso, perche' li' non c'e' ancora nulla che parta con la chiave sbagliata.
+function checkEngineCredentials(home, fleetDefsPath, enabled = true) {
+  const name = 'engine credentials';
+  if (!enabled) return { name, ok: true, warn: true, detail: 'Fleet disabilitata' };
+  const target = fleetDefsPath || path.join(home, '.nexuscrew', 'fleet.json');
+  const defs = loadDefinitions(target);
+  if (!defs) return { name, ok: true, warn: true, detail: 'fleet.json non leggibile: provenienza non verificabile' };
+  const { describeManaged, extraModelsFrom } = require('../fleet/managed.js');
+  const inUso = new Set((defs.cells || []).map((c) => c && c.engine).filter(Boolean));
+  const extraModels = extraModelsFrom(defs);
+  const righe = [];
+  const conflitti = [];
+  for (const engine of defs.engines || []) {
+    if (!engine || !engine.managed) continue;
+    const info = describeManaged(engine.managed, { home, extraModels, engineId: engine.id });
+    const envKey = info.auth;
+    if (!envKey || envKey === 'login' || envKey === 'none') continue;
+    const dove = info.credentialPath
+      ? `${info.credentialSource} (${info.credentialPath}, mtime ${new Date(info.credentialMtime).toISOString()}, sha256 ${info.credentialHash8})`
+      : info.credentialSource;
+    righe.push(`${engine.id}: ${envKey} from ${dove}`);
+    if (info.credentialConflict) conflitti.push({ engine: engine.id, inUso: inUso.has(engine.id), c: info.credentialConflict });
+  }
+  if (!righe.length) return { name, ok: true, detail: 'nessun engine con credenziale risolta' };
+  for (const { engine, c } of conflitti) {
+    const altri = c.others
+      .map((o) => `${o.path} (mtime ${new Date(o.mtime).toISOString()}, sha256 ${o.hash8})`)
+      .join(', ');
+    righe.push(`${engine}: ${c.envKey} e' definita anche in ${altri} con un valore DIVERSO (vince ${c.winner.path})`);
+  }
+  const grave = conflitti.some((k) => k.inUso);
+  const detail = righe.join(' · ');
+  if (grave) return { name, ok: false, detail };
+  if (conflitti.length) return { name, ok: true, warn: true, detail };
+  return { name, ok: true, detail };
+}
+
 // Read-only check: alternate-screen is applied per managed session, while the
 // history limit remains an operator-owned tmux setting. Do not write ~/.tmux.conf
 // or change a live server from doctor; only recommend a sufficient value.
@@ -682,6 +752,7 @@ function doctor(opts = {}) {
     checkTmuxSurvival(platform, execImpl),
     checkTokenPerms(tokenPath),
     checkFleetDefinitions(home, opts.fleetDefsPath, fleetEnabled),
+    checkEngineCredentials(home, opts.fleetDefsPath, fleetEnabled),
     checkAlternateScreenHistory(opts.alternateScreen !== undefined
       ? opts.alternateScreen : loadConfig().alternateScreen, execImpl, opts.tmuxBin),
     checkTermuxExec(opts.env, { platform, home }),
@@ -715,4 +786,5 @@ module.exports = {
   checkSshClient, checkAutossh, checkSshPermitlisten,
   checkMcpIdentity, checkIdentityAuthorityMode, checkTermuxExec,
   checkTmuxServerCwd, checkTmuxServerTermuxPreload,
+  checkEngineCredentials,
 };

package/lib/fleet/builtin.js

@@ -38,8 +38,10 @@ const {
 const {
   publicCatalog, describeManaged, describeCatalogCredential, defaultShellEngine, defaultAgyEngine, defaultKimiEngine, defaultGrokEngine, defaultVlEngine,
   CATALOG, credential: resolveProfileCredential, extraModelsFrom, knownMcpServerNames, profileFor,
+  normalizeManagedSpec,
 } = require('./managed.js');
-const { probeModel } = require('./model-probe.js');
+const { probeModel, probeCustomEndpoint } = require('./model-probe.js');
+const { sharedProbe: defaultEndpointProbe } = require('./endpoint-probe.js');
 const { validEnvKey } = require('./env-key.js');
 const { setCredential, removeCredential } = require('./credentials.js');
 const { createLaunchBroker } = require('./launch-broker.js');
@@ -887,8 +889,44 @@ async function createBuiltinFleet(cfg = {}) {
         return !!(profile && profile.id === wantedEngine);
       })
       .map((e) => e.id);
-    if (usato.length) {
-      throw httpError(409, `modello in uso: ${usato.join(', ')}`);
+    // E una CELLA puo' sovrascrivere il modello del proprio engine: l'engine non
+    // lo usa, la cella si'. Guardare solo gli engine lasciava passare la
+    // rimozione e lasciava una cella che punta a un modello che non c'e' piu':
+    // il danno si manifestava al primo avvio, davanti a chi non sa cosa e'
+    // cambiato. Le chiavi sono le STESSE due della risoluzione — l'id
+    // dell'engine e quello del suo profilo — piu' l'override singolo `cell.model`,
+    // che vale per l'engine della cella.
+    // Il profilo che conta e' quello dell'engine DICHIARANTE: la seconda chiave
+    // con cui una cella riferisce un engine e' l'id del suo profilo, non quello
+    // di un altro.
+    const wantedDef = findEngine(defs, wantedEngine);
+    const wantedProfile = wantedDef && wantedDef.managed
+      ? profileFor(wantedDef.managed.client, wantedDef.managed.provider, wantedDef.managed.credentialProfile || '')
+      : null;
+    const wantedProfileId = wantedProfile && wantedProfile.id;
+    const celleUsano = (defs.cells || [])
+      .filter((c) => {
+        const perEngine = c.models || {};
+        if (perEngine[wantedEngine] === wantedId) return true;
+        if (wantedProfileId && perEngine[wantedProfileId] === wantedId) return true;
+        // `cell.model` vale per l'engine DELLA cella: e' un uso del modello
+        // chiesto solo se quella cella gira proprio sull'engine dichiarante.
+        if (c.model === wantedId) {
+          if (c.engine === wantedEngine) return true;
+          const cellEngine = findEngine(defs, c.engine);
+          const cellProfile = cellEngine && cellEngine.managed
+            ? profileFor(cellEngine.managed.client, cellEngine.managed.provider, cellEngine.managed.credentialProfile || '')
+            : null;
+          return !!(cellProfile && cellProfile.id === wantedEngine);
+        }
+        return false;
+      })
+      .map((c) => c.id);
+    if (usato.length || celleUsano.length) {
+      const parti = [];
+      if (usato.length) parti.push(`modello in uso: ${usato.join(', ')}`);
+      if (celleUsano.length) parti.push(`celle: ${celleUsano.join(', ')}`);
+      throw httpError(409, parti.join('; '));
     }
     await mutate(defs, (d) => {
       d.models = (d.models || []).filter((m) => !(m.id === wantedId && m.engine === wantedEngine));
@@ -1273,7 +1311,10 @@ 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, extraModels: extraModelsFrom(defs), engineId: e.id });
+        if (e.managed) out.managedInfo = describeManaged(e.managed, {
+          ...cfg, home, extraModels: extraModelsFrom(defs), engineId: e.id,
+          endpointProbe: cfg.endpointProbe || defaultEndpointProbe,
+        });
         return out;
       }),
       cells: defs.cells.map((c) => {
@@ -1452,19 +1493,54 @@ async function createBuiltinFleet(cfg = {}) {
     return ['status', 'up', 'down', 'restart', 'engine', 'boot', 'define', 'edit', 'remove', 'import', 'restore', 'schema', 'definitions', 'credentials', 'model-test'];
   }
 
+  // Un engine del documento con un `baseUrl` dichiarato a mano: indirizzo e
+  // credenziale risolti per la prova, e niente altro. Il valore della chiave NON
+  // entra nel ritorno di testModel ne' in un log.
+  function customEndpointFor(engineId) {
+    const defsNow = (typeof reloadDefs === 'function' ? reloadDefs() : defs) || defs;
+    const eng = findEngine(defsNow, engineId);
+    if (!eng || !eng.managed || !eng.managed.baseUrl) return null;
+    const spec = normalizeManagedSpec(eng.managed, {
+      extraModels: extraModelsFrom(defsNow), engineId: eng.id,
+    });
+    if (!spec) return null;
+    const prof = profileFor(spec.client, spec.provider, spec.credentialProfile || '');
+    let credential = '';
+    try {
+      credential = (resolveProfileCredential(prof, {
+        client: prof.client, provider: prof.provider,
+        ...(spec.credentialProfile ? { credentialProfile: spec.credentialProfile } : {}),
+      }, cfg, home) || {}).value || '';
+    } catch (_) { credential = ''; }
+    return { endpoint: spec.baseUrl || '', credential };
+  }
+
   // «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 id = String(engineId || '');
+    const profile = CATALOG.find((p) => p.id === id);
     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;
     }
+    if (!profile) {
+      // Un engine DICHIARATO con un endpoint proprio non sta nel catalogo
+      // pubblico: rispondere 404 significava «non provabile» proprio dove la
+      // prova serve di piu' — un router interno che nessuno sorveglia. Si prova
+      // sul suo indirizzo, con le credenziali gia' risolte per quell'engine.
+      const custom = customEndpointFor(id);
+      if (!custom) {
+        const e = new Error(`profilo sconosciuto "${engineId}"`); e.status = 404; throw e;
+      }
+      const out = await probeCustomEndpoint({
+        endpoint: custom.endpoint, credential: custom.credential, model: wanted,
+        fetchImpl: opts.fetchImpl,
+      });
+      return { engine: id, model: wanted, ...out };
+    }
     const spec = {
       client: profile.client,
       provider: profile.provider,

package/lib/fleet/endpoint-probe.js

@@ -0,0 +1,146 @@
+'use strict';
+// lib/fleet/endpoint-probe.js — «l'endpoint risponde?», chiesto all'endpoint.
+//
+// Un engine managed con un `baseUrl` dichiarato a mano (un router llama.cpp, un
+// server locale, un proxy) veniva dichiarato `ready` appena il BINARIO esisteva e
+// la credenziale era a posto. Nessuno interrogava mai l'indirizzo: un router
+// spento risultava pronto, e lo si scopriva facendo partire la cella. Qui la
+// domanda si fa prima, con un GET sull'elenco dei modelli — l'unica chiamata che
+// non consuma token e non genera testo.
+//
+// TRE DISCIPLINE, che valgono quanto la sonda:
+//   1. NON BLOCCANTE OLTRE IL PROPRIO BUDGET. `refresh` e' l'unico punto che
+//      aspetta, e aspetta al massimo `timeoutMs`. Chi legge lo stato da un
+//      percorso sincrono usa `read`/`ensure`: ottiene il verdetto NOTO ADESSO e
+//      al massimo fa partire un rifornimento in sottofondo.
+//   2. UNA PROBE OGNI `ttlMs` PER ENDPOINT. `nc_status` e la UI interrogano lo
+//      stato di continuo: senza cache si tradurrebbe in una tempesta di GET
+//      verso ogni router del parco.
+//   3. GLI ENGINE DI CATALOGO NON SI SONDANO. La sonda si applica solo dove
+//      l'indirizzo e' dichiarato (provider pubblici: irraggiungibile da qui non
+//      significa rotto, e non e' compito di questo nodo misurarlo).
+
+const DEFAULT_TIMEOUT_MS = 1500;
+const DEFAULT_TTL_MS = 30000;
+
+// L'elenco modelli sta sotto `/v1/models` per le API in stile OpenAI. Un
+// `baseUrl` che dichiara gia' `/v1` non lo ripete: ripeterlo produce
+// `/v1/v1/models`, che risponde 404 e verrebbe letto come «endpoint vivo».
+function modelsProbeUrl(baseUrl) {
+  const b = String(baseUrl || '').trim().replace(/\/+$/, '');
+  if (!/^https?:\/\//i.test(b)) return null;
+  return /\/v1$/.test(b) ? `${b}/models` : `${b}/v1/models`;
+}
+
+// `host:porta` per il messaggio: e' cio' che serve a chi legge per capire QUALE
+// indirizzo non risponde, senza riversare l'URL intero nel verdetto.
+function endpointHost(baseUrl) {
+  try {
+    const u = new URL(String(baseUrl));
+    const port = u.port || (u.protocol === 'https:' ? '443' : '80');
+    return `${u.hostname}:${port}`;
+  } catch (_) { return String(baseUrl || ''); }
+}
+
+function createEndpointProbe({
+  fetchImpl = fetch,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  ttlMs = DEFAULT_TTL_MS,
+  now = () => Date.now(),
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+  log = () => {},
+} = {}) {
+  const cache = new Map();   // baseUrl -> {state, reason, at}
+  const inFlight = new Map(); // baseUrl -> Promise
+
+  // Verdetto noto ADESSO, senza toccare la rete. `null` = mai sondato.
+  function read(baseUrl) {
+    if (!modelsProbeUrl(baseUrl)) return null;
+    const hit = cache.get(baseUrl);
+    if (!hit) return null;
+    return { state: hit.state, reason: hit.reason, at: hit.at, stale: (now() - hit.at) >= ttlMs };
+  }
+
+  async function refresh(baseUrl) {
+    const url = modelsProbeUrl(baseUrl);
+    if (!url) return null;
+    if (inFlight.has(baseUrl)) return inFlight.get(baseUrl);
+    const run = (async () => {
+      const controller = new AbortController();
+      const timer = setTimer(() => controller.abort(), timeoutMs);
+      // Un timer di sonda non tiene vivo il processo.
+      if (timer && typeof timer.unref === 'function') timer.unref();
+      let verdict;
+      try {
+        const res = await fetchImpl(url, { method: 'GET', signal: controller.signal });
+        const status = res && typeof res.status === 'number' ? res.status : 0;
+        if (status >= 200 && status < 300) {
+          verdict = { state: 'ready', reason: 'ready' };
+        } else if (status === 401 || status === 403) {
+          // L'endpoint ha risposto e sta chiedendo una credenziale: e' VIVO.
+          // Se la chiave sia quella giusta lo decide il client, non questa sonda.
+          verdict = { state: 'ready', reason: 'ready' };
+        } else if (status >= 500) {
+          verdict = { state: 'unreachable', reason: `endpoint unreachable: ${endpointHost(baseUrl)} (http ${status})` };
+        } else {
+          // Qualunque altra risposta (404 compreso) e' comunque una risposta:
+          // l'indirizzo c'e' ed e' in ascolto.
+          verdict = { state: 'ready', reason: 'ready' };
+        }
+      } catch (error) {
+        const aborted = error && (error.name === 'AbortError' || error.code === 'ABORT_ERR');
+        verdict = {
+          state: 'unreachable',
+          reason: `endpoint unreachable: ${endpointHost(baseUrl)} (${aborted ? `timeout (${timeoutMs}ms)` : 'connessione rifiutata'})`,
+        };
+      } finally {
+        try { clearTimer(timer); } catch (_) {}
+      }
+      cache.set(baseUrl, { ...verdict, at: now() });
+      try { log(`sonda endpoint ${endpointHost(baseUrl)}: ${verdict.state}`); } catch (_) {}
+      return verdict;
+    })();
+    inFlight.set(baseUrl, run);
+    try { return await run; } finally { inFlight.delete(baseUrl); }
+  }
+
+  // Percorso SINCRONO: ritorna il verdetto noto (o `null`) e, se manca o e'
+  // scaduto, avvia il rifornimento senza attendere. Il primo giro dopo un
+  // avvio puo' quindi non sapere ancora; dal secondo in poi dice la verita'
+  // per tutta la durata del TTL.
+  function ensure(baseUrl) {
+    if (!modelsProbeUrl(baseUrl)) return null;
+    const hit = read(baseUrl);
+    if (!hit || hit.stale) { refresh(baseUrl).catch(() => {}); }
+    return hit ? { state: hit.state, reason: hit.reason } : null;
+  }
+
+  // Percorso ASINCRONO: attende la sonda SOLO se il verdetto e' assente o
+  // scaduto. E' quello che usa lo status, dove un'attesa breve e' ammessa e
+  // un'informazione vecchia non serve a nessuno.
+  async function status(baseUrl) {
+    const hit = read(baseUrl);
+    if (hit && !hit.stale) return { state: hit.state, reason: hit.reason };
+    return refresh(baseUrl).catch(() => null);
+  }
+
+  return {
+    read, ensure, refresh, status,
+    size: () => cache.size,
+    clear: () => cache.clear(),
+    limits: { timeoutMs, ttlMs },
+    url: modelsProbeUrl,
+    host: endpointHost,
+  };
+}
+
+// Istanza di processo: la cache deve sopravvivere alla singola chiamata, ed e'
+// esattamente cio' che evita la tempesta di probe.
+const sharedProbe = createEndpointProbe();
+
+module.exports = {
+  createEndpointProbe, sharedProbe, modelsProbeUrl, endpointHost,
+  ENDPOINT_PROBE_TIMEOUT_MS: DEFAULT_TIMEOUT_MS,
+  ENDPOINT_PROBE_TTL_MS: DEFAULT_TTL_MS,
+};

package/lib/fleet/managed.js

@@ -433,8 +433,16 @@ const CREDENTIAL_SOURCES = Object.freeze(['environment', 'nexuscrew-store', 'aut
 // 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.
+// Le origini sono DISTINTE perche' l'operatore deve poterle distinguere: prima
+// `providers.zsh`, i due file di chiavi e il file legacy si presentavano tutti
+// come `compatibility`, e chi guardava non poteva sapere chi avesse fornito la
+// chiave — ne' se erano due a fornirla, con valori diversi. `compatibility`
+// resta nell'elenco come alias di lettura: non e' piu' prodotto, ma un client
+// vecchio puo' ancora riceverlo e deve avere la sua stringa.
 const CREDENTIAL_SOURCE_VALUES = Object.freeze([
-  'login', 'none', 'environment', 'nexuscrew-store', 'local', 'compatibility', 'missing', 'unreadable',
+  'login', 'none', 'environment', 'nexuscrew-store', 'local',
+  'providers-shell', 'keys-file', 'secure-file', 'legacy',
+  '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}$/;
@@ -858,7 +866,21 @@ function parseEnvFile(file, opts = {}, out) {
     const st = fs.lstatSync(target);
     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'));
+    const values = parseAssignments(fs.readFileSync(target, 'utf8'));
+    // Provenienza richiesta dal chiamante (vedi parseProviderKeyFiles). Si
+    // registra per CHIAVE, con l'impronta e non il valore, e solo per i file che
+    // il chiamante ha dichiarato di voler tracciare: gli altri restano com'e-
+    // rano.
+    if (out && out.provenance instanceof Map) {
+      const mtime = Math.floor(st.mtimeMs);
+      const source = opts.provenanceSource || 'file';
+      for (const [key, value] of Object.entries(values)) {
+        const list = out.provenance.get(key) || [];
+        list.push({ source, path: file, mtime, hash8: hash8Of(value) });
+        out.provenance.set(key, list);
+      }
+    }
+    return values;
   } catch (e) {
     if (blocked && e.code !== 'ENOENT') blocked.push({ path: file, code: e.code || e.constructor.name });
     return {};
@@ -871,7 +893,20 @@ function parseProviderShellFile(file, out) {
     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'));
+    const values = parseAssignments(fs.readFileSync(file, 'utf8'));
+    // Stessa registrazione della provenienza dei file di chiavi: la shell sta
+    // PIU' IN ALTO nella precedenza, quindi una providers.zsh stantia produce
+    // lo stesso guasto dei file — a parti invertite — e va vista allo stesso
+    // modo. Il valore non entra qui: solo la sua impronta.
+    if (out && out.provenance instanceof Map) {
+      const mtime = Math.floor(st.mtimeMs);
+      for (const [key, value] of Object.entries(values)) {
+        const list = out.provenance.get(key) || [];
+        list.push({ source: 'providers-shell', path: file, mtime, hash8: hash8Of(value) });
+        out.provenance.set(key, list);
+      }
+    }
+    return values;
   } catch (e) {
     if (blocked && e.code !== 'ENOENT') blocked.push({ path: file, code: e.code || e.constructor.name });
     return {};
@@ -1001,6 +1036,32 @@ function shellProvidersPath(cfg, home) {
     || path.join(home, '.config', 'ai-shell', 'providers.zsh');
 }
 
+// L'impronta di un valore, MAI il valore. Serve a dire «due sorgenti hanno
+// questa variabile e il contenuto e' DIVERSO» senza dire cosa contiene: e' la
+// sola forma che rende visibile un conflitto restando sicura da mostrare, da
+// scrivere in un log e da mettere in una risposta API. Il valore entra in
+// questa funzione e non ne esce: qui si calcola, si prende l'impronta e si
+// scarta. Chi aggiungera' campi a questa struttura non aggiunga il valore.
+function hash8Of(text) {
+  return crypto.createHash('sha256').update(String(text)).digest('hex').slice(0, 8);
+}
+
+// I conflitti del SOLO gruppo dei file di chiavi: per ogni variabile definita in
+// piu' di un file, l'ultimo vince (e' la precedenza dichiarata) ma se il
+// contenuto differisce l'operatore deve saperlo. Due file con la STESSA impronta
+// non sono un conflitto: e' la stessa chiave in due posti.
+function findCredentialConflicts(provenance) {
+  const conflicts = [];
+  if (!(provenance instanceof Map)) return conflicts;
+  for (const [envKey, list] of provenance) {
+    if (!Array.isArray(list) || list.length < 2) continue;
+    const winner = list[list.length - 1];
+    const others = list.slice(0, -1).filter((e) => e && e.hash8 !== winner.hash8);
+    if (others.length) conflicts.push({ envKey, winner, others });
+  }
+  return conflicts;
+}
+
 function providerKeyPaths(cfg, home) {
   const paths = [
     cfg.providerKeysPath || process.env.NEXUSCREW_PROVIDER_KEYS
@@ -1018,7 +1079,14 @@ function parseProviderKeyFiles(cfg, home, out) {
   // 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 }, out));
+  // La provenienza si traccia QUI, e solo per questi file: e' l'unico punto che
+  // li vede in ordine e che sa quale ha fornito ogni chiave. L'etichetta segue
+  // l'ORDINE: l'ultimo file e' il file di override, e con un solo path
+  // configurato non c'e' nessun override da nominare.
+  for (let i = 0; i < files.length; i += 1) {
+    const source = files.length > 1 && i === files.length - 1 ? 'secure-file' : 'keys-file';
+    Object.assign(values, parseEnvFile(files[i], { allowSymlinkRoots: roots, provenanceSource: source }, out));
+  }
   return values;
 }
 
@@ -1031,12 +1099,28 @@ function parseProviderKeyFiles(cfg, home, out) {
 function credentialSources(cfg, home, out, { trackLegacy = true } = {}) {
   let local = {};
   try { local = readCredentialStore(cfg, home); } catch (_) { /* unsafe/corrupt store is ignored, never trusted */ }
+  // UNA sola mappa di provenienza, riempita NELL'ORDINE DI PRECEDENZA: prima i
+  // file di chiavi (il piu' debole, poi l'override), poi la shell, che li
+  // scavalca. L'ultimo che ha scritto una variabile e' chi vince davvero, ed e'
+  // quello che il conflitto deve nominare. Il `blocked` del chiamante resta
+  // condiviso: l'illeggibilita' continua a essere tracciata come prima.
+  const provenance = new Map();
+  const bag = { blocked: out && Array.isArray(out.blocked) ? out.blocked : null, provenance };
+  const keys = parseProviderKeyFiles(cfg, home, bag);
+  const shell = parseProviderShellFile(shellProvidersPath(cfg, home), bag);
+  const conflicts = findCredentialConflicts(provenance);
+  if (out) { out.provenance = provenance; out.conflicts = conflicts; }
   return {
     runtime: cfg.env || process.env,
     local,
-    shell: parseProviderShellFile(shellProvidersPath(cfg, home), out),
-    keys: parseProviderKeyFiles(cfg, home, out),
+    shell,
+    keys,
     legacy: parseEnvFile(secretsPath(cfg, home), {}, trackLegacy ? out : undefined),
+    // Ordine REALE dei file di chiavi: l'ultimo vince. Serve a dire DA QUALE
+    // file viene la chiave vincente, non solo da quale gruppo.
+    keyPaths: providerKeyPaths(cfg, home),
+    provenance,
+    conflicts,
   };
 }
 
@@ -1059,10 +1143,33 @@ function credential(profile, spec, cfg, home, out) {
   // auto: legacy resolution order (runtime -> store -> shell -> keys -> legacy).
   if (sources.runtime[envKey]) return { envKey, value: sources.runtime[envKey], source: 'environment' };
   if (sources.local[envKey]) return { envKey, value: sources.local[envKey], source: 'local' };
-  if (sources.shell[envKey]) return { envKey, value: sources.shell[envKey], source: 'compatibility' };
-  if (sources.keys[envKey]) return { envKey, value: sources.keys[envKey], source: 'compatibility' };
+  if (sources.shell[envKey]) {
+    // Il file della shell: prima condivideva l'etichetta con i file di chiavi e
+    // col legacy, quindi non si poteva sapere da dove venisse la chiave. E'
+    // un FILE anche lui, quindi porta la sua provenienza come gli altri.
+    const trailShell = sources.provenance && sources.provenance.get(envKey);
+    const winShell = Array.isArray(trailShell) ? trailShell.find((e) => e.source === 'providers-shell') : null;
+    return {
+      envKey, value: sources.shell[envKey], source: 'providers-shell',
+      ...(winShell ? { path: winShell.path, mtime: winShell.mtime, hash8: winShell.hash8 } : {}),
+    };
+  }
+  if (sources.keys[envKey]) {
+    // Quale DEI DUE file ha fornito la chiave: l'ultimo dell'ordine vince, e se
+    // e' il file di override la provenienza lo dice. Con l'impronta e l'mtime,
+    // mai col valore.
+    const trail = sources.provenance && sources.provenance.get(envKey);
+    const win = Array.isArray(trail) && trail.length ? trail[trail.length - 1] : null;
+    const paths = Array.isArray(sources.keyPaths) ? sources.keyPaths : [];
+    const secure = !!(win && paths.length > 1 && win.path === paths[paths.length - 1]);
+    return {
+      envKey, value: sources.keys[envKey],
+      source: secure ? 'secure-file' : 'keys-file',
+      ...(win ? { path: win.path, mtime: win.mtime, hash8: win.hash8 } : {}),
+    };
+  }
   if (profile.legacySecrets && sources.legacy[envKey]) {
-    return { envKey, value: sources.legacy[envKey], source: 'compatibility' };
+    return { envKey, value: sources.legacy[envKey], source: 'legacy' };
   }
   // auto: nessuna fonte ha la chiave. Se un file credenziale esiste ma non si
   // e' potuto leggere (EACCES/ELOOP...), non possiamo dichiarare la chiave
@@ -1221,7 +1328,10 @@ function describeManaged(spec, cfg = {}) {
   const binary = normalized.client === 'shell'
     ? resolveInteractiveShell({ ...cfg, home }, { blocked: binaryBlocked })
     : findBinary(normalized.client, home, { blocked: binaryBlocked });
-  const cred = credential(profile, normalized, cfg, home, { blocked: credBlocked });
+  // La scatola e' tenuta: dopo la chiamata porta anche i CONFLITTI fra file di
+  // chiavi, calcolati dove i file si leggono in ordine.
+  const credOut = { blocked: credBlocked };
+  const cred = credential(profile, normalized, cfg, home, credOut);
   // 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'
@@ -1256,6 +1366,38 @@ function describeManaged(spec, cfg = {}) {
       reason = `${normalized.client} non supportato su questa piattaforma (usa shell.local con command ${normalized.client})`;
     }
   }
+  // Endpoint dichiarato A MANO: l'esistenza del binario e della credenziale non
+  // dice se l'indirizzo risponde. Un router spento risultava `ready` e lo si
+  // scopriva facendo partire la cella. Il verdetto arriva dal chiamante quando
+  // ha potuto attendere la sonda (`cfg.endpointVerdict`), oppure dalla cache
+  // (lettura sincrona, mai bloccante). Gli engine di catalogo non si sondano:
+  // li' l'indirizzo non e' una scelta di questo nodo.
+  if (configured && normalized.baseUrl) {
+    let verdict = cfg.endpointVerdict && typeof cfg.endpointVerdict === 'object' ? cfg.endpointVerdict : null;
+    if (!verdict && cfg.endpointProbe && typeof cfg.endpointProbe.ensure === 'function') {
+      try { verdict = cfg.endpointProbe.ensure(normalized.baseUrl); } catch (_) { verdict = null; }
+    }
+    if (verdict && verdict.state === 'unreachable') {
+      configured = false;
+      reason = verdict.reason || `endpoint unreachable: ${normalized.baseUrl}`;
+    } else if (verdict && verdict.state === 'ready') {
+      reason = 'ready';
+    }
+  }
+  // Conflitto fra i file di chiavi: l'engine RESTA configurato — una chiave
+  // valida c'e' e il client puo' partire — ma chi guarda deve sapere che la
+  // stessa variabile e' definita altrove con un contenuto diverso. E' il caso
+  // che sul campo si e' presentato come «la cella usa una chiave revocata»:
+  // senza questo, l'unico modo di accorgersene era confrontare gli hash a mano.
+  // Le impronte, mai i valori.
+  if (configured) {
+    const conflitti = Array.isArray(credOut.conflicts) ? credOut.conflicts : [];
+    const mio = conflitti.find((c) => c && c.envKey === cred.envKey);
+    if (mio && mio.others && mio.others.length) {
+      const altri = mio.others.map((o) => o.path).join(', ');
+      reason = `${reason === 'ready' ? 'ready ' : reason + ' '}(credential ${cred.envKey} also defined in ${altri} with a different value)`;
+    }
+  }
   return {
     client: profile.client, clientLabel: CLIENT_LABELS[profile.client], provider: profile.provider,
     credentialProfile: normalized.credentialProfile || '', model: normalized.model,
@@ -1267,6 +1409,18 @@ function describeManaged(spec, cfg = {}) {
     // (source 'unreadable', authConfigured false) non viene collassata in
     // 'missing' — il discriminante e' CHI ha fallito, non il esito grezzo.
     credentialSource: cred.source,
+    // Provenienza della credenziale risolta: path, mtime e impronta del valore
+    // (MAI il valore). Presenti solo quando la sorgente e' un file.
+    credentialPath: cred.path || '',
+    credentialMtime: cred.mtime || 0,
+    credentialHash8: cred.hash8 || '',
+    // Conflitto fra i file di chiavi: la stessa variabile definita in piu' file
+    // con contenuto diverso. `null` quando non c'e' — o quando i file dicono la
+    // stessa cosa, che non e' un conflitto.
+    credentialConflict: (() => {
+      const list = Array.isArray(credOut.conflicts) ? credOut.conflicts : [];
+      return list.find((c) => c && c.envKey === cred.envKey) || null;
+    })(),
     configured,
     // Catalogo builtin del profilo PIU' i modelli dichiarati in
     // `definitions.models[]` per questo engine (o, legacy, per il profilo).