@mmmbuto/nexuscrew 0.9.59 → 0.9.61

package/frontend/dist/index.html

@@ -11,7 +11,7 @@
   <meta name="apple-mobile-web-app-title" content="NexusCrew" />
   <link rel="manifest" href="/manifest.json" />
   <title>NexusCrew</title>
-  <script type="module" crossorigin src="/assets/index-CZFJnks_.js"></script>
+  <script type="module" crossorigin src="/assets/index-VtTd56fc.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-fCIoVxeq.css">
 </head>
 <body>

package/frontend/dist/sw.js

@@ -41,6 +41,19 @@ function alertKey(data) {
   return eventId ? `${owner}:${eventId}` : null;
 }
 
+// Canonical ASK identity takes precedence over event IDs and caller tags.
+async function askAlertTag(data) {
+  if (typeof data.ownerId !== 'string' || typeof data.askId !== 'string'
+    || !/^[a-f0-9]{32}$/i.test(data.ownerId) || !/^[a-f0-9]{8}$/i.test(data.askId)) return null;
+  const generation = Number.isSafeInteger(data.ownerAskTs) && data.ownerAskTs > 0 ? String(data.ownerAskTs)
+    : typeof data.ownerAskFingerprint === 'string' && /^[a-f0-9]{64}$/.test(data.ownerAskFingerprint) ? `unknown:${data.ownerAskFingerprint}` : null;
+  if (!generation) return null;
+  const bytes = new TextEncoder().encode(JSON.stringify([data.ownerId, data.askId, generation]));
+  const digest = await crypto.subtle.digest('SHA-256', bytes);
+  return `nc:ask:${Array.from(new Uint8Array(digest), b => b.toString(16).padStart(2, '0')).join('')}`;
+}
+let alertDelivery = Promise.resolve();
+
 function openAlertsDb() {
   return new Promise((resolve) => {
     try {
@@ -93,9 +106,10 @@ self.addEventListener('push', (e) => {
   const title = typeof data.title === 'string' && data.title ? data.title : 'NexusCrew';
   const body = typeof data.body === 'string' ? data.body : '';
   const url = safeLocalPath(data.url) || '/';
-  const key = alertKey(data);
-  const tag = typeof data.tag === 'string' && TAG_RE.test(data.tag) ? data.tag : LEGACY_TAG;
-  e.waitUntil((async () => {
+  e.waitUntil(alertDelivery = alertDelivery.catch(() => {}).then(async () => {
+    const askTag = await askAlertTag(data);
+    const key = askTag || alertKey(data);
+    const tag = askTag || (typeof data.tag === 'string' && TAG_RE.test(data.tag) ? data.tag : LEGACY_TAG);
     if (await alreadyAlerted(key)) return; // this event already rang once
     await rememberAlerted(key); // registered BEFORE showing: no double alert
     await self.registration.showNotification(title, {
@@ -104,7 +118,7 @@ self.addEventListener('push', (e) => {
       tag,
       data: { url },
     });
-  })());
+  }));
 });
 
 // Click sulla notifica: focus di una finestra gia' aperta (deep-link via

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.9.59"}
+{"version":"0.9.61"}

package/lib/audio/dispatch.js

@@ -98,6 +98,11 @@ function createDispatcher(opts = {}) {
       status: payload.status,
       ...(payload.reason ? { reason: String(payload.reason).slice(0, 64) } : {}),
       httpStatus: res.status,
+      ...(['delivered', 'no-delivery', 'suppressed', 'elided'].includes(payload.alertStatus) ? { alertStatus: payload.alertStatus } : {}),
+      ...(payload.alert && Number.isSafeInteger(payload.alert.ui) && payload.alert.ui >= 0 && Number.isSafeInteger(payload.alert.push) && payload.alert.push >= 0 ? { alert: { ui: payload.alert.ui, push: payload.alert.push, ...(typeof payload.alert.uiAttempted === 'boolean' ? { uiAttempted: payload.alert.uiAttempted } : {}), ...(typeof payload.alert.pushAttempted === 'boolean' ? { pushAttempted: payload.alert.pushAttempted } : {}), ...(typeof payload.alert.pushReason === 'string' ? { pushReason: payload.alert.pushReason.slice(0, 64) } : {}) } } : {}),
+      ...(payload.suppressed === true ? { suppressed: true } : {}),
+      ...(payload.elided === true ? { elided: true } : {}),
+      ...(typeof payload.deduped === 'boolean' ? { deduped: payload.deduped } : {}),
     };
   }
 

package/lib/fleet/builtin.js

@@ -30,7 +30,7 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const {
-  loadDefinitions, atomicWrite, CAPS, MAX_CELLS, validTmuxName, validateCommandTrust,
+  loadDefinitions, atomicWrite, CAPS, MAX_CELLS, validTmuxName, validateCommandTrust, defaultDefinitionsPath,
   aggiornaDefinizioni,
   cellIdFromTmuxSession,
   resolveCwd, normalizeCwdRel, deriveCwdRel,
@@ -611,7 +611,7 @@ async function createBuiltinFleet(cfg = {}) {
   if (cfg.builtinEnabled === false) return off;
 
   const home = cfg.home || os.homedir();
-  const defsPath = cfg.fleetDefsPath || path.join(home, '.nexuscrew', 'fleet.json');
+  const defsPath = defaultDefinitionsPath(cfg);
   const tmuxBin = cfg.tmuxBin || process.env.TMUX_BIN || 'tmux';
   const readonly = () => (cfg.readonlyDefault === true || process.env.NEXUSCREW_READONLY === '1');
   // Lease opt-in: attivo solo quando cfg.cellLeaseEnabled === true. server.js lo
@@ -792,7 +792,7 @@ async function createBuiltinFleet(cfg = {}) {
   });
   const {
     status, cellStatus, up, down, restart, isCellSession,
-    reloadDefs, findCell, findEngine, refreshSessions, commitDefs,
+    reloadDefs, cachedDefs, findCell, findEngine, refreshSessions, commitDefs,
   } = rt;
 
   // Scrive il draft mutato; atomicWrite valida PRIMA (fail-closed). Su input
@@ -1353,7 +1353,10 @@ async function createBuiltinFleet(cfg = {}) {
 
   // Vista editabile ma secret-safe: gli env values restano write-only.
   function definitions() {
-    const defs = reloadDefs();
+    // La fotografia della finestra di TTL (runtime.cachedDefs): una lettura+parse
+    // per finestra condivisa con status, non una per chiamata. Le mutazioni
+    // dell'interfaccia restano immediate via commitDefs.
+    const defs = cachedDefs();
     const { map: credentialMap } = credentialRequirements(defs);
     const managedCatalog = publicCatalog().map((profile) => {
       if (typeof profile.credentialEnv !== 'string') return profile;
@@ -1473,10 +1476,13 @@ async function createBuiltinFleet(cfg = {}) {
   }
 
   function credentialRequirements(existingDefs) {
-    const defs = existingDefs || reloadDefs(); const map = new Map();
+    const defs = existingDefs || cachedDefs(); const map = new Map();
+    // extraModels si calcola UNA volta per la fotografia: rileggerlo per ogni
+    // engine moltiplicava le letture del file per il numero di motori.
+    const extraModels = extraModelsFrom(defs);
     for (const engine of defs.engines) {
       if (!engine.managed) continue;
-      const info = describeManaged(engine.managed, { ...cfg, home, extraModels: extraModelsFrom(reloadDefs()) });
+      const info = describeManaged(engine.managed, { ...cfg, home, extraModels });
       const envKey = info.auth;
       if (!validEnvKey(envKey) || envKey === 'login' || envKey === 'none') continue;
       const current = map.get(envKey) || {

package/lib/fleet/definitions.js

@@ -10,12 +10,21 @@
 // lib/fs/routes.js and lib/tmux/lifecycle.js.
 const fs = require('node:fs');
 const path = require('node:path');
+const os = require('node:os');
 const crypto = require('node:crypto');
 const { normalizeManagedSpec } = require('./managed.js');
 
 // --- Cap + identita' (dichiarati; 100 regge una flotta reale con margine;
 // il limite resta deliberato contro un file patologico) ---
 const SCHEMA_VERSION = 1;
+
+// Un cfg.home assente e' la NORMA delle installazioni reali (bin/nexuscrew
+// serve non passa home): il default segue os.homedir(), esattamente come
+// ogni altro path del server (server.js) e come il runtime Fleet.
+function defaultDefinitionsPath(cfg = {}) {
+  const home = (cfg && cfg.home) || os.homedir();
+  return cfg.fleetDefsPath || path.join(home, '.nexuscrew', 'fleet.json');
+}
 const MAX_ENGINES = 100;
 const MAX_CELLS = 32;
 const MAX_ARGS = 32;            // argv: array, mai stringa spezzata (no shell)
@@ -1198,6 +1207,12 @@ const CAPS = {
 };
 
 module.exports = {
+  // Il default canonico del path di fleet.json: UNA ricetta sola per il
+  // runtime Fleet (builtin.js) e per ogni lettore delle definizioni (owner
+  // ASK scope incluso). Come tutto il resto del server, un cfg.home assente
+  // cade su os.homedir(): due ricette divergenti qui hanno prodotto il
+  // crash all'avvio delle installazioni senza home esplicita.
+  defaultDefinitionsPath,
   parseDefinitions,
   effectiveCapabilities,
   parseCapabilitySet,

package/lib/fleet/managed.js

@@ -854,6 +854,38 @@ function safeAllowedRoots(roots = []) {
 // "missing" che il caller altrimenti riporterebbe per una credenziale presente ma
 // illeggibile. Il verdetto (niente valori estratti -> {}) e' invariato; il
 // discriminante e' CHI ha fallito, non che ci sia stata un'eccezione.
+// --- cache dei file di chiavi (patch upstream verificata) --------------------
+// credentialSources() viene risolta a ogni tick e rilegge+riparsa gli stessi
+// file (ai.env, secure/.env, providers.env, providers.zsh): misurate ~78
+// letture/s su questo nodo. I CONTROLLI DI SICUREZZA (symlink, permessi, uid,
+// size) restano eseguiti a ogni chiamata: la cache copre solo
+// readFileSync+parseAssignments ed e' chiavata sull'identita' esatta del file
+// (dev/ino/size/mtime/ctime/mode/uid), quindi qualunque scrittura, replace o
+// chmod la invalida da se'. Stesso pattern del resto del file: nessun valore
+// entra nei log, solo la mappa restituita al chiamante.
+const envFileCache = new Map();
+// Tetto di vita di una voce: l'identita' al millisecondo non distingue una
+// riscrittura nello STESSO millisecondo con la stessa size, e senza tetto la
+// voce sopravvivrebbe finche' il file non cambia identita' di nuovo — una
+// chiave ruotata resterebbe invisibile per un tempo illimitato. Un secondo
+// basta al dedup del burst (le letture di un tick sono fra loro vicinissime)
+// e limita lo stantio al peggio a un secondo.
+const ENV_FILE_CACHE_MAX_AGE_MS = 1000;
+
+function envFileCacheKey(st) {
+  return `${st.dev}:${st.ino}:${st.size}:${st.mtimeMs}:${st.ctimeMs}:${st.mode}:${st.uid}`;
+}
+
+function readEnvFileCached(target, st) {
+  const key = envFileCacheKey(st);
+  const hit = envFileCache.get(key);
+  if (hit && Date.now() - hit.at <= ENV_FILE_CACHE_MAX_AGE_MS) return hit.values;
+  const values = parseAssignments(fs.readFileSync(target, 'utf8'));
+  if (envFileCache.size > 32) envFileCache.clear();
+  envFileCache.set(key, { values, at: Date.now() });
+  return values;
+}
+
 function parseEnvFile(file, opts = {}, out) {
   const blocked = Array.isArray(out && out.blocked) ? out.blocked : null;
   try {
@@ -868,7 +900,7 @@ function parseEnvFile(file, opts = {}, out) {
     const st = fs.lstatSync(target);
     if (!st.isFile() || st.isSymbolicLink() || (st.mode & 0o077) || st.size > 256 * 1024) return {};
     if (typeof process.getuid === 'function' && st.uid !== process.getuid()) return {};
-    const values = parseAssignments(fs.readFileSync(target, 'utf8'));
+    const values = readEnvFileCached(target, st);
     // Provenienza richiesta dal chiamante (vedi parseProviderKeyFiles). Si
     // registra per CHIAVE, con l'impronta e non il valore, e solo per i file che
     // il chiamante ha dichiarato di voler tracciare: gli altri restano com'e-
@@ -895,7 +927,7 @@ function parseProviderShellFile(file, out) {
     const st = fs.lstatSync(file);
     if (!st.isFile() || st.isSymbolicLink() || (st.mode & 0o022) || st.size > 256 * 1024) return {};
     if (typeof process.getuid === 'function' && st.uid !== process.getuid()) return {};
-    const values = parseAssignments(fs.readFileSync(file, 'utf8'));
+    const values = readEnvFileCached(file, st);
     // Stessa registrazione della provenienza dei file di chiavi: la shell sta
     // PIU' IN ALTO nella precedenza, quindi una providers.zsh stantia produce
     // lo stesso guasto dei file — a parti invertite — e va vista allo stesso
@@ -2292,16 +2324,19 @@ const CODEX_DAEMON_MIN_VERSION = '0.131.0-alpha.12';
 const CODEX_PROBE_TIMEOUT_MS = 10000;
 const codexCapabilityCache = new Map();
 const CODEX_MCP_CONTEXT_ENV = ['MCP_DEVICE', 'NEXUSCREW_MCP_SESSION', 'TMUX', 'TMUX_PANE'];
-function codexEmbeddedGate(binary, cfg) {
+function codexEmbeddedGate(binary, cfg, client) {
   const { spawnSync } = require('node:child_process');
   const { compareVersions, parseVersion } = require('../update/core.js');
-  const unsupported = { ok: false, reason: 'Codex Termux embedded identity isolation is unsupported: runtime capability could not be verified' };
+  const pkg = client === 'codex-vl' ? '@mmmbuto/codex-vl' : '@openai/codex';
+  const minimum = client === 'codex-vl' ? '0.156.1-vl.1' : '0.156.0';
+  const unsupported = { ok: false, reason: `Codex embedded identity isolation is unsupported: runtime capability could not be verified. Update ${pkg} to ${minimum} or later (npm install -g ${pkg}@latest); the launched binary must return a readable --version and advertise --no-daemon in --help.` };
   let resolved, stat;
   try { resolved = fs.realpathSync(binary); stat = fs.statSync(resolved); } catch (_) { return unsupported; }
-  const cached = codexCapabilityCache.get(resolved);
+  const cacheKey = `${client}:${resolved}`;
+  const cached = codexCapabilityCache.get(cacheKey);
   if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached.result;
   const remember = result => {
-    codexCapabilityCache.set(resolved, { mtimeMs: stat.mtimeMs, size: stat.size, result });
+    codexCapabilityCache.set(cacheKey, { mtimeMs: stat.mtimeMs, size: stat.size, result });
     return result;
   };
   const explicitNode = needsExplicitNode(binary, cfg.platform || process.platform, cfg.env || process.env);
@@ -2547,27 +2582,6 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
       if (attivita) args.push(`--settings=${JSON.stringify({ hooks: attivita.hooks })}`);
     }
   } else if (spec.client === 'codex' || spec.client === 'codex-vl') {
-    const termux = (cfg.platform || process.platform) === 'android'
-      || termuxRuntimePaths(cfg.env || process.env, { platform: cfg.platform || process.platform, home }) !== null;
-    if (spec.client === 'codex' && termux) {
-      const gate = codexEmbeddedGate(info.binary, cfg);
-      if (!gate.ok) return { ok: false, info, reason: gate.reason };
-      if (gate.embedded) args.push('--no-daemon');
-      if (gate.embedded) try {
-        const { servers } = codexSurfaceTables(readCodexUserToml(path.join(home, '.codex')));
-        const bridge = servers.get('nexuscrew');
-        if (bridge && bridge.enabled !== false) {
-          if (bridge.env && CODEX_MCP_CONTEXT_ENV.some(name => Object.prototype.hasOwnProperty.call(bridge.env, name))) {
-            return { ok: false, info, reason: 'Codex embedded MCP identity cannot use static context overrides: remove the NexusCrew identity keys from mcp_servers.nexuscrew.env' };
-          }
-          const names = [...new Set([...(Array.isArray(bridge.env_vars) ? bridge.env_vars : []), ...CODEX_MCP_CONTEXT_ENV])];
-          args.push('-c', `mcp_servers.nexuscrew.env_vars=${JSON.stringify(names)}`);
-        }
-      } catch (_) {
-        return { ok: false, info, reason: 'Codex embedded MCP identity requires a readable, valid MCP configuration' };
-      }
-    }
-
     // Canale di attivita' per le celle codex: gli stessi eventi che le celle
     // Claude pubblicano via `--settings`, qui come hook `-c` con la fiducia che
     // il client pretende (senza, apre un dialogo di revisione e la cella resta
@@ -2864,33 +2878,23 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
     const authorityUnavailable = identityMode === 'authority' && !identityAuthorityReady
       ? (identityAuthorityFault || 'authority credentials missing')
       : '';
-    if (hasDefinitionOverride && typeof definitionEnv[CODEX_APP_SERVER_IDENTITY_REQUIRED] === 'string') {
+    const requiredOverride = hasDefinitionOverride && typeof definitionEnv[CODEX_APP_SERVER_IDENTITY_REQUIRED] === 'string'
+      ? definitionEnv[CODEX_APP_SERVER_IDENTITY_REQUIRED]
+      : hasRuntimeOverride && typeof runtimeEnv[CODEX_APP_SERVER_IDENTITY_REQUIRED] === 'string'
+        ? runtimeEnv[CODEX_APP_SERVER_IDENTITY_REQUIRED] : null;
+    if (authorityUnavailable || (!authorityActive && requiredOverride === '1')) {
+      identityChannel = false;
+      identityAuthorityUnavailable = authorityUnavailable || 'required identity channel needs ready authority';
+      if (logLine) logLine('fleet identity: protected cell launch refused — ' + identityAuthorityUnavailable);
+    } else 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];
       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;
@@ -2899,6 +2903,10 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
       }
     }
   }
+  // One resolved launch decision controls the channel and the final isolation arguments.
+  const isolateCodex = (spec.client === 'codex' || spec.client === 'codex-vl')
+    && !identityAuthorityUnavailable && identityChannel !== true;
+  const resolvedIdentityRequired = env[CODEX_APP_SERVER_IDENTITY_REQUIRED];
   // Prompt su argv (0.8.47) SOLO per i client senza percorso classified
   // delivery. Dalla 0.9.41: TUTTE le claude.* passano a consegna
   // ritardata (kimi.* le avevano dal 0.8.47) — promptMode 'send-keys' con
@@ -2913,7 +2921,6 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
   // per-cell file composed by the vl branch (VL_SYSTEM_APPEND_FILE).
   // send-keys does not apply: the deliverBootstrapPrompt classifier covers
   // only kimi/claude, and vl starts immediately without waits.
-  if (spec.client !== 'shell' && spec.client !== 'vl' && !promptViaDelivery && cell?.prompt) args.push(cell.prompt);
   // nexuscrew-store source: neutralize the profile's env set in the composed
   // child env (unset, never empty), so the runtime cannot leak credentials that
   // the local store is meant to own.
@@ -2938,6 +2945,28 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
       env[name] = value;
     }
   }
+  if (spec.client === 'codex-vl' && env[CODEX_APP_SERVER_IDENTITY_REQUIRED] !== resolvedIdentityRequired) {
+    return { ok: false, info, reason: 'Fleet identity environment passthrough conflicts with the resolved launch decision' };
+  }
+  if (isolateCodex) {
+    const gate = codexEmbeddedGate(info.binary, cfg, spec.client);
+    if (!gate.ok) return { ok: false, info, reason: gate.reason };
+    if (gate.embedded) args.push('--no-daemon');
+    if (gate.embedded) try {
+      const { servers } = codexSurfaceTables(readCodexUserToml(path.join(home, '.codex')));
+      const bridge = servers.get('nexuscrew');
+      if (bridge && bridge.enabled !== false) {
+        if (bridge.env && CODEX_MCP_CONTEXT_ENV.some(name => Object.prototype.hasOwnProperty.call(bridge.env, name))) {
+          return { ok: false, info, reason: 'Codex embedded MCP identity cannot use static context overrides: remove the NexusCrew identity keys from mcp_servers.nexuscrew.env' };
+        }
+        const names = [...new Set([...(Array.isArray(bridge.env_vars) ? bridge.env_vars : []), ...CODEX_MCP_CONTEXT_ENV])];
+        args.push('-c', `mcp_servers.nexuscrew.env_vars=${JSON.stringify(names)}`);
+      }
+    } catch (_) {
+      return { ok: false, info, reason: 'Codex embedded MCP identity requires a readable, valid MCP configuration' };
+    }
+  }
+  if (spec.client !== 'shell' && spec.client !== 'vl' && !promptViaDelivery && cell?.prompt) args.push(cell.prompt);
   let command = info.binary;
   if (needsExplicitNode(info.binary, cfg.platform || process.platform, cfg.env || process.env)) {
     command = cfg.nodeExecPath || process.execPath;

package/lib/fleet/runtime.js

@@ -124,6 +124,20 @@ function createBuiltinRuntime(ctx) {
     return cache.defs; // mai null: boot non-null e reload mantiene l'ultimo valido
   }
 
+  // La fotografia definitions per le VITE di sola lettura (definitions,
+  // credentialStatus): una sola lettura+parse per finestra di TTL, la stessa
+  // finestra di cellStatus ma con contatore proprio, per non toccare il
+  // fresco di sessions. Le mutazioni dell'interfaccia restano immediate:
+  // passano da commitDefs, che aggiorna la fotografia in cache.
+  let defsAt = 0;
+  function cachedDefs() {
+    if (Date.now() - defsAt > STATUS_TTL_MS) {
+      reloadDefs();
+      defsAt = Date.now();
+    }
+    return cache.defs;
+  }
+
   // Commit del defs mutato dal facade CRUD (builtin.js mutate()). invalida anche
   // la TTL dello status, esattamente come faceva builtin.js prima dell'estrazione.
   function commitDefs(defs) {
@@ -774,7 +788,7 @@ function createBuiltinRuntime(ctx) {
 
   return {
     status, cellStatus, up, down, restart, isCellSession,
-    reloadDefs, findCell, findEngine, refreshSessions, commitDefs,
+    reloadDefs, cachedDefs, findCell, findEngine, refreshSessions, commitDefs,
   };
 }
 

package/lib/mcp/tools.js

@@ -385,6 +385,7 @@ const TOOLS = [
       });
       return {
         askId: j.id,
+        ...(Array.isArray(j.fanout) ? { fanout: j.fanout } : {}),
         note: 'la risposta dell\'operatore arrivera\' come messaggio incollato in questa sessione tmux',
       };
     },

package/lib/notify/ask-alert-identity.js

@@ -0,0 +1,24 @@
+'use strict';
+const crypto = require('node:crypto');
+// Alert identity is independent of aliases and notification emission time.
+function canonicalAskAlert(frame) {
+  const ownerId = frame && frame.ownerId;
+  const askId = frame && (frame.ownerAskId || frame.askId);
+  if (typeof ownerId !== 'string' || !/^[a-f0-9]{32}$/i.test(ownerId)
+    || typeof askId !== 'string' || !/^[a-f0-9]{8}$/i.test(askId)) return null;
+  const ownerAskTs = frame.ownerAskTs;
+  const fingerprint = frame.ownerAskFingerprint;
+  const generation = Number.isSafeInteger(ownerAskTs) && ownerAskTs > 0 ? String(ownerAskTs)
+    : typeof fingerprint === 'string' && /^[a-f0-9]{64}$/.test(fingerprint) ? `unknown:${fingerprint}` : null;
+  if (!generation) return null;
+  const key = JSON.stringify([ownerId, askId, generation]);
+  return { ownerId, askId, ...(generation.startsWith('unknown:') ? { ownerAskFingerprint: fingerprint } : { ownerAskTs }),
+    tag: `nc:ask:${crypto.createHash('sha256').update(key).digest('hex')}`, key };
+}
+function alertFields(frame) {
+  const identity = canonicalAskAlert(frame);
+  if (!identity) return {};
+  const { key, ...fields } = identity;
+  return fields;
+}
+module.exports = { canonicalAskAlert, alertFields };

package/lib/notify/ask-alert-registry.js

@@ -0,0 +1,96 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { canonicalAskAlert } = require('./ask-alert-identity.js');
+const { askFingerprint } = require('./asks.js');
+const MAX_ENTRIES = 4096;
+const MAX_BYTES = 1024 * 1024;
+const TTL_MS = 24 * 60 * 60 * 1000;
+// One instance is shared by both ingress paths in a receiver process. An
+// unfinished durable claim is uncertain after restart, never a success.
+function createAskAlertRegistry({ filePath, now = Date.now, maxEntries = MAX_ENTRIES, maxBytes = MAX_BYTES, ttlMs = TTL_MS } = {}) {
+  let entries = {}; let blocked = false;
+  try {
+    if (fs.statSync(filePath).size > maxBytes) throw new Error('oversized');
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (data.v !== 1 || !data.entries || typeof data.entries !== 'object' || Array.isArray(data.entries) || Object.keys(data.entries).length > maxEntries) throw new Error('shape');
+    for (const [key, r] of Object.entries(data.entries)) {
+      if (!/^nc:ask:[a-f0-9]{64}$/.test(key) || !r || !Number.isFinite(r.at)
+        || (r.priorTag !== undefined && !/^nc:ask:[a-f0-9]{64}$/.test(r.priorTag))
+        || !['ui', 'push'].every(c => r[c] === undefined || ['pending', 'delivered', 'failed', 'uncertain'].includes(r[c]))) throw new Error('shape');
+    }
+    entries = data.entries;
+  } catch (e) { if (e.code !== 'ENOENT') blocked = true; }
+  function prune() {
+    const cutoff = now() - ttlMs;
+    for (const [key, r] of Object.entries(entries)) if (r.at <= cutoff) delete entries[key];
+  }
+  function save() {
+    const text = JSON.stringify({ v: 1, entries });
+    if (Buffer.byteLength(text) > maxBytes) return false;
+    const temp = `${filePath}.${crypto.randomUUID()}.tmp`;
+    try {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(temp, text, { mode: 0o600, flag: 'wx' }); fs.renameSync(temp, filePath); return true;
+    } catch (_) { try { fs.unlinkSync(temp); } catch (_) {} return false; }
+  }
+  function storedKey(tag) {
+    return entries[tag] ? tag : Object.keys(entries).find(key => entries[key].priorTag === tag) || tag;
+  }
+  // Called only with a complete owner-authoritative ASK and its generation.
+  // Rename one record rather than adding an unbounded alias collection.
+  function adopt(ownerId, ask, authoritativeTs) {
+    if (blocked || !Number.isSafeInteger(authoritativeTs) || authoritativeTs <= 0 || !ask) return false;
+    const askId = ask.ownerAskId || ask.id;
+    const old = canonicalAskAlert({ ownerId, askId, ownerAskFingerprint: askFingerprint(ask) });
+    const known = canonicalAskAlert({ ownerId, askId, ownerAskTs: authoritativeTs });
+    if (!old || !known) return false;
+    prune(); const source = entries[old.tag];
+    const existing = entries[known.tag];
+    if (!source && !existing) return false;
+    // A known fan-out can precede an older feed notification with no generation.
+    // Bind that historical namespace before its first claim, not after alerting.
+    if (!source) {
+      if (existing.priorTag === old.tag) return true;
+      const previous = existing;
+      entries[known.tag] = { ...existing, priorTag: old.tag };
+      if (!save()) { entries[known.tag] = previous; blocked = true; return false; }
+      return true;
+    }
+    const previous = JSON.parse(JSON.stringify(entries));
+    const rank = { failed: 1, pending: 2, uncertain: 3, delivered: 4 };
+    const target = entries[known.tag] || {};
+    const adopted = { at: Math.max(source.at, target.at || 0), priorTag: old.tag };
+    for (const c of ['ui', 'push']) {
+      const a = source[c], b = target[c];
+      if (a || b) adopted[c] = (rank[a] || 0) > (rank[b] || 0) ? a : b;
+    }
+    delete entries[old.tag]; entries[known.tag] = adopted;
+    if (!save()) { entries = previous; blocked = true; return false; } return true;
+  }
+  function claim(frame, channel) {
+    const id = canonicalAskAlert(frame);
+    if (!id) return { allowed: true, reason: 'generic' };
+    if (blocked || !['ui', 'push'].includes(channel)) return { allowed: false, reason: 'alert-registry-unavailable' };
+    prune(); const key = storedKey(id.tag); const prior = entries[key]; const phase = prior && prior[channel];
+    if (phase && phase !== 'failed') return { allowed: false, reason: phase === 'delivered' ? 'already-alerted' : 'alert-uncertain' };
+    if (!prior && Object.keys(entries).length >= maxEntries) {
+      const oldest = Object.entries(entries).filter(([, r]) => r.ui !== 'pending' && r.push !== 'pending').sort((a, b) => a[1].at - b[1].at)[0];
+      if (!oldest) return { allowed: false, reason: 'alert-registry-cap' };
+      delete entries[oldest[0]];
+    }
+    entries[key] = { ...(prior || {}), at: now(), [channel]: 'pending' };
+    if (!save()) { blocked = true; return { allowed: false, reason: 'alert-registry-unavailable' }; }
+    return { allowed: true, key };
+  }
+  function complete(frame, channel, result) {
+    const id = canonicalAskAlert(frame);
+    const key = id && storedKey(id.tag);
+    if (!id || blocked || !entries[key] || entries[key][channel] !== 'pending') return false;
+    entries[key][channel] = result === 'uncertain' ? 'uncertain' : result > 0 ? 'delivered' : 'failed';
+    if (!save()) { blocked = true; return false; } return true;
+  }
+  return { claim, complete, adopt, limits: { maxEntries, maxBytes, ttlMs }, filePath };
+}
+module.exports = { createAskAlertRegistry, MAX_ENTRIES, MAX_BYTES, TTL_MS };

package/lib/notify/asks.js

@@ -148,12 +148,18 @@ function createAsksStore(opts = {}) {
   // Chiusura dell'alias locale quando l'OWNER chiude la domanda. Durevole: la
   // riga resta nello storico marcata, quindi non ricompare a un reload e non
   // torna risponibile.
-  function closeImported({ ownerId, ownerAskId, outcome }) {
+  function closeImported({ ownerId, ownerAskId, ownerAskTs, outcome }) {
     const ur = unreadableGuard();
     if (ur) return { ok: false, reason: 'store-unreadable', changed: false, ask: null };
     const ask = findImported(ownerId, ownerAskId);
     const record = getImportedDismissal(ownerId, ownerAskId);
-    if (record) {
+    // Known closure generations cannot mutate a newer alias or dismissal receipt.
+    const closureTs = Number.isSafeInteger(ownerAskTs) && ownerAskTs > 0 ? ownerAskTs : null;
+    const recordMismatch = closureTs && record && record.ownerAskTs && record.ownerAskTs !== closureTs;
+    if ((closureTs && ask && generationTs(ask) && generationTs(ask) !== closureTs) || (!ask && recordMismatch)) {
+      return { ok: true, changed: false, ask: null, generationMismatch: true };
+    }
+    if (record && !recordMismatch) {
       const synced = updateImportedDismissal(ownerId, ownerAskId, { syncState: outcome === 'answered' ? 'confirmed-answered' : 'confirmed-dismissed', ownerOutcome: outcome });
       if (!synced.ok) return { ...synced, changed: false, ask: null };
     }

package/lib/notify/closure-retry.js

@@ -93,7 +93,7 @@ function createClosureRetryQueue({
     // riceve una seconda consegna inutile.
     const targets = [...entry.targets];
     try {
-      results = await run({ askId: entry.askId, outcome: entry.outcome, session: entry.session, targets });
+      results = await run({ askId: entry.askId, ...(entry.ownerAskTs ? { ownerAskTs: entry.ownerAskTs } : {}), outcome: entry.outcome, session: entry.session, targets });
     } catch (e) {
       results = targets.map((target) => ({ target, status: 'unknown', reason: 'dispatch-threw' }));
       try { log(`chiusura ask ${entry.askId}: tentativo fallito (${String(e && e.message || e)})`); } catch (_) {}
@@ -129,11 +129,12 @@ function createClosureRetryQueue({
   // stessa chiusura UNISCE i target invece di essere buttata via: e' cio' che
   // impedisce a un peer spento di sparire dalla coda quando un ALTRO peer
   // risponde, o quando la stessa chiusura viene riprovata piu' tardi.
-  function enqueue({ askId, outcome, session, targets } = {}) {
+  function enqueue({ askId, ownerAskTs, outcome, session, targets } = {}) {
     if (stopped || !askId || !outcome) return { ok: false, reason: 'invalid' };
     const nuovi = [...new Set((Array.isArray(targets) ? targets : []).map((t) => String(t)).filter(Boolean))];
     if (!nuovi.length) return { ok: false, reason: 'no-targets' };
-    const existing = entries.find((e) => e.askId === askId && e.outcome === outcome);
+    const generation = Number.isSafeInteger(ownerAskTs) && ownerAskTs > 0 ? ownerAskTs : null;
+    const existing = entries.find((e) => e.askId === askId && e.outcome === outcome && (e.ownerAskTs || null) === generation);
     if (existing) {
       const prima = existing.targets.size;
       for (const t of nuovi) existing.targets.add(t);
@@ -148,7 +149,7 @@ function createClosureRetryQueue({
       try { log(`coda chiusure piena (${maxEntries}): scartata la piu' vecchia (${oldest.askId})`); } catch (_) {}
     }
     const entry = {
-      askId, outcome, session, targets: new Set(nuovi),
+      askId, ...(generation ? { ownerAskTs: generation } : {}), outcome, session, targets: new Set(nuovi),
       attempts: 0, createdAt: now(), nextAt: 0, timer: null, inFlight: false,
     };
     entries.push(entry);