failproofai 1.0.1-beta.0 → 1.0.1

package/.next/standalone/docs-old/he/agenteye/cli.mdx

@@ -0,0 +1,349 @@
+---
+title: "CLI"
+description: "נהל את כל Failproof AI Observability מהטרמינל או מסקריפט: ללא צורך בגלישה בדashboard."
+---
+
+נהל את כל Failproof AI Observability מהטרמינל או מסקריפט: ללא צורך בגלישה בדashboard. ה-CLI של `agenteye` שואל על הנתונים שלך (sessions, event logs, evaluations) וממנהל את הארגון שלך (API keys, users, settings, alerts, incidents, saved queries), אז הפנה אליו כאשר אתה רוצה להוסיף בדיקה אוטומטית, לחבר Observability ל-CI, או להשאיר לagent לבדוק production. כל פקודה תומכת בדגל `--json`, כך שהיא עובדת באותה מידה טובה בשבילך בשורת הפקודה או לagent שמריץ ודורס את התוצאה.
+
+עם בינארי אחד אתה יכול:
+
+- **קרוא את הנתונים שלך**: `sessions`, `events`, `evals`, `errors` (סנן לפי זמן, agent, env, score).
+- **נהל את הארגון שלך**: `keys`, `users`, `settings`, `alerts`, `incidents`.
+- **הרץ ניתוחים**: SQL שמור ומריץ query ad-hoc (`query`).
+- **שאל את עוזר ה-AI**: אותו analyst read-only שאתה משוחח איתו בdashboard (`agent`).
+
+> **הערה:** זה ה-CLI של `agenteye`, כלי שונה מה-collector daemon (`agenteye-collector`). ה-CLI מדבר עם dashboard שלך; ה-collector שולח events לשרת.
+
+---
+
+## התחלה מהירה
+
+מלא אפס עד התוצאה הראשונה שלך בארבע שורות. אתחל את ה-CLI לdashboard שלך, התחבר, אשר מי אתה, ואז משוך את יום אחרון של runs:
+
+```bash
+pipx install agenteye
+agenteye --base-url https://agenteye.example.com login --email you@example.com   # emailed 6-digit code
+agenteye whoami                                                                  # confirm user + active org
+agenteye --json sessions --since 24h                                             # one row per agent run, last 24h
+```
+
+הפקודה האחרונה מדפיסה אובייקט JSON של ה-sessions האחרונים ביותר (החדשים ביותר קודם, מוגבלים ל-50 כברירת מחדל). Pipe את זה ל-`jq` כדי לחתוך אותו, או הסר `--json` לטבלה boxed וצבעונית. כל שורה נושאת את status של ה-run, ואם evaluator נתן ציון, את ציוני המטריקות שלו (מקוצר כאן):
+
+```json
+{
+  "sessions": [
+    {
+      "session_id": "run-8f2a",
+      "agent_id": "checkout-bot",
+      "environment": "prod",
+      "status": "error",
+      "scores": { "helpfulness": 0.42, "tool_efficiency": 0.55 },
+      "event_count": 37,
+      "started_at": "2026-07-16T09:14:02Z",
+      "last_event_at": "2026-07-16T09:14:48Z"
+    }
+  ],
+  "next_cursor": null
+}
+```
+
+שאר הדף מסביר כל חלק: [התקנה](#installation) בבידוד, [התחברות](#authentication), [תצורה](#configuration), [הקונבנציות הגלובליות](#global-options--conventions) שכל פקודה משתפת, ו[הפניה המלאה לפקודות](#command-reference).
+
+---
+
+## התקנה
+
+ה-CLI הוא חבילת PyPI ציבורית בשם **`agenteye`**. התקן אותו בסביבה מבודדת כך שיהיה לו תמיד תלויות משלו:
+
+```bash
+pipx install agenteye
+# or
+uv tool install agenteye
+```
+
+זה דורש Python 3.10+. הפקודה המותקנת היא **`agenteye`**:
+
+```bash
+agenteye --version
+agenteye --help
+```
+
+> **הערה:** ה-Python SDK של Failproof AI Observability משתמש גם בשם ההפצה `agenteye`. התקנת ה-CLI עם `pipx` או `uv tool` (במקום `pip install` לתוך virtualenv משותף) מונעת התנגשות בין השניים. `pip install agenteye` פשוט בסדר רק אם ה-SDK לא מותקן באותה סביבה.
+
+---
+
+## התחברות
+
+ה-CLI מתחבר ל-**dashboard** עם קוד חד-פעמי בדואר:
+
+```bash
+agenteye login --email you@example.com
+# A 6-digit code is emailed to you; paste it at the prompt.
+```
+
+토큰ה-session מאוחסן ב-`~/.agenteye/cli.json` (קריא רק לך, mode `0600`) והוא תקף למשך 24 שעות כברירת מחדל. כאשר הוא פג, הרץ `agenteye login` שוב.
+
+```bash
+agenteye whoami     # show the current user, active org, and permissions
+agenteye logout     # revoke the session and clear the stored token
+```
+
+`whoami` לעולם לא נכשל בsession חסר או פג; הוא מדווח על `logged_in: false` במקום זאת, כך שסקריפט או agent יכול לבדוק את מצב ה-auth בבטחה (הוא עדיין יכול להיכשל עם non-zero אם לא מוגדר base URL או ה-dashboard לא זמין).
+
+**דרישות:** הדואר שלך חייב להיות מורשה להתחבר לdashboard (שאל את מנהל Failproof AI Observability שלך), וה-dashboard חייב להיות זמין ב-base URL שלו (ראה [Configuration](#configuration)). אם אתה מבקש קוד וכלום לא מגיע, הדואר שלך כנראה עדיין לא מופעל לגישה לdashboard.
+
+---
+
+## בחר את ה-org שלך (multi-tenant)
+
+אם החשבון שלך שייך ליותר מ-org אחד, בחר את ה-active **בזמן login**; זה נשמר ומשמש לכל פקודה מאוחרת:
+
+```bash
+agenteye login --org acme           # authenticate and set the active tenant in one step
+agenteye orgs list                  # the orgs you can access (the active one is marked)
+agenteye orgs switch globex         # change the saved default
+agenteye --org globex sessions      # override for a single command
+```
+
+אם אתה שייך בדיוק לorg אחד הוא נבחר אוטומטית ואתה יכול להתעלם מ-`--org` לחלוטין. אם אתה שייך לכמה ולא בחרת אחד, ה-CLI מרשימה אותם ושואל אותך להריץ מחדש עם `--org <slug>`. ה-org הpublic הactive נשלח לdashboard בכל בקשה, וההרשאות שלך מסולרות **per org**; `agenteye whoami` מציגה את ה-org הactive, ההרשאות שלך בו, והחברויות שלך.
+
+---
+
+## תצורה
+
+| הגדרה | דגל | משתנה סביבה | ברירת מחדל |
+|---|---|---|---|
+| Dashboard base URL | `--base-url` | `AGENTEYE_DASHBOARD_URL` | **required** (no default) |
+| Active org/tenant | `--org` | `AGENTEYE_ORG` | chosen at login; saved in `~/.agenteye/cli.json` |
+| Session token | `--token` | `AGENTEYE_CLI_TOKEN` | from `~/.agenteye/cli.json` |
+| JSON output | `--json` | `AGENTEYE_CLI_JSON` | off |
+| Skip TLS verification | `--insecure` / `--secure` | `AGENTEYE_INSECURE` | off (saved at login) |
+| Request timeout (seconds) | `--timeout` | _(none)_ | 30 |
+| Disable usage telemetry | _(none)_ | `AGENTEYE_ANALYTICS_DISABLED` (or `DO_NOT_TRACK`) | telemetry is currently disabled; nothing is sent |
+
+סדר ההחלטה הוא **flag → environment variable → config file**. אין ברירת מחדל; חייב לאתחל את ה-CLI לdashboard שלך, או per-command (`--base-url https://agenteye.example.com`) או פעם אחת דרך הסביבה (זה גם נשמר לאחר `login` הראשון שלך):
+
+```bash
+export AGENTEYE_DASHBOARD_URL=https://agenteye.example.com
+```
+
+ספריית התצורה מכבדת `AGENTEYE_HOME` (אותה קונבנציה המשמשת את ה-SDK וה-collector); אם מוגדר, `cli.json` חי ב-`$AGENTEYE_HOME/cli.json`.
+
+### TLS חתום עצמי או פנימי
+
+אם ה-dashboard שלך מוזן דרך HTTPS עם תעודה חתומה עצמית או פנימית (לדוגמה, שם host raw load-balancer), אימות TLS דוחה אותו עם שגיאת `CERTIFICATE_VERIFY_FAILED`. עבור `--insecure` כדי לדלג על אימות תעודה:
+
+```bash
+agenteye --base-url https://agenteye.internal --insecure login
+```
+
+`--insecure` הוא **נשמר ל-`cli.json` כאשר אתה מתחבר**, כך שפקודות מאוחרות יותר דילוג אימות אוטומטי; אתה לא צריך לחזור על הדגל. עבור `--secure` לקול מאומת חד-פעמי, או כדי לשמור אימות חזרה על ב-login הבא שלך. ה-CLI מדפיס אזהרה ל-stderr לפני כל פקודה שמתקשרת לdashboard בזמן אימות מכובה. דילוג אימות מסיר הגנה נגד התקפות man-in-the-middle; ודא שאתה סומך על נתיב הרשת לdashboard (VPN, private subnet, וכו') לפני שאתה מסתמך עליו.
+
+---
+
+## Telemetry & privacy
+
+> **הערה:** ה-CLI המסופק שולח **שום telemetry שימוש היום.** מתג הרג ראשי הוא פועל, כך שלום לא משודר בכל סביבה. הקטע שלהלן מתאר את יכולת ה-opt-out לאם וכאשר telemetry כשהוא מופעל אי פעם.
+
+גם כשמופעל, telemetry יהיה **analytics שימוש אנונימי בלבד**, לא מעולם ה-agent, session, או event שלך:
+
+- **לא ה-agent, session, או event שלך כשהוא משאיר את התשתית שלך.** רק שימוש CLI יהיה מדווח: הפקודה ו-subcommand name (לדוגמה `keys create`), **names** של הדגלים שהשתמשת בהם (לא פעם את הערכים שלהם), success/exit status, ודווח, בתוספת per-action event לmutations (לדוגמה `api_key_created`, `query_run`) בנשיאה שמות/enums סטטיים בלבד וספירות גס. ה-dashboard URL שלך, session token, דואר, org slug, resource ids, SQL, key secrets, וquery filters היו **never** שלח. אופרטורים היו מזוהים רק ב-opaque internal id, לא לפי דואר.
+- **Opt out מראש** על ידי הגדרה `AGENTEYE_ANALYTICS_DISABLED=1` בסביבה של ה-CLI (ה-CLI גם מכבד את ה-cross-tool `DO_NOT_TRACK=1` קונבנציה). זה נכנס לתוקף ברגע telemetry הוא אי פעם הופכת, כך שסביבה privacy-conscious יכולה להישאר opted out לצמיתות.
+- אם telemetry היו מופעל, ה-CLI היה שלח ישירות ל-PostHog (`https://us.i.posthog.com`); מכונה עם host זה חסום היא שקט לא שלח כלום וה-CLI היה unaffected.
+
+---
+
+## Global options & conventions
+
+קרא את זה פעם אחת; זה חל לכל פקודה.
+
+- **Global options לך לפני הפקודה.** `agenteye --json sessions` הוא נכון; `agenteye sessions --json` היא שגיאת שימוש. ה-globals הם `--json`, `--base-url`, `--org`, `--token`, `--insecure`/`--secure`, `--timeout`, `--quiet`, ו-`--no-color`.
+- **`--json` מדפיס pure JSON ל-stdout, וכלום אחר.** Human status lines, הערות, ושגיאות לך ל-**stderr**, כך ש-`--json` stdout capture נשאר נקי ל-pipe לתוך `jq` גם כאשר status line מוצג. ללא `--json` אתה משיג boxed, צפוי בחזרה לעיני אדם.
+- **גלה עם `--help`.** כל פקודה וsub-command יש `--help` (ו-`-h` alias): `agenteye -h`, `agenteye sessions -h`, `agenteye keys create -h`. העזרה ברמה העליונה גם רשימות exit codes וגלובליות אפציות. אין global machine-readable surface dump; השתמש per-command `--help`, בתוספת domain-specific `agenteye query schema` ו-`agenteye settings schema` לשניים אלו registries.
+- **Confirmations auto-skip לscrips וagents.** Create/update/delete פקודות הנושא "האם אתה בטוח?" בטרמינל interactive, אבל **auto-skip שהנושא תחת `--json` או בכל פעם stdin אינו TTY** (TTY הוא interactive terminal session; pipe או CI runner לא), כך שscrips וagents לא תלויים. עבור `--yes`/`-y` כדי לדלג עליו במפורש. מכיוון שהנושא לא יקום לagent, agent צריך לאשר משימות destructive עם אדם ראשון.
+- **Pagination:** תוצאות הן newest-first וcursor-paginated (כל עמוד חוזר token אתה משתמש כדי להביא את הבא). `--limit N` (alias `-n`) caps rows ו**defaults ל-50**; `--all` auto-paginates (בחלקי 200-row) **עד `--limit`**, כך צרה `--all` עדיין עוצר ב-50. לעבור מלא עבור pass a גבוה explicit cap: `--all --limit 1000`. `--page-size N` שליטה per-request chunk (max 200); `--cursor <id>` resumes מא prior page's `next_cursor`.
+- **Time filters:** `--since` לוקח a relative window: `15m`, `1h`, `6h`, `24h`, `7d`, או `all` (dashboard's presets). לארוך או custom range (say 30 ימים האחרונים), השתמש `--from`/`--to`: explicit ISO-8601 UTC timestamps **עם `T` וtimezone** (לדוגמה `2026-06-01T00:00:00Z`) כי override `--since`. space-separated או timezone-less value היא שגיאת שימוש.
+- **`--fields a,b,c`** (על `events`, `sessions`, `evals`, `errors`) מגביל את הפלט לאלו מקשים, עבור שניהם הטבלה ו-`--json`. שמות לא ידועים דחויים עם הרשימה תקפה, דרך זול לגלות שמות שדה.
+- **`--file payload.json`** (או `--file -` לקרוא stdin) מספק מלא JSON request body כאשר משאב יש צורה מורכבת (על `alerts create/update`, `settings set`, ו-`users create/update`). Saved-query SQL משתמש `--sql @file.sql` במקום.
+- **Multi-value filters** הם comma-separated → matched כ-set (union בתוך filter אחד, AND throughout filters): `--event-type tool_use,tool_result`. Click אפציות אינם variadic, כך `--add a b` שבירות. השתמש `--add a,b`, חזור הדגל (`--add a --add b`), או ציטוט (`--add "a b"`).
+
+---
+
+## Command reference
+
+### אתה תשתמש בחמשת הפקודות הללו ביותר
+
+יום רביעי של עבודה מתבצעות דרך של קצת read commands. התחל כאן, אז הגע עבור המשטח המלא להלן כאשר אתה צריך:
+
+| פקודה | מה זה עושה | נסה את זה |
+|---|---|---|
+| `sessions` | שורה אחת לכל agent run: זמן, env, agent, status, ציון לאחרונה. | `agenteye --json sessions --since 24h --status error` |
+| `events` | ה-raw per-step trail בתוך run (הוסף `--full` לtayloads). | `agenteye --json events --session-id run-001 --all` |
+| `evals` | תוצאות הערכה וציונים; `--aggregate` rolls them up. | `agenteye --json evals --aggregate --since 7d --env prod` |
+| `errors` | רק את errored events; `--aggregate` לספירה לפי סוג. | `agenteye --json errors --since 24h --aggregate` |
+| `list` | גלה את ערכי ה-filter תקפה (agents, envs, models, …). | `agenteye list agents` |
+
+### כל מה ש-CLI יכול לעשות
+
+המשטח המלא עוקב. ל-CLI יש **18 פקודות top-level**. כל read commands קבל `--json` וגלובליות אפציות לעיל; הרץ `agenteye <command> -h` (או `<command> <subcommand> -h`) לexhaustive flag list וJSON shape של כל אחד.
+
+### Identity: `login` · `logout` · `whoami` · `orgs` · `version` · `help`
+
+```bash
+agenteye login --email you@example.com [--org acme]   # emailed one-time code; saves the session
+agenteye logout                                       # clear the saved session on this machine
+agenteye whoami                                       # current user, active org, permissions
+agenteye version                                      # print the CLI version (same as --version)
+agenteye help                                         # top-level help (same as --help)
+```
+
+`orgs` inspects וscreens ה-active tenant:
+
+```bash
+agenteye orgs list        # your orgs + your role in each (active one marked)
+agenteye orgs switch acme # change the saved active org (omit the slug to pick from a list on a TTY)
+agenteye orgs current     # identity card for the active org
+agenteye orgs perms       # your permissions in the active org, grouped by resource
+```
+
+### Observe (read-only): `events` · `sessions` · `evals` · `errors` · `list`
+
+אף אחד מאלה צרך confirmation. Shared filters: `--session-id`, `--agent-id`, `--env` (**לא** `--environment`), וה-time range (`--since` / `--from` / `--to`).
+
+```bash
+# events (alias: the raw per-step trail), newest first
+agenteye --json events --session-id run-001 --event-type tool_use,tool_result --all --limit 1000
+agenteye --json events --since 1h --search timeout --all | jq '.events[].payload'
+
+# sessions: one row per agent run (time/env/agent/session/status; no score filtering)
+agenteye --json sessions --since 24h --status error
+agenteye --json sessions --agent-id checkout-bot --env prod --all --limit 1000
+
+# evals: evaluation results + scores; --score filters by metric, --aggregate rolls up
+agenteye --json evals --score helpfulness:0.5..0.8 --score tool_efficiency:..0.3
+agenteye --json evals --aggregate --since 7d --env prod        # status mix + per-key score stats
+
+# errors: errored events; --aggregate for counts/sessions/agents/last-seen
+agenteye --json errors --since 24h --aggregate
+agenteye --json errors --since 24h --error-type timeout --all --limit 1000
+
+# list: discover valid filter values before you filter
+agenteye list envs        # also: agents event_types score_filters models hooks tools error_types
+```
+
+`--score KEY:MIN..MAX` (על **`evals`**, לא `sessions`) הוא repeatable וAND-combined; שניהם bound הם אופציוניים (`..0.5` אומר ≤ 0.5, `0.9..` אומר ≥ 0.9). עד 20 score filters לבקשה. `evals --scores-full` היא display flag עבור ה-**human table בלבד**; זה מראה כל score pair במקום את הראשון כמה בתוספת `+N` count. זה אין השפעה תחת `--json`, שתמיד מחזיר את object score מלא. לקרוא **one session end-to-end**, שלב את ה-event trail עם הערכתו:
+
+```bash
+agenteye --json events --session-id run-001 --all --limit 1000 | jq '.events[] | {ts, event_type}'
+agenteye --json evals  --session-id run-001                       # its scores + status
+```
+
+### Manage (permission-gated): `keys` · `users` · `settings` · `alerts` · `incidents`
+
+**`keys`**: API keys. הסוד נוצר מקומית, שלח לשרת (אשר stores רק hash), ו-**shown פעם אחת** על create/regenerate; capture זה אז. עם `--json` זה מופיע רק בשדה `key`. Referenced by **name**.
+
+```bash
+agenteye keys list                                   # active keys first, then revoked
+agenteye keys show ci-bot
+agenteye keys create ci-bot --add events:read.add    # scope to what you need; prints the secret ONCE
+agenteye keys create ops --permission-set standard --remove queries:run   # seed a preset, then trim
+agenteye keys update ci-bot --add evaluations:read --yes
+agenteye keys regenerate ci-bot --yes                # rotate the secret (the old one stops working)
+agenteye keys disable ci-bot --yes                   # revoke
+```
+
+הרשאות עבודה כמו `(permission-set ∪ --add) − --remove`. Tokens הם `slug:action` (לדוגמה `events:read`) או `slug:action.action` להרחיב כמה על משאב אחד (`events:read.add` → `events:read`, `events:add`). Presets: `read-only`, `standard`, `admin`. Human-only הרשאות (`keys:update`) לא יכול להיות כן ל-key.
+
+**`users`**: org members, referenced by **email** (UUID id נכנס גם accepted).
+
+```bash
+agenteye users list [--active-only]
+agenteye users show dev@corp.com
+agenteye users create dev@corp.com --permission-set standard
+agenteye users update dev@corp.com --add alerts:write --remove queries:delete   # predicts + confirms
+agenteye users disable dev@corp.com --yes            # has protected/self guards
+agenteye users enable dev@corp.com
+```
+
+**`settings`**: fixed registry (אתה קורא ושנה קיים keys; אתה לא יכול ליצור חדש).
+
+```bash
+agenteye settings list                               # key · value · type · updated (secrets masked)
+agenteye settings schema                             # what each key accepts (type · range · description)
+agenteye settings set session_ttl_secs --value 86400 --yes
+```
+
+**`alerts`**: הגדרות alert, referenced by **name**. `create` לוקח positional NAME בתוספת flags או מלא JSON body דרך `--file`.
+
+```bash
+agenteye alerts list
+agenteye alerts show high-errors
+agenteye alerts create high-errors --file alert.json          # NAME is required (positional)
+agenteye alerts update high-errors --severity critical --yes
+agenteye alerts test high-errors --yes                        # fire a test notification
+agenteye alerts delete high-errors --yes
+```
+
+**`incidents`**: alert incidents, referenced by id (short ids accepted). `show` prints ה-full activity log; קרא את זה לפני פועל.
+
+```bash
+agenteye incidents list --state firing                # also: acknowledged, resolved
+agenteye incidents count
+agenteye incidents show <id>
+agenteye incidents ack <id>
+agenteye incidents assign <id> you@corp.com           # assignee must be an operator
+agenteye incidents resolve <id> --yes
+agenteye incidents open --alert-id <id> --severity critical    # open one manually against an alert
+agenteye incidents comment-add <id> "root cause: upstream 5xx"
+agenteye incidents comment-list <id> ; agenteye incidents comment-delete <id> <comment-id>
+agenteye incidents subscribe <id> ; agenteye incidents unsubscribe <id> ; agenteye incidents subscribers <id>
+```
+
+### Analytics & assistant: `query` · `agent`
+
+**`query`**: saved SQL נגד analytics store בתוספת ad-hoc runner. Saved queries הם referenced by **name**; ה-SQL הוא validated server-side (SELECT/WITH רק, statement timeout, row cap).
+
+```bash
+agenteye query schema [TABLE]                         # column layout of the analytics views
+agenteye query run --sql "select count(*) from analytics.events"
+agenteye query run errs --arg prod --limit 100        # run a saved query + a positional $1
+agenteye query list ; agenteye query show errs
+agenteye query create errs --sql @errs.sql --description "errored events (24h)"
+agenteye query update errs --sql @errs.sql --yes ; agenteye query delete errs --yes
+```
+
+**`agent`**: דברים ל-built-in **AI assistant** (אותו read-only analyst אתה יכול לשוחח עם בdashboard). Chats הם referenced by short chat-id (prefix-resolved).
+
+```bash
+agenteye agent health                                 # is the AI assistant configured/reachable
+agenteye agent models                                 # models you can pass to --model (default marked)
+agenteye agent ask "which agents errored most in the last day?"    # starts a chat; prints its short id
+agenteye agent ask --chat <short-id> "and which tools did they call?"   # continue that chat
+agenteye agent chats ; agenteye agent show <short-id>
+agenteye agent rename <short-id> --title "error triage" ; agenteye agent delete <short-id>
+```
+
+---
+
+## Exit codes
+
+| קוד | משמעות |
+|---|---|
+| 0 | הצלחה |
+| 1 | שגיאה לא צפויה (לדוגמה ה-dashboard החזיר 5xx) |
+| 2 | שגיאת שימוש (ארגומנטים לא תקפה, פקודה/דגל לא ידוע, שם collision) |
+| 3 | לא יכול להגיע ל-dashboard |
+| 4 | לא התחבר או session פג; הרץ `agenteye login` |
+| 5 | Authenticated, אבל החשבון שלך חסר את ההרשאה הנדרשת (ההודעה קורא את זה) |
+| 6 | משאב המבוקש לא היה found (לדוגמה session לא ידוע או incident id) |
+
+אלה עושים את ה-CLI בטוח לsript: coding agent יכול branch על `4` להנושא אותך re-authenticate, או `5` to surface החסרה הרשאה. ראה [CLI recipes לagents](/he/agenteye/cli-recipes) עבור exit-code-handling דפוסים וJSON output צורות.
+
+---
+
+## הצעדים הבאים
+
+- **[CLI recipes לagents](/he/agenteye/cli-recipes)**: copy-paste query דפוסים, `jq` one-liners, `--fields` הקרנות, exit-code handling, וJSON output צורות, כתוב עבור agents coding driving ה-CLI.
+- **[CLI agent skill](/he/agenteye/cli-skill)**: חבילה זה CLI כמו installable Claude Code / Codex *skill* כך agent coding drives Failproof AI Observability מ-plain-English בקשות.
+- **[API keys](/he/agenteye/api-keys)**: דגם ההרשאה מאחוריי `keys create --add …`.
+- **[AI assistant](/he/agenteye/assistant)**: enabling ה-assistant כי `agent ask` דברים ל.

package/.next/standalone/docs-old/he/agenteye/codex-capture.mdx

@@ -0,0 +1,56 @@
+---
+---
+title: "Codex session capture"
+description: "Tail your team's local OpenAI Codex sessions into AgentEye as ordinary sessions and events — with no change to how they run Codex."
+---
+
+המהנדסים שלך כבר משתמשים ב-OpenAI Codex כל יום. Codex session capture מביא את הסשנים של קידוד אלה לתוך AgentEye כסשנים ואירועים רגילים, כך שתוכל לחפש, להשמיע שוב ולהעריך אותם לצד כל שאר מה שאתה צופה בו. זה משלים את [Python SDK](/he/agenteye/python-sdk): ה-SDK מחוממי אגנטים שאתה כותב, בעוד שזה תופס את עבודת ה-Codex שהצוות שלך כבר עושה — ללא שום שינוי בדרך שהם משתמשים בו.
+
+collector בעלי רקע קטן קורא Codex local session transcripts כשהם נכתבים ושולח אותם ל-AgentEye. collector אחד לכל מכונה תופס כל Codex surface מקומי בו זמנית — אין הגדרה לכל משטח.
+
+אותו collector תופס אגנטים אחרים גם — ראה [OpenClaw](/he/agenteye/openclaw-capture) ו-[Hermes](/he/agenteye/hermes-capture). הפוך כל אחד שאתה מריץ; collector יחיד יכול להשתמע למספר בו זמנית.
+
+---
+
+## מה זה תופס
+
+כל Codex surface שמריץ **locally** מייצר את אותו on-disk session transcripts, ו-collector תופס את כולם:
+
+- ה-Codex **CLI** ו-`codex exec`
+- ה-**VS Code / IDE extension**
+- ה-**desktop app**, כשהוא מריץ סשן locally
+
+כל Codex session הופך ל-AgentEye [session](/he/agenteye/sessions); ההודעות של user ו-assistant שלו, reasoning, tool calls, tool results, ו-token usage הופכים ל-[events](/he/agenteye/event-stream) התואמים. ה-surface שכל סשן הגיע ממנה (CLI, IDE, או desktop) נרשם, כך שתוכל להבחין ביניהם.
+
+> **Cloud sessions לא תופסים.** ה-desktop app בהולך וגדל מריץ סשנים בענן Codex ושומר רק את metadata שלהם במכונה — אין local transcript לקרוא. רק סשנים המתורגמים locally תופסים.
+
+---
+
+## הפוך זה פעיל
+
+Capture כבוי עד שתהפוך אותו פעיל. התקן את ה-collector עם API key שיש לו את הרשות `events:add` (ראה [API keys](/he/agenteye/api-keys)), והפוך את ה-Codex capture פעיל:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/FailproofAI/agenteye-collector/main/install.sh \
+  | sh -s -- --key <YOUR_API_KEY> --codex-enabled
+```
+
+זה מתקין את ה-collector, משנה אותו כ-background service, ומתחיל ללכוד. אשר שהוא פועל:
+
+```bash
+agenteye-collector health
+```
+
+בהפעלה הראשונה, הסשנים ה-Codex הקיימים שלך מתמלאים חזרה פעם אחת ופעילות חדשה ואז זורמת תוך שניות. הקבצים שלהם של Codex עצמם נקראים בלבד — אף פעם לא משונים, מועברים, או מחוקים — וכל סשן נשלח בדיוק פעם אחת, אפילו על פני restarts.
+
+---
+
+## היכן זה מופיע
+
+סשנים תפוסים מופיעים ב-**Sessions**, והאירועים שלהם בזרם **Events**, כמו כל אגנט אחר שאתה צופה בו — כך שה-[session replay](/he/agenteye/sessions), [search](/he/agenteye/queries), [evaluations](/he/agenteye/evaluations), ו-[alerts](/he/agenteye/alerts) כולם עובדים עליהם. סנן לפי ה-Codex agent כדי לראות אותם בעצמם.
+
+---
+
+## Privacy
+
+Codex transcripts מכילים את הסשן המלא — כולל command output, file contents, וכל מה ש-Codex קרא או כתב — ויכול להכיל סודות. סשנים תפוסים נשלחים כמו שהם, אז הפוך את ה-capture פעיל רק במכונות וצוותים שבהם ריכוז תוכן זה ב-AgentEye הוא מתאים, ותן ל-collector key בהיקף `events:add` בלבד. ראה [Security](/he/agenteye/security) להבנת איך הנתונים שלך מוחזקים מבודדים.

package/.next/standalone/docs-old/he/agenteye/concepts.mdx

@@ -0,0 +1,87 @@
+---
+title: "קונספטים"
+description: "אוצר המילים של Failproof AI Observability — אירועים, סשנים, הערכות, ביקורות, ממצאים, וכרונות — מוגדרים במקום אחד."
+---
+
+
+עמוד זה מגדיר את אוצר המילים שבו משתמשת Failproof AI Observability. אם מונח בגיד אחר לא מוכר לך, הוא מוגדר כאן. אתה לא חייב לקרוא את זה מתחילה עד סוף: התסקור, או חזור בעת שתיתקל במילה שאתה רוצה להבהיר.
+
+---
+
+## מודל הנתונים
+
+**Event**
+יחידת הנתונים הקטנה ביותר. אירוע אחד רושם צעד יחיד שהסוכן שלך ביצע: `tool_use`, `model_request`, `hook_completed`, `error`, וכדומה. הסוכן שלך פולט אירועים דרך ה-[Python SDK](/he/agenteye/python-sdk); הם מופיעים בזמן אמת בעמוד **Events**.
+
+**Session**
+ריצה אחת של סוכן, המזוהה על ידי `session_id`. סשן הוא כל האירועים החולקים את המזהה הזה, ממוקדים בשורה יחידה בעמוד **Sessions** וצויירו כגרף ביצוע בעמוד הפרטים שלו. סשן בדרך כלל מתחיל עם `agent_start` ומסתיים עם `agent_end`.
+
+**Agent**
+שחקן בעל שם בתוך ריצה, המזוהה על ידי `agent_id`. ריצה יכולה לכלול כמה סוכנים: מתכננן שיוצר תת-סוכן מסכם, לדוגמה. תת-סוכנים נושאים `parent_id`, וזה מה שמאפשר ל-Failproof AI Observability לצייר אותם בנתיבים שלהם בגרף הביצוע.
+
+**Environment**
+תווית למקום בו התרחשה הריצה: `production`, `staging`, `dev`. אתה מגדיר את זה פעם אחת כשאתה מגדיר את ה-SDK. כמעט כל עמוד בלוח הבקרה יכול לסנן לפי סביבה.
+
+**Context-window fill**
+אחוז חלון ההקשר של מודל שתגובה צרכה. Failproof AI Observability חוצצה אותו על אירועי `model_response` עבור מודלים שהוא מזהה, כך שגדילת ההנחיה והעימות קרוב יהיו גלויים ממש בזרם האירועים.
+
+---
+
+## איכות
+
+**Evaluation**
+ציון איכות לסשן שהסתיים, שמופק על ידי שירות ניקוד שאתה מריץ. הערכות הן אופציונליות: עד שאתה מחבר מערך, סשנים מתועדים אך לא מדורגים. כל הערכה יכולה להכיל כמה ציונים בעלי שם (לדוגמה `helpfulness`, `factuality`, `tool_efficiency`), כל אחד עם הערה קצרה של הנמקה. ראה [Evaluation suite](/he/agenteye/evaluation-suite).
+
+**Score key**
+שם של ממד אחד שמערך דיווח עליו, כגון `helpfulness`. התראות וביקורות יכולות להסתכל על מפתח ציון ספציפי לאורך זמן.
+
+**Evaluator**
+שירות הניקוד שלך. Failproof AI Observability משדרת את התמלול של ריצה שהסתיימה אליו ושומרת את הציונים שהוא מחזיר. זה לא משדר מערך ברירת מחדל; לוגיקת הניקוד היא שלך.
+
+---
+
+## מציאה ותיקון כשלים
+
+**Hook**
+מגן או תופעת לוואי שמסגרת הסוכן שלך מריצה סביב צעד: בדיקת בטיחות תוכן, עריכת PII, שמורת תקציב. Hooks פולטות אירועי `hook_triggered` / `hook_completed` עם `outcome` (allow, deny, modify), ומקבלות את עמוד ההתבוננות שלהן.
+
+**Alert rule**
+כלל שנכנס לפעולה כאשר מטרי חוצה סף שהגדרת: שיעור שגיאות, p95 latency, עלות אסימונים, או ציון מערך. כאשר כלל נכנס לפעולה, הוא פותח כרונה ומודיע לערוצים שבחרת (דוא"ל, Slack, webhook, בתוך לוח הבקרה). ראה [Alerts](/he/agenteye/alerts).
+
+**Incident**
+בעיה פתוחה שנוצרה כאשר כלל התראה נכנס לפעולה. לכרונות יש מחזור חיים (קבל, הקצה, פתור) וציר זמן פעילות שרושם כל פעולה. אתה יכול גם לפתוח אחת ידנית.
+
+**Audit**
+חקירה חוזרת (כל שעה עד שבועית) שחופרת את היומנים שלך *על פני* סשנים לחיפוש דפוסי כשל שלא כתבת כלל עבורם: אשכולות שגיאות, ציונים נמוכים, חריגות latency, לולאות קריאת כלים, וריצות שלא הסתיימו. איפה שהתראה שומרת על מטרי שאתה כבר יודע עליו, ביקורת אומרת לך למה להסתכל הבא. ראה [Audits](/he/agenteye/audits).
+
+**Finding**
+תוצאה אחת דורגת וגיבוי ראיות מריצת ביקורת. מציאה מכנה דפוס, מקשרת להפעלות המדויקות מאחוריו, וממלאה מחזור חיים בדיקה (קבל, פתור, השתק, בטל). Failproof AI Observability מסלקת מציאות פעם על פעם כך שדפוס ידוע מתעדכן במקום להצטבר.
+
+**The AI assistant**
+הצ'אט בתוך לוח הבקרה שמענה לשאלות על הסוכנים שלך באנגלית רגילה, על הנתונים שלך שלך. הוא קריאה בלבד כברירת מחדל; כל דבר שהוא יוצר (שאילתה שמורה, לוח בקרה) מאושר בשער, והוא לא יכול לעולם למחוק. ראה [AI assistant](/he/agenteye/assistant).
+
+---
+
+## הפעלה
+
+**Organization (tenant)**
+סביבת עבודה מבודדת. מופע אחד של Failproof AI Observability יכול להנחות ארגונים רבים, כל אחד עם המשתמשים, המפתחות, וההנתונים שלו. כל URL של לוח בקרה מסודר בהיקף של ה-slug הארגוני שלך (`/<org-slug>/…`).
+
+**Collector**
+`agenteye-collector`, הדמון הקל שרץ בכל מכונת סוכן, מקבץ את האירועים שה-SDK כותב לדיסק, ומשדר אותם לשרת.
+
+**API key**
+אסימון בהיקף זה מאמת לקוח כנגד השרת. מפתחות נושאים הרשאות דקיקות (לדוגמה `events:add` עבור הקולט, היקפי קריאה בלבד עבור מפתח לוח בקרה). ראה [API keys](/he/agenteye/api-keys).
+
+**Server**
+שירות ההשקעה וה-API. הוא משקיע אירועים, שומר מצב תפעולי בבסיסי הנתונים שלך, ומשרת את לוח הבקרה וה-CLI.
+
+**Dashboard**
+ממשק המשתמש של האינטרנט. כל עמוד מסודר לארגון ו קורא דרך API של השרת.
+
+---
+
+## צעדים הבאים
+
+- [Overview](/he/agenteye/overview): איך החלקים האלה מתאימים יחד.
+- [Observability](/he/agenteye/observability): משטחי ההתבוננות (Events, Sessions, Models, Tools, Hooks, Errors).

package/.next/standalone/docs-old/he/agenteye/dashboards.mdx

@@ -0,0 +1,46 @@
+---
+title: "לוחות בקרה"
+description: "הפוך את נתוני הסוכן הלייב שלך לתמונה משותפת אחת שכל הצוות שלך משקיף עליה."
+---
+
+
+הפוך את נתוני הסוכן הלייב שלך לתמונה משותפת אחת שכל הצוות שלך משקיף עליה. הצמד את השאילתות החשובות ביותר כגרפים, וכולם יפתחו את אותם מספרים במבט אחד, ללא הרצה חוזרת של שאילתה אחת.
+
+![לוח בקרה הבנוי משאילתות שמורות: קו אירועים לשעה, עמודות שגיאות לפי סוג, גרף שטח של השהיה, ואסימונים לפי מודל](/agenteye/images/dashboard-fleet.png)
+
+*לוח אחד, ארבע שאילתות שמורות: אירועים לשעה, שגיאות לפי סוג, השהיה, ואסימונים לפי מודל.*
+
+## כולם רואים את אותה אמת
+
+הפסק להדביק צילומי מסך לצ'אט והפסק להריץ את אותה שאילתה חמש פעמים ביום. לוח בקרה הוא לוח משותף ברמת הארגון שכל חבר בצוות שלך יכול לפתוח כדי לראות את אותו הנוף בדיוק. כאשר הנתונים הבסיסיים משתנים, הגרפים משתנים איתם, כך שהלוח תמיד עדכני ואף אחד לא מתווכח על מספרים ישנים.
+
+לוח הצי לעיל הוא צורה טובה להתחלה לפעולות יומיומיות:
+
+- שורת **אירועים-לשעה**, כך שתוכל לצפות בתפוקה ולתפוס ירידה פתאומית
+- עמודות **שגיאות-לפי-סוג**, כך שקטגוריות הכשל הגדולות ביותר שלך בולטות
+- גרף שטח של **השהיה**, כך שההאטות מופיעות לפני שמשתמשים מתלוננים
+- פירוט **אסימונים-לפי-מודל**, כך שהעלות נשארת בשדה הראייה
+
+תמצא את הלוחות שלך ב `/<org-slug>/dashboards`.
+
+## הצמד את השאילתות שכבר שמרת
+
+כל אריח מתחיל כשאילתה שמורה. בנה ושמור את השאילתה שחשובה לך בספריית [Queries](/he/agenteye/queries) (הגדרות מוגדרות מראש בנוסף לשלך, על האירועים וההערכות שלך), ואז הצמד אותה ללוח בקרה כגרף המתאים לנתונים: **שורה** לטרנדים לאורך זמן, **עמודות** להשוואת קטגוריות, **שטח** לנפח, או **עוגה** לפירוט חלקים.
+
+מכיוון שאריח הוא פשוט השאילתה השמורה שלך המוצגת כגרף, אין כלום שצריך להסנכרן ביד. עדכן את השאילתה פעם אחת וכל לוח בקרה שמשתמש בה יתעדכן גם כן.
+
+## צפה באיכות, לא רק בנפח
+
+נפח אומר לך שהסוכנים עסוקים. איכות אומרת לך שהם באמת עושים את העבודה. כוונן לוח בקרה ל[ניקוד ההערכות](/he/agenteye/evaluations) שלך ותקבל לוח שעוקב אחרי עד כמה טוב הרצות מתנהלות לאורך זמן, כך שרגרסיה באיכות תופיע כטבילה בגרף במקום הפתעה מלקוח.
+
+![לוח בקרה ממוקד איכות הבנוי משאילתות הערכה שמורות](/agenteye/images/dashboard-quality.png)
+
+*לוח איכות שומר את ניקוד ההערכות שלך בחזית, ממש לצד המספרים התפעוליים.*
+
+שמור לוח פעולות ולוח איכות זה לצד זה וצוות שלך יש מקום אחד לענות על שתי השאלות "האם זה עובד?" ו"האם זה טוב?", ללא שמישהו מריץ שוב שאילתה.
+
+## קשור
+
+- [Queries](/he/agenteye/queries): בנה ושמור את השאילתות שהופכות לאריחים שלך.
+- [Evaluations](/he/agenteye/evaluations): דרג את ההרצות שלך כך שתוכל לתרשים איכות לאורך זמן.
+- [Alerts](/he/agenteye/alerts): הפוך סף בכל אחד מהמדדים הללו לעמוד.

package/.next/standalone/docs-old/he/agenteye/error-tracking.mdx

@@ -0,0 +1,41 @@
+---
+title: "עקיבות שגיאות"
+description: "ראה כל כשל שהסוכנים שלך מייצרים במקום אחד, מקובצים כך שפיצוץ רועם נקרא כבעיה אחת."
+---
+
+
+ראה כל כשל שהסוכנים שלך מייצרים במקום אחד, מקובצים כך שפיצוץ רועם נקרא כבעיה אחת. אתה מקבל נתיב בלחיצה אחת מ"משהו אדום" לריצה המדויקת שהשתברה, ללא צורך בגלילה בזרם חי כדי למצוא אותה.
+
+![עמוד השגיאות: היסטוגרמה של כשלים לאורך זמן מעל שורות שגיאה אדומות מקובצות, כל אחת עם כפתור "+התראה" בלחיצה אחת](/agenteye/images/errors.png)
+*עמוד השגיאות: היסטוגרמה של כשלים לאורך זמן, כשכשלים חוזרים מקופלים לשורה אחת לכל תקרית.*
+
+## כל כשל, כבר אסוף עבורך
+
+כאשר סוכן משתבר, לא צריך לגלול בזרם אירועים חי בתקווה לתפוס את השורות האדומות לפני שהן גללו. עמוד **השגיאות** עושה את האיסוף בשבילך. הוא אוסף הכל שלוח המחוונים היה צובע באדום למשטח ניתוח אחד, כך שהדבר הראשון שאתה רואה הוא מה נכשל, לא היכן ללכת לחפש אותו.
+
+וזה תופס יותר מהברורות. לצד אירועי `error` מפורשים, Failproof AI Observability משטח גם את הכשלים השקטים: כל `tool_result`, `hook_completed`, או `agent_end` שהמטען שלו נושא כשל מופיע כאן. כלי שהחזיר שגיאה, או hook שיצא בצורה גרועה, כבר לא מחמק אליך רק מכיוון שלא הטילו חריג חזק.
+
+על פני החלק העליון, היסטוגרמה מתווה שגיאות לאורך זמן. מבט אחד אומר לך האם זה זרימה עמוקה קבועה או דוקן שהתחיל לפני כמה דקות, כך שאתה יודע מיד האם להשליך מה שאתה עושה.
+
+כמו כל משטח צפייה, עמוד השגיאות מסוגנן לארגון שלך ומסננים לפי טווח תאריכים, סביבה, סוכן וסשן. זה אומר שאתה יכול לקחת רשימת קfleet רחבה ולהצמצם אותה לסוכן אחד או סביבה אחת שאכפת לך בעצם.
+
+## תקרית אחת, לא מאה שורות זהות
+
+תלות אחת שבורה יכולה להדליק את אותה שגיאה מאות פעמים בדקה. נותרה גולמית, זו קיר של קווים כמעט זהים שקוברים את הדבר האחד שאתה בעצם צריך לראות.
+
+Failproof AI Observability מקפל כשלים חוזרים השותפים לאותו סשן וסוג שגיאה לשורה אחת. פיצוץ נקרא כתקרית אחת. בסוף אתה סופר בעיות, לא שורות log, והאות שחשובה נשארת על גבי במקום להיות טבולה בנפחה שלה.
+
+## מ"משהו אדום" לאירוע המדויק
+
+לחץ על כל שורה כדי להנחות ישר בתוך הסשן של הריצה הזו, ממוקם על האירוע המדויק שנכשל. אין העתקת מזהי סשן, אין גלילה כדי לחפש את הרגע שזה השתבר: אתה מגיע לזה, כשגרף הביצוע המלא במבט אחד כך שאתה יכול לראות מה הסוכן עשה בשניות לפני שזה השתבר.
+
+אם יש לך `alerts:write`, כל שורה גם נושאת כפתור **+התראה**. לחץ עליו ו-Observability פותח כלל התראה חדש כבר מלא כדי לתפוס את אותו כשל שוב. התקרית שזה עתה ערכת ניתוח הופכת לזו שמעמודה אותך בפעם הבאה, במקום להפתיע אותך פעמיים.
+
+**היכן למצוא זה:** עמוד **השגיאות** חי בסעיף הצפייה של לוח המחוונים, ב `/<org-slug>/errors`.
+
+## קשור
+
+- [התראות](/he/agenteye/alerts): הפוך כל כשל לכלל עמודה.
+- [תקריות](/he/agenteye/incidents): עקוב אחר התראה שנורה מפתיחה לפתרון.
+- [סשנים](/he/agenteye/sessions): פתח את הריצה המלאה מאחורי כל שגיאה.
+- [ביקורות](/he/agenteye/audits): תן ל-Observability למצוא דפוסי כשל על פני הריצות שלך בשבילך.