pi-jev-guard 0.3.3 → 0.5.0

package/extensions/index.ts

@@ -1,9 +1,9 @@
 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 { registerJevAskTool } from "../src/ask.ts";
+import { registerVerificationTool, type VerificationToolRunResult } from "../src/verification-tool.ts";
 import {
   configSnapshot,
   loadConfig,
@@ -19,15 +19,14 @@ import { createReviewer, createTypedAsk } from "../src/factory.ts";
 import { createMetrics } from "../src/metrics.ts";
 import { registerJevTool } from "../src/tools.ts";
 import {
-  STATIC_DEEPSEEK_FLASH,
-  buildOverlaidProvider,
+  isPatched,
   isTwinId,
-  mergeModelsById,
+  patchProvider,
   twinIdFor,
+  unpatchProvider,
   untwinId,
 } from "../src/automatic/overlay.ts";
 import type { GateVerdictReport } from "../src/automatic/guardian.ts";
-import { readStoreModels } from "../src/store-models.ts";
 import { DEFAULT_GATE_RULES, elideWithMarker } from "../src/reviewer.ts";
 import {
   TOOL_POLICY_REVISION,
@@ -60,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,
+  isVerificationManifestPath,
+  decideVerificationAction,
+  loadVerificationManifest,
+  manifestCheckForCommand,
+  normalizeObservedPath,
+  recordObservedModification,
+  recordVerificationRun,
+  selectVerificationChecks,
+  trustVerificationManifest,
+  trustedVerificationManifest,
+  type VerificationManifestTrust,
+  type VerificationStatus,
+} from "../src/verification.ts";
+import {
+  formatVerificationExecutions,
+  runVerificationChecks,
+  type VerificationExecution,
+} from "../src/verification-runner.ts";
 
 export interface GateStatus {
   active: boolean;
@@ -102,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;
 
@@ -113,16 +145,13 @@ export default function (pi: ExtensionAPI) {
   let lastGroundingErrorAt = 0;
   const metrics = createMetrics();
 
-  // 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).
+  // Twin attivi, uno o più per provider. Patch in-place sull'oggetto live:
+  // nessuna (ri-)registrazione, quindi nessun conflitto di ownership con
+  // altre estensioni (es. pi-accounts) e nessuna entry spuria nel registry.
   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;
+    /** Oggetto live patchato (per unpatch mirato senza registry). */
+    live?: Provider;
   }
   const overlays = new Map<string, OverlayState>();
 
@@ -194,12 +223,114 @@ export default function (pi: ExtensionAPI) {
     return getConfig();
   }
 
-  /** Provider upstream vero: il nostro upstream catturato, o il live dal registry. */
+  function captureVerificationManifest(cwd: string): VerificationManifestTrust {
+    verificationCwd = cwd;
+    verificationManifestTrust = trustVerificationManifest(cwd, config.verification.manifestPath);
+    return verificationManifestTrust;
+  }
+
+  function verificationSnapshot(cwd: string): {
+    loaded: ReturnType<typeof loadVerificationManifest>;
+    status: VerificationStatus;
+  } {
+    const loaded = trustedVerificationManifest(
+      verificationManifestTrust,
+      cwd,
+      config.verification.manifestPath,
+    );
+    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 dal manifest locale validato. Questa funzione
+   * serve sia al tool del modello sia al comando utente /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,
     providerId: string,
   ): Provider | undefined {
-    return overlays.get(providerId)?.upstream ?? registry.getProvider(providerId);
+    try {
+      return registry.getProvider(providerId);
+    } catch {
+      return undefined;
+    }
   }
 
   function snapshotUpstream(
@@ -220,61 +351,50 @@ export default function (pi: ExtensionAPI) {
     return { provider, model: model as Model<Api> };
   }
 
-  /** Registra (o aggiorna) l'overlay di un provider con i suoi twin. */
-  function registerOverlay(
-    providerId: string,
-    upstream: Provider,
-    twinIds: string[],
-  ): void {
-    const overlay = buildOverlaidProvider({
-      upstream,
+  /** Applica (o aggiorna) la patch gate sull'oggetto provider live. */
+  function patchLiveProvider(live: Provider, twinIds: string[]): string[] {
+    return patchProvider(live, {
       twinModelIds: twinIds,
       getConfig,
       getReview: getGateReview,
       onVerdict: recordGateVerdict,
-      createPostCheck: createGroundingCheck,
-    });
-    pi.registerProvider(overlay);
-    overlays.set(providerId, {
-      upstream,
-      twinIds: [...twinIds],
-      provider: overlay,
+      createPostCheck,
     });
   }
 
   /**
-   * 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.
+   * Assicura la patch su tutti i twin attivi contro il provider live
+   * corrente. Se un'altra estensione (es. pi-accounts) ha sostituito
+   * l'oggetto, il nuovo viene patchato ex-novo; se l'oggetto è lo stesso
+   * ma non patchato, viene patchato. Non chiama mai register/unregister:
+   * la config del proprietario resta intatta e i suoi controlli di
+   * ownership non vedono alcuna "configuration changed".
+   * Ritorna i provider (ri-)patchati in questa chiamata.
    */
-  function reassertOverlays(registry: ModelRegistry): string[] {
-    const fixed: string[] = [];
+  function ensurePatches(registry: ModelRegistry): string[] {
+    // Re-patch sempre (idempotente ed economico): dopo un /reload la factory
+    // è nuova ma gli oggetti restano patchati con le closure vecchie, e la
+    // lista twin potrebbe essere cambiata. Si segnalano solo i provider che
+    // non erano patchati, per non spammare entry diagnostiche a ogni hook.
+    const patched: 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;
+      if (!live) continue;
+      const was = isPatched(live);
       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;
-        }
+        patchLiveProvider(live, state.twinIds);
+        state.live = live;
+        if (!was) patched.push(providerId);
       } catch {
-        const current = overlays.get(providerId);
-        if (current) current.reassertFailed = true;
+        // Riprova al prossimo hook; mai bloccare il flusso.
       }
     }
-    return fixed;
+    return patched;
   }
 
   /**
@@ -294,11 +414,13 @@ export default function (pi: ExtensionAPI) {
     }
 
     try {
-      // Provider non più gemellati: unregister → builtin ripristinato.
+      // Provider non più gemellati: ripristina i metodi originali (l'oggetto
+      // resta del proprietario: nessuna unregister che spiazzi gli altri).
       for (const providerId of [...overlays.keys()]) {
         if (!byProvider.has(providerId)) {
           try {
-            pi.unregisterProvider(providerId);
+            const live = registry.getProvider(providerId);
+            if (live) unpatchProvider(live);
           } catch {
             // ignora
           }
@@ -307,15 +429,23 @@ export default function (pi: ExtensionAPI) {
       }
 
       for (const [providerId, twinIds] of byProvider) {
-        // Cattura il live PRIMA dell'override (dopo, getProvider dà l'overlay).
-        const existing = overlays.get(providerId)?.upstream;
-        const live = existing ?? registry.getProvider(providerId);
+        // Sempre il live corrente: con la patch non esistono chain di
+        // upstream stale da preservare.
+        const live = liveUpstreamProvider(registry, providerId);
         if (!live) return { ok: false, error: `Provider non trovato: ${providerId}` };
         for (const model of twinIds) {
           const has = live.getModels().some((m) => m.id === model && !isTwinId(m.id));
           if (!has) return { ok: false, error: `Modello non trovato: ${providerId}/${model}` };
         }
-        registerOverlay(providerId, live, twinIds);
+        try {
+          patchLiveProvider(live, twinIds);
+        } catch (error) {
+          return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+          };
+        }
+        overlays.set(providerId, { twinIds: [...twinIds], live });
       }
 
       config = withTwinRefs(config, refs);
@@ -383,21 +513,20 @@ export default function (pi: ExtensionAPI) {
     };
   }
 
-  /** Rimuove tutti gli overlay (i builtin tornano da soli). */
+  /** Rimuove tutte le patch (i metodi originali tornano da soli). */
   function removeGuarded(): { ok: boolean; error?: string; removed?: number } {
     if (overlays.size === 0) return { ok: false, error: "nessun guarded attivo" };
     const removed = overlays.size;
-    for (const providerId of [...overlays.keys()]) {
+    // Nessuna unregister: gli oggetti restano del proprietario, si
+    // ripristinano solo i metodi sugli oggetti che abbiamo patchato.
+    for (const state of [...overlays.values()]) {
       try {
-        pi.unregisterProvider(providerId);
-      } catch (error) {
-        return {
-          ok: false,
-          error: error instanceof Error ? error.message : String(error),
-        };
+        if (state.live) unpatchProvider(state.live);
+      } catch {
+        // ignora
       }
-      overlays.delete(providerId);
     }
+    overlays.clear();
     return { ok: true, removed };
   }
 
@@ -438,6 +567,8 @@ export default function (pi: ExtensionAPI) {
     keyPresent: () => resolveBackend(getConfig()).apiKeyPresent,
   });
 
+  registerVerificationTool(pi, { run: runProjectVerification });
+
   registerJevCommand(pi, {
     config: getConfig,
     setMode: (mode) => {
@@ -479,63 +610,66 @@ 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,
+        ...(loaded.ok ? { manifestLoaded: true } : { 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);
+      return refresh();
+    },
+    reloadVerificationManifest: (cwd) => {
+      const trusted = captureVerificationManifest(cwd);
+      return trusted.ok
+        ? { ok: true, path: trusted.path }
+        : { ok: false, error: trusted.error };
+    },
+    runVerification: ({ cwd, selection, signal, trusted }) =>
+      runProjectVerification({ cwd, selection, signal, trusted }),
     getLastGate: () => lastGate,
   });
 
-  // 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 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) {
-    seedRefs = twinRefs(config);
-  }
-  if (seedRefs.length > 0) {
-    // Raggruppa per provider: un overlay per provider con tutti i suoi twin.
-    const byProvider = new Map<string, string[]>();
-    for (const ref of seedRefs) {
-      const list = byProvider.get(ref.provider) ?? [];
-      if (!list.includes(ref.model)) list.push(ref.model);
-      byProvider.set(ref.provider, list);
-    }
-    for (const [providerId, twinIds] of byProvider) {
-      try {
-        // providers/all è mappato dagli alias di pi; il subpath del singolo
-        // provider non lo è e fallirebbe a load (solo installazioni npm).
-        const base = builtinProviders().find((p) => p.id === providerId);
-        if (!base) throw new Error(`provider ${providerId} not in builtins`);
-        // Il catalogo builtin può non avere i modelli salvati: provider
-        // dinamici (es. openai-codex) li tengono nel models-store, altri
-        // (deepseek-flash su versioni vecchie) in una definizione statica.
-        const extra = [
-          ...(providerId === "deepseek" ? [STATIC_DEEPSEEK_FLASH] : []),
-          ...readStoreModels(providerId),
-        ];
-        const seedUpstream: Provider = {
-          ...base,
-          getModels: () => mergeModelsById(base.getModels(), extra),
-        };
-        const known = new Set(seedUpstream.getModels().map((m) => m.id));
-        const usable = twinIds.filter((model) => known.has(model));
-        if (usable.length === 0) continue;
-        registerOverlay(providerId, seedUpstream, usable);
-      } catch {
-        // Provider non gemellabile all'avvio: session_start riproverà dal registry.
-      }
-    }
-  }
+  // NOTA: nessun seed di boot con oggetti fake. La patch lavora SOLO
+  // sull'oggetto live del registry: registrare un oggetto nostro
+  // cancellerebbe la config del proprietario (es. pi-accounts vedrebbe
+  // "configuration changed" e abortirebbe i turni). I twin salvati vengono
+  // patchati a session_start (ogni modalità) e il twin automatic viene
+  // riselezionato lì; un twin persistito non ripristinabile cade sul modello
+  // di default e startSession lo riseleziona.
 
   async function startSession(ctx: ExtensionContext): Promise<void> {
     restoreMode(ctx);
     // 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.
+    try {
+      if (twinRefs(config).length > 0) {
+        applyTwins(twinRefs(config), ctx.modelRegistry, false);
+      }
+    } catch {
+      // session_start non deve mai fallire per il seed.
+    }
     const auto = process.env.JEV_AUTO_UPSTREAM?.trim();
     if (auto && auto !== "0" && auto.toLowerCase() !== "off") {
       try {
@@ -615,9 +749,9 @@ export default function (pi: ExtensionAPI) {
     try {
       const refs = twinRefs(config);
       if (refs.length === 0) return;
-      // Ricuci gli overlay noti scalzati contro il provider live corrente.
-      reassertOverlays(registry);
-      // Registra ex-novo i provider gemellati senza overlay (seed precoce).
+      // Ricuci le patch su oggetti sostituiti dal proprietario.
+      ensurePatches(registry);
+      // Patch ex-novo i provider gemellati senza stato (seed precoce).
       const byProvider = new Map<string, string[]>();
       for (const ref of refs) {
         if (overlays.get(ref.provider)?.twinIds.includes(ref.model)) continue;
@@ -632,13 +766,17 @@ export default function (pi: ExtensionAPI) {
         } catch {
           continue;
         }
-        if (!live) continue;
+        if (!live || isPatched(live)) {
+          if (live) overlays.set(providerId, { twinIds: [...twinIds], live });
+          continue;
+        }
         const models = live.getModels();
         if (!twinIds.every((id) => models.some((m) => m.id === id && !isTwinId(m.id)))) {
           continue;
         }
         try {
-          registerOverlay(providerId, live, twinIds);
+          patchLiveProvider(live, twinIds);
+          overlays.set(providerId, { twinIds: [...twinIds], live });
         } catch {
           // Riprova al prossimo hook; mai bloccare l'input.
         }
@@ -663,9 +801,21 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
+  // Ultima rete prima della generation: dopo eventuali replace altrui nel
+  // 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.
+    }
+  });
+
   pi.on("before_agent_start", async (_event, ctx) => {
     try {
-      noteReassert(reassertOverlays(ctx.modelRegistry));
+      verificationCwd = ctx.cwd;
+      noteReassert(ensurePatches(ctx.modelRegistry));
     } catch {
       // mai bloccare il turno
     }
@@ -719,8 +869,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));
+      // Una selezione account/provider può aver sostituito l'oggetto: ripatcha.
+      noteReassert(ensurePatches(ctx.modelRegistry));
       if (sessionMode !== "automatic" || !config.automatic.requireGuardedModel) return;
       if (overlays.size === 0) return;
       if (isGuardedModel(event.model.provider, event.model.id)) return;
@@ -769,6 +919,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 {
@@ -800,6 +982,20 @@ export default function (pi: ExtensionAPI) {
 
       if (event.toolName === "write" || event.toolName === "edit") {
         const input = event.input as { path?: unknown };
+        if (isVerificationManifestPath(input.path, ctx.cwd, config.verification.manifestPath)) {
+          pi.appendEntry("jev-tool-block", {
+            tool: event.toolName,
+            ruleId: "verification-manifest-immutable",
+            revision: TOOL_POLICY_REVISION,
+          });
+          if (ctx.hasUI) {
+            ctx.ui.notify("Jev tool policy: il modello non può modificare il manifest che autorizza i suoi check.", "warning");
+          }
+          return {
+            block: true,
+            reason: "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", {
@@ -892,6 +1088,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;
@@ -1040,12 +1290,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;
@@ -1113,9 +1478,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
+      // Dopo la richiesta: se qualcuno ha sostituito l'oggetto, ripatcha
       // per il turno successivo (il payload resta già normalizzato).
-      noteReassert(reassertOverlays(ctx.modelRegistry));
+      noteReassert(ensurePatches(ctx.modelRegistry));
       if (sessionMode !== "automatic") return;
       if (event.message.role !== "assistant") return;