pi-jev-guard 0.5.0 → 0.6.0

package/README.md

@@ -6,7 +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 esplicitamente autorizzati nel manifest locale; il modello può eseguire soltanto quegli id, mai shell arbitraria.
+- **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
 
@@ -183,54 +183,101 @@ grounding (`warned`/`repaired`/`held`).
 
 ### Verifica progetto deterministica (opt-in)
 
-Il grounding è probabilistico; per **compilazione, lint e test** è meglio una
-prova deterministica. La verifica progetto mantiene, solo nella sessione,
-una lista di `edit`/`write` riusciti e degli esiti osservati dei check. Il
-footer della risposta viene generato dall'estensione, non dal modello:
-quindi non può trasformare un test non eseguito in “test passati”.
+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”.
 
-1. Copia e adatta il manifest versionato/localmente controllato:
+#### 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
 ```
 
-2. Controllalo tu e acquisiscilo nella sessione (o riacquisiscilo dopo una
-   modifica manuale):
+Controllalo tu, poi acquisiscilo (e ripeti dopo ogni modifica manuale):
 
 ```text
 /jev verification reload
-/jev verification warn       # footer trasparente, nessuna rigenerazione
-# oppure: /jev verification repair|hold
 ```
 
-3. Dopo un edit, il modello può eseguire soltanto gli id dichiarati nel
-   manifest — mai una shell string fornita dal modello:
+In alternativa puoi definire **una** policy comune per tutti i tuoi progetti
+nella config utente, purché esista davvero e sia sotto il tuo controllo:
 
-```text
-/jev verify recommended      # i check pertinenti non ancora freschi
-/jev verify all              # tutti, fino a verification.maxCommands
-/jev verify typecheck        # un id esplicito del manifest
+```json
+{
+  "verification": {
+    "globalManifestPath": "~/.pi/agent/jev-verification.global.json",
+    "defaultProfile": "common"
+  }
+}
 ```
 
-Il tool LLM `jev_verify` ha lo stesso vincolo. Richiede un progetto trusted e
-non accetta comandi arbitrari. Footer/repair/hold operano nel twin in
-`automatic`; `/jev verify` può essere usato manualmente anche per controllare
-un progetto senza pubblicare un footer. Il manifest è acquisito a inizio sessione o
-con `/jev verification reload`; se cambia dopo, la verifica rifiuta di
-eseguire fino a una nuova acquisizione utente. `write`/`edit` del modello sul
-manifest sono bloccati; anche modifiche via shell vengono rilevate dal
-fingerprint e non aggiornano i comandi autorizzati. Il manifest è quindi una
-policy dell'utente/progetto, non una superficie di prompt injection.
+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 di invocare `jev_verify`; `hold` trattiene le risposte quando un
-check è fallito, e dopo il tentativo bounded anche quando resta mancante.
-Nessun manifest o nessun check pertinente è una limitazione dichiarata, non
-un fallimento del codice e non produce hold. La raccolta delle modifiche è
-limitata a `edit`/`write` osservati: una modifica fatta con shell non viene
-attribuita automaticamente al modello.
+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
 

package/config/jev-config.example.json

@@ -69,10 +69,11 @@
     "enabled": false,
     "mode": "warn",
     "manifestPath": ".pi/jev-verification.json",
+    "defaultProfile": "common",
     "maxRepairs": 1,
     "commandTimeoutMs": 120000,
     "outputChars": 6000,
