pi-jev-guard 0.2.0 → 0.2.2

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
@@ -48,29 +56,49 @@ In chat, l'LLM può chiamare `jev_validate` per controlli mirati.
 
 **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.
+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 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.
+(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`, usa i glob invece delle voci esplicite,
+così i twin futuri non restano nascosti:
+
+```json
+"enabledModels": ["openai-codex/*__jev", "deepseek/*__jev", "...altri pattern..."]
+```
 
-Se filtri i modelli con `enabledModels`, tieni le voci `__jev` dei twin che usi
-o restano nascosti.
+Dopo aver aggiunto un twin serve `/reload` (lo scope è risolto all'avvio della sessione).
+`/jev upstream` avvisa subito quando il twin appena creato è fuori dal picker.
 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.
+
+Verdetto **incerto** (`review`): il gate tenta prima una riga riparazione privata
+(`automatic.repairOnReview`, default `true`), poi applica la policy configurata:
+`policy.onUncertain` e `policy.onUnavailable` (`"hold"` default, oppure `"pass"`).
+Con `"pass"` il testo viene pubblicato con una nota di trasparenza sul verdetto.
+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/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,
@@ -23,6 +24,7 @@ import {
   isTwinId,
   mergeModelsById,
   twinIdFor,
+  untwinId,
 } from "../src/automatic/overlay.ts";
 import type { GateVerdictReport } from "../src/automatic/guardian.ts";
 import { readStoreModels } from "../src/store-models.ts";
@@ -61,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 });
@@ -85,7 +101,6 @@ export default function (pi: ExtensionAPI) {
   }
   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 });
@@ -150,7 +165,7 @@ 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: il nostro upstream catturato, o il live dal registry. */
@@ -324,6 +339,7 @@ export default function (pi: ExtensionAPI) {
   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>" };
@@ -359,17 +375,11 @@ 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,
@@ -392,16 +402,15 @@ 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 seedRefs: TwinRef[] = [];
   if (bootAuto && !autoOff) {
     const parsed = parseUpstreamRef([bootAuto]);
     if (!("error" in parsed)) seedRefs = [parsed];
-  } else if (!bootAuto && config.mode === "automatic") {
+  } else if (!bootAuto) {
     seedRefs = twinRefs(config);
   }
   if (seedRefs.length > 0) {
@@ -439,7 +448,8 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
-  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 {
@@ -458,9 +468,17 @@ export default function (pi: ExtensionAPI) {
         // 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 (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) {
@@ -473,7 +491,7 @@ export default function (pi: ExtensionAPI) {
       const primary = primaryTwin();
       if (!primary) return;
       const twinId = twinIdFor(primary.model);
-      if (ctx.model?.provider === primary.provider && ctx.model?.id === twinId) return;
+      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);
@@ -488,13 +506,27 @@ export default function (pi: ExtensionAPI) {
     } 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 (sessionMode !== "automatic" || !config.automatic.requireGuardedModel) return;
       if (overlays.size === 0) return;
       if (isGuardedModel(event.model.provider, event.model.id)) return;
 
@@ -527,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 =
@@ -545,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") {
@@ -660,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).` };
   }
@@ -669,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;
@@ -735,7 +768,7 @@ 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 };

package/package.json

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

package/src/automatic/guardian.ts

@@ -130,6 +130,26 @@ export async function consumePrivate(
   return final;
 }
 
