failproofai 1.0.1-beta.0 → 1.0.1

package/.next/standalone/docs-old/pt-br/dashboard.mdx

@@ -0,0 +1,151 @@
+---
+title: Dashboard
+description: "Monitore sessões de agentes, revise chamadas de ferramentas e gerencie políticas"
+icon: chart-line
+---
+
+O dashboard do failproofai é uma aplicação web local para monitorar suas sessões de agentes de IA e gerenciar políticas. Veja o que seus agentes fizeram enquanto você estava ausente.
+
+---
+
+## Iniciando o dashboard
+
+```bash
+failproofai
+```
+
+Abre em `http://localhost:8020`.
+
+O dashboard lê dados locais de projeto, sessão e configuração do failproofai diretamente do sistema de arquivos. Recursos opcionais com autenticação, como lembretes de auditoria e convites, enviam as informações necessárias para essas requisições (incluindo endereços de e-mail) para APIs remotas.
+
+---
+
+## Páginas
+
+### Projetos
+
+Lista todos os projetos de Claude Code, OpenAI Codex, GitHub Copilot CLI _(beta)_, Cursor Agent _(beta)_, OpenCode _(beta)_, Pi _(beta)_, Hermes, OpenClaw, Factory Droid, Devin, Antigravity e Goose encontrados na sua máquina. Projetos Claude são descobertos em `~/.claude/projects/` (ou no caminho definido por `CLAUDE_PROJECTS_PATH`); projetos Codex são descobertos escaneando todas as transcrições em `~/.codex/sessions/<YYYY>/<MM>/<DD>/*.jsonl` e agrupando pelo `cwd` registrado no primeiro registro de cada sessão; projetos Copilot CLI são descobertos escaneando cada `~/.copilot/session-state/<sessionId>/workspace.yaml` (configurável via `COPILOT_HOME`) e agrupando pelo campo `cwd`; projetos Cursor Agent são descobertos escaneando metadados por sessão em `~/.cursor/agent-sessions/<sessionId>/` (configurável via `CURSOR_HOME`, com `conversations/` e `sessions/` como fallbacks) buscando um escalar `cwd` em `meta.json` / `session.json` / `workspace.yaml`; projetos OpenCode são descobertos consultando seu banco SQLite em `~/.local/share/opencode/opencode.db` via `opencode db --format json` (lemos as tabelas `session` e `project` e agrupamos por `project_id`); projetos Pi são descobertos escaneando transcrições JSONL por sessão em `~/.pi/agent/sessions/<encoded-cwd>/<timestamp>_<uuid>.jsonl` (configurável via `PI_SESSIONS_DIR`) e obtendo o `cwd` do primeiro registro de cada sessão; sessões do gateway Hermes são lidas diretamente do armazenamento SQLite de cada perfil — `~/.hermes/state.db` mais `~/.hermes/profiles/<name>/state.db` (substituível via `HERMES_HOME`, ou `HERMES_DB_PATH` para um único banco) — e agrupadas em projetos `hermes-<profile>-<source>` por perfil e `source` (Slack/Telegram/cli/cron — sessões de gateway não têm cwd); sessões do gateway OpenClaw são lidas de `~/.openclaw/agents/<agentId>/sessions/*.jsonl` e agrupadas em projetos `openclaw-<agentId>-<channel>` por agente e canal (também sem cwd); projetos Factory Droid são descobertos a partir das transcrições JSONL em `~/.factory/sessions/<encoded-cwd>/*.jsonl` e agrupados por cwd; projetos Devin a partir de seu banco SQLite em `~/.local/share/devin/cli/sessions.db` (agrupados pelo `working_directory` de cada sessão); projetos Antigravity a partir das transcrições JSONL em `~/.gemini/antigravity-cli/brain/<conversationId>/…/transcript_full.jsonl` e agrupados por cwd; e projetos Goose a partir de seu banco SQLite em `~/.local/share/goose/sessions/sessions.db` (agrupados pelo `working_dir` de cada sessão). Um projeto que foi utilizado por múltiplos CLIs aparece como uma única linha com todos os badges correspondentes. Use o menu suspenso **CLI** acima da tabela para filtrar por um agente CLI específico; a URL preserva sua seleção como `?cli=claude|codex|copilot|cursor|opencode|pi|hermes|openclaw|factory|devin|antigravity|goose`.
+
+Hermes e OpenClaw são de escopo de usuário e não possuem diretório de trabalho para agrupamento, portanto são exibidos como uma **árvore de pastas recolhível** — perfil (ou agente) no nível superior, com seus canais abaixo — enquanto todos os CLIs baseados em cwd permanecem como linhas planas. Linhas de pasta consolidam a contagem de sessões e a atividade mais recente de tudo abaixo delas, pastas recolhidas são lembradas entre visitas, e uma busca por palavra-chave expande o que corresponder.
+
+Cada projeto exibe:
+- Nome do projeto (derivado do caminho da pasta)
+- Um badge de CLI — `Claude Code` (laranja), `OpenAI Codex` (roxo), `GitHub Copilot` (azul), `Cursor Agent` (esmeralda), `OpenCode` (âmbar), `Pi` (rosa) e/ou `Hermes` (índigo)
+- Data da atividade mais recente da sessão
+
+Clique em um projeto para ver suas sessões.
+
+### Sessões
+
+Lista todas as sessões dentro de um projeto. Cada sessão exibe:
+- ID da sessão
+- Timestamps de início e fim
+- Número de chamadas de ferramentas
+- Contagem de atividade de hooks (políticas que foram acionadas)
+
+Use o filtro de intervalo de datas e a busca por ID de sessão para refinar a lista. As sessões são paginadas.
+
+Clique em uma sessão para abrir o visualizador de sessão.
+
+### Visualizador de sessão
+
+O visualizador de sessão responde à pergunta central sobre agentes autônomos: o que o agente fez e ele se manteve no caminho certo? Um badge de CLI ao lado do cabeçalho indica se a sessão é uma transcrição de Claude Code, OpenAI Codex, GitHub Copilot CLI, Cursor Agent, OpenCode, Pi, Hermes, OpenClaw, Factory Droid, Devin, Antigravity ou Goose. Ele exibe uma linha do tempo de tudo o que aconteceu em uma sessão:
+
+- **Mensagens** - Respostas de texto do Claude e prompts do usuário
+- **Chamadas de ferramentas** - Cada ferramenta invocada pelo Claude, com sua entrada e saída
+- **Atividade de políticas** - Para cada chamada de ferramenta, quais políticas foram acionadas e qual decisão retornaram
+
+A barra de estatísticas no topo exibe a duração da sessão, total de chamadas de ferramentas e um resumo das decisões de hook (contagens de allow / deny / instruct).
+
+Clique no botão **Download Logs** para exportar a sessão. Para sessões de Claude Code, Codex, Copilot, Cursor e Pi, você recebe a transcrição JSONL original em disco, byte a byte; para OpenCode (cujas sessões residem em SQLite, não em disco) você recebe um documento JSON espelhando as tabelas subjacentes `session` / `messages` / `parts`.
+
+### Auditoria
+
+Um relatório com personalidade sobre como seu agente realmente se comportou ao longo das sessões passadas. Executa o mesmo escaneamento do CLI `failproofai audit`, mas renderiza como um pôster de tela única compartilhável + quatro seções abaixo da dobra:
+
+1. **Pôster** — preenche o primeiro viewport. Região de captura PNG autossuficiente com o wordmark failproof_ai + rótulo de auditoria · índice de arquétipo (`№ NN of 08`) + data de auditoria · pontuação numérica (0–100) + pílula de percentil (`top 15%`) · o nome do arquétipo (um de `the optimist`, `the cowboy`, `the explorer`, `the goldfish`, `the paranoid architect`, `the precision builder`, `the hammer`, `the ghost`) + faixa de 3 palavras-chave · linha de raridade `// only N% of agents are this archetype` · tile de sigilo 8×8 pixels · rodapé `audit yours → failproof.ai`. Três botões de compartilhamento ficam logo fora da caixa de captura: `post your archetype` (X intent), `share on linkedin`, `download poster`. A captura é feita via `html-to-image` para que o PNG corresponda pixel a pixel ao que é exibido na tela (bordas tracejadas, máscara de logo SVG, gradientes, métricas de fonte — tudo preservado).
+2. **Pontos fortes** — lista de linhas ✓ tranquilas com comportamentos que seu agente já faz corretamente, derivados dos dados da auditoria ao vivo (taxa de chamada de ferramentas limpa, sem pushes diretos para main, zero vazamentos de credenciais, zero tempestades de tentativas) — cada um exibido apenas quando a política relevante tem um histórico limpo durante a janela de auditoria.
+3. **Peculiaridades** — tabela do que passou despercebido, ordenado por gravidade: `quando · o que passou + a política que teria detectado · pílula de severidade · visto`, onde a recorrência aparece como `new` (uma vez), `N× seen` (2–9 vezes) ou `recurring` (10+).
+4. **Como melhorar** — lista de linhas tranquilas, uma por política prescrita: nome da política em branco, descrição em uma linha, comando de instalação + botão de cópia no lado direito. O cabeçalho da seção exibe `enable all N → projected <score> · <tier>` (a pontuação que você alcançaria com todas as correções aplicadas), e seu botão `[install all]` copia o comando combinado `failproofai policy add a b c …` para cada política prescrita.
+5. **Volte melhorado** — dois cards lado a lado. Esquerda: definir um lembrete (seletor de cadência `3d` / `7d` / `14d` / `30d`; persiste via `/api/auth/reminder` após autenticação). Direita: desbloquear benefícios failproof — `invite a friend` abre um modal que aceita uma lista de e-mails de amigos separados por vírgula/espaço/quebra de linha (máx. 10 por envio), faz POST para `/api/audit/invite`, que encaminha para o `POST /v0/invite` do api-server. O api-server envia um e-mail por destinatário a partir de `invite@failproof.ai` com o remetente em Cc e `Reply-To` configurado, para que o destinatário veja quem o convidou e o remetente receba uma cópia em sua caixa de entrada. Usuários anônimos são redirecionados pelo `AuthDialog` primeiro para que o e-mail do remetente seja conhecido antes de os convites serem enviados. Direitos / cumprimento de benefícios é um acompanhamento futuro.
+
+Impulsionado pelo runtime `failproofai audit` — consulte [CLI de Auditoria](/pt-br/cli/audit) para o mecanismo de escaneamento subjacente, flags suportadas e invariantes de cache por transcrição. O dashboard armazena em cache o resultado mais recente em `~/.failproofai/audit-dashboard.json` (modo `0600`, slot único, novas execuções sobrescrevem) para que revisitas sejam instantâneas; **tanto os caches por transcrição quanto os de resultado completo são rejeitados na leitura após 7 dias** para que o dashboard nunca sirva silenciosamente um resultado com uma semana de atraso — após o TTL, `/audit` vai para seu estado vazio e solicita uma nova execução. Clicar em `[ re-audit now ]` próximo ao final do relatório faz POST em `/api/audit/run` com `noCache: true` — uma re-auditoria ignora o cache por transcrição e re-escaneia cada transcrição do zero em vez de retornar silenciosamente o resultado em cache — e o dashboard faz polling em `/api/audit/status` a 1Hz até que a execução termine; uma faixa rosa fixa de progresso é fixada no topo do viewport durante a execução com um cronômetro decorrido, e o resultado atualizado substitui o anterior ao concluir com sucesso (sem recarregamento completo da página; uma re-auditoria com falha deixa o relatório anterior intacto). Em caso de falha, a faixa fica vermelha com texto baseado no `RerunError.kind` (`timeout` / `network` / `post_failed`). Estado vazio (sem cache ou expirado) e estado de zero sessões (cache existe, mas o escaneamento não encontrou transcrições) são apresentados separadamente.
+
+### Políticas
+
+Uma página com duas abas para gerenciar políticas e revisar atividades.
+
+<Tabs>
+  <Tab title="Aba de Políticas">
+  - Seleção múltipla de quais CLIs de agentes o failproofai protege a partir de um único painel — Claude Code, OpenAI Codex, GitHub Copilot, Cursor Agent, OpenCode, Pi e Hermes têm uma linha com status de instalação (`Active` / `Detected` / `Inactive`), o caminho de configurações de escopo de usuário e um destaque colorido por marca. Marque ou desmarque os CLIs desejados e clique em `Apply changes` para instalar/desinstalar a diferença em uma etapa. CLIs cujo binário é detectado no PATH são pré-marcados.
+  - Ative ou desative políticas individuais com um único clique (salva em `~/.failproofai/policies-config.json` — compartilhado entre todos os CLIs instalados)
+  - Expanda uma política para configurar seus parâmetros (para políticas que suportam `policyParams`)
+  - Defina um caminho de arquivo de políticas personalizado
+  </Tab>
+  <Tab title="Aba de Atividade">
+  - Histórico paginado completo de cada evento de hook disparado em todas as sessões
+  - Filtre por decisão, tipo de evento, CLI (Claude Code / OpenAI Codex / GitHub Copilot _(beta)_ / Cursor Agent _(beta)_ / OpenCode _(beta)_ / Pi _(beta)_ / Hermes / OpenClaw / Factory Droid / Devin / Antigravity / Goose), nome da política ou ID de sessão
+  - Cada linha exibe: timestamp, nome da política, decisão, badge de CLI (laranja = Claude Code, roxo = OpenAI Codex, azul = GitHub Copilot, esmeralda = Cursor Agent, âmbar = OpenCode, rosa = Pi, índigo = Hermes, verde-azulado = OpenClaw, rosa-avermelhado = Factory Droid, violeta = Devin, ciano = Antigravity, lima = Goose), nome da ferramenta, ID de sessão e o motivo para decisões de deny/instruct
+  - Clique em um ID de sessão para abrir sua transcrição — o visualizador detecta automaticamente qual CLI disparou o 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 renderiza o badge do CLI correspondente no cabeçalho
+  </Tab>
+</Tabs>
+
+---
+
+## Atualização automática
+
+O dashboard possui um botão de alternância de atualização automática na navegação superior. Quando ativado, a página atual é atualizada periodicamente para exibir novas sessões e atividades de políticas conforme aparecem. Essencial para monitorar sessões de agentes autônomos de longa duração.
+
+---
+
+## Desabilitando páginas
+
+Se você precisar apenas de algumas partes do dashboard, defina `FAILPROOFAI_DISABLE_PAGES` com uma lista de nomes de páginas separados por vírgula:
+
+```bash
+FAILPROOFAI_DISABLE_PAGES=policies failproofai
+```
+
+Valores válidos: `policies`, `projects`, `audit`.
+
+---
+
+## Configurando o caminho dos projetos
+
+Por padrão, o dashboard lê do diretório padrão de projetos do Claude Code. Substitua para configurações personalizadas:
+
+```bash
+CLAUDE_PROJECTS_PATH=/custom/path/to/projects failproofai
+```
+
+---
+
+## Acessando de um host diferente de localhost
+
+Ao executar o dashboard em **modo dev** (`npm run dev`) e acessá-lo a partir de um hostname diferente de `localhost` — por exemplo, um domínio personalizado, um IP remoto ou uma URL tunelada — você pode ver um aviso como:
+
+```text
+⚠ Blocked cross-origin request to Next.js dev resource /_next/webpack-hmr from "dashboard.example.com".
+```
+
+Isso é o Next.js bloqueando o acesso cross-origin ao seu websocket de HMR (hot module reload), que é um recurso exclusivo do modo dev. Para permitir seu host, use a flag `--allowed-origins`:
+
+```bash
+npm run dev -- --allowed-origins dashboard.example.com
+```
+
+Para múltiplos hosts ou IPs, passe uma lista separada por vírgulas:
+
+```bash
+npm run dev -- --allowed-origins dashboard.example.com,192.168.1.5
+```
+
+Você também pode definir a variável de ambiente `FAILPROOFAI_ALLOWED_DEV_ORIGINS` em vez disso:
+
+```bash
+FAILPROOFAI_ALLOWED_DEV_ORIGINS=dashboard.example.com npm run dev
+```
+
+<Note>
+Isso se aplica apenas ao modo dev. Ao executar `failproofai` (modo produção), não há websocket de HMR nem problema de recurso dev cross-origin.
+</Note>

