failproofai 1.0.1-beta.0 → 1.0.1

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

@@ -0,0 +1,307 @@
+---
+title: उदाहरण
+description: "Claude Code और Agents SDK के लिए hooks सेट अप कैसे करें"
+icon: book-open
+---
+
+आम परिस्थितियों के लिए तुरंत उपयोग के लिए तैयार उदाहरण। प्रत्येक दिखाता है कि कैसे इंस्टॉल करें और क्या अपेक्षा करें।
+
+---
+
+## Claude Code के लिए hooks सेट अप करना
+
+Failproof AI, Claude Code के साथ इसके [hooks सिस्टम](https://docs.anthropic.com/en/docs/claude-code/hooks) के माध्यम से एकीकृत होता है। जब आप `failproofai policies --install` चलाते हैं, तो यह Claude Code के `settings.json` में hook कमांड रजिस्टर करता है जो हर tool call पर चलते हैं।
+
+<Steps>
+  <Step title="failproofai इंस्टॉल करें">
+    ```bash
+    npm install -g failproofai
+    ```
+  </Step>
+  <Step title="सभी built-in policies सक्षम करें">
+    ```bash
+    failproofai policies --install
+    ```
+  </Step>
+  <Step title="सत्यापित करें कि hooks रजिस्टर हैं">
+    ```bash
+    cat ~/.claude/settings.json | grep failproofai
+    ```
+
+    आपको `PreToolUse`, `PostToolUse`, `Notification`, और `Stop` events के लिए hook entries दिखने चाहिए।
+  </Step>
+  <Step title="Claude Code चलाएं">
+    ```bash
+    claude
+    ```
+
+    Policies अब हर tool call पर स्वचालित रूप से चलते हैं। Claude को `sudo rm -rf /` चलाने के लिए कहने का प्रयास करें - यह ब्लॉक हो जाएगा।
+  </Step>
+</Steps>
+
+---
+
+## Agents SDK के लिए hooks सेट अप करना
+
+यदि आप [Agents SDK](https://docs.anthropic.com/en/docs/agents-sdk) के साथ बिल्ड कर रहे हैं, तो आप एक ही hook सिस्टम को प्रोग्रामेटिक रूप से उपयोग कर सकते हैं।
+
+<Steps>
+  <Step title="अपने प्रोजेक्ट में failproofai इंस्टॉल करें">
+    ```bash
+    npm install failproofai
+    ```
+  </Step>
+  <Step title="अपने agent में hooks कॉन्फ़िगर करें">
+    अपने agent process बनाते समय hook कमांड पास करें। Hooks उसी तरह चलते हैं जैसे Claude Code में - stdin/stdout JSON के माध्यम से:
+
+    ```bash
+    failproofai --hook PreToolUse   # हर tool से पहले कॉल किया जाता है
+    failproofai --hook PostToolUse  # हर tool के बाद कॉल किया जाता है
+    ```
+  </Step>
+  <Step title="अपने agent के लिए एक custom policy लिखें">
+    ```javascript
+    import { customPolicies, allow, deny } from "failproofai";
+
+    customPolicies.add({
+      name: "limit-to-project-dir",
+      description: "Agent को प्रोजेक्ट डायरेक्टरी के अंदर रखें",
+      match: { events: ["PreToolUse"] },
+      fn: async (ctx) => {
+        const path = String(ctx.toolInput?.file_path ?? "");
+        if (path.startsWith("/") && !path.startsWith(ctx.session?.cwd ?? "")) {
+          return deny("Agent प्रोजेक्ट डायरेक्टरी तक सीमित है");
+        }
+        return allow();
+      },
+    });
+    ```
+  </Step>
+  <Step title="Custom policy इंस्टॉल करें">
+    ```bash
+    failproofai policies --install --custom ./my-agent-policies.js
+    ```
+  </Step>
+</Steps>
+
+---
+
+## विनाशकारी कमांड ब्लॉक करें
+
+सबसे आम सेटअप - agents को अपरिवर्तनीय नुकसान करने से रोकें।
+
+```bash
+failproofai policies --install block-sudo block-rm-rf block-force-push block-curl-pipe-sh
+```
+
+यह क्या करता है:
+- `block-sudo` - सभी `sudo` कमांड ब्लॉक करता है
+- `block-rm-rf` - recursive file deletion ब्लॉक करता है
+- `block-force-push` - `git push --force` ब्लॉक करता है
+- `block-curl-pipe-sh` - रिमोट scripts को shell में पाइप करना ब्लॉक करता है
+
+---
+
+## Secret leakage रोकें
+
+Agents को tool output में credentials देखने या leak करने से रोकें।
+
+```bash
+failproofai policies --install sanitize-api-keys sanitize-jwt sanitize-connection-strings sanitize-bearer-tokens
+```
+
+ये `PostToolUse` पर चलते हैं - एक tool चलने के बाद, ये agent को दिखाने से पहले output को साफ करते हैं।
+
+---
+
+## Agents को Slack alerts भेजें जब उन्हें ध्यान की जरूरत हो
+
+Slack को idle alerts भेजने के लिए notification hook का उपयोग करें।
+
+```javascript
+import { customPolicies, allow, instruct } from "failproofai";
+
+customPolicies.add({
+  name: "slack-on-idle",
+  description: "Agent के इनपुट की प्रतीक्षा के समय Slack को alert भेजें",
+  match: { events: ["Notification"] },
+  fn: async (ctx) => {
+    const webhookUrl = process.env.SLACK_WEBHOOK_URL;
+    if (!webhookUrl) return allow();
+
+    const message = String(ctx.payload?.message ?? "Agent इनपुट की प्रतीक्षा कर रहा है");
+    const project = ctx.session?.cwd ?? "अज्ञात";
+
+    try {
+      await fetch(webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          text: `*${message}*\nProject: \`${project}\``,
+        }),
+        signal: AbortSignal.timeout(5000),
+      });
+    } catch {
+      // अगर Slack तक पहुंच नहीं है तो agent को कभी ब्लॉक न करें
+    }
+
+    return allow();
+  },
+});
+```
+
+इसे इंस्टॉल करें:
+
+```bash
+SLACK_WEBHOOK_URL=https://hooks.slack.com/... failproofai policies --install --custom ./slack-alerts.js
+```
+
+---
+
+## Agents को एक branch पर रखें
+
+Agents को branches switch करने या protected ones को push करने से रोकें।
+
+```javascript
+import { customPolicies, allow, deny } from "failproofai";
+
+customPolicies.add({
+  name: "stay-on-branch",
+  description: "Agent को दूसरी branches checkout करने से रोकें",
+  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("मौजूदा branch पर रहें। यदि आवश्यक हो तो -b के साथ एक नई branch बनाएं।");
+    }
+    return allow();
+  },
+});
+```
+
+---
+
+## Commits से पहले tests की आवश्यकता करें
+
+Agents को committing से पहले tests चलाने के लिए याद दिलाएं।
+
+```javascript
+import { customPolicies, allow, instruct } from "failproofai";
+
+customPolicies.add({
+  name: "test-before-commit",
+  description: "Agent को committing से पहले tests चलाने के लिए याद दिलाएं",
+  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("Committing से पहले tests चलाएं। पहले `npm test` या `bun test` का उपयोग करें।");
+    }
+    return allow();
+  },
+});
+```
+
+---
+
+## एक production repo को lock down करें
+
+एक project-level config commit करें ताकि आपकी टीम के हर developer को same policies मिलें।
+
+अपने repo में `.failproofai/policies-config.json` बनाएं:
+
+```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"]
+    }
+  }
+}
+```
+
+फिर इसे commit करें:
+
+```bash
+git add .failproofai/policies-config.json
+git commit -m "Add failproofai team policies"
+```
+
+हर team member जिसके पास failproofai installed है, ये rules स्वचालित रूप से pick up करेंगे।
+
+---
+
+## Convention policies के साथ एक org-wide quality standard बनाएं
+
+सबसे प्रभावी सेटअप: अपने repo में `.failproofai/policies/` commit करें जिसमें आपके प्रोजेक्ट के लिए tailored policies हों। हर team member को ये स्वचालित रूप से मिलते हैं — कोई install commands नहीं, कोई config changes नहीं।
+
+<Steps>
+  <Step title="डायरेक्टरी बनाएं और policies जोड़ें">
+    ```bash
+    mkdir -p .failproofai/policies
+    ```
+
+    ```js
+    // .failproofai/policies/team-policies.mjs
+    import { customPolicies, allow, deny, instruct } from "failproofai";
+
+    // अपनी टीम के preferred package manager को लागू करें
+    // (या इसके बजाय built-in prefer-package-manager policy सक्षम करें)
+    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("npm की जगह bun का उपयोग करें।");
+        return allow();
+      },
+    });
+
+    // Agent को committing से पहले tests चलाने के लिए याद दिलाएं
+    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("Committing से पहले tests चलाएं।");
+        }
+        return allow();
+      },
+    });
+    ```
+  </Step>
+  <Step title="Git को commit करें">
+    ```bash
+    git add .failproofai/policies/
+    git commit -m "Add team quality policies"
+    ```
+  </Step>
+  <Step title="सुधार करते रहें">
+    जैसे-जैसे आपकी टीम नई failure modes को हिट करती है, policies जोड़ें और push करें। हर कोई अपने अगले `git pull` पर update पाता है। ये policies एक living quality standard बन जाती हैं जो आपकी टीम के साथ बढ़ती हैं।
+  </Step>
+</Steps>
+
+---
+
+## अधिक उदाहरण
+
+Repo में [`examples/`](https://github.com/failproofai/failproofai/tree/main/examples) डायरेक्टरी में शामिल है:
+
+| फाइल | यह क्या दिखाता है |
+|------|---------------|
+| `policies-basic.js` | Starter policies - production writes, force-push, piped scripts ब्लॉक करें |
+| `policies-notification.js` | Idle notifications और session end के लिए Slack alerts |
+| `policies-advanced/index.js` | Transitive imports, async hooks, PostToolUse output scrubbing, Stop event handling |

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

@@ -0,0 +1,38 @@
+---
+title: "एजेंटों के लिए"
+description: "एक कमांड में अपने कोडिंग एजेंट को Failproof AI ज्ञान जोड़ें। Claude Code, Cursor, Windsurf और अधिक के साथ काम करता है।"
+---
+
+एक कमांड में अपने कोडिंग एजेंट को पूरा Failproof AI संदर्भ जोड़ें। Claude Code, Cursor, Windsurf और किसी भी अन्य एजेंट के साथ काम करता है जो कौशल का समर्थन करता है।
+
+```bash
+npx skills add https://docs.befailproof.ai
+```
+
+`npx skills` पता लगाता है कि आपके पास कौन से एजेंट स्थापित हैं और प्रत्येक के लिए कौशल को सही प्रारूप में स्वचालित रूप से जोड़ता है।
+
+## कौशल क्या कवर करता है
+
+| क्षेत्र | क्या शामिल है |
+|------|----------------|
+| नीतियां | बिल्ट-इन नीति नाम, इवेंट प्रकार, पैरामीटर, सक्षम/अक्षम करें |
+| कस्टम नीतियां | `customPolicies.add()`, मैच फ़िल्टर, `allow`/`deny`/`instruct` API |
+| Context ऑब्जेक्ट | `ctx.eventType`, `ctx.toolName`, `ctx.toolInput`, `ctx.session` |
+| कॉन्फ़िगरेशन | `policies-config.json` संरचना, स्कोप मर्जिंग, `policyParams` |
+| CLI | `failproofai policies --install`, `--uninstall`, `--custom`, स्कोप |
+| डैशबोर्ड | सेशन व्यूअर, नीति गतिविधि, पर्यावरण चर |
+| आर्किटेक्चर | हुक हैंडलर प्रवाह, एक्जिट कोड, stdin/stdout अनुबंध |
+
+## क्या कौशल पूर्ण है?
+
+Mintlify नेविगेशन के सभी पृष्ठों से `llms.txt` जेनरेट करता है। Failproof AI दस्तावेज़ पूरा API कवर करते हैं - हर नीति, विकल्प और उदाहरण शामिल है। यदि आपको कुछ गायब मिले, तो स्रोत `https://docs.befailproof.ai/llms-full.txt` पर है।
+
+लक्षित संदर्भ के लिए, सीधे एक विशिष्ट पृष्ठ से लिंक करें:
+
+```bash
+# केवल कस्टम नीतियां API
+npx skills add https://docs.befailproof.ai/custom-policies
+
+# केवल बिल्ट-इन नीतियां
+npx skills add https://docs.befailproof.ai/built-in-policies
+```

