@mmmbuto/nexuscrew 0.9.30 → 0.9.32

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,7 +1409,29 @@ 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,
-    configured, models: [...(profile.models || [])], defaultModel: profile.model || '',
+    // 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).
+    // Senza l'unione un profilo custom — che catalogo non ha — elencava `[]`
+    // anche con due modelli dichiarati: il boot li accettava (declaredFor) ma
+    // la finestra, che legge da qui, non li mostrava.
+    models: [...new Set([
+      ...(profile.models || []),
+      ...declaredModelsFor(extraModels, profile.id, cfg.engineId || null).map((m) => m.id),
+    ])],
+    defaultModel: profile.model || '',
     binary: binary || '', displayName: normalized.displayName || profile.label,
     reason,
   };

package/lib/fleet/model-probe.js

@@ -6,11 +6,20 @@
 // 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.
+// COSTO, per gli engine DI CATALOGO: 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.
+//
+// COSTO, per un endpoint DICHIARATO A MANO (`probeCustomEndpoint`): la regola
+// sopra vale finche' il catalogo c'e'. Un router locale spesso non espone
+// `GET /models`, e su quel ramo l'alternativa a una richiesta minima non e' una
+// prova gratuita — e' nessuna prova, cioe' un `unverified` su un modello che
+// quasi certamente esiste. Li' si ricade su UN completamento da un token
+// (`max_tokens: 1`) e il testo generato non viene letto ne' registrato: la
+// risposta serve solo a distinguere «c'e'» da «non c'e'».
 //
 // COSA NON ESCE MAI DA QUI:
 //   - il testo che il modello eventualmente genera: non viene letto, non viene
@@ -44,6 +53,98 @@ function modelsUrl(profile) {
   return joinUrl(endpoint, 'models');
 }
 
