pi-jev-guard 0.1.6 → 0.2.1

package/README.md

@@ -26,7 +26,15 @@ export TYPESAFE_API_KEY="..."              # backend typesafe diretto
 
 ## Uso normale (invariato)
 
-Con l'estensione installata non cambia nulla finché non la usi: i modelli normali restano selezionabili e nessuna verifica parte da sola (`mode: on-demand`).
+Le nuove sessioni partono in `on-demand`: i modelli normali restano selezionabili e nessuna verifica parte da sola.
+`/jev mode automatic|on-demand` salva la scelta **nella sessione**, non nella config globale.
+La scelta sopravvive a `/reload`, riavvio e `/resume`; fork e `/tree` seguono lo stato del ramo.
+Credenziali, policy e catalogo dei twin restano condivisi.
+
+Migrazione: il vecchio `mode` in `jev-config.json` non controlla più l'estensione
+(resta compatibile con i consumer standalone). Nelle sessioni senza uno stato salvato,
+riattiva `automatic` una volta se desiderato. `JEV_MODE=automatic` può impostare il valore
+iniziale in headless; una scelta già salvata nella sessione ha precedenza.
 
 ```text
 /jev check ./src/example.ts        # verifica singola di un file
@@ -39,28 +47,46 @@ In chat, l'LLM può chiamare `jev_validate` per controlli mirati.
 ## Uso protetto
 
 ```text
