pi-jev-guard 0.1.5 → 0.2.0

package/README.md

@@ -39,21 +39,34 @@ 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), quindi la sessione riapre
+direttamente sul `__jev` senza warning. Il **primario** (ultimo aggiunto, o
+quello salvato come tale) è il target di auto-selezione e revert.
+
+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`.
 
 Torna normale con `/model` (modello normale) + `/jev mode on-demand`.
 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.
+`/jev upstream` senza argomenti ripristina tutti i twin salvati, `/jev untwin P M`
+ne rimuove uno solo, `/jev off` li rimuove tutti
+(e torna a on-demand, provider originali ripristinati). In `automatic` i twin
+si ripristinano da soli al riavvio.
 
-Se filtri i modelli con `enabledModels`, tieni la voce del twin (es.
-`deepseek/deepseek-flash__jev`) o resta nascosto.
+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

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,8 +1,7 @@
 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,
@@ -10,7 +9,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";
@@ -19,11 +21,12 @@ import {
   STATIC_DEEPSEEK_FLASH,
   buildOverlaidProvider,
   isTwinId,
+  mergeModelsById,
   twinIdFor,
 } from "../src/automatic/overlay.ts";
 import type { GateVerdictReport } from "../src/automatic/guardian.ts";
-import { DEFAULT_GATE_RULES } from "../src/reviewer.ts";
-import { elideWithMarker } from "../src/reviewer.ts";
+import { readStoreModels } from "../src/store-models.ts";
+import { DEFAULT_GATE_RULES, elideWithMarker } from "../src/reviewer.ts";
 import {
   TOOL_POLICY_REVISION,
   checkFilePath,
@@ -74,24 +77,56 @@ 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 {
@@ -100,13 +135,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() {
@@ -119,15 +153,12 @@ export default function (pi: ExtensionAPI) {
     return config;
   }
 
-  /** 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(
@@ -148,56 +179,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,
@@ -206,7 +259,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,
@@ -214,55 +267,78 @@ 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)}` };
   }
 