+// Un endpoint dichiarato A MANO non sta nel catalogo pubblico: la prova si fa
+// sul suo indirizzo. Stessa forma di URL della sonda di prontezza (`/v1` non si
+// ripete), stesso verdetto enum della prova di catalogo — chi legge l'esito non
+// deve sapere da quale dei due rami e' arrivato.
+function chatCompletionsUrl(baseUrl) {
+  const b = String(baseUrl || '').trim().replace(/\/+$/, '');
+  if (!/^https?:\/\//i.test(b)) return null;
+  return /\/v1$/.test(b) ? `${b}/chat/completions` : `${b}/v1/chat/completions`;
+}
+
+// Un endpoint locale spesso non espone `GET /models` (o lo espone vuoto). La
+// seconda via e' la richiesta minima: `max_tokens: 1`, nessun testo letto, e il
+// corpo della risposta NON entra nell'esito. Serve a distinguere «il modello
+// c'e'» da «il modello non c'e'», non a misurare la qualita' della risposta.
+const CUSTOM_FALLBACK_TIMEOUT_MS = 10000;
+
+async function probeCustomEndpoint({
+  endpoint, credential = '', model, fetchImpl = fetch,
+  timeoutMs = DEFAULT_TIMEOUT_MS, fallbackTimeoutMs = CUSTOM_FALLBACK_TIMEOUT_MS,
+} = {}) {
+  const listUrl = modelsUrl({ endpoint });
+  if (!listUrl) return { outcome: 'unverified', latencyMs: 0, detail: 'endpoint non interrogabile' };
+
+  const started = Date.now();
+  const headers = credential ? { authorization: `Bearer ${credential}` } : {};
+  const list = await timedFetch({
+    fetchImpl, url: listUrl, method: 'GET', headers, timeoutMs,
+  });
+  if (list.transport === 'timeout') return { outcome: 'unreachable', latencyMs: list.latencyMs, detail: `timeout (${timeoutMs}ms)` };
+  if (list.transport === 'error') return { outcome: 'unreachable', latencyMs: list.latencyMs, detail: 'endpoint non raggiungibile' };
+  if (list.status === 401 || list.status === 403) return { outcome: 'auth', latencyMs: list.latencyMs };
+  if (list.status >= 200 && list.status < 300) {
+    // Un elenco VUOTO non e' «il modello non c'e'»: e' un endpoint che non
+    // espone un catalogo. Trattarlo come assenza darebbe un falso negativo su
+    // un modello che risponde benissimo — il caso tipico dei router locali.
+    const rows = Array.isArray(list.payload && list.payload.data) ? list.payload.data
+      : Array.isArray(list.payload && list.payload.models) ? list.payload.models : null;
+    if (rows && rows.length) {
+      const found = findInCatalog(list.payload, model);
+      if (found === true) return { outcome: 'ok', latencyMs: list.latencyMs };
+      if (found === false) return { outcome: 'unknown-model', latencyMs: list.latencyMs };
+    }
+    // Elenco assente, vuoto o illeggibile: si prova la via minima invece di
+    // dichiarare `unverified` un modello che probabilmente c'e'.
+  } else if (list.status >= 500) {
+    return { outcome: 'unreachable', latencyMs: list.latencyMs, detail: `http ${list.status}` };
+  }
+
+  const chatUrl = chatCompletionsUrl(endpoint);
+  if (!chatUrl) return { outcome: 'unverified', latencyMs: Date.now() - started, detail: 'endpoint non interrogabile' };
+  const chat = await timedFetch({
+    fetchImpl,
+    url: chatUrl,
+    method: 'POST',
+    headers: { 'content-type': 'application/json', ...headers },
+    body: JSON.stringify({ model, max_tokens: 1, messages: [{ role: 'user', content: 'ping' }] }),
+    timeoutMs: fallbackTimeoutMs,
+  });
+  const latencyMs = Date.now() - started;
+  if (chat.transport === 'timeout') return { outcome: 'unreachable', latencyMs, detail: `timeout (${fallbackTimeoutMs}ms)` };
+  if (chat.transport === 'error') return { outcome: 'unreachable', latencyMs, detail: 'endpoint non raggiungibile' };
+  if (chat.status === 401 || chat.status === 403) return { outcome: 'auth', latencyMs };
+  if (chat.status >= 200 && chat.status < 300) return { outcome: 'ok', latencyMs };
+  // 400/404 su un modello chiesto per nome: l'endpoint risponde e non lo
+  // conosce. E' l'esito piu' utile che si possa dare senza leggere il corpo.
+  if (chat.status === 400 || chat.status === 404 || chat.status === 422) return { outcome: 'unknown-model', latencyMs };
+  return { outcome: 'unverified', latencyMs, detail: `http ${chat.status}` };
+}
+
+// Una fetch sola, con budget proprio, che non solleva mai: l'esito e' un valore.
+async function timedFetch({ fetchImpl, url, method, headers, body, timeoutMs }) {
+  const started = Date.now();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, {
+      method, signal: controller.signal, headers, ...(body ? { body } : {}),
+    });
+    const status = res && typeof res.status === 'number' ? res.status : 0;
+    let payload = null;
+    if (status >= 200 && status < 300) {
+      try { payload = typeof res.json === 'function' ? await res.json() : null; } catch (_) { payload = null; }
+    }
+    return { status, payload, latencyMs: Date.now() - started };
+  } catch (error) {
+    const aborted = error && (error.name === 'AbortError' || error.code === 'ABORT_ERR');
+    return { status: 0, payload: null, latencyMs: Date.now() - started, transport: aborted ? 'timeout' : 'error' };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 function authHeaders(profile, credential) {
   const protocol = profile && profile.protocol;
   if (protocol === 'anthropic_messages') {
@@ -126,4 +227,7 @@ async function probeModel({
   }
 }
 
-module.exports = { probeModel, OUTCOMES, findInCatalog, modelsUrl };
+module.exports = {
+  probeModel, OUTCOMES, findInCatalog, modelsUrl,
+  probeCustomEndpoint, chatCompletionsUrl, CUSTOM_FALLBACK_TIMEOUT_MS,
+};

package/lib/fleet/runtime.js

@@ -20,6 +20,7 @@ const {
 const {
   describeManaged, resolveManagedEngine, discoverOllamaModels, discoverPiModels, extraModelsFrom,
 } = require('./managed.js');
+const { sharedProbe: defaultEndpointProbe } = require('./endpoint-probe.js');
 const {
   httpError, minimalEnv, tmuxExec,
   composeClientInvocation, alternateScreenArgs,
@@ -170,12 +171,29 @@ function createBuiltinRuntime(ctx) {
     // Le discovery esterne hanno budget propri. Avviarle in parallelo mantiene
     // il budget dello status sotto quello del bridge invece di sommare i timeout
     // di Ollama e Pi in sequenza.
-    const [ollamaModels, piModels] = await Promise.all([
+    // Stessa logica per gli endpoint dichiarati a mano: la sonda ha un budget
+    // suo (≤ 1,5 s) e va in parallelo alle discovery, non in coda. Si attende
+    // SOLO cio' che non e' in cache: entro il TTL il verdetto e' gia' noto, ed
+    // e' questo che tiene `nc_status` e la UI lontani dal tempestare i router.
+    const endpointProbe = cfg.endpointProbe || defaultEndpointProbe;
+    const customUrls = [...new Set(cache.defs.engines
+      .map((e) => (e.managed && e.managed.baseUrl ? e.managed.baseUrl : null))
+      .filter(Boolean))];
+    const endpointVerdicts = new Map();
+    const probeEndpoints = customUrls.length
+      ? Promise.all(customUrls.map((u) => endpointProbe.status(u).then((v) => [u, v]).catch(() => [u, null])))
+      : Promise.resolve([]);
+    const [ollamaModels, piModels, probedEndpoints] = await Promise.all([
       needsOllama ? discoverOllamaModels({ ...cfg, home }) : [],
       needsPi ? discoverPiModels({ ...cfg, home }) : {},
+      probeEndpoints,
     ]);
+    for (const [u, v] of probedEndpoints) endpointVerdicts.set(u, v);
     const engines = cache.defs.engines.map((e) => {
-      const managed = e.managed ? describeManaged(e.managed, { ...cfg, home, extraModels: extraModelsFrom(cache.defs) }) : null;
+      const managed = e.managed ? describeManaged(e.managed, {
+        ...cfg, home, extraModels: extraModelsFrom(cache.defs), engineId: e.id,
+        endpointVerdict: e.managed && e.managed.baseUrl ? endpointVerdicts.get(e.managed.baseUrl) || null : null,
+      }) : null;
       return {
         id: e.id, label: e.label, rc: !!e.rc,
         ...(managed ? {
@@ -184,12 +202,21 @@ function createBuiltinRuntime(ctx) {
           models: managed.provider === 'ollama-cloud' ? ollamaModels
             : (managed.client === 'pi'
               ? (e.managed.provider === 'custom'
-                ? [e.managed.model]
+                ? [...new Set([e.managed.model, ...managed.models].filter(Boolean))]
                 : (e.managed.provider === 'native'
                   ? [...new Set(Object.values(piModels).flat())]
                   : (piModels[e.managed.provider] || [])))
               : managed.models),
           configured: managed.configured, reason: managed.reason,
+          // Provenienza della credenziale risolta: prima non arrivava affatto
+          // qui, quindi `nc_status` e la vista non potevano distinguere le
+          // origini nemmeno in teoria. Path, mtime e impronta del valore — il
+          // valore non esce mai da `managed.js`.
+          credentialSource: managed.credentialSource || 'missing',
+          credentialPath: managed.credentialPath || '',
+          credentialMtime: managed.credentialMtime || 0,
+          credentialHash8: managed.credentialHash8 || '',
+          credentialConflict: managed.credentialConflict || null,
         } : { kind: 'custom', configured: true, model: e.model?.value || '', models: [] }),
       };
     });

package/lib/notify/ask-answer-service.js

@@ -61,8 +61,12 @@ function createAskAnswerService({ asks, paste, receipts, onClosure, labelPrefix
     const committed = asks.commit(askId, text);
     if (request && receipts) receipts.finalize(request.peerId, askId, request.requestId, 'committed', null);
     const finalAsk = asks.get(askId);
-    emitClosure('ask-answered', { askId, revision: (finalAsk && finalAsk.revision) || 1, cellSession: finalAsk && finalAsk.session });
-    return { ok: true, committed };
+    const closure = emitClosure('ask-answered', { askId, revision: (finalAsk && finalAsk.revision) || 1, cellSession: finalAsk && finalAsk.session });
+    // `closure` e' il lavoro di recapito della chiusura verso i peer. Nasce QUI,
+    // nel punto in cui la transizione e' autorevole, e non su una rotta: legarlo
+    // alle route locali lasciava fuori la via federata, che e' il caso normale
+    // quando a rispondere e' un altro nodo. Chi puo' attendere lo attende.
+    return { ok: true, committed, closure };
   }
 
   // LOCAL answer: validation and binding already happened in the route.
@@ -115,8 +119,10 @@ function createAskAnswerService({ asks, paste, receipts, onClosure, labelPrefix
     }
     const out = asks.dismiss(askId);
     if (!out.ok) return out;
-    emitClosure('ask-dismissed', { askId, revision: (out.ask && out.ask.revision) || 1, cellSession: out.ask && out.ask.session });
-    return out;
+    const closure = emitClosure('ask-dismissed', { askId, revision: (out.ask && out.ask.revision) || 1, cellSession: out.ask && out.ask.session });
+    // Stesso punto comune dell'answer. `dismiss` resta SINCRONO — i chiamanti
+    // esistenti leggono `ok` subito — e il recapito viaggia come promise a parte.
+    return { ...out, closure };
   }
 
   // Operator reconciliation of a delivery-unknown attempt. The revision is a

package/lib/notify/asks.js

@@ -13,6 +13,10 @@ const ASKS_FILE = 'asks.json';
 // RIFIUTATO (reason 'cap'), mai droppato uno aperto. MAX_KEEP pota solo gli
 // answered piu' vecchi dal file.
 const MAX_OPEN = 100;
+// Cap degli ask IMPORTATI, separato da quello locale (stessa cifra): le domande
+// che arrivano da un peer e quelle poste da questo nodo sono due classi
+// distinte, e le prime non devono poter esaurire il budget delle seconde.
+const MAX_OPEN_IMPORTED = 100;
 const MAX_KEEP = 100;          // ask totali persistiti (i piu' vecchi answered si potano)
 const MAX_QUESTION = 2000;
 const MAX_OPTIONS = 8;
@@ -65,19 +69,58 @@ function createAsksStore(opts = {}) {
     return { ok: true, value: { question: question.trim(), options: opts2 } };
   }
 
-  function openCount() {
-    return load().filter((a) => !a.answered && !a.dismissed).length;
+  // Un ask IMPORTATO appartiene a un altro nodo: lo marca `originNode`, che e'
+  // anche il marcatore che ne impedisce la ri-esportazione.
+  function isImported(a) { return !!(a && a.originNode); }
+
+  function openCount(kind = 'local') {
+    return load().filter((a) => !a.answered && !a.dismissed
+      && (kind === 'imported' ? isImported(a) : !isImported(a))).length;
+  }
+
+  // Identita' CANONICA di un ask importato: la coppia (ownerId, ownerAskId).
+  // L'`id` locale e' nostro e all'owner non dice nulla; e' la coppia che nomina
+  // lo STESSO oggetto sui due nodi, quindi e' la chiave con cui si riconcilia.
+  function findImported(ownerId, ownerAskId) {
+    return load().find((a) => isImported(a) && a.ownerId === String(ownerId)
+      && a.ownerAskId === String(ownerAskId)) || null;
+  }
+
+  // Chiusura dell'alias locale quando l'OWNER chiude la domanda. Durevole: la
+  // riga resta nello storico marcata, quindi non ricompare a un reload e non
+  // torna risponibile.
+  function closeImported({ ownerId, ownerAskId, outcome }) {
+    const ask = findImported(ownerId, ownerAskId);
+    if (!ask) return { ok: true, changed: false, ask: null };
+    if (ask.answered || ask.dismissed) return { ok: true, changed: false, ask };
+    if (outcome === 'answered') { ask.answered = true; ask.answeredReconciled = true; }
+    else ask.dismissed = true;
+    ask.revision = (ask.revision || 0) + 1;
+    save();
+    return { ok: true, changed: true, ask };
   }
 
-  function create({ question, options, session }) {
+  function create({ question, options, session, ownerId, ownerAskId, originNode, originCell }) {
     const v = validate({ question, options });
     if (!v.ok) return { ok: false, reason: 'invalid', error: v.error };
-    // da revisione: cap duro sugli aperti — rifiuto esplicito, MAI drop di ask aperti.
-    if (openCount() >= MAX_OPEN) {
+    // DEDUP: la stessa domanda puo' arrivare due volte allo stesso nodo (import
+    // diretto del fan-out e feed dell'owner). L'identita' canonica e' la coppia
+    // (ownerId, ownerAskId): se l'alias esiste gia', si restituisce quello, non
+    // se ne crea un secondo.
+    if (originNode && ownerId && ownerAskId) {
+      const existing = findImported(ownerId, ownerAskId);
+      if (existing) return { ok: true, ask: existing, deduped: true };
+    }
+    // Cap duro sugli aperti, SEPARATO PER CLASSE: gli importati non consumano il
+    // budget dei locali. Con un cap unico, cento domande ricevute da un peer
+    // lasciavano questo nodo senza poter porre la prima domanda propria.
+    const imported = !!originNode;
+    const cap = imported ? MAX_OPEN_IMPORTED : MAX_OPEN;
+    if (openCount(imported ? 'imported' : 'local') >= cap) {
       return {
         ok: false,
         reason: 'cap',
-        error: `cap ask aperti raggiunto (${MAX_OPEN}): rispondi o attendi prima di crearne altri`,
+        error: `cap ask aperti raggiunto (${cap}): rispondi o attendi prima di crearne altri`,
       };
     }
     const ask = {
@@ -85,6 +128,23 @@ function createAsksStore(opts = {}) {
       question: v.value.question,
       ...(v.value.options ? { options: v.value.options } : {}),
       session: String(session),
+      // Identita' QUALIFICATA dell'ask. `ownerId` e' il nodo che possiede la
+      // domanda: la UI identifica una card con la coppia (ownerId, id) — due
+      // proprietari possono usare lo stesso id locale — e instrada la risposta
+      // al proprietario via ask-relay invece di incollarla qui. Assente = ask
+      // di questo nodo (il caso locale storico).
+      ...(ownerId ? { ownerId: String(ownerId) } : {}),
+      // L'id con cui l'OWNER conosce questa domanda. Su un ask importato l'`id`
+      // locale e' nostro e serve solo a noi; la risposta deve invece citare
+      // l'id dell'owner, perche' e' lui che risolve l'ask nel proprio store.
+      // Senza questo campo una risposta a un ask importato colpirebbe un id
+      // inesistente (o, peggio, un ask locale nostro con lo stesso id).
+      ...(ownerAskId ? { ownerAskId: String(ownerAskId) } : {}),
+      // Provenienza di un ask ARRIVATO dalla federazione. E' il marcatore che
+      // rende esplicito l'invariante: un ask con `originNode` non viene mai
+      // ri-esportato (nessun loop A->B->A). Un ask locale non ha questo campo.
+      ...(originNode ? { originNode: String(originNode) } : {}),
+      ...(originCell ? { originCell: String(originCell) } : {}),
       ts: now(),
       revision: 0,
       answered: false,
@@ -190,7 +250,7 @@ function createAsksStore(opts = {}) {
     return commit(id, text);
   }
 
-  return { create, get, list, openCount, claim, release, commit, markAnswered, markReconciled, isAnswering, dismiss, validate, filePath, MAX_OPEN };
+  return { create, get, list, openCount, isImported, findImported, closeImported, claim, release, commit, markAnswered, markReconciled, isAnswering, dismiss, validate, filePath, MAX_OPEN, MAX_OPEN_IMPORTED };
 }
 
 module.exports = { createAsksStore };