failproofai 0.0.6-beta.2 → 0.0.6-beta.4

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

@@ -1,307 +0,0 @@
----
-title: Beispiele
-description: "So richten Sie Hooks für Claude Code und das Agents SDK ein"
-icon: book-open
----
-
-Sofort verwendbare Beispiele für häufige Szenarien. 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 Sie `failproofai policies --install` ausführen, registriert es Hook-Befehle in der `settings.json` von Claude Code, 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 jetzt automatisch bei jedem Tool-Aufruf ausgeführt. Bitten Sie Claude, `sudo rm -rf /` auszuführen – es 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 programmatisch 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 ausgelöst wie in Claude Code – ü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 Anmeldeinformationen in der Tool-Ausgabe sehen oder weitergeben.
-
-```bash
-failproofai policies --install sanitize-api-keys sanitize-jwt sanitize-connection-strings sanitize-bearer-tokens
-```
-
-Diese 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 Benachrichtigungs-Hook, um Leerlauf-Warnungen 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 auf 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 voraussetzen
-
-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:
-
-```bash
-git add .failproofai/policies-config.json
-git commit -m "Add failproofai team policies"
-```
-
-Jedes Teammitglied, das failproofai installiert hat, übernimmt diese Regeln automatisch.
-
----
-
-## Einen organisationsweiten Qualitätsstandard mit Convention-Richtlinien aufbauen
-
-Das wirkungsvollste Setup: Committen Sie `.failproofai/policies/` in Ihr Repository mit auf Ihr Projekt zugeschnittenen Richtlinien. Jedes Teammitglied erhält sie automatisch – keine Installationsbefehle, keine 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";
-
-    // Bevorzugten Paketmanager Ihres Teams durchsetzen
-    // (oder stattdessen die integrierte prefer-package-manager-Richtlinie aktivieren)
-    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();
-      },
-    });
-
-    // Den Agenten daran erinnern, vor dem Committen Tests auszuführen
-    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 committen">
-    ```bash
-    git add .failproofai/policies/
-    git commit -m "Add team quality policies"
-    ```
-  </Step>
-  <Step title="Kontinuierlich verbessern">
-    Wenn Ihr Team auf neue Fehlerquellen stößt, fügen Sie Richtlinien hinzu und pushen Sie. Jeder erhält die Aktualisierung beim nächsten `git pull`. Diese Richtlinien werden zu einem lebendigen Qualitätsstandard, der mit Ihrem Team wächst.
-  </Step>
-</Steps>
-
----
-
-## Weitere Beispiele
-
-Das Verzeichnis [`examples/`](https://github.com/exospherehost/failproofai/tree/main/examples) im Repository enthält:
-
-| Datei | Was es zeigt |
-|-------|--------------|
-| `policies-basic.js` | Einstiegsrichtlinien – Schreibzugriffe auf Produktion, Force-Push und Piped-Skripte blockieren |
-| `policies-notification.js` | Slack-Benachrichtigungen für Leerlauf-Meldungen und Sitzungsende |
-| `policies-advanced/index.js` | Transitive Imports, asynchrone Hooks, PostToolUse-Ausgabebereinigung, Stop-Event-Behandlung |

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

@@ -1,38 +0,0 @@
----
-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

@@ -1,186 +0,0 @@
----
-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 – nur für das Erstellen aus dem Quellcode erforderlich)
-
----
-
-## 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 Werkzeugaufruf eines Agenten ausgeführt werden. Sie erkennen destruktive Befehle, das Durchsickern von Geheimnissen und andere Fehlerquellen, bevor Schaden entsteht.
-
-    ```bash
-    failproofai policies --install
-    ```
-
-    Dadurch werden Hook-Einträge in die `settings.json` von Claude Code geschrieben. Sie können auch für ein einzelnes Projekt installieren oder bestimmte Policies auswählen:
-
-    ```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 starten">
-    ```bash
-    failproofai
-    ```
-
-    Öffnet ein lokales Dashboard unter `http://localhost:8020`, in dem Sie Sitzungen durchsuchen, Werkzeugaufrufe untersuchen und Policies verwalten können.
-  </Step>
-  <Step title="Agenten ausführen">
-    Starten Sie Claude Code wie gewohnt. Wenn der Agent etwas Riskantes versucht, greift failproofai automatisch ein. Lassen Sie ihn unbeaufsichtigt laufen und überprüfen Sie anschließend im Dashboard, was passiert ist.
-  </Step>
-</Steps>
-
----
-
-## Wie Policies funktionieren
-
-Jedes Mal, wenn ein Agent ein Werkzeug ausführt, ruft Claude Code failproofai als Subprozess 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 und dem Agenten wird der Grund mitgeteilt
-- **instruct** – dem Prompt des Agenten werden zusätzliche Informationen hinzugefügt
-
-<Note>
-Policies laufen in Ihrem lokalen Prozess. Es werden keine Daten an einen externen Dienst übertragen.
-</Note>
-
----
-
-## Team-Policies mit konventionsbasierten Policies einrichten
-
-Der schnellste Weg, Qualitätsstandards im gesamten Team zu etablieren, ist die `.failproofai/policies/`-Konvention. Legen Sie Policy-Dateien in dieses Verzeichnis ab und sie werden automatisch geladen – ohne Flags, ohne Konfigurationsänderungen, ohne Installationsbefehle.
-
-<Steps>
-  <Step title="Policies-Verzeichnis erstellen">
-    ```bash
-    mkdir -p .failproofai/policies
-    ```
-  </Step>
-  <Step title="Policy-Dateien hinzufügen">
-    Kopieren Sie die Starter-Beispiele oder schreiben Sie Ihre eigenen:
-
-    ```bash
-    cp node_modules/failproofai/examples/convention-policies/*.mjs .failproofai/policies/
-    ```
-
-    Oder erstellen Sie eine neue:
-
-    ```js
-    // .failproofai/policies/team-policies.mjs
-    import { customPolicies, allow, deny, instruct } from "failproofai";
-
-    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"
-    ```
-
-    Jedes Teammitglied, das failproofai installiert hat, übernimmt diese Policies automatisch. Es ist keine individuelle Einrichtung pro Entwickler erforderlich.
-  </Step>
-</Steps>
-
-<Tip>
-Checken Sie `.failproofai/policies/` in Ihr Repository ein, damit das gesamte Team dieselben Standards teilt. Sobald Ihr Team neue Fehlerquellen entdeckt, fügen Sie Policies hinzu und pushen Sie – alle erhalten die Aktualisierung beim nächsten `git pull`. Mit der Zeit werden diese Policies zu einem lebendigen Qualitätsstandard, der sich kontinuierlich verbessert.
-</Tip>
-
----
-
-## Datenspeicherung
-
-Alle Konfigurationen und Protokolle verbleiben auf Ihrem Rechner:
-
-| Pfad | Gespeicherte Inhalte |
-|------|----------------------|
-| `~/.failproofai/policies-config.json` | Globale Policy-Konfiguration |
-| `~/.failproofai/hook-activity.jsonl` | Hook-Ausführungsverlauf |
-| `~/.failproofai/hook.log` | Debug-Protokoll für benutzerdefinierte Hook-Fehler |
-| `.failproofai/policies-config.json` | Projektspezifische Konfiguration (eingecheckt) |
-| `.failproofai/policies-config.local.json` | Persönliche Überschreibungen (per gitignore ausgeschlossen) |
-
----
-
-## 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">
-  Sitzungen überwachen und Policy-Aktivität einsehen
-</Card>
-
-</CardGroup>

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