-/jev upstream deepseek deepseek-flash   # crea deepseek/deepseek-flash__jev
-/jev mode automatic                    # seleziona il twin + attiva enforcement
+/jev upstream deepseek deepseek-flash          # crea deepseek/deepseek-flash__jev
+/jev upstream openai-codex gpt-5.6-terra       # aggiunge openai-codex/gpt-5.6-terra__jev
+/jev twins                                    # elenca attivi e salvati
+/jev untwin openai-codex gpt-5.6-terra         # rimuove uno solo
+/jev mode automatic                           # seleziona il primario + attiva enforcement
 ```
 
-Nessun login extra: il twin vive nello stesso provider e riusa la credenziale già configurata (env, stored, OAuth/SSO come Codex business plan). I modelli originali restano intatti e selezionabili.
+**Più twin insieme**: ogni `/jev upstream` *aggiunge* un modello guarded, senza
+rimuovere i precedenti. I twin vengono registrati anche all'avvio (i modelli
+dinamici come Codex sono letti dal models-store), quando gli originali sono disponibili.
+Il **primario** salvato è il target di auto-selezione e revert; un twin già selezionato
+nella sessione viene mantenuto al reload, anche se non è il primario.
+
+Nessun login extra: i twin vivono nello stesso provider e riusano la credenziale già configurata (env, stored, OAuth/SSO come Codex business plan). I modelli originali restano intatti e selezionabili.
 
-In `automatic` il twin viene registrato già all'avvio (prima del ripristino del
-modello di sessione), così la sessione può riaprire direttamente su `__jev`.
+I twin salvati vengono registrati prima del ripristino del modello anche in
+`on-demand`: registrazione e attivazione del gate sono indipendenti. Il suffisso
+`__jev` è locale e non viene inviato al provider; anche la cronologia viene
+normalizzata sull'identità originale senza perdere firme o metadati di continuazione.
 
-Torna normale con `/model` (modello normale) + `/jev mode on-demand`.
+Torna normale con `/jev mode on-demand`, che seleziona anche il modello originale.
 In `automatic`, selezionare un modello non protetto lo fa ritornare
 subito al twin (enforcement a livello selezione).
-`/jev upstream` senza argomenti ripristina l'ultimo salvato, `/jev off` rimuove il twin
-(e torna a on-demand, provider originale ripristinato). In `automatic` il twin
-si ripristina da solo al riavvio.
-
-Se filtri i modelli con `enabledModels`, tieni la voce del twin (es.
-`deepseek/deepseek-flash__jev`) o resta nascosto.
+`/jev upstream` senza argomenti ripristina tutti i twin salvati, `/jev untwin P M`
+ne rimuove uno solo, `/jev off` li rimuove tutti
+(e salva on-demand nella sessione, selezionando l'originale prima di rimuovere il routing).
+`/jev off` conserva il catalogo salvato: al reload gli alias tornano disponibili,
+ma il gate rimane disattivato.
+
+Se filtri i modelli con `enabledModels`, tieni le voci `__jev` dei twin che usi
+o restano nascosti.
 L'installazione punta alla cartella: dopo un aggiornamento del codice basta `/reload`.
 
-Headless/CI: `JEV_AUTO_UPSTREAM=provider/model` crea il guarded all'avvio
-(con `pi --print` solo `deepseek/deepseek-flash`).
+Headless/CI: `JEV_MODE=automatic JEV_AUTO_UPSTREAM=provider/model` crea e attiva
+il guarded nelle sessioni senza uno stato Jev salvato.
+
+Un hold `[JEV — OUTPUT NON PUBBLICATO]` interrompe intenzionalmente il turno:
+controlla `/jev last`. Non viene aggirato con un proseguimento automatico.
+Le conferme per comandi di rete sospetti attendono invece una decisione esplicita;
+la normale sequenza tool → risposta successiva continua senza un nuovo prompt.
 
 ## Come decide
 

package/config/jev-config.example.json

@@ -8,7 +8,10 @@
     "timeoutMs": 4000,
     "timeoutMsTypesafe": 1500,
     "timeoutMsOpenRouter": 4000,
-    "retryTransients": { "enabled": true, "maxRetries": 1 },
+    "retryTransients": {
+      "enabled": true,
+      "maxRetries": 1
+    },
     "apiKeyFile": "~/.pi/agent/jev-api-key.txt"
   },
   "policy": {
@@ -22,6 +25,16 @@
     "transport": "provider-gate",
     "maxRegenerations": 2,
     "requireGuardedModel": true,
+    "twins": [
+      {
+        "provider": "deepseek",
+        "model": "deepseek-flash"
+      },
+      {
+        "provider": "openai-codex",
+        "model": "gpt-5.6-terra"
+      }
+    ],
     "upstreamProvider": "deepseek",
     "upstreamModel": "deepseek-flash"
   },
@@ -44,7 +57,9 @@
   },
   "outputJudge": {
     "enabled": true,
-    "tools": ["bash"],
+    "tools": [
+      "bash"
+    ],
     "outputChars": 2000,
     "leakThreshold": 0.9,
     "minConfidence": 0.6,
@@ -52,8 +67,16 @@
   },
   "exfilCheck": {
     "enabled": true,
-    "tools": ["bash", "powershell"],
-    "blockOn": { "destructive": 0.9, "exfiltration": 0.7, "beyondScope": 0.85, "impact": 2.5 },
+    "tools": [
+      "bash",
+      "powershell"
+    ],
+    "blockOn": {
+      "destructive": 0.9,
+      "exfiltration": 0.7,
+      "beyondScope": 0.85,
+      "impact": 2.5
+    },
     "minConfidence": 0.5,
     "cacheSeconds": 120,
     "blockWithoutUI": false

package/extensions/index.ts

@@ -1,7 +1,8 @@
 import type { ExtensionAPI, ExtensionContext, ModelRegistry } from "@earendil-works/pi-coding-agent";
 import type { Model, Provider } from "@earendil-works/pi-ai";
 import type { Api } from "@earendil-works/pi-ai";
-import { builtinProviders } from "@earendil-works/pi-ai/providers/all";import { registerJevCommand, type UpstreamResult } from "../src/commands.ts";
+import { builtinProviders } from "@earendil-works/pi-ai/providers/all";
+import { registerJevCommand, type UpstreamResult } from "../src/commands.ts";
 import { registerJevAskTool } from "../src/ask.ts";
 import {
   configSnapshot,
@@ -9,7 +10,10 @@ import {
   parseUpstreamRef,
   resolveBackend,
   saveConfig,
+  twinRefs,
+  withTwinRefs,
   type JevConfig,
+  type TwinRef,
 } from "../src/config.ts";
 import { createReviewer, createTypedAsk } from "../src/factory.ts";
 import { createMetrics } from "../src/metrics.ts";
@@ -18,7 +22,9 @@ import {
   STATIC_DEEPSEEK_FLASH,
   buildOverlaidProvider,
   isTwinId,
+  mergeModelsById,
   twinIdFor,
+  untwinId,
 } from "../src/automatic/overlay.ts";
 import type { GateVerdictReport } from "../src/automatic/guardian.ts";
 import { readStoreModels } from "../src/store-models.ts";
@@ -57,6 +63,20 @@ export interface GateStatus {
 
 export default function (pi: ExtensionAPI) {
   let config: JevConfig = loadConfig();
+  // Shared config holds credentials/policy/twins, not the session toggle.
+  const initialMode = process.env.JEV_MODE === "automatic" ? "automatic" : "on-demand";
+  let sessionMode: JevConfig["mode"] = initialMode;
+  function getConfig(): JevConfig {
+    return { ...config, mode: sessionMode };
+  }
+  function restoreMode(ctx: ExtensionContext): void {
+    sessionMode = initialMode;
+    for (const entry of ctx.sessionManager.getBranch()) {
+      if (entry.type !== "custom" || entry.customType !== "jev-mode") continue;
+      const mode = (entry.data as { mode?: unknown } | undefined)?.mode;
+      if (mode === "automatic" || mode === "on-demand") sessionMode = mode;
+    }
+  }
   // Full (3 regole) per tool/comandi/diagnostica; gate (difetti concreti) per provider.
   let handle = createReviewer(configSnapshot(config));
   let gateHandle = createReviewer(configSnapshot(config), { rules: DEFAULT_GATE_RULES });
@@ -73,24 +93,55 @@ export default function (pi: ExtensionAPI) {
   let lastExfilErrorAt = 0;
   const metrics = createMetrics();
 
-  // Opt-in: nessun overlay all'avvio. Si crea solo con /jev upstream
-  // (o ripristino automatico quando la config dice automatic).
-  let overlaidProviderId: string | undefined;
-  let upstreamRefs = new Map<string, Provider>();
-  let twinTarget: { provider: string; model: string } | undefined;
+  // Twin attivi, uno o più per provider. Nessun overlay finché la config non
+  // li attiva (automatic) o l'utente non usa /jev upstream (opt-in).
+  interface OverlayState {
+    upstream: Provider;
+    twinIds: string[];
+  }
+  const overlays = new Map<string, OverlayState>();
 
-  const getConfig = () => config;
   const getReview = () => handle.review;
   const getGateReview = () => gateHandle.review;
   const getInfo = () => ({ backend: handle.backend, model: handle.model });
 
+  /** Twin primario (auto-selezione e revert): ultimo aggiunto che è attivo. */
+  function primaryTwin(): TwinRef | undefined {
+    const saved = twinRefs(config);
+    const wanted =
+      saved.find(
+        (r) =>
+          r.provider === config.automatic.upstreamProvider &&
+          r.model === config.automatic.upstreamModel,
+      ) ?? saved[saved.length - 1];
+    if (wanted && overlays.get(wanted.provider)?.twinIds.includes(wanted.model)) {
+      return wanted;
+    }
+    // Ripiego: primo twin attivo.
+    for (const [providerId, state] of overlays) {
+      const model = state.twinIds[0];
+      if (model) return { provider: providerId, model };
+    }
+    return undefined;
+  }
+
+  function activeTwinRefs(): TwinRef[] {
+    const refs: TwinRef[] = [];
+    for (const [providerId, state] of overlays) {
+      for (const model of state.twinIds) refs.push({ provider: providerId, model });
+    }
+    return refs;
+  }
+
   function getGateStatus(): GateStatus {
-    if (overlaidProviderId && twinTarget) {
+    const primary = primaryTwin();
+    if (primary) {
+      const count = activeTwinRefs().length;
       return {
         active: true,
-        twin: `${twinTarget.provider}/${twinIdFor(twinTarget.model)}`,
-        upstream: `${twinTarget.provider}/${twinTarget.model}`,
-        reason: `overlay attivo su ${overlaidProviderId} (stessa auth del provider)`,
+        twin: `${primary.provider}/${twinIdFor(primary.model)}`,
+        upstream: `${primary.provider}/${primary.model}`,
+        reason: `${count} twin attiv${count === 1 ? "o" : "i"} su ${overlays.size} provider (stessa auth)`,
       };
     }
     return {
@@ -99,13 +150,12 @@ export default function (pi: ExtensionAPI) {
     };
   }
 
+  /** True se la coppia provider/modello è una twin da noi registrata. */
   function isGuardedModel(provider: string | undefined, modelId: string | undefined): boolean {
-    if (!overlaidProviderId || !twinTarget || !provider || !modelId) return false;
-    return (
-      provider === twinTarget.provider &&
-      modelId === twinIdFor(twinTarget.model) &&
-      isTwinId(modelId)
-    );
+    if (!provider || !modelId || !isTwinId(modelId)) return false;
+    const state = overlays.get(provider);
+    if (!state) return false;
+    return state.twinIds.some((model) => twinIdFor(model) === modelId);
   }
 
   function refresh() {
@@ -115,18 +165,15 @@ export default function (pi: ExtensionAPI) {
     typedHandle = createTypedAsk(configSnapshot(config));
     outputCache = createVerdictCache<OutputVerdict>({ ttlSeconds: config.outputJudge.cacheSeconds });
     exfilCache = createVerdictCache<ExfilVerdict>({ ttlSeconds: config.exfilCheck.cacheSeconds });
-    return config;
+    return getConfig();
   }
 
-  /** Provider upstream vero, spacchettando il nostro overlay se già attivo. */
+  /** Provider upstream vero: il nostro upstream catturato, o il live dal registry. */
   function liveUpstreamProvider(
     registry: ModelRegistry,
     providerId: string,
   ): Provider | undefined {
-    if (overlaidProviderId === providerId) {
-      return upstreamRefs.get(providerId);
-    }
-    return registry.getProvider(providerId);
+    return overlays.get(providerId)?.upstream ?? registry.getProvider(providerId);
   }
 
   function snapshotUpstream(
@@ -147,56 +194,78 @@ export default function (pi: ExtensionAPI) {
     return { provider, model: model as Model<Api> };
   }
 
-  function applyOverlay(
-    snapshot: { provider: Provider; model: Model<Api> },
+  /** Registra (o aggiorna) l'overlay di un provider con i suoi twin. */
+  function registerOverlay(
+    providerId: string,
+    upstream: Provider,
+    twinIds: string[],
+  ): void {
+    const overlay = buildOverlaidProvider({
+      upstream,
+      twinModelIds: twinIds,
+      getConfig,
+      getReview: getGateReview,
+      onVerdict: recordGateVerdict,
+    });
+    pi.registerProvider(overlay);
+    overlays.set(providerId, { upstream, twinIds: [...twinIds] });
+  }
+
+  /**
+   * Allinea il registry ai twin richiesti: registra i provider coinvolti e
+   * ripristina (unregister) quelli che non hanno più twin.
+   */
+  function applyTwins(
+    refs: TwinRef[],
+    registry: ModelRegistry,
     persist: boolean,
-  ): UpstreamResult {
-    const providerId = snapshot.provider.id;
+  ): { ok: boolean; error?: string; twins?: string[] } {
+    const byProvider = new Map<string, string[]>();
+    for (const ref of refs) {
+      const list = byProvider.get(ref.provider) ?? [];
+      if (!list.includes(ref.model)) list.push(ref.model);
+      byProvider.set(ref.provider, list);
+    }
+
     try {
-      // Rimuovi overlay precedente su provider diverso (ripristina builtin).
-      if (overlaidProviderId && overlaidProviderId !== providerId) {
-        try {
-          pi.unregisterProvider(overlaidProviderId);
-        } catch {
-          // ignora
+      // Provider non più gemellati: unregister → builtin ripristinato.
+      for (const providerId of [...overlays.keys()]) {
+        if (!byProvider.has(providerId)) {
+          try {
+            pi.unregisterProvider(providerId);
+          } catch {
+            // ignora
+          }
+          overlays.delete(providerId);
         }
-        upstreamRefs.delete(overlaidProviderId);
       }
-      // Cattura il live PRIMA dell'override (dopo, getProvider dà l'overlay).
-      if (!upstreamRefs.has(providerId)) {
-        upstreamRefs.set(providerId, snapshot.provider);
+
+      for (const [providerId, twinIds] of byProvider) {
+        // Cattura il live PRIMA dell'override (dopo, getProvider dà l'overlay).
+        const existing = overlays.get(providerId)?.upstream;
+        const live = existing ?? registry.getProvider(providerId);
+        if (!live) return { ok: false, error: `Provider non trovato: ${providerId}` };
+        for (const model of twinIds) {
+          const has = live.getModels().some((m) => m.id === model && !isTwinId(m.id));
+          if (!has) return { ok: false, error: `Modello non trovato: ${providerId}/${model}` };
+        }
+        registerOverlay(providerId, live, twinIds);
       }
-      const overlay = buildOverlaidProvider({
-        upstream: upstreamRefs.get(providerId) as Provider,
-        twinModelIds: [snapshot.model.id],
-        getConfig,
-        getReview: getGateReview,
-        onVerdict: recordGateVerdict,
-      });
-      pi.registerProvider(overlay);
-      overlaidProviderId = providerId;
-      twinTarget = { provider: providerId, model: snapshot.model.id };
-      config = {
-        ...config,
-        automatic: {
-          ...config.automatic,
-          upstreamProvider: providerId,
-          upstreamModel: snapshot.model.id,
-        },
-      };
+
+      config = withTwinRefs(config, refs);
       if (persist) {
         try {
           saveConfig(config);
         } catch (error) {
           return {
             ok: false,
-            error: `Upstream aggiornato in memoria ma salvataggio fallito: ${
+            error: `Twin aggiornati in memoria ma salvataggio fallito: ${
               error instanceof Error ? error.message : String(error)
             }`,
           };
         }
       }
