failproofai 0.0.5 → 0.0.6-beta.0

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

@@ -1,10 +1,10 @@
 ---
 title: Politiques personnalisées
-description: "Écrivez vos propres politiques en JavaScript — appliquez des conventions, prévenez la dérive, détectez les échecs, intégrez des systèmes externes"
+description: "Écrivez vos propres politiques en JavaScript — appliquez des conventions, prévenez la dérive, détectez les défaillances, intégrez des systèmes externes"
 icon: code
 ---
 
-Les politiques personnalisées vous permettent d'écrire des règles pour n'importe quel comportement d'agent : appliquer des conventions de projet, prévenir la dérive, bloquer les opérations destructrices, détecter les agents bloqués, ou s'intégrer avec Slack, des workflows d'approbation, et bien plus. Elles utilisent le même système d'événements hook et les mêmes décisions `allow`, `deny`, `instruct` que les politiques intégrées.
+Les politiques personnalisées vous permettent d'écrire des règles pour n'importe quel comportement d'agent : appliquer des conventions de projet, prévenir la dérive, bloquer les opérations destructives, détecter les agents bloqués, ou s'intégrer avec Slack, des workflows d'approbation, et bien plus. Elles utilisent le même système d'événements de hook et les mêmes décisions `allow`, `deny`, `instruct` que les politiques intégrées.
 
 ---
 
@@ -29,7 +29,7 @@ customPolicies.add({
 });
 ```
 
-Installez-le :
+Installation :
 
 ```bash
 failproofai policies --install --custom ./my-policies.js
@@ -39,12 +39,12 @@ failproofai policies --install --custom ./my-policies.js
 
 ## Deux façons de charger des politiques personnalisées
 
-### Option 1 : Par convention (recommandé)
+### Option 1 : Basée sur les conventions (recommandée)
 
-Déposez des fichiers `*policies.{js,mjs,ts}` dans `.failproofai/policies/` et ils sont chargés automatiquement — aucun indicateur ni changement de configuration requis. Cela fonctionne comme les git hooks : déposez un fichier, il est pris en compte immédiatement.
+Déposez des fichiers `*policies.{js,mjs,ts}` dans `.failproofai/policies/` et ils sont automatiquement chargés — aucun indicateur ni modification de configuration nécessaire. Cela fonctionne comme les hooks git : déposez un fichier, et c'est tout.
 
 ```
-# Niveau projet — commité dans git, partagé avec l'équipe
+# Niveau projet — validé dans git, partagé avec l'équipe
 .failproofai/policies/security-policies.mjs
 .failproofai/policies/workflow-policies.mjs
 
@@ -52,15 +52,15 @@ Déposez des fichiers `*policies.{js,mjs,ts}` dans `.failproofai/policies/` et i
 ~/.failproofai/policies/my-policies.mjs
 ```
 
-**Comment ça fonctionne :**
-- Les répertoires projet et utilisateur sont tous deux analysés (union — pas de priorité au premier scope)
-- Les fichiers sont chargés alphabétiquement dans chaque répertoire. Préfixez avec `01-`, `02-` pour contrôler l'ordre
+**Fonctionnement :**
+- Les répertoires du projet et de l'utilisateur sont tous deux analysés (union — pas de priorité au premier scope)
+- Les fichiers sont chargés par ordre alphabétique dans chaque répertoire. Préfixez avec `01-`, `02-` pour contrôler l'ordre
 - Seuls les fichiers correspondant à `*policies.{js,mjs,ts}` sont chargés ; les autres fichiers sont ignorés
 - Chaque fichier est chargé indépendamment (fail-open par fichier)
-- Fonctionne en parallèle avec les indicateurs `--custom` explicites et les politiques intégrées
+- Fonctionne conjointement avec les politiques `--custom` explicites et les politiques intégrées
 
 <Tip>
-Les politiques par convention sont le moyen le plus simple de partager des politiques au sein d'une équipe. Commitez `.failproofai/policies/` dans git et chaque membre de l'équipe les reçoit automatiquement.
+Les politiques par convention sont le moyen le plus simple de partager des politiques au sein d'une équipe. Validez `.failproofai/policies/` dans git et chaque membre de l'équipe les obtient automatiquement.
 </Tip>
 
 ### Option 2 : Chemin de fichier explicite
