failproofai 1.0.1-beta.0 → 1.0.1

package/.next/standalone/docs-old/fr/agenteye/cli-recipes.mdx

@@ -0,0 +1,179 @@
+---
+title: "Recettes CLI pour agents"
+description: "Patterns de requêtes à copier-coller et recettes jq qui transforment les données de session, d'événement et d'évaluation en quelque chose qu'un script ou un agent de codage peut automatiser."
+---
+
+
+Récupérez les données de sessions, d'événements et d'évaluations (et déclenchez des réévaluations) directement depuis un script ou un agent de codage, avec du JSON propre sur stdout qui s'enchaîne directement dans `jq`. Ces recettes transforment les données de Failproof AI Observability en quelque chose qu'un utilisateur de terminal ou un agent de codage IA (Claude Code, Cursor) peut interroger et automatiser, sans cliquer dans le tableau de bord.
+
+Les patterns ci-dessous sont prêts à être copiés-collés pour la CLI Failproof AI Observability (`agenteye`). Pour l'installation, l'authentification et la liste complète des options, consultez [CLI](/fr/agenteye/cli) ; exécutez `agenteye -h` ou `agenteye <command> -h` pour l'aide intégrée.
+
+## Règles d'or
+
+1. **Les options globales vont *avant* la commande.** `agenteye --json sessions` est correct ; `agenteye sessions --json` ne l'est pas. Les globales sont `--json`, `--base-url`, `--org`, `--token`, `--insecure`/`--secure`, `--timeout`, `--quiet`, `--no-color`.
+2. **Passez `--json` dès que vous analysez la sortie.** Les données vont sur **stdout** en JSON ; les statuts lisibles par l'humain et les erreurs vont sur **stderr**, donc stdout reste propre pour être transmis à `jq`.
+3. **Basez-vous sur le code de sortie**, pas sur le texte de stderr : `0` ok · `1` erreur inattendue · `2` arguments invalides · `3` tableau de bord inaccessible · `4` non connecté ou session expirée · `5` permission manquante · `6` ressource introuvable.
+4. **Explorez avec `-h`.** Chaque commande documente ses filtres, les formats de valeurs et la forme JSON.
+
+## Configuration initiale
+
+```bash
+export AGENTEYE_DASHBOARD_URL=https://agenteye.example.com   # pour ne pas répéter --base-url
+agenteye login --email you@example.com                       # collez le code reçu par email ; valable ~24h
+```
+
+## Vérifier l'authentification avant de travailler
+
+`whoami` ne renvoie jamais d'erreur en cas de session manquante ou expirée ; il signale `logged_in:false` à la place, ce qui permet à un agent de sonder l'état d'authentification en toute sécurité. (Il peut tout de même sortir avec un code non nul si aucune URL de base n'est définie ou si le tableau de bord est inaccessible.)
+
+```bash
+if [ "$(agenteye --json whoami | jq -r .logged_in)" != "true" ]; then
+  echo "Not authenticated. Run: agenteye login" >&2; exit 1
+fi
+```
+
+## Trouver les sessions en échec ou avec un score bas
+
+```bash
+# sessions des dernières 24h dont l'évaluation est en erreur
+agenteye --json sessions --since 24h --status error | jq -r '.sessions[].session_id'
+
+# évaluations avec un score helpfulness <= 0.5, pour un agent donné
+agenteye --json evals --agent-id checkout-bot --score helpfulness:..0.5 \
+  | jq '.evaluations[] | {session_id, scores}'
+```
+
+Le filtrage par score s'effectue sur **`evals`**, pas sur `sessions`. `--score KEY:MIN..MAX` est répétable et combiné par ET ; chaque borne est optionnelle (`..0.5` signifie ≤ 0.5, `0.9..` signifie ≥ 0.9). Vous pouvez passer jusqu'à 20 filtres de score par requête ; au-delà, le serveur renvoie HTTP 400. `sessions` partage les filtres `--env`, `--status`, `--agent-id`, `--session-id` et de plage temporelle avec `evals`, mais ne dispose pas de `--score`.
+
+## Lire une session de bout en bout
+
+Il n'existe pas de commande `session show` unique. Combinez la trace d'événements avec l'évaluation de la session :
+
+```bash
+# la dernière évaluation de la session (statut + scores)
+agenteye --json evals --session-id run-001 | jq '.evaluations[0] | {status, scores}'
+
+# tous les événements de l'exécution (augmentez --limit pour un balayage complet)
+agenteye --json events --session-id run-001 --all --limit 1000 | jq '.events[] | {ts, event_type}'
+
+# uniquement les appels d'outils dans une session (--full est requis pour obtenir le payload brut)
+agenteye --json events --full --session-id run-001 --event-type tool_use,tool_result --all \
+  | jq '.events[].payload'
+```
+
+> **Note :** Par défaut, `events` lit un flux rapide sans payload. Chaque événement porte un résumé `summary` calculé côté serveur ainsi que des indicateurs comme `is_error` et les compteurs de tokens, mais `payload` est renvoyé sous la forme `{}`. Pour récupérer le payload brut, ajoutez `--full` (ou `--fields payload`). Le flux complet est plus lent à grande échelle, donc limitez-le : associez `--full` à un seul `--session-id`.
+
+## Tout récupérer (pagination)
+
+Les résultats sont triés du plus récent au plus ancien et paginés par curseur.
+
+```bash
+# en une fois : récupère jusqu'à 500 lignes par pages de 200
+agenteye --json events --session-id run-001 --limit 500 --all > events.json
+
+# pagination manuelle : réinjectez next_cursor
+page=$(agenteye --json events --limit 100)
+cursor=$(echo "$page" | jq -r '.next_cursor // empty')
+[ -n "$cursor" ] && agenteye --json events --limit 100 --cursor "$cursor"
+```
+
+## Réduire la sortie avec --fields
+
+Restreignez les clés (dans le tableau et avec `--json`) pour limiter ce qu'un agent doit lire.
+
+```bash
+agenteye --json sessions --since 7d --fields session_id,status,scores | jq -c '.sessions[]'
+agenteye --json events --session-id run-001 --fields ts,event_type --all
+```
+
+Les noms de champs inconnus sont rejetés (sortie `2`) avec la liste des valeurs valides — un moyen simple de découvrir les noms de champs.
+
+## Découvrir les valeurs de filtre valides
+
+```bash
+agenteye --json list envs | jq -r '.values[]'           # valeurs pour --env
+agenteye --json list tools | jq -r '.values[]'          # noms d'outils ; aussi agents, models, event_types, …
+agenteye --json list score_filters | jq -r '.values[]'  # KEY valide pour --score KEY:MIN..MAX
+```
+
+## Choisir son organisation (multi-tenant)
+
+Si vous appartenez à plusieurs organisations, choisissez le tenant actif à la connexion (il est sauvegardé) :
+
+```bash
+agenteye login --org acme --email you@corp.com   # définit le tenant en même temps que la connexion
+agenteye --json orgs list | jq -r '.orgs[].org_slug'
+agenteye --org globex --json sessions --since 24h   # remplace pour une seule commande
+```
+
+Une connexion multi-org sans `--org` se termine avec un code non nul et affiche les organisations disponibles.
+
+## Créer une clé API pour le SDK/collecteur
+
+```bash
+# le secret est affiché UNE SEULE FOIS ; avec --json, c'est le champ .key
+key=$(agenteye --json keys create ci-bot --add events:read.add | jq -r '.key')
+agenteye keys regenerate ci-bot --yes    # rotation ; agenteye keys disable ci-bot --yes pour révoquer
+```
+
+## Exécuter une requête enregistrée ou ad hoc
+
+```bash
+agenteye --json query run --sql "select count(*) from analytics.events" | jq '.rows'
+agenteye --json query run errs --arg prod | jq '.rows'   # une requête enregistrée + un $1 positionnel
+```
+
+## Traiter un incident de manière non interactive
+
+```bash
+id=$(agenteye --json incidents list --state firing | jq -r '.incidents[0].id')
+agenteye incidents ack "$id"
+agenteye incidents assign "$id" --assignee you@corp.com
+agenteye incidents resolve "$id" --yes
+```
+
+> **Note :** Les mutations ignorent automatiquement leur invite de confirmation sous `--json` ou quand stdin n'est pas un TTY, afin que les agents ne restent jamais bloqués ; passez `--yes`/`-y` pour l'ignorer explicitement ailleurs.
+
+## Gestion des codes de sortie dans un script
+
+```bash
+out=$(agenteye --json sessions --since 1h) || code=$?
+case "${code:-0}" in
+  0) echo "$out" | jq '.sessions | length' ;;
+  4) echo "Session expired - run 'agenteye login'." >&2 ;;
+  5) echo "Missing permission (ask an admin for evaluations:read)." >&2 ;;
+  3) echo "Dashboard unreachable - check the URL." >&2 ;;
+  *) echo "Unexpected error (exit ${code})." >&2 ;;
+esac
+```
+
+## Formes de la sortie JSON
+
+| Commande | JSON sur stdout (avec `--json`) |
+|---|---|
+| `whoami` | `{"logged_in": true, "id", "email", "is_instance_admin", "active_org", "permissions": [...], "memberships": [...]}` ou `{"logged_in": false}` |
+| `orgs list` | `{"active_org", "orgs": [{"org_slug","org_name","permission_set","permissions"}]}` |
+| `events` | `{"events": [...], "next_cursor": <cursor or null>}` |
+| `evals` | `{"evaluations": [...], "next_cursor": <cursor or null>}` |
+| `sessions` | `{"sessions": [...], "next_cursor": <cursor or null>}` |
+| `errors` | `{"errors": [...], "next_cursor": <cursor or null>}` |
+| `list <kind>` | `{"kind", "values": [...]}` |
+| `keys list` / `keys create` | `{"keys": [...]}` / `{id, name, permissions, created_at, key}` (`key` affiché une seule fois) |
+| `query run` | `{columns: [{name,type}], rows: [[...]], truncated, elapsed_ms}` |
+| `users list` / `settings list` | `{"users": [...]}` / `{"settings": [...]}` |
+| `alerts list` / `incidents list` | `{"alerts": [...]}` / `{"incidents": [...]}` |
+| create/update/delete (toute commande) | l'objet ressource, ou `{"deleted": true, "id"}` pour les suppressions |
+| échec (toute commande, avec `--json`) | `{"error": "...", "exit_code": <n>, "status"?: <http>, "hint"?: "..."}` sur stdout |
+
+- Chaque élément **event** (`events`) : `id, session_id, agent_id, event_type, ts, payload, environment, summary, is_error, error_type, output_tokens, context_window, context_fill`. Notez que `payload` vaut `{}` sauf si vous demandez le flux complet avec `--full` (ou `--fields payload`).
+- Chaque élément **evaluation** (`evals`) : `id, session_id, agent_id, environment, status, scores, reasoning, summary, error, attempt_count, duration_ms, completed_at, created_at`.
+- Chaque élément **session** (`sessions`) : `session_id, agent_id, environment, status, scores, event_count, started_at, last_event_at, first_event_id, last_event_id, latest_evaluation`.
+
+Le `--fields` de chaque commande accepte exactement les noms de champs de ses propres éléments. L'ensemble diffère entre `sessions` et `evals`, donc un nom valide pour l'un peut être rejeté par l'autre.
+
+## Étapes suivantes
+
+- [CLI](/fr/agenteye/cli) : installation, authentification et référence complète des options pour chaque commande.
+- [Compétence CLI pour agent](/fr/agenteye/cli-skill) : regroupez ces recettes en une compétence que votre agent de codage peut charger.
+- [Clés API](/fr/agenteye/api-keys) : créez et délimitez les clés avec lesquelles la CLI, le SDK et le collecteur s'authentifient.
+- [SDK Python](/fr/agenteye/python-sdk) : envoyez des événements dans Failproof AI Observability pour que ces recettes aient des données à interroger.