-    "maxCommands": 3
+    "maxCommands": 4
   },
   "exfilCheck": {
     "enabled": true,

package/extensions/index.ts

@@ -68,16 +68,16 @@ import type { PostPublishCheckFn, PostPublishCheckResult } from "../src/automati
 import {
   buildVerificationStatus,
   createVerificationState,
-  isVerificationManifestPath,
+  isVerificationPolicyPath,
   decideVerificationAction,
-  loadVerificationManifest,
+  loadVerificationPolicy,
   manifestCheckForCommand,
   normalizeObservedPath,
   recordObservedModification,
   recordVerificationRun,
   selectVerificationChecks,
-  trustVerificationManifest,
-  trustedVerificationManifest,
+  trustVerificationPolicy,
+  trustedVerificationPolicy,
   type VerificationManifestTrust,
   type VerificationStatus,
 } from "../src/verification.ts";
@@ -225,18 +225,18 @@ export default function (pi: ExtensionAPI) {
 
   function captureVerificationManifest(cwd: string): VerificationManifestTrust {
     verificationCwd = cwd;
-    verificationManifestTrust = trustVerificationManifest(cwd, config.verification.manifestPath);
+    verificationManifestTrust = trustVerificationPolicy(cwd, config.verification);
     return verificationManifestTrust;
   }
 
   function verificationSnapshot(cwd: string): {
-    loaded: ReturnType<typeof loadVerificationManifest>;
+    loaded: ReturnType<typeof loadVerificationPolicy>;
     status: VerificationStatus;
   } {
-    const loaded = trustedVerificationManifest(
+    const loaded = trustedVerificationPolicy(
       verificationManifestTrust,
       cwd,
-      config.verification.manifestPath,
+      config.verification,
     );
     return { loaded, status: buildVerificationStatus(verificationState, loaded) };
   }
@@ -269,8 +269,8 @@ export default function (pi: ExtensionAPI) {
   }
 
   /**
-   * Esegue SOLO check estratti dal manifest locale validato. Questa funzione
-   * serve sia al tool del modello sia al comando utente /jev verify.
+   * 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;
@@ -616,7 +616,10 @@ export default function (pi: ExtensionAPI) {
         enabled: config.verification.enabled,
         mode: config.verification.mode,
         manifestPath: config.verification.manifestPath,
-        ...(loaded.ok ? { manifestLoaded: true } : { manifestLoaded: false, manifestError: loaded.error }),
+        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 })),
       };
@@ -630,12 +633,16 @@ export default function (pi: ExtensionAPI) {
         next.verification.mode = mode;
       }
       saveConfig(next);
-      return refresh();
+      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 }
+        ? { ok: true, path: trusted.path, sourceLabel: trusted.sourceLabel }
         : { ok: false, error: trusted.error };
     },
     runVerification: ({ cwd, selection, signal, trusted }) =>
@@ -982,18 +989,34 @@ 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)) {
+        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: "verification-manifest-immutable",
+            ruleId,
             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");
+            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: "Bloccato da jev tool policy (verification-manifest-immutable): modifica il manifest manualmente e poi usa /jev verification reload.",
+            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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-jev-guard",
-  "version": "0.5.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": [

package/src/commands.ts

@@ -19,7 +19,7 @@ import { reviewWithCoverage } from "./reviewer.ts";
 import type { Metrics } from "./metrics.ts";
 import type { OutputVerdict } from "./output-judge.ts";
 import type { GateVerdictReport } from "./automatic/guardian.ts";
-import type { VerificationMode } from "./verification.ts";
+import type { VerificationDefaultProfile, VerificationManifestSource, VerificationMode } from "./verification.ts";
 
 export interface GateStatusView {
   active: boolean;
@@ -84,7 +84,10 @@ export interface JevCommandDeps {
     enabled: boolean;
     mode: VerificationMode;
     manifestPath: string;
+    defaultProfile: VerificationDefaultProfile;
     manifestLoaded: boolean;
+    manifestSource?: VerificationManifestSource;
+    manifestSourceLabel?: string;
     manifestError?: string;
     changedFiles: string[];
     checks: Array<{ id: string; state: "passed" | "failed" | "pending" }>;
@@ -94,6 +97,7 @@ export interface JevCommandDeps {
     ok: boolean;
     error?: string;
     path?: string;
+    sourceLabel?: string;
   };
   runVerification?: (args: {
     cwd: string;
@@ -146,9 +150,9 @@ export const JEV_HELP_TEXT = [
   "  /jev grounding off|warn|repair|hold",
   "                           Grounding affermazioni sessione (solo automatic, opt-in)",
   "  /jev verification off|warn|repair|hold|reload",
-  "                           Footer deterministico + repair dai check progetto (opt-in; reload acquisisce manifest)",
+  "                           Footer deterministico; locale > manifest globale > profilo common (opt-in)",
   "  /jev verify [recommended|all|id]",
-  "                           Esegue solo check dichiarati in .pi/jev-verification.json",
+  "                           Esegue solo check della policy acquisita, mai shell arbitraria",
   "  /jev backend             Mostra backend attivo e chiavi rilevate",
   "  /jev backend auto|openrouter|typesafe",
   "                           Cambia backend (salvato in jev-config.json)",
@@ -281,8 +285,8 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
             `Grounding: ${cfg.grounding.enabled ? `attivo in automatic (mode=${cfg.grounding.mode}, evidenza=${deps.groundingStatus().entries}${deps.groundingStatus().hasStaleTests ? ", test stale" : ""})` : "disattivo (opt-in: /jev grounding warn)"}`,
             verification
               ? `Verifica progetto: ${verification.enabled
-                ? `attiva (mode=${verification.mode}, manifest=${verification.manifestLoaded ? "OK" : verification.manifestError ?? "assente"}, modifiche=${verification.changedFiles.length}, check=${verification.checks.map((check) => `${check.id}:${check.state}`).join(",") || "—"})`
-                : `disattiva (opt-in: /jev verification warn; manifest=${verification.manifestPath})`}`
+                ? `attiva (mode=${verification.mode}, policy=${verification.manifestLoaded ? verification.manifestSourceLabel ?? "OK" : verification.manifestError ?? "assente"}, modifiche=${verification.changedFiles.length}, check=${verification.checks.map((check) => `${check.id}:${check.state}`).join(",") || "—"})`
+                : `disattiva (opt-in: /jev verification warn; locale=${verification.manifestPath}, fallback=${verification.defaultProfile})`}`
               : "Verifica progetto: non disponibile in questa estensione",
             cfg.mode === "automatic"
               ? "ATTENZIONE: in automatic testo/codice vengono inviati al verificatore. Crea il twin con /jev upstream e seleziona il modello __jev per enforcement."
@@ -570,12 +574,13 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
             st.enabled
               ? [
                   `Verifica progetto attiva in automatic (mode=${st.mode}).`,
-                  `Manifest: ${st.manifestPath} — ${st.manifestLoaded ? "OK" : st.manifestError ?? "non disponibile"}.`,
+                  `Policy: ${st.manifestLoaded ? st.manifestSourceLabel ?? "OK" : st.manifestError ?? "non disponibile"}.`,
+                  `Override locale: ${st.manifestPath}; fallback integrato: ${st.defaultProfile}.`,
                   `Modifiche osservate: ${st.changedFiles.join(", ") || "nessuna"}.`,
                   `Check: ${st.checks.map((check) => `${check.id}:${check.state}`).join(", ") || "nessuno pertinente"}.`,
-                  "Esegui quelli mancanti con /jev verify recommended. Dopo una modifica manuale del manifest: /jev verification reload.",
+                  "Esegui quelli mancanti con /jev verify recommended. Dopo una modifica manuale della policy: /jev verification reload.",
                 ].join("\n")
-              : `Verifica progetto disattiva (opt-in). Manifest previsto: ${st.manifestPath}. Attiva con /jev verification warn|repair|hold.`,
+              : `Verifica progetto disattiva (opt-in). Override locale: ${st.manifestPath}; fallback: ${st.defaultProfile}. Attiva con /jev verification warn|repair|hold.`,
             "info",
           );
           return;
@@ -588,8 +593,8 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
           const reloaded = deps.reloadVerificationManifest(ctx.cwd);
           ctx.ui.notify(
             reloaded.ok
-              ? `Manifest verifica acquisito: ${reloaded.path}. I comandi verranno eseguiti solo da questa snapshot.`
-              : `Manifest verifica non acquisito: ${reloaded.error}`,
+              ? `Policy verifica acquisita: ${reloaded.sourceLabel ?? reloaded.path}. I comandi verranno eseguiti solo da questa snapshot.`
+              : `Policy verifica non acquisita: ${reloaded.error}`,
             reloaded.ok ? "info" : "warning",
           );
           return;
@@ -602,7 +607,7 @@ export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
         ctx.ui.notify(
           value === "off"
             ? "Verifica progetto disattivata."
-            : `Verifica progetto attiva (mode=${value}). Crea ${deps.verificationStatus(ctx.cwd).manifestPath} con i soli comandi approvati, poi usa /jev verify recommended.`,
+            : `Verifica progetto attiva (mode=${value}). Usa il profilo globale common automaticamente; un manifest locale in ${deps.verificationStatus(ctx.cwd).manifestPath} lo sovrascrive. Poi usa /jev verify recommended.`,
           "info",
         );
         return;

package/src/config.ts

@@ -197,15 +197,18 @@ export const DEFAULT_CONFIG: JevConfig = {
     invalidateTestsOnEdit: true,
   },
   verification: {
-    // Opt-in: il manifest può eseguire solo comandi esplicitamente approvati
-    // dal progetto; non abilitarlo silenziosamente in installazioni esistenti.
+    // Opt-in: solo una policy acquisita può autorizzare check; non abilitarla
+    // silenziosamente in installazioni esistenti.
     enabled: false,
     mode: "warn",
     manifestPath: ".pi/jev-verification.json",
+    // Profilo built-in per nuovi progetti: si attiva solo dopo il consenso
+    // esplicito /jev verification warn|repair|hold (enabled resta false).
+    defaultProfile: "common",
     maxRepairs: 1,
     commandTimeoutMs: 120000,
     outputChars: 6000,
-    maxCommands: 3,
+    maxCommands: 4,
   },
   exfilCheck: {
     enabled: true,
@@ -254,6 +257,21 @@ export function loadConfig(configPath?: string): JevConfig {
     fileConfig,
   ) as JevConfig;
 
+  // Normalizza il fallback verifica: config precedenti non lo contengono;
+  // valori manuali ignoti non devono disattivare/alterare la policy a caso.
+  if (!isRecord(loaded.verification)) {
+    loaded.verification = { ...DEFAULT_CONFIG.verification };
+  }
+  if (typeof loaded.verification.manifestPath !== "string" || !loaded.verification.manifestPath.trim()) {
+    loaded.verification.manifestPath = DEFAULT_CONFIG.verification.manifestPath;
+  }
+  if (loaded.verification.defaultProfile !== "common" && loaded.verification.defaultProfile !== "off") {
+    loaded.verification.defaultProfile = DEFAULT_CONFIG.verification.defaultProfile;
+  }
+  if (typeof loaded.verification.globalManifestPath !== "string") {
+    delete loaded.verification.globalManifestPath;
+  }
+
   // Normalizza la lista twin (config scritta a mano o da versioni vecchie):
   // dedup, scarta voci malformate, garantisce che il primario sia incluso.
   let merged = withTwinRefs(loaded, twinRefs(loaded));

package/src/verification-runner.ts

@@ -1,4 +1,4 @@
-/** Esecuzione bounded dei soli comandi dichiarati nel manifest di verifica. */
+/** Esecuzione bounded dei soli comandi dichiarati dalla policy di verifica acquisita. */
 import { spawn } from "node:child_process";
 import type { VerificationCheck, VerificationSettings } from "./verification.ts";
 
@@ -34,8 +34,8 @@ function appendBounded(state: { text: string; elided: number }, chunk: Buffer, m
 }
 
 /**
- * Esegue un comando scelto dal manifest. `command` non arriva mai dal modello;
- * il chiamante deve aver già selezionato un VerificationCheck validato.
+ * Esegue un comando scelto dalla policy. `command` non arriva mai dal modello;
+ * il chiamante deve aver già selezionato un VerificationCheck acquisito.
  */
 export async function runVerificationCheck(args: {
   check: VerificationCheck;
@@ -98,8 +98,8 @@ export async function runVerificationCheck(args: {
     };
 
     try {
-      // shell è necessario perché il manifest contiene comandi normali come
-      // `npm run typecheck`; la fiducia arriva dal file locale + project trust.
+      // shell è necessario per comandi normali come `npm run typecheck`; la
+      // fiducia arriva dalla policy acquisita + project trust.
       child = spawn(check.command, {
         cwd,
         shell: true,

package/src/verification-tool.ts

@@ -27,7 +27,7 @@ export function registerVerificationTool(
     name: "jev_verify",
     label: "Jev project verification",
     description:
-      "Run a project-approved typecheck, lint, or test declared in .pi/jev-verification.json. " +
+      "Run a typecheck, lint, or test authorized by the acquired local/global verification policy. " +
       "It never accepts arbitrary shell commands.",
     promptSnippet: "Run approved project verification checks after code edits.",
     promptGuidelines: [

package/src/verification.ts

@@ -7,12 +7,16 @@
  * dati, non dal testo del modello, quindi non può inventare test superati.
  */
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
-import { isAbsolute, relative, resolve, sep } from "node:path";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 
 export type VerificationMode = "warn" | "repair" | "hold";
+/** Profilo integrato usato quando non esiste un override locale/globale. */
+export type VerificationDefaultProfile = "common" | "off";
+export type VerificationManifestSource = "project" | "global-manifest" | "global-profile";
 
-/** Impostazioni condivise; i comandi eseguibili restano nel manifest locale. */
+/** Impostazioni condivise; i comandi eseguibili arrivano solo dalla policy acquisita. */
 export interface VerificationSettings {
   /** Opt-in: nessun footer, repair o comando automatico finché è false. */
   enabled: boolean;
@@ -20,6 +24,10 @@ export interface VerificationSettings {
   mode: VerificationMode;
   /** File JSON relativo alla root del progetto, mai un comando generato dal modello. */
   manifestPath: string;
+  /** Manifest opzionale dell'utente, assoluto o con `~/`; fallback dopo quello locale. */
+  globalManifestPath?: string;
+  /** Fallback integrato per nuovi progetti; resta inattivo finché enabled=false. */
+  defaultProfile: VerificationDefaultProfile;
   /** Rigenerazioni massime per risposta quando mancano/falliscono check. */
   maxRepairs: number;
   /** Timeout massimo predefinito dei check avviati da jev_verify o /jev verify. */
@@ -33,7 +41,7 @@ export interface VerificationSettings {
 export interface VerificationCheck {
   /** Id stabile, usato da /jev verify e dal tool jev_verify. */
   id: string;
-  /** Comando esplicitamente approvato dal manifest del progetto. */
+  /** Comando esplicitamente approvato dalla policy acquisita. */
   command: string;
   /** Glob dei file a cui il check si applica; assente = tutte le modifiche. */
   files?: string[];
@@ -48,12 +56,31 @@ export interface VerificationManifest {
 }
 
 export type LoadedVerificationManifest =
-  | { ok: true; path: string; manifest: VerificationManifest; fingerprint: string }
+  | {
+      ok: true;
+      /** Percorso assoluto per manifest file, identificatore stabile per profilo integrato. */
+      path: string;
+      source: VerificationManifestSource;
+      sourceLabel: string;
+      /** File che influenzano i comandi autorizzati e che il modello non può alterare. */
+      protectedPaths: string[];
+      manifest: VerificationManifest;
+      fingerprint: string;
+    }
   | { ok: false; path?: string; error: string };
 
-/** Manifest acquisito a inizio sessione o su comando utente esplicito. */
+/** Manifest/profilo acquisito a inizio sessione o su comando utente esplicito. */
 export type VerificationManifestTrust =
-  | { ok: true; cwd: string; path: string; manifest: VerificationManifest; fingerprint: string }
+  | {
+      ok: true;
+      cwd: string;
+      path: string;
+      source: VerificationManifestSource;
+      sourceLabel: string;
+      protectedPaths: string[];
+      manifest: VerificationManifest;
+      fingerprint: string;
+    }
   | { ok: false; cwd: string; error: string };
 
 /** Un edit/write osservato con successo; non pretende di vedere modifiche via shell. */
@@ -94,6 +121,9 @@ export interface VerificationCheckStatus {
 
 export interface VerificationStatus {
   changedFiles: string[];
+  /** Origine della policy che ha autorizzato i check correnti. */
+  manifestSource?: VerificationManifestSource;
+  manifestSourceLabel?: string;
   /** Errore/mancanza manifest: non è una prova negativa sul codice. */
   manifestError?: string;
   checks: VerificationCheckStatus[];
@@ -110,8 +140,8 @@ export function createVerificationState(): VerificationState {
 
 /**
  * Trasforma un path tool in un path relativo al progetto. I path fuori root
- * non entrano nel manifest locale: possono essere riportati dal modello, ma
- * non diventano falsamente coperti da un check del progetto corrente.
+ * non entrano nella policy del progetto: possono essere riportati dal modello,
+ * ma non diventano falsamente coperti da un check del progetto corrente.
  */
 export function normalizeObservedPath(path: unknown, cwd: string): string | undefined {
   if (typeof path !== "string" || !path.trim()) return undefined;
@@ -237,6 +267,16 @@ export function resolveManifestPath(cwd: string, manifestPath: string): string |
   return target;
 }
 
+/** Un manifest globale è una scelta esplicita della config dell'utente: solo path assoluto o `~/`. */
+export function resolveGlobalManifestPath(manifestPath: string | undefined): string | undefined {
+  const raw = manifestPath?.trim();
+  if (!raw) return undefined;
+  const expanded = raw === "~"
+    ? homedir()
+    : raw.startsWith("~/") ? join(homedir(), raw.slice(2)) : raw;
+  return isAbsolute(expanded) ? resolve(expanded) : undefined;
+}
+
 /** Il modello non può alterare la policy che autorizza i suoi comandi. */
 export function isVerificationManifestPath(
   path: unknown,
@@ -246,7 +286,37 @@ export function isVerificationManifestPath(
   if (typeof path !== "string" || !path.trim()) return false;
   const manifest = resolveManifestPath(cwd, manifestPath);
   if (!manifest) return false;
-  return resolve(cwd, path.trim()) === manifest;
+  return canonicalPolicyPath(resolve(cwd, path.trim())) === canonicalPolicyPath(manifest);
+}
+
+function canonicalPolicyPath(path: string): string {
+  const resolved = resolve(path);
+  try {
+    // Il confronto passa dal target reale: una symlink non consente di
+    // aggirare l'immutabilità del manifest o di package.json acquisito.
+    return realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+function normalizedToolPath(path: string, cwd: string): string {
+  const trimmed = path.trim();
+  const expanded = trimmed === "~"
+    ? homedir()
+    : trimmed.startsWith("~/") ? join(homedir(), trimmed.slice(2)) : trimmed;
+  return canonicalPolicyPath(resolve(cwd, expanded));
+}
+
+/** Protegge anche input (es. package.json) che decidono un profilo globale. */
+export function isVerificationPolicyPath(
+  path: unknown,
+  cwd: string,
+  trust: VerificationManifestTrust | undefined,
+): boolean {
+  if (typeof path !== "string" || !path.trim() || !trust?.ok || trust.cwd !== resolve(cwd)) return false;
+  const target = normalizedToolPath(path, cwd);
+  return trust.protectedPaths.includes(target);
 }
 
 function fingerprintText(text: string): string {
@@ -255,85 +325,345 @@ function fingerprintText(text: string): string {
   return createHash("sha256").update(text).digest("hex");
 }
 
-export function loadVerificationManifest(
-  cwd: string,
-  manifestPath: string,
-): LoadedVerificationManifest {
-  const path = resolveManifestPath(cwd, manifestPath);
-  if (!path) {
-    return { ok: false, error: "percorso manifest non valido: deve restare dentro il progetto" };
+const COMMON_PROFILE_PATH = "<global-profile:common-v1>";
+const MAX_MANIFEST_BYTES = 1_000_000;
+const MAX_PROFILE_INPUT_BYTES = 1_000_000;
+const MAX_PROFILE_INPUT_CHARS = 1_000_000;
+const NODE_CODE_FILES = [
+  "**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.mjs", "**/*.cjs",
+  "package.json", "tsconfig.json", "tsconfig.*.json",
+];
+const NODE_TEST_FILES = [...NODE_CODE_FILES, "test/**", "tests/**", "__tests__/**"];
+
+interface ProfileInput {
+  path: string;
+  text: string;
+}
+
+function readProfileInput(path: string): ProfileInput | { error: string } {
+  try {
+    if (statSync(path).size > MAX_PROFILE_INPUT_BYTES) {
+      return { error: `${path} supera ${MAX_PROFILE_INPUT_BYTES} byte` };
+    }
+    const text = readFileSync(path, "utf8");
+    if (text.length > MAX_PROFILE_INPUT_CHARS) {
+      return { error: `${path} supera ${MAX_PROFILE_INPUT_CHARS} caratteri` };
+    }
+    return { path, text };
+  } catch (error) {
+    return { error: `${path}: ${error instanceof Error ? error.message : String(error)}` };
   }
-  if (!existsSync(path)) {
-    return { ok: false, path, error: `manifest non trovato: ${manifestPath}` };
+}
+
+function isProfileInput(value: ProfileInput | { error: string }): value is ProfileInput {
+  return "text" in value;
+}
+
+function findGitRoot(cwd: string): string | undefined {
+  let current = resolve(cwd);
+  while (true) {
+    if (existsSync(join(current, ".git"))) return current;
+    const parent = dirname(current);
+    if (parent === current) return undefined;
+    current = parent;
   }
+}
+
+function nodeProfile(root: string):
+  | { checks: VerificationCheck[]; inputs: ProfileInput[] }
+  | { error: string }
+  | undefined {
+  const path = join(root, "package.json");
+  if (!existsSync(path)) return undefined;
+  const input = readProfileInput(path);
+  if (!isProfileInput(input)) return input;
+  let parsed: unknown;
   try {
-    const text = readFileSync(path, "utf8");
+    parsed = JSON.parse(input.text);
+  } catch (error) {
+    return { error: `profilo globale: package.json non valido: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const scripts = isRecord(parsed) && isRecord(parsed.scripts) ? parsed.scripts : {};
+  const hasScript = (name: string) => typeof scripts[name] === "string" && scripts[name].trim().length > 0;
+  const checks: VerificationCheck[] = [];
+  if (hasScript("typecheck")) {
+    checks.push({ id: "node-typecheck", command: "npm run typecheck", description: "Node/TypeScript typecheck", files: NODE_CODE_FILES });
+  }
+  if (hasScript("lint")) {
+    checks.push({ id: "node-lint", command: "npm run lint", description: "Node lint", files: NODE_CODE_FILES });
+  }
+  const testScript = ["test:unit", "test:ci", "test"].find(hasScript);
+  if (testScript) {
+    checks.push({
+      id: "node-test",
+      command: testScript === "test" ? "npm test" : `npm run ${testScript}`,
+      description: `Node test (${testScript})`,
+      files: NODE_TEST_FILES,
+    });
+  }
+  return checks.length > 0 ? { checks, inputs: [input] } : undefined;
+}
+
+function markerProfile(args: {
+  root: string;
+  marker: string;
+  checks: VerificationCheck[];
+}): { checks: VerificationCheck[]; inputs: ProfileInput[] } | { error: string } | undefined {
+  const path = join(args.root, args.marker);
+  if (!existsSync(path)) return undefined;
+  const input = readProfileInput(path);
+  if (!isProfileInput(input)) return input;
+  return { checks: args.checks, inputs: [input] };
+}
+
+function pythonProfile(root: string):
+  | { checks: VerificationCheck[]; inputs: ProfileInput[] }
+  | { error: string }
+  | undefined {
+  const candidates = ["pytest.ini", "pyproject.toml", "setup.cfg"];
+  const inputs: ProfileInput[] = [];
+  for (const name of candidates) {
+    const path = join(root, name);
+    if (!existsSync(path)) continue;
+    const input = readProfileInput(path);
+    if (!isProfileInput(input)) return input;
+    inputs.push(input);
+  }
+  const pytestConfigured = inputs.some((input) =>
+    input.path.endsWith("pytest.ini") ||
+    /\[(?:tool\.pytest(?:\.ini_options)?|tool:pytest)\]/.test(input.text) ||
+    /["']pytest(?:[<>=~!][^"']*)?["']/.test(input.text),
+  );
+  if (!pytestConfigured) return undefined;
+  return {
+    checks: [{
+      id: "python-pytest",
+      command: "python -m pytest",
+      description: "Python pytest",
+      files: ["**/*.py", "pyproject.toml", "pytest.ini", "setup.cfg"],
+    }],
+    inputs,
+  };
+}
+
+/**
+ * Profilo built-in, deliberatamente conservativo. I comandi sono nel codice
+ * dell'estensione, non arrivano dal repository o dal modello; i file che ne
+ * abilitano la selezione entrano nel fingerprint/protectedPaths della snapshot.
+ */
+export function loadCommonVerificationProfile(cwd: string): LoadedVerificationManifest {
+  const root = resolve(cwd);
+  const node = nodeProfile(root);
+  if (node && "error" in node) return { ok: false, error: node.error };
+  const cargo = node ? undefined : markerProfile({
+    root,
+    marker: "Cargo.toml",
+    checks: [
+      { id: "cargo-check", command: "cargo check", description: "Rust compile check", files: ["**/*.rs", "Cargo.toml", "Cargo.lock", "build.rs"] },
+      { id: "cargo-test", command: "cargo test", description: "Rust tests", files: ["**/*.rs", "Cargo.toml", "Cargo.lock", "build.rs", "tests/**"] },
+    ],
+  });
+  if (cargo && "error" in cargo) return { ok: false, error: cargo.error };
+  const go = node || cargo ? undefined : markerProfile({
+    root,
+    marker: "go.mod",
+    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);
+  if (python && "error" in python) return { ok: false, error: python.error };
+  const selected = node ?? cargo ?? go ?? python;
+  const checks = selected ? [...selected.checks] : [];
+  const gitRoot = findGitRoot(root);
+  if (gitRoot) {
+    checks.push({ id: "git-diff-check", command: "git diff --check", description: "Whitespace and patch integrity" });
+  }
+  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)",
+    };
+  }
+  const inputs = selected?.inputs ?? [];
+  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 })),
+    manifest,
+  }));
+  return {
+    ok: true,
+    path: COMMON_PROFILE_PATH,
+    source: "global-profile",
+    sourceLabel: "profilo globale common",
+    protectedPaths: inputs.map((input) => canonicalPolicyPath(input.path)),
+    manifest,
+    fingerprint,
+  };
+}
+
+function loadManifestAtPath(args: {
+  path: string;
+  source: "project" | "global-manifest";
+  sourceLabel: string;
+}): LoadedVerificationManifest {
+  if (!existsSync(args.path)) {
+    return { ok: false, path: args.path, error: `manifest non trovato: ${args.sourceLabel}` };
+  }
+  try {
+    if (statSync(args.path).size > MAX_MANIFEST_BYTES) {
+      return { ok: false, path: args.path, error: `manifest non valido: supera ${MAX_MANIFEST_BYTES} byte` };
+    }
+    const text = readFileSync(args.path, "utf8");
     const parsed = JSON.parse(text);
     return {
       ok: true,
-      path,
+      path: args.path,
+      source: args.source,
+      sourceLabel: args.sourceLabel,
+      protectedPaths: [canonicalPolicyPath(args.path)],
       manifest: parseVerificationManifest(parsed),
       fingerprint: fingerprintText(text),
     };
   } catch (error) {
     return {
       ok: false,
-      path,
+      path: args.path,
       error: `manifest non valido: ${error instanceof Error ? error.message : String(error)}`,
     };
   }
 }
 
-/** Acquisisce la policy di esecuzione dal disco in un punto esplicitamente utente. */
-export function trustVerificationManifest(
+/** Carica solo il manifest locale; API mantenuta per use case per-progetto espliciti. */
+export function loadVerificationManifest(
   cwd: string,
   manifestPath: string,
-): VerificationManifestTrust {
-  const loaded = loadVerificationManifest(cwd, manifestPath);
+): LoadedVerificationManifest {
+  const path = resolveManifestPath(cwd, manifestPath);
+  if (!path) {
+    return { ok: false, error: "percorso manifest non valido: deve restare dentro il progetto" };
+  }
+  return loadManifestAtPath({ path, source: "project", sourceLabel: `manifest locale: ${manifestPath}` });
+}
+
+/**
+ * Precedenza: manifest locale → manifest globale dell'utente → profilo common.
+ * Un file esplicito ma malformato/non trovato non degrada silenziosamente a un
+ * altro fallback: l'utente deve accorgersi della policy che ha configurato.
+ */
+export function loadVerificationPolicy(
+  cwd: string,
+  settings: VerificationSettings,
+): LoadedVerificationManifest {
+  const localPath = resolveManifestPath(cwd, settings.manifestPath);
+  if (!localPath) {
+    return { ok: false, error: "percorso manifest locale non valido: deve restare dentro il progetto" };
+  }
+  if (existsSync(localPath)) return loadVerificationManifest(cwd, settings.manifestPath);
+
+  const configuredGlobal = settings.globalManifestPath?.trim();
+  if (configuredGlobal) {
+    const globalPath = resolveGlobalManifestPath(configuredGlobal);
+    if (!globalPath) {
+      return { ok: false, error: "percorso manifest globale non valido: usa un path assoluto o ~/" };
+    }
+    return loadManifestAtPath({
+      path: globalPath,
+      source: "global-manifest",
+      sourceLabel: `manifest globale: ${globalPath}`,
+    });
+  }
+
+  if (settings.defaultProfile === "off") {
+    return { ok: false, path: localPath, error: `manifest locale non trovato: ${settings.manifestPath}; profilo globale disattivato` };
+  }
+  return loadCommonVerificationProfile(cwd);
+}
+
+function trustLoaded(cwd: string, loaded: LoadedVerificationManifest): VerificationManifestTrust {
   return loaded.ok
     ? {
         ok: true,
         cwd: resolve(cwd),
         path: loaded.path,
+        source: loaded.source,
+        sourceLabel: loaded.sourceLabel,
+        protectedPaths: [...loaded.protectedPaths],
         manifest: loaded.manifest,
         fingerprint: loaded.fingerprint,
       }
     : { ok: false, cwd: resolve(cwd), error: loaded.error };
 }
 
-/**
- * Ritorna il manifest acquisito, ma rifiuta mutazioni del file dopo il trust.
- * I comandi vengono poi selezionati dall'oggetto in memoria acquisito, non
- * dal file corrente: un agente non può scrivere un comando e farlo eseguire
- * nella stessa sessione.
- */
-export function trustedVerificationManifest(
-  trust: VerificationManifestTrust | undefined,
+/** Acquisisce un manifest locale esplicito; compatibilità con l'API v0.5. */
+export function trustVerificationManifest(
   cwd: string,
   manifestPath: string,
+): VerificationManifestTrust {
+  return trustLoaded(cwd, loadVerificationManifest(cwd, manifestPath));
+}
+
+/** Acquisisce la policy risolta (locale, globale o profilo integrato). */
+export function trustVerificationPolicy(
+  cwd: string,
+  settings: VerificationSettings,
+): VerificationManifestTrust {
+  return trustLoaded(cwd, loadVerificationPolicy(cwd, settings));
+}
+
+function trustedLoaded(
+  trust: VerificationManifestTrust | undefined,
+  cwd: string,
+  current: LoadedVerificationManifest,
 ): LoadedVerificationManifest {
-  if (!trust) return { ok: false, error: "manifest non ancora acquisito; usa /jev verification reload" };
+  if (!trust) return { ok: false, error: "policy verifica non ancora acquisita; usa /jev verification reload" };
   if (!trust.ok) return { ok: false, error: trust.error };
   if (trust.cwd !== resolve(cwd)) {
-    return { ok: false, error: "manifest acquisito per un'altra directory; usa /jev verification reload" };
+    return { ok: false, error: "policy verifica acquisita per un'altra directory; usa /jev verification reload" };
   }
-  const current = loadVerificationManifest(cwd, manifestPath);
   if (!current.ok) return current;
-  if (current.path !== trust.path || current.fingerprint !== trust.fingerprint) {
+  if (
+    current.path !== trust.path ||
+    current.source !== trust.source ||
+    current.fingerprint !== trust.fingerprint
+  ) {
     return {
       ok: false,
       path: current.path,
-      error: "manifest modificato dopo l'acquisizione; controllalo e usa /jev verification reload",
+      error: `${trust.source === "global-profile" ? "profilo globale" : "manifest"} modificato dopo l'acquisizione; controllalo e usa /jev verification reload`,
     };
   }
   return {
     ok: true,
     path: trust.path,
+    source: trust.source,
+    sourceLabel: trust.sourceLabel,
+    protectedPaths: [...trust.protectedPaths],
     manifest: trust.manifest,
     fingerprint: trust.fingerprint,
   };
 }
 
+/** Ritorna il manifest locale acquisito, rifiutando mutazioni dopo il trust. */
+export function trustedVerificationManifest(
+  trust: VerificationManifestTrust | undefined,
+  cwd: string,
+  manifestPath: string,
+): LoadedVerificationManifest {
+  return trustedLoaded(trust, cwd, loadVerificationManifest(cwd, manifestPath));
+}
+
+/** Ritorna la policy acquisita, rifiutando mutazioni di manifest o input profilo. */
+export function trustedVerificationPolicy(
+  trust: VerificationManifestTrust | undefined,
+  cwd: string,
+  settings: VerificationSettings,
+): LoadedVerificationManifest {
+  return trustedLoaded(trust, cwd, loadVerificationPolicy(cwd, settings));
+}
+
 function globToRegExp(pattern: string): RegExp {
   let source = "^";
   for (let i = 0; i < pattern.length; i++) {
@@ -385,7 +715,9 @@ export function buildVerificationStatus(
   if (changedFiles.length === 0) {
     return {
       changedFiles,
-      ...(loaded.ok ? {} : { manifestError: loaded.error }),
+      ...(loaded.ok
+        ? { manifestSource: loaded.source, manifestSourceLabel: loaded.sourceLabel }
+        : { manifestError: loaded.error }),
       checks: [],
       actionable: false,
       hasPending: false,
@@ -421,6 +753,8 @@ export function buildVerificationStatus(
   const hasFailed = checks.some((check) => check.state === "failed");
   return {
     changedFiles,
+    manifestSource: loaded.source,
+    manifestSourceLabel: loaded.sourceLabel,
     checks,
     actionable: checks.length > 0,
     hasPending,
@@ -450,9 +784,12 @@ export function verificationNotice(status: VerificationStatus): string | undefin
     lines.push(`> - Stato: ${status.manifestError}; nessuna verifica configurata è stata attribuita.`);
     return lines.join("\n");
   }
+  if (status.manifestSourceLabel) {
+    lines.push(`> - Policy: ${status.manifestSourceLabel}.`);
+  }
   if (!status.actionable) {
     lines.push(
-      "> - Stato: nessun check del manifest corrisponde ai file modificati; correttezza non verificata.",
+      "> - Stato: nessun check della policy corrisponde ai file modificati; correttezza non verificata.",
     );
     return lines.join("\n");
   }