failproofai 1.0.1-beta.0 → 1.0.1

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

@@ -0,0 +1,151 @@
+---
+title: Dashboard
+description: "Agent-Sitzungen überwachen, Tool-Aufrufe prüfen und Richtlinien verwalten"
+icon: chart-line
+---
+
+Das failproofai-Dashboard ist eine lokale Webanwendung zur Überwachung Ihrer KI-Agent-Sitzungen und zur Verwaltung von Richtlinien. Sehen Sie, was Ihre Agents während Ihrer Abwesenheit getan haben.
+
+---
+
+## Dashboard starten
+
+```bash
+failproofai
+```
+
+Öffnet sich unter `http://localhost:8020`.
+
+Das Dashboard liest lokale Projekt-, Sitzungs- und failproofai-Konfigurationsdaten direkt aus dem Dateisystem. Optionale authentifizierte Funktionen, wie Audit-Erinnerungen und Einladungen, senden die für diese Anfragen benötigten Informationen (einschließlich E-Mail-Adressen) an Remote-APIs.
+
+---
+
+## Seiten
+
+### Projekte
+
+Listet alle Claude Code-, OpenAI Codex-, GitHub Copilot CLI- _(Beta)_, Cursor Agent- _(Beta)_, OpenCode- _(Beta)_, Pi- _(Beta)_, Hermes-, OpenClaw-, Factory Droid-, Devin-, Antigravity- und Goose-Projekte auf, die auf Ihrem Computer gefunden wurden. Claude-Projekte werden aus `~/.claude/projects/` (oder dem durch `CLAUDE_PROJECTS_PATH` festgelegten Pfad) ermittelt; Codex-Projekte werden durch Scannen aller Transkripte unter `~/.codex/sessions/<YYYY>/<MM>/<DD>/*.jsonl` und Gruppierung nach dem in jedem ersten Datensatz der Sitzung aufgezeichneten `cwd` entdeckt; Copilot CLI-Projekte werden durch Scannen jeder `~/.copilot/session-state/<sessionId>/workspace.yaml` (konfigurierbar über `COPILOT_HOME`) und Gruppierung nach dem `cwd`-Feld entdeckt; Cursor Agent-Projekte werden durch Scannen der sitzungsspezifischen Metadaten unter `~/.cursor/agent-sessions/<sessionId>/` (konfigurierbar über `CURSOR_HOME`, mit `conversations/` und `sessions/` als Fallback) für ein `cwd`-Skalar in `meta.json` / `session.json` / `workspace.yaml` entdeckt; OpenCode-Projekte werden durch Abfragen der SQLite-Datenbank unter `~/.local/share/opencode/opencode.db` via `opencode db --format json` entdeckt (wir lesen die Tabellen `session` und `project` und gruppieren nach `project_id`); Pi-Projekte werden durch Scannen der sitzungsspezifischen JSONL-Transkripte unter `~/.pi/agent/sessions/<encoded-cwd>/<timestamp>_<uuid>.jsonl` (konfigurierbar über `PI_SESSIONS_DIR`) und Auslesen des `cwd` aus dem ersten Datensatz jeder Sitzung entdeckt; Hermes Gateway-Sitzungen werden direkt aus dem SQLite-Speicher jedes Profils gelesen — `~/.hermes/state.db` sowie `~/.hermes/profiles/<name>/state.db` (überschreibbar über `HERMES_HOME` oder `HERMES_DB_PATH` für eine einzelne Datenbank) — und in `hermes-<profile>-<source>`-Projekte nach Profil und `source` (Slack/Telegram/cli/cron – Gateway-Sitzungen haben kein cwd) gruppiert; OpenClaw Gateway-Sitzungen werden aus `~/.openclaw/agents/<agentId>/sessions/*.jsonl` gelesen und in `openclaw-<agentId>-<channel>`-Projekte nach Agent und Kanal gruppiert (ebenfalls ohne cwd); Factory Droid-Projekte werden aus den JSONL-Transkripten unter `~/.factory/sessions/<encoded-cwd>/*.jsonl` ermittelt und nach cwd gruppiert; Devin-Projekte aus der SQLite-Datenbank unter `~/.local/share/devin/cli/sessions.db` (gruppiert nach dem `working_directory` jeder Sitzung); Antigravity-Projekte aus den JSONL-Transkripten unter `~/.gemini/antigravity-cli/brain/<conversationId>/…/transcript_full.jsonl` und nach cwd gruppiert; und Goose-Projekte aus der SQLite-Datenbank unter `~/.local/share/goose/sessions/sessions.db` (gruppiert nach dem `working_dir` jeder Sitzung). Ein Projekt, das von mehreren CLIs verwendet wurde, wird als einzelne Zeile mit allen passenden Badges angezeigt. Verwenden Sie das **CLI**-Dropdown über der Tabelle, um nach einer bestimmten Agent-CLI zu filtern; die URL speichert Ihre Auswahl als `?cli=claude|codex|copilot|cursor|opencode|pi|hermes|openclaw|factory|devin|antigravity|goose`.
+
+Hermes und OpenClaw sind benutzerbezogen und haben kein Arbeitsverzeichnis zur Gruppierung, daher werden sie als **ausklappbarer Ordnerbaum** dargestellt — Profil (oder Agent) auf der obersten Ebene, darunter die Kanäle — während alle cwd-basierten CLIs als flache Zeile verbleiben. Ordnerzeilen fassen die Sitzungsanzahl und die jüngste Aktivität aller untergeordneten Elemente zusammen, eingeklappte Ordner werden zwischen Besuchen gespeichert, und eine Schlüsselwortsuche klappt gefundene Treffer auf.
+
+Jedes Projekt zeigt:
+- Projektname (abgeleitet vom Ordnerpfad)
+- Ein CLI-Badge — `Claude Code` (orange), `OpenAI Codex` (lila), `GitHub Copilot` (blau), `Cursor Agent` (smaragd), `OpenCode` (bernstein), `Pi` (pink) und/oder `Hermes` (indigo)
+- Datum der letzten Sitzungsaktivität
+
+Klicken Sie auf ein Projekt, um seine Sitzungen anzuzeigen.
+
+### Sitzungen
+
+Listet alle Sitzungen innerhalb eines Projekts auf. Jede Sitzung zeigt:
+- Sitzungs-ID
+- Start- und Endzeitstempel
+- Anzahl der Tool-Aufrufe
+- Anzahl der Hook-Aktivitäten (ausgelöste Richtlinien)
+
+Verwenden Sie den Datumsbereichsfilter und die Sitzungs-ID-Suche, um die Liste einzugrenzen. Sitzungen sind paginiert.
+
+Klicken Sie auf eine Sitzung, um den Sitzungsbetrachter zu öffnen.
+
+### Sitzungsbetrachter
+
+Der Sitzungsbetrachter beantwortet die zentrale Frage bei autonomen Agents: Was hat der Agent getan, und ist er auf Kurs geblieben? Ein CLI-Badge neben dem Header zeigt an, ob es sich um ein Claude Code-, OpenAI Codex-, GitHub Copilot CLI-, Cursor Agent-, OpenCode-, Pi-, Hermes-, OpenClaw-, Factory Droid-, Devin-, Antigravity- oder Goose-Transkript handelt. Er zeigt einen Zeitstrahl aller Ereignisse in einer Sitzung:
+
+- **Nachrichten** – Claudes Textantworten und Benutzeraufforderungen
+- **Tool-Aufrufe** – Jedes Tool, das Claude aufgerufen hat, mit Ein- und Ausgabe
+- **Richtlinienaktivität** – Für jeden Tool-Aufruf: welche Richtlinien ausgelöst wurden und welche Entscheidung sie zurückgegeben haben
+
+Die Statistikleiste oben zeigt Sitzungsdauer, Gesamtzahl der Tool-Aufrufe und eine Zusammenfassung der Hook-Entscheidungen (allow / deny / instruct-Anzahl).
+
+Klicken Sie auf die Schaltfläche **Logs herunterladen**, um die Sitzung zu exportieren. Für Claude Code-, Codex-, Copilot-, Cursor- und Pi-Sitzungen erhalten Sie das originale JSONL-Transkript vom Datenträger byte-für-byte; für OpenCode (dessen Sitzungen in SQLite und nicht auf der Festplatte gespeichert sind) erhalten Sie ein JSON-Dokument, das die zugrunde liegenden Tabellen `session` / `messages` / `parts` widerspiegelt.
+
+### Audit
+
+Ein charaktergetriebener Bericht darüber, wie sich Ihr Agent tatsächlich in vergangenen Sitzungen verhalten hat. Führt denselben Scan wie die `failproofai audit`-CLI durch, stellt ihn jedoch als einseitiges, teilbares Poster + vier Abschnitte unterhalb des sichtbaren Bereichs dar:
+
+1. **Poster** — füllt den ersten Viewport. Eigenständiger PNG-Erfassungsbereich mit dem failproof_ai-Wortmarke + Audit-Label · Archetyp-Index (`№ NN of 08`) + Audit-Datum · numerische Punktzahl (0–100) + Perzentil-Pille (`top 15%`) · der Archetyp-Name (einer von `the optimist`, `the cowboy`, `the explorer`, `the goldfish`, `the paranoid architect`, `the precision builder`, `the hammer`, `the ghost`) + 3-Keyword-Streifen · `// only N% of agents are this archetype`-Seltenheitszeile · 8×8-Pixel-Sigillen-Kachel · `audit yours → failproof.ai`-Fußzeile. Drei Teilen-Schaltflächen befinden sich knapp außerhalb des Erfassungsbereichs: `post your archetype` (X Intent), `share on linkedin`, `download poster`. Die Erfassung erfolgt über `html-to-image`, sodass das PNG pixelgenau mit der Bildschirmdarstellung übereinstimmt (gestrichelte Rahmen, SVG-Logo-Maske, Farbverläufe, Schriftmetriken — alles erhalten).
+2. **Stärken** — ruhige ✓-Zeilenliste von Verhaltensweisen, die Ihr Agent bereits richtig macht, abgeleitet aus den Live-Audit-Daten (saubere Tool-Aufruf-Rate, keine direkten Pushes zu main, null Credential-Lecks, null Wiederholungsstürme) — jeweils nur angezeigt, wenn die entsprechende Richtlinie im Audit-Zeitraum eine saubere Bilanz hat.
+3. **Eigenheiten** — Tabelle der Dinge, die durchgerutscht sind, nach Schweregrad sortiert: `Zeitpunkt · Was durchgerutscht ist + die Richtlinie, die es hätte abfangen sollen · Schweregradpille · gesehen`, wobei das Vorkommen `new` (einmal), `N× seen` (2–9 Mal) oder `recurring` (10+) lautet.
+4. **So verbessern Sie sich** — ruhige Zeilenliste, eine pro empfohlener Richtlinie: Richtlinienname in Weiß, einzeilige Beschreibung, Installationsbefehl + Kopierschaltfläche auf der rechten Seite. Die Abschnittsüberschrift lautet `enable all N → projected <score> · <tier>` (die Punktzahl, die Sie mit allen angewendeten Korrekturen erreichen würden), und die Schaltfläche `[install all]` kopiert den kombinierten `failproofai policy add a b c …`-Befehl für jede empfohlene Richtlinie.
+5. **Komm besser zurück** — zwei nebeneinander liegende Karten. Links: Erinnerung setzen (`3d` / `7d` / `14d` / `30d` Kadenz-Auswahl; wird nach Authentifizierung über `/api/auth/reminder` gespeichert). Rechts: failproof-Vorteile freischalten — `invite a friend` öffnet ein Modal, das eine komma-/leerzeichen-/zeilenumbruchgetrennte Liste von Freundes-E-Mails akzeptiert (max. 10 pro Sendung), POSTet diese an `/api/audit/invite`, das sie an den API-Server unter `POST /v0/invite` weiterleitet. Der API-Server sendet eine E-Mail pro Empfänger von `invite@failproof.ai` mit dem Absender im Cc und gesetztem `Reply-To`, sodass der Empfänger sieht, wer ihn eingeladen hat, und der Absender eine Kopie in seinem Posteingang erhält. Anonyme Benutzer werden zuerst durch den `AuthDialog` geleitet, damit die E-Mail des Absenders bekannt ist, bevor Einladungen verschickt werden. Ansprüche/Vorteilserfüllung folgt.
+
+Angetrieben von der `failproofai audit`-Laufzeit — siehe [Audit CLI](/de/cli/audit) für die zugrunde liegende Scan-Engine, unterstützte Flags und sitzungsspezifische Cache-Invarianten. Das Dashboard speichert das neueste Ergebnis unter `~/.failproofai/audit-dashboard.json` (Modus `0600`, einzelner Slot, neue Läufe überschreiben), sodass erneute Besuche sofort laden; **sowohl der transkriptspezifische als auch der gesamtergebnisbezogene Cache werden beim Lesen abgelehnt, sobald sie älter als 7 Tage sind**, damit das Dashboard kein einwöchiges Ergebnis stillschweigend ausliefert — nach Ablauf der TTL fällt `/audit` in seinen Leerzustand und fordert einen neuen Lauf an. Ein Klick auf `[ re-audit now ]` nahe am Ende des Berichts sendet einen POST an `/api/audit/run` mit `noCache: true` — ein Re-Audit umgeht den transkriptspezifischen Cache und scannt jedes Transkript von Grund auf neu, anstatt stillschweigend das zwischengespeicherte Ergebnis zurückzugeben — und das Dashboard fragt `/api/audit/status` mit 1 Hz ab, bis der Lauf abgeschlossen ist; ein pinker Fortschrittsbalken wird während des Laufs mit einem Zeitmesser oben im Viewport fixiert, und das frische Ergebnis wird bei Erfolg an Ort und Stelle ausgetauscht (kein vollständiges Neuladen der Seite; ein fehlgeschlagener Re-Audit lässt den vorherigen Bericht intakt). Bei einem Fehler wird der Balken rot mit einer auf den `RerunError.kind` abgestimmten Meldung (`timeout` / `network` / `post_failed`). Leerzustand (kein Cache oder abgelaufen) und Null-Sitzungen-Zustand (Cache vorhanden, aber der Scan hat keine Transkripte gefunden) werden separat angezeigt.
+
+### Richtlinien
+
+Eine zweiseitige Seite zur Verwaltung von Richtlinien und zur Überprüfung von Aktivitäten.
+
+<Tabs>
+  <Tab title="Richtlinien-Tab">
+  - Wählen Sie per Mehrfachauswahl aus, welche Agent-CLIs failproofai schützt — Claude Code, OpenAI Codex, GitHub Copilot, Cursor Agent, OpenCode, Pi und Hermes haben jeweils eine Zeile mit Installationsstatus (`Active` / `Detected` / `Inactive`), dem benutzerspezifischen Einstellungspfad und einem markenspezifischen Akzent. Aktivieren oder deaktivieren Sie die gewünschten CLIs und klicken Sie auf `Apply changes`, um die Änderungen in einem Schritt zu installieren/deinstallieren. CLIs, deren Binary im PATH erkannt wird, sind vorausgewählt.
+  - Schalten Sie einzelne Richtlinien mit einem Klick ein oder aus (schreibt in `~/.failproofai/policies-config.json` — gemeinsam von allen installierten CLIs genutzt)
+  - Erweitern Sie eine Richtlinie, um ihre Parameter zu konfigurieren (für Richtlinien, die `policyParams` unterstützen)
+  - Legen Sie einen benutzerdefinierten Pfad für die Richtliniendatei fest
+  </Tab>
+  <Tab title="Aktivitäts-Tab">
+  - Vollständiger paginierter Verlauf aller Hook-Ereignisse, die in allen Sitzungen ausgelöst wurden
+  - Filtern nach Entscheidung, Ereignistyp, CLI (Claude Code / OpenAI Codex / GitHub Copilot _(Beta)_ / Cursor Agent _(Beta)_ / OpenCode _(Beta)_ / Pi _(Beta)_ / Hermes / OpenClaw / Factory Droid / Devin / Antigravity / Goose), Richtlinienname oder Sitzungs-ID
+  - Jede Zeile zeigt: Zeitstempel, Richtlinienname, Entscheidung, CLI-Badge (orange = Claude Code, lila = OpenAI Codex, blau = GitHub Copilot, smaragd = Cursor Agent, bernstein = OpenCode, pink = Pi, indigo = Hermes, blaugrün = OpenClaw, rose = Factory Droid, violett = Devin, cyan = Antigravity, limette = Goose), Tool-Name, Sitzungs-ID und den Grund für deny/instruct-Entscheidungen
+  - Klicken Sie auf eine Sitzungs-ID, um ihr Transkript zu öffnen — der Betrachter erkennt automatisch, welche CLI den Hook ausgelöst hat (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`) und zeigt das passende CLI-Badge im Header an
+  </Tab>
+</Tabs>
+
+---
+
+## Automatische Aktualisierung
+
+Das Dashboard verfügt über einen Umschalter für die automatische Aktualisierung in der oberen Navigation. Wenn aktiviert, wird die aktuelle Seite regelmäßig aktualisiert, um neue Sitzungen und Richtlinienaktivitäten anzuzeigen, sobald sie auftreten. Unverzichtbar für die Überwachung lang laufender autonomer Agent-Sitzungen.
+
+---
+
+## Seiten deaktivieren
+
+Wenn Sie nur bestimmte Teile des Dashboards benötigen, setzen Sie `FAILPROOFAI_DISABLE_PAGES` auf eine kommagetrennte Liste von Seitennamen:
+
+```bash
+FAILPROOFAI_DISABLE_PAGES=policies failproofai
+```
+
+Gültige Werte: `policies`, `projects`, `audit`.
+
+---
+
+## Projektpfad konfigurieren
+
+Standardmäßig liest das Dashboard aus dem Standardverzeichnis für Claude Code-Projekte. Überschreiben Sie es für benutzerdefinierte Setups:
+
+```bash
+CLAUDE_PROJECTS_PATH=/custom/path/to/projects failproofai
+```
+
+---
+
+## Zugriff von einem Nicht-localhost-Host
+
+Wenn Sie das Dashboard im **Entwicklungsmodus** (`npm run dev`) ausführen und von einem anderen Hostnamen als `localhost` darauf zugreifen — zum Beispiel einer benutzerdefinierten Domain, einer Remote-IP oder einer getunnelten URL — erscheint möglicherweise eine Warnung wie:
+
+```text
+⚠ Blocked cross-origin request to Next.js dev resource /_next/webpack-hmr from "dashboard.example.com".
+```
+
+Dies ist Next.js, das den ursprungsübergreifenden Zugriff auf seinen HMR-WebSocket (Hot Module Reload) blockiert, welcher eine ausschließlich entwicklungsspezifische Funktion ist. Um Ihren Host zuzulassen, verwenden Sie das Flag `--allowed-origins`:
+
+```bash
+npm run dev -- --allowed-origins dashboard.example.com
+```
+
+Für mehrere Hosts oder IPs übergeben Sie eine kommagetrennte Liste:
+
+```bash
+npm run dev -- --allowed-origins dashboard.example.com,192.168.1.5
+```
+
+Sie können auch stattdessen die Umgebungsvariable `FAILPROOFAI_ALLOWED_DEV_ORIGINS` setzen:
+
+```bash
+FAILPROOFAI_ALLOWED_DEV_ORIGINS=dashboard.example.com npm run dev
+```
+
+<Note>
+Dies gilt nur für den Entwicklungsmodus. Beim Ausführen von `failproofai` (Produktionsmodus) gibt es keinen HMR-WebSocket und kein ursprungsübergreifendes Entwicklungsressourcenproblem.
+</Note>

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

@@ -0,0 +1,307 @@
+---
+title: Beispiele
+description: "So richtest du Hooks für Claude Code und das Agents SDK ein"
+icon: book-open
+---
+
+Sofort einsatzbereite Beispiele für häufige Anwendungsfälle. Jedes zeigt, wie man es installiert und was zu erwarten ist.
+
+---
+
+## Hooks für Claude Code einrichten
+
+Failproof AI integriert sich mit Claude Code über dessen [Hooks-System](https://docs.anthropic.com/en/docs/claude-code/hooks). Wenn du `failproofai policies --install` ausführst, werden Hook-Befehle in der `settings.json` von Claude Code registriert, die bei jedem Tool-Aufruf ausgelöst werden.
+
+<Steps>
+  <Step title="failproofai installieren">
+    ```bash
+    npm install -g failproofai
+    ```
+  </Step>
+  <Step title="Alle integrierten Richtlinien aktivieren">
+    ```bash
+    failproofai policies --install
+    ```
+  </Step>
+  <Step title="Prüfen, ob Hooks registriert sind">
+    ```bash
+    cat ~/.claude/settings.json | grep failproofai
+    ```
+
+    Es sollten Hook-Einträge für `PreToolUse`-, `PostToolUse`-, `Notification`- und `Stop`-Ereignisse erscheinen.
+  </Step>
+  <Step title="Claude Code starten">
+    ```bash
+    claude
+    ```
+
+    Richtlinien laufen jetzt automatisch bei jedem Tool-Aufruf. Versuche, Claude zur Ausführung von `sudo rm -rf /` aufzufordern – der Befehl wird blockiert.
+  </Step>
+</Steps>
+
+---
+
+## Hooks für das Agents SDK einrichten
+
+Wenn du mit dem [Agents SDK](https://docs.anthropic.com/en/docs/agents-sdk) entwickelst, kannst du dasselbe Hook-System programmatisch verwenden.
+
+<Steps>
+  <Step title="failproofai im Projekt installieren">
+    ```bash
+    npm install failproofai
+    ```
+  </Step>
+  <Step title="Hooks im Agenten konfigurieren">
+    Übergib Hook-Befehle beim Erstellen deines Agentenprozesses. Die Hooks werden genau wie in Claude Code ausgelöst – über stdin/stdout JSON:
+
+    ```bash
+    failproofai --hook PreToolUse   # wird vor jedem Tool aufgerufen
+    failproofai --hook PostToolUse  # wird nach jedem Tool aufgerufen
+    ```
+  </Step>
+  <Step title="Eine benutzerdefinierte Richtlinie für den Agenten schreiben">
+    ```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="Die benutzerdefinierte Richtlinie installieren">
+    ```bash
+    failproofai policies --install --custom ./my-agent-policies.js
+    ```
+  </Step>
+</Steps>
+
+---
+
+## Destruktive Befehle blockieren
+
+Das häufigste Setup – verhindert, dass Agenten irreversiblen Schaden anrichten.
+
+```bash
+failproofai policies --install block-sudo block-rm-rf block-force-push block-curl-pipe-sh
+```
+
+Was das bewirkt:
+- `block-sudo` – blockiert alle `sudo`-Befehle
+- `block-rm-rf` – blockiert das rekursive Löschen von Dateien
+- `block-force-push` – blockiert `git push --force`
+- `block-curl-pipe-sh` – blockiert das Weiterleiten von Remote-Skripten an die Shell
+
+---
+
+## Geheimnisse vor Weitergabe schützen
+
+Verhindert, dass Agenten Zugangsdaten in der Tool-Ausgabe sehen oder weitergeben.
+
+```bash
+failproofai policies --install sanitize-api-keys sanitize-jwt sanitize-connection-strings sanitize-bearer-tokens
+```
+
+Diese Richtlinien werden bei `PostToolUse` ausgelöst – nachdem ein Tool ausgeführt wurde, bereinigen sie die Ausgabe, bevor der Agent sie sieht.
+
+---
+
+## Slack-Benachrichtigungen erhalten, wenn Agenten Aufmerksamkeit brauchen
+
+Verwende den Notification-Hook, um Leerlauf-Benachrichtigungen an Slack weiterzuleiten.
+
+```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 {
+      // den Agenten niemals blockieren, wenn Slack nicht erreichbar ist
+    }
+
+    return allow();
+  },
+});
+```
+
+Installieren:
+
+```bash
+SLACK_WEBHOOK_URL=https://hooks.slack.com/... failproofai policies --install --custom ./slack-alerts.js
+```
+
+---
+
+## Agenten auf einem Branch halten
+
+Verhindert, dass Agenten Branches wechseln oder in geschützte Branches pushen.
+
+```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();
+  },
+});
+```
+
+---
+
+## Tests vor Commits vorschreiben
+
+Erinnere Agenten daran, Tests vor dem Committen auszuführen.
+
+```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();
+  },
+});
+```
+
+---
+
+## Ein Produktions-Repository absichern
+
+Lege eine projektweite Konfiguration fest, damit alle Entwickler in deinem Team dieselben Richtlinien erhalten.
+
+Erstelle `.failproofai/policies-config.json` in deinem 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"]
+    }
+  }
+}
+```
+
+Dann einchecken:
+
+```bash
+git add .failproofai/policies-config.json
+git commit -m "Add failproofai team policies"
+```
+
+Alle Teammitglieder, die failproofai installiert haben, übernehmen diese Regeln automatisch.
+
+---
+
+## Organisationsweite Qualitätsstandards mit Convention-Richtlinien etablieren
+
+Das wirkungsvollste Setup: Lege `.failproofai/policies/` mit auf dein Projekt zugeschnittenen Richtlinien in dein Repository. Alle Teammitglieder erhalten sie automatisch – ohne Installationsbefehle, ohne Konfigurationsänderungen.
+
+<Steps>
+  <Step title="Verzeichnis erstellen und Richtlinien hinzufügen">
+    ```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="In Git einchecken">
+    ```bash
+    git add .failproofai/policies/
+    git commit -m "Add team quality policies"
+    ```
+  </Step>
+  <Step title="Kontinuierlich verbessern">
+    Wenn das Team auf neue Fehlerquellen stößt, füge Richtlinien hinzu und pushe sie. Alle erhalten das Update beim nächsten `git pull`. Diese Richtlinien werden zu einem lebendigen Qualitätsstandard, der mit deinem Team wächst.
+  </Step>
+</Steps>
+
+---
+
+## Weitere Beispiele
+
+Das Verzeichnis [`examples/`](https://github.com/failproofai/failproofai/tree/main/examples) im Repository enthält:
+
+| Datei | Inhalt |
+|------|---------------|
+| `policies-basic.js` | Einstiegsrichtlinien – Schreibzugriffe auf Produktion, Force-Push und weitergeleitete Skripte blockieren |
+| `policies-notification.js` | Slack-Benachrichtigungen bei Leerlauf-Meldungen und Sitzungsende |
+| `policies-advanced/index.js` | Transitive Imports, asynchrone Hooks, PostToolUse-Ausgabebereinigung, Stop-Ereignisbehandlung |

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

@@ -0,0 +1,38 @@
+---
+title: "Für Agenten"
+description: "Failproof AI-Wissen in einem Befehl zu deinem Coding-Agenten hinzufügen. Funktioniert mit Claude Code, Cursor, Windsurf und mehr."
+---
+
+Füge die vollständige Failproof AI-Referenz in einem Befehl zu deinem Coding-Agenten hinzu. Funktioniert mit Claude Code, Cursor, Windsurf und jedem anderen Agenten, der Skills unterstützt.
+
+```bash
+npx skills add https://docs.befailproof.ai
+```
+
+`npx skills` erkennt automatisch, welche Agenten du installiert hast, und fügt den Skill im jeweils passenden Format hinzu.
+
+## Was der Skill abdeckt
+
+| Bereich | Inhalt |
+|---------|--------|
+| Policies | Integrierte Policy-Namen, Event-Typen, Parameter, aktivieren/deaktivieren |
+| Custom policies | `customPolicies.add()`, Match-Filter, `allow`/`deny`/`instruct`-API |
+| Context-Objekt | `ctx.eventType`, `ctx.toolName`, `ctx.toolInput`, `ctx.session` |
+| Konfiguration | `policies-config.json`-Struktur, Scope-Zusammenführung, `policyParams` |
+| CLI | `failproofai policies --install`, `--uninstall`, `--custom`, Scopes |
+| Dashboard | Session-Viewer, Policy-Aktivität, Umgebungsvariablen |
+| Architektur | Hook-Handler-Flow, Exit-Codes, stdin/stdout-Vertrag |
+
+## Ist der Skill vollständig?
+
+Mintlify generiert `llms.txt` aus allen Seiten der Navigation. Die Failproof AI-Dokumentation deckt die vollständige API ab – jede Policy, Option und jedes Beispiel ist enthalten. Falls dir etwas fehlt, findest du die Quelle unter `https://docs.befailproof.ai/llms-full.txt`.
+
+Für gezielten Kontext kannst du direkt auf eine bestimmte Seite verlinken:
+
+```bash
+# Nur die Custom-Policies-API
+npx skills add https://docs.befailproof.ai/custom-policies
+
+# Nur die integrierten Policies
+npx skills add https://docs.befailproof.ai/built-in-policies
+```