package/.next/standalone/docs-old/fr/agenteye/cli-skill.mdx

@@ -0,0 +1,159 @@
+---
+title: "Compétence d'agent CLI Failproof AI Observability"
+description: "Demandez à votre agent de développement « est-ce que quelque chose est cassé aujourd'hui ? » et laissez-le répondre à partir de vos données Failproof AI Observability en direct, sans aucune commande à mémoriser."
+---
+
+
+Demandez à votre agent de développement *« est-ce que quelque chose est cassé aujourd'hui ? »* et laissez-le répondre à partir de vos données Failproof AI Observability en direct, sans aucune commande à mémoriser. La **compétence CLI Failproof AI Observability** (`agenteye-cli`) est une *compétence d'agent* : un petit dossier d'instructions qu'un agent de développement comme Claude Code ou Codex charge à la demande. Elle apprend à l'agent à piloter votre déploiement Observability via le [CLI `agenteye`](/fr/agenteye/cli) à partir de requêtes en langage naturel comme *« donne à la CI une clé qui ne peut qu'envoyer des événements »* ou *« acquitte l'incident en cours et assigne-le moi »*.
+
+Il **ne s'agit pas** d'un service ni d'un binaire distinct ; il n'y a rien à déployer. La compétence s'appuie sur le CLI déjà installé : l'agent exécute `agenteye --json …`, analyse le JSON propre renvoyé et vous répond en texte clair. Tout ce qu'elle peut faire, vous pourriez le faire vous-même en tapant les mêmes commandes.
+
+---
+
+## Relation avec les autres interfaces Failproof AI Observability
+
+Failproof AI Observability vous offre quatre façons d'accéder aux mêmes données et contrôles. Elles se complètent :
+
+| Interface | Description | Où elle s'exécute | Utilisez-la quand |
+|---|---|---|---|
+| **[CLI](/fr/agenteye/cli)** | La référence des commandes et options pour `agenteye` | Votre terminal | Vous voulez exécuter ou scripter une commande précise |
+| **[Recettes CLI](/fr/agenteye/cli-recipes)** | Modèles `jq`/pipeline à copier-coller | Votre terminal / scripts | Vous intégrez le CLI dans de l'automatisation |
+| **Compétence CLI** (ce document) | Une porte d'entrée en langage naturel sur le CLI | Votre agent de développement, sur votre poste | Vous voulez *poser la question* et laisser l'agent choisir la commande |
+| **[Compétence Evaluator](/fr/agenteye/evaluator-skill)** | Une compétence jumelle qui conçoit et construit votre service de scoring | Votre agent de développement, sur votre poste | Vous voulez *produire* des scores d'évaluation plutôt que les lire |
+| **[Compétence SDK Python](/fr/agenteye/python-sdk-skill)** | Une compétence jumelle qui instrumente votre agent pour qu'il émette de la télémétrie | Votre agent de développement, sur votre poste | Vous voulez que votre agent *produise* les événements que cette compétence lit |
+| **[Assistant IA intégré au tableau de bord](/fr/agenteye/assistant)** | Un chat intégré au tableau de bord | Côté serveur (dans le tableau de bord) | Vous voulez des questions-réponses sur vos données directement dans le tableau de bord |
+
+La compétence elle-même n'a aucun privilège propre ; elle se contente de transformer vos mots en appels CLI qui s'exécutent en tant que vous :
+
+```mermaid
+flowchart TD
+    YOU["vous : 'acquitte l'incident en cours'"] --> AGENT["agent de développement (Claude Code / Codex)<br/>charge la compétence agenteye-cli"]
+    AGENT --> CLI["agenteye --json incidents ack ..."]
+    CLI -->|votre session CLI authentifiée| API["API du tableau de bord Observability"]
+```
+
+### vs. l'assistant IA intégré au tableau de bord : une distinction importante
+
+Ce sont deux outils différents avec des périmètres d'action très différents :
+
+- L'**assistant IA intégré au tableau de bord** ([assistant IA](/fr/agenteye/assistant)) est un chat intégré au tableau de bord, alimenté par le service d'agent. Il est **en lecture seule avec création soumise à validation** : il peut rédiger des requêtes sauvegardées et des tableaux de bord, mais chaque écriture s'arrête pour demander votre approbation explicite, et il ne supprime jamais rien. Il est conditionné à la permission `agent:use` et ne voit jamais que les données de l'organisation que vous consultez.
+- La **compétence CLI** s'exécute sur *votre* poste, dans *votre* agent de développement, et pilote le CLI `agenteye` en tant que **vous**. Elle peut utiliser **toute la surface du CLI, y compris les mutations** (créer/alterner/désactiver des clés API, modifier les paramètres d'organisation, résoudre des incidents, supprimer des requêtes sauvegardées), limitée uniquement par les permissions de votre connexion CLI. Traitez-la exactement avec la même prudence que si vous tapiez ces commandes vous-même.
+
+---
+
+## Prérequis
+
+1. Le **CLI `agenteye` installé** et dans le `PATH` (voir la référence [CLI](/fr/agenteye/cli) : `pipx install agenteye`).
+2. Votre **URL de tableau de bord** configurée (`AGENTEYE_DASHBOARD_URL`, ou l'agent passe `--base-url`).
+3. Une **session connectée** : exécutez `agenteye login` vous-même au préalable. La compétence **ne peut pas** effectuer la connexion par code à usage unique envoyé par e-mail à votre place ; elle vous indiquera d'exécuter `agenteye login` si la session est manquante ou expirée (code de sortie CLI `4`).
+
+---
+
+## Où la trouver
+
+La compétence est publiée dans la collection publique de compétences de Failproof AI :
+
+**[github.com/FailproofAI/skills](https://github.com/FailproofAI/skills)** → [`skills/agenteye-cli/`](https://github.com/FailproofAI/skills/tree/main/skills/agenteye-cli)
+
+Rien n'est restreint — le dépôt est public et la compétence n'a besoin d'aucun identifiant propre, car elle ne fait que piloter le CLI `agenteye` **public** contre *votre* tableau de bord, en utilisant la session avec laquelle *vous* vous êtes connecté. Vous n'avez besoin de la demander à personne.
+
+Notez qu'elle est distribuée dans son propre dossier et **n'est pas** incluse dans le paquet `pipx install agenteye`, donc ne la cherchez pas là.
+
+## Installation de la compétence
+
+Le chemin le plus rapide est le CLI [`skills`](https://skills.sh), qui récupère le dossier et le place là où votre agent le cherche :
+
+```bash
+# Claude Code, ce projet uniquement
+npx skills add FailproofAI/skills --skill agenteye-cli -a claude-code
+
+# tous les projets (installe dans ~/.claude/skills/)
+npx skills add FailproofAI/skills --skill agenteye-cli -a claude-code -g --copy
+
+# Codex à la place
+npx skills add FailproofAI/skills --skill agenteye-cli -a codex
+```
+
+Gérez-la ensuite comme n'importe quelle autre compétence :
+
+```bash
+npx skills list -a claude-code      # ce qui est installé
+npx skills update agenteye-cli      # récupérer la dernière version
+npx skills remove agenteye-cli      # la supprimer
+```
+
+Vous préférez installer manuellement ? Une compétence d'agent est simplement un dossier contenant un `SKILL.md` (plus des références optionnelles), donc la copier fonctionne également :
+
+- **Claude Code** : placez le dossier `agenteye-cli/` dans `~/.claude/skills/` (tous les projets) ou `<votre-repo>/.claude/skills/` (ce dépôt uniquement). Claude Code la détecte automatiquement — vérifiez avec la liste `/skills`, ou posez simplement une question correspondant à sa description.
+- **Codex (OpenAI)** : Codex lit le même `SKILL.md`. Le fichier `agents/openai.yaml` inclus définit `allow_implicit_invocation: true`, donc Codex sélectionne automatiquement la compétence quand une tâche correspond ; sinon, invoquez-la explicitement avec `$agenteye-cli`.
+
+---
+
+## Sécurité : les mutations ne demandent PAS confirmation quand un agent exécute le CLI
+
+> **Avertissement :** Lisez ceci avant de laisser un agent effectuer des modifications.
+
+Le CLI `agenteye` demande normalement *« êtes-vous sûr ? »* avant une action destructive. Il **saute automatiquement cette confirmation dès qu'il n'est pas attaché à un terminal (ce qui correspond exactement à la façon dont un agent de développement l'exécute), et `--json` la saute également.** Ainsi, la demande de confirmation **ne se déclenchera pas** pour l'agent.
+
+La compétence est conçue pour compenser : elle est instruite d'énoncer la commande exacte qu'elle va exécuter et d'obtenir votre **accord explicite avant tout changement d'état**. Maintenez cette discipline. Lorsque vous pilotez Failproof AI Observability via un agent, *vous* êtes l'étape de confirmation. Les commandes modifiant l'état à surveiller :
+
+- `keys create` / `update` / `disable` / `regenerate`
+- `users create` / `update` / `disable` / `enable`
+- `settings set`
+- `alerts create` / `update` / `delete` / `test`
+- les sous-commandes `incidents` en écriture : `ack` / `assign` / `resolve` / `open` / `comment-add` / `comment-delete` / `subscribe` / `unsubscribe`
+- `query create` / `update` / `delete`
+- `agent rename` / `delete`
+- `orgs switch`
+
+Tout ce qui relève de la section **Observe** (`events`, `sessions`, `evals`, `errors`, `list`, `whoami`, `orgs list/current/perms`) est en lecture seule et ne modifie rien.
+
+L'agent agissant en tant que **vous**, il ne peut faire que ce que votre connexion est autorisée à faire ; les permissions sont résolues **par organisation** (voir [Clés API](/fr/agenteye/api-keys)). Une commande pour laquelle vous n'avez pas la permission renvoie le code de sortie `5` avec le nom exact de la permission manquante, ce qui permet à l'agent de vous indiquer précisément ce qu'il faut demander à un administrateur plutôt que d'échouer silencieusement.
+
+---
+
+## Ce que vous pouvez lui demander
+
+Voici à quoi ressemble un vrai échange — une lecture, puis une modification qui attend votre accord :
+
+```text
+vous   ▸ Est-ce que quelque chose est cassé ces dernières 24 heures ?
+
+agent  ▸ Exécution : agenteye --json errors --since 24h --aggregate
+         3 types d'erreurs dans les dernières 24h. Le plus fréquent est TimeoutError
+         (18 occurrences, toutes sur le checkout-agent), puis RateLimited (5).
+         Voulez-vous les sessions en échec pour TimeoutError ?
+
+vous   ▸ Donne à la CI une clé qui ne peut qu'envoyer des événements.
+
+agent  ▸ Cela crée une clé API. Je vais exécuter :
+           agenteye keys create ci --add events:add
+         D'accord pour continuer ?
+
+vous   ▸ oui
+
+agent  ▸ Fait. Clé « ci » créée avec events:add uniquement.
+         Le secret n'est affiché qu'une seule fois, enregistrez-le maintenant. Je ne peux pas le réafficher.
+```
+
+La compétence associe chaque intention exprimée en langage naturel à la bonne commande `agenteye`, en découvrant d'abord les valeurs valides (`list <kind>`, `whoami`) pour ne pas deviner, et en énonçant la commande exacte avant tout changement. Quelques exemples supplémentaires :
+
+- *« Est-ce que quelque chose est cassé / en échec ces dernières 24 heures ? »* → `errors --since 24h --aggregate`, puis un récapitulatif.
+- *« Pourquoi la session `run-001` a-t-elle échoué ? »* → `events --session-id run-001 --all` + `evals --session-id run-001`.
+- *« Comment évolue la qualité cette semaine ? »* → `evals --aggregate --since 7d`, puis exploration des exécutions avec les scores les plus bas.
+- *« Donne à la CI une clé qui ne peut qu'envoyer des événements. »* → `keys create ci --add events:add` (elle énonce la commande, puis la crée et capture le secret à usage unique).
+- *« Qui a accès ? Mets Dana en lecture seule. »* → `users list` → `users update dana@… --permission-set read-only` (après confirmation de votre part).
+- *« Acquitte l'incident en cours et assigne-le moi. »* → `incidents list --state firing` → `incidents ack <id>` / `incidents assign <id> vous@…`.
+
+Pour les commandes exactes, les options et les structures JSON correspondantes, consultez la référence [CLI](/fr/agenteye/cli) et les [recettes CLI pour agents](/fr/agenteye/cli-recipes).
+
+---
+
+## Prochaines étapes
+
+- **[CLI](/fr/agenteye/cli)** : référence complète des commandes et options pour `agenteye`.
+- **[Recettes CLI pour agents](/fr/agenteye/cli-recipes)** : modèles `jq` à copier-coller et gestion des codes de sortie.
+- **[Compétence d'agent Evaluator](/fr/agenteye/evaluator-skill)** : la compétence jumelle, pour construire l'évaluateur dont les scores sont lus par `agenteye evals`.
+- **[Compétence d'agent SDK Python](/fr/agenteye/python-sdk-skill)** : la compétence jumelle, pour instrumenter un agent afin qu'il émette la télémétrie lue par `agenteye`.
+- **[Assistant IA](/fr/agenteye/assistant)** : l'assistant intégré au tableau de bord (à ne pas confondre avec cette compétence en ligne de commande).
+- **[Clés API](/fr/agenteye/api-keys)** : le modèle de permissions par organisation qui délimite ce que la compétence peut faire.