+/** Aggiunge una riga di trasparenza sul verdetto non conclusivo. */
+function uncertainNotice(verdict: ReviewResult): string {
+  const top = [...verdict.checks].sort((a, b) => b.pFlaw - a.pFlaw)[0];
+  const detail = top ? ` (${top.ruleId} p=${top.pFlaw.toFixed(3)})` : "";
+  const reason = verdict.errorCode ? ` errore=${verdict.errorCode}` : "";
+  return `\n\n> [jev] verdetto non conclusivo: ${verdict.status}${detail}${reason} — pubblicato per policy onUncertain/onUnavailable=pass.`;
+}
+
+/** Copia del candidato con la nota accodata all'ultimo blocco di testo. */
+function withNotice(message: AssistantMessage, notice: string): AssistantMessage {
+  const content = message.content.map((block) => ({ ...block }));
+  const last = [...content].reverse().find((block) => block.type === "text");
+  if (last && last.type === "text") {
+    last.text = `${last.text}${notice}`;
+  } else {
+    content.push({ type: "text", text: notice.trimStart() });
+  }
+  return { ...message, content };
+}
+
 function assertCompleteCandidate(message: AssistantMessage): void {
   // Rifiuta terminali non supportati per pubblicazione.
   if (
@@ -177,6 +197,10 @@ export function runGuardedStream(
     const usages: Usage[] = [];
     let attemptContext = originalContext;
     const maxRegenerations = deps.config.automatic.maxRegenerations;
+    // Un verdetto incerto non è un difetto accertato: un solo tentativo di
+    // riparazione mirata evita l'hold immediato su prosa borderline.
+    const maxReviewRepairs = deps.config.automatic.repairOnReview === false ? 0 : 1;
+    let reviewRepairs = 0;
 
     try {
       for (let attempt = 0; attempt <= maxRegenerations; attempt++) {
@@ -224,10 +248,11 @@ export function runGuardedStream(
         }
         signal?.throwIfAborted();
 
-        if (verdict.status === "pass") {
+        const publishCandidate = async (notice?: string): Promise<void> => {
           deps.onVerdict?.({ verdict, attempts: attempt + 1, outcome: "published" });
+          const approved = notice ? withNotice(candidate, notice) : candidate;
           const aggregated = aggregateUsage(usages);
-          const replayed = replayApproved(candidate, {
+          const replayed = replayApproved(approved, {
             provider: deps.publishedProvider,
             model: deps.publishedModel,
             usage: aggregated,
@@ -239,10 +264,19 @@ export function runGuardedStream(
           }
           const final = await replayed.result();
           out.end(final);
+        };
+
+        if (verdict.status === "pass") {
+          await publishCandidate();
           return;
         }
 
-        if (verdict.status === "block" && attempt < maxRegenerations) {
+        const canRepair =
+          verdict.status === "block"
+            ? attempt < maxRegenerations
+            : verdict.status === "review" && reviewRepairs < maxReviewRepairs;
+        if (canRepair) {
+          if (verdict.status === "review") reviewRepairs++;
           attemptContext = buildRepairContext({
             originalContext,
             rejectedText: rawCandidate,
@@ -252,6 +286,15 @@ export function runGuardedStream(
           continue;
         }
 
+        // Policy esplicita per i verdetti non conclusivi (config, non silenziosa).
+        const uncertainPass = verdict.status === "review" && deps.config.policy.onUncertain === "pass";
+        const unavailablePass =
+          verdict.status === "unavailable" && deps.config.policy.onUnavailable === "pass";
+        if (uncertainPass || unavailablePass) {
+          await publishCandidate(uncertainNotice(verdict));
+          return;
+        }
+
         // Hold: pubblica failure sicura, mai il candidato bocciato.
         const attempts = attempt + 1;
         deps.onVerdict?.({ verdict, attempts, outcome: "held" });

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";
@@ -134,7 +136,7 @@ export function buildOverlaidProvider(deps: OverlayDeps): Provider {
     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 originals = mergeModelsById(stripTwins(rawOriginals), []);
     const twins: Model<Api>[] = [];
     for (const original of originals) {
       if (chosen.has(original.id)) {
@@ -155,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(
@@ -167,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,6 +2,7 @@ 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 { isTwinId, untwinId } from "./automatic/overlay.ts";
 import type { JevConfig, TwinRef } from "./config.ts";
 import {
   defaultConfigPath,
@@ -42,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 };
@@ -91,8 +94,8 @@ 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        Aggiunge il twin M__jev nel provider P (salvato)",
   "  /jev upstream P/M        Stessa cosa in forma compatta",
@@ -111,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");
@@ -130,6 +133,32 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
       const parts = args.trim().split(/\s+/).filter(Boolean);
       const sub = parts[0] ?? "status";
 
+      // Terza domanda del picker: registrato, visibile, selezionato. Il twin
+      // appena creato non è mai nello scope risolto a inizio sessione.
+      function twinInScope(provider: string, modelId: string): boolean {
+        try {
+          const scoped = ctx.scopedModels ?? [];
+          if (scoped.length === 0) return true;
+          return scoped.some(
+            (s) => s.model.provider === provider && s.model.id === `${modelId}__jev`,
+          );
+        } catch {
+          return true;
+        }
+      }
+
+      // 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;
@@ -179,20 +208,21 @@ 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})` : `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}`,
@@ -220,14 +250,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;
       }
@@ -293,10 +324,15 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
           return;
         }
         const total = deps.twinStatus().active.length;
+        const visible = twinInScope(parsed.provider, parsed.model);
         ctx.ui.notify(
           `Twin aggiunto: ${res.twin} (totale attivi: ${total}, stessa auth del provider). ` +
-            `Selezionalo con /model per enforcement in automatic.`,
-          "info",
+            (visible
+              ? "Selezionalo con /model per enforcement in automatic."
+              : `ATTENZIONE: non compare in /model — enabledModels non lo copre. ` +
+                `Aggiungi "${parsed.provider}/*__jev" a enabledModels e fai /reload, ` +
+                `oppure attivalo direttamente con /jev mode automatic.`),
+          visible ? "info" : "warning",
         );
         return;
       }
@@ -319,7 +355,8 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
           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)"}`);
+          const hidden = twinInScope(ref.provider, ref.model) ? "" : "  (fuori dal picker)";
+          lines.push(`${mark}${star} ${key}${activeKeys.has(key) ? "" : "  (non attivo)"}${hidden}`);
         }
         ctx.ui.notify(
           [
@@ -342,8 +379,21 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
           );
           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}).`
@@ -354,11 +404,13 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
       }
 
       if (sub === "off") {
-        const res = deps.removeGuarded();
-        if (res.ok) {
-          // Senza twin, automatic è contraddittorio: torna on-demand.
-          deps.setMode("on-demand");
+        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 rimossi: ${res.removed ?? 0} (provider originali ripristinati), modalità on-demand.`
@@ -465,7 +517,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

@@ -31,6 +31,8 @@ export interface JevConfig {
   automatic: {
     transport: "provider-gate";
     maxRegenerations: number;
+    /** Tentativo privato extra quando il verdetto è incerto (review). */
+    repairOnReview: boolean;
     requireGuardedModel: boolean;
     /** Twin salvati: più modelli guarded insieme (uno o più per provider). */
     twins: TwinRef[];
@@ -121,6 +123,7 @@ export const DEFAULT_CONFIG: JevConfig = {
   automatic: {
     transport: "provider-gate",
     maxRegenerations: 2,
+    repairOnReview: true,
     requireGuardedModel: true,
     twins: [],
     // Vuoti di default: nessun twin "salvato" finché l'utente non ne aggiunge
@@ -408,7 +411,8 @@ export function withTwinRefs(config: JevConfig, refs: TwinRef[]): JevConfig {
     automatic: {
       ...config.automatic,
       twins: refs.map((r) => ({ ...r })),
-      ...(primary ? { upstreamProvider: primary.provider, upstreamModel: primary.model } : {}),
+      upstreamProvider: primary?.provider ?? "",
+      upstreamModel: primary?.model ?? "",
     },
   };
 }