failproofai 1.0.1-beta.0 → 1.0.1

package/.next/standalone/docs-old/it/dashboard.mdx

@@ -0,0 +1,151 @@
+---
+title: Dashboard
+description: "Monitora le sessioni degli agenti, esamina le chiamate ai tool e gestisci le policy"
+icon: chart-line
+---
+
+La dashboard di failproofai è un'applicazione web locale per monitorare le sessioni dei tuoi agenti AI e gestire le policy. Scopri cosa hanno fatto i tuoi agenti mentre eri via.
+
+---
+
+## Avvio della dashboard
+
+```bash
+failproofai
+```
+
+Si apre su `http://localhost:8020`.
+
+La dashboard legge i dati locali di progetto, sessione e configurazione di failproofai direttamente dal filesystem. Le funzionalità opzionali autenticate, come i promemoria di audit e gli inviti, inviano le informazioni necessarie per tali richieste (inclusi gli indirizzi email) alle API remote.
+
+---
+
+## Pagine
+
+### Progetti
+
+Elenca tutti i progetti Claude Code, OpenAI Codex, GitHub Copilot CLI _(beta)_, Cursor Agent _(beta)_, OpenCode _(beta)_, Pi _(beta)_, Hermes, OpenClaw, Factory Droid, Devin, Antigravity e Goose trovati sul tuo computer. I progetti Claude vengono individuati da `~/.claude/projects/` (o dal percorso impostato da `CLAUDE_PROJECTS_PATH`); i progetti Codex vengono individuati scansionando ogni transcript sotto `~/.codex/sessions/<YYYY>/<MM>/<DD>/*.jsonl` e raggruppando per il `cwd` registrato nel primo record della sessione; i progetti Copilot CLI vengono individuati scansionando ogni `~/.copilot/session-state/<sessionId>/workspace.yaml` (configurabile tramite `COPILOT_HOME`) e raggruppando per il suo campo `cwd`; i progetti Cursor Agent vengono individuati scansionando i metadati per sessione sotto `~/.cursor/agent-sessions/<sessionId>/` (configurabile tramite `CURSOR_HOME`, con `conversations/` e `sessions/` sondati come fallback) per uno scalare `cwd` in `meta.json` / `session.json` / `workspace.yaml`; i progetti OpenCode vengono individuati interrogando il suo DB SQLite su `~/.local/share/opencode/opencode.db` tramite `opencode db --format json` (leggiamo le tabelle `session` e `project` e raggruppiamo per `project_id`); i progetti Pi vengono individuati scansionando i transcript JSONL per sessione sotto `~/.pi/agent/sessions/<encoded-cwd>/<timestamp>_<uuid>.jsonl` (configurabile tramite `PI_SESSIONS_DIR`) e estraendo il `cwd` dal primo record di ogni sessione; le sessioni gateway Hermes vengono lette direttamente dall'archivio SQLite di ogni profilo — `~/.hermes/state.db` più `~/.hermes/profiles/<name>/state.db` (sovrapponibile tramite `HERMES_HOME`, oppure `HERMES_DB_PATH` per un singolo database) — e raggruppate in progetti `hermes-<profile>-<source>` per profilo e `source` (Slack/Telegram/cli/cron — le sessioni gateway non hanno cwd); le sessioni gateway OpenClaw vengono lette da `~/.openclaw/agents/<agentId>/sessions/*.jsonl` e raggruppate in progetti `openclaw-<agentId>-<channel>` per agente e canale (anch'esse senza cwd); i progetti Factory Droid vengono individuati dai transcript JSONL su `~/.factory/sessions/<encoded-cwd>/*.jsonl` e raggruppati per cwd; i progetti Devin dal suo DB SQLite su `~/.local/share/devin/cli/sessions.db` (raggruppati per il `working_directory` di ogni sessione); i progetti Antigravity dai transcript JSONL su `~/.gemini/antigravity-cli/brain/<conversationId>/…/transcript_full.jsonl` e raggruppati per cwd; e i progetti Goose dal suo DB SQLite su `~/.local/share/goose/sessions/sessions.db` (raggruppati per il `working_dir` di ogni sessione). Un progetto che è stato utilizzato da più CLI viene visualizzato come una singola riga con tutti i badge corrispondenti. Usa il menu a tendina **CLI** sopra la tabella per filtrare per uno specifico CLI agente; l'URL conserva la tua selezione come `?cli=claude|codex|copilot|cursor|opencode|pi|hermes|openclaw|factory|devin|antigravity|goose`.
+
+Hermes e OpenClaw hanno ambito utente e nessuna directory di lavoro per raggruppare, quindi vengono visualizzati come un **albero di cartelle comprimibile** — profilo (o agente) al livello superiore, i suoi canali sotto — mentre ogni CLI basato su cwd rimane una riga piatta. Le righe della cartella accumulano il conteggio delle sessioni e l'attività più recente di tutto ciò che contengono, le cartelle compresse vengono ricordate tra le visite e una ricerca per parola chiave espande tutto ciò che corrisponde.
+
+Ogni progetto mostra:
+- Nome del progetto (derivato dal percorso della cartella)
+- Un badge CLI — `Claude Code` (arancione), `OpenAI Codex` (viola), `GitHub Copilot` (blu), `Cursor Agent` (smeraldo), `OpenCode` (ambra), `Pi` (rosa), e/o `Hermes` (indaco)
+- Data dell'attività di sessione più recente
+
+Fai clic su un progetto per visualizzare le sue sessioni.
+
+### Sessioni
+
+Elenca tutte le sessioni all'interno di un progetto. Ogni sessione mostra:
+- ID sessione
+- Timestamp di inizio e fine
+- Numero di chiamate ai tool
+- Conteggio dell'attività hook (policy che si sono attivate)
+
+Usa il filtro intervallo di date e la ricerca ID sessione per ridurre l'elenco. Le sessioni sono impaginate.
+
+Fai clic su una sessione per aprire il visualizzatore di sessione.
+
+### Visualizzatore di sessione
+
+Il visualizzatore di sessione risponde alla domanda chiave per gli agenti autonomi: cosa ha fatto l'agente e ha mantenuto la rotta? Un badge CLI accanto all'intestazione indica se la sessione è una trascrizione di Claude Code, OpenAI Codex, GitHub Copilot CLI, Cursor Agent, OpenCode, Pi, Hermes, OpenClaw, Factory Droid, Devin, Antigravity o Goose. Mostra una timeline di tutto ciò che è accaduto in una sessione:
+
+- **Messaggi** - Le risposte di testo di Claude e i prompt dell'utente
+- **Chiamate ai tool** - Ogni tool invocato da Claude, con il suo input e output
+- **Attività delle policy** - Per ogni chiamata ai tool, quali policy si sono attivate e quale decisione hanno restituito
+
+La barra delle statistiche in alto mostra la durata della sessione, il numero totale di chiamate ai tool e un riepilogo delle decisioni hook (conteggi allow / deny / instruct).
+
+Fai clic sul pulsante **Download Logs** per esportare la sessione. Per le sessioni Claude Code, Codex, Copilot, Cursor e Pi ottieni il transcript JSONL originale su disco byte per byte; per OpenCode (le cui sessioni si trovano in SQLite, non su disco) ottieni un documento JSON che rispecchia le tabelle sottostanti `session` / `messages` / `parts`.
+
+### Audit
+
+Un rapporto guidato dalla personalità su come il tuo agente si è effettivamente comportato nelle sessioni passate. Esegue la stessa scansione del CLI `failproofai audit` ma la rende come un poster condivisibile a schermo unico + quattro sezioni sotto la piega:
+
+1. **Poster** — riempie il primo viewport. Regione PNG self-contained con il wordmark failproof_ai + etichetta audit · indice archetipo (`№ NN di 08`) + data audit · punteggio numerico (0–100) + pillola di ranking percentile (`top 15%`) · il nome dell'archetipo (uno di `the optimist`, `the cowboy`, `the explorer`, `the goldfish`, `the paranoid architect`, `the precision builder`, `the hammer`, `the ghost`) + striscia da 3 parole chiave · riga di rarità `// only N% of agents are this archetype` · tile sigillo 8×8 pixel · footer `audit yours → failproof.ai`. Tre pulsanti di condivisione si trovano appena al di fuori della casella di acquisizione: `post your archetype` (intenzione X), `share on linkedin`, `download poster`. L'acquisizione funziona tramite `html-to-image` quindi il PNG corrisponde al rendering su schermo pixel per pixel (bordi tratteggiati, maschera logo SVG, gradienti, metriche dei caratteri — tutto conservato).
+2. **Strengths** — elenco di righe calmo ✓ dei comportamenti che il tuo agente già fa bene, derivato dai dati di audit live (tasso di chiamata ai tool pulito, nessun push diretto a main, zero perdite di credenziali, zero tempeste di tentativi) — ognuno presentato solo quando la relativa policy ha un registro pulito nell'intervallo di audit.
+3. **Quirks** — tabella di ciò che è sfuggito, classificato per gravità: `when · what slipped + the policy that would've caught it · severity pill · seen`, dove la ricorrenza legge `new` (una volta), `N× seen` (2–9 volte), o `recurring` (10+).
+4. **How to improve** — elenco di righe calmo, uno per policy prescritta: nome policy in bianco, descrizione di una riga, comando di installazione + pulsante di copia sul lato destro. L'intestazione della sezione legge `enable all N → projected <score> · <tier>` (il punteggio che raggiungeresti con ogni correzione applicata), e il suo pulsante `[install all]` copia il comando combinato `failproofai policy add a b c …` per ogni policy prescritta.
+5. **Come back better** — due carte una accanto all'altra. Sinistra: imposta un promemoria (selettore di cadenza `3d` / `7d` / `14d` / `30d`; persiste tramite `/api/auth/reminder` una volta autenticato). Destra: sblocca i vantaggi di failproof — `invite a friend` apre un modale che accetta un elenco di email di amici separati da virgola/spazio/newline (max 10 per invio), le invia tramite POST a `/api/audit/invite`, che inoltrano a `POST /v0/invite` del server api. Il server api invia un'email per destinatario da `invite@failproof.ai` con il mittente in Cc e `Reply-To` impostato, quindi il destinatario vede chi lo ha invitato e il mittente riceve una copia nella sua inbox. Gli utenti anonimi vengono instradati prima attraverso `AuthDialog` in modo che l'email del mittente sia nota prima che gli inviti vengano inviati. L'adempimento dei diritti / vantaggi è un seguito.
+
+Guidato dal runtime `failproofai audit` — vedi [Audit CLI](/it/cli/audit) per il motore di scansione sottostante, i flag supportati e gli invarianti di cache per transcript. La dashboard memorizza nella cache il risultato più recente su `~/.failproofai/audit-dashboard.json` (modo `0600`, slot singolo, i nuovi run sovrascrivono) quindi le revisioni sono istantanee; **sia la cache per transcript che il risultato complessivo vengono rifiutati in lettura una volta che sono più vecchi di 7 giorni** quindi la dashboard non serve mai silenziosamente un risultato di una settimana — passato il TTL `/audit` cade nel suo stato vuoto e chiede un'esecuzione nuova. Facendo clic su `[ re-audit now ]` vicino al fondo del rapporto si invia `/api/audit/run` con `noCache: true` — la riesecuzione dell'audit bypassa la cache per transcript e ripete la scansione di ogni transcript da zero invece di restituire silenziosamente il risultato memorizzato — e la dashboard esegue il polling di `/api/audit/status` a 1Hz fino al termine dell'esecuzione; una striscia di progresso rosa appiccicatizia si fissa all'inizio del viewport durante l'esecuzione con un timer di tempo trascorso, e il risultato nuovo si scambia al suo posto al successo (nessun ricaricamento della pagina intera; un riesame fallito dell'audit lascia intatto il rapporto precedente). In caso di errore la striscia diventa rossa con copia codificata da `RerunError.kind` (`timeout` / `network` / `post_failed`). Lo stato vuoto (nessuna cache o scaduta) e lo stato zero-sessioni (cache esiste ma la scansione non ha trovato alcun transcript) sono visualizzati separatamente.
+
+### Policy
+
+Una pagina a due schede per gestire le policy e esaminare l'attività.
+
+<Tabs>
+  <Tab title="Scheda Policy">
+  - Seleziona più CLI agente che failproofai protegge da un singolo pannello — Claude Code, OpenAI Codex, GitHub Copilot, Cursor Agent, OpenCode, Pi e Hermes hanno tutti una riga con stato di installazione (`Active` / `Detected` / `Inactive`), il percorso delle impostazioni con ambito utente e un accento di colore del marchio. Seleziona o deseleziona i CLI che desideri e fai clic su `Apply changes` per installare/disinstallare la differenza in un unico passaggio. I CLI il cui binario è rilevato su PATH sono pre-selezionati.
+  - Attiva o disattiva singole policy con un solo clic (scrive su `~/.failproofai/policies-config.json` — condiviso su ogni CLI installato)
+  - Espandi una policy per configurarne i parametri (per le policy che supportano `policyParams`)
+  - Imposta un percorso file di policy personalizzato
+  </Tab>
+  <Tab title="Scheda Activity">
+  - Cronologia impaginata completa di ogni evento hook che si è attivato in tutte le sessioni
+  - Filtra per decisione, tipo di evento, CLI (Claude Code / OpenAI Codex / GitHub Copilot _(beta)_ / Cursor Agent _(beta)_ / OpenCode _(beta)_ / Pi _(beta)_ / Hermes / OpenClaw / Factory Droid / Devin / Antigravity / Goose), nome della policy o ID sessione
+  - Ogni riga mostra: timestamp, nome della policy, decisione, badge CLI (arancione = Claude Code, viola = OpenAI Codex, blu = GitHub Copilot, smeraldo = Cursor Agent, ambra = OpenCode, rosa = Pi, indaco = Hermes, azzurro = OpenClaw, rosa antico = Factory Droid, violetto = Devin, ciano = Antigravity, lime = Goose), nome del tool, ID sessione e il motivo delle decisioni deny/instruct
+  - Fai clic su un ID sessione per aprire il suo transcript — il visualizzatore auto-rileva quale CLI ha attivato l'hook (Claude `~/.claude/projects/…`, Codex `~/.codex/sessions/…`, Copilot CLI `~/.copilot/session-state/<id>/events.jsonl`, Cursor Agent `~/.cursor/agent-sessions/<id>/events.jsonl`, OpenCode `~/.local/share/opencode/opencode.db`, Pi `~/.pi/agent/sessions/<encoded-cwd>/<id>.jsonl`, Hermes `~/.hermes/state.db`, OpenClaw `~/.openclaw/agents/<id>/sessions/*.jsonl`, Factory Droid `~/.factory/sessions/<encoded-cwd>/<id>.jsonl`, Devin `~/.local/share/devin/cli/sessions.db`, Antigravity `~/.gemini/antigravity-cli/brain/<id>/…/transcript_full.jsonl`, Goose `~/.local/share/goose/sessions/sessions.db`) e visualizza il badge CLI corrispondente nell'intestazione
+  </Tab>
+</Tabs>
+
+---
+
+## Aggiornamento automatico
+
+La dashboard dispone di un interruttore di aggiornamento automatico nella navigazione in alto. Se abilitato, la pagina corrente si aggiorna periodicamente per mostrare nuove sessioni e attività di policy man mano che appaiono. Essenziale per il monitoraggio delle sessioni di agenti autonomi a lunga esecuzione.
+
+---
+
+## Disabilitazione delle pagine
+
+Se hai bisogno solo di alcune parti della dashboard, imposta `FAILPROOFAI_DISABLE_PAGES` su un elenco separato da virgole di nomi di pagina:
+
+```bash
+FAILPROOFAI_DISABLE_PAGES=policies failproofai
+```
+
+Valori validi: `policies`, `projects`, `audit`.
+
+---
+
+## Configurazione del percorso dei progetti
+
+Per impostazione predefinita, la dashboard legge dalla directory dei progetti Claude Code standard. Sostituiscila per configurazioni personalizzate:
+
+```bash
+CLAUDE_PROJECTS_PATH=/custom/path/to/projects failproofai
+```
+
+---
+
+## Accesso da un host non-localhost
+
+Quando esegui la dashboard in **modalità dev** (`npm run dev`) e accedi da un nome host diverso da `localhost` - ad esempio, un dominio personalizzato, un IP remoto o un URL tunnelato - potresti vedere un avviso come:
+
+```text
+⚠ Blocked cross-origin request to Next.js dev resource /_next/webpack-hmr from "dashboard.example.com".
+```
+
+Si tratta di Next.js che blocca l'accesso cross-origin alla sua risorsa dev HMR (hot module reload websocket), che è una funzionalità solo per dev. Per consentire il tuo host, usa il flag `--allowed-origins`:
+
+```bash
+npm run dev -- --allowed-origins dashboard.example.com
+```
+
+Per più host o IP, passa un elenco separato da virgole:
+
+```bash
+npm run dev -- --allowed-origins dashboard.example.com,192.168.1.5
+```
+
+Puoi anche impostare la variabile di ambiente `FAILPROOFAI_ALLOWED_DEV_ORIGINS`:
+
+```bash
+FAILPROOFAI_ALLOWED_DEV_ORIGINS=dashboard.example.com npm run dev
+```
+
+<Note>
+Questo si applica solo alla modalità dev. Quando si esegue `failproofai` (modalità produzione), non c'è websocket HMR e nessun problema di risorsa dev cross-origin.
+</Note>

