pi-jev-guard 0.7.0 → 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
 
@@ -190,10 +194,11 @@ comandi fissi dell'estensione quando trova segnali convenzionali:
 | `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 ./...` |
+| `*.sln` / `*.csproj` (root o 2 livelli) | `dotnet build`, `dotnet test` |
 | configurazione pytest | `python -m pytest` |
 | repository Git | `git diff --check` |
 
-Il profilo sceglie un solo ecosistema (Node → Rust → Go → Python) e aggiunge
+Il profilo sceglie un solo ecosistema (Node → Rust → Go → .NET → 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.

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.0",
+  "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),
   };
 }
 
@@ -296,7 +328,7 @@ export interface GroundingDecision {
 
 /** Nota accodata al testo pubblicato quando il grounding scatta senza hold. */
 export function groundingNotice(reasons: string[]): string {
-  return `\n\n> [jev] grounding: affermazioni sulla sessione non supportate dall'evidenza (${reasons.join(", ")}) — verifica col modello i file/comandi citati.`;
+  return `\n\n> [jev] grounding: affermazioni sulla sessione non supportate dall'evidenza (${reasons.join(", ")}) — controlla i file/comandi citati prima di darli per verificati.`;
 }
 
 /** Feedback per la rigenerazione: correggere, non accusare. */

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(

package/src/verification.ts

@@ -7,7 +7,7 @@
  * dati, non dal testo del modello, quindi non può inventare test superati.
  */
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 
@@ -340,6 +340,14 @@ interface ProfileInput {
   text: string;
 }
 
+/** Selezione del profilo: comandi fissi + input che decidono se applicarsi. */
+interface ProfileSelection {
+  checks: VerificationCheck[];
+  inputs: ProfileInput[];
+  /** Solo nomi dei marker (es. .sln/.csproj): il contenuto non sceglie comandi. */
+  markers?: string[];
+}
+
 function readProfileInput(path: string): ProfileInput | { error: string } {
   try {
     if (statSync(path).size > MAX_PROFILE_INPUT_BYTES) {
@@ -370,7 +378,7 @@ function findGitRoot(cwd: string): string | undefined {
 }
 
 function nodeProfile(root: string):
-  | { checks: VerificationCheck[]; inputs: ProfileInput[] }
+  | ProfileSelection
   | { error: string }
   | undefined {
   const path = join(root, "package.json");
@@ -408,7 +416,7 @@ function markerProfile(args: {
   root: string;
   marker: string;
   checks: VerificationCheck[];
-}): { checks: VerificationCheck[]; inputs: ProfileInput[] } | { error: string } | undefined {
+}): ProfileSelection | { error: string } | undefined {
   const path = join(args.root, args.marker);
   if (!existsSync(path)) return undefined;
   const input = readProfileInput(path);
@@ -416,8 +424,59 @@ function markerProfile(args: {
   return { checks: args.checks, inputs: [input] };
 }
 
+const DOTNET_MARKER_EXT = [".sln", ".csproj", ".fsproj", ".vbproj"];
+const DOTNET_SKIP_DIRS = new Set(["node_modules", ".git", "bin", "obj"]);
+const DOTNET_FILES = [
+  "**/*.cs", "**/*.fs", "**/*.vb",
+  "**/*.csproj", "**/*.fsproj", "**/*.vbproj", "**/*.sln",
+  "**/*.props", "**/*.targets", "global.json",
+];
+
+/**
+ * Marker .NET in root e due livelli di sottocartelle (bounded: max 40):
+ * solo nomi, il contenuto dei progetti non seleziona comandi — `dotnet
+ * build`/`dotnet test` sono fissi, quindi niente superficie di iniezione.
+ */
+function findDotnetMarkers(root: string): string[] {
+  const found: string[] = [];
+  const visit = (dir: string, depth: number): void => {
+    if (found.length >= 40 || depth > 2) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (found.length >= 40) return;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith(".") || DOTNET_SKIP_DIRS.has(entry.name)) continue;
+        visit(full, depth + 1);
+      } else if (DOTNET_MARKER_EXT.some((ext) => entry.name.endsWith(ext))) {
+        found.push(relative(root, full).split(sep).join("/"));
+      }
+    }
+  };
+  visit(root, 0);
+  return found.sort();
+}
+
+function dotnetProfile(root: string): ProfileSelection | undefined {
+  const markers = findDotnetMarkers(root);
+  if (markers.length === 0) return undefined;
+  return {
+    checks: [
+      { id: "dotnet-build", command: "dotnet build", description: ".NET build", files: DOTNET_FILES },
+      { id: "dotnet-test", command: "dotnet test", description: ".NET tests", files: [...DOTNET_FILES, "**/tests/**"] },
+    ],
+    inputs: [],
+    markers,
+  };
+}
+
 function pythonProfile(root: string):
-  | { checks: VerificationCheck[]; inputs: ProfileInput[] }
+  | ProfileSelection
   | { error: string }
   | undefined {
   const candidates = ["pytest.ini", "pyproject.toml", "setup.cfg"];
@@ -470,9 +529,10 @@ export function loadCommonVerificationProfile(cwd: string): LoadedVerificationMa
     checks: [{ id: "go-test", command: "go test ./...", description: "Go tests", files: ["**/*.go", "go.mod", "go.sum"] }],
   });
   if (go && "error" in go) return { ok: false, error: go.error };
-  const python = node || cargo || go ? undefined : pythonProfile(root);
+  const dotnet = node || cargo || go ? undefined : dotnetProfile(root);
+  const python = node || cargo || go || dotnet ? undefined : pythonProfile(root);
   if (python && "error" in python) return { ok: false, error: python.error };
-  const selected = node ?? cargo ?? go ?? python;
+  const selected = node ?? cargo ?? go ?? dotnet ?? python;
   const checks = selected ? [...selected.checks] : [];
   const gitRoot = findGitRoot(root);
   if (gitRoot) {
@@ -481,16 +541,18 @@ export function loadCommonVerificationProfile(cwd: string): LoadedVerificationMa
   if (checks.length === 0) {
     return {
       ok: false,
-      error: "nessun manifest locale e profilo globale common non applicabile (nessun progetto Node/Rust/Go/Python o repository Git rilevato)",
+      error: "nessun manifest locale e profilo globale common non applicabile (nessun progetto Node/Rust/Go/.NET/Python o repository Git rilevato)",
     };
   }
   const inputs = selected?.inputs ?? [];
+  const markers = selected?.markers ?? [];
   const manifest: VerificationManifest = { version: 1, checks };
   const fingerprint = fingerprintText(JSON.stringify({
     profile: "common-v1",
     root,
     gitRoot: gitRoot ?? null,
     inputs: inputs.map((input) => ({ path: input.path, text: input.text })),
+    markers,
     manifest,
   }));
   return {