@mmmbuto/nexuscrew 0.8.58 → 0.9.0

package/lib/fleet/builtin.js

@@ -41,6 +41,7 @@ const { probeModel } = require('./model-probe.js');
 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 { MINIMAL_ENV_KEYS, termuxRuntimePaths } = require('../runtime/env.js');
 const { requireSharedTmuxProtection } = require('../tmux/shared-server.js');
 
@@ -117,6 +118,56 @@ function backfillAgyEngine(defsPath, defs, cfg = {}) {
   try { return atomicWrite(defsPath, draft); } catch (_) { return defs; }
 }
 
+// Engine desktop.local: NON managed (nessun client/provider AI, solo command+args
+// come un engine custom). Entra nel container desktop via `docker exec` e
+// precompila panelUrl al pannello web KasmVNC del container. `-u abc` non e' un
+// dettaglio: senza, si entra come root e Chromium nel container rifiuta di
+// partire ("Running as root without --no-sandbox is not supported") — un
+// errore che nomina il soggetto sbagliato. panelUrl e' comodita' sopra il
+// meccanismo condiviso (validPanelUrl in definitions.js): l'engine non ha una
+// sua strada per imporre l'URL, dichiara solo il valore, e resta sovrascrivibile
+// per-cella come qualunque altro panelUrl (vedi parseCell).
+function defaultDesktopEngine() {
+  return {
+    id: 'desktop.local',
+    label: 'Desktop',
+    command: 'docker',
+    args: ['exec', '-it', '-u', 'abc', 'ai-desktop', 'bash'],
+    promptMode: 'send-keys',
+    panelUrl: 'https://127.0.0.1:6901',
+  };
+}
+
+// Backfill dell'engine desktop.local: come backfillKimiEngine, idempotente
+// (gia' presente -> skip) e non distruttivo su collisione id (un 'desktop.local'
+// gia' scelto dall'utente per altro non viene sovrascritto). Nessun platform
+// gate: il container e' un servizio esterno raggiunto via docker, non un
+// binario per-platform come agy/grok.
+//
+// DELIBERATAMENTE NON agganciata al bootstrap (a differenza di shell/agy/kimi/
+// grok/vl, vedi piu' sotto): NON e' una dimenticanza, e' una decisione presa
+// (decisione di progetto, 2026-08-14). Un backfill universale presuppone un container con un
+// nome preciso — `ai-desktop` — che quasi nessuna installazione avra'. E
+// desktop.local non e' managed: non ha un describeManaged che lo segnali come
+// "non configurato" quando il container manca, quindi resterebbe nella lista
+// engine silenziosamente rotto — esattamente la classe di difetto (un gate
+// verde/una feature presente che non significa cio' che sembra) inseguita piu'
+// volte in questa stessa giornata di lavoro.
+// Scartata anche l'opzione apparentemente furba di un gate su un container-probe
+// all'avvio: il probe e' una decisione presa UNA volta, mentre il container puo'
+// nascere e morire dopo — un engine che appare/scompare a seconda di quando hai
+// riavviato e' peggio di uno assente, e richiederebbe interrogare Docker a ogni
+// bootstrap: una dipendenza nuova sul percorso di avvio per una comodita'.
+// Resta MANUALE: chi ha il container se lo aggiunge nella propria procedura
+// — e' il posto dove qualcuno sa gia' che il container esiste.
+function backfillDesktopEngine(defsPath, defs) {
+  if (!defs || defs.engines.some((engine) => engine.id === 'desktop.local')) return defs;
+  if (defs.engines.length >= CAPS.MAX_ENGINES) return defs;
+  const draft = draftFrom(defs);
+  draft.engines.push(defaultDesktopEngine());
+  try { return atomicWrite(defsPath, draft); } catch (_) { return defs; }
+}
+
 // Backfill dell'engine Kimi Code CLI nativo: installazioni esistenti ricevono
 // kimi.native in modo idempotente e non distruttivo. Nessun platform gate: il
 // CLI gira ovunque giri Node e su Termux il resolver applica gia' il workaround