@@ -1,57 +0,0 @@
----
-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.

package/.next/standalone/docs/de/package-aliases.mdx

@@ -1,82 +0,0 @@
----
-title: Paketaliase
-description: "Registrierte Tippfehler-Präventionsaliase und wie sie funktionieren"
-icon: copy
----
-
-## Offizielles Paket
-
-Das kanonische npm-Paket ist **`failproofai`**:
-
-```bash
-npm install -g failproofai
-# oder
-bun add -g failproofai
-```
-
----
-
-## Warum wir die Aliasnamen besitzen
-
-Typosquatting ist ein verbreiteter Supply-Chain-Angriff, bei dem ein böswilliger Akteur einen Paketnamen registriert, der nur einen Tastendruck vom Namen eines bekannten Pakets entfernt ist. Ahnungslose Nutzer, die beim Installationsbefehl einen Tippfehler machen, führen am Ende Code eines Angreifers mit vollem Systemzugriff aus – genau die Art von Bedrohung, gegen die Failproof AI entwickelt wurde.
-
-Um diese Angriffsfläche zu eliminieren, **besitzen wir vorsorglich alle häufigen Falschschreibweisen und Formatierungsvarianten** von `failproofai` auf npm. Keiner dieser Namen kann von Dritten registriert werden. Jeder ist ein schlanker Proxy, der das echte `failproofai`-Paket installiert und an dieses delegiert.
-
----
-
-## Registrierte Aliase
-
-**Formatierungsvarianten** – verschiedene Schreibweisen von „failproof ai":
-
-| Paket | Status |
-|-------|--------|
-| `failproof` | ✅ Veröffentlicht |
-| `failproof-ai` | ⏳ Ausstehend (npm-Freigabe) |
-| `fail-proof-ai` | ⏳ Ausstehend (npm-Freigabe) |
-| `failproof_ai` | ⏳ Ausstehend (npm-Freigabe) |
-| `fail_proof_ai` | ⏳ Ausstehend (npm-Freigabe) |
-| `fail-proofai` | ⏳ Ausstehend (npm-Freigabe) |
-
-**`failprof*`-Tippfehler** – ein „o" fehlt in „proof":
-
-| Paket | Status |
-|-------|--------|
-| `failprof` | ✅ Veröffentlicht |
-| `failprof-ai` | ✅ Veröffentlicht |
-| `failprofai` | ⏳ Ausstehend (npm-Freigabe) |
-| `fail-prof-ai` | ⏳ Ausstehend (npm-Freigabe) |
-| `failprof_ai` | ⏳ Ausstehend (npm-Freigabe) |
-
-**`faliproof*`-Tippfehler** – vertauschtes „a" und „i":
-
-| Paket | Status |
-|-------|--------|
-| `faliproof` | ✅ Veröffentlicht |
-| `faliproof-ai` | ✅ Veröffentlicht |
-| `faliproofai` | ⏳ Ausstehend (npm-Freigabe) |
-
-> **Warum ausstehend?** Die Spam-Präventionsrichtlinie von npm blockiert Namen, die nach dem Entfernen von Satzzeichen und Ähnlichkeitsprüfungen auf dieselbe Zeichenkette wie ein bestehendes Paket normalisiert werden. Wir haben den npm-Support kontaktiert, um diese Namen für Anti-Squatting-Zwecke zu reservieren. Sie werden aktiviert, sobald sie genehmigt sind.
-
-Sie können überprüfen, ob ein veröffentlichter Alias uns gehört:
-
-```bash
-npm info failproof
-# Achten Sie auf: "ExosphereHost Inc." im Feld maintainers
-```
-
----
-
-## Wie die Aliase funktionieren
-
-Jedes Aliaspaket:
-
-1. Listet `failproofai` als Abhängigkeit auf – sodass das echte Paket (einschließlich seiner `postinstall`-Hook-Einrichtung) bei der Installation ausgeführt wird
-2. Stellt eine ausführbare Datei bereit, die dem eigenen Namen entspricht (z. B. `failprof-ai`) und alle Argumente an die `failproofai`-Binärdatei weiterleitet
-
-Der Proxy ist ein zweizeiliges Node-Skript; es enthält keine Logik, keine Netzwerkaufrufe und keine Datenerfassung über das hinaus, was `failproofai` selbst tut.
-
----
-
-## Falls Sie einen Namen finden, den wir vergessen haben
-
-Öffnen Sie ein Issue unter [exospherehost/failproofai](https://github.com/exospherehost/failproofai/issues) und wir werden ihn registrieren.