package/.next/standalone/docs-old/pt-br/examples.mdx

@@ -0,0 +1,307 @@
+---
+title: Exemplos
+description: "Como configurar hooks para Claude Code e o Agents SDK"
+icon: book-open
+---
+
+Exemplos prontos para uso em cenários comuns. Cada um mostra como instalar e o que esperar.
+
+---
+
+## Configurando hooks para o Claude Code
+
+O Failproof AI integra-se ao Claude Code por meio do seu [sistema de hooks](https://docs.anthropic.com/en/docs/claude-code/hooks). Quando você executa `failproofai policies --install`, ele registra comandos de hook no `settings.json` do Claude Code que são acionados a cada chamada de ferramenta.
+
+<Steps>
+  <Step title="Instale o failproofai">
+    ```bash
+    npm install -g failproofai
+    ```
+  </Step>
+  <Step title="Ative todas as políticas integradas">
+    ```bash
+    failproofai policies --install
+    ```
+  </Step>
+  <Step title="Verifique se os hooks foram registrados">
+    ```bash
+    cat ~/.claude/settings.json | grep failproofai
+    ```
+
+    Você deve ver entradas de hook para os eventos `PreToolUse`, `PostToolUse`, `Notification` e `Stop`.
+  </Step>
+  <Step title="Execute o Claude Code">
+    ```bash
+    claude
+    ```
+
+    As políticas agora são executadas automaticamente a cada chamada de ferramenta. Tente pedir ao Claude para executar `sudo rm -rf /` — o comando será bloqueado.
+  </Step>
+</Steps>
+
+---
+
+## Configurando hooks para o Agents SDK
+
+Se você está desenvolvendo com o [Agents SDK](https://docs.anthropic.com/en/docs/agents-sdk), pode usar o mesmo sistema de hooks de forma programática.
+
+<Steps>
+  <Step title="Instale o failproofai no seu projeto">
+    ```bash
+    npm install failproofai
+    ```
+  </Step>
+  <Step title="Configure os hooks no seu agente">
+    Passe comandos de hook ao criar o processo do seu agente. Os hooks são acionados da mesma forma que no Claude Code — via stdin/stdout JSON:
+
+    ```bash
+    failproofai --hook PreToolUse   # chamado antes de cada ferramenta
+    failproofai --hook PostToolUse  # chamado após cada ferramenta
+    ```
+  </Step>
+  <Step title="Escreva uma política personalizada para o seu 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="Instale a política personalizada">
+    ```bash
+    failproofai policies --install --custom ./my-agent-policies.js
+    ```
+  </Step>
+</Steps>
+
+---
+
+## Bloquear comandos destrutivos
+
+A configuração mais comum — impedir que agentes causem danos irreversíveis.
+
+```bash
+failproofai policies --install block-sudo block-rm-rf block-force-push block-curl-pipe-sh
+```
+
+O que isso faz:
+- `block-sudo` — bloqueia todos os comandos `sudo`
+- `block-rm-rf` — bloqueia a exclusão recursiva de arquivos
+- `block-force-push` — bloqueia `git push --force`
+- `block-curl-pipe-sh` — bloqueia o redirecionamento de scripts remotos para o shell
+
+---
+
+## Prevenir vazamento de segredos
+
+Impeça que agentes visualizem ou vazem credenciais na saída de ferramentas.
+
+```bash
+failproofai policies --install sanitize-api-keys sanitize-jwt sanitize-connection-strings sanitize-bearer-tokens
+```
+
+Essas políticas são acionadas no `PostToolUse` — após a execução de uma ferramenta, elas limpam a saída antes que o agente a veja.
+
+---
+
+## Receber alertas no Slack quando agentes precisam de atenção
+
+Use o hook de notificação para encaminhar alertas de inatividade ao 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 {
+      // nunca bloqueie o agente se o Slack estiver inacessível
+    }
+
+    return allow();
+  },
+});
+```
+
+Instale com:
+
+```bash
+SLACK_WEBHOOK_URL=https://hooks.slack.com/... failproofai policies --install --custom ./slack-alerts.js
+```
+
+---
+
+## Manter agentes em uma branch
+
+Impeça que agentes troquem de branch ou façam push para branches protegidas.
+
+```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();
+  },
+});
+```
+
+---
+
+## Exigir testes antes de commits
+
+Lembre os agentes de executar os testes antes de fazer 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();
+  },
+});
+```
+
+---
+
+## Proteger um repositório de produção
+
+Faça commit de uma configuração no nível do projeto para que todos os desenvolvedores do seu time utilizem as mesmas políticas.
+
+Crie `.failproofai/policies-config.json` no seu repositório:
+
+```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"]
+    }
+  }
+}
+```
+
+Em seguida, faça o commit:
+
+```bash
+git add .failproofai/policies-config.json
+git commit -m "Add failproofai team policies"
+```
+
+Todo membro do time que tiver o failproofai instalado irá receber essas regras automaticamente.
+
+---
+
+## Construir um padrão de qualidade organizacional com políticas de convenção
+
+A configuração de maior impacto: faça commit de `.failproofai/policies/` no seu repositório com políticas ajustadas ao seu projeto. Todos os membros do time as recebem automaticamente — sem comandos de instalação, sem alterações de configuração.
+
+<Steps>
+  <Step title="Crie o diretório e adicione as políticas">
+    ```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="Faça commit no git">
+    ```bash
+    git add .failproofai/policies/
+    git commit -m "Add team quality policies"
+    ```
+  </Step>
+  <Step title="Continue melhorando">
+    À medida que o seu time encontrar novos problemas, adicione políticas e faça push. Todos recebem a atualização no próximo `git pull`. Essas políticas se tornam um padrão de qualidade vivo que cresce junto com o time.
+  </Step>
+</Steps>
+
+---
+
+## Mais exemplos
+
+O diretório [`examples/`](https://github.com/failproofai/failproofai/tree/main/examples) no repositório contém:
+
+| Arquivo | O que demonstra |
+|---------|-----------------|
+| `policies-basic.js` | Políticas iniciais — bloquear escritas em produção, force-push e scripts redirecionados |
+| `policies-notification.js` | Alertas no Slack para notificações de inatividade e encerramento de sessão |
+| `policies-advanced/index.js` | Importações transitivas, hooks assíncronos, limpeza de saída no PostToolUse e tratamento do evento Stop |

package/.next/standalone/docs-old/pt-br/for-agents.mdx

@@ -0,0 +1,38 @@
+---
+title: "Para agentes"
+description: "Adicione o conhecimento do Failproof AI ao seu agente de codificação com um único comando. Funciona com Claude Code, Cursor, Windsurf e muito mais."
+---
+
+Adicione a referência completa do Failproof AI ao seu agente de codificação com um único comando. Funciona com Claude Code, Cursor, Windsurf e qualquer outro agente que suporte skills.
+
+```bash
+npx skills add https://docs.befailproof.ai
+```
+
+O `npx skills` detecta quais agentes você tem instalados e adiciona a skill no formato correto para cada um automaticamente.
+
+## O que a skill cobre
+
+| Área | O que está incluído |
+|------|----------------|
+| Policies | Nomes de policies nativas, tipos de eventos, parâmetros, ativar/desativar |
+| Custom policies | `customPolicies.add()`, filtros de correspondência, API `allow`/`deny`/`instruct` |
+| Objeto de contexto | `ctx.eventType`, `ctx.toolName`, `ctx.toolInput`, `ctx.session` |
+| Configuração | Estrutura do `policies-config.json`, mesclagem de escopos, `policyParams` |
+| CLI | `failproofai policies --install`, `--uninstall`, `--custom`, escopos |
+| Dashboard | Visualizador de sessões, atividade de policies, variáveis de ambiente |
+| Arquitetura | Fluxo do hook handler, códigos de saída, contrato stdin/stdout |
+
+## A skill está completa?
+
+O Mintlify gera o `llms.txt` a partir de todas as páginas da navegação. A documentação do Failproof AI cobre a API completa — cada policy, opção e exemplo está incluído. Se você encontrar algo faltando, a fonte está em `https://docs.befailproof.ai/llms-full.txt`.
+
+Para contexto direcionado, vincule diretamente a uma página específica:
+
+```bash
+# Apenas a API de custom policies
+npx skills add https://docs.befailproof.ai/custom-policies
+
+# Apenas as built-in policies
+npx skills add https://docs.befailproof.ai/built-in-policies
+```