failproofai 0.0.2 → 0.0.4-beta.0

package/.next/standalone/docs/he/cli/list-policies.mdx

@@ -0,0 +1,32 @@
+---
+---
+title: רשימת מדיניויות
+description: "ראה אילו מדיניויות מופעלות, הפרמטרים שלהן ומדיניויות מותאמות אישית"
+---
+
+```bash
+failproofai policies
+```
+
+מציג את כל המדיניויות עם המצב שלהן, הפרמטרים המוגדרים, והמדיניויות המותאמות אישית.
+
+## דוגמה לפלט
+
+```text
+Failproof AI Hook Policies (user)
+
+  Status  Name                          Description
+  ──────  ──────────────────────────────────────────────────────────────
+  ✓       block-sudo                    Block sudo commands
+            allowPatterns: ["sudo systemctl status"]
+  ✓       block-rm-rf                   Block recursive deletions
+  ✗       block-curl-pipe-sh            Block curl|bash patterns
+  ✓       sanitize-api-keys             Redact API keys from output
+            additionalPatterns: [{ regex: "MY_TOKEN_...", label: "..." }]
+
+  ── Custom Policies (/home/alice/myproject/my-policies.js) ──────────────
+  ✓       require-jira-ticket           Block commits without ticket
+  ✓       approval-gate                 Approval gate for destructive ops
+```
+
+מפתחות לא מוכרים ב-`policyParams` מסומנים כאן כדי שתוכל לתפוס שגיאות הקלדה בשלב מוקדם.

package/.next/standalone/docs/he/cli/remove-policies.mdx

@@ -0,0 +1,43 @@
+---
+title: הסרת מדיניויות
+description: "הסר רשומות hook מהגדרות Claude Code"
+---
+
+```bash
+failproofai policies --uninstall [policy-names...] [options]
+```
+
+מסיר רשומות failproofai hook מ-`settings.json` של Claude Code.
+
+כינויים: `failproofai p -u`
+
+## אפשרויות
+
+| דגל | תיאור |
+|------|-------------|
+| `--scope user` | הסר מהגדרות גלובליות (ברירת מחדל) |
+| `--scope project` | הסר מהגדרות הפרויקט |
+| `--scope local` | הסר מהגדרות מקומיות |
+| `--scope all` | הסר מכל ההיקפים בבת אחת |
+| `--custom` / `-c` | נקה את ה-`customPoliciesPath` מהתצורה |
+
+## התנהגות
+
+- **ללא שמות מדיניויות** - מסיר את כל רשומות failproofai hook מקובץ ההגדרות
+- **שמות ספציפיים** - משבית מדיניויות אלו אך שומרת hooks מותקנים
+
+## דוגמאות
+
+```bash
+# הסר את כל ה-hooks באופן גלובלי
+failproofai policies --uninstall
+
+# השבת מדיניות ספציפית (שומרת hooks מותקנים)
+failproofai policies --uninstall block-sudo
+
+# הסר hooks מכל היקף
+failproofai policies --uninstall --scope all
+
+# נקה את נתיב המדיניויות המותאמות
+failproofai policies --uninstall --custom
+```

package/.next/standalone/docs/he/cli/version.mdx

@@ -0,0 +1,12 @@
+---
+title: בדיקת גרסה
+description: "הדפסת גרסת failproofai המותקנת"
+---
+
+```bash
+failproofai --version
+# or
+failproofai -v
+```
+
+הדפס את מספר הגרסה המותקנת.

package/.next/standalone/docs/he/configuration.mdx

