pi-jev-guard 0.7.1 → 0.7.2

package/README.md

@@ -148,7 +148,9 @@ Non blocca mai; `/jev output` mostra l'ultimo verdetto.
 
 Sempre in `automatic`, il **grounding** (opt-in, default spento) confronta le
 affermazioni sulla sessione — "ho letto il file", "i test passano", "ho
-eseguito X" — con un registro evidenza costruito dai `tool_result`
+eseguito X", "il guard riporta X" — con un registro evidenza costruito dai
+`tool_result` e dai fatti generati dal guard (footer di verifica, run
+`jev_verify`)
 (comandi, test, letture, modifiche; redatto, max 30 voci, solo sessione
 corrente). Due domande Jev strette: contraddizione con l'evidenza e
 affermazione non supportata. Senza evidenza non si giudica: "senza
@@ -165,7 +167,9 @@ 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”.
+diventare “test passati”. Un report di “verifica” scritto dal modello non ha
+valore: il footer autorevole è solo quello del guard (marcato `generata dal
+guard, non dal modello`) e una guideline ai tool scoraggia le imitazioni.
 
 #### Nuovi progetti: zero manifest locale
 

package/extensions/index.ts

@@ -32,6 +32,7 @@ import {
   OUTPUT_QUESTIONS,
   buildOutputState,
   createVerdictCache,
+  elideText,
   evaluateOutput,
   outputKey,
   toolResultText,
@@ -52,6 +53,7 @@ import {
   decideGroundingAction,
   evaluateGrounding,
   groundingKey,
+  guardEvidenceEntry,
   recordEvidence,
   recordToolResult,
   parseExitCode,
@@ -73,6 +75,7 @@ import {
   selectVerificationChecks,
   trustVerificationPolicy,
   trustedVerificationPolicy,
+  verificationNotice,
   type VerificationManifestTrust,
   type VerificationStatus,
 } from "../src/verification.ts";
@@ -224,7 +227,7 @@ export default function (pi: ExtensionAPI) {
    * 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: {
+  async function executeProjectVerification(args: {
     cwd: string;
     selection: string | undefined;
     signal?: AbortSignal;
@@ -273,6 +276,27 @@ export default function (pi: ExtensionAPI) {
     };
   }
 
+  /** Wrapper audit: ogni run (tool o comando) è evidenza per il grounding. */
+  async function runProjectVerification(args: {
+    cwd: string;
+    selection: string | undefined;
+    signal?: AbortSignal;
+    trusted: boolean;
+  }): Promise<VerificationToolRunResult> {
+    const outcome = await executeProjectVerification(args);
+    recordGuardFact({
+      tool: "jev_verify",
+      summary: `jev_verify: ${args.selection ?? "recommended"} → ${
+        outcome.results.length > 0
+          ? outcome.results.map((r) => `${r.id}:${r.ok ? "pass" : "fail"}`).join(", ")
+          : "nessun check eseguito"
+      }`,
+      ok: outcome.results.length > 0 && outcome.results.every((r) => r.ok),
+      excerpt: outcome.message,
+    });
+    return outcome;
+  }
+
   /** Provider live corrente dal registry (sempre fresco, mai snapshot). */
   function liveUpstreamProvider(
     registry: ModelRegistry,
@@ -860,6 +884,39 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
+  /**
+   * I fatti generati dal guard (footer di verifica, run jev_verify) sono
+   * evidenza di prima classe per il grounding: senza questo, citare "il guard
+   * riporta X" risulterebbe sempre un'affermazione non supportata.
+   */
+  function recordGuardFact(args: {
+    tool: "jev-guard" | "jev_verify";
+    summary: string;
+    ok: boolean;
+    excerpt?: string;
+  }): void {
+    try {
+      if (sessionMode !== "automatic" || !config.grounding.enabled) return;
+      const excerpt = args.excerpt?.trim()
+        ? elideText(args.excerpt.trim(), Math.max(0, config.grounding.excerptChars))
+        : undefined;
+      const entry = guardEvidenceEntry({
+        tool: args.tool,
+        summary: args.summary,
+        ok: args.ok,
+        ...(excerpt ? { excerpt } : {}),
+        seq: ++evidenceSeq,
+        at: Date.now(),
+      });
+      recordEvidence(evidenceLedger, entry, {
+        maxEntries: config.grounding.maxEntries,
+        invalidateTestsOnEdit: config.grounding.invalidateTestsOnEdit,
+      });
+    } catch {
+      // Mai rompere il flusso per il ledger.
+    }
+  }
+
   function throttledGroundingError(error: unknown): void {
     const now = Date.now();
     if (now - lastGroundingErrorAt < 60_000) return;
@@ -996,6 +1053,14 @@ export default function (pi: ExtensionAPI) {
       return async () => {
         const { status } = verificationSnapshot(cwd);
         if (status.changedFiles.length === 0) return { action: "publish" };
+        // Il footer è un fatto del guard: entra nell'evidenza grounding,
+        // così citarlo ("il guard riporta X") resta un claim verificabile.
+        recordGuardFact({
+          tool: "jev-guard",
+          summary: `jev-guard: policy=${status.manifestSourceLabel ?? "sconosciuta"}; modifiche=${status.changedFiles.join(", ") || "nessuna"}; check=${status.checks.map((item) => `${item.check.id}:${item.state}`).join(", ") || "nessuno"}`,
+          ok: status.allPassed,
+          ...(verificationNotice(status) ? { excerpt: verificationNotice(status) } : {}),
+        });
         const decision = decideVerificationAction({
           status,
           mode,

package/package.json

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

package/src/grounding.ts

@@ -21,7 +21,7 @@ import type {
 
 export type GroundingMode = "warn" | "repair" | "hold";
 
-export type EvidenceKind = "command" | "test" | "read" | "modify";
+export type EvidenceKind = "command" | "test" | "read" | "modify" | "verification";
 
 export interface EvidenceEntry {
   seq: number;
@@ -49,6 +49,38 @@ export function isTestCommand(command: string): boolean {
   return TEST_COMMAND.test(command);
 }
 
+/**
+ * Prove di esito (test o verifica progetto): una modifica successiva le rende
+ * stale — non provano più lo stato attuale del codice.
+ */
+export function isOutcomeEvidence(kind: EvidenceKind): boolean {
+  return kind === "test" || kind === "verification";
+}
+
+/**
+ * Fatto generato dal guard (footer di verifica, run jev_verify): entra
+ * nell'evidenza al pari dei tool_result, così le affermazioni
+ * "il guard riporta X" sono verificabili invece di sembrare inventate.
+ */
+export function guardEvidenceEntry(args: {
+  tool: "jev-guard" | "jev_verify";
+  summary: string;
+  ok: boolean;
+  seq: number;
+  at: number;
+  excerpt?: string;
+}): EvidenceEntry {
+  return {
+    seq: args.seq,
+    at: args.at,
+    tool: args.tool,
+    kind: "verification",
+    summary: args.summary,
+    ok: args.ok,
+    ...(args.excerpt ? { excerpt: args.excerpt } : {}),
+  };
+}
+
 const EXIT_CODE = /Command exited with code (\d+)/;
 
 /** Exit code dal testo d'errore pi ("Command exited with code N"). */
@@ -152,7 +184,7 @@ export function recordEvidence(
   let invalidated = 0;
   if (opts.invalidateTestsOnEdit && entry.kind === "modify" && entry.ok) {
     for (const prior of ledger) {
-      if (prior.kind === "test" && !prior.stale && prior.seq < entry.seq) {
+      if (isOutcomeEvidence(prior.kind) && !prior.stale && prior.seq < entry.seq) {
         prior.stale = true;
         invalidated++;
       }
@@ -197,7 +229,7 @@ export function buildEvidenceDigest(
   }
   return {
     entries,
-    hasStaleTests: recent.some((e) => e.kind === "test" && e.stale),
+    hasStaleTests: recent.some((e) => isOutcomeEvidence(e.kind) && e.stale),
   };
 }
 

package/src/tools.ts

@@ -20,6 +20,7 @@ export function registerJevTool(
       "Use jev_validate when an independent targeted check is useful.",
       "Do not describe review or unavailable as successful validation.",
       "Jev validation does not replace compilation or tests.",
+      "Do not write your own verification-status sections in replies: the guard appends the only authoritative footer.",
     ],
     parameters: Type.Object({
       requirements: Type.String({ minLength: 1, maxLength: 16000 }),

package/src/verification-tool.ts

@@ -34,6 +34,7 @@ export function registerVerificationTool(
       "After a successful edit/write, call jev_verify with check='recommended' when verification is enabled.",
       "Use only this tool's declared check ids; never claim code compiles or tests pass without its observed result.",
       "If a check fails, inspect its actual output, repair the code, then run the check again.",
+      "Never write your own verification report or imitate the guard footer in replies: the guard appends the only authoritative footer.",
     ],
     parameters: Type.Object({
       check: Type.Optional(