pi-jev-guard 0.4.0 → 0.6.0

package/README.md

@@ -6,6 +6,7 @@ Verifica le risposte con [TypeSafe Jev](https://docs.typesafe.ai) dentro [pi](ht
 - **Domande tipate**: tool `jev_ask` per giudizi calibrati definiti dal modello (noul/choice/score) invece di prosa.
 - **Automatica**: gemello guarded `<modello>__jev` dentro lo stesso provider, che trattiene la risposta, la verifica con Jev e pubblica solo l'output approvato (con rigenerazione privata su `block`). Stessa auth del provider: nessun login extra, funziona anche con Codex/OAuth.
 - **Giudice output** (solo `automatic`, fail-open): dopo ogni `bash` cerca secret nel testo e classifica i fallimenti, allegando un consiglio al risultato.
+- **Verifica progetto** (opt-in): footer deterministico da `edit`/`write` osservati e check autorizzati da override locale, manifest globale utente o profilo comune integrato; il modello può eseguire soltanto quegli id, mai shell arbitraria.
 
 ## Installazione
 
@@ -180,6 +181,104 @@ le contraddizioni ad alta confidenza. Fail-open: se il verificatore non
 risponde, il testo passa senza nota. `/jev last` mostra anche l'esito
 grounding (`warned`/`repaired`/`held`).
 
+### Verifica progetto deterministica (opt-in)
+
+Il grounding è probabilistico; per **compilazione, lint e test** serve una
+prova deterministica. La verifica progetto conserva, solo nella sessione,
+`edit`/`write` riusciti e gli esiti osservati dei check. Il footer viene
+generato dall'estensione, non dal modello: un test non eseguito non può
+diventare “test passati”.
+
+#### Nuovi progetti: zero manifest locale
+
+Una volta, in una sessione col twin `automatic`, abilita la modalità scelta:
+
+```text
+/jev verification repair
+```
+
+Da quel momento ogni progetto usa questa precedenza:
+
+1. `.pi/jev-verification.json` locale, se presente;
+2. `verification.globalManifestPath`, se l'hai configurato nella config
+   utente;
+3. profilo integrato `common` (default).
+
+Il profilo `common` non legge comandi dal repository: abilita esclusivamente
+comandi fissi dell'estensione quando trova segnali convenzionali:
+
+| Rilevamento | Check disponibili |
+|---|---|
+| `package.json` con script | `npm run typecheck`, `npm run lint`, uno tra `npm run test:unit`, `npm run test:ci`, `npm test` |
+| `Cargo.toml` | `cargo check`, `cargo test` |
+| `go.mod` | `go test ./...` |
+| configurazione pytest | `python -m pytest` |
+| repository Git | `git diff --check` |
+
+Il profilo sceglie un solo ecosistema (Node → Rust → Go → Python) e aggiunge
+il check Git quando applicabile. I comandi sono bounded da
+`verification.maxCommands` (default `4`) e timeout. Se nessun segnale è
+rilevato, non esegue nulla e il footer dichiara la limitazione.
+
+Dopo un edit il modello può scegliere solo id già acquisiti:
+
+```text
+/jev verify recommended      # check pertinenti non ancora freschi
+/jev verify all              # tutti, fino a verification.maxCommands
+/jev verify node-typecheck   # un id esplicito della policy corrente
+```
+
+Il tool LLM `jev_verify` ha lo stesso vincolo, richiede un progetto trusted e
+non accetta shell arbitraria. Footer/repair/hold operano nel twin
+`automatic`; `/jev verify` è utilizzabile manualmente anche senza footer.
+
+#### Override per progetti speciali
+
+Per una pipeline specifica, aggiungi un manifest al progetto: prevale sempre
+sul profilo globale.
+
+```bash
+mkdir -p .pi
+cp config/jev-verification.example.json .pi/jev-verification.json
+```
+
+Controllalo tu, poi acquisiscilo (e ripeti dopo ogni modifica manuale):
+
+```text
+/jev verification reload
+```
+
+In alternativa puoi definire **una** policy comune per tutti i tuoi progetti
+nella config utente, purché esista davvero e sia sotto il tuo controllo:
+
+```json
+{
+  "verification": {
+    "globalManifestPath": "~/.pi/agent/jev-verification.global.json",
+    "defaultProfile": "common"
+  }
+}
+```
+
+Un `globalManifestPath` configurato ma assente o malformato non degrada
+silenziosamente al profilo integrato: la verifica segnala l'errore. Per
+disattivare il fallback integrato imposta `"defaultProfile": "off"`.
+`/jev verification` e `/jev status` mostrano l'origine effettiva della policy.
+
+Manifest e profilo sono acquisiti a inizio sessione, all'attivazione esplicita
+o con `/jev verification reload`. Se un manifest, un `package.json` o un file
+di configurazione che abilita il profilo cambia dopo l'acquisizione, nessun
+check parte fino al reload utente. In automatic, con tool policy e verifica
+attive, `write`/`edit` del modello su tali file sono bloccati; una modifica via shell
+viene comunque rilevata dal fingerprint. Questo evita che il modello trasformi
+uno script o un manifest in un nuovo comando autorizzato.
+
+Modalità: `warn` aggiunge il footer; `repair` rigenera una volta con feedback
+che chiede `jev_verify`; `hold` trattiene dopo una failure concreta, o dopo il
+tentativo bounded se restano check mancanti. Nessun check pertinente non è un
+fallimento del codice e non produce hold. Le modifiche rilevate restano solo
+quelle di `edit`/`write`: una modifica shell non viene attribuita al modello.
+
 ## Configurazione
 
 `~/.pi/agent/jev-config.json` (o `$JEV_CONFIG`). Env: `JEV_MODE`, `JEV_BACKEND`
@@ -234,3 +333,6 @@ echo '{"requirements":"...","candidate":"..."}' | npm run jev-check
 - Il grounding controlla solo affermazioni verificabili sulla sessione
   (comandi, file, test, modifiche): niente fact-check di fatti esterni,
   e con contesti lunghi l'evidenza oltre budget viene elisa.
+- La verifica progetto dimostra solo i check dichiarati ed eseguiti dopo gli
+  `edit`/`write` osservati; non è una prova formale di correttezza, non vede
+  modifiche effettuate via shell e non sostituisce review umana.

package/config/jev-config.example.json

@@ -65,6 +65,16 @@
     "minConfidence": 0.6,
     "cacheSeconds": 120
   },
