failproofai 0.0.2 → 0.0.3

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

@@ -0,0 +1,142 @@
+---
+title: Dashboard
+description: "Agent-Sitzungen überwachen, Tool-Aufrufe einsehen und Richtlinien verwalten"
+icon: chart-line
+---
+
+Das failproofai Dashboard ist eine lokale Webanwendung zur Überwachung deiner KI-Agent-Sitzungen und zur Verwaltung von Richtlinien. Sieh nach, was deine Agents in deiner Abwesenheit gemacht haben.
+
+---
+
+## Dashboard starten
+
+```bash
+failproofai
+```
+
+Öffnet sich unter `http://localhost:8020`.
+
+Das Dashboard liest direkt aus dem Dateisystem – aus deinen Claude Code Projektordnern und den failproofai Konfigurationsdateien. Es werden keine Daten an einen externen Dienst übertragen.
+
+---
+
+## Seiten
+
+### Projekte
+
+Listet alle Claude Code Projekte auf, die auf deinem Rechner gefunden wurden. Projekte werden aus `~/.claude/projects/` (oder dem über `CLAUDE_PROJECTS_PATH` festgelegten Pfad) eingelesen.
+
+Jedes Projekt zeigt:
+- Projektname (abgeleitet vom Ordnerpfad)
+- Anzahl der Sitzungen
+- Datum der letzten Sitzungsaktivität
+
+Klicke auf ein Projekt, um dessen 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)
+
+Verwende den Datumsbereichsfilter und die Sitzungs-ID-Suche, um die Liste einzugrenzen. Sitzungen werden seitenweise angezeigt.
+
+Klicke auf eine Sitzung, um den Sitzungs-Viewer zu öffnen.
+
+### Sitzungs-Viewer
+
+Der Sitzungs-Viewer beantwortet die zentrale Frage bei autonomen Agents: Was hat der Agent getan, und ist er auf Kurs geblieben? Er zeigt eine Zeitleiste aller Ereignisse einer Sitzung:
+
+- **Nachrichten** – Claudes Textantworten und Benutzeranfragen
+- **Tool-Aufrufe** – Jeder von Claude aufgerufene Tool, mit Eingabe 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, Gesamtanzahl der Tool-Aufrufe sowie eine Zusammenfassung der Hook-Entscheidungen (Anzahl allow / deny / instruct).
+
+Du kannst die Sitzung über den Download-Button als ZIP- oder JSONL-Datei exportieren.
+
+### Richtlinien
+
+Eine Seite mit zwei Tabs zur Verwaltung von Richtlinien und zur Einsicht in Aktivitäten.
+
+<Tabs>
+  <Tab title="Policies tab">
+  - Einzelne Richtlinien per Klick aktivieren oder deaktivieren (schreibt in `~/.failproofai/policies-config.json`)
+  - Eine Richtlinie aufklappen, um ihre Parameter zu konfigurieren (für Richtlinien, die `policyParams` unterstützen)
+  - Hooks für einen bestimmten Scope installieren oder entfernen
+  - Einen benutzerdefinierten Pfad für die Richtliniendatei festlegen
+  </Tab>
+  <Tab title="Activity tab">
+  - Vollständige, seitenweise Historie aller Hook-Ereignisse, die sitzungsübergreifend ausgelöst wurden
+  - Suche nach Richtlinienname, Sitzungs-ID, Tool-Name oder Entscheidung
+  - Jede Zeile zeigt: Zeitstempel, Richtlinienname, Entscheidung, Tool-Name, Sitzungs-ID und den Grund für deny/instruct-Entscheidungen
+  </Tab>
+</Tabs>
+
+---
+
+## Automatische Aktualisierung
+
+Das Dashboard verfügt über einen Auto-Refresh-Schalter 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 langläufiger autonomer Agent-Sitzungen.
+
+---
+
+## Seiten deaktivieren
+
+Wenn du nur bestimmte Teile des Dashboards benötigst, setze `FAILPROOFAI_DISABLE_PAGES` auf eine kommagetrennte Liste von Seitennamen:
+
+```bash
+FAILPROOFAI_DISABLE_PAGES=policies failproofai
+```
+
+Gültige Werte: `policies`, `projects`.
+
+---
+
+## Design
+
+Das Dashboard unterstützt hellen und dunklen Modus. Umschalten über den Button in der Navigationsleiste. Die Einstellung wird im lokalen Speicher deines Browsers gespeichert.
+
+---
+
+## Projektpfad konfigurieren
+
+Standardmäßig liest das Dashboard aus dem Standard-Claude Code Projektverzeichnis. Für individuelle Setups lässt sich dieser Pfad überschreiben:
+
+```bash
+CLAUDE_PROJECTS_PATH=/custom/path/to/projects failproofai
+```
+
+---
+
+## Zugriff von einem Nicht-localhost-Host
+
+Wenn du das Dashboard im **Dev-Modus** (`npm run dev`) ausführst und von einem anderen Hostnamen als `localhost` darauf zugreifst – beispielsweise einer benutzerdefinierten Domain, einer Remote-IP oder einer getunnelten URL – kann folgende Warnung erscheinen:
+
+```text
+⚠ Blocked cross-origin request to Next.js dev resource /_next/webpack-hmr from "dashboard.example.com".
+```
+
+Dabei blockiert Next.js den Cross-Origin-Zugriff auf seinen HMR-Websocket (Hot Module Reload), was ein ausschließlich im Dev-Modus vorhandenes Feature ist. Um deinen Host zuzulassen, verwende das Flag `--allowed-origins`:
+
+```bash
+npm run dev -- --allowed-origins dashboard.example.com
+```
+
+Für mehrere Hosts oder IPs wird eine kommagetrennte Liste übergeben:
+
+```bash
+npm run dev -- --allowed-origins dashboard.example.com,192.168.1.5
+```
+
+Alternativ kann die Umgebungsvariable `FAILPROOFAI_ALLOWED_DEV_ORIGINS` gesetzt werden:
+
+```bash
+FAILPROOFAI_ALLOWED_DEV_ORIGINS=dashboard.example.com npm run dev
+```
+
+<Note>
+Dies gilt ausschließlich für den Dev-Modus. Beim Ausführen von `failproofai` (Produktionsmodus) gibt es keinen HMR-Websocket und kein Cross-Origin-Problem mit Dev-Ressourcen.
+</Note>

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

