# Politiques

**Politiques** décider ce qui se passe quand un [point de contrôle](https://maetra.io/fr/docs/govern-api/checkpoints) est créé: s'ils s'appliquent à une action, et comment elle est gérée - auto-approbation, auto-blocage, ou route pour les approbateurs avec un quorum et un délai.

Les politiques sont écrites dans le tableau de bord. Au-dessus de l'API ils sont **en lecture seule** — vous dressez la liste de l'ensemble actif afin qu'un agent (ou votre outillage) puisse voir quels contrôles s'appliquent.

### Modes d'action

Govern soutient deux modes de politique :

| Mode | Utilisez-le pour | Comportement au cours de l'exécution |
| ---- | ---------- | ---------------- |
| Configuration exacte de la politique | Des modèles d'action connus comme les remboursements, les transferts, les changements d'enregistrement, les messages sortants ou les exportations de données. | Maetra vérifie les conditions de la politique sauvegardée, puis applique l'approbation configurée, bloc, quorum, timeout, et les paramètres de notification. |
| Renseignements sur la décision | Actions où le risque dépend du contexte d'exécution au lieu d'une condition exacte. | Maetra évalue le point de contrôle en fonction des paramètres de la politique et peut autoriser, demander l'approbation ou bloquer en fonction du mode sélectionné. |

Le renseignement de décision est activé sur la politique dans le tableau de bord. API et MCP appelants n'envoient pas un séparé `decision_intelligence` sur le terrain. Ils envoient la même charge utile de point de contrôle, et les contrôles de politique active si Maetra utilise des conditions exactes ou des renseignements de décision d'exécution.

### Énumérer les politiques actives

`GET /v1/policies/active` — demande une portée `govern:policies:read`.

#### cURL

```bash
curl "https://api.maetra.io/v1/policies/active" \
  -H "Authorization: Bearer $MAETRA_API_KEY"
```

#### JavaScript

```javascript
const res = await fetch("https://api.maetra.io/v1/policies/active", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.MAETRA_API_KEY}`,
  },
});
if (!res.ok) throw new Error(`Maetra API ${res.status}`);
const data = await res.json();
console.log(data);
```

#### TypeScript

```typescript
const res = await fetch("https://api.maetra.io/v1/policies/active", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.MAETRA_API_KEY}`,
  },
});
if (!res.ok) throw new Error(`Maetra API ${res.status}`);
const data = (await res.json());
```

#### Python

```python
import os, requests

res = requests.get(
    "https://api.maetra.io/v1/policies/active",
    headers={"Authorization": f"Bearer {os.environ['MAETRA_API_KEY']}"},
)
res.raise_for_status()
print(res.json())
```

#### Rust

```rust
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = std::env::var("MAETRA_API_KEY")?;
    let client = reqwest::Client::new();
    let res = client
        .get("https://api.maetra.io/v1/policies/active")
        .bearer_auth(&key)
        .send()
        .await?;
    let data: serde_json::Value = res.json().await?;
    println!("{data:#}");
    Ok(())
}
```

#### C++

```cpp
#include <curl/curl.h>
#include <cstdlib>
#include <string>

int main() {
    CURL* curl = curl_easy_init();
    std::string auth = "Authorization: Bearer " + std::string(std::getenv("MAETRA_API_KEY"));
    struct curl_slist* headers = nullptr;
    headers = curl_slist_append(headers, auth.c_str());
    curl_easy_setopt(curl, CURLOPT_URL, "https://api.maetra.io/v1/policies/active");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_perform(curl);   // response is written to stdout by default
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    return 0;
}
```

#### Java

```java
import java.net.URI;
import java.net.http.*;

var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.maetra.io/v1/policies/active"))
    .header("Authorization", "Bearer " + System.getenv("MAETRA_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
```


#### Réponse

```json
{
  "policies": [
    {
      "id": "pol_2Kd9",
      "name": "High-value transfers",
      "description": "Route transfers over $1,000 to finance.",
      "is_default": false,
      "autonomy_gate": "L3",
      "match_tree": { "all": [ { "field": "action", "eq": "transfer_funds" } ] },
      "on_match": "require_approval",
      "evaluation_mode": "exact_policy",
      "decision_intelligence_mode": null,
      "approver_mode": "any",
      "quorum_required": 1,
      "timeout_seconds": 300,
      "on_timeout": "reject",
      "notifications": { "email": true, "slack_channel": true, "slack_dm": false },
      "version": 4,
      "updated_at": "2026-07-01T09:12:00.000Z"
    }
  ]
}
```

| Champ | Type | Désignation des marchandises |
| ---------------------- | ------- | -------------------------------------------------------------------- |
| `id` | chaîne de caractères | Numéro d'identification politique. Passer à `policy_ids` sur un point de contrôle pour l'évaluation de la portée. |
| `name` / `description` | chaîne de caractères | Des étiquettes qui font face à l'homme. |
| `is_default` | booléen | S'il s'agit d'un espace de travail par défaut. |
| `autonomy_gate` | chaîne de caractères | Niveau d'autonomie (`L0`–`L5`) à/au-dessus de ce qu'il engage. |
| `match_tree` | objet | L'arbre d'état décide s'il s'applique. |
| `on_match` | chaîne de caractères | Que faire lorsqu'il s'applique (p. ex. `require_approval`, `block`). |
| `evaluation_mode` | chaîne de caractères | `exact_policy` ou `decision_intelligence`. |
| `decision_intelligence_mode` | chaîne de caractères \| null | Mode d'intelligence de la décision lorsque `evaluation_mode` est `decision_intelligence`. |
| `approver_mode` | chaîne de caractères | Comment les ordonnateurs sont-ils sélectionnés (p. ex. `any`). |
| `quorum_required` | entier | Les approbations doivent être approuvées. |
| `timeout_seconds` | entier | Combien de temps attendre le quorum. |
| `on_timeout` | chaîne de caractères | Que faire si le délai expire (par exemple: `reject`). |
| `notifications` | objet | `email`, `slack_channel`, `slack_dm` les booléens. |
| `version` | entier | Incréments sur chaque édition. |
| `updated_at` | chaîne de caractères | Horodatage ISO 8601. |

### Ébauche d'un point de contrôle sur des politiques spécifiques

Par défaut, un point de contrôle est évalué par **Tous** les politiques actives applicables. Les politiques relatives aux personnes handicapées et aux personnes supprimées ne sont pas évaluées. Passons `policy_ids` (ou `policy_group_ids`) limiter l'évaluation à des politiques précises ou à des politiques d'intelligence décisionnelle:

```json
{ "action": "transfer_funds", "policy_ids": ["pol_2Kd9"] }
```