@mmmbuto/nexuscrew 0.9.20 → 0.9.21

package/lib/fleet/identity-transport.js

@@ -0,0 +1,68 @@
+'use strict';
+
+function issueIdentityChallenge({
+  identityAuthority,
+  daemonCredential,
+  audience,
+  daemonBootId,
+  connectionId,
+} = {}) {
+  if (!identityAuthority || typeof identityAuthority.registerDaemonChallenge !== 'function') {
+    return { ok: false, reason: 'identity-authority' };
+  }
+  const out = identityAuthority.registerDaemonChallenge({
+    daemonCredential,
+    audience,
+    daemonBootId,
+    connectionId,
+  });
+  if (!out.ok) return out;
+  return { challenge: out.challenge, issuedAt: out.issuedAt, expiresAt: out.expiresAt };
+}
+
+function issueLaunchIdentity({
+  identityAuthority,
+  daemonCredential,
+  launcherCredential,
+  audience,
+  daemonBootId,
+  connectionId,
+  subject,
+} = {}) {
+  const challenge = issueIdentityChallenge({
+    identityAuthority,
+    daemonCredential,
+    audience,
+    daemonBootId,
+    connectionId,
+  });
+  if (!challenge || !challenge.challenge) {
+    return { ok: false, reason: challenge && challenge.reason ? challenge.reason : 'challenge' };
+  }
+  const grant = identityAuthority.issueLaunchGrant({
+    launcherCredential,
+    challenge: challenge.challenge,
+    subject,
+  });
+  if (!grant || !grant.ok) {
+    return { ok: false, reason: grant && grant.reason ? grant.reason : 'grant' };
+  }
+  const proof = identityAuthority.issueChallengeProof({
+    launchGrant: grant.grant,
+    challenge: challenge.challenge,
+  });
+  if (!proof || !proof.ok) {
+    return { ok: false, reason: proof && proof.reason ? proof.reason : 'proof' };
+  }
+  return {
+    ok: true,
+    audience,
+    daemonBootId,
+    connectionId,
+    challenge: challenge.challenge,
+    grant: grant.grant,
+    proof: proof.proof,
+  };
+}
+
+module.exports = { issueIdentityChallenge, issueLaunchIdentity };

package/lib/fleet/launch-broker.js

@@ -5,6 +5,7 @@ const net = require('node:net');
 const os = require('node:os');
 const path = require('node:path');
 const crypto = require('node:crypto');
+const { issueLaunchIdentity } = require('./identity-transport.js');
 
 const MAX_PAYLOAD = 512 * 1024;
 const REQUEST_LIMIT = 256;