package/.next/standalone/docs-old/hi/getting-started.mdx

@@ -0,0 +1,200 @@
+---
+---
+title: शुरुआत करना
+description: "failproofai इंस्टॉल करें, policies को सक्षम करें, और अपने agents को विश्वसनीयता से चलाएं"
+icon: rocket
+---
+
+## आवश्यकताएं
+
+- **Node.js** >= 20.9.0
+- **Bun** >= 1.3.0 (वैकल्पिक - केवल स्रोत से बनाने के लिए आवश्यक)
+
+---
+
+## इंस्टॉलेशन
+
+<CodeGroup>
+
+```bash npm
+npm install -g failproofai
+```
+
+```bash bun
+bun add -g failproofai
+```
+
+</CodeGroup>
+
+---
+
+## त्वरित शुरुआत
+
+<Steps>
+  <Step title="Policies को सक्षम करें">
+    Policies ऐसे नियम हैं जो प्रत्येक agent tool call से पहले और बाद में चलते हैं। वे विनाशकारी कमांड, secret leakage, और अन्य विफलता मोड को पकड़ते हैं इससे पहले कि वे नुकसान पहुंचाएं।
+
+    ```bash
+    failproofai policies --install
+    ```
+
+    यह आपके इंस्टॉल किए गए agent CLIs में hook entries लिखता है (Claude Code के `~/.claude/settings.json`, OpenAI Codex के `~/.codex/hooks.json`, GitHub Copilot CLI के `~/.copilot/hooks/failproofai.json`, Cursor Agent के `~/.cursor/hooks.json`, OpenCode के generated plugin shim को `~/.config/opencode/plugins/failproofai.mjs` पर प्लस `~/.config/opencode/opencode.json` के `plugin` array में एक रजिस्ट्रेशन entry, Pi के `~/.pi/agent/settings.json`, Hermes के `~/.hermes/config.yaml`, OpenClaw के `~/.openclaw/openclaw.json`, Factory Droid के `~/.factory/hooks.json`, Devin CLI के `~/.config/devin/config.json`, Antigravity CLI के `~/.gemini/config/hooks.json`, या Goose के auto-discovered plugin dir को `~/.agents/plugins/failproofai/hooks/hooks.json` पर)। जब एक से अधिक मौजूद हों तो आपको prompt दिया जाएगा; prompt को छोड़ने के लिए `--cli claude codex copilot cursor opencode pi hermes openclaw factory devin antigravity goose` (कोई भी subset) पास करें।
+
+    GitHub Copilot CLI, Cursor Agent, OpenCode, और Pi समर्थन **beta** में हैं — `--cli copilot`, `--cli cursor`, `--cli opencode`, या `--cli pi` के साथ इंस्टॉल करें। Hermes (hermes-agent, एक Slack/Telegram gateway) user-scope के साथ `--cli hermes` से इंस्टॉल होता है और एक **offline audit source** भी है। OpenClaw (openclaw gateway, एक self-hosted multi-channel assistant) user-scope के साथ `--cli openclaw` से इंस्टॉल होता है — enforcement इसके in-process plugin hooks के माध्यम से चलता है (`before_agent_finalize` एक real turn-end gate है, इसलिए `require-*-before-stop` builtins को enforce करते हैं) — और एक **offline audit source** भी है। Factory Droid (`droid`) `--cli factory` के साथ इंस्टॉल होता है (user + project scope) और एक **offline audit source** भी है। Devin CLI (`devin`, Cognition) `--cli devin` के साथ इंस्टॉल होता है (user + project scope) और एक **offline audit source** भी है। Antigravity CLI (`agy`) `--cli antigravity` के साथ इंस्टॉल होता है (user + project scope) और एक **offline audit source** भी है। Goose (codename goose, Block) `--cli goose` के साथ इंस्टॉल होता है (user + project scope) — installer बस एक plugin dir को `~/.agents/plugins/failproofai/` पर रखता है जो Goose auto-discovers करता है, और यह एक **offline audit source** भी है।
+
+    ```bash
+    failproofai policies --install --scope project
+    failproofai policies --install --cli codex --scope project
+    failproofai policies --install --cli copilot --scope project
+    failproofai policies --install --cli cursor --scope project
+    failproofai policies --install --cli opencode --scope project
+    failproofai policies --install --cli pi --scope project
+    failproofai policies --install --cli hermes --scope user
+    failproofai policies --install --cli openclaw --scope user
+    failproofai policies --install --cli factory --scope project
+    failproofai policies --install --cli devin --scope project
+    failproofai policies --install --cli antigravity --scope project
+    failproofai policies --install --cli goose --scope project
+    failproofai policies --install block-sudo block-rm-rf sanitize-api-keys
+    ```
+  </Step>
+  <Step title="सत्यापन करें">
+    ```bash
+    failproofai policies
+    ```
+
+    हर policy दिखाता है, चाहे वह सक्षम हो, और कोई भी configured parameters।
+  </Step>
+  <Step title="Dashboard लॉन्च करें">
+    ```bash
+    failproofai
+    ```
+
+    `http://localhost:8020` पर एक local dashboard खोलता है जहां आप sessions browse कर सकते हैं, tool calls को inspect कर सकते हैं, और policies को manage कर सकते हैं।
+  </Step>
+  <Step title="अपना agent चलाएं">
+    Claude Code को सामान्य तरीके से शुरू करें। यदि agent कुछ risky करने का प्रयास करता है, तो failproofai स्वचालित रूप से इसे intercept करता है। इसे unattended चलाते हुए छोड़ें और dashboard में देखें कि क्या हुआ।
+  </Step>
+</Steps>
+
+---
+
+## Policies कैसे काम करते हैं
+
+हर बार जब एक agent एक tool चलाता है, Claude Code failproofai को एक subprocess के रूप में कॉल करता है:
+
+```text
+Claude Code  →  failproofai --hook PreToolUse  →  stdin JSON को पढ़ता है
+                                                 policies का मूल्यांकन करता है
+                                                 stdout में decision लिखता है
+```
+
+प्रत्येक policy तीन निर्णयों में से एक को return करता है:
+
+- **allow** - agent सामान्य रूप से आगे बढ़ता है
+- **deny** - कार्रवाई blocked है, agent को कारण बताया जाता है
+- **instruct** - agent के prompt में अतिरिक्त context जोड़ा जाता है
+
+<Note>
+Policies आपकी local process में चलती हैं। कुछ भी दूरस्थ सेवा को नहीं भेजा जाता।
+</Note>
+
+---
+
+## Convention-based policies के साथ team policies सेट अप करें
+
+अपनी team में गुणवत्ता मानकों को स्थापित करने का सबसे तेज़ तरीका `.failproofai/policies/` convention है। इस निर्देशिका में policy files रखें और वे स्वचालित रूप से लोड होते हैं — कोई flags, कोई config changes, कोई install commands नहीं।
+
+<Steps>
+  <Step title="Policies निर्देशिका बनाएं">
+    ```bash
+    mkdir -p .failproofai/policies
+    ```
+  </Step>
+  <Step title="Policy files जोड़ें">
+    Starter examples को copy करें या अपने खुद के बनाएं:
+
+    ```bash
+    cp node_modules/failproofai/examples/convention-policies/*.mjs .failproofai/policies/
+    ```
+
+    या एक नया बनाएं:
+
+    ```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("Commit करने से पहले tests चलाएं।");
+        }
+        return allow();
+      },
+    });
+    ```
+  </Step>
+  <Step title="Git को commit करें">
+    ```bash
+    git add .failproofai/policies/
+    git commit -m "Add team quality policies"
+    ```
+
+    हर team member जिसके पास failproofai installed है, ये policies स्वचालित रूप से उठाता है। कोई per-developer setup की जरूरत नहीं।
+  </Step>
+</Steps>
+
+<Tip>
+`.failproofai/policies/` को अपने repo में commit करें ताकि पूरी team एक जैसे मानकों को साझा करे। जैसे ही आपकी team नई विफलता मोड की खोज करे, policies जोड़ें और push करें — हर कोई अपने अगले `git pull` पर update प्राप्त करता है। समय के साथ ये policies एक जीवंत गुणवत्ता मानक बन जाते हैं जो लगातार सुधारते रहते हैं।
+</Tip>
+
+---
+
+## डेटा स्टोरेज
+
+सभी configuration और logs आपकी machine पर रहते हैं:
+
+| Path | क्या store करता है |
+|------|----------------|
+| `~/.failproofai/policies/local-policies/policies-config.json` | Global policy config |
+| `~/.failproofai/hook-activity/` | Hook execution history (paged JSONL) |
+| `~/.failproofai/logs/` | Debug logs custom hook errors के लिए |
+| `.failproofai/policies-config.json` | Per-project config (committed) |
+| `.failproofai/policies-config.local.json` | Personal overrides (gitignored) |
+
+---
+
+## Uninstalling
+
+```bash
+failproofai policies --uninstall
+```
+
+`~/.claude/settings.json` से hook entries को हटाता है। `~/.failproofai/` में config files को रखा जाता है।
+
+---
+
+## अगले कदम
+
+<CardGroup cols={2}>
+
+<Card title="Configuration" icon="gear" href="/hi/configuration">
+  Scopes और config file format
+</Card>
+
+<Card title="Built-in policies" icon="shield" href="/hi/built-in-policies">
+  सभी 26 policies parameters के साथ
+</Card>
+
+<Card title="Custom policies" icon="code" href="/hi/custom-policies">
+  JavaScript में अपनी खुद की policies लिखें
+</Card>
+
+<Card title="Agent monitor" icon="chart-line" href="/hi/dashboard">
+  Sessions को monitor करें और policy activity को review करें
+</Card>
+
+</CardGroup>