@@ -214,24 +265,32 @@ function resolveCellCwd(cell, home) {
     relNorm = normalizeCwdRel(cell.cwdRel);
     if (relNorm === null) return { ok: false, fail: { reason: 'invalid-rel', cwdRel: cell.cwdRel } };
   }
-  const realHome = resolveCwd(home, home);
-  if (!realHome) return { ok: false, fail: { reason: 'home-unavailable' } };
-  const realCwd = hasCwd ? resolveCwd(cell.cwd, home) : null;
-  const realFromRel = hasRel ? resolveCwd(path.join(realHome, relNorm), home) : null;
+  // out.unverifiable distingue "non esiste / fuori home / non directory"
+  // (legittimo rifiuto) da "esiste ma non ho potuto verificarlo" (EACCES/ELOOP su
+  // realpath): stesso verdetto (ok:false, fail-closed di sicurezza), messaggio
+  // diverso. Vedi resolveCwd e unportableCwdError. Il discriminante e' CHI ha
+  // fallito, non che ci sia stata un'eccezione.
+  const homeOut = {};
+  const realHome = resolveCwd(home, home, homeOut);
+  if (!realHome) return { ok: false, fail: { reason: 'home-unavailable', ...(homeOut.unverifiable ? { unverifiable: homeOut.unverifiable } : {}) } };
+  const cwdOut = {};
+  const realCwd = hasCwd ? resolveCwd(cell.cwd, home, cwdOut) : null;
+  const relOut = {};
+  const realFromRel = hasRel ? resolveCwd(path.join(realHome, relNorm), home, relOut) : null;
   if (hasCwd && hasRel) {
-    if (!realCwd) return { ok: false, fail: { reason: 'invalid-cwd', cwd: cell.cwd } };
-    if (!realFromRel) return { ok: false, fail: { reason: 'invalid-rel', cwdRel: cell.cwdRel } };
+    if (!realCwd) return { ok: false, fail: { reason: 'invalid-cwd', cwd: cell.cwd, ...(cwdOut.unverifiable ? { unverifiable: cwdOut.unverifiable } : {}) } };
+    if (!realFromRel) return { ok: false, fail: { reason: 'invalid-rel', cwdRel: cell.cwdRel, ...(relOut.unverifiable ? { unverifiable: relOut.unverifiable } : {}) } };
     if (realCwd !== realFromRel) return { ok: false, fail: { reason: 'mismatch', cwd: cell.cwd, cwdRel: cell.cwdRel } };
     return { ok: true, cwd: realCwd, cwdRel: relNorm };
   }
   if (hasCwd) {
-    if (!realCwd) return { ok: false, fail: { reason: 'invalid-cwd', cwd: cell.cwd } };
+    if (!realCwd) return { ok: false, fail: { reason: 'invalid-cwd', cwd: cell.cwd, ...(cwdOut.unverifiable ? { unverifiable: cwdOut.unverifiable } : {}) } };
     const rel = deriveCwdRel(realCwd, realHome);
     if (rel === null) return { ok: false, fail: { reason: 'not-under-home', cwd: cell.cwd } };
     return { ok: true, cwd: realCwd, cwdRel: rel };
   }
   // solo cwdRel
-  if (!realFromRel) return { ok: false, fail: { reason: 'invalid-rel', cwdRel: cell.cwdRel } };
+  if (!realFromRel) return { ok: false, fail: { reason: 'invalid-rel', cwdRel: cell.cwdRel, ...(relOut.unverifiable ? { unverifiable: relOut.unverifiable } : {}) } };
   return { ok: true, cwd: realFromRel, cwdRel: relNorm };
 }
 
@@ -258,12 +317,28 @@ function unportableCwdError(failures, home) {
     const entry = { id };
     const cwd = typeof fail.cwd === 'string' ? fail.cwd : undefined;
     if (cwd !== undefined) entry.cwd = cwd;
+    // "non ho potuto verificare" (EACCES/ELOOP...) vs "non esiste/fuori home":
+    // stesso verdetto (rifiuto, fail-closed di sicurezza), ma la causa e' diversa
+    // e l'operatore deve saperlo: potrebbe bastare un permesso, non un path
+    // sbagliato. Il discriminante e' CHI ha fallito, non che ci sia stata
+    // un'eccezione.
+    if (fail.unverifiable) entry.unverifiable = fail.unverifiable;
     const suggestion = suggestCwdRel(cwd, home);
     if (suggestion) entry.suggestion = suggestion;
     return entry;
   });
