> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Hooks

> Benutzerdefinierte Logik ausführen, wenn während einer Sitzung bestimmte Ereignisse eintreten

Mit Hooks kannst du benutzerdefinierte Logik ausführen, wenn Ereignisse im Lebenszyklus des Agenten auftreten. Du kannst Hooks verwenden, um Richtlinien durchzusetzen, Kontext hinzuzufügen, Aktionen zu protokollieren, Berechtigungen zu ändern oder externe Systeme zu integrieren.

Hooks werden im JSON-Format konfiguriert. Lege sie im `.devin/`-Verzeichnis deines Projekts ab (oder in einer Konfiguration auf Nutzerebene), und Devin CLI führt sie bei passenden Lifecycle-Ereignissen aus. Vorhandene Hooks in `.claude/`-Verzeichnissen werden ebenfalls automatisch erkannt — siehe [Wo Hooks zu finden sind](#where-hooks-live).

***

<div id="what-can-hooks-do">
  ## Was können Hooks tun?
</div>

<CardGroup cols={2}>
  <Card title="Richtlinien durchsetzen" icon="shield">
    Gefährliche Befehle blockieren, für bestimmte Aktionen eine Bestätigung verlangen oder den Zugriff auf Dateien einschränken.
  </Card>

  <Card title="Kontext hinzufügen" icon="message">
    Zusätzliche Anweisungen oder Informationen einfügen, wenn bestimmte Tools aufgerufen werden.
  </Card>

  <Card title="Folgeaktionen ausführen" icon="bolt">
    Skripte ausführen, Benachrichtigungen senden oder Ereignisse protokollieren, wenn etwas geschieht.
  </Card>

  <Card title="Berechtigungen ändern" icon="lock">
    Berechtigungen je nach Situation dynamisch gewähren oder einschränken.
  </Card>
</CardGroup>

***

<div id="quick-example">
  ## Kurzes Beispiel
</div>

Legen Sie `.devin/hooks.v1.json` in Ihrem Projekt an:

```json theme={null}
{
  "PreToolUse": [
    {
      "matcher": "exec",
      "hooks": [
        {
          "type": "command",
          "command": "./scripts/check-command.sh"
        }
      ]
    }
  ]
}
```

Dabei wird `./scripts/check-command.sh` vor jeder Ausführung eines Shell-Befehls ausgeführt. Das Skript erhält Ereignisdaten über stdin und kann die Aktion blockieren, indem es einen Exit-Code ungleich null zurückgibt.

***

<div id="hook-events">
  ## Hook-Ereignisse
</div>

Hooks können auf diese Ereignisse im Lebenszyklus reagieren:

| Ereignis            | Wann es ausgelöst wird                               |
| ------------------- | ---------------------------------------------------- |
| `PreToolUse`        | Bevor ein Tool ausgeführt wird                       |
| `PostToolUse`       | Nachdem ein Tool beendet wurde                       |
| `PermissionRequest` | Wenn eine Berechtigungsentscheidung erforderlich ist |
| `UserPromptSubmit`  | Wenn der Nutzer eine Nachricht absendet              |
| `Stop`              | Wenn der Agent stoppen möchte                        |
| `SessionStart`      | Wenn eine Sitzung beginnt                            |
| `SessionEnd`        | Wenn eine Sitzung endet                              |

Unter [Lifecycle Hooks](/de/cli/extensibility/hooks/lifecycle-hooks) finden Sie Details zu jedem Ereignis und den jeweils verfügbaren Daten.

***

<div id="hook-format">
  ## Hook-Format
</div>

Jeder Hook hat einen **Typ** (`command` oder `prompt`), einen optionalen **Matcher** (Regex auf den `tool_name` des Hook-Ereignisses) und eine Konfiguration:

```json theme={null}
{
  "PreToolUse": [
    {
      "matcher": "exec",
      "hooks": [
        {
          "type": "command",
          "command": "./scripts/validate.sh",
          "timeout": 10
        }
      ]
    }
  ]
}
```

| Feld      | Beschreibung                                                                                                                                            |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `matcher` | Regex, die mit dem `tool_name` des Hook-Ereignisses abgeglichen wird. Eine leere Zeichenfolge oder ein weggelassener Matcher passt auf alle Tool-Namen. |
| `type`    | `"command"` zum Ausführen eines Shell-Befehls oder `"prompt"` zum Auswerten eines LLM-Prompts.                                                          |
| `command` | Auszuführender Shell-Befehl (für den Typ `command`).                                                                                                    |
| `prompt`  | Auszuwertender LLM-Prompt (für den Typ `prompt`).                                                                                                       |
| `timeout` | Timeout in Sekunden (optional).                                                                                                                         |

<div id="command-hooks">
  ### Befehls-Hooks
</div>

Befehls-Hooks führen einen Shell-Befehl aus. Ereignisdaten werden als JSON über **stdin** übergeben, und der Befehl kann über **stdout** JSON zurückgeben, um das Ergebnis zu steuern (siehe [Ausgabeformat](#output-format) unten).

**Eingabe** (stdin):

```json theme={null}
{
  "hook_event_name": "PreToolUse",
  "tool_name": "exec",
  "tool_input": {
    "command": "rm -rf /"
  }
}
```

Die Umgebungsvariable `DEVIN_PROJECT_DIR` wird automatisch auf das Projektstammverzeichnis gesetzt.

Unter [Using the Matcher](/de/cli/extensibility/hooks/lifecycle-hooks#using-the-matcher) finden Sie die integrierten Tool-Namen und das MCP-Tool-Namensformat, nach denen Sie abgleichen können.

<div id="output-format">
  ### Ausgabeformat
</div>

Ein Command-Hook kann ein JSON-Objekt an **stdout** ausgeben, um das Ergebnis zu steuern.

Um eine Aktion zu genehmigen oder zu blockieren, gib ein `decision`-Feld auf oberster Ebene zurück (mit einem optionalen `reason`):

```json theme={null}
{
  "decision": "block",
  "reason": "Destructive command blocked by policy"
}
```

Um Text in den Kontext des Agenten einzuschleusen, geben Sie `additionalContext` in einem `hookSpecificOutput`-Objekt zurück, das mit dem Ereignisnamen versehen ist:

```json theme={null}
{
  "hookSpecificOutput": {
    "hookEventName": "UserPromptSubmit",
    "additionalContext": "Remember: deploys require an approved change ticket."
  }
}
```

| Ausgabefeld                            | Beschreibung                                                                                                |
| -------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `decision`                             | `"approve"`, um die Aktion zuzulassen, oder `"block"`, um sie zu blockieren                                 |
| `reason`                               | Erklärung, die dem Agenten angezeigt wird                                                                   |
| `hookSpecificOutput.hookEventName`     | Ereignis, für das die Ausgabe gilt (z. B. `UserPromptSubmit`, `SessionStart`, `PostToolUse`)                |
| `hookSpecificOutput.additionalContext` | Text, der in den Kontext des Agenten eingefügt wird (für `UserPromptSubmit`, `SessionStart`, `PostToolUse`) |

<div id="exit-codes">
  ### Exit-Codes
</div>

| Code   | Bedeutung                                         |
| ------ | ------------------------------------------------- |
| 0      | Erfolg — Hook wird normal fortgesetzt             |
| 2      | Blockiert — Aktion wird verweigert                |
| Andere | Fehler — wird protokolliert, blockiert aber nicht |

***

<div id="where-hooks-live">
  ## Wo Hooks zu finden sind
</div>

Devin CLI liest Hooks aus den folgenden Speicherorten. Alle verwenden dasselbe JSON-Format.

<div id="project-level">
  ### Auf Projektebene
</div>

| Speicherort                   | Beschreibung                                            |
| ----------------------------- | ------------------------------------------------------- |
| `.devin/hooks.v1.json`        | Eigenständige Hooks-Datei (empfohlen)                   |
| `.devin/config.json`          | `"hooks"`-Schlüssel in der Konfigurationsdatei          |
| `.devin/config.local.json`    | `"hooks"`-Schlüssel (lokale Überschreibung, gitignored) |
| `.claude/settings.json`       | `"hooks"`-Schlüssel (Claude-Code-Format)                |
| `.claude/settings.local.json` | `"hooks"`-Schlüssel (Claude-Code-Format)                |

<div id="user-level-global">
  ### Nutzerebene (global)
</div>

| Pfad                                                                        | Beschreibung                                   |
| --------------------------------------------------------------------------- | ---------------------------------------------- |
| `~/.config/devin/config.json` (`%APPDATA%\devin\config.json` unter Windows) | `"hooks"`-Schlüssel in der Nutzerkonfiguration |
| `~/.claude.json`                                                            | `"hooks"`-Schlüssel (Claude Code-Format)       |
| `~/.claude/settings.json`                                                   | `"hooks"`-Schlüssel (Claude Code-Format)       |
| `~/.claude/settings.local.json`                                             | `"hooks"`-Schlüssel (Claude Code-Format)       |

<Note>
  In `.devin/hooks.v1.json` ist das Hooks-Objekt die **gesamte Datei** (kein umschließender Schlüssel erforderlich). An allen anderen Speicherorten sind Hooks in einer Settings-Datei unter dem `"hooks"`-Schlüssel verschachtelt.
</Note>

<Note>
  Hooks aus `.claude/`-Pfaden werden geladen, wenn `read_config_from.claude` aktiviert ist (Standardeinstellung). Bei Bedarf kannst du dies in deiner [Nutzerkonfiguration](/de/cli/reference/configuration/read-config-from) deaktivieren.
</Note>

***

<div id="verifying-hooks">
  ## Hooks überprüfen
</div>

Verwenden Sie den Slash-Befehl `/hooks`, um alle aktuell geladenen Hooks und ihre Quelldateien anzuzeigen:

```
/hooks
```

***

<div id="next-steps">
  ## Nächste Schritte
</div>

<CardGroup cols={2}>
  <Card title="Lifecycle Hooks" icon="rotate" href="/de/cli/extensibility/hooks/lifecycle-hooks">
    Detaillierte Informationen zu jedem Ereignistyp und den verfügbaren Daten.
  </Card>

  <Card title="Konfiguration" icon="gear" href="/de/cli/reference/configuration/read-config-from">
    Legen Sie fest, aus welchen Konfigurationsorten Devin CLI Hooks liest.
  </Card>
</CardGroup>