@@ -0,0 +1,222 @@
+---
+title: תצורה
+description: "פורמט קובץ תצורה, מערכת תחומי תצורה תלת-שכבתית וכללי מיזוג"
+icon: gear
+---
+
+failproofai משתמש בקובצי תצורה JSON כדי לשלוט אילו מדיניויות פעילות, כיצד הן מתנהגות ומאיפה נטענות מדיניויות מותאמות אישית. התצורה מעוצבת להיות קלה לשיתוף עם הצוות שלך - התחייב אותה ללאגר שלך וכל מפתח יקבל את אותה רשת הבטיחות של הסוכן.
+
+---
+
+## תחומי תצורה
+
+קיימים שלושה תחומי תצורה, מוערכים לפי סדר עדיפויות:
+
+| תחום | נתיב קובץ | מטרה |
+|-------|-----------|---------|
+| **פרויקט** | `.failproofai/policies-config.json` | הגדרות לפי מאגר, מחויבות לבקרת גרסה |
+| **מקומי** | `.failproofai/policies-config.local.json` | עדכונים אישיים למאגר, מוחרגים מ-gitignore |
+| **גלובלי** | `~/.failproofai/policies-config.json` | ברירות מחדל ברמת משתמש בכל הפרויקטים |
+
+כאשר failproofai מקבל אירוע hook, הוא טוען ומיזג את כל שלושת הקובצים הקיימים עבור ספריית העבודה הנוכחית.
+
+### כללי מיזוג
+
+**`enabledPolicies`** - איחוד של כל שלושת התחומים. מדיניות המופעלת בכל רמה פעילה.
+
+```text
+project:  ["block-sudo"]
+local:    ["block-rm-rf"]
+global:   ["block-sudo", "sanitize-api-keys"]
+
+resolved: ["block-sudo", "block-rm-rf", "sanitize-api-keys"]  ← איחוד ללא כפילויות
+```
+
+**`policyParams`** - התחום הראשון המגדיר פרמטרים עבור מדיניות מסוימת מנצח לחלוטין. אין מיזוג עמוק של ערכים בתוך פרמטרים של מדיניות.
+
+```text
+project:  block-sudo → { allowPatterns: ["sudo apt-get update"] }
+global:   block-sudo → { allowPatterns: ["sudo systemctl status"] }
+
+resolved: { allowPatterns: ["sudo apt-get update"] }   ← הפרויקט מנצח, גלובלי מתעלם
+```
+
+```text
+project:  (no block-sudo entry)
+local:    (no block-sudo entry)
+global:   block-sudo → { allowPatterns: ["sudo systemctl status"] }
+
+resolved: { allowPatterns: ["sudo systemctl status"] }  ← נופל דרך לגלובלי
+```
+
+**`customPoliciesPath`** - התחום הראשון המגדיר אותו מנצח.
+
+**`llm`** - התחום הראשון המגדיר אותו מנצח.
+
+---
+
+## פורמט קובץ התצורה
+
+```json
+{
+  "enabledPolicies": [
+    "block-sudo",
+    "block-rm-rf",
+    "block-push-master",
+    "sanitize-api-keys",
+    "sanitize-jwt",
+    "block-env-files",
+    "block-read-outside-cwd"
+  ],
+  "policyParams": {
+    "block-sudo": {
+      "allowPatterns": ["sudo systemctl status", "sudo journalctl"]
+    },
+    "block-push-master": {
+      "protectedBranches": ["main", "release", "prod"]
+    },
+    "block-rm-rf": {
+      "allowPaths": ["/tmp"]
+    },
+    "block-read-outside-cwd": {
+      "allowPaths": ["/shared/data", "/opt/company"]
+    },
+    "sanitize-api-keys": {
+      "additionalPatterns": [
+        { "regex": "myco_[A-Za-z0-9]{32}", "label": "MyCo API key" }
+      ]
+    },
+    "warn-large-file-write": {
+      "thresholdKb": 512
+    }
+  },
+  "customPoliciesPath": "/home/alice/myproject/my-policies.js"
+}
+```
+
+---
+
+## ייחוס שדות
+
+### `enabledPolicies`
+
+סוג: `string[]`
+
+רשימת שמות מדיניויות להפעלה. שמות חייבים להתאים בדיוק לזהויות המדיניויות המוצגות על ידי `failproofai policies`. ראה [Built-in Policies](/he/built-in-policies) לרשימה המלאה.
+
+מדיניויות שאינן ב-`enabledPolicies` אינן פעילות, גם אם יש להן רשומות ב-`policyParams`.
+
+### `policyParams`
+
+סוג: `Record<string, Record<string, unknown>>`
+
+עדכוני פרמטרים לפי מדיניות. המפתח החיצוני הוא שם המדיניות; המפתחות הפנימיים הם ספציפיים למדיניות. כל מדיניות מתעדת את הפרמטרים הזמינים שלה ב-[Built-in Policies](/he/built-in-policies).
+
+אם למדיניות יש פרמטרים אך אתה לא מציין אותם, משתמשים בברירות המחדל המובנות של המדיניות. משתמשים שלא מגדירים את `policyParams` בכלל מקבלים התנהגות זהה לגרסאות קודמות.
+
+מפתחות לא ידועים בתוך בלוק הפרמטרים של מדיניות מתעלמים בשתיקה בזמן hook, אך מסומנים כאזהרות כאשר אתה מריץ `failproofai policies`.
+
+#### `hint` (חוצה תחומים)
+
+סוג: `string` (אופציונלי)
+
+הודעה המצורפת לסיבה כאשר מדיניות חוזרת `deny` או `instruct`. השתמש בה כדי לתן Claude הנחיה פעולה ללא שינוי המדיניות עצמה.
+
+עובד עם כל סוג מדיניות — מובנה, מותאמת אישית (`custom/`), קונוונציה של פרויקט (`.failproofai-project/`), או קונוונציה של משתמש (`.failproofai-user/`).
+
+```json
+{
+  "policyParams": {
+    "block-force-push": {
+      "hint": "Try creating a fresh branch instead."
+    },
+    "block-sudo": {
+      "allowPatterns": ["sudo apt-get"],
+      "hint": "Use apt-get directly without sudo."
+    },
+    "custom/my-policy": {
+      "hint": "Ask the user for approval first."
+    }
+  }
+}
+```
+
+כאשר `block-force-push` דוחה, Claude רואה: *"Force-pushing is blocked. Try creating a fresh branch instead."*
+
+ערכים שאינם מחרוזות ומחרוזות ריקות מתעלמים בשתיקה. אם `hint` לא מוגדר, ההתנהגות ללא שינוי (תאימות אחורית).
+
+### `customPoliciesPath`
+
+סוג: `string` (נתיב מוחלט)
+
+נתיב לקובץ JavaScript המכיל מדיניויות hook מותאמות אישית. זה מוגדר אוטומטית על ידי `failproofai policies --install --custom <path>` (הנתיב נפתר לערך מוחלט לפני האחסון).
+
+הקובץ נטען מחדש בכל אירוע hook - אין קשמן. ראה [Custom Policies](/he/custom-policies) לפרטי יצירה.
+
+### מדיניויות המבוססות על קונוונציה (v0.0.2-beta.7+)
+
+בנוסף ל-`customPoliciesPath` המפורש, failproofai גילוי ותקבל מחדש קובצי מדיניויות מספריות `.failproofai/policies/`:
+
+| רמה | ספרייה | תחום |
+|-------|-----------|-------|
+| פרויקט | `.failproofai/policies/` | משותף עם צוות דרך בקרת גרסה |
+| משתמש | `~/.failproofai/policies/` | אישי, חל על כל הפרויקטים |
+
+**התאמת קובצים:** רק קובצים התואמים `*policies.{js,mjs,ts}` נטענים (למשל `security-policies.mjs`, `workflow-policies.js`). קובצים אחרים בספרייה מתעלמים.
+
+**אין צורך בתצורה:** מדיניויות קונוונציה אינן דורשות רשומות ב-`policies-config.json`. פשוט זרוק קובצים לספרייה והם ייבחרו באירוע ה-hook הבא.
+
+**טעינת איחוד:** שתי ספריות קונוונציה של פרויקט ומשתמש סרוקות. כל הקובצים התואמים משתי הרמות נטענות (בניגוד ל-`customPoliciesPath` המשתמש בתחום-ראשון-מנצח).
+
+ראה [Custom Policies](/he/custom-policies) לפרטים נוספים ודוגמאות.
+
+### `llm`
+
+סוג: `object` (אופציונלי)
+
+תצורת לקוח LLM עבור מדיניויות המבצעות קריאות AI. לא נדרש עבור רוב ההתקנות.
+
+```json
+{
+  "llm": {
+    "model": "claude-sonnet-4-6",
+    "apiKey": "sk-ant-..."
+  }
+}
+```
+
+---
+
+## ניהול תצורה מה-CLI
+
+הפקודות `policies --install` ו-`policies --uninstall` כותבות ל-`settings.json` של Claude Code (נקודות כניסה ה-hook), בעוד `policies-config.json` הוא הקובץ שאתה מנהל ישירות. שניים נפרדים:
+
+- **`settings.json`** - אומר ל-Claude Code להתקשר ל-`failproofai --hook <event>` בכל שימוש בכלי
+- **`policies-config.json`** - אומר ל-failproofai אילו מדיניויות להעריך ועם אילו פרמטרים
+
+אתה יכול לערוך את `policies-config.json` ישירות בכל זמן; שינויים יקבלו תוקף מיידי באירוע ה-hook הבא ללא צורך בהפעלה מחדש.
+
+---
+
+## דוגמה: תצורת רמת פרויקט עם ברירות מחדל של צוות
+
+התחייב `.failproofai/policies-config.json` ללאגר שלך:
+
+```json
+{
+  "enabledPolicies": [
+    "block-sudo",
+    "block-rm-rf",
+    "block-push-master",
+    "sanitize-api-keys",
+    "block-env-files"
+  ],
+  "policyParams": {
+    "block-push-master": {
+      "protectedBranches": ["main", "release", "hotfix"]
+    }
+  }
+}
+```
+
+כל מפתח יכול אז ליצור `.failproofai/policies-config.local.json` (מוחרג מ-gitignore) לעדכונים אישיים ללא השפעה על חברי צוות.