+  const unverifiable = failures.filter((f) => f.fail.unverifiable);
+  const code = 'unportable-cwd';
+  if (unverifiable.length) {
+    const codes = [...new Set(unverifiable.map((f) => f.fail.unverifiable))].join(', ');
+    return httpError(400, `cwd non verificabile (esiste ma illeggibile: ${codes}), per: ${unverifiable.map((f) => f.id).join(', ')}: il percorso potrebbe esserci ma non si e' potuto verificare (permessi/symlink)`, {
+      code,
+      cells,
+      hint: 'non e\' necessariamente un path sbagliato: il percorso potrebbe esistere sotto la home ma i permessi della directory non hanno permesso di verificarlo',
+    });
+  }
   return httpError(400, `cwd non portabile (deve esistere sotto la home) per: ${failures.map((f) => f.id).join(', ')}`, {
-    code: 'unportable-cwd',
+    code,
     cells,
     hint: 'il percorso appartiene a un altro dispositivo o non esiste sotto la home di questo device: scegli una cartella sotto la home',
   });
@@ -298,6 +373,9 @@ async function createBuiltinFleet(cfg = {}) {
   const off = {
     available: false, provider: 'builtin',
     isCellSession: () => false, capabilities: () => [],
+    // B4: close() sempre sicura su qualunque Fleet restituita, anche unavailable:
+    // il caller non deve distinguere `off` dalla Fleet reale.
+    close: async () => {},
   };
   const blocked = (reason, code) => ({ ...off, reason, ...(code ? { migrationCode: code } : {}) });
   if (cfg.builtinEnabled === false) return off;
@@ -306,16 +384,38 @@ async function createBuiltinFleet(cfg = {}) {
   const defsPath = cfg.fleetDefsPath || path.join(home, '.nexuscrew', 'fleet.json');
   const tmuxBin = cfg.tmuxBin || process.env.TMUX_BIN || 'tmux';
   const readonly = () => (cfg.readonlyDefault === true || process.env.NEXUSCREW_READONLY === '1');
-  const launchBroker = cfg.launchBroker || createLaunchBroker({ ...cfg, home });
+  // Lease opt-in: attivo solo quando cfg.cellLeaseEnabled === true. server.js lo
+  // passa true in start(); i test che chiamano createServer() direttamente non
+  // passano il flag, quindi la suite esistente non vede endpoint lease aperti da up().
+  const cellLeaseEnabled = cfg.cellLeaseEnabled === true;
+
+  // --- P1-2 (audit 3405df0): TUTTI i gate availability AVVENGONO PRIMA di creare
+  // leaseManager/launchBroker e di leaseManager.boot(). leaseManager non esiste finche'
+  // la Fleet non e' confermata disponibile, quindi NESSUN endpoint lease resta vivo su
+  // un early return (off/blocked) finche' ogni gate resta sopra questa boundary.
+  // P2 (audit 2a05db2): questo e' un fatto contingente del ref corrente, NON una
+  // garanzia anti-refactor. Un gate aggiunto DOPO la creazione del manager passerebbe
+  // inosservato senza un controllo statico/mutation-sensitive: il commento non impedisce
+  // un `return off` futuro oltre la boundary. La promessa vera e' limitata: oggi nessun
+  // early return segue la creazione del manager, e la creazione avviene dopo tutti i
+  // gate noti. Manternerla richiede che ogni nuovo gate resti qui sopra.
+
+  // Bootstrap: fleet.json valido? garbage -> unavailable (fail-closed, design §7).
+  // ENOENT (missing) o parse invalido -> off (unavailable legittimo, fail-closed);
+  // EACCES/ELOOP sul lstat (file presente ma non verificabile) -> off CON reason,
+  // perche' "non ho potuto guardare" e' un problema diverso da "non c'e'" o "e'
+  // garbage". Verdetto (available:false) invariato; il discriminante e' CHI ha
+  // fallito, non che ci sia stata un'eccezione.
+  const bootStat = {};
+  let boot = loadDefinitions(defsPath, bootStat);
+  if (!boot) return bootStat.lstatBlocked
+    ? { ...off, reason: `fleet.json non verificabile (${bootStat.lstatBlocked}): fail-closed, non "assente" né "invalido"` }
+    : off;
 
-  // Bootstrap: fleet.json valido? garbage -> unavailable (fail-closed, design §7)
-  let boot = loadDefinitions(defsPath);
-  if (!boot) return off;
   if (!readonly()) {
-    // La migrazione precede QUALUNQUE backfill/scrittura: loadDefinitions
-    // normalizza i nomi legacy soltanto in memoria. Se il rename e' ambiguo o
-    // fallisce, fleet.json resta byte-invariato e la Fleet non puo creare una
-    // seconda sessione safe accanto a quella legacy.
+    // La migrazione precede QUALUNQUE backfill/scrittura: loadDefinitions normalizza
+    // i nomi legacy solo in memoria. Se il rename e' ambiguo o fallisce, fleet.json
+    // resta byte-invariato e la Fleet non puo creare una seconda sessione safe.
     let migration;
     try {
       migration = await migrateLegacyTmuxSessions(tmuxBin, boot, { readonly: false });
@@ -351,12 +451,46 @@ 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;
+  const launchBroker = cfg.launchBroker || createLaunchBroker({
+    ...cfg, home,
+    // R3.1.1: la connessione broker one-shot resta APERTA dopo il payload e diviene
+    // il canale lease del supervisore.
+    ...(leaseManager ? {
+      onLease: (socket, lease) => {
+        // P1-3 (reaudit dd38c83): attachInitial restituisce false se la
+        // persistenza del bind fallisce. F-B (audit 2a @ 142e272): ora il
+        // broker chiama onLease PRIMA di scrivere il payload. Il ritorno
+        // ESPLICITO false (o la socket distrutta qui) comunica al broker di NON
+        // consegnare il payload: il supervisore riceve la chiusura prima del
+        // frame e non spawna MAI un child con una lease che il server non ha
+        // committato; e non resta un lease-client connesso a un manager vuoto
+        // (state=none) — l'orfano di prima nasceva cosi'.
+        const ok = lease && lease.cellId
+          ? leaseManager.attachInitial(lease.cellId, socket, { generation: 0 })
+          : false;
+        if (!ok) {
+          try { socket.destroy(); } catch (_) {}
+        }
+        return ok;
+      },
+    } : {}),
+  });
+  if (leaseManager) {
+    try { await leaseManager.boot(); } catch {
+      // logged dal manager; un fallimento di singolo endpoint non blocca il boot.
+    }
+  }
+
   // Runtime estratto (lib/fleet/runtime.js): possiede cache + definizioni e
   // espone status/up/down/restart/isCellSession + gli accessor allo store
   // (reloadDefs/findCell/findEngine/refreshSessions/commitDefs) che il CRUD
   // qui sotto riusa. status/up/down/restart sono INVARIATI.
   const rt = createBuiltinRuntime({
-    cfg, home, defsPath, tmuxBin, readonly, launchBroker, boot, ensureProtection,
+    cfg, home, defsPath, tmuxBin, readonly, launchBroker, leaseManager, boot, ensureProtection,
   });
   const {
     status, cellStatus, up, down, restart, isCellSession,
@@ -1039,7 +1173,7 @@ async function createBuiltinFleet(cfg = {}) {
     return { engine: profile.id, model: wanted, ...out };
   }
 
-  async function close() { await launchBroker.close(); }
+  async function close() { await launchBroker.close(); if (leaseManager) leaseManager.close(); }
 
   return {
     available: true,
@@ -1050,6 +1184,10 @@ async function createBuiltinFleet(cfg = {}) {
     schema, definitions, capabilities,
     credentialStatus, setLocalCredential, removeLocalCredential, testModel,
     defineModel, removeModel, close,
+    // Fetta 2b (D3): il lease Live esposto alle route /api/lease, che il bridge
+    // MCP delle celle consuma per register/refresh/recovery (B5). Assente se il
+    // lease e' disattivato: le route rispondono 501, non 500.
+    ...(leaseManager ? { lease: leaseManager } : {}),
   };
 }
 
@@ -1060,6 +1198,10 @@ module.exports = {
   backfillKimiEngine,
   backfillGrokEngine,
   backfillVlEngine,
+  // Esportate ma NON chiamate qui sopra (§bootstrap, righe ~354-358): scelta
+  // deliberata, non una dimenticanza — vedi il commento su backfillDesktopEngine.
+  backfillDesktopEngine,
+  defaultDesktopEngine,
   resolveCellCwd,
   composeLaunchArgv,
   composeClientInvocation,

package/lib/fleet/catalogs/opencode-go.json

@@ -4,25 +4,71 @@
       "slug": "deepseek-v4-flash",
       "display_name": "deepseek-v4-flash",
       "description": "OpenCode Go: deepseek-v4-flash",
-      "default_reasoning_level": "medium",
+      "default_reasoning_level": "high",
       "supported_reasoning_levels": [
         {
           "effort": "low",
           "description": "Fast responses with lighter reasoning"
         },
         {
-          "effort": "medium",
-          "description": "Balanced reasoning depth"
+          "effort": "high",
+          "description": "Greater reasoning depth for complex problems"
+        },
+        {
+          "effort": "max",
+          "description": "Maximum reasoning depth"
+        }
+      ],
+      "shell_type": "default",
+      "visibility": "list",
+      "supported_in_api": true,
+      "priority": 50,
+      "availability_nux": null,
+      "upgrade": null,
+      "base_instructions": "",
+      "supports_reasoning_summaries": true,
+      "default_reasoning_summary": "none",
+      "support_verbosity": false,
+      "default_verbosity": null,
+      "apply_patch_tool_type": null,
+      "web_search_tool_type": "text",
+      "truncation_policy": {
+        "mode": "tokens",
+        "limit": 1000000
+      },
+      "supports_parallel_tool_calls": false,
+      "supports_image_detail_original": false,
+      "context_window": 1000000,
+      "effective_context_window_percent": 95,
+      "experimental_supported_tools": [],
+      "input_modalities": [
+        "text"
+      ],
+      "supports_search_tool": false
+    },
+    {
+      "slug": "deepseek-v4-pro",
+      "display_name": "deepseek-v4-pro",
+      "description": "OpenCode Go: deepseek-v4-pro",
+      "default_reasoning_level": "high",
+      "supported_reasoning_levels": [
+        {
+          "effort": "low",
+          "description": "Fast responses with lighter reasoning"
         },
         {
           "effort": "high",
           "description": "Greater reasoning depth for complex problems"
+        },
+        {
+          "effort": "max",
+          "description": "Maximum reasoning depth"
         }
       ],
       "shell_type": "default",
       "visibility": "list",
       "supported_in_api": true,
-      "priority": 50,
+      "priority": 56,
       "availability_nux": null,
       "upgrade": null,
       "base_instructions": "",

package/lib/fleet/cell-exec.js

@@ -19,6 +19,11 @@ const DEFAULT_SUPERVISE = Object.freeze({
   maxRapidRestarts: 8,
 });
 
+// F-B (audit 2a, correzione escalation): limite ESPLICITO fra SIGTERM e
+// SIGKILL quando la lease e' persa (onLost, main()). Un figlio che ignora
+// SIGTERM non deve restare appeso a tempo indeterminato.
+const LEASE_LOST_KILL_ESCALATION_MS = 5000;
+
 function parseArgs(argv) {
   const out = {};
   for (let i = 0; i < argv.length; i += 2) {
@@ -75,24 +80,40 @@ function validRestartPrompt(value) {
     && (value.readyWaitMs === undefined || validInteger(value.readyWaitMs, 0, 120000));
 }
 
+function validLease(value) {
+  if (value === undefined) return true;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  // 2b (A2): la capability statica e' revocata e non esiste piu' nel payload.
+  // Il proof supervisore NON transita qui: arriva sul canale lease dal server.
+  if (Object.keys(value).some((k) => !['cellId', 'launchEpoch', 'stablePath'].includes(k))) return false;
+  return (value.cellId === undefined || (typeof value.cellId === 'string' && value.cellId.length > 0 && value.cellId.length <= 128))
+    && typeof value.launchEpoch === 'string' && value.launchEpoch.length > 0 && value.launchEpoch.length <= 128
+    && typeof value.stablePath === 'string' && value.stablePath.length > 0 && value.stablePath.length <= 4096;
+}
+
 function validPayload(payload) {
   if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return false;
-  if (Object.keys(payload).some((key) => !['command', 'args', 'env', 'supervise', 'restartPrompt'].includes(key))) return false;
+  if (Object.keys(payload).some((key) => !['command', 'args', 'env', 'supervise', 'restartPrompt', 'lease'].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);
+    && validRestartPrompt(payload.restartPrompt)
+    && validLease(payload.lease);
 }
 
-function receivePayload(socketPath, nonce, timeoutMs = 5000) {
+function receivePayload(socketPath, nonce, timeoutMs = 5000, opts = {}) {
   return new Promise((resolve, reject) => {
     const socket = net.createConnection(socketPath);
     let data = Buffer.alloc(0); let expected = null; let done = false;
     const finish = (error, payload) => {
-      if (done) return; done = true; socket.destroy();
-      if (error) reject(error); else resolve(payload);
+      if (done) return; done = true;
+      if (error) { socket.destroy(); reject(error); return; }
+      // R3.1.1 (opt-in): keepOpen restituisce il socket APERTO al caller (broker
+      // lease); il caller lo passa al lease-client. Default: destroy (one-shot).
+      if (opts.keepOpen) { resolve({ payload, socket }); return; }
+      socket.destroy(); resolve(payload);
     };
     socket.setTimeout(timeoutMs, () => finish(new Error('launch broker timed out')));
     socket.once('connect', () => socket.write(`${JSON.stringify({ nonce })}\n`));
@@ -256,7 +277,14 @@ function startGenerationPrompt(config, generation, childState, seams = {}) {
 async function main(argv = process.argv.slice(2), seams = {}) {
   const parsed = parseArgs(argv);
   if (!parsed) throw new Error('usage: cell-exec --socket <path> --nonce <hex>');
-  const payload = await (seams.receivePayload || receivePayload)(parsed.socketPath, parsed.nonce);
+  const received = await (seams.receivePayload || receivePayload)(parsed.socketPath, parsed.nonce, 5000, { keepOpen: true });
+  // Compat: il seam di test puo' restituire un payload direttamente; la forma
+  // produttiva restituisce { payload, socket } con socket APERTO (broker lease).
+  const payload = received && typeof received === 'object' && received.payload ? received.payload : received;
+  const leaseSocket = received && typeof received === 'object' && received.socket ? received.socket : null;
+  // Se il payload non porta lease (cella non-ospite), rilascia subito il socket
+  // broker: niente canale lease, e il supervisore non deve trattenere il loop.
+  if (!payload.lease && leaseSocket) { try { leaseSocket.destroy(); } catch (_) {} }
   const supervise = normalizeSupervise(payload.supervise);
   const spawnImpl = seams.spawn || spawn;
   const now = seams.now || Date.now;
@@ -269,7 +297,58 @@ async function main(argv = process.argv.slice(2), seams = {}) {
   if (process.env.TMUX) childEnv.TMUX = process.env.TMUX;
   if (process.env.TMUX_PANE) childEnv.TMUX_PANE = process.env.TMUX_PANE;
 
+  // R3.1.2: nessun bearer di lease transita al child. childEnv deriva SOLO da
+  // payload.env (piu' TMUX); payload.lease (cellId/launchEpoch/stablePath) resta
+  // nel supervisore e alimenta il lease-client. spawnImpl passa env + stdio
+  // inherit. Il proof (2b) vive nel lease-client, MAI nell'env del child.
+  let generation = 0;
+  let leaseCtl = null;
+  // F-B (audit 2a): current/stopping vivono QUI (prima del lease-client) perche'
+  // la callback onLost qui sotto li riferisce dalla closure.
   let current = null; let stopping = false;
+  if (payload.lease && leaseSocket && !leaseSocket.destroyed) {
+    const { startLeaseClient } = require('./lease-client.js');
+    leaseCtl = startLeaseClient(leaseSocket, {
+      stablePath: payload.lease.stablePath,
+      launchEpoch: payload.lease.launchEpoch,
+      // R3.3.4: la generation AVANZA coi restart del supervisore (loop sotto,
+      // generation += 1). Passiamo un getter cosicche' il reconnect presenti
+      // sempre la generation corrente, non 0 fisso (riconcilia :301 con :381).
+      generation: () => generation,
+      // F-B (audit 2a @ 142e272): 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.
+      // Ora il supervisore viene avvisato: ferma il child (stopping + SIGTERM)
+      // e il main loop termina con lui — mai un child vivo oltre la lease.
+      //
+      // Correzione (seconda riconsegna): un SOLO SIGTERM senza escalation
+      // lascia appeso un child che lo ignora (misurato sul percorso reale:
+      // {spawned:1, kills:['SIGTERM'], state:'pending'}) — l'orfano non NASCE
+      // piu' (F-B originale chiuso davvero), ma un figlio gia' vivo che non
+      // collabora non muore. LEASE_LOST_KILL_ESCALATION_MS e' il limite
+      // ESPLICITO, scritto qui: se il child non e' uscito entro questa
+      // finestra dal SIGTERM, si passa a SIGKILL. `target` fissa il processo
+      // di QUESTA generazione: se nel frattempo e' gia' uscito (current
+      // azzerato a null dal loop principale dopo waitChild), l'escalation e'
+      // no-op — mai un kill fantasma su un pid riusato.
+      onLost: () => {
+        writeError('nexuscrew cell supervisor stopped: lease lost (reconnect grace expired)\n');
+        stopping = true;
+        const target = current;
+        try { if (target) target.kill('SIGTERM'); } catch (_) {}
+        if (target) {
+          const escalate = seams.setTimeout || setTimeout;
+          const timer = escalate(() => {
+            if (current === target) {
+              try { target.kill('SIGKILL'); } catch (_) {}
+            }
+          }, LEASE_LOST_KILL_ESCALATION_MS);
+          if (timer && typeof timer.unref === 'function') timer.unref();
+        }
+      },
+    }, seams);
+  }
+
   const handlers = new Map();
   for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
     const handler = () => {
@@ -283,7 +362,6 @@ async function main(argv = process.argv.slice(2), seams = {}) {
     for (const [signal, handler] of handlers) proc.off?.(signal, handler);
   };
 
-  let generation = 0;
   let delayMs = supervise.restartDelayMs;
   let rapid = [];
   try {
@@ -343,7 +421,7 @@ async function main(argv = process.argv.slice(2), seams = {}) {
       delayMs = Math.min(supervise.maxRestartDelayMs, Math.max(supervise.restartDelayMs, delayMs * 2));
       generation += 1;
     }
-  } finally { cleanup(); }
+  } finally { if (leaseCtl) { try { leaseCtl.stop(); } catch (_) {} } cleanup(); }
 }
 
 if (require.main === module) {
@@ -353,6 +431,6 @@ if (require.main === module) {
 }
 
 module.exports = {
-  DEFAULT_SUPERVISE, parseArgs, validSupervise, validRestartPrompt, validPayload,
+  DEFAULT_SUPERVISE, LEASE_LOST_KILL_ESCALATION_MS, parseArgs, validSupervise, validRestartPrompt, validPayload, validLease,
   receivePayload, sanitizeSpawnError, normalizeSupervise, waitChild, startGenerationPrompt, main,
 };