pi-jev-guard 0.1.0

package/extensions/index.ts

@@ -0,0 +1,692 @@
+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 { deepseekProvider } from "@earendil-works/pi-ai/providers/deepseek";
+import { registerJevCommand, type UpstreamResult } from "../src/commands.ts";
+import { registerJevAskTool } from "../src/ask.ts";
+import {
+  configSnapshot,
+  loadConfig,
+  parseUpstreamRef,
+  resolveBackend,
+  saveConfig,
+  type JevConfig,
+} from "../src/config.ts";
+import { createReviewer, createTypedAsk } from "../src/factory.ts";
+import { createMetrics } from "../src/metrics.ts";
+import { registerJevTool } from "../src/tools.ts";
+import {
+  STATIC_DEEPSEEK_FLASH,
+  buildOverlaidProvider,
+  isTwinId,
+  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 {
+  TOOL_POLICY_REVISION,
+  checkFilePath,
+  checkShellCommand,
+} from "../src/tools-policy.ts";
+import {
+  OUTPUT_QUESTIONS,
+  buildOutputState,
+  createVerdictCache,
+  evaluateOutput,
+  outputKey,
+  toolResultText,
+  type OutputVerdict,
+} from "../src/output-judge.ts";
+import {
+  EXFIL_QUESTIONS,
+  buildExfilState,
+  evaluateExfil,
+  hasNetworkTool,
+  lastUserText,
+  type ExfilVerdict,
+} from "../src/exfil.ts";
+
+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();
+  // 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 });
+  let typedHandle = createTypedAsk(configSnapshot(config));
+  let outputCache = createVerdictCache<OutputVerdict>({ ttlSeconds: config.outputJudge.cacheSeconds });
+  let exfilCache = createVerdictCache<ExfilVerdict>({ ttlSeconds: config.exfilCheck.cacheSeconds });
+  let lastOutput: { tool: string; verdict: OutputVerdict; at: number } | undefined;
+  let lastGate: { report: GateVerdictReport; at: number } | undefined;
+
+  function recordGateVerdict(report: GateVerdictReport): void {
+    lastGate = { report, at: Date.now() };
+  }
+  let lastOutputErrorAt = 0;
+  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;
+
+  const getConfig = () => config;
+  const getReview = () => handle.review;
+  const getGateReview = () => gateHandle.review;
+  const getInfo = () => ({ backend: handle.backend, model: handle.model });
+
+  function getGateStatus(): GateStatus {
+    if (overlaidProviderId && twinTarget) {
+      return {
+        active: true,
+        twin: `${twinTarget.provider}/${twinIdFor(twinTarget.model)}`,
+        upstream: `${twinTarget.provider}/${twinTarget.model}`,
+        reason: `overlay attivo su ${overlaidProviderId} (stessa auth del provider)`,
+      };
+    }
+    return {
+      active: false,
+      reason: "nessun guarded attivo — usa /jev upstream <provider> <model>",
+    };
+  }
+
+  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)
+    );
+  }
+
+  function refresh() {
+    config = loadConfig();
+    handle = createReviewer(configSnapshot(config));
+    gateHandle = createReviewer(configSnapshot(config), { rules: DEFAULT_GATE_RULES });
+    typedHandle = createTypedAsk(configSnapshot(config));
+    outputCache = createVerdictCache<OutputVerdict>({ ttlSeconds: config.outputJudge.cacheSeconds });
+    exfilCache = createVerdictCache<ExfilVerdict>({ ttlSeconds: config.exfilCheck.cacheSeconds });
+    return config;
+  }
+
+  /** Provider upstream vero, spacchettando il nostro overlay se già attivo. */
+  function liveUpstreamProvider(
+    registry: ModelRegistry,
+    providerId: string,
+  ): Provider | undefined {
+    if (overlaidProviderId === providerId) {
+      return upstreamRefs.get(providerId);
+    }
+    return registry.getProvider(providerId);
+  }
+
+  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> };
+  }
+
+  function applyOverlay(
+    snapshot: { provider: Provider; model: Model<Api> },
+    persist: boolean,
+  ): UpstreamResult {
+    const providerId = snapshot.provider.id;
+    try {
+      // Rimuovi overlay precedente su provider diverso (ripristina builtin).
+      if (overlaidProviderId && overlaidProviderId !== providerId) {
+        try {
+          pi.unregisterProvider(overlaidProviderId);
+        } catch {
+          // ignora
+        }
+        upstreamRefs.delete(overlaidProviderId);
+      }
+      // Cattura il live PRIMA dell'override (dopo, getProvider dà l'overlay).
+      if (!upstreamRefs.has(providerId)) {
+        upstreamRefs.set(providerId, snapshot.provider);
+      }
+      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,
+        },
+      };
+      if (persist) {
+        try {
+          saveConfig(config);
+        } catch (error) {
+          return {
+            ok: false,
+            error: `Upstream aggiornato in memoria ma salvataggio fallito: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+          };
+        }
+      }
+      return { ok: true, twin: `${providerId}/${twinIdFor(snapshot.model.id)}` };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /** Crea o sposta il twin guarded (persistente). */
+  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 };
+    return applyOverlay(found, true);
+  }
+
+  /** Riapplica l'ultimo upstream salvato in config. */
+  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);
+  }
+
+  /** 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),
+      };
+    }
+    upstreamRefs.delete(overlaidProviderId);
+    overlaidProviderId = undefined;
+    twinTarget = undefined;
+    return { ok: true };
+  }
+
+  /** Seleziona il twin attivo come modello di sessione. */
+  async function switchToGuarded(
+    registry: ModelRegistry,
+  ): Promise<{ ok: boolean; error?: string; model?: string }> {
+    if (!overlaidProviderId || !twinTarget) {
+      return { ok: false, error: "nessun guarded attivo — prima /jev upstream <provider> <model>" };
+    }
+    const twinId = twinIdFor(twinTarget.model);
+    const model = registry.find(overlaidProviderId, twinId);
+    if (!model) {
+      return { ok: false, error: `twin non in registry: ${overlaidProviderId}/${twinId}` };
+    }
+    try {
+      const ok = await pi.setModel(model);
+      if (!ok) {
+        return { ok: false, error: `auth mancante per ${overlaidProviderId} — /login ${overlaidProviderId}` };
+      }
+      return { ok: true, model: `${overlaidProviderId}/${model.id}` };
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+
+  registerJevTool(pi, {
+    review: getReview,
+    config: getConfig,
+    metrics,
+  });
+
+  registerJevAskTool(pi, {
+    ask: () => typedHandle.ask,
+    config: getConfig,
+    keyPresent: () => resolveBackend(getConfig()).apiKeyPresent,
+  });
+
+  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;
+    },
+    reload: refresh,
+    review: getReview,
+    reviewerInfo: getInfo,
+    metrics,
+    gateStatus: getGateStatus,
+    setUpstream,
+    refreshUpstream,
+    removeGuarded,
+    switchToGuarded,
+    getLastOutput: () => lastOutput,
+    getLastGate: () => lastGate,
+  });
+
+  // Seed headless: --print risolve --model prima di session_start, quindi per
+  // il solo caso deepseek/deepseek-flash si pre-registra un overlay statico
+  // (sostituito dal clone live appena il registry è disponibile).
+  // Richiede JEV_AUTO_UPSTREAM: senza, nessun guarded (opt-in).
+  const bootAuto = process.env.JEV_AUTO_UPSTREAM?.trim().toLowerCase();
+  if (bootAuto === "deepseek/deepseek-flash") {
+    try {
+      const base = deepseekProvider();
+      const seedUpstream: Provider = {
+        ...base,
+        getModels: () => [...base.getModels(), { ...STATIC_DEEPSEEK_FLASH }],
+      };
+      const overlay = buildOverlaidProvider({
+        upstream: seedUpstream,
+        twinModelIds: ["deepseek-flash"],
+        getConfig,
+        getReview: getGateReview,
+        onVerdict: recordGateVerdict,
+      });
+      pi.registerProvider(overlay);
+      upstreamRefs.set("deepseek", seedUpstream);
+      overlaidProviderId = "deepseek";
+      twinTarget = { provider: "deepseek", model: "deepseek-flash" };
+    } catch {
+      overlaidProviderId = undefined;
+      twinTarget = undefined;
+    }
+  }
+
+  pi.on("session_start", async (_event, ctx) => {
+    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 {
+            applyOverlay(found, false);
+          }
+        }
+      } catch {
+        // Resta opt-in manuale.
+      }
+    }
+    // Config automatic senza guarded = contraddittorio: ripristina + seleziona.
+    try {
+      if (config.mode !== "automatic" || !config.automatic.requireGuardedModel) return;
+      if (!overlaidProviderId || !twinTarget) {
+        const restored = refreshUpstream(ctx.modelRegistry);
+        if (!restored.ok) {
+          if (ctx.hasUI) {
+            ctx.ui.notify(`Jev automatic senza guarded: ${restored.error} (diagnostica sola).`, "warning");
+          }
+          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);
+      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}.`,
+          switched ? "info" : "warning",
+        );
+      }
+    } catch {
+      // Non bloccare l'avvio sessione.
+    }
+  });
+
+  // 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 (!overlaidProviderId || !twinTarget) return;
+      if (isGuardedModel(event.model.provider, event.model.id)) return;
+
+      const twinId = twinIdFor(twinTarget.model);
+      const twin = ctx.modelRegistry.find(overlaidProviderId, twinId);
+      const fallback =
+        twin ??
+        (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",
+          );
+        }
+      } 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.
+    }
+  });
+
+  // Status TUI durante il gate: lo streaming guarded non emette nulla finché
+  // Jev non approva; mostra stato invece di silenzio ambiguo.
+  pi.on("message_start", async (event, ctx) => {
+    try {
+      if (config.mode !== "automatic" || !ctx.hasUI) return;
+      const msg: any = event.message;
+      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)) {
+        ctx.ui.setStatus("jev", "Jev: verifica in corso (output trattenuto)");
+      }
+    } catch {
+      // Mai rompere il flusso per lo status.
+    }
+  });
+
+  // Policy pre-esecuzione tool (solo automatic).
+  pi.on("tool_call", async (event, ctx) => {
+    try {
+      if (config.mode !== "automatic") return;
+      if (!config.toolsPolicy.enabled) return;
+
+      if (event.toolName === "bash" || event.toolName === "powershell") {
+        const input = event.input as { command?: unknown };
+        const verdict = checkShellCommand(input.command, event.toolName);
+        if (verdict.blocked) {
+          pi.appendEntry("jev-tool-block", {
+            tool: event.toolName,
+            ruleId: verdict.ruleId,
+            revision: TOOL_POLICY_REVISION,
+          });
+          if (ctx.hasUI) {
+            ctx.ui.notify(`Jev tool policy: bloccato ${event.toolName} (${verdict.reason})`, "warning");
+          }
+          return {
+            block: true,
+            reason: `Bloccato da jev tool policy (${verdict.ruleId}): ${verdict.reason}.`,
+          };
+        }
+        // E-lite: comandi con tool di rete → giudizio semantico (fail-open).
+        const exfil = await exfilCheck(event.toolName, input.command, ctx);
+        if (exfil) return exfil;
+        return;
+      }
+
+      if (event.toolName === "write" || event.toolName === "edit") {
+        const input = event.input as { path?: unknown };
+        const verdict = checkFilePath(input.path);
+        if (verdict.blocked) {
+          pi.appendEntry("jev-tool-block", {
+            tool: event.toolName,
+            ruleId: verdict.ruleId,
+            revision: TOOL_POLICY_REVISION,
+          });
+          if (ctx.hasUI) {
+            ctx.ui.notify(`Jev tool policy: bloccato ${event.toolName} (${verdict.reason})`, "warning");
+          }
+          return {
+            block: true,
+            reason: `Bloccato da jev tool policy (${verdict.ruleId}): ${verdict.reason}.`,
+          };
+        }
+        return;
+      }
+    } catch {
+      // Fail-open qui: mai rompere tool legittimi per un errore della policy.
+    }
+  });
+
+  async function exfilCheck(
+    toolName: string,
+    command: unknown,
+    ctx: ExtensionContext,
+  ): Promise<{ block: true; reason: string } | undefined> {
+    if (!config.exfilCheck.enabled) return undefined;
+    if (!config.exfilCheck.tools.includes(toolName)) return undefined;
+    if (typeof command !== "string" || !hasNetworkTool(command)) return undefined;
+    if (!resolveBackend(config).apiKeyPresent) return undefined;
+
+    let verdict: ExfilVerdict | undefined;
+    try {
+      verdict = await exfilCache.getOr(outputKey(toolName, command), async () => {
+        const asked = await typedHandle.ask(
+          buildExfilState({
+            cwd: ctx.cwd,
+            toolName,
+            command,
+            userRequest: lastUserText(ctx.sessionManager.buildContextEntries()),
+          }),
+          EXFIL_QUESTIONS,
+          ctx.signal ?? undefined,
+        );
+        const t = config.exfilCheck;
+        return evaluateExfil(asked, {
+          destructive: t.blockOn.destructive,
+          exfiltration: t.blockOn.exfiltration,
+          beyondScope: t.blockOn.beyondScope,
+          impact: t.blockOn.impact,
+          minConfidence: t.minConfidence,
+        });
+      });
+    } catch (error) {
+      if (ctx.signal?.aborted) return undefined;
+      const now = Date.now();
+      if (now - lastExfilErrorAt >= 60_000) {
+        lastExfilErrorAt = now;
+        try {
+          ctx.ui.notify(
+            `Jev exfil check: ${error instanceof Error ? error.message : String(error)} (failing open)`,
+            "error",
+          );
+        } catch {
+          // ignora
+        }
+      }
+      return undefined;
+    }
+    if (!verdict?.flagged) return undefined;
+
+    pi.appendEntry("jev-exfil-flag", {
+      tool: toolName,
+      reasons: verdict.reasons,
+      model: verdict.model,
+    });
+    const summary = verdict.reasons.join(", ");
+    if (!ctx.hasUI) {
+      if (config.exfilCheck.blockWithoutUI) {
+        return { block: true, reason: `Bloccato da jev exfil check (headless): ${summary}.` };
+      }
+      return undefined;
+    }
+    const allow = await ctx.ui.confirm(
+      "Jev: comando di rete sospetto",
+      `${toolName}\n${summary}\n\nEseguire comunque?`,
+    );
+    return allow ? undefined : { block: true, reason: `Bloccato da jev exfil check (${summary}) (declined).` };
+  }
+
+  // Giudice output (solo automatic, fail-open): dopo l'esecuzione cerca
+  // secret nel testo e classifica i fallimenti. Non blocca mai: allega
+  // una riga al risultato che il modello legge.
+  pi.on("tool_result", async (event, ctx) => {
+    try {
+      if (config.mode !== "automatic") return;
+      if (!config.outputJudge.enabled) return;
+      if (!config.outputJudge.tools.includes(event.toolName)) return;
+      if (!resolveBackend(config).apiKeyPresent) return;
+      const text = toolResultText(event.content);
+      if (!text.trim()) return;
+
+      let verdict: OutputVerdict | undefined;
+      try {
+        verdict = await outputCache.getOr(outputKey(event.toolName, text), async () => {
+          const asked = await typedHandle.ask(
+            buildOutputState({
+              cwd: ctx.cwd,
+              toolName: event.toolName,
+              input: event.input,
+              output: text,
+              isError: event.isError,
+              outputChars: config.outputJudge.outputChars,
+            }),
+            OUTPUT_QUESTIONS,
+            ctx.signal ?? undefined,
+          );
+          return evaluateOutput(asked, config.outputJudge);
+        });
+      } catch (error) {
+        if (ctx.signal?.aborted) return;
+        throttledOutputError(ctx, error);
+        return;
+      }
+      if (!verdict?.notice) return;
+
+      lastOutput = { tool: event.toolName, verdict, at: Date.now() };
+      if (ctx.hasUI) {
+        ctx.ui.setStatus("jev", `Jev: ${verdict.kind} (${event.toolName})`);
+        if (verdict.kind === "leak") {
+          ctx.ui.notify(
+            `Jev: ${event.toolName} output may carry a secret (${verdict.leaksSecret.toFixed(2)})`,
+            "warning",
+          );
+        }
+      }
+      return {
+        content: [...event.content, { type: "text", text: `[jev-guard] ${verdict.notice}` }],
+      };
+    } catch {
+      // Fail-open: mai rompere i risultati tool.
+    }
+  });
+
+  function throttledOutputError(ctx: { ui: { notify: (m: string, t: "error") => void } }, error: unknown): void {
+    const now = Date.now();
+    if (now - lastOutputErrorAt < 60_000) return;
+    lastOutputErrorAt = now;
+    try {
+      ctx.ui.notify(
+        `Jev output judge: ${error instanceof Error ? error.message : String(error)} (failing open)`,
+        "error",
+      );
+    } catch {
+      // ignora
+    }
+  }
+
+  pi.on("message_end", async (event, ctx) => {
+    try {
+      if (ctx.hasUI) ctx.ui.setStatus("jev", undefined);
+      if (config.mode !== "automatic") return;
+      if (event.message.role !== "assistant") return;
+
+      const msg = event.message as { provider?: string; model?: string };
+      if (isGuardedModel(msg.provider, msg.model)) {
+        pi.appendEntry("jev-guarded", {
+          twin: twinTarget ? `${twinTarget.provider}/${twinIdFor(twinTarget.model)}` : undefined,
+          upstream: twinTarget ? `${twinTarget.provider}/${twinTarget.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",
+          );
+        }
+      }
+
+      const candidate = event.message.content
+        .flatMap((block: any) =>
+          block && block.type === "text" && typeof block.text === "string"
+            ? [block.text]
+            : [],
+        )
+        .join("\n\n");
+
+      if (!candidate.trim()) return;
+
+      const snapshot = configSnapshot(config);
+      const result = await handle.review(
+        {
+          requirements: "Satisfy the user's explicit request without defects.",
+          candidate: elideWithMarker(candidate, snapshot.limits.maxCandidateChars),
+        },
+        ctx.signal ?? undefined,
+      );
+      metrics.record(result);
+
+      if (ctx.hasUI && result.status !== "pass") {
+        ctx.ui.notify(`Jev diagnostic ${result.status}: ${JSON.stringify(result.checks)}`, "warning");
+      }
+
+      pi.appendEntry("jev-diagnostic", {
+        status: result.status,
+        backend: result.backend,
+        model: result.model,
+        errorCode: result.errorCode,
+        elapsedMs: result.elapsedMs,
+      });
+    } catch {
+      // Mai rompere il flusso per un diagnostico.
+    }
+  });
+}