-  /** Riapplica l'ultimo upstream salvato in config. */
+  /** 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 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) {
+    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) };
     }
@@ -299,9 +375,15 @@ export default function (pi: ExtensionAPI) {
     reviewerInfo: getInfo,
     metrics,
     gateStatus: getGateStatus,
+    twinStatus: () => ({
+      active: activeTwinRefs(),
+      saved: twinRefs(config),
+      primary: primaryTwin(),
+    }),
     setUpstream,
     refreshUpstream,
     removeGuarded,
+    removeTwin,
     switchToGuarded,
     getLastOutput: () => lastOutput,
     getLastGate: () => lastGate,
@@ -315,55 +397,45 @@ export default function (pi: ExtensionAPI) {
   // sostituisce col clone live dal registry.
   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;
+    if (!("error" in parsed)) seedRefs = [parsed];
   } else if (!bootAuto && config.mode === "automatic") {
-    seedTarget = {
-      provider: config.automatic.upstreamProvider,
-      model: config.automatic.upstreamModel,
-    };
+    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 (es. versioni
-      // più vecchie senza deepseek-flash): uniamo la definizione statica.
-      const extra =
-        seedTarget.provider === "deepseek" && seedTarget.model === "deepseek-flash"
-          ? [STATIC_DEEPSEEK_FLASH]
-          : [];
-      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.
+      }
     }
   }
 
@@ -379,7 +451,7 @@ 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 {
@@ -389,7 +461,7 @@ export default function (pi: ExtensionAPI) {
     // Config automatic senza guarded = contraddittorio: ripristina + seleziona.
     try {
       if (config.mode !== "automatic" || !config.automatic.requireGuardedModel) return;
-      if (!overlaidProviderId || !twinTarget) {
+      if (overlays.size === 0) {
         const restored = refreshUpstream(ctx.modelRegistry);
         if (!restored.ok) {
           if (ctx.hasUI) {
@@ -398,17 +470,18 @@ 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 (ctx.model?.provider === primary.provider && ctx.model?.id === twinId) 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",
         );
       }
@@ -422,13 +495,12 @@ export default function (pi: ExtensionAPI) {
   pi.on("model_select", async (event, ctx) => {
     try {
       if (config.mode !== "automatic" || !config.automatic.requireGuardedModel) return;
-      if (!overlaidProviderId || !twinTarget) 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);
@@ -668,9 +740,11 @@ export default function (pi: ExtensionAPI) {
 
       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.5",
+  "version": "0.2.0",
   "type": "module",
   "description": "Jev validation guard for pi: on-demand tool + automatic provider gate. Dual backend: TypeSafe direct + OpenRouter.",
   "keywords": [
@@ -46,5 +46,11 @@
     "typebox": "1.3.34",
     "typescript": "5.9.3",
     "vitest": "5.0.1"
+  },
+  "allowScripts": {
+    "@google/genai@1.52.0": true,
+    "@openrouter/sdk@1.3.1": true,
+    "protobufjs@7.6.6": true,
+    "esbuild@0.28.2": true
   }
 }

package/src/automatic/overlay.ts

@@ -100,6 +100,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 +129,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(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);
       }

package/src/commands.ts

@@ -2,8 +2,15 @@ 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 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 +24,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;
@@ -37,7 +53,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 +74,8 @@ export const JEV_SUBCOMMANDS = [
   "mode",
   "models",
   "upstream",
+  "twins",
+  "untwin",
   "off",
   "refresh-upstream",
   "check",
@@ -70,10 +94,12 @@ export const JEV_HELP_TEXT = [
   "  /jev mode on-demand      Solo verifiche esplicite (default, zero costi impliciti)",
   "  /jev mode automatic      Enforcement: seleziona il twin guarded + verifica",
   "  /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",
@@ -114,7 +140,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 {
@@ -165,7 +192,8 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
             `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: ${gate.active ? `attivo (twin ${gate.twin})` : `non attivo (${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}`,
@@ -242,12 +270,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,17 +289,70 @@ 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 === "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 res = deps.removeTwin(ctx.modelRegistry, parsed.provider, parsed.model);
+        const total = deps.twinStatus().active.length;
+        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 res = deps.removeGuarded();
         if (res.ok) {
@@ -279,7 +361,7 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
         }
         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",
         );

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,56 @@ 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 })),
+      ...(primary ? { 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 });

package/src/store-models.ts

@@ -0,0 +1,47 @@
+/**
+ * Lettura read-only dei modelli dinamici dal models-store di pi.
+ *
+ * Alcuni provider (es. openai-codex) non hanno modelli nel catalogo statico:
+ * la lista arriva da `<agentDir>/models-store.json` e viene popolata al
+ * refresh con le credenziali. Senza questo, il seed all'avvio non troverebbe
+ * il modello e il twin non esisterebbe al momento del ripristino sessione.
+ *
+ * Solo lettura, best-effort: file assente/corrotto → nessun modello.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { Api, Model } from "@earendil-works/pi-ai";
+
+export function modelsStorePath(agentDir?: string): string {
+  return join(agentDir ?? getAgentDir(), "models-store.json");
+}
+
+function isUsableModel(value: unknown, providerId: string): value is Model<Api> {
+  if (typeof value !== "object" || value === null) return false;
+  const m = value as Record<string, unknown>;
+  return (
+    typeof m.id === "string" &&
+    m.id.length > 0 &&
+    typeof m.api === "string" &&
+    m.api.length > 0 &&
+    (m.provider === undefined || m.provider === providerId)
+  );
+}
+
+/** Modelli salvati nello store per un provider, normalizzati sull'id richiesto. */
+export function readStoreModels(providerId: string, agentDir?: string): Model<Api>[] {
+  try {
+    const raw = JSON.parse(readFileSync(modelsStorePath(agentDir), "utf8")) as Record<
+      string,
+      { models?: unknown }
+    >;
+    const entry = raw?.[providerId];
+    const models = Array.isArray(entry?.models) ? entry.models : [];
+    return models
+      .filter((m) => isUsableModel(m, providerId))
+      .map((m) => ({ ...(m as Model<Api>), provider: providerId }));
+  } catch {
+    return [];
+  }
+}