@@ -76,15 +76,15 @@ failproofai policies --install --custom ./new-policies.js
 failproofai policies --uninstall --custom
 ```
 
-Le chemin absolu résolu est stocké dans `policies-config.json` sous `customPoliciesPath`. Le fichier est chargé à nouveau à chaque événement hook — aucune mise en cache entre les événements.
+Le chemin absolu résolu est stocké dans `policies-config.json` sous `customPoliciesPath`. Le fichier est chargé à nouveau à chaque événement de hook — il n'y a pas de mise en cache entre les événements.
 
 ### Utiliser les deux ensemble
 
 Les politiques par convention et le fichier `--custom` explicite peuvent coexister. Ordre de chargement :
 
 1. Fichier `customPoliciesPath` explicite (si configuré)
-2. Fichiers de convention projet (`{cwd}/.failproofai/policies/`, alphabétique)
-3. Fichiers de convention utilisateur (`~/.failproofai/policies/`, alphabétique)
+2. Fichiers de convention du projet (`{cwd}/.failproofai/policies/`, alphabétique)
+3. Fichiers de convention de l'utilisateur (`~/.failproofai/policies/`, alphabétique)
 
 ---
 
@@ -98,7 +98,7 @@ import { customPolicies, allow, deny, instruct } from "failproofai";
 
 ### `customPolicies.add(hook)`
 
-Enregistre une politique. Appelez cette méthode autant de fois que nécessaire pour plusieurs politiques dans le même fichier.
+Enregistre une politique. Appelez cette fonction autant de fois que nécessaire pour plusieurs politiques dans le même fichier.
 
 ```ts
 customPolicies.add({
@@ -115,29 +115,28 @@ customPolicies.add({
 |----------|--------|----------|
 | `allow()` | Autorise l'opération silencieusement | L'action est sûre, aucun message nécessaire |
 | `deny(message)` | Bloque l'opération | L'agent ne doit pas effectuer cette action |
-| `instruct(message)` | Ajoute du contexte sans bloquer | Fournir à l'agent du contexte supplémentaire pour rester sur la bonne voie |
+| `instruct(message)` | Ajoute du contexte sans bloquer | Donner à l'agent un contexte supplémentaire pour rester sur la bonne voie |
 
 `deny(message)` — le message apparaît à Claude préfixé par `"Blocked by failproofai:"`. Un seul `deny` court-circuite toute évaluation ultérieure.
 
 `instruct(message)` — le message est ajouté au contexte de Claude pour l'appel d'outil en cours. Tous les messages `instruct` sont accumulés et délivrés ensemble.
 
 <Tip>
-Vous pouvez ajouter des instructions supplémentaires à n'importe quel message `deny` ou `instruct` en ajoutant un champ `hint` dans `policyParams` — sans modifier le code. Cela fonctionne également pour les politiques personnalisées (`custom/`), par convention projet (`.failproofai-project/`) et par convention utilisateur (`.failproofai-user/`). Voir [Configuration → hint](/fr/configuration#hint-cross-cutting) pour les détails.
+Vous pouvez ajouter des indications supplémentaires à n'importe quel message `deny` ou `instruct` en ajoutant un champ `hint` dans `policyParams` — aucune modification de code nécessaire. Cela fonctionne également pour les politiques personnalisées (`custom/`), les politiques de convention de projet (`.failproofai-project/`) et les politiques de convention utilisateur (`.failproofai-user/`). Consultez [Configuration → hint](/fr/configuration#hint-cross-cutting) pour plus de détails.
 </Tip>
 
-### Messages allow informationnels
+### Messages d'autorisation informatifs
 
-
-`allow(message)` autorise l'opération **et** envoie un message informationnel à Claude. Le message est délivré en tant que `additionalContext` dans la réponse stdout du gestionnaire de hook — le même mécanisme qu'`instruct`, mais sémantiquement différent : c'est une mise à jour de statut, pas un avertissement.
+`allow(message)` autorise l'opération **et** envoie un message informatif à Claude. Le message est délivré en tant que `additionalContext` dans la réponse stdout du gestionnaire de hook — le même mécanisme qu'`instruct`, mais sémantiquement différent : c'est une mise à jour de statut, pas un avertissement.
 
 | Fonction | Effet | Utiliser quand |
 |----------|--------|----------|
-| `allow(message)` | Autorise et envoie du contexte à Claude | Confirmer qu'une vérification a réussi, ou expliquer pourquoi une vérification a été ignorée |
+| `allow(message)` | Autoriser et envoyer du contexte à Claude | Confirmer qu'une vérification a réussi, ou expliquer pourquoi une vérification a été ignorée |
 
 Cas d'utilisation :
 - **Confirmations de statut :** `allow("All CI checks passed.")` — indique à Claude que tout est en ordre
-- **Explications fail-open :** `allow("GitHub CLI not installed, skipping CI check.")` — indique à Claude pourquoi une vérification a été ignorée pour qu'il ait le contexte complet
-- **Accumulation de messages multiples :** si plusieurs politiques retournent chacune `allow(message)`, tous les messages sont joints par des sauts de ligne et délivrés ensemble
+- **Explications fail-open :** `allow("GitHub CLI not installed, skipping CI check.")` — indique à Claude pourquoi une vérification a été ignorée afin qu'il dispose du contexte complet
+- **Accumulation de plusieurs messages :** si plusieurs politiques retournent chacune `allow(message)`, tous les messages sont joints par des sauts de ligne et délivrés ensemble
 
 ```js
 customPolicies.add({
@@ -163,7 +162,7 @@ customPolicies.add({
 | `eventType` | `string` | `"PreToolUse"`, `"PostToolUse"`, `"Notification"`, `"Stop"` |
 | `toolName` | `string \| undefined` | L'outil appelé (ex. `"Bash"`, `"Write"`, `"Read"`) |
 | `toolInput` | `Record<string, unknown> \| undefined` | Les paramètres d'entrée de l'outil |
-| `payload` | `Record<string, unknown>` | Payload brut complet de l'événement provenant de Claude Code |
+| `payload` | `Record<string, unknown>` | Charge utile brute complète de l'événement provenant de Claude Code |
 | `session` | `SessionMetadata \| undefined` | Contexte de session (voir ci-dessous) |
 
 ### Champs de `SessionMetadata`
@@ -190,9 +189,9 @@ customPolicies.add({
 Les politiques sont évaluées dans cet ordre :
 
 1. Politiques intégrées (dans l'ordre de définition)
-2. Politiques personnalisées explicites de `customPoliciesPath` (dans l'ordre `.add()`)
-3. Politiques de convention projet `.failproofai/policies/` (fichiers alphabétiques, ordre `.add()` à l'intérieur)
-4. Politiques de convention utilisateur `~/.failproofai/policies/` (fichiers alphabétiques, ordre `.add()` à l'intérieur)
+2. Politiques personnalisées explicites depuis `customPoliciesPath` (dans l'ordre `.add()`)
+3. Politiques de convention du projet `.failproofai/policies/` (fichiers alphabétiques, ordre `.add()` à l'intérieur)
+4. Politiques de convention de l'utilisateur `~/.failproofai/policies/` (fichiers alphabétiques, ordre `.add()` à l'intérieur)
 
 <Note>
 Le premier `deny` court-circuite toutes les politiques suivantes. Tous les messages `instruct` sont accumulés et délivrés ensemble.
@@ -219,13 +218,13 @@ customPolicies.add({
 });
 ```
 
-Tous les imports relatifs accessibles depuis le fichier d'entrée sont résolus. Cela est implémenté en réécrivant les imports `from "failproofai"` vers le chemin dist réel et en créant des fichiers `.mjs` temporaires pour assurer la compatibilité ESM.
+Tous les imports relatifs accessibles depuis le fichier d'entrée sont résolus. Ceci est implémenté en réécrivant les imports `from "failproofai"` vers le chemin dist réel et en créant des fichiers `.mjs` temporaires pour garantir la compatibilité ESM.
 
 ---
 
 ## Filtrage par type d'événement
 
-Utilisez `match.events` pour limiter le déclenchement d'une politique :
+Utilisez `match.events` pour limiter quand une politique se déclenche :
 
 ```js
 customPolicies.add({
@@ -239,7 +238,7 @@ customPolicies.add({
 });
 ```
 
-Omettez `match` entièrement pour se déclencher sur chaque type d'événement.
+Omettez `match` entièrement pour se déclencher à chaque type d'événement.
 
 ---
 
@@ -251,14 +250,14 @@ Les politiques personnalisées sont **fail-open** : les erreurs ne bloquent jama
 |---------|----------|
 | `customPoliciesPath` non défini | Aucune politique personnalisée explicite ne s'exécute ; les politiques de convention et les politiques intégrées continuent normalement |
 | Fichier introuvable | Avertissement consigné dans `~/.failproofai/hook.log` ; les politiques intégrées continuent |
-| Erreur de syntaxe/import (explicite) | Erreur consignée dans `~/.failproofai/hook.log` ; politiques personnalisées explicites ignorées |
-| Erreur de syntaxe/import (convention) | Erreur consignée ; ce fichier ignoré, les autres fichiers de convention se chargent quand même |
-| `fn` lève une exception à l'exécution | Erreur consignée ; ce hook traité comme `allow` ; les autres hooks continuent |
-| `fn` prend plus de 10s | Timeout consigné ; traité comme `allow` |
+| Erreur de syntaxe/import (explicite) | Erreur consignée dans `~/.failproofai/hook.log` ; les politiques personnalisées explicites sont ignorées |
+| Erreur de syntaxe/import (convention) | Erreur consignée ; ce fichier est ignoré, les autres fichiers de convention se chargent quand même |
+| `fn` lève une exception à l'exécution | Erreur consignée ; ce hook est traité comme `allow` ; les autres hooks continuent |
+| `fn` prend plus de 10 s | Délai consigné ; traité comme `allow` |
 | Répertoire de convention manquant | Aucune politique de convention ne s'exécute ; aucune erreur |
 
 <Tip>
-Pour déboguer les erreurs de politiques personnalisées, surveillez le fichier journal :
+Pour déboguer les erreurs de politiques personnalisées, surveillez le fichier de log :
 
 ```bash
 tail -f ~/.failproofai/hook.log
@@ -328,10 +327,10 @@ Le répertoire `examples/` contient des fichiers de politiques prêts à l'emplo
 
 | Fichier | Contenu |
 |------|----------|
-| `examples/policies-basic.js` | Cinq politiques de démarrage couvrant les modes d'échec courants des agents |
-| `examples/policies-advanced/index.js` | Patterns avancés : imports transitifs, appels asynchrones, nettoyage de sortie et hooks de fin de session |
-| `examples/convention-policies/security-policies.mjs` | Politiques de sécurité par convention (bloquer les écritures .env, empêcher la réécriture de l'historique git) |
-| `examples/convention-policies/workflow-policies.mjs` | Politiques de workflow par convention (rappels de tests, audit des écritures de fichiers) |
+| `examples/policies-basic.js` | Cinq politiques de démarrage couvrant les modes de défaillance courants des agents |
+| `examples/policies-advanced/index.js` | Modèles avancés : imports transitifs, appels asynchrones, nettoyage des sorties et hooks de fin de session |
+| `examples/convention-policies/security-policies.mjs` | Politiques de sécurité basées sur les conventions (bloquer les écritures .env, empêcher la réécriture de l'historique git) |
+| `examples/convention-policies/workflow-policies.mjs` | Politiques de workflow basées sur les conventions (rappels de tests, audit des écritures de fichiers) |
 
 ### Utiliser les exemples de fichiers explicites
 
@@ -339,16 +338,16 @@ Le répertoire `examples/` contient des fichiers de politiques prêts à l'emplo
 failproofai policies --install --custom ./examples/policies-basic.js
 ```
 
-### Utiliser les exemples par convention
+### Utiliser les exemples basés sur les conventions
 
 ```bash
-# Copier au niveau projet
+# Copier au niveau du projet
 mkdir -p .failproofai/policies
 cp examples/convention-policies/*.mjs .failproofai/policies/
 
-# Ou copier au niveau utilisateur
+# Ou copier au niveau de l'utilisateur
 mkdir -p ~/.failproofai/policies
 cp examples/convention-policies/*.mjs ~/.failproofai/policies/
 ```
 
-Aucune commande d'installation requise — les fichiers sont pris en compte automatiquement au prochain événement hook.
+Aucune commande d'installation nécessaire — les fichiers sont récupérés automatiquement au prochain événement de hook.

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

@@ -1,11 +1,11 @@
 ---
 ---
 title: ארכיטקטורה
-description: "כיצד מטפל ה-hook, טעינת ההגדרות והערכת המדיניות עובדים באופן פנימי"
+description: "כיצד מטפל ה-hook, טעינת התצורה והערכת המדיניות עובדים באופן פנימי"
 icon: sitemap
 ---
 
-מסמך זה מסביר כיצד failproofai עובד באופן פנימי: כיצד מערכת ה-hook מיירטת קריאות כלים של סוכנים, כיצד הגדרות נטענות ומתמזגות, כיצד מדיניות מוערכת, וכיצד לוח הבקרה עוקב אחרי פעילות סוכנים.
+מסמך זה מסביר כיצד failproofai עובד באופן פנימי: כיצד מערכת ה-hook חוצצת קריאות כלי סוכן, כיצד התצורה נטענת ומוזגת, כיצד מדיניות מוערכת, וכיצד לוח המחוונים מנטר פעילות סוכן.
 
 ---
 
@@ -13,18 +13,18 @@ icon: sitemap
 
 ל-failproofai יש שתי תת-מערכות עצמאיות:
 
-1. **מטפל Hook** - תת-תהליך CLI מהיר שClaude Code מפעיל בכל קריאת כלי סוכן. מעריך מדיניות ומחזיר החלטה.
-2. **Agent Monitor (Dashboard)** - יישום Next.js לניטור של סשנים של סוכנים וניהול מדיניות.
+1. **מטפל ה-Hook** - תהליך CLI מהיר שהוא Claude Code משדר בכל קריאת כלי סוכן. מעריך מדיניות והחזר החלטה.
+2. **Agent Monitor (Dashboard)** - אפליקציית Next.js לניטור מושבי סוכן וניהול מדיניות.
 
-שתי התת-מערכות משתפות קבצי הגדרות בתיקייה `~/.failproofai/` ובתיקייה `.failproofai/` של הפרויקט, אך הן פועלות כתהליכים נפרדים ותקשרות רק דרך מערכת הקבצים.
+שתי התת-מערכות חולקות קבצי תצורה ב-`~/.failproofai/` ובתיקייה `~/.failproofai/` של הפרויקט, אך הם פועלים כתהליכים נפרדים ותקשורתם היא רק דרך מערכת הקבצים.
 
 ---
 
-## מטפל Hook
+## מטפל ה-Hook
 
-### שילוב עם Claude Code
+### אינטגרציה עם Claude Code
 
-כאשר אתה מריץ `failproofai policies --install`, הוא כותב ערכים כמו זה לתוך `~/.claude/settings.json`:
+כאשר אתה מריץ `failproofai policies --install`, הוא כותב ערכים כמו זה ב-`~/.claude/settings.json`:
 
 ```json
 {
@@ -45,9 +45,9 @@ icon: sitemap
 }
 ```
 
-Claude Code לאחר מכן מפעיל את `failproofai --hook PreToolUse` כתת-תהליך לפני כל קריאת כלי, תוך העברת מטען JSON ל-stdin.
+Claude Code לאחר מכן משדר `failproofai --hook PreToolUse` כתת-תהליך לפני כל קריאת כלי, והעברת עומס JSON על stdin.
 
-### פורמט מטען
+### פורמט עומס
 
 ```json
 {
@@ -61,11 +61,11 @@ Claude Code לאחר מכן מפעיל את `failproofai --hook PreToolUse` כת
 }
 ```
 
-לאירועי `PostToolUse`, המטען מכיל גם `tool_result` עם הפלט של הכלי.
+עבור אירועי `PostToolUse`, העומס מכיל גם `tool_result` עם הפלט של הכלי.
 
-המטפל אוכף מגבלת stdin של 1 MB. מטענים החוצים זאת מושלכים וכל מדיניות מאפשרת באופן מובנה.
+המטפל כופה גבול של 1 MB ל-stdin. עומסים החוצים זאת מושלכים וכל המדיניות משתמעת להרשות.
 
-### פורמט תجובה
+### פורמט תגובה
 
 **Deny (PreToolUse):**
 ```json
@@ -86,7 +86,7 @@ Claude Code לאחר מכן מפעיל את `failproofai --hook PreToolUse` כת
 }
 ```
 
-**Instruct (כל אירוע מלבד Stop):**
+**Instruct (any event except Stop):**
 ```json
 {
   "hookSpecificOutput": {
@@ -95,9 +95,9 @@ Claude Code לאחר מכן מפעיל את `failproofai --hook PreToolUse` כת
 }
 ```
 
-**אירוע Stop instruct:**
+**Stop event instruct:**
 - קוד יציאה: `2`
-- סיבה כתובה ל-stderr (לא stdout)
+- הנמקה כתובה ל-stderr (לא stdout)
 
 **Allow:**
 - קוד יציאה: `0`
@@ -105,23 +105,23 @@ Claude Code לאחר מכן מפעיל את `failproofai --hook PreToolUse` כת
 
 **Allow עם הודעה:**
 
-`allow(message)` מאפשר למדיניות לשלוח הקשר מידע חזור ל-Claude גם כאשר הפעולה מורשית. מטפל ה-hook כותב את ה-JSON הבא ל-**stdout** (לא קובץ הגדרות — זו תגובת המטפל ל-Claude Code, בדיוק כמו תגובות deny ו-instruct לעיל):
+`allow(message)` מאפשר למדיניות לשלוח הקשר מידע חזרה ל-Claude גם כאשר הפעולה מורשית. מטפל ה-Hook כותב את ה-JSON הבא ל-**stdout** (לא קובץ תצורה — זו התגובה של המטפל ל-Claude Code, בדיוק כמו תגובות deny ו-instruct למעלה):
 
 ```json
-// כתוב ל-stdout על ידי תהליך מטפל ה-hook
+// Written to stdout by the hook handler process
 {
   "hookSpecificOutput": {
     "additionalContext": "All CI checks passed on branch 'feat/my-feature'."
   }
 }
 ```
-- קוד יציאה: `0` (פעולה מורשית)
-- כאשר מדיניות מרובות מחזירות `allow` עם הודעה, הודעותיהן משולבות עם שורות חדשות לתוך מחרוזת `additionalContext` יחידה
-- אם אף מדיניות לא מספקת הודעה, stdout ריק (זהה לקודם)
+- קוד יציאה: `0` (הפעולה מורשית)
+- כאשר מדיניות מרובות החוזרות `allow` עם הודעה, ההודעות שלהן מחוברות עם שורות חדשות למחרוזת `additionalContext` יחידה
+- אם אין מדיניות המספקת הודעה, stdout הוא ריק (כמו קודם)
 
 ### צינור עיבוד
 
-`src/hooks/handler.ts` מיישם את כל הצינור:
+`src/hooks/handler.ts` מיישם את המסלול המלא:
 
 ```text
 stdin JSON
@@ -140,13 +140,13 @@ stdin JSON
   → exit
 ```
 
-כל התהליך פועל בפחות מ-100ms עבור מטענים טיפוסיים ללא קריאות LLM.
+התהליך כולו פועל בפחות מ-100ms עבור עומסים טיפוסיים ללא קריאות LLM.
 
 ---
 
-## טעינת הגדרות
+## טעינת תצורה
 
-`src/hooks/hooks-config.ts` מיישם טעינת הגדרות בשלוש טווחים.
+`src/hooks/hooks-config.ts` מיישם טעינת תצורה בתחום שלוש.
 
 ```text
 [1] {cwd}/.failproofai/policies-config.json        ← project  (highest priority)
@@ -154,40 +154,40 @@ stdin JSON
 [3] ~/.failproofai/policies-config.json             ← global   (lowest priority)
 ```
 
-לוגיקת מיזוג:
-- `enabledPolicies` - איחוד מבודד בכל שלושה הקבצים
-- `policyParams` - למפתח לכל מדיניות, הקובץ הראשון שמגדיר אותו מנצח במלואו
-- `customPoliciesPath` - הקובץ הראשון שמגדיר אותו מנצח
-- `llm` - הקובץ הראשון שמגדיר אותו מנצח
+ההיגיון של המיזוג:
+- `enabledPolicies` - איחוד לא משוכפל בכל שלוש הקבצים
+- `policyParams` - per-policy key, הקובץ הראשון שמגדיר את זה מנצח לחלוטין
+- `customPoliciesPath` - הקובץ הראשון שמגדיר את זה מנצח
+- `llm` - הקובץ הראשון שמגדיר את זה מנצח
 
-לוח הבקרה בדיקה משתמש ב-`readHooksConfig()` (גלובאלי בלבד) לקריאה וכתיבה, מכיוון שהוא אינו מופעל עם cwd של פרויקט.
+לוח המחוונים ברשת משתמש ב-`readHooksConfig()` (global only) לקריאה וכתיבה, מכיוון שהוא לא משדר עם cwd של פרויקט.
 
 ---
 
 ## הערכת מדיניות
 
-`src/hooks/policy-evaluator.ts` מפעיל מדיניות בסדר.
+`src/hooks/policy-evaluator.ts` מריץ מדיניות בסדר.
 
 עבור כל מדיניות:
 
-1. חפש את סכמת `params` של המדיניות (אם יש לה אחת).
-2. קרא את `policyParams[policy.name]` מההגדרה המתמזגת.
-3. מזג ערכים המסופקים על ידי משתמש על ברירות ברירת המחדל של הסכמה לייצור `ctx.params`.
-4. קרא ל-`policy.fn(ctx)` עם ההקשר שנפתר.
-5. אם התוצאה היא `deny`, עצור מיד והחזר את ההחלטה הזו.
+1. חפש את סכימת `params` של המדיניות (אם יש לה).
+2. קרא את `policyParams[policy.name]` מהתצורה המוזגת.
+3. זיזוג ערכים המסופקים על ידי המשתמש מעל ברירות ברירת המחדל בסכימה כדי לייצר `ctx.params`.
+4. התקשר ל-`policy.fn(ctx)` עם ההקשר המסולק.
+5. אם התוצאה היא `deny`, עצור מיד והחזר החלטה זו.
 6. אם התוצאה היא `instruct`, צבור את ההודעה והמשך.
 7. אם התוצאה היא `allow`, המשך למדיניות הבאה.
 
-לאחר שכל המדיניות פועלות:
-- אם הוחזר `deny`, פלוט את תגובת deny.
-- אם התוצאות `instruct` נאספו, פלוט תגובת instruct יחידה עם כל ההודעות משולבות.
+לאחר שכל המדיניות תרוץ:
+- אם אחת כלשהי `deny` הוחזרה, פלוט את תגובת deny.
+- אם תשובות `instruct` כלשהן אוספות, פלוט תגובת instruct אחת עם כל ההודעות מחוברות.
 - אחרת, פלוט תגובת allow (stdout ריק, יציאה 0).
 
 ---
 
-## מדיניות מובנית
+## מדיניות בנויה
 
-`src/hooks/builtin-policies.ts` מגדיר את כל 26 מדיניות מובנית כאובייקטי `BuiltinPolicyDefinition`:
+`src/hooks/builtin-policies.ts` מגדיר את כל 26 המדיניות המובנות כ-`BuiltinPolicyDefinition` אובייקטים:
 
 ```typescript
 interface BuiltinPolicyDefinition {
@@ -205,15 +205,15 @@ interface BuiltinPolicyDefinition {
 }
 ```
 
-מדיניות המקבלת `params` מצהירה ספכמת `PolicyParamsSchema` עם סוגים וברירות מחדל לכל פרמטר. מעריך המדיניות מזריק ערכים שנפתרו ל-`ctx.params` לפני קריאה ל-`fn`. פונקציות מדיניות קוראות `ctx.params` ללא שמירה null מכיוון שברירות מחדל מוחלות תמיד קודם.
+מדיניות המקבלת `params` מצהירה `PolicyParamsSchema` עם סוגים וברירות ברירת מחדל עבור כל פרמטר. מעריך המדיניות מזריק ערכים מסולקים ל-`ctx.params` לפני קריאה ל-`fn`. פונקציות מדיניות קוראות ל-`ctx.params` ללא guard null מכיוון שברירות ברירת מחדל תמיד מיושמות תחילה.
 
-התאמת דפוס בתוך מדיניות משתמשת בטוקנים של פקודה מנותחים (argv), לא התאמה של מחרוזת גולמית. זה מונע עקיפה דרך הזרקת מפעילי shell (לדוגמה, דפוס עבור `sudo systemctl status *` לא יכול להיות מעוקף על ידי הוספת `; rm -rf /` לפקודה).
+התאמת דפוסים בתוך מדיניות משתמשת בקלקולי פקודה מנותחים (argv), לא התאמה של מחרוזות גולמיות. זה מונע עקיפה דרך הזרקת אופרטור מעטפת (למשל דפוס עבור `sudo systemctl status *` לא יכול להיות מעוקף על ידי הוספת `; rm -rf /` לפקודה).
 
 ---
 
-## מדיניות מותאמת אישית
+## מדיניות מותאמת
 
-`src/hooks/custom-hooks-registry.ts` מיישם רישום `globalThis`-backed:
+`src/hooks/custom-hooks-registry.ts` מיישם רישום מסגרת `globalThis`:
 
 ```typescript
 const REGISTRY_KEY = "__failproofai_custom_hooks__";
@@ -228,23 +228,23 @@ export function clearCustomHooks(): void { ... }  // used in tests
 
 `src/hooks/custom-hooks-loader.ts` טוען את קובץ המדיניות של המשתמש:
 
-1. קרא את `customPoliciesPath` מהגדרות; דלג אם היעדר.
-2. פתור לנתיב מוחלט; בדוק שהקובץ קיים.
-3. כתוב מחדש את כל `from "failproofai"` כדי להסב לנתיב dist בפועל כך `customPolicies` מתפתר לרישום `globalThis` זהה.
-4. כתוב מחדש רקורסיבי יבוא מקומי חולף כדי להבטיח תאימות ESM.
-5. כתוב קבצי `.mjs` זמניים ו-`import()` הקובץ הכניסה.
-6. קרא ל-`getCustomHooks()` כדי לאחזר hooks שנרשמו.
+1. קרא את `customPoliciesPath` מהתצורה; דלג אם חסר.
+2. פתור לנתיב מוחלט; בדוק קובץ קיים.
+3. כתוב מחדש את כל `from "failproofai"` ייבוא לנתיב ה-dist בפועל כדי `customPolicies` יתבררו לרישום `globalThis` זהה.
+4. כתוב מחדש ייבוא מקומי חולף רקורסיבי כדי להבטיח התאימות ESM.
+5. כתוב קבצי `.mjs` זמניים ו-`import()` קובץ הכניסה.
+6. התקשר ל-`getCustomHooks()` כדי לשלוח קטגוריות מחדש.
 7. נקה את כל הקבצים הזמניים בבלוק `finally`.
 
-בכל שגיאה (קובץ לא נמצא, שגיאת תחביר, כשל בייבוא), השגיאה נרשמת ל-`~/.failproofai/hook.log` והטוען מחזיר מערך ריק. מדיניות מובנית אינה מושפעת.
+בכל שגיאה (קובץ לא נמצא, שגיאת תחביר, כישלון ייבוא), השגיאה מתועדת ב-`~/.failproofai/hook.log` והטוען מחזיר מערך ריק. מדיניות מובנית לא מושפעת.
 
-מדיניות מותאמת אישית מוערכת לאחר כל מדיניות מובנית. מדיניות מותאמת אישית `deny` עדיין קוצרת מדיניות מותאמת אישית נוספת (אך כל הביומיניות כבר רצות בנקודה זו).
+מדיניות מותאמת מוערכת לאחר כל המדיניות המובנות. `deny` מדיניות מותאמת עדיין מעיל קצר מדיניות מותאמת נוספת (אך כל הבנוי כבר רץ בנקודה זו).
 
 ---
 
 ## רישום פעילות
 
-לאחר כל אירוע hook, המטפל מצרף שורת JSONL ל-`~/.failproofai/hook-activity.jsonl`:
+לאחר כל אירוע hook, המטפל מוסיף שורת JSONL ל-`~/.failproofai/hook-activity.jsonl`:
 
 ```json
 {
@@ -259,13 +259,13 @@ export function clearCustomHooks(): void { ... }  // used in tests
 }
 ```
 
-שורה אחת לכל מדיניות שקיבלה החלטה שאינה allow. החלטות allow אינן נרשמות (כדי להקטין את גודל הקובץ).
+שורה אחת לכל מדיניות שנתנה החלטה שאינה מאפשרת. החלטות Allow לא מתועדות (כדי לשמור את הקובץ קטן).
 
 ---
 
-## ארכיטקטורת לוח הבקרה
+## ארכיטקטורת לוח המחוונים
 
-לוח הבקרה הוא יישום **Next.js 16** המשתמש ב-App Router עם React Server Components ו-Server Actions.
+לוח המחוונים הוא אפליקציית **Next.js 16** באמצעות App Router עם React Server Components ו-Server Actions.
 
 ```text
 app/
@@ -287,20 +287,20 @@ app/
 
 **זרימת נתונים:**
 
-- רכיבי עמוד קוראים ל-`lib/projects.ts` ו-`lib/log-entries.ts` כדי לקרוא נתוני פרויקט/סשן ישירות מ-מערכת הקבצים (אין שכבת API לקריאה).
-- עמוד המדיניות משתמש ב-Server Actions לכל מוטציות (toggle, params update, install/remove).
-- מציג הסשן מנתח את פורמט התמלילון JSONL של Claude ומרנדר ציר זמן של הודעות וקריאות כלים.
+- רכיבי עמוד קוראים ל-`lib/projects.ts` ו-`lib/log-entries.ts` כדי לקרוא נתוני פרויקט/מושב ישירות מ-filesystem (ללא שכבת API לקריאות).
+- עמוד המדיניות משתמש בשרת Actions עבור כל מוטציות (החלפה, עדכון params, התקנה/הסרה).
+- צופה המושב מנתח פורמט תוליד JSONL של Claude ומרחיב ציר זמן של הודעות וקריאות כלים.
 
 **החלטות עיצוב מרכזיות:**
 
-- אין בסיס נתונים - כל מצב מתמשך הוא בקבצים רגילים (`~/.failproofai/`, `~/.claude/projects/`).
-- Server Actions למוטציות - אין צורך ב-REST API עבור פעולות CRUD.
-- React Server Components עבור עמודי קריאה - טעינה ראשונית מהירה יותר, אין חבילת לקוח עבור הבאת נתונים.
-- רכיבים לקוח רק כאשר יש צורך באינטראקטיביות (toggles מדיניות, חיפוש פעילות, מציג יומן).
+- אין מסד נתונים - כל המצב קבוע נמצא בקבצים רגילים (`~/.failproofai/`, `~/.claude/projects/`).
+- Server Actions למוטציות - אין צורך ב-REST API לפעולות CRUD.
+- React Server Components עבור עמודי קריאה - קריאה ראשונית מהירה יותר, אין צרור לקוח לאחזור נתונים.
+- רכיבי לקוח רק בו זה דרוש אינטראקטיביות (החלפות מדיניות, חיפוש פעילות, צופה יומן).
 
 ---
 
-## פריסת קובץ
+## פריסת קבצים
 
 ```text
 failproofai/