package/.next/standalone/docs-old/it/examples.mdx

@@ -0,0 +1,307 @@
+---
+title: Esempi
+description: "Come configurare gli hook per Claude Code e Agents SDK"
+icon: book-open
+---
+
+Esempi pronti all'uso per scenari comuni. Ognuno mostra come installare e cosa aspettarsi.
+
+---
+
+## Configurare gli hook per Claude Code
+
+Failproof AI si integra con Claude Code attraverso il suo [sistema di hook](https://docs.anthropic.com/en/docs/claude-code/hooks). Quando esegui `failproofai policies --install`, registra i comandi degli hook nel file `settings.json` di Claude Code che si attivano ad ogni chiamata di strumento.
+
+<Steps>
+  <Step title="Installa failproofai">
+    ```bash
+    npm install -g failproofai
+    ```
+  </Step>
+  <Step title="Abilita tutte le policy integrate">
+    ```bash
+    failproofai policies --install
+    ```
+  </Step>
+  <Step title="Verifica che gli hook siano registrati">
+    ```bash
+    cat ~/.claude/settings.json | grep failproofai
+    ```
+
+    Dovresti vedere le voci degli hook per gli eventi `PreToolUse`, `PostToolUse`, `Notification` e `Stop`.
+  </Step>
+  <Step title="Esegui Claude Code">
+    ```bash
+    claude
+    ```
+
+    Le policy ora vengono eseguite automaticamente ad ogni chiamata di strumento. Prova a chiedere a Claude di eseguire `sudo rm -rf /` - verrà bloccato.
+  </Step>
+</Steps>
+
+---
+
+## Configurare gli hook per Agents SDK
+
+Se stai costruendo con [Agents SDK](https://docs.anthropic.com/en/docs/agents-sdk), puoi utilizzare lo stesso sistema di hook a livello di programmazione.
+
+<Steps>
+  <Step title="Installa failproofai nel tuo progetto">
+    ```bash
+    npm install failproofai
+    ```
+  </Step>
+  <Step title="Configura gli hook nel tuo agente">
+    Passa i comandi degli hook quando crei il processo del tuo agente. Gli hook si attivano allo stesso modo di Claude Code - tramite JSON su stdin/stdout:
+
+    ```bash
+    failproofai --hook PreToolUse   # chiamato prima di ogni strumento
+    failproofai --hook PostToolUse  # chiamato dopo ogni strumento
+    ```
+  </Step>
+  <Step title="Scrivi una policy personalizzata per il tuo agente">
+    ```javascript
+    import { customPolicies, allow, deny } from "failproofai";
+
+    customPolicies.add({
+      name: "limit-to-project-dir",
+      description: "Keep the agent inside the project directory",
+      match: { events: ["PreToolUse"] },
+      fn: async (ctx) => {
+        const path = String(ctx.toolInput?.file_path ?? "");
+        if (path.startsWith("/") && !path.startsWith(ctx.session?.cwd ?? "")) {
+          return deny("Agent is restricted to the project directory");
+        }
+        return allow();
+      },
+    });
+    ```
+  </Step>
+  <Step title="Installa la policy personalizzata">
+    ```bash
+    failproofai policies --install --custom ./my-agent-policies.js
+    ```
+  </Step>
+</Steps>
+
+---
+
+## Blocca i comandi distruttivi
+
+La configurazione più comune - previeni che gli agenti causino danni irreversibili.
+
+```bash
+failproofai policies --install block-sudo block-rm-rf block-force-push block-curl-pipe-sh
+```
+
+Cosa fa:
+- `block-sudo` - blocca tutti i comandi `sudo`
+- `block-rm-rf` - blocca l'eliminazione ricorsiva di file
+- `block-force-push` - blocca `git push --force`
+- `block-curl-pipe-sh` - blocca l'invio di script remoti tramite pipe a shell
+
+---
+
+## Previeni la fuga di segreti
+
+Impedisci agli agenti di vedere o divulgare credenziali nell'output dello strumento.
+
+```bash
+failproofai policies --install sanitize-api-keys sanitize-jwt sanitize-connection-strings sanitize-bearer-tokens
+```
+
+Si attivano su `PostToolUse` - dopo che uno strumento viene eseguito, puliscono l'output prima che l'agente lo veda.
+
+---
+
+## Ricevi avvisi Slack quando gli agenti hanno bisogno di attenzione
+
+Usa l'hook di notifica per inoltrare gli avvisi di inattività a Slack.
+
+```javascript
+import { customPolicies, allow, instruct } from "failproofai";
+
+customPolicies.add({
+  name: "slack-on-idle",
+  description: "Alert Slack when the agent is waiting for input",
+  match: { events: ["Notification"] },
+  fn: async (ctx) => {
+    const webhookUrl = process.env.SLACK_WEBHOOK_URL;
+    if (!webhookUrl) return allow();
+
+    const message = String(ctx.payload?.message ?? "Agent is waiting");
+    const project = ctx.session?.cwd ?? "unknown";
+
+    try {
+      await fetch(webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          text: `*${message}*\nProject: \`${project}\``,
+        }),
+        signal: AbortSignal.timeout(5000),
+      });
+    } catch {
+      // never block the agent if Slack is unreachable
+    }
+
+    return allow();
+  },
+});
+```
+
+Installalo:
+
+```bash
+SLACK_WEBHOOK_URL=https://hooks.slack.com/... failproofai policies --install --custom ./slack-alerts.js
+```
+
+---
+
+## Mantieni gli agenti su un ramo
+
+Impedisci agli agenti di cambiare ramo o fare push verso rami protetti.
+
+```javascript
+import { customPolicies, allow, deny } from "failproofai";
+
+customPolicies.add({
+  name: "stay-on-branch",
+  description: "Prevent the agent from checking out other branches",
+  match: { events: ["PreToolUse"] },
+  fn: async (ctx) => {
+    if (ctx.toolName !== "Bash") return allow();
+    const cmd = String(ctx.toolInput?.command ?? "");
+    if (/git\s+checkout\s+(?!-b)/.test(cmd)) {
+      return deny("Stay on the current branch. Create a new branch with -b if needed.");
+    }
+    return allow();
+  },
+});
+```
+
+---
+
+## Richiedi test prima dei commit
+
+Ricorda agli agenti di eseguire i test prima di fare commit.
+
+```javascript
+import { customPolicies, allow, instruct } from "failproofai";
+
+customPolicies.add({
+  name: "test-before-commit",
+  description: "Remind the agent to run tests before committing",
+  match: { events: ["PreToolUse"] },
+  fn: async (ctx) => {
+    if (ctx.toolName !== "Bash") return allow();
+    const cmd = String(ctx.toolInput?.command ?? "");
+    if (/git\s+commit/.test(cmd)) {
+      return instruct("Run tests before committing. Use `npm test` or `bun test` first.");
+    }
+    return allow();
+  },
+});
+```
+
+---
+
+## Proteggi un repo di produzione
+
+Effettua il commit della configurazione a livello di progetto in modo che ogni sviluppatore del tuo team ottenga le stesse policy.
+
+Crea `.failproofai/policies-config.json` nel tuo repository:
+
+```json
+{
+  "enabledPolicies": [
+    "block-sudo",
+    "block-rm-rf",
+    "block-force-push",
+    "block-push-master",
+    "block-env-files",
+    "sanitize-api-keys",
+    "sanitize-jwt"
+  ],
+  "policyParams": {
+    "block-push-master": {
+      "protectedBranches": ["main", "release", "production"]
+    }
+  }
+}
+```
+
+Quindi effettua il commit:
+
+```bash
+git add .failproofai/policies-config.json
+git commit -m "Add failproofai team policies"
+```
+
+Ogni membro del team che ha failproofai installato raccoglierà automaticamente queste regole.
+
+---
+
+## Crea uno standard di qualità a livello organizzativo con le policy di convenzione
+
+La configurazione più impattante: effettua il commit di `.failproofai/policies/` nel tuo repo con policy personalizzate per il tuo progetto. Ogni membro del team le ottiene automaticamente — nessun comando di installazione, nessun cambiamento di configurazione.
+
+<Steps>
+  <Step title="Crea la directory e aggiungi le policy">
+    ```bash
+    mkdir -p .failproofai/policies
+    ```
+
+    ```js
+    // .failproofai/policies/team-policies.mjs
+    import { customPolicies, allow, deny, instruct } from "failproofai";
+
+    // Enforce your team's preferred package manager
+    // (or enable the built-in prefer-package-manager policy instead)
+    customPolicies.add({
+      name: "enforce-bun",
+      match: { events: ["PreToolUse"] },
+      fn: async (ctx) => {
+        if (ctx.toolName !== "Bash") return allow();
+        const cmd = String(ctx.toolInput?.command ?? "");
+        if (/\bnpm\b/.test(cmd)) return deny("Use bun instead of npm.");
+        return allow();
+      },
+    });
+
+    // Remind the agent to run tests before committing
+    customPolicies.add({
+      name: "test-before-commit",
+      match: { events: ["PreToolUse"] },
+      fn: async (ctx) => {
+        if (ctx.toolName !== "Bash") return allow();
+        if (/git\s+commit/.test(ctx.toolInput?.command ?? "")) {
+          return instruct("Run tests before committing.");
+        }
+        return allow();
+      },
+    });
+    ```
+  </Step>
+  <Step title="Effettua il commit su git">
+    ```bash
+    git add .failproofai/policies/
+    git commit -m "Add team quality policies"
+    ```
+  </Step>
+  <Step title="Continua a migliorare">
+    Man mano che il tuo team incontra nuovi modi di fallire, aggiungi policy e fai il push. Tutti ricevono l'aggiornamento al loro prossimo `git pull`. Queste policy diventano uno standard di qualità vivo che cresce con il tuo team.
+  </Step>
+</Steps>
+
+---
+
+## Altri esempi
+
+La directory [`examples/`](https://github.com/failproofai/failproofai/tree/main/examples) nel repository contiene:
+
+| File | Cosa mostra |
+|------|-------------|
+| `policies-basic.js` | Policy di base - blocca le scritture in produzione, force-push, script inviati tramite pipe |
+| `policies-notification.js` | Avvisi Slack per notifiche di inattività e fine sessione |
+| `policies-advanced/index.js` | Import transitivi, hook asincroni, scrubbing dell'output PostToolUse, gestione dell'evento Stop |

package/.next/standalone/docs-old/it/for-agents.mdx

@@ -0,0 +1,38 @@
+---
+title: "Per gli agenti"
+description: "Aggiungi la conoscenza di Failproof AI al tuo agente di codifica in un comando. Funziona con Claude Code, Cursor, Windsurf e molti altri."
+---
+
+Aggiungi il riferimento completo di Failproof AI al tuo agente di codifica in un comando. Funziona con Claude Code, Cursor, Windsurf e qualsiasi altro agente che supporti le skill.
+
+```bash
+npx skills add https://docs.befailproof.ai
+```
+
+`npx skills` rileva quali agenti hai installato e aggiunge la skill nel formato corretto per ciascuno automaticamente.
+
+## Cosa copre la skill
+
+| Area | Cosa è incluso |
+|------|----------------|
+| Policies | Nomi policy built-in, tipi di evento, parametri, abilitazione/disabilitazione |
+| Custom policies | `customPolicies.add()`, filtri di corrispondenza, API `allow`/`deny`/`instruct` |
+| Oggetto Context | `ctx.eventType`, `ctx.toolName`, `ctx.toolInput`, `ctx.session` |
+| Configurazione | Struttura `policies-config.json`, merging dei scope, `policyParams` |
+| CLI | `failproofai policies --install`, `--uninstall`, `--custom`, scope |
+| Dashboard | Visualizzatore di sessioni, attività delle policy, variabili d'ambiente |
+| Architettura | Flusso del gestore hook, codici di uscita, contratto stdin/stdout |
+
+## La skill è completa?
+
+Mintlify genera `llms.txt` da tutte le pagine nella navigazione. La documentazione di Failproof AI copre l'API completa - ogni policy, opzione ed esempio è incluso. Se trovi qualcosa di mancante, la fonte è su `https://docs.befailproof.ai/llms-full.txt`.
+
+Per un contesto mirato, collega direttamente a una pagina specifica:
+
+```bash
+# Solo l'API delle custom policies
+npx skills add https://docs.befailproof.ai/custom-policies
+
+# Solo le policy built-in
+npx skills add https://docs.befailproof.ai/built-in-policies
+```