+  "verification": {
+    "enabled": false,
+    "mode": "warn",
+    "manifestPath": ".pi/jev-verification.json",
+    "defaultProfile": "common",
+    "maxRepairs": 1,
+    "commandTimeoutMs": 120000,
+    "outputChars": 6000,
+    "maxCommands": 4
+  },
   "exfilCheck": {
     "enabled": true,
     "tools": [

package/config/jev-verification.example.json

@@ -0,0 +1,22 @@
+{
+  "version": 1,
+  "checks": [
+    {
+      "id": "typecheck",
+      "description": "TypeScript static check",
+      "command": "npm run typecheck",
+      "files": ["src/**/*.ts", "extensions/**/*.ts", "test/**/*.ts"]
+    },
+    {
+      "id": "unit",
+      "description": "Unit tests",
+      "command": "npm run test:unit",
+      "files": ["src/**/*.ts", "extensions/**/*.ts", "test/**/*.ts"]
+    },
+    {
+      "id": "diff-check",
+      "description": "Whitespace and patch integrity",
+      "command": "git diff --check"
+    }
+  ]
+}

package/extensions/index.ts

@@ -3,6 +3,7 @@ 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 { registerJevAskTool } from "../src/ask.ts";
+import { registerVerificationTool, type VerificationToolRunResult } from "../src/verification-tool.ts";
 import {
   configSnapshot,
   loadConfig,
@@ -58,11 +59,33 @@ import {
   groundingKey,
   recordEvidence,
   recordToolResult,
+  parseExitCode,
   GROUNDING_QUESTIONS,
   type EvidenceEntry,
   type GroundingEvaluation,
 } from "../src/grounding.ts";
-import type { PostPublishCheckFn } from "../src/automatic/guardian.ts";
+import type { PostPublishCheckFn, PostPublishCheckResult } from "../src/automatic/guardian.ts";
+import {
+  buildVerificationStatus,
+  createVerificationState,
+  isVerificationPolicyPath,
+  decideVerificationAction,
+  loadVerificationPolicy,
+  manifestCheckForCommand,
+  normalizeObservedPath,
+  recordObservedModification,
+  recordVerificationRun,
+  selectVerificationChecks,
+  trustVerificationPolicy,
+  trustedVerificationPolicy,
+  type VerificationManifestTrust,
+  type VerificationStatus,
+} from "../src/verification.ts";
+import {
+  formatVerificationExecutions,
+  runVerificationChecks,
+  type VerificationExecution,
+} from "../src/verification-runner.ts";
 
 export interface GateStatus {
   active: boolean;
@@ -100,6 +123,17 @@ export default function (pi: ExtensionAPI) {
   // Resettato a ogni session_start; solo automatic lo alimenta e lo usa.
   let evidenceLedger: EvidenceEntry[] = [];
   let evidenceSeq = 0;
+  // Stato distinto dal grounding: resta utile anche quando il grounding
+  // probabilistico è spento. Registra solo edit/write osservati e run di
+  // comandi approvati dal manifest del progetto.
+  let verificationState = createVerificationState();
+  let verificationSeq = 0;
+  /** Check bash/powershell iniziati davvero: seq=start, non result order. */
+  const verificationCheckStarts = new Map<string, { id: string; command: string; seq: number; source: "bash" | "powershell" }>();
+  let verificationCwd: string | undefined;
+  // Acquisito solo all'avvio sessione o con un comando utente esplicito.
+  // Il modello non può trasformare un edit al manifest in un comando eseguito.
+  let verificationManifestTrust: VerificationManifestTrust | undefined;
   let lastOutput: { tool: string; verdict: OutputVerdict; at: number } | undefined;
   let lastGate: { report: GateVerdictReport; at: number } | undefined;
 
@@ -189,6 +223,104 @@ export default function (pi: ExtensionAPI) {
     return getConfig();
   }
 
+  function captureVerificationManifest(cwd: string): VerificationManifestTrust {
+    verificationCwd = cwd;
+    verificationManifestTrust = trustVerificationPolicy(cwd, config.verification);
+    return verificationManifestTrust;
+  }
+
+  function verificationSnapshot(cwd: string): {
+    loaded: ReturnType<typeof loadVerificationPolicy>;
+    status: VerificationStatus;
+  } {
+    const loaded = trustedVerificationPolicy(
+      verificationManifestTrust,
+      cwd,
+      config.verification,
+    );
+    return { loaded, status: buildVerificationStatus(verificationState, loaded) };
+  }
+
+  function verificationReport(
+    status: VerificationStatus,
+    action: "passed" | "warned" | "repaired" | "held",
+  ): NonNullable<GateVerdictReport["verification"]> {
+    return {
+      action,
+      changedFiles: [...status.changedFiles],
+      checks: status.checks.map((item) => ({ id: item.check.id, state: item.state })),
+    };
+  }
+
+  function recordVerificationExecution(
+    execution: VerificationExecution,
+    source: "jev_verify" | "bash" | "powershell" | "manual",
+    /** Marker al momento dell'avvio, non al tool_result. */
+    startedSeq = ++verificationSeq,
+  ): void {
+    recordVerificationRun(verificationState, {
+      id: execution.id,
+      command: execution.command,
+      ok: execution.ok,
+      ...(execution.exitCode !== undefined ? { exitCode: execution.exitCode } : {}),
+      seq: startedSeq,
+      source,
+    });
+  }
+
+  /**
+   * Esegue SOLO check estratti dalla policy acquisita (locale, globale o
+   * profilo integrato). Serve sia al tool del modello sia a /jev verify.
+   */
+  async function runProjectVerification(args: {
+    cwd: string;
+    selection: string | undefined;
+    signal?: AbortSignal;
+    trusted: boolean;
+  }): Promise<VerificationToolRunResult> {
+    const settings = config.verification;
+    if (!settings.enabled) {
+      return {
+        ok: false,
+        message: "[jev_verify] Verifica progetto disattivata. Attivala con /jev verification warn|repair|hold.",
+        results: [],
+      };
+    }
+    if (!args.trusted) {
+      return {
+        ok: false,
+        message: "[jev_verify] Progetto non trusted: nessun comando del manifest è stato eseguito.",
+        results: [],
+      };
+    }
+    const { loaded, status } = verificationSnapshot(args.cwd);
+    const selected = selectVerificationChecks(
+      loaded,
+      status,
+      args.selection,
+      settings.maxCommands,
+    );
+    if (!selected.ok) {
+      return { ok: false, message: `[jev_verify] ${selected.error}`, results: [] };
+    }
+    // Snapshot dell'ordine PRIMA dell'esecuzione: se un edit concorrente
+    // termina mentre il runner è attivo, questi risultati restano
+    // conservativamente stale/pending invece di essere falsamente freschi.
+    const startedSeq = ++verificationSeq;
+    const results = await runVerificationChecks({
+      checks: selected.checks,
+      cwd: args.cwd,
+      settings,
+      signal: args.signal,
+    });
+    for (const result of results) recordVerificationExecution(result, "jev_verify", startedSeq);
+    return {
+      ok: results.length > 0 && results.every((result) => result.ok),
+      message: formatVerificationExecutions(results),
+      results,
+    };
+  }
+
   /** Provider live corrente dal registry (sempre fresco, mai snapshot). */
   function liveUpstreamProvider(
     registry: ModelRegistry,
@@ -226,7 +358,7 @@ export default function (pi: ExtensionAPI) {
       getConfig,
       getReview: getGateReview,
       onVerdict: recordGateVerdict,
-      createPostCheck: createGroundingCheck,
+      createPostCheck,
     });
   }
 
@@ -435,6 +567,8 @@ export default function (pi: ExtensionAPI) {
     keyPresent: () => resolveBackend(getConfig()).apiKeyPresent,
   });
 
+  registerVerificationTool(pi, { run: runProjectVerification });
+
   registerJevCommand(pi, {
     config: getConfig,
     setMode: (mode) => {
@@ -476,6 +610,43 @@ export default function (pi: ExtensionAPI) {
       saveConfig(next);
       return refresh();
     },
+    verificationStatus: (cwd) => {
+      const { loaded, status } = verificationSnapshot(cwd);
+      return {
+        enabled: config.verification.enabled,
+        mode: config.verification.mode,
+        manifestPath: config.verification.manifestPath,
+        defaultProfile: config.verification.defaultProfile,
+        ...(loaded.ok
+          ? { manifestLoaded: true, manifestSource: loaded.source, manifestSourceLabel: loaded.sourceLabel }
+          : { manifestLoaded: false, manifestError: loaded.error }),
+        changedFiles: status.changedFiles,
+        checks: status.checks.map((item) => ({ id: item.check.id, state: item.state })),
+      };
+    },
+    setVerification: (mode) => {
+      const next = configSnapshot(config);
+      if (mode === "off") {
+        next.verification.enabled = false;
+      } else {
+        next.verification.enabled = true;
+        next.verification.mode = mode;
+      }
+      saveConfig(next);
+      const refreshed = refresh();
+      // L'attivazione è un'azione utente esplicita: acquisisce gli input
+      // correnti del fallback invece di riusare una snapshot presa quando era off.
+      if (mode !== "off" && verificationCwd) captureVerificationManifest(verificationCwd);
+      return refreshed;
+    },
+    reloadVerificationManifest: (cwd) => {
+      const trusted = captureVerificationManifest(cwd);
+      return trusted.ok
+        ? { ok: true, path: trusted.path, sourceLabel: trusted.sourceLabel }
+        : { ok: false, error: trusted.error };
+    },
+    runVerification: ({ cwd, selection, signal, trusted }) =>
+      runProjectVerification({ cwd, selection, signal, trusted }),
     getLastGate: () => lastGate,
   });
 
@@ -492,6 +663,10 @@ export default function (pi: ExtensionAPI) {
     // Nuova sessione = nuova evidenza: il ledger non attraversa le sessioni.
     evidenceLedger = [];
     evidenceSeq = 0;
+    verificationState = createVerificationState();
+    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.
@@ -637,6 +812,7 @@ export default function (pi: ExtensionAPI) {
   // before_agent_start, ripatcha in silenzio (mai register/unregister).
   pi.on("turn_start", async (_event, ctx) => {
     try {
+      verificationCwd = ctx.cwd;
       ensurePatches(ctx.modelRegistry);
     } catch {
       // Mai bloccare il turno.
@@ -645,6 +821,7 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("before_agent_start", async (_event, ctx) => {
     try {
+      verificationCwd = ctx.cwd;
       noteReassert(ensurePatches(ctx.modelRegistry));
     } catch {
       // mai bloccare il turno
@@ -749,6 +926,38 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
+  /**
+   * Marca l'INIZIO reale di un check shell già autorizzato. Non basta
+   * l'ordine dei tool_result: bash e edit possono essere concorrenti e un
+   * test avviato prima di un edit non deve risultare fresco dopo di esso.
+   */
+  pi.on("tool_execution_start", async (event, ctx) => {
+    try {
+      if (sessionMode !== "automatic") return;
+      if (event.toolName !== "bash" && event.toolName !== "powershell") return;
+      verificationCwd = ctx.cwd;
+      const { loaded } = verificationSnapshot(ctx.cwd);
+      if (!loaded.ok) return;
+      const args = event.args as { command?: unknown };
+      const check = manifestCheckForCommand(loaded.manifest, args.command);
+      if (!check) return;
+      verificationCheckStarts.set(event.toolCallId, {
+        id: check.id,
+        command: check.command,
+        seq: ++verificationSeq,
+        source: event.toolName,
+      });
+      // Difesa memoria contro toolcall senza result (abort esterno).
+      while (verificationCheckStarts.size > 100) {
+        const oldest = verificationCheckStarts.keys().next().value;
+        if (oldest === undefined) break;
+        verificationCheckStarts.delete(oldest);
+      }
+    } catch {
+      // Nessun impatto sull'esecuzione del tool.
+    }
+  });
+
   // Policy pre-esecuzione tool (solo automatic).
   pi.on("tool_call", async (event, ctx) => {
     try {
@@ -780,6 +989,36 @@ export default function (pi: ExtensionAPI) {
 
       if (event.toolName === "write" || event.toolName === "edit") {
         const input = event.input as { path?: unknown };
+        const profileInput = verificationManifestTrust?.ok && verificationManifestTrust.source === "global-profile";
+        if (
+          isVerificationPolicyPath(input.path, ctx.cwd, verificationManifestTrust) &&
+          // Il profilo comune è opt-in: non rendere package.json immutabile
+          // nelle installazioni che non hanno attivato la verifica progetto.
+          (!profileInput || config.verification.enabled)
+        ) {
+          const ruleId = profileInput
+            ? "verification-profile-input-immutable"
+            : "verification-manifest-immutable";
+          pi.appendEntry("jev-tool-block", {
+            tool: event.toolName,
+            ruleId,
+            revision: TOOL_POLICY_REVISION,
+          });
+          if (ctx.hasUI) {
+            ctx.ui.notify(
+              profileInput
+                ? "Jev tool policy: il modello non può modificare un file che decide i check del profilo globale acquisito."
+                : "Jev tool policy: il modello non può modificare il manifest che autorizza i suoi check.",
+              "warning",
+            );
+          }
+          return {
+            block: true,
+            reason: profileInput
+              ? "Bloccato da jev tool policy (verification-profile-input-immutable): modifica manualmente la configurazione del progetto e poi usa /jev verification reload."
+              : "Bloccato da jev tool policy (verification-manifest-immutable): modifica il manifest manualmente e poi usa /jev verification reload.",
+          };
+        }
         const verdict = checkFilePath(input.path);
         if (verdict.blocked) {
           pi.appendEntry("jev-tool-block", {
@@ -872,6 +1111,60 @@ export default function (pi: ExtensionAPI) {
     return allow ? undefined : { block: true, reason: `Bloccato da jev exfil check (${summary}) (declined).` };
   }
 
+  /**
+   * Registra modifiche e risultati dei check configurati. È deliberatamente
+   * separato dal grounding: il footer deterministico deve funzionare anche
+   * senza una chiamata Jev aggiuntiva. I bash nativi contano soltanto se il
+   * loro comando coincide ESATTAMENTE con un id del manifest.
+   */
+  function recordVerificationResult(event: {
+    toolCallId?: string;
+    toolName: string;
+    input: unknown;
+    content: unknown;
+    isError: boolean;
+  }, cwd: string): void {
+    try {
+      // Raccolta locale senza costo anche se il footer è spento: attivarlo a
+      // metà sessione conserva gli edit/write già osservati. Pubblicazione,
+      // repair ed esecuzione restano rigorosamente opt-in in config.
+      if (sessionMode !== "automatic") return;
+      verificationCwd = cwd;
+      if (event.toolName === "edit" || event.toolName === "write") {
+        if (event.isError) return;
+        const input = event.input as { path?: unknown };
+        const path = normalizeObservedPath(input.path, cwd);
+        if (path) recordObservedModification(verificationState, path, ++verificationSeq);
+        return;
+      }
+      if (event.toolName !== "bash" && event.toolName !== "powershell") return;
+      const input = event.input as { command?: unknown };
+      const started = event.toolCallId
+        ? verificationCheckStarts.get(event.toolCallId)
+        : undefined;
+      if (event.toolCallId) verificationCheckStarts.delete(event.toolCallId);
+      const { loaded } = verificationSnapshot(cwd);
+      if (!loaded.ok) return;
+      const check = manifestCheckForCommand(loaded.manifest, input.command);
+      if (!check) return;
+      const output = toolResultText(event.content);
+      const exitCode = parseExitCode(output);
+      recordVerificationRun(verificationState, {
+        id: check.id,
+        command: check.command,
+        ok: !event.isError,
+        ...(exitCode !== undefined ? { exitCode } : {}),
+        // In runtime il marker esiste perché tool_execution_start precede il
+        // result. Fallback conservativo per adapter/test legacy senza evento:
+        // allocato qui, mai riusa un pass precedente.
+        seq: started?.seq ?? ++verificationSeq,
+        source: event.toolName,
+      });
+    } catch {
+      // Un footer non deve mai cambiare il risultato di un tool.
+    }
+  }
+
   /** Registra un tool_result nel ledger evidenza (solo automatic, mai bloccare). */
   function recordGroundingResult(event: {
     toolName: string;
@@ -1020,12 +1313,127 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
+  /**
+   * Post-check deterministico del codice: non dichiara il codice corretto,
+   * ma allega il fatto osservato (edit/write + check manifest). In repair il
+   * modello ha un solo giro per invocare `jev_verify` e correggere l'errore;
+   * in hold una failure concreta non viene pubblicata.
+   */
+  function createVerificationCheck(): PostPublishCheckFn | undefined {
+    try {
+      if (sessionMode !== "automatic" || !config.verification.enabled) return undefined;
+      const cwd = verificationCwd;
+      if (!cwd) return undefined;
+      const mode = config.verification.mode;
+      const maxRepairs = config.verification.maxRepairs;
+      let repairsUsed = 0;
+      return async () => {
+        const { status } = verificationSnapshot(cwd);
+        if (status.changedFiles.length === 0) return { action: "publish" };
+        const decision = decideVerificationAction({
+          status,
+          mode,
+          repairsUsed,
+          maxRepairs,
+        });
+        if (decision.action === "regenerate") {
+          repairsUsed++;
+          try {
+            pi.appendEntry("jev-verification-repair", {
+              files: status.changedFiles,
+              checks: status.checks.map((item) => ({ id: item.check.id, state: item.state })),
+            });
+          } catch {
+            // solo diagnostica
+          }
+          return {
+            action: "regenerate",
+            feedback: decision.feedback,
+            verification: verificationReport(status, "repaired"),
+          };
+        }
+        if (decision.action === "hold") {
+          try {
+            pi.appendEntry("jev-verification-hold", {
+              files: status.changedFiles,
+              checks: status.checks.map((item) => ({ id: item.check.id, state: item.state })),
+            });
+          } catch {
+            // solo diagnostica
+          }
+          return {
+            action: "hold",
+            holdText: decision.holdText,
+            verification: verificationReport(status, "held"),
+          };
+        }
+        // "repaired" solo se il giro di repair è arrivato davvero a check
+        // freschi tutti passati; altrimenti resta un warning, mai un successo
+        // inventato solo perché il modello ha ricevuto feedback.
+        const action = status.allPassed
+          ? repairsUsed > 0 ? "repaired" : "passed"
+          : "warned";
+        try {
+          pi.appendEntry("jev-verification-status", {
+            action,
+            files: status.changedFiles,
+            checks: status.checks.map((item) => ({ id: item.check.id, state: item.state })),
+            ...(status.manifestError ? { manifestError: status.manifestError } : {}),
+          });
+        } catch {
+          // solo diagnostica
+        }
+        return {
+          action: "publish",
+          ...(decision.notice ? { notice: decision.notice } : {}),
+          verification: verificationReport(status, action),
+        };
+      };
+    } catch {
+      // Fail-open: errore del footer non deve bloccare il gate.
+      return undefined;
+    }
+  }
+
+  /** Compone grounding probabilistico e verifica deterministica senza perderne le note. */
+  function createPostCheck(): PostPublishCheckFn | undefined {
+    const grounding = createGroundingCheck();
+    const verification = createVerificationCheck();
+    if (!grounding && !verification) return undefined;
+    return async (args) => {
+      let groundingResult: PostPublishCheckResult | undefined;
+      if (grounding) {
+        groundingResult = await grounding(args);
+        if (groundingResult.action !== "publish") return groundingResult;
+      }
+      let verificationResult: PostPublishCheckResult | undefined;
+      if (verification) {
+        verificationResult = await verification(args);
+        if (verificationResult.action !== "publish") {
+          return {
+            ...verificationResult,
+            ...(groundingResult?.grounding ? { grounding: groundingResult.grounding } : {}),
+          };
+        }
+      }
+      const notices = [groundingResult?.notice, verificationResult?.notice]
+        .filter((notice): notice is string => Boolean(notice));
+      return {
+        action: "publish",
+        ...(notices.length > 0 ? { notice: notices.join("") } : {}),
+        ...(groundingResult?.grounding ? { grounding: groundingResult.grounding } : {}),
+        ...(verificationResult?.verification ? { verification: verificationResult.verification } : {}),
+      };
+    };
+  }
+
   // 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 {
       // Ledger prima di tutto: vale anche con outputJudge disattivato.
+      recordVerificationResult(event, ctx.cwd);
       recordGroundingResult(event);
       if (sessionMode !== "automatic") return;
       if (!config.outputJudge.enabled) return;

package/package.json

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