pi-jev-guard 0.6.0 → 0.7.0

package/extensions/index.ts

@@ -1,19 +1,15 @@
 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 { registerJevCommand, type UpstreamResult } from "../src/commands.ts";
+import { registerJevCommand } from "../src/commands.ts";
 import { registerJevAskTool } from "../src/ask.ts";
 import { registerVerificationTool, type VerificationToolRunResult } from "../src/verification-tool.ts";
 import {
   configSnapshot,
   loadConfig,
-  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";
@@ -22,7 +18,6 @@ import {
   isPatched,
   isTwinId,
   patchProvider,
-  twinIdFor,
   unpatchProvider,
   untwinId,
 } from "../src/automatic/overlay.ts";
@@ -89,16 +84,12 @@ import {
 
 export interface GateStatus {
   active: boolean;
-  /** Ref twin "provider/id__jev" quando attivo. */
-  twin?: string;
-  /** Ref upstream originale "provider/id" quando attivo. */
-  upstream?: string;
   reason: string;
 }
 
 export default function (pi: ExtensionAPI) {
   let config: JevConfig = loadConfig();
-  // Shared config holds credentials/policy/twins, not the session toggle.
+  // Shared config holds credentials/policy, not the session toggle.
   const initialMode = process.env.JEV_MODE === "automatic" ? "automatic" : "on-demand";
   let sessionMode: JevConfig["mode"] = initialMode;
   function getConfig(): JevConfig {
@@ -145,71 +136,32 @@ export default function (pi: ExtensionAPI) {
   let lastGroundingErrorAt = 0;
   const metrics = createMetrics();
 
-  // Twin attivi, uno o più per provider. Patch in-place sull'oggetto live:
-  // nessuna (ri-)registrazione, quindi nessun conflitto di ownership con
-  // altre estensioni (es. pi-accounts) e nessuna entry spuria nel registry.
-  interface OverlayState {
-    twinIds: string[];
-    /** Oggetto live patchato (per unpatch mirato senza registry). */
-    live?: Provider;
-  }
-  const overlays = new Map<string, OverlayState>();
+  // Provider patchati in-place (id → oggetto live). Nessuna (ri-)registrazione:
+  // nessun conflitto di ownership con altre estensioni (es. pi-accounts) e
+  // nessuna entry spuria nel registry.
+  const patchedProviders = new Map<string, Provider>();
 
   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 {
-    const primary = primaryTwin();
-    if (primary) {
-      const count = activeTwinRefs().length;
-      return {
-        active: true,
-        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 {
-      active: false,
-      reason: "nessun guarded attivo — usa /jev upstream <provider> <model>",
-    };
+    return sessionMode === "automatic"
+      ? { active: true, reason: "gate attivo sul modello selezionato (e su ogni cambio modello)" }
+      : { active: false, reason: "nessun gate — usa /jev mode automatic" };
   }
 
-  /** True se la coppia provider/modello è una twin da noi registrata. */
-  function isGuardedModel(provider: string | undefined, modelId: string | undefined): boolean {
-    if (!provider || !modelId || !isTwinId(modelId)) return false;
-    const state = overlays.get(provider);
-    if (!state) return false;
-    return state.twinIds.some((model) => twinIdFor(model) === modelId);
+  /**
+   * True se le richieste del provider passano davvero dal gate (automatic +
+   * patch applicata). Usato per l'audit (`jev-guarded`) e la diagnostica.
+   */
+  function gateActiveFor(
+    registry: ModelRegistry | undefined,
+    provider: string | undefined,
+  ): boolean {
+    if (sessionMode !== "automatic" || !provider || !registry) return false;
+    const live = liveUpstreamProvider(registry, provider);
+    return Boolean(live && isPatched(live));
   }
 
   function refresh() {
@@ -333,28 +285,9 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
-  function snapshotUpstream(
-    registry: ModelRegistry,
-    providerId: string,
-    modelId: string,
-  ): { provider: Provider; model: Model<Api> } | { error: string } {
-    const provider = liveUpstreamProvider(registry, providerId);
-    if (!provider) {
-      return { error: `Provider non trovato: ${providerId}` };
-    }
-    const model = provider
-      .getModels()
-      .find((m) => m.id === modelId && !isTwinId(m.id));
-    if (!model) {
-      return { error: `Modello non trovato: ${providerId}/${modelId}` };
-    }
-    return { provider, model: model as Model<Api> };
-  }
-
   /** Applica (o aggiorna) la patch gate sull'oggetto provider live. */
-  function patchLiveProvider(live: Provider, twinIds: string[]): string[] {
-    return patchProvider(live, {
-      twinModelIds: twinIds,
+  function patchLiveProvider(live: Provider): void {
+    patchProvider(live, {
       getConfig,
       getReview: getGateReview,
       onVerdict: recordGateVerdict,
@@ -363,33 +296,34 @@ export default function (pi: ExtensionAPI) {
   }
 
   /**
-   * Assicura la patch su tutti i twin attivi contro il provider live
-   * corrente. Se un'altra estensione (es. pi-accounts) ha sostituito
-   * l'oggetto, il nuovo viene patchato ex-novo; se l'oggetto è lo stesso
-   * ma non patchato, viene patchato. Non chiama mai register/unregister:
-   * la config del proprietario resta intatta e i suoi controlli di
-   * ownership non vedono alcuna "configuration changed".
+   * Assicura la patch sul provider del modello in uso (e su quelli già
+   * patchati). Se un'altra estensione (es. pi-accounts) ha sostituito
+   * l'oggetto, il nuovo viene patchato ex-novo. Non chiama mai
+   * register/unregister: la config del proprietario resta intatta e i suoi
+   * controlli di ownership non vedono alcuna "configuration changed".
    * Ritorna i provider (ri-)patchati in questa chiamata.
    */
-  function ensurePatches(registry: ModelRegistry): string[] {
+  function ensurePatches(registry: ModelRegistry, providerId?: string): string[] {
     // Re-patch sempre (idempotente ed economico): dopo un /reload la factory
-    // è nuova ma gli oggetti restano patchati con le closure vecchie, e la
-    // lista twin potrebbe essere cambiata. Si segnalano solo i provider che
-    // non erano patchati, per non spammare entry diagnostiche a ogni hook.
+    // è nuova ma gli oggetti restano patchati con le closure vecchie. Si
+    // segnalano solo i provider che non erano patchati, per non spammare
+    // entry diagnostiche a ogni hook.
     const patched: string[] = [];
-    for (const [providerId, state] of [...overlays]) {
+    const wanted = new Set([...patchedProviders.keys()]);
+    if (providerId) wanted.add(providerId);
+    for (const id of wanted) {
       let live: Provider | undefined;
       try {
-        live = registry.getProvider(providerId);
+        live = registry.getProvider(id);
       } catch {
         continue;
       }
       if (!live) continue;
       const was = isPatched(live);
       try {
-        patchLiveProvider(live, state.twinIds);
-        state.live = live;
-        if (!was) patched.push(providerId);
+        patchLiveProvider(live);
+        patchedProviders.set(id, live);
+        if (!was) patched.push(id);
       } catch {
         // Riprova al prossimo hook; mai bloccare il flusso.
       }
@@ -397,164 +331,23 @@ export default function (pi: ExtensionAPI) {
     return patched;
   }
 
-  /**
-   * 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,
-  ): { 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 {
-      // Provider non più gemellati: ripristina i metodi originali (l'oggetto
-      // resta del proprietario: nessuna unregister che spiazzi gli altri).
-      for (const providerId of [...overlays.keys()]) {
-        if (!byProvider.has(providerId)) {
-          try {
-            const live = registry.getProvider(providerId);
-            if (live) unpatchProvider(live);
-          } catch {
-            // ignora
-          }
-          overlays.delete(providerId);
-        }
-      }
-
-      for (const [providerId, twinIds] of byProvider) {
-        // Sempre il live corrente: con la patch non esistono chain di
-        // upstream stale da preservare.
-        const live = liveUpstreamProvider(registry, 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}` };
-        }
-        try {
-          patchLiveProvider(live, twinIds);
-        } catch (error) {
-          return {
-            ok: false,
-            error: error instanceof Error ? error.message : String(error),
-          };
-        }
-        overlays.set(providerId, { twinIds: [...twinIds], live });
-      }
-
-      config = withTwinRefs(config, refs);
-      if (persist) {
-        try {
-          saveConfig(config);
-        } catch (error) {
-          return {
-            ok: false,
-            error: `Twin aggiornati in memoria ma salvataggio fallito: ${
-              error instanceof Error ? error.message : String(error)
-            }`,
-          };
-        }
-      }
-      return { ok: true, twins: activeTwinRefs().map((r) => `${r.provider}/${twinIdFor(r.model)}`) };
-    } catch (error) {
-      return {
-        ok: false,
-        error: error instanceof Error ? error.message : String(error),
-      };
-    }
-  }
-
-  /** Aggiunge un twin (persistente). Gli altri restano attivi. */
-  function setUpstream(
-    registry: ModelRegistry,
-    providerId: string,
-    modelId: string,
-  ): UpstreamResult {
-    const found = snapshotUpstream(registry, providerId, modelId);
-    if ("error" in found) return { ok: false, error: found.error };
-    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 tutti i twin salvati in config (es. dopo il riavvio). */
-  function refreshUpstream(registry: ModelRegistry): UpstreamResult {
-    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 tutte le patch (i metodi originali 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;
+    if (patchedProviders.size === 0) return { ok: false, error: "nessun provider patchato" };
+    const removed = patchedProviders.size;
     // Nessuna unregister: gli oggetti restano del proprietario, si
     // ripristinano solo i metodi sugli oggetti che abbiamo patchato.
-    for (const state of [...overlays.values()]) {
+    for (const live of patchedProviders.values()) {
       try {
-        if (state.live) unpatchProvider(state.live);
+        unpatchProvider(live);
       } catch {
         // ignora
       }
     }
-    overlays.clear();
+    patchedProviders.clear();
     return { ok: true, removed };
   }
 
-  /** Seleziona il twin primario come modello di sessione. */
-  async function switchToGuarded(
-    registry: ModelRegistry,
-  ): Promise<{ ok: boolean; error?: string; model?: string }> {
-    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(primary.model);
-    const model = registry.find(primary.provider, twinId);
-    if (!model) {
-      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 ${primary.provider} — /login ${primary.provider}` };
-      }
-      return { ok: true, model: `${primary.provider}/${model.id}` };
-    } catch (error) {
-      return { ok: false, error: error instanceof Error ? error.message : String(error) };
-    }
-  }
-
   registerJevTool(pi, {
     review: getReview,
     config: getConfig,
@@ -582,16 +375,7 @@ 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,
     groundingStatus: () => ({
       enabled: config.grounding.enabled,
@@ -653,10 +437,8 @@ export default function (pi: ExtensionAPI) {
   // NOTA: nessun seed di boot con oggetti fake. La patch lavora SOLO
   // sull'oggetto live del registry: registrare un oggetto nostro
   // cancellerebbe la config del proprietario (es. pi-accounts vedrebbe
-  // "configuration changed" e abortirebbe i turni). I twin salvati vengono
-  // patchati a session_start (ogni modalità) e il twin automatic viene
-  // riselezionato lì; un twin persistito non ripristinabile cade sul modello
-  // di default e startSession lo riseleziona.
+  // "configuration changed" e abortirebbe i turni). La patch del provider
+  // del modello in uso parte a session_start e viene ricucita a ogni hook.
 
   async function startSession(ctx: ExtensionContext): Promise<void> {
     restoreMode(ctx);
@@ -667,71 +449,16 @@ export default function (pi: ExtensionAPI) {
     verificationSeq = 0;
     verificationCheckStarts.clear();
     captureVerificationManifest(ctx.cwd);
-    // Patch dei twin salvati in OGNI modalità (nessun setModel qui): senza,
-    // un twin persistito non esisterebbe nel catalogo. Silenzioso: la
-    // diagnostica resta agli hook di turno.
-    try {
-      if (twinRefs(config).length > 0) {
-        applyTwins(twinRefs(config), ctx.modelRegistry, false);
-      }
-    } catch {
-      // session_start non deve mai fallire per il seed.
-    }
-    const auto = process.env.JEV_AUTO_UPSTREAM?.trim();
-    if (auto && auto !== "0" && auto.toLowerCase() !== "off") {
-      try {
-        const parsed = parseUpstreamRef([auto]);
-        if ("error" in parsed) {
-          if (ctx.hasUI) ctx.ui.notify(`JEV_AUTO_UPSTREAM non valido: ${parsed.error}`, "warning");
-        } else {
-          const found = snapshotUpstream(ctx.modelRegistry, parsed.provider, parsed.model);
-          if ("error" in found) {
-            if (ctx.hasUI) ctx.ui.notify(`JEV_AUTO_UPSTREAM fallito: ${found.error}`, "warning");
-          } else {
-            applyTwins([parsed], ctx.modelRegistry, false);
-          }
-        }
-      } catch {
-        // Resta opt-in manuale.
-      }
-    }
-    // Automatic richiede il routing guarded della sessione.
     try {
-      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) {
-            ctx.ui.notify(`Jev automatic senza guarded: ${restored.error} (diagnostica sola).`, "warning");
-          }
-          return;
-        }
-      }
-      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 ${primary.provider}/${twinId}.`
-            : `Jev automatic: auth mancante per ${primary.provider} — /login ${primary.provider}.`,
-          switched ? "info" : "warning",
-        );
+      // Alias legacy __jev (versioni <= 0.6.x) selezionato: torna all'originale.
+      if (ctx.model && isTwinId(ctx.model.id)) {
+        const original = ctx.modelRegistry.find(ctx.model.provider, untwinId(ctx.model.id));
+        if (original) await pi.setModel(original);
       }
+      // Patch del provider del modello in uso (silenziosa).
+      ensurePatches(ctx.modelRegistry, ctx.model?.provider);
     } catch {
-      // Non bloccare l'avvio sessione.
+      // session_start non deve mai fallire.
     }
   }
   pi.on("session_start", async (_event, ctx) => {
@@ -741,64 +468,23 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_tree", async (_event, ctx) => { await startSession(ctx); });
 
   /**
-   * Assicura gli overlay PRIMA di qualsiasi before_agent_start (evento input).
-   * Un'altra estensione (pi-accounts) legge il registry nel suo
-   * before_agent_start per decidere i modelli disponibili dell'account e,
-   * se il twin non c'è, arma l'abort del turno ("This operation was
-   * aborted" istantaneo su turn_start). Il seed precoce rende i twin
-   * visibili a quella lettura, indipendentemente dall'ordine di load.
-   * Silenzioso: nessuna entry diagnostica qui (l'input arriva a ogni
-   * prompt); la diagnostica resta nel reassert di before_agent_start.
-   * Vale in ogni modalità: anche in on-demand il twin passthrough ha
-   * bisogno dell'overlay registrato (altrimenti l'id __jev finisce all'API).
+   * Assicura la patch PRIMA di ogni turno (evento input): un'altra
+   * estensione (pi-accounts) legge il registry nel suo before_agent_start e
+   * l'ordine di load non è garantito. Silenzioso: nessuna entry diagnostica
+   * qui (l'input arriva a ogni prompt); la diagnostica resta negli hook di
+   * turno. Vale in ogni modalità: la patch serve anche in on-demand per
+   * normalizzare gli alias legacy __jev che non devono mai finire all'API.
    */
-  function ensureOverlays(registry: ModelRegistry): void {
+  pi.on("input", async (_event, ctx) => {
     try {
-      const refs = twinRefs(config);
-      if (refs.length === 0) return;
-      // Ricuci le patch su oggetti sostituiti dal proprietario.
-      ensurePatches(registry);
-      // Patch ex-novo i provider gemellati senza stato (seed precoce).
-      const byProvider = new Map<string, string[]>();
-      for (const ref of refs) {
-        if (overlays.get(ref.provider)?.twinIds.includes(ref.model)) continue;
-        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) {
-        let live: Provider | undefined;
-        try {
-          live = registry.getProvider(providerId);
-        } catch {
-          continue;
-        }
-        if (!live || isPatched(live)) {
-          if (live) overlays.set(providerId, { twinIds: [...twinIds], live });
-          continue;
-        }
-        const models = live.getModels();
-        if (!twinIds.every((id) => models.some((m) => m.id === id && !isTwinId(m.id)))) {
-          continue;
-        }
-        try {
-          patchLiveProvider(live, twinIds);
-          overlays.set(providerId, { twinIds: [...twinIds], live });
-        } catch {
-          // Riprova al prossimo hook; mai bloccare l'input.
-        }
-      }
+      ensurePatches(ctx.modelRegistry, ctx.model?.provider);
     } catch {
-      // Mai bloccare l'input per il seed.
+      // Mai bloccare l'input.
     }
-  }
-
-  pi.on("input", async (_event, ctx) => {
-    ensureOverlays(ctx.modelRegistry);
   });
 
   // Prima di ogni turno: se un'altra estensione ci ha scalzati dal provider,
-  // rimettiamo l'overlay (altrimenti l'id __jev arriverebbe all'API).
+  // rimettiamo la patch (il gate resterebbe altrimenti bypassato).
   function noteReassert(fixed: string[]): void {
     if (fixed.length === 0) return;
     try {
@@ -813,7 +499,7 @@ export default function (pi: ExtensionAPI) {
   pi.on("turn_start", async (_event, ctx) => {
     try {
       verificationCwd = ctx.cwd;
-      ensurePatches(ctx.modelRegistry);
+      ensurePatches(ctx.modelRegistry, ctx.model?.provider);
     } catch {
       // Mai bloccare il turno.
     }
@@ -822,7 +508,7 @@ export default function (pi: ExtensionAPI) {
   pi.on("before_agent_start", async (_event, ctx) => {
     try {
       verificationCwd = ctx.cwd;
-      noteReassert(ensurePatches(ctx.modelRegistry));
+      noteReassert(ensurePatches(ctx.modelRegistry, ctx.model?.provider));
     } catch {
       // mai bloccare il turno
     }
@@ -872,38 +558,20 @@ export default function (pi: ExtensionAPI) {
         : message),
   }));
 
-  // Enforcement a livello selezione: in automatic non si può restare
-  // su un modello non guarded (revert immediato al twin).
+  // Cambio modello: ripatcha il nuovo provider (il gate segue la selezione)
+  // e normalizza gli alias legacy __jev ancora selezionati.
   pi.on("model_select", async (event, ctx) => {
     try {
       // Una selezione account/provider può aver sostituito l'oggetto: ripatcha.
-      noteReassert(ensurePatches(ctx.modelRegistry));
-      if (sessionMode !== "automatic" || !config.automatic.requireGuardedModel) return;
-      if (overlays.size === 0) return;
-      if (isGuardedModel(event.model.provider, event.model.id)) return;
-
-      const primary = primaryTwin();
-      const fallback =
-        (primary ? ctx.modelRegistry.find(primary.provider, twinIdFor(primary.model)) : undefined) ??
-        (event.previousModel && isGuardedModel(event.previousModel.provider, event.previousModel.id)
-          ? event.previousModel
-          : undefined);
-      if (fallback) {
-        await pi.setModel(fallback);
-        if (ctx.hasUI) {
-          ctx.ui.notify(
-            `Jev automatic: modello non protetto rifiutato, ripristinato ${fallback.provider}/${fallback.id}. Per usarlo esplicitamente: /jev mode on-demand.`,
-            "warning",
-          );
+      noteReassert(ensurePatches(ctx.modelRegistry, event.model.provider));
+      if (isTwinId(event.model.id)) {
+        const original = ctx.modelRegistry.find(event.model.provider, untwinId(event.model.id));
+        if (original && await pi.setModel(original) && ctx.hasUI) {
+          ctx.ui.notify("Jev: alias legacy __jev normalizzato al modello originale.", "info");
         }
-      } else if (ctx.hasUI) {
-        ctx.ui.notify(
-          "Jev automatic senza guarded disponibile: enforcement assente (diagnostica sola).",
-          "warning",
-        );
       }
     } catch {
-      // Mai rompere il cambio modello per l'enforcement.
+      // Mai rompere il cambio modello.
     }
   });
 
@@ -916,9 +584,7 @@ export default function (pi: ExtensionAPI) {
       if (msg?.role !== "assistant") return;
       const provider: string | undefined =
         typeof msg?.provider === "string" ? msg.provider : ctx.model?.provider;
-      const id: string | undefined =
-        typeof msg?.model === "string" ? msg.model : (ctx.model as any)?.id;
-      if (provider && id && isGuardedModel(provider, id)) {
+      if (gateActiveFor(ctx.modelRegistry, provider)) {
         ctx.ui.setStatus("jev", "Jev: verifica in corso (output trattenuto)");
       }
     } catch {
@@ -1503,29 +1169,24 @@ export default function (pi: ExtensionAPI) {
       if (ctx.hasUI) ctx.ui.setStatus("jev", undefined);
       // Dopo la richiesta: se qualcuno ha sostituito l'oggetto, ripatcha
       // per il turno successivo (il payload resta già normalizzato).
-      noteReassert(ensurePatches(ctx.modelRegistry));
+      noteReassert(ensurePatches(ctx.modelRegistry, ctx.model?.provider));
       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();
+      if (gateActiveFor(ctx.modelRegistry, msg.provider ?? ctx.model?.provider)) {
+        // Audit del turno gated: il gate ha già deciso safety/repair/hold.
         pi.appendEntry("jev-guarded", {
-          twin: msg.model ? `${msg.provider}/${msg.model}` : undefined,
-          upstream: primary ? `${primary.provider}/${primary.model}` : undefined,
-          active: activeTwinRefs().map((r) => `${r.provider}/${r.model}`),
+          model: msg.provider && msg.model ? `${msg.provider}/${msg.model}` : undefined,
         });
         return;
       }
 
-      const gate = getGateStatus();
-      if (config.automatic.requireGuardedModel && !gate.active) {
-        if (ctx.hasUI) {
-          ctx.ui.notify(
-            "Jev automatic senza guarded attivo: enforcement assente (diagnostica sola). Usa /jev upstream <provider> <model> e seleziona il modello col suffisso __jev.",
-            "warning",
-          );
-        }
+      if (ctx.hasUI) {
+        ctx.ui.notify(
+          "Jev: turno non passato dal gate (provider non patchato) — solo diagnostica.",
+          "warning",
+        );
       }
 
       const candidate = event.message.content