@mmmbuto/nexuscrew 0.9.24 → 0.9.25

package/lib/fleet/cell-exec.js

@@ -111,9 +111,14 @@ function validLease(value) {
 
 function validPayload(payload) {
   if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return false;
-  if (Object.keys(payload).some((key) => !['command', 'args', 'env', 'supervise', 'restartPrompt', 'lease', 'identity'].includes(key))) return false;
+  if (Object.keys(payload).some((key) => !['command', 'args', 'env', 'supervise', 'restartPrompt', 'lease', 'identity', 'identityChannel'].includes(key))) return false;
   if (typeof payload.command !== 'string' || !payload.command || !Array.isArray(payload.args)) return false;
   if (!payload.env || typeof payload.env !== 'object' || Array.isArray(payload.env)) return false;
+  // Il launcher decide se il canale identita' esiste (managed.js) e lo dichiara
+  // nel payload con `identityChannel`: il supervisore non lo ricalcola. La chiave
+  // va quindi ammessa qui, e SOLO come booleano: un valore di altro tipo e' un
+  // payload malformato, non un "canale assente" (assente = caller precedente).
+  if (payload.identityChannel !== undefined && typeof payload.identityChannel !== 'boolean') return false;
   return payload.args.every((v) => typeof v === 'string')
     && Object.entries(payload.env).every(([k, v]) => /^[A-Za-z_][A-Za-z0-9_]{0,63}$/.test(k) && typeof v === 'string')
     && validSupervise(payload.supervise)
@@ -522,7 +527,16 @@ async function main(argv = process.argv.slice(2), seams = {}) {
   const sleep = seams.sleep || ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const proc = seams.process || process;
   const writeError = seams.writeError || seams.stderrWrite || ((message) => process.stderr.write(message));
-  const childEnv = { ...payload.env, NEXUSCREW_IDENTITY_FD: '3:4' };
+  // Il canale identita' nasce SOLO se il launcher lo ha deciso: la stessa
+  // risoluzione che decide CODEX_APP_SERVER_IDENTITY_REQUIRED in managed.js
+  // viaggia nel payload come `identityChannel`. Derivarlo qui (aggiungere
+  // sempre fd 3:4) permetteva ai due di divergere: una cella standalone
+  // riceveva il canale, avviava l'handshake contro un lease server legacy che
+  // rispondeva 'revoked', e moriva. Un payload senza il campo (caller
+  // precedenti) conserva il comportamento di prima.
+  const identityChannel = payload.identityChannel !== false;
+  const childEnv = { ...payload.env };
+  if (identityChannel) childEnv.NEXUSCREW_IDENTITY_FD = '3:4';
   // tmux injects these only after the broker ticket was created. Preserve them
   // for the actual TUI and bind NexusCrew MCP callbacks to the owning session.
   if (process.env.TMUX) childEnv.TMUX = process.env.TMUX;
@@ -612,7 +626,11 @@ async function main(argv = process.argv.slice(2), seams = {}) {
       const promptCtl = startGenerationPrompt(payload.restartPrompt, generation, childState, seams);
       current = spawnImpl(payload.command, payload.args, {
         env: childEnv,
-        stdio: ['inherit', 'inherit', 'inherit', 'pipe', 'pipe'],
+        // Senza canale non si creano nemmeno le pipe: fd 3 e 4 chiusi nel
+        // child (non pipe aperte e inutilizzate).
+        stdio: identityChannel
+          ? ['inherit', 'inherit', 'inherit', 'pipe', 'pipe']
+          : ['inherit', 'inherit', 'inherit'],
       });
       // R1a (fix5): exit/error del figlio contano SUBITO, prima di qualunque
       // await — se il figlio esce durante l'handshake di generazione, l'evento
@@ -649,7 +667,15 @@ async function main(argv = process.argv.slice(2), seams = {}) {
           ),
           childExit.then(() => 'exited'),
         ]);
-        if (raced === 'ok' && !childSettled) {
+        if (!identityChannel) {
+          // Nessun canale da aprire: la transizione di generazione resta
+          // annunciata al lease (bookkeeping), ma l'identita' non esiste e
+          // non c'e' nessun fd da chiudere. L'uscita del figlio resta
+          // diagnostica.
+          if (raced === 'exited') {
+            writeError(`nexuscrew cell: figlio uscito durante l'handshake di generazione (gen ${generation})\n`);
+          }
+        } else if (raced === 'ok' && !childSettled) {
           identityCtl = createIdentityChannel({
             request: current && current.stdio && current.stdio[3],
             response: current && current.stdio && current.stdio[4],
@@ -671,7 +697,7 @@ async function main(argv = process.argv.slice(2), seams = {}) {
         } else {
           writeError(`nexuscrew cell: generazione ${generation} senza identita' (${raced})\n`);
         }
-      } else {
+      } else if (identityChannel) {
         identityCtl = createIdentityChannel({
           request: current && current.stdio && current.stdio[3],
           response: current && current.stdio && current.stdio[4],

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