@@ -82,6 +83,10 @@ function createLaunchBroker(cfg = {}) {
   // onLease o senza lease il comportamento e' invariato (socket.end, one-shot):
   // le celle non-ospite non sono toccate.
   const onLease = typeof cfg.onLease === 'function' ? cfg.onLease : null;
+  const identityMode = cfg.identityMode || 'legacy';
+  const identityAuthority = cfg.identityAuthority || null;
+  const identityDaemonCredential = cfg.identityDaemonCredential || null;
+  const identityLauncherCredential = cfg.identityLauncherCredential || null;
 
   function expire(nonce) {
     const entry = pending.get(nonce);
@@ -226,7 +231,27 @@ function createLaunchBroker(cfg = {}) {
   async function issue(payload) {
     const target = await start();
     const nonce = crypto.randomBytes(32).toString('hex');
-    const entry = { encoded: encodePayload(payload), expires: Date.now() + ttlMs, timer: null, lease: payload && payload.lease ? payload.lease : null };
+    let encodedPayload = payload;
+    if (payload && payload.identity) {
+      if (identityMode !== 'authority' || !identityAuthority || !identityDaemonCredential) {
+        throw new Error('identity authority non disponibile');
+      }
+      const launched = issueLaunchIdentity({
+        identityAuthority,
+        daemonCredential: identityDaemonCredential,
+        launcherCredential: identityLauncherCredential,
+        audience: payload.identity.audience,
+        daemonBootId: payload.identity.daemonBootId,
+        connectionId: payload.identity.connectionId,
+        subject: payload.identity.subject,
+      });
+      if (!launched || !launched.ok) {
+        throw new Error(`identity launch ${launched && launched.reason ? launched.reason : 'malformed'}`);
+      }
+      const { ok, ...identity } = launched;
+      encodedPayload = { ...payload, identity };
+    }
+    const entry = { encoded: encodePayload(encodedPayload), expires: Date.now() + ttlMs, timer: null, lease: payload && payload.lease ? payload.lease : null };
     entry.timer = setTimeout(() => expire(nonce), ttlMs);
     entry.timer.unref?.();
     pending.set(nonce, entry);

package/lib/fleet/lease-client.js

@@ -18,6 +18,48 @@
 const net = require('node:net');
 const L = require('./cell-lease.js');
 
+const IDENTITY_FRAME_LIMIT = 8 * 1024;
+const IDENTITY_TIMEOUT_MS = 4000;
+const IDENTITY_CHALLENGE_KEYS = Object.freeze([
+  'version', 'audience', 'daemonBootId', 'connectionId', 'nonce', 'issuedAt', 'expiresAt',
+]);
+
+function nonEmptyString(value, max = 256) {
+  return typeof value === 'string' && value.length > 0 && value.length <= max;
+}
+
+function validDaemonChallenge(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const keys = Object.keys(value);
+  if (keys.length !== IDENTITY_CHALLENGE_KEYS.length
+    || IDENTITY_CHALLENGE_KEYS.some((key) => !Object.prototype.hasOwnProperty.call(value, key))) return false;
+  // R4: tipi JSON originari, niente coercizioni (Number()/regex su non-stringhe).
+  const issuedAt = value.issuedAt;
+  const expiresAt = value.expiresAt;
+  return value.version === 1
+    && nonEmptyString(value.audience) && nonEmptyString(value.daemonBootId)
+    && nonEmptyString(value.connectionId)
+    && typeof value.nonce === 'string' && /^[a-f0-9]{64}$/.test(value.nonce)
+    && Number.isSafeInteger(issuedAt) && Number.isSafeInteger(expiresAt)
+    && issuedAt >= 0 && expiresAt > issuedAt;
+}
+
+function identityErrorCode(reason) {
+  switch (reason) {
+    case 'expired': return 'EXPIRED';
+    case 'replay': case 'challenge-replay': return 'REPLAY';
+    case 'audience': case 'daemonBootId': case 'connectionId': return 'AUDIENCE_MISMATCH';
+    case 'lease-down': case 'revoked': case 'generation': return 'REVOKED';
+    case 'timeout': case 'authority-unavailable': case 'authority': return 'AUTHORITY_UNAVAILABLE';
+    default: return 'IDENTITY_UNVERIFIED';
+  }
+}
+
+function validIdentityRequestId(value) {
+  return (typeof value === 'string' && value.length > 0 && value.length <= 128)
+    || Number.isSafeInteger(value);
+}
+
 function startLeaseClient(initialSocket, info, seams = {}) {
   if (!initialSocket || !info || !info.stablePath || !info.launchEpoch) return null;
   const setTimer = seams.setTimeout || ((fn, ms) => setTimeout(fn, ms));
@@ -34,12 +76,45 @@ function startLeaseClient(initialSocket, info, seams = {}) {
   let heldProof = null;
   // R3.2: bound di grace per i reconnect (eofAt + GRACE_MS). Oltre non si ritenta.
   let reconnectDeadline = null;
+  const identityPending = new Map();
+  // R1: una sola transizione di generazione in volo (il supervisore e' sequenziale).
+  let generationWaiter = null;
 
   function send(obj) {
     if (!current || current.destroyed || !current.writable) return false;
     try { current.write(`${JSON.stringify(obj)}\n`); return true; } catch (_) { return false; }
   }
 
+  function rejectIdentity(reason) {
+    for (const pending of identityPending.values()) {
+      clearTimer(pending.timer);
+      pending.reject(Object.assign(new Error(reason), { code: reason }));
+    }
+    identityPending.clear();
+  }
+
+  function identityDown() {
+    rejectIdentity('lease-down');
+    if (generationWaiter) {
+      const waiter = generationWaiter;
+      generationWaiter = null;
+      clearTimer(waiter.timer);
+      waiter.reject(Object.assign(new Error('lease-down'), { code: 'lease-down' }));
+    }
+    if (typeof info.onIdentityDown === 'function') {
+      try { info.onIdentityDown(); } catch (_) {}
+    }
+  }
+
+  function cancelIdentity(requestId) {
+    const pending = identityPending.get(requestId);
+    if (!pending) return false;
+    identityPending.delete(requestId);
+    clearTimer(pending.timer);
+    pending.reject(Object.assign(new Error('cancelled'), { code: 'cancelled' }));
+    return true;
+  }
+
   function armRefresh() {
     clearTimer(refreshTimer);
     refreshTimer = setTimer(() => {
@@ -52,6 +127,7 @@ function startLeaseClient(initialSocket, info, seams = {}) {
 
   function onEOF() {
     if (stopped) return;
+    identityDown();
     if (current) { try { current.removeAllListeners('data'); current.removeAllListeners('close'); current.removeAllListeners('end'); } catch (_) {} }
     current = null;
     clearTimer(refreshTimer);
@@ -157,6 +233,31 @@ function startLeaseClient(initialSocket, info, seams = {}) {
       while ((nl = buf.indexOf('\n')) !== -1) {
         const line = buf.slice(0, nl); buf = buf.slice(nl + 1);
         let msg; try { msg = JSON.parse(line); } catch (_) { continue; }
+        if (msg.type === 'challengeProofResult' && validIdentityRequestId(msg.requestId)) {
+          const pending = identityPending.get(msg.requestId);
+          if (pending) {
+            identityPending.delete(msg.requestId);
+            clearTimer(pending.timer);
+            if (msg.ok === true && msg.proof && typeof msg.proof === 'object') {
+              pending.resolve({ ok: true, proof: msg.proof });
+            } else {
+              const reason = msg.ok === false && typeof msg.reason === 'string' ? msg.reason : 'identity-unverified';
+              pending.reject(Object.assign(new Error(reason), { code: reason }));
+            }
+          }
+        }
+        if (msg.type === 'generationAck' && generationWaiter && msg.generation === generationWaiter.generation) {
+          const waiter = generationWaiter;
+          generationWaiter = null;
+          clearTimer(waiter.timer);
+          waiter.resolve({ ok: true, generation: msg.generation });
+        }
+        if (msg.type === 'generationDeny' && generationWaiter) {
+          const waiter = generationWaiter;
+          generationWaiter = null;
+          clearTimer(waiter.timer);
+          waiter.reject(Object.assign(new Error('revoked'), { code: 'revoked' }));
+        }
         if ((msg.type === 'ack' || msg.type === 'lease') && msg.proof && typeof msg.proof === 'object') {
           heldProof = msg.proof;
         }
@@ -175,17 +276,83 @@ function startLeaseClient(initialSocket, info, seams = {}) {
   armRefresh();
   send({ type: 'refresh' }); // primo refresh immediato
 
+  function challengeProof({ requestId, generation, challenge } = {}) {
+    if (!validIdentityRequestId(requestId) || !Number.isSafeInteger(generation) || generation < 0) {
+      return Promise.resolve({ ok: false, reason: 'identity-unverified' });
+    }
+    if (!validDaemonChallenge(challenge)) return Promise.resolve({ ok: false, reason: 'challenge' });
+    if (stopped || !current || current.destroyed || !current.writable || identityPending.has(requestId)) {
+      return Promise.resolve({ ok: false, reason: 'authority-unavailable' });
+    }
+    return new Promise((resolve, reject) => {
+      const pending = { resolve, reject, timer: null };
+      pending.timer = setTimer(() => {
+        if (!identityPending.has(requestId)) return;
+        identityPending.delete(requestId);
+        reject(Object.assign(new Error('timeout'), { code: 'timeout' }));
+      }, IDENTITY_TIMEOUT_MS);
+      if (pending.timer && typeof pending.timer.unref === 'function') pending.timer.unref();
+      identityPending.set(requestId, pending);
+      const sent = send({ type: 'challengeProof', requestId, generation, challenge });
+      if (!sent) {
+        identityPending.delete(requestId);
+        clearTimer(pending.timer);
+        reject(Object.assign(new Error('authority-unavailable'), { code: 'authority-unavailable' }));
+      }
+    });
+  }
+
+  // R1: annuncia la transizione di generazione sulla connessione viva PRIMA
+  // che il supervisore apra il canale identita' della generazione nuova.
+  function announceGeneration(generation) {
+    if (!Number.isSafeInteger(generation) || generation < 0) {
+      return Promise.resolve({ ok: false, reason: 'identity-unverified' });
+    }
+    if (stopped || !current || current.destroyed || !current.writable) {
+      return Promise.resolve({ ok: false, reason: 'lease-down' });
+    }
+    return new Promise((resolve, reject) => {
+      const waiter = { resolve, reject, timer: null, generation };
+      generationWaiter = waiter;
+      waiter.timer = setTimer(() => {
+        if (generationWaiter !== waiter) return;
+        generationWaiter = null;
+        reject(Object.assign(new Error('timeout'), { code: 'timeout' }));
+      }, IDENTITY_TIMEOUT_MS);
+      if (waiter.timer && typeof waiter.timer.unref === 'function') waiter.timer.unref();
+      if (!send({ type: 'generation', generation })) {
+        if (generationWaiter === waiter) generationWaiter = null;
+        clearTimer(waiter.timer);
+        reject(Object.assign(new Error('lease-down'), { code: 'lease-down' }));
+      }
+    });
+  }
+
   return {
     stop() {
       stopped = true;
+      rejectIdentity('lease-down');
+      if (generationWaiter) {
+        const waiter = generationWaiter;
+        generationWaiter = null;
+        clearTimer(waiter.timer);
+        waiter.reject(Object.assign(new Error('lease-down'), { code: 'lease-down' }));
+      }
       clearTimer(refreshTimer);
       clearTimer(reconnectTimer);
       try { current && current.destroy(); } catch (_) {}
       current = null;
     },
+    challengeProof,
+    announceGeneration,
+    cancelIdentityChallenge: cancelIdentity,
     _isConnected: () => !!current && !current.destroyed,
     _heldProof: () => heldProof,
+    _identityPendingCount: () => identityPending.size,
   };
 }
 
-module.exports = { startLeaseClient };
+module.exports = {
+  startLeaseClient, validDaemonChallenge, identityErrorCode,
+  IDENTITY_FRAME_LIMIT, IDENTITY_TIMEOUT_MS,
+};

package/lib/fleet/lease-routes.js

@@ -4,10 +4,9 @@
 //
 // Il bridge MCP di una cella (`nexuscrew mcp`) parla con l'HTTP API locale dietro
 // Bearer (canale nativo del bridge): queste route sono quel collegamento.
-// La CELLA e' derivata dalla sessione tmux dichiarata dal chiamante — lo stesso
-// modello degli altri tool nc_*; il PROOF firmato dal verifier per-installazione
-// e' l'authorizer di refresh/recovery (PREMESSA 2b: cambia il modello di
-// autorizzazione, non il trasporto).
+// La CELLA di register e' derivata dal proof identity verificato dall'authority;
+// refresh/recovery la derivano dal proof child firmato dal lease manager. La
+// sessione tmux del body non e' mai un authorizer.
 //
 // Semantica degli status (tutti 200 salvo errori di protocollo):
 //   registered | live | pending | no-registration | expired | denied
@@ -15,11 +14,38 @@
 // richiesta era malformata o il servizio non c'e' — non e' un esito di lease.
 
 const express = require('express');
-const { cellIdFromTmuxSession } = require('./definitions.js');
+const { cellIdFromTmuxSession, tmuxSessionForCell } = require('./definitions.js');
+const { createIdentityBindingGuard } = require('../identity/binding-guard.js');
 
-function leaseRoutes({ fleetP, readonly = () => false, log = () => {} }) {
+function leaseRoutes({
+  fleetP, readonly = () => false, log = () => {}, identityAuthority = null,
+  identityAudience = 'nexuscrew-lease', identityMode = 'legacy', instanceId = null,
+}) {
+  const bindingGuard = createIdentityBindingGuard({
+    fleetP, instanceId, now: () => Date.now(),
+    // refresh/recovery hanno gia il proof child come authorizer nel body. Il
+    // binding MCP, quando presentato, viene verificato fail-closed; l'assenza
+    // preserva il canale nativo lease (D) che esisteva prima di G3.
+    sharedRequired: false,
+  });
+
+  async function guardBinding(req, cell) {
+    try {
+      return await bindingGuard.verify(req, { expected: { cell }, localOnly: true });
+    } catch (e) {
+      return e;
+    }
+  }
+
+  function bindingRejected(res, error) {
+    return res.status(403).json({ error: error.message, code: error.code });
+  }
   const r = express.Router();
   const smallJson = express.json({ limit: '8kb' });
+  if (identityMode !== 'legacy' && identityMode !== 'authority') {
+    throw new Error('fleet.identity.mode non valido');
+  }
+  const mode = identityMode;
 
   const guard = (fn) => async (req, res) => {
     try {
@@ -30,19 +56,25 @@ function leaseRoutes({ fleetP, readonly = () => false, log = () => {} }) {
       if (!fleet.lease || typeof fleet.lease.childRegister !== 'function') {
         return res.status(501).json({ error: 'lease non disponibile su questo nodo' });
       }
-      return await fn(fleet.lease, req, res);
+      return await fn(fleet.lease, req, res, fleet);
     } catch (e) {
       res.status(500).json({ error: String((e && e.message) || e) });
     }
   };
 
-  // La sessione dichiarata determina la cella. Se non risolve in una cella
-  // valida la richiesta non ha soggetto: 400, senza cadere in un default.
-  const cellOf = (req) => cellIdFromTmuxSession(req.body && req.body.session);
-  const requireCell = (req, res) => {
-    const cell = cellOf(req);
-    if (!cell) {
-      res.status(400).json({ error: 'sessione non valida: impossibile derivare la cella' });
+  // La sessione nel body NON è una credenziale. Per register il subject viene
+  // dal proof identity emesso dall'authority; per refresh/recovery dal proof
+  // child già firmato dal lease manager. Se un client legacy invia session la
+  // confrontiamo solo come guardia anti-confusione, mai per scegliere la cella.
+  const cellFromProof = (req, res) => {
+    const cell = req.body && req.body.proof && req.body.proof.cellId;
+    if (!tmuxSessionForCell(cell)) {
+      res.status(400).json({ error: 'proof senza cella valida' });
+      return null;
+    }
+    const declared = req.body && req.body.session;
+    if (declared !== undefined && cellIdFromTmuxSession(declared) !== cell) {
+      res.status(400).json({ error: 'sessione body discordante dal proof' });
       return null;
     }
     return cell;
@@ -56,31 +88,71 @@ function leaseRoutes({ fleetP, readonly = () => false, log = () => {} }) {
     return proof;
   };
 
-  r.post('/register', smallJson, guard((lease, req, res) => {
+  r.post('/register', smallJson, guard((lease, req, res, fleet) => {
     if (readonly()) return res.status(403).json({ error: 'READONLY: lease child bloccato' });
-    const cell = requireCell(req, res);
-    if (!cell) return undefined;
-    const out = lease.childRegister(cell);
+    let cell;
+    if (mode === 'authority') {
+      const proof = requireProof(req, res);
+      if (!proof) return undefined;
+      const authority = identityAuthority || fleet.identityAuthority;
+      if (!authority || typeof authority.verifyChallengeProof !== 'function') {
+        return res.status(501).json({ error: 'identity authority non disponibile' });
+      }
+      const checked = authority.verifyChallengeProof(proof, { audience: identityAudience });
+      if (!checked.ok) return res.json({ status: 'denied', reason: checked.reason });
+      cell = cellFromProof(req, res);
+      if (!cell) return undefined;
+    } else {
+      const declared = req.body && req.body.session;
+      cell = cellIdFromTmuxSession(declared);
+      if (!cell) return res.status(400).json({ error: 'sessione mancante o non valida' });
+    }
+    const out = lease.childRegister(cell, { authority: mode === 'authority' });
     log(`lease-route: register ${cell} -> ${out.status}`);
     return res.json(out);
   }));
 
-  r.post('/refresh', smallJson, guard((lease, req, res) => {
+  // Introspezione del proof child per il contesto shared del bridge MCP:
+  // READ-ONLY (non consuma, non rinnova), attiva soltanto in authority mode.
+  // In legacy risponde 501: nessun binding B+C puo nascere dal percorso D.
+  r.post('/introspect', smallJson, guard((lease, req, res) => {
+    if (mode !== 'authority') {
+      return res.status(501).json({ error: 'identity introspection richiede fleet.identity.mode authority' });
+    }
+    const proof = requireProof(req, res);
+    if (!proof) return undefined;
+    const out = lease.childIntrospect(proof);
+    if (out.status === 'live') {
+      const node = typeof instanceId === 'function' ? instanceId() : instanceId;
+      return res.json({
+        ...out,
+        tmuxSession: tmuxSessionForCell(out.cellId),
+        ...(typeof node === 'string' && node ? { instanceId: node } : {}),
+      });
+    }
+    return res.json(out);
+  }));
+
+  r.post('/refresh', smallJson, guard(async (lease, req, res) => {
     if (readonly()) return res.status(403).json({ error: 'READONLY: lease child bloccato' });
-    const cell = requireCell(req, res);
-    if (!cell) return undefined;
     const proof = requireProof(req, res);
     if (!proof) return undefined;
+    const cell = cellFromProof(req, res);
+    if (!cell) return undefined;
+    const binding = await guardBinding(req, cell);
+    if (binding instanceof Error) return bindingRejected(res, binding);
     const out = lease.childRefresh(cell, proof);
     return res.json(out);
   }));
 
-  r.post('/recovery', smallJson, guard((lease, req, res) => {
+  r.post('/recovery', smallJson, guard(async (lease, req, res) => {
     if (readonly()) return res.status(403).json({ error: 'READONLY: lease child bloccato' });
-    const cell = requireCell(req, res);
-    if (!cell) return undefined;
     const proof = requireProof(req, res);
     if (!proof) return undefined;
+    const cell = cellFromProof(req, res);
+    if (!cell) return undefined;
+    const binding = await guardBinding(req, cell);
+    if (binding instanceof Error) return bindingRejected(res, binding);
     const out = lease.childRecovery(cell, proof);
     log(`lease-route: recovery ${cell} -> ${out.status}`);
     return res.json(out);

package/lib/fleet/managed.js

@@ -20,6 +20,10 @@ const OLLAMA_CLOUD_MODELS = Object.freeze([
   // glm-5.3: disponibile su ollama.com/library (2026-09-05). La scheda
   // dichiara Context 1M tokens, Input Text e le badge tools/thinking/cloud.
   'glm-5.3',
+  // kimi-k3: disponibile su ollama.com/library (2026-09-06). La scheda
+  // dichiara Context 1M tokens, Input Text, Image e le badge vision/tools/thinking/cloud.
+  // DICHIARATO 2026-09-06 https://ollama.com/library/kimi-k3
+  'kimi-k3',
 ]);
 // Autorita' per OLLAMA_CONTEXT = IL CAMPO STRUTTURATO «Context» della scheda
 // canale (ollama.com/library, fetch 2026-08-27) — NON la descrizione, che
@@ -48,6 +52,9 @@ const OLLAMA_CONTEXT = Object.freeze({
   'glm-5.3-flash': 1000000,
   // glm-5.3: scheda «Context / 1M tokens» (2026-09-05).
   'glm-5.3': 1000000,
+  // kimi-k3: scheda «Context / 1M tokens», Input Text, Image (2026-09-06).
+  // DICHIARATO 2026-09-06 https://ollama.com/library/kimi-k3
+  'kimi-k3': 1000000,
 });
 // Capacita' per modello OSSERVATE dalla scheda canale (ollama.com/library,
 // 2026-08-27). Assenza = default conservativo (comportamento odierno, nessuna
@@ -62,6 +69,10 @@ const OLLAMA_MODEL_CAPABILITIES = Object.freeze({
   // glm-5.3: scheda tools/thinking/cloud, Input Text (2026-09-05). PARALLEL
   // NON dichiarato: default conservativo false finche' non misurato su device.
   'glm-5.3': Object.freeze({ input: ['text'], reasoning: true, supportsParallelToolCalls: false }),
+  // kimi-k3: scheda vision/tools/thinking/cloud, Input Text, Image (2026-09-06).
+  // PARALLEL NON dichiarato: default conservativo false finche' non misurato su device.
+  // DICHIARATO 2026-09-06 https://ollama.com/library/kimi-k3
+  'kimi-k3': Object.freeze({ input: ['text', 'image'], reasoning: true, supportsParallelToolCalls: false }),
 });
 // Descrittori dell'engine ollama-cloud per la generazione del catalogo client:
 // stessa forma dei descrittori custom/PI (id, label, contextWindow, input,
@@ -1835,6 +1846,8 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
     else if (spec.provider === 'ollama-cloud') {
       env.OPENAI_API_KEY = cred.value;
       args.push(...codexProviderArgs('ollama_cloud', 'Ollama Cloud', profile.endpoint, 'OPENAI_API_KEY'));
+      // Ollama Responses rejects the built-in web_search tool before the turn starts.
+      args.push('-c', 'web_search="disabled"');
       args.push('-c', 'model_providers.ollama_cloud.stream_idle_timeout_ms=600000', '-c', `model_context_window=${ollamaContextFor(model) ?? 200000}`);
       // Catalogo generato dagli id DICHIARATI DELL'ENGINE: senza entry il
       // client cade sul descrittore fallback (272000 fisso, parallel tools

package/lib/fleet/runtime.js

@@ -13,6 +13,7 @@
 // policy, la redazione e il testo degli errori sono INVARIATI rispetto a
 // builtin.js prima dell'estrazione.
 const path = require('node:path');
+const crypto = require('node:crypto');
 const {
   loadDefinitions, validateCommandTrust, resolveCwd,
 } = require('./definitions.js');
@@ -41,7 +42,11 @@ function findEngine(defs, id) { return defs.engines.find((e) => e.id === id) ||
 //   e' tornato unavailable su garbage).
 // ---------------------------------------------------------------------------
 function createBuiltinRuntime(ctx) {
-  const { cfg, home, defsPath, tmuxBin, readonly, launchBroker, leaseManager, boot, ensureProtection } = ctx;
+  const {
+    cfg, home, defsPath, tmuxBin, readonly, launchBroker, leaseManager, boot, ensureProtection,
+    identityAuthority = null, identityMode = 'legacy', identityOwnerInstanceId = null,
+  } = ctx;
+  const identityDaemonBootId = cfg.identityDaemonBootId || crypto.randomBytes(16).toString('hex');
   let cache = { at: 0, defs: boot, sessions: new Set() };
 
   function reloadDefs() {
@@ -232,6 +237,23 @@ function createBuiltinRuntime(ctx) {
     if (leaseManager) {
       try { leaseInfo = await leaseManager.track(cell.id); } catch (_) { leaseInfo = null; }
     }
+    const identity = identityMode === 'authority' && identityAuthority ? {
+      audience: cfg.identityAudience || cfg.fleet?.identity?.audience || 'nexuscrew-lease',
+      daemonBootId: identityDaemonBootId,
+      connectionId: `${cell.id}-${crypto.randomBytes(8).toString('hex')}`,
+      subject: {
+        ownerInstanceId: identityOwnerInstanceId,
+        cellId: cell.id,
+        incarnationId: crypto.randomBytes(16).toString('hex'),
+        launchEpoch: leaseInfo ? leaseInfo.launchEpoch : crypto.randomBytes(8).toString('hex'),
+      },
+    } : undefined;
+    if (identity && leaseManager && typeof leaseManager.setLaunchSubject === 'function'
+      && leaseManager.setLaunchSubject(cell.id, identity.subject) !== true) {
+      throw httpError(500, 'identity launch subject non registrabile', null, {
+        phase: 'launch-broker', code: 'IDENTITY_SUBJECT_UNAVAILABLE',
+      });
+    }
     ticket = await launchBroker.issue({
         command: child.command,
         args: child.args,
@@ -241,6 +263,7 @@ function createBuiltinRuntime(ctx) {
           MCP_DEVICE: `${String(cell.id).toLowerCase()}-agent`,
           NEXUSCREW_MCP_SESSION: cell.tmuxSession,
         },
+        ...(identity ? { identity } : {}),
         ...(leaseInfo ? { lease: { cellId: cell.id, launchEpoch: leaseInfo.launchEpoch, stablePath: leaseInfo.stablePath } } : {}),
         supervise: {
           enabled: !launchEngine.shellOneShot,