@mmmbuto/nexuscrew 0.9.19 → 0.9.21

package/lib/audio/routes.js

@@ -22,6 +22,7 @@ const { createReceiptStore } = require('./receipt.js');
 const { createSpeakRateLimiter } = require('./rate-limit.js');
 const { createGroupReceiptStore } = require('./group-receipt.js');
 const { createGroupSpeaker } = require('./group-speak.js');
+const { createIdentityBindingGuard } = require('../identity/binding-guard.js');
 
 const UTTERANCE_ID_RE = /^[A-Za-z0-9._:-]{8,128}$/;
 const LANG_RE = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,34})$/;
@@ -103,6 +104,24 @@ function parseGroupSpeakBody(body) {
 }
 
 function audioRoutes(deps = {}) {
+  const bindingGuard = createIdentityBindingGuard({
+    fleetP: deps.fleetP || null,
+    instanceId: deps.localNodeId || null,
+    now: deps.now || Date.now,
+    sharedRequired: deps.identityMode === 'authority',
+  });
+
+  async function guardBinding(req) {
+    try {
+      return await bindingGuard.verify(req, { localOnly: true });
+    } catch (e) {
+      return e;
+    }
+  }
+
+  function bindingRejected(res, error) {
+    return send(res, 403, { error: error.message, code: error.code });
+  }
   if (!deps.originResolver || typeof deps.originResolver.resolve !== 'function') {
     throw new Error('audioRoutes: originResolver e obbligatorio (origine verificata)');
   }
@@ -210,6 +229,8 @@ function audioRoutes(deps = {}) {
 
   r.post('/speak', async (req, res) => {
     const resolved = await originOr401(req, res); if (!resolved) return undefined;
+    const binding = await guardBinding(req);
+    if (binding instanceof Error) return bindingRejected(res, binding);
     const { origin, trust, visited } = resolved;
     const parsed = parseSpeakBody(req.body, { federated: trust === 'federated' });
     if (parsed.error) return send(res, 400, { status: 'refused', reason: parsed.error });
@@ -256,6 +277,8 @@ function audioRoutes(deps = {}) {
 
   r.post('/stop', async (req, res) => {
     const resolved = await originOr401(req, res); if (!resolved) return undefined;
+    const binding = await guardBinding(req);
+    if (binding instanceof Error) return bindingRejected(res, binding);
     const { origin } = resolved;
     const parsed = parseStopBody(req.body, { federated: resolved.trust === 'federated' });
     if (parsed.error) return send(res, 400, { status: 'refused', reason: parsed.error });
@@ -326,6 +349,8 @@ function audioRoutes(deps = {}) {
   r.post('/groups/speak', async (req, res) => {
     const resolved = await originOr401(req, res); if (!resolved) return undefined;
     if (resolved.trust !== 'local-bridge') return send(res, 403, { status: 'refused', reason: 'local-bridge-required' });
+    const binding = await guardBinding(req);
+    if (binding instanceof Error) return bindingRejected(res, binding);
     const parsed = parseGroupSpeakBody(req.body);
     if (parsed.error) return send(res, 400, { status: 'refused', reason: parsed.error });
     if (readonly()) return send(res, 422, { status: 'refused', reason: 'readonly' });
@@ -350,6 +375,8 @@ function audioRoutes(deps = {}) {
   r.post('/groups/stop', async (req, res) => {
     const resolved = await originOr401(req, res); if (!resolved) return undefined;
     if (resolved.trust !== 'local-bridge') return send(res, 403, { status: 'refused', reason: 'local-bridge-required' });
+    const binding = await guardBinding(req);
+    if (binding instanceof Error) return bindingRejected(res, binding);
     if (!onlyKeys(req.body, new Set(['utteranceId'])) || typeof req.body.utteranceId !== 'string' || !UTTERANCE_ID_RE.test(req.body.utteranceId)) {
       return send(res, 400, { status: 'refused', reason: 'invalid-utterance' });
     }

package/lib/cells/routes.js

@@ -3,6 +3,7 @@
 const express = require('express');
 const { isValidSession } = require('../files/store.js');
 const { submitTextOk } = require('../tmux/actions.js');
+const { createIdentityBindingGuard } = require('../identity/binding-guard.js');
 
 const CELL_ID_RE = /^[A-Za-z0-9._-]{1,32}$/;
 const CELL_LABEL_MAX = 64;
@@ -68,7 +69,20 @@ function validIdentity(value) {
     && isValidSession(value.tmuxSession);
 }
 
-function cellsRoutes({ fleetP, instanceId, submit, readonly = () => false, now = () => Date.now(), diagnostics = null }) {
+function cellsRoutes({ fleetP, instanceId, submit, readonly = () => false, now = () => Date.now(), diagnostics = null, identityMode = 'legacy' }) {
+  const bindingGuard = createIdentityBindingGuard({
+    fleetP, instanceId, now,
+    sharedRequired: identityMode === 'authority',
+  });
+
+  async function guardBinding(req, expected) {
+    try {
+      return await bindingGuard.verify(req, { expected, localOnly: false });
+    } catch (e) {
+      return e;
+    }
+  }
+
   const r = express.Router();
 
   async function status() {
@@ -111,7 +125,7 @@ function cellsRoutes({ fleetP, instanceId, submit, readonly = () => false, now =
         });
       } catch (_) {}
     };
-    const reject = (code, reason) => { logSend('warn', 'CELL_MESSAGE_REJECTED', reason); return res.status(code).json({ error: reason }); };
+    const reject = (code, reason, extra = null) => { logSend('warn', 'CELL_MESSAGE_REJECTED', reason); return res.status(code).json({ error: reason, ...(extra || {}) }); };
     const keys = Object.keys(body);
     if (keys.some((key) => !['id', 'from', 'to', 'message'].includes(key))
       || !MESSAGE_ID_RE.test(String(body.id || ''))
@@ -131,6 +145,20 @@ function cellsRoutes({ fleetP, instanceId, submit, readonly = () => false, now =
     if (!visited.length && body.from.instanceId !== localId) {
       return reject(403, 'mittente remoto senza route autenticata');
     }
+    // Mittente locale: la tupla dichiarata deve corrispondere a una cella della
+    // directory attiva. Il nome di sessione non è una verifica: la fa lo stato vivo.
+    if (body.from.instanceId === localId) {
+      const directory = publicCells(await status(), localId, now());
+      const sender = directory.find((cell) => cell.cell === body.from.cell
+        && cell.tmuxSession === body.from.tmuxSession && cell.active === true);
+      if (!sender) return reject(403, 'mittente locale non verificato');
+    }
+    // Binding identity shared: presentato -> verificato server-side completo,
+    // mai accettato per sola coerenza formale né degradato a percorso legacy.
+    const binding = await guardBinding(req, body.from);
+    if (binding instanceof Error) {
+      return reject(403, binding.message, { code: binding.code });
+    }
     try {
       const cells = publicCells(await status(), localId, now());
       const target = cells.find((cell) => cell.cell === body.to.cell

package/lib/cli/commands.js

@@ -1516,8 +1516,18 @@ function dispatch(argv, opts = {}) {
   if (cmd === 'mcp') {
     // Server MCP stdio (bridge cella→operatore): stdout e' il canale JSON-RPC, quindi
     // NESSUN log qui. keepAlive: resta vivo finche' il client tiene aperto stdin.
+    // Il provider produttivo esiste soltanto se la cella ha un canale identity
+    // authority persistito: senza canale il bridge resta sul percorso embedded
+    // legacy, senza mai trasformare una dichiarazione in identita verificata.
     const startMcpImpl = opts.startMcpImpl || require('../mcp/server.js').startMcp;
-    startMcpImpl();
+    const cfg = opts.config || require('../config.js').loadConfig();
+    const provider = opts.identityContextProvider !== undefined
+      ? opts.identityContextProvider
+      : require('../mcp/identity-provider.js')
+        .createMcpIdentityProvider({ config: cfg, env: process.env });
+    startMcpImpl(provider
+      ? { ...opts, config: cfg, identityContextProvider: provider }
+      : { ...opts, config: cfg });
     return { code: 0, keepAlive: true };
   }
   if (cmd === 'fleet-boot') {

package/lib/files/routes.js

@@ -7,10 +7,30 @@ const { Router } = require('express');
 const multer = require('multer');
 const store = require('./store.js');
 const { pasteArgs } = require('../tmux/actions.js');
+const { createIdentityBindingGuard, expectedFromSession } = require('../identity/binding-guard.js');
 
 // Router file-exchange. Nessuno stato: tutto deriva da cfg + filesystem.
 // notifier (opzionale, MCP bridge): emette la notify di consegna file outbox.
-function filesRoutes({ cfg, sessionExists, paste, notifier, readonly = () => false }) {
+function filesRoutes({
+  cfg, sessionExists, paste, notifier, readonly = () => false,
+  fleetP = null, instanceId = null, identityMode = 'legacy',
+}) {
+  const bindingGuard = createIdentityBindingGuard({
+    fleetP, instanceId, now: () => Date.now(), sharedRequired: identityMode === 'authority',
+  });
+
+  async function guardBinding(req, session = null) {
+    try {
+      const expected = expectedFromSession(session, instanceId);
+      return await bindingGuard.verify(req, { expected, localOnly: true });
+    } catch (e) {
+      return e;
+    }
+  }
+
+  function bindingRejected(res, error) {
+    return res.status(403).json({ error: error.message, code: error.code });
+  }
   const router = Router();
   const upload = multer({
     storage: multer.memoryStorage(),
@@ -29,6 +49,8 @@ function filesRoutes({ cfg, sessionExists, paste, notifier, readonly = () => fal
       if (!store.isValidSession(session) || !sessionExists(session)) {
         return res.status(404).json({ error: 'sessione tmux inesistente' });
       }
+      const binding = await guardBinding(req, session);
+      if (binding instanceof Error) return bindingRejected(res, binding);
       const saved = store.saveUpload(cfg.filesRoot, session, req.file.buffer, req.file.originalname);
       // paste=false (tasto allegati del composer): il client appende il path al
       // testo del composer — niente scrittura PTY. Default = incolla (FilesPanel).
@@ -78,7 +100,7 @@ function filesRoutes({ cfg, sessionExists, paste, notifier, readonly = () => fal
   // da revisione: gated READONLY — la copia e' una scrittura su disco; il gate
   // sta PRIMA di ogni altro check (nessun probe di sessione/path in READONLY).
   const bridgeReadonly = () => (cfg.readonlyDefault === true || process.env.NEXUSCREW_READONLY === '1');
-  router.post('/outbox', express.json({ limit: '8kb' }), (req, res) => {
+  router.post('/outbox', express.json({ limit: '8kb' }), async (req, res) => {
     try {
       if (bridgeReadonly()) {
         return res.status(403).json({ error: 'READONLY: consegna file bloccata' });
@@ -88,6 +110,8 @@ function filesRoutes({ cfg, sessionExists, paste, notifier, readonly = () => fal
       if (!store.isValidSession(session) || !sessionExists(session)) {
         return res.status(404).json({ error: 'sessione tmux inesistente' });
       }
+      const binding = await guardBinding(req, session);
+      if (binding instanceof Error) return bindingRejected(res, binding);
       if (typeof b.path !== 'string' || !path.isAbsolute(b.path)) {
         return res.status(400).json({ error: 'path deve essere assoluto' });
       }
@@ -139,10 +163,13 @@ function filesRoutes({ cfg, sessionExists, paste, notifier, readonly = () => fal
     res.download(full);
   });
 
-  router.delete('/', (req, res) => {
+  router.delete('/', async (req, res) => {
     if (readonly()) return res.status(403).json({ error: 'READONLY: eliminazione file bloccata' });
+    const session = String(req.query.session || '');
+    const binding = await guardBinding(req, session);
+    if (binding instanceof Error) return bindingRejected(res, binding);
     const ok = store.removeFile(
-      cfg.filesRoot, String(req.query.session || ''), String(req.query.box || ''), String(req.query.name || ''),
+      cfg.filesRoot, session, String(req.query.box || ''), String(req.query.name || ''),
     );
     if (!ok) return res.status(404).json({ error: 'file non trovato' });
     res.json({ deleted: true });

package/lib/fleet/builtin.js

@@ -44,6 +44,7 @@ const { validEnvKey } = require('./env-key.js');
 const { setCredential, removeCredential } = require('./credentials.js');
 const { createLaunchBroker } = require('./launch-broker.js');
 const { createLeaseManager } = require('./cell-lease-server.js');
+const { createIdentityAuthority } = require('./identity-authority.js');
 const { MINIMAL_ENV_KEYS, termuxRuntimePaths } = require('../runtime/env.js');
 const { requireSharedTmuxProtection } = require('../tmux/shared-server.js');
 
@@ -84,6 +85,17 @@ function draftFrom(defs) {
   };
 }
 
+const RESERVED_ENV_KEYS = new Set(['MCP_DEVICE']);
+
+function rejectReservedEnvKey(source, context) {
+  if (!source || typeof source !== 'object' || Array.isArray(source)) return;
+  for (const key of Object.keys(source)) {
+    if (RESERVED_ENV_KEYS.has(key)) {
+      throw httpError(400, `${context}: ${key} è riservato e non può essere impostato dall'engine`);
+    }
+  }
+}
+
 function warnEngineCap(log, engineId, count) {
   const emit = typeof log === 'function' ? log : console.warn;
   emit(`WARN fleet backfill: engine ${engineId} non aggiunto: ${count} engine dichiarati, cap ${CAPS.MAX_ENGINES} raggiunto; riduci gli engine prima di riprovare`);
@@ -684,12 +696,31 @@ async function createBuiltinFleet(cfg = {}) {
     });
   await ensureProtection();
 
-  // --- Tutti i gate availability passati. Ora (e solo ora) creiamo leaseManager e
-  // launchBroker e riapriamo gli endpoint lease delle celle note (R3.3.1 recovery,
-  // rilievo 3). Non fatale: un fallimento di singolo endpoint non blocca il boot.
-  const leaseManager = cellLeaseEnabled ? createLeaseManager({ ...cfg, home }) : null;
+  // --- Tutti i gate availability passati. Ora (e solo ora) creiamo identity,
+  // leaseManager e launchBroker. L'authority resta server-side: nessuna
+  // credenziale o chiave HMAC attraversa il payload consegnato alla cella.
+  const identityMode = cfg.fleetIdentityMode || cfg.fleet?.identity?.mode || 'legacy';
+  const identityOwnerInstanceId = typeof cfg.identityOwnerInstanceId === 'function'
+    ? cfg.identityOwnerInstanceId()
+    : (cfg.identityOwnerInstanceId || null);
+  const identityAuthority = cfg.identityAuthority || (
+    cfg.identityDaemonCredential && cfg.identityLauncherCredential
+      ? createIdentityAuthority({
+        dir: cfg.identityAuthorityDir || path.join(home, '.nexuscrew', 'identity-authority'),
+        daemonCredential: cfg.identityDaemonCredential,
+        launcherCredential: cfg.identityLauncherCredential,
+        subjectResolver: cfg.identitySubjectResolver,
+        log: cfg.log,
+      })
+      : null
+  );
+  const leaseManager = cellLeaseEnabled ? createLeaseManager({ ...cfg, home, identityAuthority }) : null;
   const launchBroker = cfg.launchBroker || createLaunchBroker({
     ...cfg, home,
+    identityMode,
+    identityAuthority,
+    identityDaemonCredential: cfg.identityDaemonCredential,
+    identityLauncherCredential: cfg.identityLauncherCredential,
     // R3.1.1: la connessione broker one-shot resta APERTA dopo il payload e diviene
     // il canale lease del supervisore.
     ...(leaseManager ? {
@@ -724,6 +755,7 @@ async function createBuiltinFleet(cfg = {}) {
   // qui sotto riusa. status/up/down/restart sono INVARIATI.
   const rt = createBuiltinRuntime({
     cfg, home, defsPath, tmuxBin, readonly, launchBroker, leaseManager, boot, ensureProtection,
+    identityAuthority, identityMode, identityOwnerInstanceId,
   });
   const {
     status, cellStatus, up, down, restart, isCellSession,
@@ -796,6 +828,7 @@ async function createBuiltinFleet(cfg = {}) {
     if (readonly()) throw httpError(403, 'READONLY: define-engine bloccato');
     if (!def || typeof def !== 'object' || Array.isArray(def)) throw httpError(400, 'definizione engine mancante');
     if (def.id != null && findEngine(reloadDefs(), def.id)) throw httpError(400, `engine esiste già: ${def.id}`);
+    rejectReservedEnvKey(def.env, 'engine env');
     await mutate(reloadDefs(), (d) => { d.engines.push(def); });
     return { ok: true, id: def.id };
   }
@@ -851,6 +884,9 @@ async function createBuiltinFleet(cfg = {}) {
     if (patch && (Object.prototype.hasOwnProperty.call(patch, 'id') || Object.prototype.hasOwnProperty.call(patch, 'env'))) {
       throw httpError(400, 'id ed env non sono modificabili tramite patch generica');
     }
+    if (envChanges !== undefined) {
+      rejectReservedEnvKey(envChanges.set, 'envChanges.set');
+    }
     await mutate(defs, (d) => {
       const target = findEngine(d, id);
       for (const [key, value] of Object.entries(patch || {})) {
@@ -1066,6 +1102,9 @@ async function createBuiltinFleet(cfg = {}) {
         || new Set(engine.envKeys).size !== engine.envKeys.length)) {
         throw httpError(400, `envKeys non valido per engine: ${engine.id}`);
       }
+      if (!engine.managed && Array.isArray(engine.envKeys) && engine.envKeys.some((key) => RESERVED_ENV_KEYS.has(key))) {
+        throw httpError(400, `envKeys riservato per engine: ${engine.id}: ${engine.envKeys.filter((key) => RESERVED_ENV_KEYS.has(key)).join(', ')}`);
+      }
       if (!engine.managed && Array.isArray(engine.args) && engine.args.some((arg) => {
         const text = String(arg || '');
         return /(?:bearer\s+|authorization\s*[:=]|(?:api[_-]?key|secret|token)\s*[:=])/i.test(text)
@@ -1435,6 +1474,7 @@ async function createBuiltinFleet(cfg = {}) {
     // MCP delle celle consuma per register/refresh/recovery (B5). Assente se il
     // lease e' disattivato: le route rispondono 501, non 500.
     ...(leaseManager ? { lease: leaseManager } : {}),
+    ...(identityAuthority ? { identityAuthority } : {}),
   };
 }
 

package/lib/fleet/cell-exec.js

@@ -8,6 +8,9 @@ const net = require('node:net');
 const path = require('node:path');
 const { spawn } = require('node:child_process');
 const { MAX_PAYLOAD } = require('./launch-broker.js');
+const {
+  validDaemonChallenge, identityErrorCode, IDENTITY_FRAME_LIMIT, IDENTITY_TIMEOUT_MS,
+} = require('./lease-client.js');
 
 const DEFAULT_SUPERVISE = Object.freeze({
   enabled: true,
@@ -80,6 +83,20 @@ function validRestartPrompt(value) {
     && (value.readyWaitMs === undefined || validInteger(value.readyWaitMs, 0, 120000));
 }
 
+function validIdentity(value) {
+  if (value === undefined) return true;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const keys = new Set(['audience', 'daemonBootId', 'connectionId', 'challenge', 'grant', 'proof']);
+  if (Object.keys(value).some((key) => !keys.has(key))) return false;
+  if (typeof value.challenge !== 'string' || !/^[a-f0-9]{64}$/.test(value.challenge)) return false;
+  if (!value.grant || typeof value.grant !== 'object' || Array.isArray(value.grant)) return false;
+  if (!value.proof || typeof value.proof !== 'object' || Array.isArray(value.proof)) return false;
+  return value.grant.kind === 'launch-grant' && value.proof.kind === 'identity-proof'
+    && typeof value.audience === 'string' && value.audience.length > 0
+    && typeof value.daemonBootId === 'string' && value.daemonBootId.length > 0
+    && typeof value.connectionId === 'string' && value.connectionId.length > 0;
+}
+
 function validLease(value) {
   if (value === undefined) return true;
   if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
@@ -93,14 +110,15 @@ 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'].includes(key))) return false;
+  if (Object.keys(payload).some((key) => !['command', 'args', 'env', 'supervise', 'restartPrompt', 'lease', 'identity'].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;
   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)
     && validRestartPrompt(payload.restartPrompt)
-    && validLease(payload.lease);
+    && validLease(payload.lease)
+    && validIdentity(payload.identity);
 }
 
 function receivePayload(socketPath, nonce, timeoutMs = 5000, opts = {}) {
@@ -150,6 +168,149 @@ function normalizeSupervise(value = {}) {
   return { ...DEFAULT_SUPERVISE, ...(value || {}) };
 }
 
+function identityErrorResponse(id, code, message) {
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: { code: -32000, message, data: { code } },
+  };
+}
+
+function validIdentityRequest(msg) {
+  if (!msg || typeof msg !== 'object' || Array.isArray(msg)) return false;
+  const keys = Object.keys(msg);
+  if (keys.length !== 4 || !['jsonrpc', 'id', 'method', 'params'].every((key) => Object.hasOwn(msg, key))) return false;
+  if (msg.jsonrpc !== '2.0' || msg.method !== 'nexuscrew/identity/challengeProof') return false;
+  if (!Number.isSafeInteger(msg.id) || msg.id < 0) return false;
+  return true;
+}
+
+function createIdentityChannel({
+  request,
+  response,
+  generation,
+  relay,
+  cancel = () => {},
+  setTimeout: setTimer = (...args) => setTimeout(...args),
+  clearTimeout: clearTimer = (timer) => { if (timer) clearTimeout(timer); },
+} = {}) {
+  if (!request || typeof request.on !== 'function'
+    || !response || typeof response.write !== 'function') return null;
+  let closed = false;
+  let nextRequestId = 1;
+  let pending = null;
+  let buffer = '';
+
+  const writeResponse = (obj, force = false) => {
+    if ((!force && closed) || !response.writable) return false;
+    try { response.write(`${JSON.stringify(obj)}\n`); return true; } catch (_) { return false; }
+  };
+
+  const sendError = (id, code, message, force = false) => (
+    writeResponse(identityErrorResponse(id, code, message), force)
+  );
+
+  const finishPending = () => {
+    if (!pending) return 0;
+    const { rpcId } = pending;
+    clearTimer(pending.timer);
+    try { cancel(pending.requestId); } catch (_) {}
+    pending = null;
+    return rpcId;
+  };
+
+  const close = (code = null, message = '', rpcId = 0, sendEofError = true) => {
+    if (closed) return;
+    closed = true;
+    const finishedId = finishPending() || 0;
+    if (code && sendEofError) sendError(rpcId || finishedId, code, message, true);
+    try { request.removeAllListeners('data'); request.destroy(); } catch (_) {}
+    try { response.end(); } catch (_) {}
+  };
+
+  const settle = (outcome) => {
+    const current = pending;
+    if (closed || !current || current.done) return;
+    current.done = true;
+    clearTimer(current.timer);
+    pending = null;
+    try { cancel(current.requestId); } catch (_) {}
+    if (outcome && outcome.ok === true && outcome.proof && typeof outcome.proof === 'object') {
+      writeResponse({ jsonrpc: '2.0', id: current.rpcId, result: { proof: outcome.proof } });
+      return;
+    }
+    const reason = outcome && typeof outcome.reason === 'string' ? outcome.reason : 'identity-unverified';
+    const code = identityErrorCode(reason);
+    sendError(current.rpcId, code, reason);
+    // C7-bis: il canale e' terminato su timeout OLTRE che su revoke — dopo la
+    // risposta di errore fd4 va in EOF (la TUI vede il canale chiuso).
+    if (code === 'REVOKED' || reason === 'timeout') close(code, reason, current.rpcId, false);
+  };
+
+  const handleLine = (line) => {
+    if (closed) return;
+    if (pending) {
+      let id = 0;
+      try {
+        const msg = JSON.parse(line);
+        id = validIdentityRequest(msg) ? msg.id : 0;
+      } catch (_) { id = 0; }
+      sendError(id, 'IDENTITY_UNVERIFIED', 'busy');
+      return;
+    }
+    let msg = null;
+    try { msg = JSON.parse(line); } catch (_) {
+      sendError(0, 'IDENTITY_UNVERIFIED', 'invalid request');
+      return;
+    }
+    if (!validIdentityRequest(msg)
+      || !msg.params || typeof msg.params !== 'object' || Array.isArray(msg.params)
+      || Object.keys(msg.params).length !== 1 || !Object.hasOwn(msg.params, 'challenge')
+      || !validDaemonChallenge(msg.params.challenge)) {
+      sendError(validIdentityRequest(msg) ? msg.id : 0, 'IDENTITY_UNVERIFIED', 'invalid request');
+      return;
+    }
+    const requestId = `g${generation}-r${nextRequestId}`;
+    nextRequestId += 1;
+    pending = {
+      requestId, rpcId: msg.id, generation, done: false, timer: null,
+    };
+    pending.timer = setTimer(() => settle({ ok: false, reason: 'timeout' }), IDENTITY_TIMEOUT_MS);
+    if (pending.timer && typeof pending.timer.unref === 'function') pending.timer.unref();
+    Promise.resolve(relay(requestId, msg.params.challenge)).then(settle, (error) => {
+      settle({ ok: false, reason: error && error.code ? error.code : 'authority-unavailable' });
+    });
+  };
+
+  request.on('data', (chunk) => {
+    if (closed) return;
+    buffer += Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
+    if (Buffer.byteLength(buffer, 'utf8') > IDENTITY_FRAME_LIMIT) {
+      close();
+      return;
+    }
+    let nl;
+    while ((nl = buffer.indexOf('\n')) !== -1) {
+      const line = buffer.slice(0, nl);
+      buffer = buffer.slice(nl + 1);
+      if (line.trim()) handleLine(line);
+      if (closed || Buffer.byteLength(buffer, 'utf8') > IDENTITY_FRAME_LIMIT) {
+        if (buffer) close();
+        break;
+      }
+    }
+  });
+  request.once('end', () => close());
+  request.once('error', () => close());
+  response.once('error', () => close());
+
+  return {
+    close,
+    isClosed: () => closed,
+    pendingCount: () => (pending ? 1 : 0),
+  };
+}
+
 function waitChild(child) {
   return new Promise((resolve) => {
     let settled = false;
@@ -291,7 +452,7 @@ 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 };
+  const childEnv = { ...payload.env, 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;
@@ -305,7 +466,7 @@ async function main(argv = process.argv.slice(2), seams = {}) {
   let leaseCtl = null;
   // da revisione interna: current/stopping vivono QUI (prima del lease-client) perche'
   // la callback onLost qui sotto li riferisce dalla closure.
-  let current = null; let stopping = false;
+  let current = null; let stopping = false; let identityCtl = null;
   if (payload.lease && leaseSocket && !leaseSocket.destroyed) {
     const { startLeaseClient } = require('./lease-client.js');
     leaseCtl = startLeaseClient(leaseSocket, {
@@ -315,6 +476,7 @@ async function main(argv = process.argv.slice(2), seams = {}) {
       // generation += 1). Passiamo un getter cosicche' il reconnect presenti
       // sempre la generation corrente, non 0 fisso (riconcilia :301 con :381).
       generation: () => generation,
+      onIdentityDown: () => closeIdentityChannel('REVOKED', 'lease unavailable'),
       // da revisione interna: lease persa per tutta la grace senza un
       // reconnect riuscito. Prima il lease-client desisteva in silenzio dopo
       // 60s e il child restava un orfano senza lease per tutta la sua vita.
@@ -333,6 +495,7 @@ async function main(argv = process.argv.slice(2), seams = {}) {
       // no-op — mai un kill fantasma su un pid riusato.
       onLost: () => {
         writeError('nexuscrew cell supervisor stopped: lease lost (reconnect grace expired)\n');
+        closeIdentityChannel('REVOKED', 'lease lost');
         stopping = true;
         const target = current;
         try { if (target) target.kill('SIGTERM'); } catch (_) {}
@@ -349,6 +512,13 @@ async function main(argv = process.argv.slice(2), seams = {}) {
     }, seams);
   }
 
+  const closeIdentityChannel = (code = null, message = '') => {
+    if (!identityCtl) return;
+    const ctl = identityCtl;
+    identityCtl = null;
+    ctl.close(code, message);
+  };
+
   const handlers = new Map();
   for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
     const handler = () => {
@@ -370,9 +540,82 @@ async function main(argv = process.argv.slice(2), seams = {}) {
       const startedAt = now();
       const childState = { exited: false };
       const promptCtl = startGenerationPrompt(payload.restartPrompt, generation, childState, seams);
-      current = spawnImpl(payload.command, payload.args, { env: childEnv, stdio: 'inherit' });
-      const result = await waitChild(current);
+      current = spawnImpl(payload.command, payload.args, {
+        env: childEnv,
+        stdio: ['inherit', 'inherit', 'inherit', 'pipe', 'pipe'],
+      });
+      // R1a (fix5): exit/error del figlio contano SUBITO, prima di qualunque
+      // await — se il figlio esce durante l'handshake di generazione, l'evento
+      // non deve andare perso (prima i listener arrivavano solo con waitChild,
+      // e il supervisore restava appeso).
+      let childSettled = false;
+      const childExit = new Promise((resolve) => {
+        current.once('exit', (code, signal) => {
+          childSettled = true;
+          resolve({ code: code == null ? 1 : code, signal, error: null });
+        });
+        current.once('error', (error) => {
+          childSettled = true;
+          resolve({ code: 1, signal: null, error });
+        });
+      });
+      // R1: transizione di generazione comunicata al lease PRIMA di aprire il
+      // canale identita' della generazione nuova. L'exit del figlio ha la
+      // precedenza sull'annuncio; FAIL-CLOSED (R1b): solo un annuncio
+      // RISOLTO con ok === true E generazione corrispondente apre il canale —
+      // ok:false (lease-down, identity-unverified), rifiuto, timeout ed exit
+      // restano tutti negativi, con sola diagnostica: il figlio parte
+      // comunque, senza identita'.
+      if (leaseCtl && generation > 0) {
+        const raced = await Promise.race([
+          // fix 6 (R1b-bis): il valore RISOLTO va ispezionato.
+          // Prima: .then(() => 'ok', ...) scartava il valore e trattava un
+          // annuncio risolto {ok:false} come successo, aprendo il canale.
+          leaseCtl.announceGeneration(generation).then(
+            (announced) => (announced && announced.ok === true && announced.generation === generation
+              ? 'ok'
+              : `announce-refused:${(announced && announced.reason) || 'generation-mismatch'}`),
+            () => 'announce-failed',
+          ),
+          childExit.then(() => 'exited'),
+        ]);
+        if (raced === 'ok' && !childSettled) {
+          identityCtl = createIdentityChannel({
+            request: current && current.stdio && current.stdio[3],
+            response: current && current.stdio && current.stdio[4],
+            generation,
+            relay: leaseCtl
+              ? (requestId, challenge) => leaseCtl.challengeProof({ requestId, generation, challenge })
+              : async () => ({ ok: false, reason: 'lease-down' }),
+            cancel: leaseCtl
+              ? (requestId) => leaseCtl.cancelIdentityChallenge(requestId)
+              : () => {},
+            setTimeout: seams.setTimeout,
+            clearTimeout: seams.clearTimeout,
+          });
+        } else if (raced === 'exited') {
+          writeError(`nexuscrew cell: figlio uscito durante l'handshake di generazione (gen ${generation})\n`);
+        } else {
+          writeError(`nexuscrew cell: generazione ${generation} senza identita' (${raced})\n`);
+        }
+      } else {
+        identityCtl = createIdentityChannel({
+          request: current && current.stdio && current.stdio[3],
+          response: current && current.stdio && current.stdio[4],
+          generation,
+          relay: leaseCtl
+            ? (requestId, challenge) => leaseCtl.challengeProof({ requestId, generation, challenge })
+            : async () => ({ ok: false, reason: 'lease-down' }),
+          cancel: leaseCtl
+            ? (requestId) => leaseCtl.cancelIdentityChallenge(requestId)
+            : () => {},
+          setTimeout: seams.setTimeout,
+          clearTimeout: seams.clearTimeout,
+        });
+      }
+      const result = await childExit;
       childState.exited = true;
+      closeIdentityChannel();
       current = null;
       // R2/R3: la generazione e' finita. Cancella la delivery in volo e ATTESA
       // del suo termine PRIMA di qualunque nuovo spawn. R9: se l'esito e' un
@@ -432,5 +675,6 @@ if (require.main === module) {
 
 module.exports = {
   DEFAULT_SUPERVISE, LEASE_LOST_KILL_ESCALATION_MS, parseArgs, validSupervise, validRestartPrompt, validPayload, validLease,
-  receivePayload, sanitizeSpawnError, normalizeSupervise, waitChild, startGenerationPrompt, main,
+  receivePayload, sanitizeSpawnError, normalizeSupervise, waitChild, startGenerationPrompt,
+  createIdentityChannel, validIdentityRequest, main,
 };