@@ -0,0 +1,253 @@
+---
+title: Beispiele
+description: "So richten Sie Hooks für Claude Code und das Agents SDK ein"
+icon: book-open
+---
+
+Sofort einsatzbereite Beispiele für häufige Szenarien. Jedes zeigt, wie die Installation funktioniert 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 Sie `failproofai policies --install` ausführen, 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="Überprüfen, ob Hooks registriert sind">
+    ```bash
+    cat ~/.claude/settings.json | grep failproofai
+    ```
+
+    Sie sollten Hook-Einträge für `PreToolUse`-, `PostToolUse`-, `Notification`- und `Stop`-Ereignisse sehen.
+  </Step>
+  <Step title="Claude Code starten">
+    ```bash
+    claude
+    ```
+
+    Richtlinien werden nun automatisch bei jedem Tool-Aufruf ausgeführt. Versuchen Sie, Claude aufzufordern, `sudo rm -rf /` auszuführen – der Befehl wird blockiert.
+  </Step>
+</Steps>
+
+---
+
+## Hooks für das Agents SDK einrichten
+
+Wenn Sie mit dem [Agents SDK](https://docs.anthropic.com/en/docs/agents-sdk) entwickeln, können Sie dasselbe Hook-System programmgesteuert verwenden.
+
+<Steps>
+  <Step title="failproofai in Ihrem Projekt installieren">
+    ```bash
+    npm install failproofai
+    ```
+  </Step>
+  <Step title="Hooks in Ihrem Agenten konfigurieren">
+    Übergeben Sie Hook-Befehle beim Erstellen Ihres Agentenprozesses. Die Hooks werden genauso 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 Ihren 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 dies 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
+
+---
+
+## Geheimnis-Leaks verhindern
+
+Verhindert, dass Agenten Anmeldedaten 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 benötigen
+
+Verwenden Sie 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();
+  },
+});
+```
+
+Installation:
+
+```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 verlangen
+
+Erinnert Agenten daran, vor dem Committen Tests 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
+
+Committen Sie eine projektbezogene Konfiguration, damit alle Entwickler in Ihrem Team dieselben Richtlinien erhalten.
+
+Erstellen Sie `.failproofai/policies-config.json` in Ihrem 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 committen Sie die Datei:
+
+```bash
+git add .failproofai/policies-config.json
+git commit -m "Add failproofai team policies"
+```
+
+Jedes Teammitglied, das failproofai installiert hat, übernimmt diese Regeln automatisch.
+
+---
+
+## Weitere Beispiele
+
+Das Verzeichnis [`examples/`](https://github.com/exospherehost/failproofai/tree/main/examples) im Repository enthält:
+
+| Datei | Inhalt |
+|-------|--------|
+| `policies-basic.js` | Grundlegende Richtlinien – blockiert Schreibzugriffe auf Produktion, Force-Push und weitergeleitete Skripte |
+| `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/de/for-agents.mdx

@@ -0,0 +1,38 @@
+---
+title: "Für Agents"
+description: "Füge Failproof AI-Wissen in einem Befehl zu deinem Coding-Agent hinzu. Funktioniert mit Claude Code, Cursor, Windsurf und mehr."
+---
+
+Füge die vollständige Failproof AI-Referenz in einem einzigen Befehl zu deinem Coding-Agent hinzu. Funktioniert mit Claude Code, Cursor, Windsurf und jedem anderen Agent, der Skills unterstützt.
+
+```bash
+npx skills add https://docs.befailproof.ai
+```
+
+`npx skills` erkennt automatisch, welche Agents du installiert hast, und fügt den Skill im richtigen Format für jeden Agent 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-Ablauf, 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 gesamte API ab – jede Policy, jede Option und jedes Beispiel ist enthalten. Falls du etwas vermisst, 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
+```

package/.next/standalone/docs/de/getting-started.mdx

@@ -0,0 +1,134 @@
+---
+title: Erste Schritte
+description: "failproofai installieren, Policies aktivieren und Agenten zuverlässig ausführen"
+icon: rocket
+---
+
+## Voraussetzungen
+
+- **Node.js** >= 20.9.0
+- **Bun** >= 1.3.0 (optional – wird nur beim Erstellen aus dem Quellcode benötigt)
+
+---
+
+## Installation
+
+<CodeGroup>
+
+```bash npm
+npm install -g failproofai
+```
+
+```bash bun
+bun add -g failproofai
+```
+
+</CodeGroup>
+
+---
+
+## Schnellstart
+
+<Steps>
+  <Step title="Policies aktivieren">
+    Policies sind Regeln, die vor und nach jedem Tool-Aufruf eines Agenten ausgeführt werden. Sie erkennen destruktive Befehle, den Abfluss von Geheimnissen und andere Fehlerquellen, bevor diese Schaden anrichten können.
+
+    ```bash
+    failproofai policies --install
+    ```
+
+    Dadurch werden Hook-Einträge in die `settings.json` von Claude Code geschrieben. Die Installation kann auch auf ein einzelnes Projekt beschränkt oder auf bestimmte Policies begrenzt werden:
+
+    ```bash
+    failproofai policies --install --scope project
+    failproofai policies --install block-sudo block-rm-rf sanitize-api-keys
+    ```
+  </Step>
+  <Step title="Überprüfen">
+    ```bash
+    failproofai policies
+    ```
+
+    Zeigt alle Policies an, ob sie aktiviert sind und welche Parameter konfiguriert wurden.
+  </Step>
+  <Step title="Dashboard öffnen">
+    ```bash
+    failproofai
+    ```
+
+    Öffnet ein lokales Dashboard unter `http://localhost:8020`, in dem Sessions durchsucht, Tool-Aufrufe inspiziert und Policies verwaltet werden können.
+  </Step>
+  <Step title="Agenten starten">
+    Claude Code wie gewohnt starten. Wenn der Agent etwas Riskantes versucht, greift failproofai automatisch ein. Der Agent kann unbeaufsichtigt laufen gelassen werden – im Dashboard lässt sich anschließend nachvollziehen, was passiert ist.
+  </Step>
+</Steps>
+
+---
+
+## So funktionieren Policies
+
+Jedes Mal, wenn ein Agent ein Tool ausführt, ruft Claude Code failproofai als Unterprozess auf:
+
+```text
+Claude Code  →  failproofai --hook PreToolUse  →  reads stdin JSON
+                                                 evaluates policies
+                                                 writes decision to stdout
+```
+
+Jede Policy gibt eine von drei Entscheidungen zurück:
+
+- **allow** – der Agent fährt normal fort
+- **deny** – die Aktion wird blockiert, der Agent wird über den Grund informiert
+- **instruct** – dem Prompt des Agenten wird zusätzlicher Kontext hinzugefügt
+
+<Note>
+Policies laufen im lokalen Prozess. Es werden keine Daten an einen externen Dienst gesendet.
+</Note>
+
+---
+
+## Datenspeicherung
+
+Alle Konfigurationen und Logs verbleiben auf dem eigenen Rechner:
+
+| Pfad | Inhalt |
+|------|--------|
+| `~/.failproofai/policies-config.json` | Globale Policy-Konfiguration |
+| `~/.failproofai/hook-activity.jsonl` | Hook-Ausführungshistorie |
+| `~/.failproofai/hook.log` | Debug-Log für Fehler in benutzerdefinierten Hooks |
+| `.failproofai/policies-config.json` | Projektspezifische Konfiguration (committed) |
+| `.failproofai/policies-config.local.json` | Persönliche Überschreibungen (gitignored) |
+
+---
+
+## Deinstallation
+
+```bash
+failproofai policies --uninstall
+```
+
+Entfernt Hook-Einträge aus `~/.claude/settings.json`. Konfigurationsdateien in `~/.failproofai/` bleiben erhalten.
+
+---
+
+## Nächste Schritte
+
+<CardGroup cols={2}>
+
+<Card title="Konfiguration" icon="gear" href="/de/configuration">
+  Geltungsbereiche und Konfigurationsdateiformat
+</Card>
+
+<Card title="Integrierte Policies" icon="shield" href="/de/built-in-policies">
+  Alle 26 Policies mit Parametern
+</Card>
+
+<Card title="Benutzerdefinierte Policies" icon="code" href="/de/custom-policies">
+  Eigene Policies in JavaScript schreiben
+</Card>
+
+<Card title="Agenten-Monitor" icon="chart-line" href="/de/dashboard">
+  Sessions überwachen und Policy-Aktivitäten einsehen
+</Card>
+
+</CardGroup>

package/.next/standalone/docs/de/introduction.mdx

@@ -0,0 +1,57 @@
+---
+title: Failproof AI
+description: "Verwalte Hooks und Policies, die deine KI-Agenten zuverlässig und autonom am Laufen halten"
+---
+
+[![npm weekly downloads](https://img.shields.io/npm/dw/failproofai?style=flat-square&color=2ea44f)](https://www.npmjs.com/package/failproofai)
+
+Hooks und Policies, die deine KI-Agenten zuverlässig und autonom am Laufen halten – für **Claude Code** und das **Agents SDK**.
+
+KI-Agenten scheitern auf vorhersehbare Weise. Sie führen destruktive Befehle aus, geben Secrets preis, verlieren den Fokus, geraten in Endlosschleifen oder pushen direkt auf main. Werden solche Fehler nicht beachtet, können kleine Probleme schnell größere Schäden verursachen.
+
+Failproof AI löst dies mit **Policies** – Regeln, die bei jedem Werkzeugaufruf eines Agenten greifen und Fehler **erkennen**, **beheben** (blockieren, anweisen, bereinigen) und **dich benachrichtigen** können, wenn etwas Aufmerksamkeit erfordert. Ein lokales Dashboard ermöglicht dir die anschließende Überprüfung aller Vorgänge.
+
+Alles läuft lokal. Keine Daten verlassen deinen Rechner.
+
+## Erste Schritte
+
+<CardGroup cols={2}>
+
+<Card title="26 integrierte Policies" icon="shield" href="/de/built-in-policies">
+  Blockiere destruktive Befehle, verhindere das Durchsickern von Secrets, halte Agenten innerhalb der Projektgrenzen – und vieles mehr, direkt einsatzbereit.
+</Card>
+
+<Card title="Eigene Policies" icon="code" href="/de/custom-policies">
+  Schreibe deine eigenen Regeln in JavaScript mit einer einfachen allow / deny / instruct API.
+</Card>
+
+<Card title="Agenten-Monitor" icon="chart-line" href="/de/dashboard">
+  Sieh, was deine Agenten in deiner Abwesenheit gemacht haben. Durchsuche Sitzungen, untersuche Werkzeugaufrufe und prüfe, wo Policies ausgelöst wurden.
+</Card>
+
+<Card title="Einfache Konfiguration" icon="gear" href="/de/configuration">
+  Passe jede Policy ohne Code an. Lege Allowlists, geschützte Branches oder Schwellenwerte pro Projekt oder global fest.
+</Card>
+
+</CardGroup>
+
+## Schnellstart
+
+<CodeGroup>
+
+```bash npm
+npm install -g failproofai
+```
+
+```bash bun
+bun add -g failproofai
+```
+
+</CodeGroup>
+
+```bash
+failproofai policies --install   # Policies aktivieren
+failproofai                      # Dashboard starten
+```
+
+Eine vollständige Anleitung findest du im [Erste Schritte](/de/getting-started)-Leitfaden.