pi-jev-guard 0.3.0 → 0.3.1

package/README.md

@@ -116,10 +116,16 @@ 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
+Verdetto **incerto** (`review`): il gate tenta prima una 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.
+
+Se un'altra estensione ri-registra lo stesso provider (caso reale: `pi-accounts`
+al cambio account), l'overlay viene ricostruito sopra il provider live prima di
+ogni turno; in più il gate toglie il suffisso `__jev` da qualunque payload,
+registrando `jev-gate-bypass` e avvisando in TUI, perché quel turno non è
+passato dalla verifica.
 Le conferme per comandi di rete sospetti attendono invece una decisione esplicita;
 la normale sequenza tool → risposta successiva continua senza un nuovo prompt.
 

package/extensions/index.ts

@@ -96,8 +96,13 @@ export default function (pi: ExtensionAPI) {
   // 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 {
+    /** Provider live catturato prima dell'override (auth inclusa). */
     upstream: Provider;
     twinIds: string[];
+    /** Il nostro overlay registrato, per accorgersi se viene scalzato. */
+    provider: Provider;
+    /** Ripiego dopo un tentativo di ri-registrazione non riuscito. */
+    reassertFailed?: boolean;
   }
   const overlays = new Map<string, OverlayState>();
 
@@ -208,7 +213,46 @@ export default function (pi: ExtensionAPI) {
       onVerdict: recordGateVerdict,
     });
     pi.registerProvider(overlay);
-    overlays.set(providerId, { upstream, twinIds: [...twinIds] });
+    overlays.set(providerId, {
+      upstream,
+      twinIds: [...twinIds],
+      provider: overlay,
+    });
+  }
+
+  /**
+   * Un'altra estensione (es. pi-accounts) può ri-registrare lo stesso provider
+   * id, sostituendo il nostro overlay con un provider che conserva i modelli
+   * (twin compresi) ma non il gate: l'id `__jev` finirebbe all'API.
+   * Qui riapplichiamo l'overlay sopra il provider live, preservandone auth e
+   * config. Se la ri-registrazione non regge, si smette di ritentare.
+   */
+  function reassertOverlays(registry: ModelRegistry): string[] {
+    const fixed: string[] = [];
+    for (const [providerId, state] of [...overlays]) {
+      if (state.reassertFailed) continue;
+      let live: Provider | undefined;
+      try {
+        live = registry.getProvider(providerId);
+      } catch {
+        continue;
+      }
+      if (!live || live === state.provider) continue;
+      try {
+        registerOverlay(providerId, live, state.twinIds);
+        const applied = overlays.get(providerId);
+        if (applied && registry.getProvider(providerId) === applied.provider) {
+          fixed.push(providerId);
+        } else if (applied) {
+          // Il registry restituisce un altro oggetto: non insistere.
+          applied.reassertFailed = true;
+        }
+      } catch {
+        const current = overlays.get(providerId);
+        if (current) current.reassertFailed = true;
+      }
+    }
+    return fixed;
   }
 
   /**
@@ -513,8 +557,62 @@ export default function (pi: ExtensionAPI) {
   });
   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.
+  // Prima di ogni turno: se un'altra estensione ci ha scalzati dal provider,
+  // rimettiamo l'overlay (altrimenti l'id __jev arriverebbe all'API).
+  function noteReassert(fixed: string[]): void {
+    if (fixed.length === 0) return;
+    try {
+      pi.appendEntry("jev-overlay-reassert", { providers: fixed });
+    } catch {
+      // solo diagnostica
+    }
+  }
+
+  pi.on("before_agent_start", async (_event, ctx) => {
+    try {
+      noteReassert(reassertOverlays(ctx.modelRegistry));
+    } catch {
+      // mai bloccare il turno
+    }
+  });
+
+  // Ultima rete: se per qualunque motivo il payload esce con l'id sintetico,
+  // togliamo il suffisso (il modello originale è quello giusto) e registriamo
+  // che quel turno NON è passato dal gate.
+  let lastBypassNoticeAt = 0;
+  pi.on("before_provider_request", async (event, ctx) => {
+    try {
+      const payload = event.payload as { model?: unknown } | undefined;
+      if (!payload || typeof payload.model !== "string" || !isTwinId(payload.model)) {
+        return undefined;
+      }
+      const requested = payload.model;
+      payload.model = untwinId(requested);
+      try {
+        pi.appendEntry("jev-gate-bypass", {
+          requested,
+          sent: payload.model,
+          provider: ctx.model?.provider,
+        });
+      } catch {
+        // solo diagnostica
+      }
+      const now = Date.now();
+      if (ctx.hasUI && now - lastBypassNoticeAt >= 60_000) {
+        lastBypassNoticeAt = now;
+        ctx.ui.notify(
+          `Jev: richiesta non passata dal gate (${requested} → ${payload.model}). Verifica disattivata per questo turno; riprova per riattivarla.`,
+          "warning",
+        );
+      }
+      return payload;
+    } catch {
+      return undefined;
+    }
+  });
+
+  // Normalizza gli alias persistiti anche dopo /jev off (overlay rimossi).
+  // L'evento context è una copia: la cronologia salvata resta invariata.
   pi.on("context", async (event) => ({
     messages: event.messages.map((message) =>
       message.role === "assistant" && isTwinId(message.model)
@@ -526,6 +624,8 @@ export default function (pi: ExtensionAPI) {
   // su un modello non guarded (revert immediato al twin).
   pi.on("model_select", async (event, ctx) => {
     try {
+      // Una selezione account/provider può aver rimpiazzato il nostro overlay.
+      noteReassert(reassertOverlays(ctx.modelRegistry));
       if (sessionMode !== "automatic" || !config.automatic.requireGuardedModel) return;
       if (overlays.size === 0) return;
       if (isGuardedModel(event.model.provider, event.model.id)) return;
@@ -768,6 +868,9 @@ export default function (pi: ExtensionAPI) {
   pi.on("message_end", async (event, ctx) => {
     try {
       if (ctx.hasUI) ctx.ui.setStatus("jev", undefined);
+      // Dopo la richiesta: se qualcuno ci ha scalzati, rimetti l'overlay
+      // per il turno successivo (il payload resta già normalizzato).
+      noteReassert(reassertOverlays(ctx.modelRegistry));
       if (sessionMode !== "automatic") return;
       if (event.message.role !== "assistant") return;
 

package/package.json

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