@mmmbuto/nexuscrew 0.9.23 → 0.9.25

package/lib/fleet/lease-client.js

@@ -48,6 +48,9 @@ function identityErrorCode(reason) {
   switch (reason) {
     case 'expired': return 'EXPIRED';
     case 'replay': case 'challenge-replay': return 'REPLAY';
+    // Verify v1.1: la tupla della connessione non corrisponde -> stesso codice
+    // del mismatch challenge-side lato daemon (prepare: AudienceMismatch).
+    case 'challenge_mismatch':
     case 'audience': case 'daemonBootId': case 'connectionId': return 'AUDIENCE_MISMATCH';
     case 'lease-down': case 'revoked': case 'generation': return 'REVOKED';
     case 'timeout': case 'authority-unavailable': case 'authority': return 'AUTHORITY_UNAVAILABLE';
@@ -55,6 +58,21 @@ function identityErrorCode(reason) {
   }
 }
 
+// Forma chiusa della tupla attesa (v1.1), condivisa da lease client e server:
+// nonce hex64, gli altri tre stringhe non vuote limitate; nessun campo extra.
+function validVerifyExpected(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const keys = Object.keys(value);
+  if (keys.length !== 4) return false;
+  for (const key of ['nonce', 'connectionId', 'daemonBootId', 'audience']) {
+    if (!Object.hasOwn(value, key)) return false;
+  }
+  if (typeof value.nonce !== 'string' || !/^[a-f0-9]{64}$/.test(value.nonce)) return false;
+  return ['connectionId', 'daemonBootId', 'audience'].every((key) => (
+    typeof value[key] === 'string' && value[key].length > 0 && value[key].length <= 200
+  ));
+}
+
 function validIdentityRequestId(value) {
   return (typeof value === 'string' && value.length > 0 && value.length <= 128)
     || Number.isSafeInteger(value);
@@ -77,6 +95,7 @@ function startLeaseClient(initialSocket, info, seams = {}) {
   // R3.2: bound di grace per i reconnect (eofAt + GRACE_MS). Oltre non si ritenta.
   let reconnectDeadline = null;
   const identityPending = new Map();
+  const verifyPending = new Map();
   // R1: una sola transizione di generazione in volo (il supervisore e' sequenziale).
   let generationWaiter = null;
 
@@ -233,6 +252,19 @@ function startLeaseClient(initialSocket, info, seams = {}) {
       while ((nl = buf.indexOf('\n')) !== -1) {
         const line = buf.slice(0, nl); buf = buf.slice(nl + 1);
         let msg; try { msg = JSON.parse(line); } catch (_) { continue; }
+        if (msg.type === 'verifyResult' && validIdentityRequestId(msg.requestId)) {
+          const pending = verifyPending.get(msg.requestId);
+          if (pending) {
+            verifyPending.delete(msg.requestId);
+            clearTimer(pending.timer);
+            if (msg.ok === true && msg.claims && typeof msg.claims === 'object') {
+              pending.resolve({ ok: true, claims: msg.claims });
+            } else {
+              const reason = msg.ok === false && typeof msg.reason === 'string' ? msg.reason : 'identity-unverified';
+              pending.resolve({ ok: false, reason });
+            }
+          }
+        }
         if (msg.type === 'challengeProofResult' && validIdentityRequestId(msg.requestId)) {
           const pending = identityPending.get(msg.requestId);
           if (pending) {
@@ -302,6 +334,45 @@ function startLeaseClient(initialSocket, info, seams = {}) {
     });
   }
 
+  //  verifica ONLINE di un identity proof presso l'authority. Risolve
+  // SEMPRE con {ok:true, claims} | {ok:false, reason}: il rifiuto e' una
+  // risposta, non un errore di trasporto. Solo timeout/authority giu'
+  // viaggiano come rejection (il relay li mappa su ok:false).
+  function verifyProof({ requestId, generation, proof, expected } = {}) {
+    if (!validIdentityRequestId(requestId) || !Number.isSafeInteger(generation) || generation < 0) {
+      return Promise.resolve({ ok: false, reason: 'identity-unverified' });
+    }
+    if (!proof || typeof proof !== 'object' || Array.isArray(proof)) {
+      return Promise.resolve({ ok: false, reason: 'malformed' });
+    }
+    // Verify v1.1: tupla attesa opzionale (retro-compat v1), schema chiuso.
+    if (expected !== undefined && !validVerifyExpected(expected)) {
+      return Promise.resolve({ ok: false, reason: 'identity-unverified' });
+    }
+    if (stopped || !current || current.destroyed || !current.writable || verifyPending.has(requestId)) {
+      return Promise.resolve({ ok: false, reason: 'authority-unavailable' });
+    }
+    return new Promise((resolve, reject) => {
+      const pending = { resolve, reject, timer: null };
+      pending.timer = setTimer(() => {
+        if (!verifyPending.has(requestId)) return;
+        verifyPending.delete(requestId);
+        reject(Object.assign(new Error('timeout'), { code: 'timeout' }));
+      }, IDENTITY_TIMEOUT_MS);
+      if (pending.timer && typeof pending.timer.unref === 'function') pending.timer.unref();
+      verifyPending.set(requestId, pending);
+      const sent = send({
+        type: 'verify', requestId, generation, v: 1, proof,
+        ...(expected ? { expected } : {}),
+      });
+      if (!sent) {
+        verifyPending.delete(requestId);
+        clearTimer(pending.timer);
+        reject(Object.assign(new Error('authority-unavailable'), { code: 'authority-unavailable' }));
+      }
+    });
+  }
+
   // R1: annuncia la transizione di generazione sulla connessione viva PRIMA
   // che il supervisore apra il canale identita' della generazione nuova.
   function announceGeneration(generation) {
@@ -338,12 +409,18 @@ function startLeaseClient(initialSocket, info, seams = {}) {
         clearTimer(waiter.timer);
         waiter.reject(Object.assign(new Error('lease-down'), { code: 'lease-down' }));
       }
+      for (const [, pending] of verifyPending) {
+        clearTimer(pending.timer);
+        pending.reject(Object.assign(new Error('lease-down'), { code: 'lease-down' }));
+      }
+      verifyPending.clear();
       clearTimer(refreshTimer);
       clearTimer(reconnectTimer);
       try { current && current.destroy(); } catch (_) {}
       current = null;
     },
     challengeProof,
+    verifyProof,
     announceGeneration,
     cancelIdentityChallenge: cancelIdentity,
     _isConnected: () => !!current && !current.destroyed,
@@ -353,6 +430,6 @@ function startLeaseClient(initialSocket, info, seams = {}) {
 }
 
 module.exports = {
-  startLeaseClient, validDaemonChallenge, identityErrorCode,
+  startLeaseClient, validDaemonChallenge, validVerifyExpected, identityErrorCode,
   IDENTITY_FRAME_LIMIT, IDENTITY_TIMEOUT_MS,
 };

package/lib/fleet/managed.js

@@ -29,6 +29,14 @@ const OLLAMA_CLOUD_MODELS = Object.freeze([
   // tools/thinking/vision/cloud; 552B MoE (8B attivi).
   // DICHIARATO 2026-09-11 https://ollama.com/library/deepseek-v4.1-flash
   'deepseek-v4.1-flash',
+  // Forme nude gemma4 e qwen3.5: MISURATE vive sull'API cloud
+  // (/v1/chat/completions -> 200, official measured sample 2026-09-12: 22
+  // live / 8 dead variants). Le varianti con tag servite in cloud restano
+  // `gemma4:31b` e `qwen3.5:397b`: `gemma4:12b`/`gemma4:e4b` e
+  // `qwen3.5:27b`/`:35b`/`:122b` sono 404 (fuori lista di proposito).
+  // DICHIARATO 2026-09-12 https://ollama.com/library/gemma4
+  // DICHIARATO 2026-09-12 https://ollama.com/library/qwen3.5
+  'gemma4', 'qwen3.5',
 ]);
 // Autorita' per OLLAMA_CONTEXT = IL CAMPO STRUTTURATO «Context» della scheda
 // canale (ollama.com/library, fetch 2026-08-27) — NON la descrizione, che
@@ -63,6 +71,12 @@ const OLLAMA_CONTEXT = Object.freeze({
   // deepseek-v4.1-flash: scheda «Context / 1M tokens» (2026-09-11); come gli
   // altri deepseek vale la convenzione binaria del repo (1M -> 1048576).
   'deepseek-v4.1-flash': 1048576,
+  // gemma4 (nudo, tag default `latest`): scheda «128K context window»,
+  // Input Text, Image (2026-09-12); convenzione binaria 128K -> 131072.
+  'gemma4': 131072,
+  // qwen3.5 (nudo, tag default `latest`): scheda «256K context window»,
+  // Input Text, Image (2026-09-12); come la sorella :397b, 256K -> 262144.
+  'qwen3.5': 262144,
 });
 // Capacita' per modello OSSERVATE dalla scheda canale (ollama.com/library,
 // 2026-08-27). Assenza = default conservativo (comportamento odierno, nessuna
@@ -85,6 +99,12 @@ const OLLAMA_MODEL_CAPABILITIES = Object.freeze({
   // (2026-09-11). PARALLEL NON dichiarato: default conservativo false finche'
   // non misurato su device.
   'deepseek-v4.1-flash': Object.freeze({ input: ['text', 'image'], reasoning: true, supportsParallelToolCalls: false }),
+  // gemma4: badge vision/tools/thinking/audio/cloud (2026-09-12); scheda Input
+  // Text, Image. PARALLEL NON dichiarato: default conservativo false.
+  'gemma4': Object.freeze({ input: ['text', 'image'], reasoning: true, supportsParallelToolCalls: false }),
+  // qwen3.5: badge vision/tools/thinking/cloud (2026-09-12); scheda Input
+  // Text, Image. PARALLEL NON dichiarato: default conservativo false.
+  'qwen3.5': Object.freeze({ input: ['text', 'image'], reasoning: true, supportsParallelToolCalls: false }),
 });
 // Descrittori dell'engine ollama-cloud per la generazione del catalogo client:
 // stessa forma dei descrittori custom/PI (id, label, contextWindow, input,
@@ -269,20 +289,47 @@ const ALIBABA_PI_MODELS = Object.freeze([
 //    "ha visto l'immagine" da "ha indovinato". Formati immagine per wire:
 //    Messages `source.base64`, Chat `image_url` data URI, Responses
 //    `input_image`.
+//
+//  DELTA 2026-09-12 («a segnale»): il piano Go non genera oggi
+//  (401 CreditsError su ogni generazione, chiave valida solo sul listing
+//  /models -> 200). Le aggiunte qui sotto NON sono misure e2e: sono
+//  SIGNAL-ONLY — nessun rifiuto di formato osservato sul gateway
+//  (CreditsError = wire accettata, crediti mancati dopo) e id presenti sia
+//  sul listing gateway (37) sia nella CLI `opencode models` 1.2.6 (27).
+//  eccezione: `qwen3.8-flash` rifiuta Responses con ModelError «format
+//  openai» (misurato 2026-09-12): entra SOLO in MESSAGES e CHAT.
+//  Rimossi i deprecated `glm-5`, `kimi-k2.5`, `minimax-m2.5`,
+//  `qwen3.5-plus`: status=deprecated upstream, assenti dalla CLI 1.2.6
+//  (sul gateway restano solo come listing). Storico LIMITS conservato nel
+//  commento della tabella.
 const OPENCODE_GO_MESSAGES_MODELS = Object.freeze([
-  'deepseek-v4-flash', 'deepseek-v4-flash-vision-exp', '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',
+  // Misurati e2e 2026-08-11 (matrice completa nel commento sopra):
+  'deepseek-v4-flash', 'deepseek-v4-flash-vision-exp', 'deepseek-v4-pro',
+  'glm-5.2', 'glm-5.1', 'minimax-m3', 'minimax-m2.7',
+  'qwen3.8-max', 'qwen3.7-max', 'qwen3.7-plus', 'qwen3.6-plus',
+  // Signal-only 2026-09-12 (CreditsError, nessun rifiuto formato):
+  'glm-5.3', 'glm-5.3-flash', 'longcat-2.0', 'deepseek-v4.1-flash',
+  'hy4-preview', 'qwen3.8-flash',
 ]);
 const OPENCODE_GO_RESPONSES_MODELS = Object.freeze([
-  'deepseek-v4-flash', 'deepseek-v4-flash-vision-exp', 'deepseek-v4-pro', 'gpt-5.6-luna', 'grok-4.6', 'glm-5.2', 'glm-5.1', 'glm-5',
+  // Misurati e2e 2026-08-11:
+  'deepseek-v4-flash', 'deepseek-v4-flash-vision-exp', 'deepseek-v4-pro',
+  'gpt-5.6-luna', 'grok-4.6', 'glm-5.2', 'glm-5.1',
+  // Signal-only 2026-09-12. qwen3.8-flash ESCLUSO di proposito: Responses
+  // rifiutata (ModelError «format openai», misurato 2026-09-12).
+  'glm-5.3', 'glm-5.3-flash', 'longcat-2.0', 'deepseek-v4.1-flash',
+  'hy4-preview',
 ]);
 const OPENCODE_GO_CHAT_MODELS = Object.freeze([
-  'deepseek-v4-flash', 'deepseek-v4-flash-vision-exp', 'deepseek-v4-pro', 'glm-5.2', 'glm-5.1', 'glm-5',
-  'kimi-k3', 'kimi-k2.7-code', 'kimi-k2.6', 'kimi-k2.5',
-  'minimax-m3', 'minimax-m2.7', 'minimax-m2.5',
-  'qwen3.8-max', 'qwen3.7-max', 'qwen3.7-plus', 'qwen3.6-plus', 'qwen3.5-plus',
-  'mimo-v2.5', 'mimo-v2.5-pro', 'hy3', 'gpt-5.6-luna',
+  // Misurati e2e 2026-08-11:
+  'deepseek-v4-flash', 'deepseek-v4-flash-vision-exp', 'deepseek-v4-pro',
+  'glm-5.2', 'glm-5.1', 'kimi-k3', 'kimi-k2.7-code', 'kimi-k2.6',
+  'minimax-m3', 'minimax-m2.7', 'qwen3.8-max', 'qwen3.7-max',
+  'qwen3.7-plus', 'qwen3.6-plus', 'mimo-v2.5', 'mimo-v2.5-pro', 'hy3',
+  'gpt-5.6-luna',
+  // Signal-only 2026-09-12:
+  'glm-5.3', 'glm-5.3-flash', 'longcat-2.0', 'deepseek-v4.1-flash',
+  'hy4-preview', 'qwen3.8-flash',
 ]);
 const OPENCODE_GO_ANTHROPIC_ROOT = 'https://opencode.ai/zen/go';
 const OPENCODE_GO_API_BASE = 'https://opencode.ai/zen/go/v1';
@@ -296,32 +343,45 @@ const OPENCODE_GO_API_BASE = 'https://opencode.ai/zen/go/v1';
 //
 // Restano numeri DICHIARATI, non misurati da noi: se un modello si comporta
 // come se ne avesse meno, il sospetto va qui prima che sul client.
+// Storico rimosso il 2026-09-12 (id deprecated, fuori CLI 1.2.6): glm-5
+// 202752/32768 · kimi-k2.5 262144/65536 · minimax-m2.5 204800/65536 ·
+// qwen3.5-plus 262144/65536. Rollback: reinserirli qui e nelle tre liste.
 const OPENCODE_GO_LIMITS = Object.freeze({
   'deepseek-v4-flash': { context: 1000000, output: 384000 },
   'deepseek-v4-flash-vision-exp': { context: 1000000, output: 384000 },
   'deepseek-v4-pro': { context: 1000000, output: 384000 },
   'glm-5.2': { context: 1000000, output: 131072 },
   'glm-5.1': { context: 202752, output: 32768 },
-  'glm-5': { context: 202752, output: 32768 },
   'kimi-k3': { context: 1048576, output: 131072 },
   'kimi-k2.7-code': { context: 262144, output: 262144 },
   'kimi-k2.6': { context: 262144, output: 65536 },
-  'kimi-k2.5': { context: 262144, output: 65536 },
   'minimax-m3': { context: 1000000, output: 131072 },
   'minimax-m2.7': { context: 204800, output: 131072 },
-  'minimax-m2.5': { context: 204800, output: 65536 },
   'qwen3.8-max': { context: 1000000, output: 131072 },
   'qwen3.7-max': { context: 1000000, output: 65536 },
   'qwen3.7-plus': { context: 1000000, output: 65536 },
   'qwen3.6-plus': { context: 1000000, output: 65536 },
-  'qwen3.5-plus': { context: 262144, output: 65536 },
   'mimo-v2.5': { context: 1000000, output: 128000 },
   'mimo-v2.5-pro': { context: 1048576, output: 128000 },
+  // hy3: NON allineato a models.dev (che ora dichiara output 128000):
+  // fonte divergente, resta il valore trascritto 2026-08-11 finche' non
+  // ricontrollato alla fonte. (divergenza segnalata in referto del 2026-09-12)
   hy3: { context: 256000, output: 64000 },
   'gpt-5.6-luna': { context: 1050000, output: 128000 },
   // grok-4.5 -> grok-4.6 (2026-08-27): id aggiornato al modello reale;
   // limiti confermati da models.dev (xai e opencode-go: 500000/500000).
   'grok-4.6': { context: 500000, output: 500000 },
+  // --- DICHIARATI models.dev 2026-09-12, NON misurati da noi: il piano Go
+  // rispondeva 401 CreditsError a ogni generazione il 2026-09-12, quindi
+  // nessun numero qui sotto e' stato verificato sul comportamento reale.
+  // Wire: nessun rifiuto di formato osservato (signal-only), tranne
+  // qwen3.8-flash su Responses (ModelError «format openai», misurato).
+  'deepseek-v4.1-flash': { context: 1000000, output: 384000 },
+  'glm-5.3': { context: 1000000, output: 131072 },
+  'glm-5.3-flash': { context: 1000000, output: 131072 },
+  'longcat-2.0': { context: 1000000, output: 131072 },
+  'qwen3.8-flash': { context: 1000000, output: 131072 },
+  'hy4-preview': { context: 1024000, output: 64000 },
 });
 
 function opencodeGoContextFor(model) {
@@ -1708,6 +1768,13 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
   // env, e i rami di trattamento (che confrontano il nome nuovo) non scattano:
   // la cella parte, sembra a posto, e gira con i parametri sbagliati.
   const env = {}; const args = []; const model = canonicalModel(cell?.model || spec.model);
+  // Identita' della cella protetta (solo codex-vl, l'unico client con un
+  // REQUIRED). La DECISIONE sul canale nasce qui, dove nasce il valore di
+  // CODEX_APP_SERVER_IDENTITY_REQUIRED, e viaggia col payload: se la derivasse
+  // il supervisore (cell-exec aggiungeva sempre fd 3:4) i due potevano
+  // divergere. Divergono, e una cella standalone muore sull'handshake.
+  let identityChannel = null;
+  let identityAuthorityUnavailable = '';
   // V-69: motivo per cui il prompt per-cella di vl NON e' stato composto
   // (versione del runtime che non regge, o file non scrivibile in sicurezza).
   // Stringa vuota = consegnato. Sale con l'engine risolto come vlPromptDegraded.
@@ -2044,6 +2111,24 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
   // as the runtime compatibility override for callers that do not carry a
   // parsed engine definition. Other managed clients never receive this key.
   if (spec.client === 'codex-vl') {
+    // REQUIRED=1 ha senso SOLO quando l'authority mode e' attivo e
+    // l'authority e' costruibile (credenziali presenti). Fuori di quello il
+    // relay non puo' emettere subject: forzare 1 produce daemon che non
+    // partono (fail-closed senza canale) o attach con `revoked` sistematico.
+    const identityMode = cfg.fleetIdentityMode
+      || (cfg.fleet && cfg.fleet.identity && cfg.fleet.identity.mode)
+      || 'legacy';
+    const identityCredentialsDistinct = (a, b) => (a && b
+      ? Buffer.from(String(a)).compare(Buffer.from(String(b))) !== 0
+      : false);
+    const identityAuthorityReady = !!(cfg.identityAuthority
+      || (cfg.identityDaemonCredential && cfg.identityLauncherCredential
+        && identityCredentialsDistinct(cfg.identityDaemonCredential, cfg.identityLauncherCredential)));
+    const identityAuthorityFault = cfg.identityAuthorityFault
+      || (cfg.identityDaemonCredential && cfg.identityLauncherCredential
+        && !identityCredentialsDistinct(cfg.identityDaemonCredential, cfg.identityLauncherCredential)
+        ? 'daemon and launcher credentials are identical' : null);
+    const logLine = typeof cfg.log === 'function' ? cfg.log : null;
     const definitionEnv = engine && engine.env;
     const runtimeEnv = cfg && cfg.env;
     const hasDefinitionOverride = definitionEnv && Object.prototype.hasOwnProperty.call(
@@ -2052,12 +2137,49 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
     const hasRuntimeOverride = runtimeEnv && Object.prototype.hasOwnProperty.call(
       runtimeEnv, CODEX_APP_SERVER_IDENTITY_REQUIRED,
     );
+    const authorityActive = identityMode === 'authority' && identityAuthorityReady;
+    // Authority configurata ma non costruibile (credenziali assenti, identiche
+    // o con permessi sbagliati): la cella protetta NON parte. Esportare '0' con
+    // una riga di log era un degrado silenzioso — il child partiva standalone e
+    // il motivo viveva solo nel log. Il rifiuto lo applica il launcher, col
+    // codice IDENTITY_AUTHORITY_UNAVAILABLE (runtime.js); qui si dichiara il
+    // MOTIVO, senza valori.
+    const authorityUnavailable = identityMode === 'authority' && !identityAuthorityReady
+      ? (identityAuthorityFault || 'authority credentials missing')
+      : '';
     if (hasDefinitionOverride && typeof definitionEnv[CODEX_APP_SERVER_IDENTITY_REQUIRED] === 'string') {
       env[CODEX_APP_SERVER_IDENTITY_REQUIRED] = definitionEnv[CODEX_APP_SERVER_IDENTITY_REQUIRED];
+      identityChannel = env[CODEX_APP_SERVER_IDENTITY_REQUIRED] === '1';
+      if (!authorityActive && identityChannel && logLine) {
+        logLine(`fleet identity: override definition force CODEX_APP_SERVER_IDENTITY_REQUIRED=1 `
+          + `but identity mode is '${identityMode}' without authority credentials`);
+      }
     } else if (hasRuntimeOverride && typeof runtimeEnv[CODEX_APP_SERVER_IDENTITY_REQUIRED] === 'string') {
       env[CODEX_APP_SERVER_IDENTITY_REQUIRED] = runtimeEnv[CODEX_APP_SERVER_IDENTITY_REQUIRED];
-    } else {
+      identityChannel = env[CODEX_APP_SERVER_IDENTITY_REQUIRED] === '1';
+      if (!authorityActive && identityChannel && logLine) {
+        logLine(`fleet identity: override runtime force CODEX_APP_SERVER_IDENTITY_REQUIRED=1 `
+          + `but identity mode is '${identityMode}' without authority credentials`);
+      }
+    } else if (authorityActive) {
       env[CODEX_APP_SERVER_IDENTITY_REQUIRED] = CODEX_APP_SERVER_IDENTITY_REQUIRED_DEFAULT;
+      identityChannel = env[CODEX_APP_SERVER_IDENTITY_REQUIRED] === '1';
+    } else if (authorityUnavailable) {
+      // Nessuna esportazione: il lancio e' rifiutato prima dello spawn, quindi
+      // il valore non arriverebbe mai a un child. Un override esplicito (rami
+      // sopra) resta una scelta dell'operatore e non entra qui.
+      identityChannel = false;
+      identityAuthorityUnavailable = authorityUnavailable;
+      if (logLine) {
+        logLine('fleet identity: protected cell launch refused — authority configured but unavailable ('
+          + authorityUnavailable + ')');
+      }
+    } else {
+      env[CODEX_APP_SERVER_IDENTITY_REQUIRED] = '0';
+      identityChannel = false;
+      if (logLine) {
+        logLine(`fleet identity: CODEX_APP_SERVER_IDENTITY_REQUIRED=0 (identity mode '${identityMode}')`);
+      }
     }
   }
   // Prompt su argv (0.8.47): SOLO i client che non hanno un percorso classified
@@ -2106,6 +2228,10 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
   return { ok: true, info, engine: {
     ...engine, command, args, env,
     promptMode: promptViaDelivery ? 'send-keys' : 'managed-argv', clientBinary: info.binary,
+    // Canale identita' (vedi sopra): assente per i client senza REQUIRED, cosi'
+    // il payload resta quello di prima e il supervisore conserva il default.
+    ...(identityChannel === null ? {} : { identityChannel }),
+    ...(identityAuthorityUnavailable ? { identityAuthorityUnavailable } : {}),
     ...(vlPromptDegraded ? { vlPromptDegraded } : {}),
     ...(spec.client === 'shell' ? { shellOneShot } : {}),
   } };

package/lib/fleet/runtime.js

@@ -41,6 +41,22 @@ function findEngine(defs, id) { return defs.engines.find((e) => e.id === id) ||
 //   boot = definizioni iniziali (loadDefinitions, non null: il caller gia'
 //   e' tornato unavailable su garbage).
 // ---------------------------------------------------------------------------
+// Preflight identita': un'authority configurata ma non costruibile
+// REFUTA il lancio della cella protetta invece di degradarla a standalone in
+// silenzio. Il motivo non contiene valori: e' la stessa stringa che il
+// risolutore (lib/fleet/managed.js) mette su `identityAuthorityUnavailable`.
+// Il codice e' stabile e destinato all'operatore, come gli altri IDENTITY_*.
+function identityLaunchRefusal(launchEngine) {
+  const reason = launchEngine && launchEngine.identityAuthorityUnavailable;
+  if (!reason) return null;
+  return {
+    status: 500,
+    code: 'IDENTITY_AUTHORITY_UNAVAILABLE',
+    message: `fleet identity: authority configurata ma non costruibile (${reason}); `
+      + 'la cella protetta non parte',
+  };
+}
+
 function createBuiltinRuntime(ctx) {
   const {
     cfg, home, defsPath, tmuxBin, readonly, launchBroker, leaseManager, boot, ensureProtection,
@@ -214,6 +230,15 @@ function createBuiltinRuntime(ctx) {
         const log = typeof cfg.log === 'function' ? cfg.log : console.warn;
         log(`fleet vl ${cell.id}: ${launchEngine.vlPromptDegraded}`);
       }
+      // L'authority e' configurata ma non e' costruibile — il child non
+      // partirebbe con un'identita' verificabile, quindi non parte affatto.
+      // Prima si esportava REQUIRED=0 con una riga di log: la cella si avviava
+      // standalone e il degrado si scopriva solo leggendo il log.
+      const refusal = identityLaunchRefusal(launchEngine);
+      if (refusal) {
+        throw httpError(refusal.status, refusal.message, null,
+          { phase: 'preflight', code: refusal.code });
+      }
     }
 
     // (2) trust del command PRIMA di lanciare
@@ -264,6 +289,10 @@ function createBuiltinRuntime(ctx) {
           NEXUSCREW_MCP_SESSION: cell.tmuxSession,
         },
         ...(identity ? { identity } : {}),
+        // La decisione sul canale viaggia col payload: il supervisore non la
+        // ricalcola (era il punto in cui i due potevano divergere).
+        ...(typeof launchEngine.identityChannel === 'boolean'
+          ? { identityChannel: launchEngine.identityChannel } : {}),
         ...(leaseInfo ? { lease: { cellId: cell.id, launchEpoch: leaseInfo.launchEpoch, stablePath: leaseInfo.stablePath } } : {}),
         supervise: {
           enabled: !launchEngine.shellOneShot,
@@ -568,4 +597,4 @@ function createBuiltinRuntime(ctx) {
   };
 }
 
-module.exports = { createBuiltinRuntime, findCell, findEngine, STATUS_TTL_MS };
+module.exports = { createBuiltinRuntime, findCell, findEngine, identityLaunchRefusal, STATUS_TTL_MS };

package/lib/mcp/identity-provider.js

@@ -15,6 +15,7 @@ const { readTokenSafe } = require('../auth/token.js');
 const { cellIdFromTmuxSession, tmuxSessionForCell } = require('../fleet/definitions.js');
 const {
   identityContextError, IDENTITY_CONTEXT_AUTHORITY_UNAVAILABLE,
+  IDENTITY_CONTEXT_VERIFIED_ENV_INVALID,
 } = require('./identity-schema.js');
 
 const INTROSPECT_TIMEOUT_MS = 8000;
@@ -27,6 +28,40 @@ function identityChannelPath({ tokenPath, session }) {
   return path.join(identityChannelDir(tokenPath), `${session}.json`);
 }
 
+// i metadati verified consegnati dal launcher VL al figlio MCP
+// (solo su sessione bound). La fonte e' PRESENTE se la version key esiste:
+// presence parziale o valori incompleti = fonte invalida (fail-closed), mai
+// assenza. Nessun valore torna al chiamante: solo coerenza booleana.
+const VERIFIED_ENV_VERSION_KEY = 'NEXUSCREW_VERIFIED_ENV_VERSION';
+const VERIFIED_ENV_FIELDS = Object.freeze({
+  ownerInstanceId: 'NEXUSCREW_VERIFIED_OWNER_INSTANCE_ID',
+  cellId: 'NEXUSCREW_VERIFIED_CELL_ID',
+  incarnationId: 'NEXUSCREW_VERIFIED_INCARNATION_ID',
+  bindingId: 'NEXUSCREW_VERIFIED_BINDING_ID',
+  origin: 'NEXUSCREW_VERIFIED_ORIGIN',
+  threadId: 'NEXUSCREW_VERIFIED_THREAD_ID',
+});
+
+function readVerifiedEnv(env) {
+  const raw = env && env[VERIFIED_ENV_VERSION_KEY];
+  if (typeof raw !== 'string') return null; // del tutto assente -> percorso legacy
+  const fields = {};
+  for (const [key, name] of Object.entries(VERIFIED_ENV_FIELDS)) {
+    const value = env[name];
+    fields[key] = typeof value === 'string' && value.trim() ? value.trim() : null;
+  }
+  return { present: true, version: raw.trim(), ...fields };
+}
+
+function verifiedEnvFault(verified, { localInstanceId } = {}) {
+  if (verified.version !== '1') return 'version';
+  if (!verified.ownerInstanceId) return 'owner';
+  if (localInstanceId && verified.ownerInstanceId !== localInstanceId) return 'owner';
+  if (!verified.cellId) return 'cell';
+  if (!verified.incarnationId) return 'incarnation';
+  return null;
+}
+
 function readIdentityChannel(filePath) {
   let raw;
   try { raw = JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch (_) { return null; }
@@ -75,13 +110,100 @@ function createMcpIdentityProvider({ config, env = process.env, fetchImpl = fetc
   const cfg = config || require('../config.js').loadConfig();
   const tokenPath = cfg && cfg.tokenPath;
   const port = cfg && cfg.port;
-  const session = env && env.NEXUSCREW_MCP_SESSION;
-  if (!tokenPath || !Number.isSafeInteger(port) || !session) return null;
-  const channelPath = identityChannelPath({ tokenPath, session });
-  if (!readIdentityChannel(channelPath)) return null;
+  const verified = readVerifiedEnv(env);
+  const legacySession = env && env.NEXUSCREW_MCP_SESSION;
+
+  // la fonte verified ha PRECEDENZA ASSOLUTA. Se i metadati verified
+  // sono presenti il provider esiste SEMPRE (anche con metadati incompleti):
+  // la validazione completa e' per-richiesta e fallisce closed con
+  // VERIFIED_ENV_INVALID. Mai un ritorno a null che riaprirebbe il percorso
+  // legacy accanto a metadati verified di provenienza non dimostrata.
+  let mode = null;
+  let channelSession = null;
+  if (verified && verified.present) {
+    mode = 'verified-env';
+    // (c) cellId -> tmuxSession con la stessa mappatura deterministica del
+    // launcher (definitions.tmuxSessionForCell): il canale identity di quella
+    // sessione e' l'unico archivo condiviso della cella su questo nodo.
+    channelSession = verified.cellId ? tmuxSessionForCell(verified.cellId) : null;
+  } else if (legacySession) {
+    mode = 'legacy-session';
+    channelSession = legacySession;
+  }
+  if (!tokenPath || !Number.isSafeInteger(port) || !mode) return null;
+  if (mode === 'legacy-session' && !channelSession) return null;
+  // In verified mode un canale sessione non derivabile NON degrada a null:
+  // il provider resta in piedi e fallisce closed per-richiesta.
+  const channelPath = identityChannelPath({ tokenPath, session: channelSession || '__unverified__' });
+  if (mode === 'legacy-session' && !readIdentityChannel(channelPath)) return null;
   const baseUrl = `http://127.0.0.1:${port}`;
 
-  async function introspectChannel() {
+  // l'ownerInstanceId dichiarato deve coincidere con l'instanceId
+  // locale del nodo. Fonte: config.injectabile (test) oppure nodes.json.
+  function localInstanceId() {
+    if (typeof cfg.identityOwnerInstanceId === 'string' && cfg.identityOwnerInstanceId) {
+      return cfg.identityOwnerInstanceId;
+    }
+    try {
+      const nodesStore = require('../nodes/store.js');
+      const nodesPath = cfg.nodesPath
+        || nodesStore.defaultNodesPath(cfg.home || require('node:os').homedir());
+      const store = nodesStore.loadStore(nodesPath);
+      return (store && store.nodeId) || null;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function verifiedFault() {
+    const fault = verifiedEnvFault(verified, { localInstanceId: localInstanceId() });
+    if (fault) return fault;
+    if (!channelSession) return 'cell';
+    if (!readIdentityChannel(channelPath)) return 'channel';
+    return null;
+  }
+
+  async function introspectVerified() {
+    const fault = verifiedFault();
+    if (fault) {
+      throw identityContextError(IDENTITY_CONTEXT_VERIFIED_ENV_INVALID,
+        `NEXUSCREW_MCP_IDENTITY_VERIFIED_ENV_INVALID: verified env incoerente (${fault})`);
+    }
+    let response;
+    try {
+      const token = readTokenSafe(tokenPath);
+      response = await fetchImpl(`${baseUrl}/api/lease/introspect`, {
+        method: 'POST',
+        headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+        body: JSON.stringify({ proof: readIdentityChannel(channelPath).proof }),
+        signal: AbortSignal.timeout(INTROSPECT_TIMEOUT_MS),
+      });
+    } catch (_) {
+      throw identityContextError(IDENTITY_CONTEXT_AUTHORITY_UNAVAILABLE,
+        'NEXUSCREW_MCP_IDENTITY_AUTHORITY_UNAVAILABLE: authority non raggiungibile');
+    }
+    if (response.status >= 500) {
+      throw identityContextError(IDENTITY_CONTEXT_AUTHORITY_UNAVAILABLE,
+        'NEXUSCREW_MCP_IDENTITY_AUTHORITY_UNAVAILABLE: authority non raggiungibile');
+    }
+    if (!response.ok) {
+      throw identityContextError(IDENTITY_CONTEXT_VERIFIED_ENV_INVALID,
+        'NEXUSCREW_MCP_IDENTITY_VERIFIED_ENV_INVALID: introspezione rifiutata dall\'authority');
+    }
+    const out = await response.json().catch(() => null);
+    const coherent = out && out.status === 'live' && out.identityMode === 'authority'
+      && out.cellId === verified.cellId && out.tmuxSession === channelSession
+      && typeof out.instanceId === 'string' && out.instanceId === verified.ownerInstanceId
+      && Number.isSafeInteger(Number(out.expiresAt)) && Number(out.expiresAt) > now()
+      && typeof out.incarnationId === 'string' && out.incarnationId === verified.incarnationId;
+    if (!coherent) {
+      throw identityContextError(IDENTITY_CONTEXT_VERIFIED_ENV_INVALID,
+        'NEXUSCREW_MCP_IDENTITY_VERIFIED_ENV_INVALID: introspezione non coerente coi metadati verified');
+    }
+    return { context: sharedContextFromIntrospection({ ...out, expiresAt: Number(out.expiresAt) }, now()), proof: readIdentityChannel(channelPath).proof };
+  }
+
+  async function introspectLegacy() {
     const channel = readIdentityChannel(channelPath);
     if (!channel) return { verified: false, mode: 'shared' };
     let response;
@@ -113,11 +235,16 @@ function createMcpIdentityProvider({ config, env = process.env, fetchImpl = fetc
     return { context: sharedContextFromIntrospection({ ...out, expiresAt: Number(out.expiresAt) }, now()), proof: channel.proof };
   }
 
+  const introspectChannel = mode === 'verified-env' ? introspectVerified : introspectLegacy;
+
   async function provider({ tool } = {}) {
     void tool; // il canale lease è per-connessione cella, non per-tool
     const out = await introspectChannel();
     return out.context ? out.context : out;
   }
+  // il server espone `source: 'verified-env'` in nc_identity quando la
+  // fonte dei metadati e' il launcher verified e non la sessione legacy.
+  provider.identitySource = mode === 'verified-env' ? 'verified-env' : 'online';
   provider.currentProof = () => {
     const channel = readIdentityChannel(channelPath);
     return channel ? channel.proof : null;
@@ -129,4 +256,5 @@ module.exports = {
   createMcpIdentityProvider,
   persistIdentityChannel,
   identityChannelPath,
+  readVerifiedEnv,
 };

package/lib/mcp/identity-schema.js

@@ -9,6 +9,7 @@ const IDENTITY_CONTEXT_MISSING = 'NEXUSCREW_MCP_IDENTITY_CONTEXT_MISSING';
 const IDENTITY_CONTEXT_UNVERIFIED = 'NEXUSCREW_MCP_IDENTITY_CONTEXT_UNVERIFIED';
 const IDENTITY_CONTEXT_FROM_MISMATCH = 'NEXUSCREW_MCP_IDENTITY_CONTEXT_FROM_MISMATCH';
 const IDENTITY_CONTEXT_AUTHORITY_UNAVAILABLE = 'NEXUSCREW_MCP_IDENTITY_AUTHORITY_UNAVAILABLE';
+const IDENTITY_CONTEXT_VERIFIED_ENV_INVALID = 'NEXUSCREW_MCP_IDENTITY_VERIFIED_ENV_INVALID';
 
 function identityContextError(code, message) {
   const error = new Error(message);
@@ -163,6 +164,7 @@ module.exports = {
   IDENTITY_CONTEXT_UNVERIFIED,
   IDENTITY_CONTEXT_FROM_MISMATCH,
   IDENTITY_CONTEXT_AUTHORITY_UNAVAILABLE,
+  IDENTITY_CONTEXT_VERIFIED_ENV_INVALID,
   identityContextError,
   normalizeIdentityContext,
 };