@mmmbuto/nexuscrew 0.9.77 → 0.9.78

package/lib/fleet/builtin.js

@@ -54,6 +54,7 @@ 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');
+const { requestVlNewSession, vlNewSessionStatus, vlLegacyInventory } = require('./vl-session.js');
 
 // Toolkit stateless + runtime estratti (behavior-preserving). I simboli di
 // launch.js sono re-esportati in module.exports per i test che li importano
@@ -965,7 +966,15 @@ async function createBuiltinFleet(cfg = {}) {
   // I campi non-identita' che `parseModel` ammette per una dichiarazione:
   // id ed engine SONO l'identita' (il chiaro per cui esiste edit-model e' non
   // doverla ritoccare), tutto il resto e' patchabile con la stessa validazione.
-  const EDIT_MODEL_FIELDS = new Set(['label', 'contextWindow', 'maxTokens', 'tools', 'vision', 'reasoning']);
+  // `effortLevels` e' fra questi: i livelli dichiarati sono parte della
+  // dichiarazione del modello, e dichiararli una volta sola non basta — il
+  // cliente vl accetta solo i livelli dichiarati, quindi cambiarli e' una
+  // correzione legittima della dichiarazione, non un campo exotic.
+  const EDIT_MODEL_FIELDS = new Set(['label', 'contextWindow', 'maxTokens', 'tools', 'vision', 'reasoning', 'effortLevels']);
+  // Stessa forma del parser (definitions.js, `parseModel`): i livelli sono
+  // token corti in minuscolo, e finiscono in un valore d'ambiente, non in argv.
+  const EFFORT_LEVELS_MAX = 8;
+  const EFFORT_LEVEL_RE = /^[a-z0-9][a-z0-9-]{0,15}$/;
 
   async function editModel(id, engine, patch) {
     if (readonly()) throw httpError(403, 'READONLY: edit-model bloccato');
@@ -997,6 +1006,24 @@ async function createBuiltinFleet(cfg = {}) {
         throw httpError(400, `${key} non valido: booleano`);
       }
     }
+    // `effortLevels`: la dichiarazione dei livelli accettati per questo
+    // modello. `null` = togli la dichiarazione (i livelli tornano a non essere
+    // richiesti); un array = i livelli nuovi. La validazione e' IDENTICA a
+    // quella del parser: un valore che il file rifiuta non entra, e un
+    // livello inventato non viene battezzato "low".
+    if (patch.effortLevels !== undefined && patch.effortLevels !== null) {
+      const levels = patch.effortLevels;
+      if (!Array.isArray(levels) || levels.length < 1 || levels.length > EFFORT_LEVELS_MAX) {
+        throw httpError(400, `effortLevels non valido: array da 1 a ${EFFORT_LEVELS_MAX} livelli`);
+      }
+      const visti = new Set();
+      for (const level of levels) {
+        if (typeof level !== 'string' || !EFFORT_LEVEL_RE.test(level) || visti.has(level)) {
+          throw httpError(400, `effortLevels non valido: livello non conforme o duplicato: ${JSON.stringify(level)}`);
+        }
+        visti.add(level);
+      }
+    }
     const defs = reloadDefs();
     if (!(defs.models || []).some((m) => m.id === wantedId && m.engine === wantedEngine)) {
       throw httpError(404, `modello non dichiarato: ${wantedId} su ${wantedEngine}`);
@@ -1008,7 +1035,13 @@ async function createBuiltinFleet(cfg = {}) {
     // e' la stessa riga del file, l'engine non ha nulla da ricaricare.
     await mutate(defs, (d) => {
       const target = d.models.find((m) => m.id === wantedId && m.engine === wantedEngine);
-      Object.assign(target, patch);
+      for (const [key, value] of Object.entries(patch)) {
+        // `null` su `effortLevels` TOGLIE la dichiarazione: e' l'unico modo per
+        // tornare a un modello senza livelli dichiarati (il parser rifiuta un
+        // array vuoto, quindi l'assenza si scrive togliendo il campo).
+        if (key === 'effortLevels' && value === null) { delete target.effortLevels; continue; }
+        target[key] = value;
+      }
     });
     return { ok: true, id: wantedId, engine: wantedEngine, edited: keys };
   }
@@ -1580,6 +1613,15 @@ async function createBuiltinFleet(cfg = {}) {
           baseUrl: { type: 'string', requiredFor: 'provider=custom', max: CAPS.MAX_COMMAND_LEN },
           envKey: { type: 'string', requiredFor: 'provider=custom', pattern: '^[A-Za-z_][A-Za-z0-9_]{0,63}$' },
           providerId: { type: 'string', requiredFor: 'provider=custom', pattern: '^[a-z][a-z0-9_-]{0,31}$' },
+          // Campi vl (client vl): percorsi assoluti sul nodo esecutore, profilo
+          // del catalogo dichiarato, livello effort dichiarato per il modello.
+          // La validazione semantica (esistenza, eseguibile, profilo nel
+          // catalogo, effort nei livelli dichiarati) vive in normalizeManagedSpec
+          // e ai gate di lancio: lo schema dice la FORMA, non la verita' del nodo.
+          vlBinary: { type: 'string', required: false, absolute: true, max: 4096 },
+          vlConfigFile: { type: 'string', required: false, absolute: true, max: 4096 },
+          vlProfile: { type: 'string', required: false, pattern: '^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$' },
+          effort: { type: 'string', required: false, pattern: '^[a-z0-9][a-z0-9-]{0,15}$' },
         },
         command: { type: 'string', requiredFor: 'custom', max: CAPS.MAX_COMMAND_LEN, absolute: true },
         args: { type: 'array', of: 'string', required: false, max: CAPS.MAX_ARGS, itemMax: CAPS.MAX_ARG_LEN },
@@ -1955,6 +1997,67 @@ async function createBuiltinFleet(cfg = {}) {
 
   async function close() { await launchBroker.close(); if (leaseManager) leaseManager.close(); }
 
+  // --- Sessione nuova esplicita (contratto vl) ------------------------------
+  // Azione SEPARATA dal ciclo di lancio: crea la richiesta persistente che il
+  // prossimo up() della cella consumera' UNA volta (rename atomico, poi --new
+  // alla sola generazione 0). Mai un flag dell'engine, mai un avvio implicito:
+  // l'operatore chiede, il ciclo di lancio applica e consuma. Autorizzata sul
+  // nodo owner perche' il marcatore e lo spawn sono dello stesso nodo.
+  async function vlNewSession(cellId) {
+    if (readonly()) throw httpError(403, 'READONLY: vl-new-session bloccato');
+    const id = String(cellId || '');
+    if (!/^[A-Za-z0-9._-]{1,32}$/.test(id) || id === '.' || id === '..') {
+      throw httpError(400, 'id cell non valido');
+    }
+    const defs = reloadDefs();
+    const cell = findCell(defs, id);
+    if (!cell) throw httpError(400, `cella sconosciuta: ${id}`);
+    const engine = findEngine(defs, cell.engine);
+    if (!engine || !engine.managed || engine.managed.client !== 'vl') {
+      throw httpError(400, `la cella ${id} non usa un engine vl: la sessione nuova esplicita esiste solo per vl`);
+    }
+    try {
+      const requested = requestVlNewSession({ home, cellId: id, now: Date.now() });
+      // Lo stato COMPLETO dopo la richiesta: se sotto c'e' un consumo precedente
+      // non verificato, l'operatore lo vede qui (esito incerto riferito, mai
+      // ripetuto in automatico).
+      return { ok: true, cell: id, ...requested, status: vlNewSessionStatus({ home, cellId: id }) };
+    } catch (e) {
+      throw httpError(500, `richiesta sessione nuova non registrabile: ${e.message}`);
+    }
+  }
+
+  // Vista READ-ONLY dello stato della richiesta di sessione nuova, per una
+  // cella sola. Il contratto e' una domanda su UNA cella: chi non puo'
+  // agire su quella cella non ne legge lo stato (il percorso di scope lo
+  // dichiara come bersaglio, quindi la risposta non porta niente di altre
+  // celle). Niente mutazioni: e' una lettura, e non e' una richiesta nuova.
+  function vlNewSessionStateView(cellId) {
+    const id = String(cellId || '');
+    if (!/^[A-Za-z0-9._-]{1,32}$/.test(id) || id === '.' || id === '..') {
+      throw httpError(400, 'id cell non valido');
+    }
+    const defs = reloadDefs();
+    const cell = findCell(defs, id);
+    if (!cell) throw httpError(400, `cella sconosciuta: ${id}`);
+    const engine = findEngine(defs, cell.engine);
+    if (!engine || !engine.managed || engine.managed.client !== 'vl') {
+      throw httpError(400, `la cella ${id} non usa un engine vl: lo stato della sessione nuova esiste solo per vl`);
+    }
+    // 'pending' = il prossimo lancio ruota; 'consumed' = un lancio ha
+    // consumato la richiesta e l'esito non e' tracciato; 'none' = mai
+    // richiesto. Nomi e timestamp: nessun contenuto di sessione.
+    return { cell: id, ...vlNewSessionStatus({ home, cellId: id }) };
+  }
+
+  // Inventario read-only delle cartelle di stato vl LEGACY (pre-contratto):
+  // elenca quello che esiste, non sposta e non cancella nulla. La migrazione,
+  // se mai ci sara', e' una procedura esplicita separata con backup e scelta
+  // dell'operatore.
+  function vlLegacyInventoryView() {
+    return vlLegacyInventory(home);
+  }
+
   return {
     available: true,
     provider: 'builtin',
@@ -1964,6 +2067,7 @@ async function createBuiltinFleet(cfg = {}) {
     schema, definitions, capabilities,
     credentialStatus, setLocalCredential, removeLocalCredential, testModel, discoverEngineModels,
     defineModel, editModel, removeModel, close,
+    vlNewSession, vlNewSessionState: vlNewSessionStateView, vlLegacyInventory: vlLegacyInventoryView,
     // Fetta 2b: il lease Live esposto alle route /api/lease, che il bridge
     // MCP delle celle consuma per register/refresh/recovery. Assente se il
     // lease e' disattivato: le route rispondono 501, non 500.

package/lib/fleet/causes.js

@@ -40,6 +40,10 @@ const CODES = [
   'MCP_CELL_FILE_UNWRITABLE',
   'CAPABILITY_PROFILE_UNWRITABLE',
   'CAPABILITY_UNKNOWN_NAME',
+  // preflight vl: pausa minima fra due lanci della stessa cella non trascorsa /
+  // marcatore «sessione nuova» non consumabile in sicurezza (albero ostile)
+  'VL_LAUNCH_COOLDOWN',
+  'VL_NEW_SESSION_UNSAFE',
   // launch-broker
   'LAUNCH_BROKER_UNSAFE',
   'LAUNCH_BROKER_PAYLOAD',

package/lib/fleet/cell-exec.js

@@ -147,7 +147,7 @@ function validActivity(value) {
 
 function validPayload(payload) {
   if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return false;
-  if (Object.keys(payload).some((key) => !['command', 'args', 'env', 'supervise', 'restartPrompt', 'lease', 'identity', 'identityChannel', 'activity'].includes(key))) return false;
+  if (Object.keys(payload).some((key) => !['command', 'args', 'env', 'supervise', 'restartPrompt', 'lease', 'identity', 'identityChannel', 'activity', 'vlNewSession'].includes(key))) return false;
   if (typeof payload.command !== 'string' || !payload.command || !Array.isArray(payload.args)) return false;
   if (!payload.env || typeof payload.env !== 'object' || Array.isArray(payload.env)) return false;
   // Il launcher decide se il canale identita' esiste (managed.js) e lo dichiara
@@ -155,6 +155,10 @@ function validPayload(payload) {
   // va quindi ammessa qui, e SOLO come booleano: un valore di altro tipo e' un
   // payload malformato, non un "canale assente" (assente = caller precedente).
   if (payload.identityChannel !== undefined && typeof payload.identityChannel !== 'boolean') return false;
+  // Stessa regola per la sessione nuova vl: la decisione arriva GIÀ PRESA dal
+  // launcher (che ha consumato il marcatore prima dello spawn), quindi qui è un
+  // booleano o niente — mai un argv da reinterpretare.
+  if (payload.vlNewSession !== undefined && typeof payload.vlNewSession !== 'boolean') return false;
   return payload.args.every((v) => typeof v === 'string')
     && Object.entries(payload.env).every(([k, v]) => /^[A-Za-z_][A-Za-z0-9_]{0,63}$/.test(k) && typeof v === 'string')
     && validSupervise(payload.supervise)
@@ -767,7 +771,16 @@ 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, {
+      // Sessione nuova vl (payload.vlNewSession): `--new` va SOLO alla
+      // generazione 0 — il primo spawn dopo che il launcher ha consumato la
+      // richiesta esplicita. I restart supervisionati (generazione 1+) usano
+      // argv pulito: una rotazione ripetuta butterebbe via la sessione appena
+      // creata, ed è esattamente ciò che il contratto vieta. Il payload resta
+      // immutato: la decisione è del launcher, l'applicazione è per generazione.
+      const generationArgs = generation === 0 && payload.vlNewSession === true
+        ? [...payload.args, '--new']
+        : payload.args;
+      current = spawnImpl(payload.command, generationArgs, {
         env: childEnv,
         // Senza canale non si creano nemmeno le pipe: fd 3 e 4 chiusi nel
         // child (non pipe aperte e inutilizzate).

package/lib/fleet/definitions.js

@@ -196,7 +196,7 @@ const MODEL_ID_MAX = 128;
 
 function parseModel(m) {
   if (!m || typeof m !== 'object' || Array.isArray(m)) return null;
-  const allowed = new Set(['id', 'engine', 'label', 'contextWindow', 'maxTokens', 'tools', 'vision', 'reasoning']);
+  const allowed = new Set(['id', 'engine', 'label', 'contextWindow', 'maxTokens', 'tools', 'vision', 'reasoning', 'effortLevels']);
   if (Object.keys(m).some((k) => !allowed.has(k))) return null;
   const id = typeof m.id === 'string' ? m.id.trim() : '';
   // Stessa forma accettata dal gate dei modelli: nessun byte di controllo, un
@@ -230,6 +230,20 @@ function parseModel(m) {
     if (typeof m[key] !== 'boolean') return null;
     out[key] = m[key];
   }
+  // `effortLevels`: the effort levels DECLARED for this model (client vl, env
+  // VL_EFFORT). The runtime accepts only declared levels — no universal
+  // low/medium/high equivalence is assumed — so an absent declaration means
+  // "no effort can be requested for this model", never "any level goes".
+  // Short lowercase tokens only: they land in an env value, not in argv.
+  if (m.effortLevels !== undefined) {
+    if (!Array.isArray(m.effortLevels) || !m.effortLevels.length || m.effortLevels.length > 8) return null;
+    const seen = new Set();
+    for (const level of m.effortLevels) {
+      if (typeof level !== 'string' || !/^[a-z0-9][a-z0-9-]{0,15}$/.test(level) || seen.has(level)) return null;
+      seen.add(level);
+    }
+    out.effortLevels = [...m.effortLevels];
+  }
   return out;
 }