-      return { ok: true, twin: `${providerId}/${twinIdFor(snapshot.model.id)}` };
+      return { ok: true, twins: activeTwinRefs().map((r) => `${r.provider}/${twinIdFor(r.model)}`) };
     } catch (error) {
       return {
         ok: false,
@@ -205,7 +274,7 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
-  /** Crea o sposta il twin guarded (persistente). */
+  /** Aggiunge un twin (persistente). Gli altri restano attivi. */
   function setUpstream(
     registry: ModelRegistry,
     providerId: string,
@@ -213,55 +282,79 @@ export default function (pi: ExtensionAPI) {
   ): UpstreamResult {
     const found = snapshotUpstream(registry, providerId, modelId);
     if ("error" in found) return { ok: false, error: found.error };
-    return applyOverlay(found, true);
+    const refs = twinRefs(config).filter(
+      (r) => !(r.provider === providerId && r.model === modelId),
+    );
+    refs.push({ provider: providerId, model: modelId });
+    const res = applyTwins(refs, registry, true);
+    if (!res.ok) return { ok: false, error: res.error };
+    return { ok: true, twin: `${providerId}/${twinIdFor(modelId)}` };
+  }
+
+  /** Rimuove un twin; se il provider resta senza twin, ripristina il builtin. */
+  function removeTwin(
+    registry: ModelRegistry,
+    providerId: string,
+    modelId: string,
+  ): { ok: boolean; error?: string } {
+    const refs = twinRefs(config);
+    const next = refs.filter((r) => !(r.provider === providerId && r.model === modelId));
+    if (next.length === refs.length) {
+      return { ok: false, error: `twin non registrato: ${providerId}/${modelId}` };
+    }
+    const res = applyTwins(next, registry, true);
+    return res.ok ? { ok: true } : { ok: false, error: res.error };
   }
 
-  /** Riapplica l'ultimo upstream salvato in config. */
+  /** Riapplica tutti i twin salvati in config (es. dopo il riavvio). */
   function refreshUpstream(registry: ModelRegistry): UpstreamResult {
-    const found = snapshotUpstream(
-      registry,
-      config.automatic.upstreamProvider,
-      config.automatic.upstreamModel,
-    );
-    if ("error" in found) return { ok: false, error: found.error };
-    return applyOverlay(found, false);
+    const res = applyTwins(twinRefs(config), registry, false);
+    if (!res.ok) return { ok: false, error: res.error };
+    const primary = primaryTwin();
+    return {
+      ok: true,
+      twin: primary ? `${primary.provider}/${twinIdFor(primary.model)}` : undefined,
+    };
   }
 
-  /** Rimuove l'overlay (il builtin torna da solo). */
-  function removeGuarded(): { ok: boolean; error?: string } {
-    if (!overlaidProviderId) return { ok: false, error: "nessun guarded attivo" };
-    try {
-      pi.unregisterProvider(overlaidProviderId);
-    } catch (error) {
-      return {
-        ok: false,
-        error: error instanceof Error ? error.message : String(error),
-      };
+  /** Rimuove tutti gli overlay (i builtin tornano da soli). */
+  function removeGuarded(): { ok: boolean; error?: string; removed?: number } {
+    if (overlays.size === 0) return { ok: false, error: "nessun guarded attivo" };
+    const removed = overlays.size;
+    for (const providerId of [...overlays.keys()]) {
+      try {
+        pi.unregisterProvider(providerId);
+      } catch (error) {
+        return {
+          ok: false,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+      overlays.delete(providerId);
     }
-    upstreamRefs.delete(overlaidProviderId);
-    overlaidProviderId = undefined;
-    twinTarget = undefined;
-    return { ok: true };
+    return { ok: true, removed };
   }
 
-  /** Seleziona il twin attivo come modello di sessione. */
+  /** Seleziona il twin primario come modello di sessione. */
   async function switchToGuarded(
     registry: ModelRegistry,
   ): Promise<{ ok: boolean; error?: string; model?: string }> {
-    if (!overlaidProviderId || !twinTarget) {
+    if (overlays.size === 0) refreshUpstream(registry);
+    const primary = primaryTwin();
+    if (!primary) {
       return { ok: false, error: "nessun guarded attivo — prima /jev upstream <provider> <model>" };
     }
-    const twinId = twinIdFor(twinTarget.model);
-    const model = registry.find(overlaidProviderId, twinId);
+    const twinId = twinIdFor(primary.model);
+    const model = registry.find(primary.provider, twinId);
     if (!model) {
-      return { ok: false, error: `twin non in registry: ${overlaidProviderId}/${twinId}` };
+      return { ok: false, error: `twin non in registry: ${primary.provider}/${twinId}` };
     }
     try {
       const ok = await pi.setModel(model);
       if (!ok) {
-        return { ok: false, error: `auth mancante per ${overlaidProviderId} — /login ${overlaidProviderId}` };
+        return { ok: false, error: `auth mancante per ${primary.provider} — /login ${primary.provider}` };
       }
-      return { ok: true, model: `${overlaidProviderId}/${model.id}` };
+      return { ok: true, model: `${primary.provider}/${model.id}` };
     } catch (error) {
       return { ok: false, error: error instanceof Error ? error.message : String(error) };
     }
@@ -282,25 +375,25 @@ export default function (pi: ExtensionAPI) {
   registerJevCommand(pi, {
     config: getConfig,
     setMode: (mode) => {
-      config = { ...config, mode };
-      handle = createReviewer(configSnapshot(config));
-      gateHandle = createReviewer(configSnapshot(config), { rules: DEFAULT_GATE_RULES });
-      typedHandle = createTypedAsk(configSnapshot(config));
-      try {
-        saveConfig(config);
-      } catch {
-        // Resta in memoria anche se il salvataggio fallisce.
-      }
-      return config;
+      pi.appendEntry("jev-mode", { mode });
+      sessionMode = mode;
+      return getConfig();
     },
+    sharedConfig: () => config,
     reload: refresh,
     review: getReview,
     reviewerInfo: getInfo,
     metrics,
     gateStatus: getGateStatus,
+    twinStatus: () => ({
+      active: activeTwinRefs(),
+      saved: twinRefs(config),
+      primary: primaryTwin(),
+    }),
     setUpstream,
     refreshUpstream,
     removeGuarded,
+    removeTwin,
     switchToGuarded,
     getLastOutput: () => lastOutput,
     getLastGate: () => lastGate,
@@ -309,68 +402,54 @@ export default function (pi: ExtensionAPI) {
   // Seed all'avvio: pi ripristina il modello di sessione PRIMA di
   // session_start, quindi un twin persistito non esisterebbe ancora e
   // cadrebbe su "Could not restore model ...__jev". Pre-registriamo un
-  // overlay statico dai provider builtin quando la config persiste
-  // automatic (o JEV_AUTO_UPSTREAM è impostato); session_start lo
-  // sostituisce col clone live dal registry.
+  // overlay per tutti i twin salvati, anche in on-demand: il mode della
+  // sessione non è disponibile prima di session_start. Un alias non attiva il gate.
   const bootAuto = process.env.JEV_AUTO_UPSTREAM?.trim();
   const autoOff = bootAuto === "0" || bootAuto?.toLowerCase() === "off";
-  let seedTarget: { provider: string; model: string } | undefined;
+  let seedRefs: TwinRef[] = [];
   if (bootAuto && !autoOff) {
     const parsed = parseUpstreamRef([bootAuto]);
-    if (!("error" in parsed)) seedTarget = parsed;
-  } else if (!bootAuto && config.mode === "automatic") {
-    seedTarget = {
-      provider: config.automatic.upstreamProvider,
-      model: config.automatic.upstreamModel,
-    };
+    if (!("error" in parsed)) seedRefs = [parsed];
+  } else if (!bootAuto) {
+    seedRefs = twinRefs(config);
   }
-  if (seedTarget) {
-    try {
-      // providers/all è mappato dagli alias di pi; il subpath del singolo
-      // provider non lo è e fallirebbe a load (solo installazioni npm).
-      const base = builtinProviders().find((p) => p.id === seedTarget?.provider);
-      if (!base) throw new Error(`provider ${seedTarget.provider} not in builtins`);
-      // Il catalogo builtin può non avere il modello salvato: provider
-      // dinamici (es. openai-codex) tengono la lista nel models-store,
-      // altri (deepseek-flash su versioni vecchie) in una definizione statica.
-      const storeModels = readStoreModels(seedTarget.provider);
-      const extra = [
-        ...(seedTarget.provider === "deepseek" && seedTarget.model === "deepseek-flash"
-          ? [STATIC_DEEPSEEK_FLASH]
-          : []),
-        ...storeModels,
-      ];
-      const seedUpstream: Provider = {
-        ...base,
-        getModels: () => {
-          const models = base.getModels();
-          const missing = extra.filter(
-            (m) => !models.some((existing) => existing.id === m.id),
-          );
-          return [...models, ...missing];
-        },
-      };
-      const hasModel = seedUpstream
-        .getModels()
-        .some((m) => m.id === seedTarget?.model);
-      if (!hasModel) throw new Error(`model ${seedTarget.model} not in builtins`);
-      const overlay = buildOverlaidProvider({
-        upstream: seedUpstream,
-        twinModelIds: [seedTarget.model],
-        getConfig,
-        getReview: getGateReview,
-        onVerdict: recordGateVerdict,
-      });
-      pi.registerProvider(overlay);
-      upstreamRefs.set(seedTarget.provider, seedUpstream);
-      overlaidProviderId = seedTarget.provider;
-      twinTarget = { provider: seedTarget.provider, model: seedTarget.model };
-    } catch {
-      // Nessun seed: il twin arriverà da session_start se possibile.
+  if (seedRefs.length > 0) {
+    // Raggruppa per provider: un overlay per provider con tutti i suoi twin.
+    const byProvider = new Map<string, string[]>();
+    for (const ref of seedRefs) {
+      const list = byProvider.get(ref.provider) ?? [];
+      if (!list.includes(ref.model)) list.push(ref.model);
+      byProvider.set(ref.provider, list);
+    }
+    for (const [providerId, twinIds] of byProvider) {
+      try {
+        // providers/all è mappato dagli alias di pi; il subpath del singolo
+        // provider non lo è e fallirebbe a load (solo installazioni npm).
+        const base = builtinProviders().find((p) => p.id === providerId);
+        if (!base) throw new Error(`provider ${providerId} not in builtins`);
+        // Il catalogo builtin può non avere i modelli salvati: provider
+        // dinamici (es. openai-codex) li tengono nel models-store, altri
+        // (deepseek-flash su versioni vecchie) in una definizione statica.
+        const extra = [
+          ...(providerId === "deepseek" ? [STATIC_DEEPSEEK_FLASH] : []),
+          ...readStoreModels(providerId),
+        ];
+        const seedUpstream: Provider = {
+          ...base,
+          getModels: () => mergeModelsById(base.getModels(), extra),
+        };
+        const known = new Set(seedUpstream.getModels().map((m) => m.id));
+        const usable = twinIds.filter((model) => known.has(model));
+        if (usable.length === 0) continue;
+        registerOverlay(providerId, seedUpstream, usable);
+      } catch {
+        // Provider non gemellabile all'avvio: session_start riproverà dal registry.
+      }
     }
   }
 
-  pi.on("session_start", async (_event, ctx) => {
+  async function startSession(ctx: ExtensionContext): Promise<void> {
+    restoreMode(ctx);
     const auto = process.env.JEV_AUTO_UPSTREAM?.trim();
     if (auto && auto !== "0" && auto.toLowerCase() !== "off") {
       try {
@@ -382,17 +461,25 @@ export default function (pi: ExtensionAPI) {
           if ("error" in found) {
             if (ctx.hasUI) ctx.ui.notify(`JEV_AUTO_UPSTREAM fallito: ${found.error}`, "warning");
           } else {
-            applyOverlay(found, false);
+            applyTwins([parsed], ctx.modelRegistry, false);
           }
         }
       } catch {
         // Resta opt-in manuale.
       }
     }
-    // Config automatic senza guarded = contraddittorio: ripristina + seleziona.
+    // Automatic richiede il routing guarded della sessione.
     try {
-      if (config.mode !== "automatic" || !config.automatic.requireGuardedModel) return;
-      if (!overlaidProviderId || !twinTarget) {
+      if (sessionMode !== "automatic") {
+        // Reload can retain a stale alias after its registration was removed.
+        if (ctx.model && isTwinId(ctx.model.id) && !isGuardedModel(ctx.model.provider, ctx.model.id)) {
+          const original = ctx.modelRegistry.find(ctx.model.provider, untwinId(ctx.model.id));
+          if (original) await pi.setModel(original);
+        }
+        return;
+      }
+      if (!config.automatic.requireGuardedModel) return;
+      if (overlays.size === 0) {
         const restored = refreshUpstream(ctx.modelRegistry);
         if (!restored.ok) {
           if (ctx.hasUI) {
@@ -401,37 +488,51 @@ export default function (pi: ExtensionAPI) {
           return;
         }
       }
-      if (!overlaidProviderId || !twinTarget) return;
-      const twinId = twinIdFor(twinTarget.model);
-      if (ctx.model?.provider === overlaidProviderId && ctx.model?.id === twinId) return;
-      const twin = ctx.modelRegistry.find(overlaidProviderId, twinId);
+      const primary = primaryTwin();
+      if (!primary) return;
+      const twinId = twinIdFor(primary.model);
+      if (isGuardedModel(ctx.model?.provider, ctx.model?.id)) return;
+      const twin = ctx.modelRegistry.find(primary.provider, twinId);
       if (!twin) return;
       const switched = await pi.setModel(twin);
       if (ctx.hasUI) {
         ctx.ui.notify(
           switched
-            ? `Jev automatic: selezionato ${overlaidProviderId}/${twinId}.`
-            : `Jev automatic: auth mancante per ${overlaidProviderId} — /login ${overlaidProviderId}.`,
+            ? `Jev automatic: selezionato ${primary.provider}/${twinId}.`
+            : `Jev automatic: auth mancante per ${primary.provider} — /login ${primary.provider}.`,
           switched ? "info" : "warning",
         );
       }
     } catch {
       // Non bloccare l'avvio sessione.
     }
+  }
+  pi.on("session_start", async (_event, ctx) => {
+    await startSession(ctx);
+    pi.appendEntry("jev-mode", { mode: sessionMode });
   });
+  pi.on("session_tree", async (_event, ctx) => { await startSession(ctx); });
+
+  // Normalize persisted aliases even after /jev off removed their overlays.
+  // The event is a context copy: session history remains unchanged.
+  pi.on("context", async (event) => ({
+    messages: event.messages.map((message) =>
+      message.role === "assistant" && isTwinId(message.model)
+        ? { ...message, model: untwinId(message.model) }
+        : message),
+  }));
 
   // Enforcement a livello selezione: in automatic non si può restare
   // su un modello non guarded (revert immediato al twin).
   pi.on("model_select", async (event, ctx) => {
     try {
-      if (config.mode !== "automatic" || !config.automatic.requireGuardedModel) return;
-      if (!overlaidProviderId || !twinTarget) return;
+      if (sessionMode !== "automatic" || !config.automatic.requireGuardedModel) return;
+      if (overlays.size === 0) return;
       if (isGuardedModel(event.model.provider, event.model.id)) return;
 
-      const twinId = twinIdFor(twinTarget.model);
-      const twin = ctx.modelRegistry.find(overlaidProviderId, twinId);
+      const primary = primaryTwin();
       const fallback =
-        twin ??
+        (primary ? ctx.modelRegistry.find(primary.provider, twinIdFor(primary.model)) : undefined) ??
         (event.previousModel && isGuardedModel(event.previousModel.provider, event.previousModel.id)
           ? event.previousModel
           : undefined);
@@ -458,7 +559,7 @@ export default function (pi: ExtensionAPI) {
   // Jev non approva; mostra stato invece di silenzio ambiguo.
   pi.on("message_start", async (event, ctx) => {
     try {
-      if (config.mode !== "automatic" || !ctx.hasUI) return;
+      if (sessionMode !== "automatic" || !ctx.hasUI) return;
       const msg: any = event.message;
       if (msg?.role !== "assistant") return;
       const provider: string | undefined =
@@ -476,7 +577,7 @@ export default function (pi: ExtensionAPI) {
   // Policy pre-esecuzione tool (solo automatic).
   pi.on("tool_call", async (event, ctx) => {
     try {
-      if (config.mode !== "automatic") return;
+      if (sessionMode !== "automatic") return;
       if (!config.toolsPolicy.enabled) return;
 
       if (event.toolName === "bash" || event.toolName === "powershell") {
@@ -591,6 +692,7 @@ export default function (pi: ExtensionAPI) {
     const allow = await ctx.ui.confirm(
       "Jev: comando di rete sospetto",
       `${toolName}\n${summary}\n\nEseguire comunque?`,
+      { signal: ctx.signal },
     );
     return allow ? undefined : { block: true, reason: `Bloccato da jev exfil check (${summary}) (declined).` };
   }
@@ -600,7 +702,7 @@ export default function (pi: ExtensionAPI) {
   // una riga al risultato che il modello legge.
   pi.on("tool_result", async (event, ctx) => {
     try {
-      if (config.mode !== "automatic") return;
+      if (sessionMode !== "automatic") return;
       if (!config.outputJudge.enabled) return;
       if (!config.outputJudge.tools.includes(event.toolName)) return;
       if (!resolveBackend(config).apiKeyPresent) return;
@@ -666,14 +768,16 @@ export default function (pi: ExtensionAPI) {
   pi.on("message_end", async (event, ctx) => {
     try {
       if (ctx.hasUI) ctx.ui.setStatus("jev", undefined);
-      if (config.mode !== "automatic") return;
+      if (sessionMode !== "automatic") return;
       if (event.message.role !== "assistant") return;
 
       const msg = event.message as { provider?: string; model?: string };
       if (isGuardedModel(msg.provider, msg.model)) {
+        const primary = primaryTwin();
         pi.appendEntry("jev-guarded", {
-          twin: twinTarget ? `${twinTarget.provider}/${twinIdFor(twinTarget.model)}` : undefined,
-          upstream: twinTarget ? `${twinTarget.provider}/${twinTarget.model}` : undefined,
+          twin: msg.model ? `${msg.provider}/${msg.model}` : undefined,
+          upstream: primary ? `${primary.provider}/${primary.model}` : undefined,
+          active: activeTwinRefs().map((r) => `${r.provider}/${r.model}`),
         });
         return;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-jev-guard",
-  "version": "0.1.6",
+  "version": "0.2.1",
   "type": "module",
   "description": "Jev validation guard for pi: on-demand tool + automatic provider gate. Dual backend: TypeSafe direct + OpenRouter.",
   "keywords": [

package/src/automatic/overlay.ts

@@ -20,6 +20,8 @@ import type {
   SimpleStreamOptions,
 } from "@earendil-works/pi-ai";
 import type { Api } from "@earendil-works/pi-ai";
+import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
+import { emptyUsage } from "./serialize.ts";
 import type { JevConfig } from "../config.ts";
 import { configSnapshot } from "../config.ts";
 import type { ReviewFn } from "../reviewer.ts";
@@ -100,6 +102,21 @@ export function twinModelFor(
   };
 }
 
+/** Unione di liste modelli con dedup per id (il primo vince). */
+export function mergeModelsById(
+  primary: readonly Model<Api>[],
+  extra: readonly Model<Api>[],
+): Model<Api>[] {
+  const out: Model<Api>[] = [];
+  const seen = new Set<string>();
+  for (const model of [...primary, ...extra]) {
+    if (!model || typeof model.id !== "string" || seen.has(model.id)) continue;
+    seen.add(model.id);
+    out.push(model);
+  }
+  return out;
+}
+
 function stripTwins(models: readonly Model<Api>[]): Model<Api>[] {
   return models.filter((m) => !isTwinId(m.id)).map((m) => ({ ...m }));
 }
@@ -114,13 +131,17 @@ export function buildOverlaidProvider(deps: OverlayDeps): Provider {
   let twinToOriginal = new Map<string, Model<Api>>();
   let currentModels: Model<Api>[] = [];
 
-  function rebuildTwins(originals: readonly Model<Api>[]): Model<Api>[] {
+  function rebuildTwins(rawOriginals: readonly Model<Api>[]): Model<Api>[] {
     twinToOriginal = new Map();
     const chosen = new Set(deps.twinModelIds);
+    // Dedup per id: sorgenti miste (builtin + store + statica) possono
+    // ripetere lo stesso modello e produrrebbero twin duplicati.
+    const originals = mergeModelsById(stripTwins(rawOriginals), []);
     const twins: Model<Api>[] = [];
     for (const original of originals) {
       if (chosen.has(original.id)) {
         const twin = twinModelFor(original, upstream.id);
+        if (twinToOriginal.has(twin.id)) continue;
         twinToOriginal.set(twin.id, original);
         twins.push(twin);
       }
@@ -136,10 +157,19 @@ export function buildOverlaidProvider(deps: OverlayDeps): Provider {
     context: Context,
     options?: SimpleStreamOptions,
   ): AssistantMessageEventStream {
+    // Public aliases are not model changes. Preserve reasoning signatures,
+    // response phases and tool ids when replaying the transcript upstream.
+    const originalContext: Context = {
+      ...context,
+      messages: context.messages.map((message) =>
+        message.role === "assistant" && message.provider === upstream.id && isTwinId(message.model)
+          ? { ...message, model: untwinId(message.model) }
+          : message),
+    };
     if (deps.upstreamStreams) {
-      return deps.upstreamStreams.streamSimple(model, context, options);
+      return deps.upstreamStreams.streamSimple(model, originalContext, options);
     }
-    return upstream.streamSimple(model, context, options);
+    return upstream.streamSimple(model, originalContext, options);
   }
 
   function guardedStreamSimple(
@@ -148,9 +178,20 @@ export function buildOverlaidProvider(deps: OverlayDeps): Provider {
     options?: SimpleStreamOptions,
   ): AssistantMessageEventStream {
     const twinOf = twinToOriginal.get(model.id);
-    // Non gemello: passthrough esatto all'upstream.
+    // A stale/unknown alias must never leak to the upstream API, even if a
+    // dynamic refresh removed its original from the catalogue.
     if (!twinOf) {
-      return upstreamCall(model, context, options);
+      if (!isTwinId(model.id)) return upstreamCall(model, context, options);
+      const stream = createAssistantMessageEventStream();
+      const error = {
+        role: "assistant" as const, content: [], api: model.api,
+        provider: model.provider, model: model.id, usage: emptyUsage(),
+        stopReason: "error" as const, timestamp: Date.now(),
+        errorMessage: `Jev: twin non disponibile ${model.provider}/${model.id}. Ripristina con /jev upstream o seleziona il modello originale.`,
+      };
+      stream.push({ type: "error", reason: "error", error });
+      stream.end(error);
+      return stream;
     }
     const snapshot = configSnapshot(deps.getConfig());
     // Gemello in on-demand: passthrough (nessuna verifica implicita).

package/src/commands.ts

@@ -2,8 +2,16 @@ import { readFileSync, existsSync, statSync, realpathSync, writeFileSync, mkdirS
 import { resolve, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import type { ExtensionAPI, ModelRegistry } from "@earendil-works/pi-coding-agent";
-import type { JevConfig } from "./config.ts";
-import { defaultConfigPath, expandHome, parseUpstreamRef, resolveBackend, saveConfig } from "./config.ts";
+import { isTwinId, untwinId } from "./automatic/overlay.ts";
+import type { JevConfig, TwinRef } from "./config.ts";
+import {
+  defaultConfigPath,
+  expandHome,
+  parseUpstreamRef,
+  resolveBackend,
+  saveConfig,
+  twinRefs,
+} from "./config.ts";
 import type { ReviewFn } from "./reviewer.ts";
 import { reviewWithCoverage } from "./reviewer.ts";
 import type { Metrics } from "./metrics.ts";
@@ -17,6 +25,15 @@ export interface GateStatusView {
   reason: string;
 }
 
+export interface TwinStatusView {
+  /** Twin attivi adesso (overlay registrati). */
+  active: TwinRef[];
+  /** Twin salvati in config (ripristinati all'avvio/refresh). */
+  saved: TwinRef[];
+  /** Twin primario: auto-selezione e revert. */
+  primary?: TwinRef;
+}
+
 export interface UpstreamResult {
   ok: boolean;
   error?: string;
@@ -26,6 +43,8 @@ export interface UpstreamResult {
 export interface JevCommandDeps {
   config: () => JevConfig;
   setMode: (mode: "on-demand" | "automatic") => JevConfig;
+  /** Shared settings without the session-only mode override. */
+  sharedConfig?: () => JevConfig;
   reload: () => JevConfig;
   review: () => ReviewFn;
   reviewerInfo: () => { backend: string; model: string };
@@ -37,7 +56,13 @@ export interface JevCommandDeps {
     modelId: string,
   ) => UpstreamResult;
   refreshUpstream: (registry: ModelRegistry) => UpstreamResult;
-  removeGuarded: () => { ok: boolean; error?: string };
+  removeGuarded: () => { ok: boolean; error?: string; removed?: number };
+  removeTwin: (
+    registry: ModelRegistry,
+    providerId: string,
+    modelId: string,
+  ) => { ok: boolean; error?: string };
+  twinStatus: () => TwinStatusView;
   switchToGuarded: (registry: ModelRegistry) => Promise<{
     ok: boolean;
     error?: string;
@@ -52,6 +77,8 @@ export const JEV_SUBCOMMANDS = [
   "mode",
   "models",
   "upstream",
+  "twins",
+  "untwin",
   "off",
   "refresh-upstream",
   "check",
@@ -67,13 +94,15 @@ export const JEV_HELP_TEXT = [
   "Jev guard — verifica risposte con TypeSafe Jev (via OpenRouter o diretto).",
   "",
   "  /jev status              Stato: modalità, backend, policy, gate, auth",
-  "  /jev mode on-demand      Solo verifiche esplicite (default, zero costi impliciti)",
-  "  /jev mode automatic      Enforcement: seleziona il twin guarded + verifica",
+  "  /jev mode on-demand      Disattiva il gate nella sessione (scelta persistente)",
+  "  /jev mode automatic      Attiva il gate nella sessione (scelta persistente)",
   "  /jev models [filtro]     Modelli pi (● twin guarded attivo, ★ ultimo salvato)",
-  "  /jev upstream P M        Crea twin guarded M__jev dentro il provider P (salvato)",
+  "  /jev upstream P M        Aggiunge il twin M__jev nel provider P (salvato)",
   "  /jev upstream P/M        Stessa cosa in forma compatta",
-  "  /jev upstream            Riapplica l'ultimo upstream salvato",
-  "  /jev off                 Rimuove il twin (torna on-demand)",
+  "  /jev upstream            Ripristina tutti i twin salvati",
+  "  /jev twins               Elenca twin attivi e salvati (● attivo, ★ primario)",
+  "  /jev untwin P M          Rimuove un twin (anche P/M)",
+  "  /jev off                 Rimuove tutti i twin (torna on-demand)",
   "  /jev refresh-upstream    Ricrea il twin dal registry (dopo refresh cataloghi)",
   "  /jev check <file> [req]  Verifica un file subito, senza cambiare modalità",
   "  /jev stats               Conteggi pass/block/review/unavailable + latenze",
@@ -85,7 +114,7 @@ export const JEV_HELP_TEXT = [
   "",
   "Flusso tipico: /jev upstream deepseek deepseek-flash → /model (scegli __jev)",
   "→ /jev mode automatic. Il twin usa la STESSA auth del provider: nessun login extra.",
-  "Torna normale con: /model + /jev mode on-demand.",
+  "Torna normale con: /jev mode on-demand. La scelta sopravvive a /reload e /resume.",
   "Env JEV_AUTO_UPSTREAM=P/M: crea il twin all'avvio (default: nessuno;",
   "con pi --print solo deepseek/deepseek-flash).",
 ].join("\n");
@@ -104,6 +133,18 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
       const parts = args.trim().split(/\s+/).filter(Boolean);
       const sub = parts[0] ?? "status";
 
+      // Never unregister the route while a synthetic model is still selected.
+      // The caller must disable automatic enforcement before switching away.
+      async function leaveSelectedTwin(): Promise<boolean> {
+        if (!ctx.model || !isTwinId(ctx.model.id)) return true;
+        const original = ctx.modelRegistry.find(ctx.model.provider, untwinId(ctx.model.id));
+        try {
+          if (original && await pi.setModel(original)) return true;
+        } catch { /* Keep the overlay on failure. */ }
+        ctx.ui.notify("Impossibile selezionare il modello originale; twin mantenuto per evitare richieste __jev al provider.", "error");
+        return false;
+      }
+
       if (sub === "help" || sub === "--help" || sub === "-h") {
         ctx.ui.notify(JEV_HELP_TEXT, "info");
         return;
@@ -114,7 +155,8 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
         const resolved = resolveBackend(cfg);
         const info = deps.reviewerInfo();
         const gate = deps.gateStatus();
-        const authProvider = gate.upstream?.split("/")[0] ?? cfg.automatic.upstreamProvider;
+        const twinView = deps.twinStatus();
+        const authProvider = twinView.primary?.provider ?? cfg.automatic.upstreamProvider;
         let guardedAuth = "—";
         if (gate.active) {
           try {
@@ -152,20 +194,22 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
           if (m?.provider && m?.id) {
             const ref = `${m.provider}/${m.id}`;
             currentModel =
-              gate.active && ref === gate.twin ? `${ref} (twin: enforcement attivo)` : ref;
+              cfg.mode === "automatic" && twinView.active.some((r) => r.provider === m.provider && `${r.model}__jev` === m.id)
+                ? `${ref} (twin: enforcement attivo)` : ref;
           }
         } catch {
           currentModel = "sconosciuto";
         }
         ctx.ui.notify(
           [
-            `Modalità: ${cfg.mode}`,
+            `Modalità: ${cfg.mode} (salvata nella sessione)`,
             `Backend: ${info.backend} (setting=${cfg.jev.backend}, ${resolved.reason})`,
             `Modello: ${info.model}`,
             `Verificatore timeout: ${resolved.timeoutMs}ms`,
             `Policy: ${cfg.policy.revision} pass<=${cfg.policy.passMaxFlawProbability} block>=${cfg.policy.blockMinFlawProbability}`,
             `Chiave presente: ${resolved.apiKeyPresent ? "sì" : "no"} (${resolved.keySource})`,
-            `Gate: ${gate.active ? `attivo (twin ${gate.twin}, stessa auth di ${authProvider})` : `non attivo (${gate.reason})`}`,
+            `Gate: ${cfg.mode === "automatic" && gate.active ? `disponibile (twin primario ${gate.twin})` : `non attivo (${cfg.mode === "on-demand" ? "on-demand" : gate.reason})`}`,
+            `Twin attivi: ${twinView.active.length > 0 ? twinView.active.map((r) => `${r.provider}/${r.model}__jev`).join(", ") : "nessuno"}`,
             `Twin nel picker: ${twinScope}`,
             `Modello corrente: ${currentModel}`,
             `Ultimo upstream salvato: ${cfg.automatic.upstreamProvider}/${cfg.automatic.upstreamModel}`,
@@ -192,14 +236,15 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
         if (value === "automatic") {
           const sw = await deps.switchToGuarded(ctx.modelRegistry);
           ctx.ui.notify(
-            `Modalità automatic attivata. Testo/codice saranno inviati a ${deps.reviewerInfo().backend}. ` +
+            `Modalità automatic attivata per questa sessione. Testo/codice saranno inviati a ${deps.reviewerInfo().backend}. ` +
               (sw.ok
                 ? `Modello selezionato: ${sw.model} (enforcement attivo).`
                 : `ATTENZIONE: ${sw.error} (solo diagnostica, nessun enforcement).`),
             sw.ok ? "info" : "warning",
           );
         } else {
-          ctx.ui.notify("Modalità on-demand attivata. Nessuna verifica automatica.", "info");
+          await leaveSelectedTwin();
+          ctx.ui.notify("Modalità on-demand salvata per questa sessione. Nessuna verifica automatica.", "info");
         }
         return;
       }
@@ -242,12 +287,13 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
       }
 
       if (sub === "upstream") {
-        // Senza argomenti: riapplica l'ultimo upstream salvato.
+        // Senza argomenti: ripristina tutti i twin salvati.
         if (parts.length === 1) {
           const res = deps.refreshUpstream(ctx.modelRegistry);
+          const count = deps.twinStatus().active.length;
           ctx.ui.notify(
             res.ok
-              ? `Twin ripristinato: ${res.twin}. Selezionalo con /model.`
+              ? `Twin ripristinati: ${count} (primario ${res.twin ?? "—"}). Seleziona con /model.`
               : `Ripristino fallito: ${res.error}`,
             res.ok ? "info" : "error",
           );
@@ -260,26 +306,94 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
         }
         const res = deps.setUpstream(ctx.modelRegistry, parsed.provider, parsed.model);
         if (!res.ok) {
-          ctx.ui.notify(`Upstream non cambiato: ${res.error}`, "error");
+          ctx.ui.notify(`Twin non aggiunto: ${res.error}`, "error");
           return;
         }
+        const total = deps.twinStatus().active.length;
         ctx.ui.notify(
-          `Twin creato: ${res.twin} da ${parsed.provider}/${parsed.model} (salvato, stessa auth del provider). ` +
+          `Twin aggiunto: ${res.twin} (totale attivi: ${total}, stessa auth del provider). ` +
             `Selezionalo con /model per enforcement in automatic.`,
           "info",
         );
         return;
       }
 
-      if (sub === "off") {
-        const res = deps.removeGuarded();
-        if (res.ok) {
-          // Senza twin, automatic è contraddittorio: torna on-demand.
+      if (sub === "twins") {
+        const view = deps.twinStatus();
+        if (view.active.length === 0 && view.saved.length === 0) {
+          ctx.ui.notify(
+            "Jev: nessun twin — aggiungine con /jev upstream <provider> <model>.",
+            "info",
+          );
+          return;
+        }
+        const primaryKey = view.primary
+          ? `${view.primary.provider}/${view.primary.model}`
+          : undefined;
+        const activeKeys = new Set(view.active.map((r) => `${r.provider}/${r.model}`));
+        const lines: string[] = [];
+        for (const ref of view.saved) {
+          const key = `${ref.provider}/${ref.model}`;
+          const mark = activeKeys.has(key) ? "● " : "○ ";
+          const star = key === primaryKey ? "★" : " ";
+          lines.push(`${mark}${star} ${key}${activeKeys.has(key) ? "" : "  (non attivo)"}`);
+        }
+        ctx.ui.notify(
+          [
+            `Twin attivi: ${view.active.length} · salvati: ${view.saved.length}`,
+            "● registrato  ★ primario (auto-selezione/revert)",
+            "",
+            ...lines,
+          ].join("\n"),
+          "info",
+        );
+        return;
+      }
+
+      if (sub === "untwin") {
+        const parsed = parseUpstreamRef(parts.slice(1));
+        if ("error" in parsed) {
+          ctx.ui.notify(
+            `${parsed.error.replace("/jev upstream", "/jev untwin")}`,
+            "warning",
+          );
+          return;
+        }
+        const previousMode = deps.config().mode;
+        const selected = ctx.model?.provider === parsed.provider && ctx.model.id === `${parsed.model}__jev`;
+        if (selected) {
           deps.setMode("on-demand");
+          if (!await leaveSelectedTwin()) {
+            deps.setMode(previousMode);
+            return;
+          }
+        }
+        const res = deps.removeTwin(ctx.modelRegistry, parsed.provider, parsed.model);
+        const total = deps.twinStatus().active.length;
+        if (selected && previousMode === "automatic" && total > 0) {
+          deps.setMode(previousMode);
+          await deps.switchToGuarded(ctx.modelRegistry);
+        }
+        ctx.ui.notify(
+          res.ok
+            ? `Twin rimosso: ${parsed.provider}/${parsed.model} (attivi: ${total}).`
+            : `Niente da rimuovere: ${res.error}`,
+          res.ok ? "info" : "warning",
+        );
+        return;
+      }
+
+      if (sub === "off") {
+        const previousMode = deps.config().mode;
+        deps.setMode("on-demand");
+        if (!await leaveSelectedTwin()) {
+          deps.setMode(previousMode);
+          return;
         }
+        const res = deps.removeGuarded();
         ctx.ui.notify(
           res.ok
-            ? "Twin rimosso (provider originale ripristinato), modalità on-demand."
+            ? `Twin rimossi: ${res.removed ?? 0} (provider originali ripristinati), modalità on-demand.`
             : `Niente da rimuovere: ${res.error}`,
           res.ok ? "info" : "warning",
         );
@@ -383,7 +497,7 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
         // Punta la config al file e ricarica gli handle col nuovo stato.
         cfg.jev.apiKeyFile = target;
         try {
-          saveConfig(cfg);
+          saveConfig({ ...cfg, mode: deps.sharedConfig?.().mode ?? cfg.mode });
         } catch {
           // Resta in memoria anche se il salvataggio fallisce.
         }

package/src/config.ts

@@ -32,6 +32,9 @@ export interface JevConfig {
     transport: "provider-gate";
     maxRegenerations: number;
     requireGuardedModel: boolean;
+    /** Twin salvati: più modelli guarded insieme (uno o più per provider). */
+    twins: TwinRef[];
+    /** Ultimo twin aggiunto: primario per auto-selezione e revert. */
     upstreamProvider: string;
     upstreamModel: string;
   };
@@ -89,6 +92,11 @@ export interface JevConfig {
   };
 }
 
+export interface TwinRef {
+  provider: string;
+  model: string;
+}
+
 export const DEFAULT_CONFIG: JevConfig = {
   version: 1,
   mode: "on-demand",
@@ -114,8 +122,11 @@ export const DEFAULT_CONFIG: JevConfig = {
     transport: "provider-gate",
     maxRegenerations: 2,
     requireGuardedModel: true,
-    upstreamProvider: "deepseek",
-    upstreamModel: "deepseek-flash",
+    twins: [],
+    // Vuoti di default: nessun twin "salvato" finché l'utente non ne aggiunge
+    // uno con /jev upstream. Il seed usa questa lista (o l'env).
+    upstreamProvider: "",
+    upstreamModel: "",
   },
   limits: {
     maxPayloadBytes: 120000,
@@ -184,11 +195,15 @@ export function loadConfig(configPath?: string): JevConfig {
     }
   }
 
-  const merged = mergeDeep(
+  const loaded = mergeDeep(
     JSON.parse(JSON.stringify(DEFAULT_CONFIG)),
     fileConfig,
   ) as JevConfig;
 
+  // Normalizza la lista twin (config scritta a mano o da versioni vecchie):
+  // dedup, scarta voci malformate, garantisce che il primario sia incluso.
+  let merged = withTwinRefs(loaded, twinRefs(loaded));
+
   const envMode = process.env.JEV_MODE;
   if (envMode === "on-demand" || envMode === "automatic") {
     merged.mode = envMode;
@@ -352,6 +367,57 @@ export function configSnapshot(config: JevConfig): JevConfig {
   return JSON.parse(JSON.stringify(config)) as JevConfig;
 }
 
+/**
+ * Twin salvati: la lista `automatic.twins` se popolata, altrimenti il singolo
+ * upstream primario (migrazione dalle versioni precedenti). Semplifica e
+ * scarta voci malformate: la config è modificabile a mano.
+ */
+export function twinRefs(config: JevConfig): TwinRef[] {
+  const raw = Array.isArray(config.automatic.twins) ? config.automatic.twins : [];
+  const cleaned: TwinRef[] = [];
+  const seen = new Set<string>();
+  for (const entry of raw) {
+    if (!entry || typeof entry.provider !== "string" || typeof entry.model !== "string") continue;
+    const provider = entry.provider.trim();
+    const model = entry.model.trim();
+    if (!provider || !model) continue;
+    const key = `${provider}\0${model}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    cleaned.push({ provider, model });
+  }
+  if (cleaned.length > 0) return cleaned;
+  const provider = config.automatic.upstreamProvider?.trim();
+  const model = config.automatic.upstreamModel?.trim();
+  return provider && model ? [{ provider, model }] : [];
+}
+
+/**
+ * Applica una lista di twin alla config: la lista è la fonte di verità.
+ * Il campo primario (auto-selezione/revert) resta se già presente nella
+ * lista, altrimenti diventa l'ultimo aggiunto.
+ */
+export function withTwinRefs(config: JevConfig, refs: TwinRef[]): JevConfig {
+  const primary = refs.find(
+    (r) =>
+      r.provider === config.automatic.upstreamProvider &&
+      r.model === config.automatic.upstreamModel,
+  ) ?? refs[refs.length - 1];
+  return {
+    ...config,
+    automatic: {
+      ...config.automatic,
+      twins: refs.map((r) => ({ ...r })),
+      upstreamProvider: primary?.provider ?? "",
+      upstreamModel: primary?.model ?? "",
+    },
+  };
+}
+
+export function twinKey(ref: TwinRef): string {
+  return `${ref.provider}/${ref.model}`;
+}
+
 export function saveConfig(config: JevConfig, configPath?: string): string {
   const path = configPath ?? defaultConfigPath();
   mkdirSync(dirname(path), { recursive: true });