pi-jev-guard 0.2.1 → 0.2.2

package/README.md

@@ -76,8 +76,15 @@ ne rimuove uno solo, `/jev off` li rimuove tutti
 `/jev off` conserva il catalogo salvato: al reload gli alias tornano disponibili,
 ma il gate rimane disattivato.
 
-Se filtri i modelli con `enabledModels`, tieni le voci `__jev` dei twin che usi
-o restano nascosti.
+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..."]
+```
+
+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_MODE=automatic JEV_AUTO_UPSTREAM=provider/model` crea e attiva
@@ -85,6 +92,11 @@ 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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-jev-guard",
-  "version": "0.2.1",
+  "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/commands.ts

@@ -133,6 +133,20 @@ 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> {
@@ -310,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;
       }
@@ -336,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(
           [

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