@mmmbuto/nexuscrew 0.9.24 → 0.9.26

package/lib/fleet/identity-provision.js

@@ -0,0 +1,142 @@
+'use strict';
+// Provisioning dell'authority mode. Genera le DUE credenziali distinte
+// (daemon + launcher) nella directory dell'authority, con permessi 0700/0600,
+// e attiva `fleet.identity.mode = "authority"` nella config. Idempotente:
+// credenziali esistenti non vengono MAI sovrascritte senza --force.
+//
+// Nessun valore di credenziale torna nel ritorno e nessun valore finisce nei
+// log: il ritorno descrive solo percorsi e azioni.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const CREDENTIAL_FILES = Object.freeze({
+  identityDaemonCredential: 'daemon.credential',
+  identityLauncherCredential: 'launcher.credential',
+});
+
+// Le due credenziali devono essere DISTINTE (stessa regola di
+// identity-authority a runtime): confronto a tempo costante sui byte.
+function credentialsDistinct(daemonCredential, launcherCredential) {
+  if (typeof daemonCredential !== 'string' || !daemonCredential
+    || typeof launcherCredential !== 'string' || !launcherCredential) return false;
+  const daemon = Buffer.from(daemonCredential);
+  const launcher = Buffer.from(launcherCredential);
+  if (daemon.length !== launcher.length) return true;
+  return !crypto.timingSafeEqual(daemon, launcher);
+}
+
+function defaultAuthorityDir(home) {
+  return path.join(home || require('node:os').homedir(), '.nexuscrew', 'identity-authority');
+}
+
+function assertSafeMode(filePath, expectedMode) {
+  const st = fs.lstatSync(filePath);
+  if (!st.isFile()) throw new Error(`identity provision: ${filePath} non e' un file regolare`);
+  if ((st.mode & 0o777) !== expectedMode) {
+    throw new Error(`identity provision: ${filePath} ha permessi ${(st.mode & 0o777).toString(8)} (attesi ${expectedMode.toString(8)})`);
+  }
+}
+
+function existingCredentials(dir) {
+  const found = [];
+  for (const name of Object.values(CREDENTIAL_FILES)) {
+    const filePath = path.join(dir, name);
+    try {
+      const st = fs.lstatSync(filePath);
+      if (st.isFile() && st.size > 0) found.push(filePath);
+    } catch (_) { /* assente: ok */ }
+  }
+  return found;
+}
+
+function provisionIdentityAuthority({
+  home,
+  dir,
+  force = false,
+  writeConfig = true,
+  configPath,
+  randomBytes = crypto.randomBytes,
+  fsImpl = fs,
+  now = new Date,
+} = {}) {
+  const targetDir = dir || defaultAuthorityDir(home);
+  fsImpl.mkdirSync(targetDir, { recursive: true, mode: 0o700 });
+
+  const preExisting = existingCredentials(targetDir);
+  if (preExisting.length && !force) {
+    return {
+      ok: false, code: 'ALREADY_PROVISIONED', dir: targetDir,
+      existing: preExisting,
+      message: 'identity authority already provisioned; pass --force to regenerate',
+    };
+  }
+
+  const written = [];
+  let daemonValue = randomBytes(32).toString('hex');
+  let launcherValue = randomBytes(32).toString('hex');
+  // Rigenera finché le due credenziali sono distinte (confronto a tempo
+  // costante, stessa regola di identity-authority). Con una fonte casuale
+  // sana la prima iterazione passa; con randomBytes iniettati degeneri il
+  // provisioning viene RIFIUTATO anche con --force, senza scrivere nulla.
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    if (credentialsDistinct(daemonValue, launcherValue)) break;
+    launcherValue = randomBytes(32).toString('hex');
+    if (attempt === 7 && !credentialsDistinct(daemonValue, launcherValue)) {
+      return {
+        ok: false, code: 'IDENTICAL_CREDENTIALS', dir: targetDir,
+        message: 'identity provision: generated credentials are identical; nothing written',
+      };
+    }
+  }
+  for (const [name, value] of [
+    [CREDENTIAL_FILES.identityDaemonCredential, daemonValue],
+    [CREDENTIAL_FILES.identityLauncherCredential, launcherValue],
+  ]) {
+    const filePath = path.join(targetDir, name);
+    fsImpl.writeFileSync(filePath, `${value}\n`, { mode: 0o600 });
+    written.push(filePath);
+  }
+  // I permessi espliciti valgono anche su filesystem che ignorano mode in
+  // writeFileSync (umask larghe): rinforza dopo la scrittura.
+  fsImpl.chmodSync(targetDir, 0o700);
+  for (const filePath of written) fsImpl.chmodSync(filePath, 0o600);
+  for (const filePath of written) assertSafeMode(filePath, 0o600);
+
+  const resolvedConfigPath = configPath
+    || (process.env.NEXUSCREW_CONFIG_FILE
+      || path.join(home || require('node:os').homedir(), '.nexuscrew', 'config.json'));
+
+  let configUpdated = false;
+  let configInstructions = null;
+  if (writeConfig) {
+    let config = {};
+    try {
+      config = JSON.parse(fsImpl.readFileSync(resolvedConfigPath, 'utf8'));
+      if (!config || typeof config !== 'object' || Array.isArray(config)) config = {};
+    } catch (_) { config = {}; }
+    config.fleet = { ...(config.fleet || {}), identity: { ...(config.fleet?.identity || {}), mode: 'authority' } };
+    fsImpl.mkdirSync(path.dirname(resolvedConfigPath), { recursive: true });
+    fsImpl.writeFileSync(resolvedConfigPath, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+    configUpdated = true;
+  } else {
+    configInstructions = [
+      'Set the following keys in the NexusCrew config (fleet.identity.mode = "authority")',
+      `and keep the two credential files in place under ${targetDir}:`,
+      ...Object.values(CREDENTIAL_FILES).map((name) => `  ${path.join(targetDir, name)}`),
+    ].join('\n');
+  }
+
+  return {
+    ok: true, dir: targetDir, written, configUpdated, configInstructions,
+    mode: 'authority',
+  };
+}
+
+module.exports = {
+  provisionIdentityAuthority,
+  defaultAuthorityDir,
+  credentialsDistinct,
+  CREDENTIAL_FILES,
+};

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,
 };