@mmmbuto/nexuscrew 0.9.76 → 0.9.78

package/lib/fleet/builtin.js

@@ -41,7 +41,7 @@ const {
   CATALOG, CLIENT_LABELS, CLIENT_ORDER, engineClient, ordinaEngine, isStandardClient,
   credential: resolveProfileCredential, extraModelsFrom, knownMcpServerNames, profileFor,
   normalizeManagedSpec, codexSurfaceNames,
-  engineModelDiscoveryPlan, ollamaCloudCatalogModels, declaredModelsFor, ALIBABA_PI_MODELS,
+  engineModelDiscoveryPlan, modelListingCredential, ollamaCloudCatalogModels, declaredModelsFor, ALIBABA_PI_MODELS,
 } = require('./managed.js');
 const { probeModel, probeCustomEndpoint } = require('./model-probe.js');
 const { createModelDiscovery, DISCOVERY_PROPOSAL_CAP } = require('./model-discovery.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 },
@@ -1823,6 +1865,23 @@ async function createBuiltinFleet(cfg = {}) {
       ...(cause ? { cause } : {}),
     };
   }
+  // Backup proposals for fields no layer could fill: the missing-data dialog
+  // offers what the internal catalog knows, and the operator's confirmation
+  // is what turns a proposal into a user value.
+  function withBackupDefaults(records, profile) {
+    const internalIndex = internalModelIndex(profile);
+    return (Array.isArray(records) ? records : []).map((m) => {
+      const backupValues = {};
+      for (const field of ['contextWindow', 'maxTokens']) {
+        if (m[field] === undefined) {
+          const known = internalValueFor(internalIndex, m.id);
+          if (known && known[field] !== undefined) backupValues[field] = known[field];
+        }
+      }
+      return Object.keys(backupValues).length ? { ...m, backupValues } : m;
+    });
+  }
+
   async function discoverEngineModels(engineId, opts = {}) {
     const id = String(engineId || '');
     if (!id || id.length > 64 || !/^[A-Za-z0-9._-]+$/.test(id)) {
@@ -1843,16 +1902,10 @@ async function createBuiltinFleet(cfg = {}) {
       spec = profile ? { client: profile.client, provider: profile.provider, ...(profile.credentialProfile ? { credentialProfile: profile.credentialProfile } : {}) } : null;
     }
     if (!profile) { const e = new Error(`engine sconosciuto: ${id}`); e.status = 404; throw e; }
-    const plan = engineModelDiscoveryPlan(profile, spec, cfg, home, id);
-    if (!plan) {
-      // No HTTP listing to interrogate (login/native flows, local providers
-      // without a base URL): an honest empty answer, never an error, so the
-      // editor stays usable. The UI hides the section on `supported: false`.
-      return { engine: id, supported: false, source: 'unsupported', models: [] };
-    }
     // User layer: models declared in fleet.json for this engine (or its
     // profile) — the values the operator chose, always on top and never
-    // rewritten by discovery.
+    // rewritten by discovery. Built BEFORE the plan: an engine without a
+    // listing still has ids worth enriching.
     const extraModels = extraModelsFrom(defs);
     const userModels = [];
     const seenUser = new Set();
@@ -1876,33 +1929,57 @@ async function createBuiltinFleet(cfg = {}) {
     }
     const backupModels = backupModelsFor(profile);
     const wanted = [...new Set([...userModels, ...backupModels].map((m) => m.id))].slice(0, 32);
+    // The plan is the HTTP listing, when the profile has one. When it does
+    // not, the same composition still runs with the API layer explicitly
+    // unavailable: known ids are enriched from the public snapshot, with no
+    // invented collector, request or auth attempt.
+    const plan = engineModelDiscoveryPlan(profile, spec, cfg, home, id);
+    // The active model is configuration the operator already chose. It counts
+    // as a known id only when it is the ONLY one: with a declared model or a
+    // profile backup the proposal already has its ids, and adding it would
+    // duplicate a row or change the order.
+    const activeModel = spec && typeof spec.model === 'string' ? spec.model.trim() : '';
+    const knownIds = !userModels.length && !backupModels.length && activeModel ? [activeModel] : [];
     const result = await engineModelDiscovery.discoverEngine({
-      ...plan,
+      ...(plan || {}),
+      engine: id,
       home,
       userModels, backupModels,
+      knownIds,
       ...(wanted.length ? { detailIds: wanted } : {}),
-      publicCatalog: { provider: profile.provider, baseUrl: plan.baseUrl, ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}) },
+      publicCatalog: {
+        provider: profile.provider,
+        ...(plan && plan.baseUrl ? { baseUrl: plan.baseUrl } : {}),
+        ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
+      },
       ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
       ...(opts.refresh === true ? { noCache: true } : {}),
+      ...(plan ? {} : { apiAvailable: false }),
     });
     // Curated response: `plan` (baseUrl, apiKey) stays out; apiModels is
-    // already merged (with provenance) into `models`.
-    // `backupValues` rides along only for fields NO layer could fill: the
-    // internal catalog's proposal for the missing-data dialog. A field any
-    // layer answered carries no proposal — the dialog asks for what nobody
-    // knows, and the operator's confirmation is what turns a proposal into a
-    // user value.
-    const internalIndex = internalModelIndex(profile);
-    const models = result.models.map((m) => {
-      const backupValues = {};
-      for (const field of ['contextWindow', 'maxTokens']) {
-        if (m[field] === undefined) {
-          const known = internalValueFor(internalIndex, m.id);
-          if (known && known[field] !== undefined) backupValues[field] = known[field];
-        }
-      }
-      return Object.keys(backupValues).length ? { ...m, backupValues } : m;
-    });
+    // already merged (with provenance) into `models`. `backupValues` rides
+    // along only for fields NO layer could fill.
+    const models = withBackupDefaults(result.models, profile);
+    if (!plan) {
+      const cred = modelListingCredential(profile, spec, cfg, home);
+      return {
+        engine: id,
+        supported: false,
+        source: 'unsupported',
+        status: result.status,
+        stale: false,
+        error: '',
+        auth: {
+          credentialState: cred.credentialState,
+          ...(cred.envKey ? { envKey: cred.envKey } : {}),
+          attempted: false,
+          credentialSent: false,
+        },
+        ...(result.publicCatalog ? { publicCatalog: result.publicCatalog } : {}),
+        models,
+        cap: DISCOVERY_PROPOSAL_CAP,
+      };
+    }
     return {
       engine: id,
       supported: true,
@@ -1920,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',
@@ -1929,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;
 }