# Politikbereiche

**Politikbereiche** Entscheiden, was passiert, wenn ein [Kontrollpunkt](https://maetra.io/de/docs/govern-api/checkpoints) wird erstellt: ob sie auf eine Aktion zutreffen und wie sie gehandhabt wird - automatische Genehmigung, automatische Blockierung oder Route zu Genehmigern mit Quorum und Timeout.

Richtlinien werden im Dashboard erstellt. Über die API sind sie **Read-Only** - Sie listen das aktive Set auf, damit ein Agent (oder Ihr Tooling) sehen kann, welche Steuerelemente gelten.

### Politikmodi

Govern unterstützt zwei Politikmodi:

| Modus | Verwenden Sie es für | Laufzeitverhalten |
| ---- | ---------- | ---------------- |
| Exaktes Policy Setup | Bekannte Aktionsmuster wie Rückerstattungen, Überweisungen, Aufzeichnungsänderungen, ausgehende Nachrichten oder Datenexporte. | Maetra überprüft die gespeicherten Richtlinienbedingungen und wendet dann die konfigurierten Einstellungen für Genehmigung, Block, Quorum, Timeout und Benachrichtigung an. |
| Entscheidungsfindung | Aktionen, bei denen das Risiko vom Laufzeitkontext anstelle einer genauen Bedingung abhängt. | Maetra wertet den Checkpoint gemäß den Richtlinieneinstellungen aus und kann basierend auf dem ausgewählten Modus zulassen, eine Genehmigung anfordern oder blockieren. |

Entscheidungsintelligenz ist in der Richtlinie im Dashboard aktiviert. API und MCP Caller senden keinen separaten `decision_intelligence` Feld. Sie senden die gleiche Checkpoint-Nutzlast, und die aktive Richtlinie kontrolliert, ob Maetra genaue Bedingungen oder Runtime Decision Intelligence verwendet.

### Aktive Politiken auflisten

`GET /v1/policies/active` — erfordert Anwendungsbereich `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());
```


#### Antwort

```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"
    }
  ]
}
```

| Feld | Typ | Beschreibung |
| ---------------------- | ------- | -------------------------------------------------------------------- |
| `id` | Schnurschnur | Policy ID. Passieren Sie `policy_ids` an einem Checkpoint zur Scope-Bewertung. |
| `name` / `description` | Schnurschnur | Human-facing Labels. |
| `is_default` | Boolean | Ob es sich um einen Workspace-Standard handelt. |
| `autonomy_gate` | Schnurschnur | Autonomieniveau ()`L0`–`L5`) an / darüber, an dem es angreift. |
| `match_tree` | Objekt | Zustandsbaum, der entscheidet, ob er gilt. |
| `on_match` | Schnurschnur | Was zu tun ist, wenn es gilt (z.B.) `require_approval`, `block`). |
| `evaluation_mode` | Schnurschnur | `exact_policy` oder `decision_intelligence`. |
| `decision_intelligence_mode` | Schnurschnur \| Null | Entscheidungs-Intelligenz-Modus, wenn `evaluation_mode` ist `decision_intelligence`. |
| `approver_mode` | Schnurschnur | Wie Genehmiger ausgewählt werden (z.B. `any`). |
| `quorum_required` | Ganzzahl | Genehmigungen mussten passieren. |
| `timeout_seconds` | Ganzzahl | Wie lange warten auf das Quorum? |
| `on_timeout` | Schnurschnur | Was tun, wenn das Timeout vergeht (z.B.) `reject`). |
| `notifications` | Objekt | `email`, `slack_channel`, `slack_dm` Booleanen. |
| `version` | Ganzzahl | Inkremente bei jedem Edit. |
| `updated_at` | Schnurschnur | Zeitstempel nach ISO 8601 |

### Scoring einen Checkpoint zu bestimmten Richtlinien

Standardmäßig wird ein Checkpoint gegen ausgewertet **alle** Anwendbare aktive Strategien. Deaktivierte und gelöschte Richtlinien werden nicht ausgewertet. Passierpass `policy_ids` (oder) `policy_group_ids`) um die Bewertung auf bestimmte genaue Richtlinien oder Entscheidungs-Intelligenz-Richtlinien zu beschränken:

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