package/.next/standalone/docs-old/hi/introduction.mdx

@@ -0,0 +1,58 @@
+---
+---
+title: "Failproof AI"
+description: "FailproofAI आपके AI agents को 39 built-in failure policies देता है जो एक ही install में loops, secret leaks, destructive tool calls और बहुत कुछ को पकड़ते हैं।"
+---
+
+[![npm weekly downloads](https://img.shields.io/npm/dw/failproofai?style=flat-square&color=2ea44f)](https://www.npmjs.com/package/failproofai)
+
+**AI failure handling**, **error recovery**, और **LLM reliability** के लिए Hooks और policies। अपने AI agents को **Claude Code**, **OpenAI Codex**, **GitHub Copilot**, **Cursor Agent**, **OpenCode**, **Pi**, **Hermes**, **OpenClaw**, **Factory Droid**, **Devin CLI**, **Antigravity CLI**, और **Agents SDK** पर विश्वसनीय और स्वायत्त रूप से चलता रहें।
+
+AI agents पूर्वानुमानित तरीकों से विफल होते हैं। वे विनाशकारी commands चलाते हैं, secrets लीक करते हैं, task से भटकते हैं, loops में फंस जाते हैं, या सीधे main में push करते हैं। अगर बिना निरीक्षण के छोड़ दिए जाएं, तो छोटी failures बड़े outages, लीक किए गए credentials और खोए हुए काम में बदल जाती हैं।
+
+FailproofAI इसे **policies** के साथ हल करता है। ये rules हर agent tool call में hook करते हैं ताकि **failures को detect** करें, **उन्हें mitigate** करें (block, instruct, sanitize), और जब कुछ attention की जरूरत हो तो **आपको alert** करें। एक local dashboard आपको afterward में हर tool call, agent failure और recovery action को review करने देता है।
+
+Transcripts और policy evaluation आपकी machine पर रहते हैं। Data सिर्फ तब भेजा जाता है जब आप explicitly किसी online feature का उपयोग करते हैं, जैसे authenticated audit reminders या invitations।
+
+## शुरुआत करें
+
+<CardGroup cols={2}>
+
+<Card title="39 built-in policies" icon="shield" href="/hi/built-in-policies">
+  विनाशकारी commands को block करें, secret leakage को रोकें, agents को project boundaries के अंदर रखें, और बहुत कुछ। सब कुछ बॉक्स से बाहर।
+</Card>
+
+<Card title="Custom policies" icon="code" href="/hi/custom-policies">
+  JavaScript में अपने खुद के rules लिखें एक simple allow / deny / instruct API के साथ।
+</Card>
+
+<Card title="Agent monitor" icon="chart-line" href="/hi/dashboard">
+  देखें कि आपके agents ने आपके दूर रहने के दौरान क्या किया। Sessions browse करें, tool calls को inspect करें, उन जगहों को review करें जहां policies fired हुई।
+</Card>
+
+<Card title="Easy configuration" icon="gear" href="/hi/configuration">
+  किसी भी policy को बिना code के tune करें। Per-project या globally allowlists, protected branches, या thresholds set करें।
+</Card>
+
+</CardGroup>
+
+## त्वरित शुरुआत
+
+<CodeGroup>
+
+```bash npm
+npm install -g failproofai
+```
+
+```bash bun
+bun add -g failproofai
+```
+
+</CodeGroup>
+
+```bash
+failproofai policies --install   # policies enable करें (या skip करें — `failproofai` पहली run पर उन्हें set करने का offer देगा)
+failproofai                      # dashboard launch करें
+```
+
+पूर्ण walkthrough के लिए [Getting started](/hi/getting-started) guide देखें।