package/.next/standalone/docs/he/custom-policies.mdx

@@ -0,0 +1,357 @@
+---
+title: מדיניויות מותאמות
+description: "כתוב את הכללים שלך ב-JavaScript - אכוף קונבנציות, עצור drift, גלה כשלים, התחבר למערכות חיצוניות"
+icon: code
+---
+
+מדיניויות מותאמות מאפשרות לך לכתוב כללים לכל התנהגות agent: אכוף קונבנציות פרויקט, עצור drift, שער פעולות הורסות, גלה agents תקועות, או התחבר ל-Slack, תהליכי אישור, ועוד. הם משתמשים באותה מערכת hook event ובהחלטות `allow`, `deny`, `instruct` כמו מדיניויות מובנות.
+
+---
+
+## דוגמה מהירה
+
+```js
+// my-policies.js
+import { customPolicies, allow, deny, instruct } from "failproofai";
+
+customPolicies.add({
+  name: "no-production-writes",
+  description: "Block writes to paths containing 'production'",
+  match: { events: ["PreToolUse"] },
+  fn: async (ctx) => {
+    if (ctx.toolName !== "Write" && ctx.toolName !== "Edit") return allow();
+    const path = ctx.toolInput?.file_path ?? "";
+    if (path.includes("production")) {
+      return deny("Writes to production paths are blocked");
+    }
+    return allow();
+  },
+});
+```
+
+התקן אותה:
+
+```bash
+failproofai policies --install --custom ./my-policies.js
+```
+
+---
+
+## שתי דרכים לטעון מדיניויות מותאמות
+
+### אפשרות 1: מבוססת קונבנציה (מומלצת, v0.0.2-beta.7+)
+
+שים קבצים `*policies.{js,mjs,ts}` בתיקייה `.failproofai/policies/` והם יוטענו באופן אוטומטי — ללא דגלים או שינויי קונפיגורציה. זה עובד כמו git hooks: שים קובץ, זה פשוט עובד.
+
+```
+# Project level — committed to git, shared with the team
+.failproofai/policies/security-policies.mjs
+.failproofai/policies/workflow-policies.mjs
+
+# User level — personal, applies to all projects
+~/.failproofai/policies/my-policies.mjs
+```
+
+**איך זה עובד:**
+- שתי התיקיות של פרויקט ומשתמש סורקות (union — לא first-scope-wins)
+- קבצים נטענים בסדר אלפביתי בתוך כל תיקייה. קידומת עם `01-`, `02-` לשליטה בסדר
+- רק קבצים התואמים `*policies.{js,mjs,ts}` נטענים; קבצים אחרים מתעלמים
+- כל קובץ טוען באופן עצמאי (fail-open לכל קובץ)
+- עובד לצד מדיניויות `--custom` מפורשות ומובנות
+
+<Tip>
+מדיניויות קונבנציה הן הדרך הקלה ביותר לשתף מדיניויות על פני הצוות. התחייב `.failproofai/policies/` ל-git וכל חבר בצוות יקבל אותם באופן אוטומטי.
+</Tip>
+
+### אפשרות 2: נתיב קובץ מפורש
+
+```bash
+# Install with a custom policies file
+failproofai policies --install --custom ./my-policies.js
+
+# Replace the policies file path
+failproofai policies --install --custom ./new-policies.js
+
+# Remove the custom policies path from config
+failproofai policies --uninstall --custom
+```
+
+הנתיב המוחלט שנפתר מאוחסן ב-`policies-config.json` בתור `customPoliciesPath`. הקובץ נטען מחדש בכל hook event - אין cache בין events.
+
+### שימוש בשניהם ביחד
+
+מדיניויות קונבנציה והקובץ `--custom` המפורש יכולים להתקיים. סדר הטעינה:
+
+1. קובץ `customPoliciesPath` מפורש (אם מוגדר)
+2. קבצי קונבנציה של פרויקט (`{cwd}/.failproofai/policies/`, אלפביתי)
+3. קבצי קונבנציה של משתמש (`~/.failproofai/policies/`, אלפביתי)
+
+---
+
+## API
+
+### Import
+
+```js
+import { customPolicies, allow, deny, instruct } from "failproofai";
+```
+
+### `customPolicies.add(hook)`
+
+רושם מדיניות. קרא לפונקציה זו כמה פעמים שנדרש עבור מדיניויות מרובות באותו קובץ.
+
+```ts
+customPolicies.add({
+  name: string;                         // required - unique identifier
+  description?: string;                 // shown in `failproofai policies` output
+  match?: { events?: HookEventType[] }; // filter by event type; omit to match all
+  fn: (ctx: PolicyContext) => PolicyResult | Promise<PolicyResult>;
+});
+```
+
+### עוזרי החלטה
+
+| פונקציה | השפעה | השתמש כאשר |
+|----------|--------|----------|
+| `allow()` | התר את הפעולה בשקט | הפעולה בטוחה, לא נדרשת הודעה |
+| `deny(message)` | חסום את הפעולה | ל-agent אין לבצע פעולה זו |
+| `instruct(message)` | הוסף הקשר ללא חסימה | תן ל-agent הקשר נוסף להישאר בעקבות |
+
+`deny(message)` - ההודעה מופיעה ל-Claude בתחילית `"Blocked by failproofai:"`. `deny` אחד בודד מקצר את כל ההערכה הנוספת.
+
+`instruct(message)` - ההודעה מצורפת להקשר של Claude לקריאת הכלי הנוכחית. כל הודעות `instruct` מצטברות ומועברות יחד.
+
+<Tip>
+אתה יכול להצמיד הנחיות נוספות לכל הודעת `deny` או `instruct` על ידי הוספת שדה `hint` ב-`policyParams` — ללא צורך בשינוי קוד. זה עובד גם על מדיניויות custom (`custom/`), קונבנציה של פרויקט (`.failproofai-project/`), וקונבנציה של משתמש (`.failproofai-user/`). ראה [Configuration → hint](/he/configuration#hint-cross-cutting) לפרטים.
+</Tip>
+
+### הודעות allow מידע (beta)
+
+<Note>
+`allow(message)` היא תכונת beta זמינה מ-v0.0.2-beta.3. ה-API עשוי להשתנות בגרסאות עתידיות. גרסאות קודמות תומכות רק ב-`allow()` ללא טיעונים.
+</Note>
+
+`allow(message)` מתיר את הפעולה **ו**שולח הודעה מידע בחזרה ל-Claude. ההודעה מועברת כ-`additionalContext` בתגובת stdout של hook handler — אותה מנגנון שבו משתמשים `instruct`, אך שונה מבחינה סמנטית: זה עדכון סטטוס, לא אזהרה.
+
+| פונקציה | השפעה | השתמש כאשר |
+|----------|--------|----------|
+| `allow(message)` | התר ושלח הקשר ל-Claude | אשר שצ'ק עבר, או הסבר למה צ'ק דולג |
+
+מקרי שימוש:
+- **אישורי סטטוס:** `allow("All CI checks passed.")` — אומר ל-Claude שהכל ירוק
+- **הסברי fail-open:** `allow("GitHub CLI not installed, skipping CI check.")` — אומר ל-Claude למה צ'ק דולג כך שיש לו הקשר מלא
+- **הודעות מרובות מצטברות:** אם מספר מדיניויות כל אחת מחזירה `allow(message)`, כל ההודעות מחוברות עם שורות חדשות ומועברות יחד
+
+```js
+customPolicies.add({
+  name: "confirm-branch-status",
+  match: { events: ["Stop"] },
+  fn: async (ctx) => {
+    const cwd = ctx.session?.cwd;
+    if (!cwd) return allow("No working directory, skipping branch check.");
+
+    // ... check branch status ...
+    if (allPushed) {
+      return allow("Branch is up to date with remote.");
+    }
+    return deny("Unpushed changes detected.");
+  },
+});
+```
+
+### שדות `PolicyContext`
+
+| שדה | סוג | תיאור |
+|-------|------|-------------|
+| `eventType` | `string` | `"PreToolUse"`, `"PostToolUse"`, `"Notification"`, `"Stop"` |
+| `toolName` | `string \| undefined` | הכלי שנקרא (למשל `"Bash"`, `"Write"`, `"Read"`) |
+| `toolInput` | `Record<string, unknown> \| undefined` | פרמטרי הקלט של הכלי |
+| `payload` | `Record<string, unknown>` | payload אירוע גולמי מלא מ-Claude Code |
+| `session` | `SessionMetadata \| undefined` | הקשר סשן (ראה למטה) |
+
+### שדות `SessionMetadata`
+
+| שדה | סוג | תיאור |
+|-------|------|-------------|
+| `sessionId` | `string` | מזהה סשן Claude Code |
+| `cwd` | `string` | ספריית עבודה של סשן Claude Code |
+| `transcriptPath` | `string` | נתיב לקובץ תמליל JSONL של הסשן |
+
+### סוגי אירוע
+
+| אירוע | מתי הוא משדר | תוכן `toolInput` |
+|-------|--------------|----------------------|
+| `PreToolUse` | לפני ש-Claude מריץ כלי | קלט הכלי (למשל `{ command: "..." }` עבור Bash) |
+| `PostToolUse` | לאחר סיום כלי | קלט הכלי + `tool_result` (הפלט) |
+| `Notification` | כאשר Claude שולח הודעה | `{ message: "...", notification_type: "idle" \| "permission_prompt" \| ... }` - hooks חייבים תמיד להחזיר `allow()`, הם לא יכולים לחסום הודעות |
+| `Stop` | כאשר סשן Claude מסתיים | ריק |
+
+---
+
+## סדר הערכה
+
+מדיניויות מוערכות בסדר זה:
+
+1. מדיניויות מובנות (בסדר הגדרה)
+2. מדיניויות custom מפורשות מ-`customPoliciesPath` (בסדר `.add()`)
+3. מדיניויות קונבנציה מ-`.failproofai/policies/` של פרויקט (קבצים אלפביתיים, סדר `.add()` בתוך)
+4. מדיניויות קונבנציה מ-`~/.failproofai/policies/` של משתמש (קבצים אלפביתיים, סדר `.add()` בתוך)
+
+<Note>
+`deny` הראשון מקצר את כל המדיניויות הבאות. כל הודעות `instruct` מצטברות ומועברות יחד.
+</Note>
+
+---
+
+## ייבואים טרנזיטיביים
+
+קבצי מדיניות מותאמות יכולים לייבא מודולים מקומיים באמצעות נתיבים יחסיים:
+
+```js
+// my-policies.js
+import { isBlockedPath } from "./utils.js";
+import { checkApproval } from "./approval-client.js";
+
+customPolicies.add({
+  name: "approval-gate",
+  fn: async (ctx) => {
+    if (ctx.toolName !== "Bash") return allow();
+    const approved = await checkApproval(ctx.toolInput?.command, ctx.session?.sessionId);
+    return approved ? allow() : deny("Approval required for this command");
+  },
+});
+```
+
+כל הייבואים היחסיים שניתן להגיע אליהם מקובץ הכניסה מופתרים. זה מיושם על ידי כתיבה מחדש של ייבואים `from "failproofai"` לנתיב dist בפועל ויצירת קבצים זמניים `.mjs` כדי להבטיח תאימות ESM.
+
+---
+
+## סינון סוג אירוע
+
+השתמש ב-`match.events` להגבלת מתי מדיניות משדרת:
+
+```js
+customPolicies.add({
+  name: "require-summary-on-stop",
+  match: { events: ["Stop"] },
+  fn: async (ctx) => {
+    // Only fires when the session ends
+    // ctx.session.transcriptPath contains the full session log
+    return allow();
+  },
+});
+```
+
+השמט `match` לחלוטין לשדר בכל סוג אירוע.
+
+---
+
+## טיפול בשגיאות ומצבי כשל
+
+מדיניויות מותאמות הן **fail-open**: שגיאות לעולם לא חוסמות מדיניויות מובנות או מקרסות hook handler.
+
+| כשל | התנהגות |
+|---------|----------|
+| `customPoliciesPath` לא מוגדר | אין מדיניויות custom מפורשות פועלות; מדיניויות קונבנציה ומובנות ממשיכות בדרך כלל |
+| קובץ לא נמצא | אזהרה מתועדת ל-`~/.failproofai/hook.log`; מובנים ממשיכים |
+| שגיאת Syntax/import (מפורשת) | שגיאה מתועדת ל-`~/.failproofai/hook.log`; מדיניויות custom מפורשות דולגות |
+| שגיאת Syntax/import (קונבנציה) | שגיאה מתועדת; קובץ זה דולג, קבצי קונבנציה אחרים עדיין נטענים |
+| `fn` זורק בזמן ריצה | שגיאה מתועדת; hook זה מטופל כ-`allow`; hooks אחרים ממשיכים |
+| `fn` לוקח יותר מ-10 שניות | timeout מתועדת; מטופל כ-`allow` |
+| ספריית קונבנציה חסרה | אין מדיניויות קונבנציה פועלות; לא שגיאה |
+
+<Tip>
+כדי לבדוק שגיאות של מדיניות מותאמת, צפה בקובץ היומן:
+
+```bash
+tail -f ~/.failproofai/hook.log
+```
+</Tip>
+
+---
+
+## דוגמה מלאה: מדיניויות מרובות
+
+```js
+// my-policies.js
+import { customPolicies, allow, deny, instruct } from "failproofai";
+
+// Prevent agent from writing to secrets/ directory
+customPolicies.add({
+  name: "block-secrets-dir",
+  description: "Prevent agent from writing to secrets/ directory",
+  match: { events: ["PreToolUse"] },
+  fn: async (ctx) => {
+    if (!["Write", "Edit"].includes(ctx.toolName ?? "")) return allow();
+    const path = ctx.toolInput?.file_path ?? "";
+    if (path.includes("secrets/")) return deny("Writing to secrets/ is not permitted");
+    return allow();
+  },
+});
+
+// Keep the agent on track: verify tests before committing
+customPolicies.add({
+  name: "remind-test-before-commit",
+  description: "Keep the agent on track: verify tests pass before committing",
+  match: { events: ["PreToolUse"] },
+  fn: async (ctx) => {
+    if (ctx.toolName !== "Bash") return allow();
+    const cmd = ctx.toolInput?.command ?? "";
+    if (/git\s+commit/.test(cmd)) {
+      return instruct("Verify all tests pass before committing. Run `bun test` if you haven't already.");
+    }
+    return allow();
+  },
+});
+
+// Prevent unplanned dependency changes during freeze
+customPolicies.add({
+  name: "dependency-freeze",
+  description: "Prevent unplanned dependency changes during freeze period",
+  match: { events: ["PreToolUse"] },
+  fn: async (ctx) => {
+    if (ctx.toolName !== "Bash") return allow();
+    const cmd = ctx.toolInput?.command ?? "";
+    const isInstall = /^(npm install|yarn add|bun add|pnpm add)\s+\S/.test(cmd);
+    if (isInstall && process.env.DEPENDENCY_FREEZE === "1") {
+      return deny("Package installs are frozen. Unset DEPENDENCY_FREEZE to allow.");
+    }
+    return allow();
+  },
+});
+
+export { customPolicies };
+```
+
+---
+
+## דוגמאות
+
+ספריית `examples/` מכילה קבצי מדיניות מוכנים להפעלה:
+
+| קובץ | תוכן |
+|------|----------|
+| `examples/policies-basic.js` | חמש מדיניויות קלפי סטרטר המכסות מצבי כשל נפוצים של agent |
+| `examples/policies-advanced/index.js` | דפוסים מתקדמים: ייבואים טרנזיטיביים, קריאות async, ניקוי פלט, hooks של סוף סשן |
+| `examples/convention-policies/security-policies.mjs` | מדיניויות אבטחה מבוססות קונבנציה (חסום כתיבות .env, מנע כתיבה מחדש של היסטוריית git) |
+| `examples/convention-policies/workflow-policies.mjs` | מדיניויות זרימת עבודה מבוססות קונבנציה (תזכורות בדיקה, קובץ כתיבה ביקורת) |
+
+### שימוש בדוגמאות קובץ מפורש
+
+```bash
+failproofai policies --install --custom ./examples/policies-basic.js
+```
+
+### שימוש בדוגמאות מבוססות קונבנציה
+
+```bash
+# Copy to project level
+mkdir -p .failproofai/policies
+cp examples/convention-policies/*.mjs .failproofai/policies/
+
+# Or copy to user level
+mkdir -p ~/.failproofai/policies
+cp examples/convention-policies/*.mjs ~/.failproofai/policies/
+```
+
+לא נדרש פקודת התקנה — הקבצים נקטפים באופן אוטומטי בהאירוע hook הבא.