---
read_when:
    - Coding-Harnesses über ACP ausführen
    - Konversationsgebundene ACP-Sitzungen auf Messaging-Channels einrichten
    - Eine Konversation in einem Message-Channel an eine persistente ACP-Sitzung binden
    - Fehlerbehebung bei ACP-Backend- und Plugin-Verdrahtung
    - '`/acp`-Befehle aus dem Chat bedienen'
summary: ACP-Laufzeitsitzungen für Codex, Claude Code, Cursor, Gemini CLI, OpenClaw ACP und andere Harness-Agenten verwenden
title: ACP Agents
x-i18n:
    generated_at: "2026-04-08T02:20:33Z"
    model: gpt-5.4
    provider: openai
    source_hash: 71c7c0cdae5247aefef17a0029360950a1c2987ddcee21a1bb7d78c67da52950
    source_path: tools/acp-agents.md
    workflow: 15
---

# ACP Agents

Sitzungen mit dem [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) ermöglichen es OpenClaw, externe Coding-Harnesses (zum Beispiel Pi, Claude Code, Codex, Cursor, Copilot, OpenClaw ACP, OpenCode, Gemini CLI und andere unterstützte ACPX-Harnesses) über ein ACP-Backend-Plugin auszuführen.

Wenn Sie OpenClaw in natürlicher Sprache bitten, „das in Codex auszuführen“ oder „Claude Code in einem Thread zu starten“, sollte OpenClaw diese Anfrage an die ACP-Laufzeit weiterleiten (nicht an die native Subagent-Laufzeit). Jeder ACP-Sitzungsstart wird als [Hintergrundaufgabe](/de/automation/tasks) erfasst.

Wenn Sie möchten, dass Codex oder Claude Code sich stattdessen direkt als externer MCP-Client
mit bestehenden OpenClaw-Channel-Konversationen verbinden, verwenden Sie
[`openclaw mcp serve`](/cli/mcp) anstelle von ACP.

## Welche Seite brauche ich?

Es gibt drei benachbarte Oberflächen, die leicht verwechselt werden können:

| Sie möchten...                                                                     | Verwenden Sie dies                    | Hinweise                                                                                                            |
| ----------------------------------------------------------------------------------- | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| Codex, Claude Code, Gemini CLI oder ein anderes externes Harness _durch_ OpenClaw ausführen | Diese Seite: ACP Agents               | Chat-gebundene Sitzungen, `/acp spawn`, `sessions_spawn({ runtime: "acp" })`, Hintergrundaufgaben, Laufzeitsteuerung |
| Eine OpenClaw-Gateway-Sitzung _als_ ACP-Server für einen Editor oder Client bereitstellen      | [`openclaw acp`](/cli/acp)            | Bridge-Modus. IDE/Client spricht ACP über stdio/WebSocket mit OpenClaw                                             |
| Eine lokale AI-CLI als reines Text-Fallback-Modell wiederverwenden                                | [CLI Backends](/de/gateway/cli-backends) | Nicht ACP. Keine OpenClaw-Tools, keine ACP-Steuerung, keine Harness-Laufzeit                                       |

## Funktioniert das sofort?

Normalerweise ja.

- Frische Installationen werden jetzt standardmäßig mit aktiviertem gebündeltem `acpx`-Laufzeit-Plugin ausgeliefert.
- Das gebündelte `acpx`-Plugin bevorzugt seine pluginlokal angeheftete `acpx`-Binärdatei.
- Beim Start prüft OpenClaw diese Binärdatei und repariert sie bei Bedarf selbst.
- Beginnen Sie mit `/acp doctor`, wenn Sie eine schnelle Bereitschaftsprüfung möchten.

Was bei der ersten Verwendung trotzdem passieren kann:

- Ein Ziel-Harness-Adapter kann bei der ersten Verwendung dieses Harnesses bei Bedarf mit `npx` abgerufen werden.
- Die Vendor-Authentifizierung muss für dieses Harness weiterhin auf dem Host vorhanden sein.
- Wenn der Host keinen npm-/Netzwerkzugriff hat, können Adapter-Abrufe beim ersten Start fehlschlagen, bis Caches vorgewärmt sind oder der Adapter auf andere Weise installiert wurde.

Beispiele:

- `/acp spawn codex`: OpenClaw sollte bereit sein, `acpx` zu bootstrappen, aber der Codex-ACP-Adapter benötigt möglicherweise trotzdem noch einen Abruf beim ersten Lauf.
- `/acp spawn claude`: dieselbe Situation für den Claude-ACP-Adapter, plus Claude-seitige Authentifizierung auf diesem Host.

## Schneller Operator-Ablauf

Verwenden Sie dies, wenn Sie ein praktisches `/acp`-Runbook möchten:

1. Starten Sie eine Sitzung:
   - `/acp spawn codex --bind here`
   - `/acp spawn codex --mode persistent --thread auto`
2. Arbeiten Sie in der gebundenen Konversation oder im Thread (oder adressieren Sie diesen Sitzungsschlüssel explizit).
3. Prüfen Sie den Laufzeitstatus:
   - `/acp status`
4. Passen Sie Laufzeitoptionen bei Bedarf an:
   - `/acp model <provider/model>`
   - `/acp permissions <profile>`
   - `/acp timeout <seconds>`
5. Geben Sie einer aktiven Sitzung einen Schubs, ohne den Kontext zu ersetzen:
   - `/acp steer tighten logging and continue`
6. Beenden Sie die Arbeit:
   - `/acp cancel` (aktuellen Turn stoppen), oder
   - `/acp close` (Sitzung schließen + Bindungen entfernen)

## Schnellstart für Menschen

Beispiele für natürliche Anfragen:

- „Binde diesen Discord-Channel an Codex.“
- „Starte hier in einem Thread eine persistente Codex-Sitzung und halte sie fokussiert.“
- „Führe das als einmalige Claude Code ACP-Sitzung aus und fasse das Ergebnis zusammen.“
- „Binde diesen iMessage-Chat an Codex und halte Folgeanfragen im selben Workspace.“
- „Verwende für diese Aufgabe Gemini CLI in einem Thread und halte Folgeanfragen dann in demselben Thread.“

Was OpenClaw tun sollte:

1. `runtime: "acp"` auswählen.
2. Das angeforderte Harness-Ziel auflösen (`agentId`, zum Beispiel `codex`).
3. Wenn eine Bindung an die aktuelle Konversation angefordert wird und der aktive Channel dies unterstützt, die ACP-Sitzung an diese Konversation binden.
4. Andernfalls, wenn eine Thread-Bindung angefordert wird und der aktuelle Channel dies unterstützt, die ACP-Sitzung an den Thread binden.
5. Folgeanfragen in dieser Bindung an dieselbe ACP-Sitzung weiterleiten, bis sie entfokussiert/geschlossen/abgelaufen ist.

## ACP im Vergleich zu Subagenten

Verwenden Sie ACP, wenn Sie eine externe Harness-Laufzeit möchten. Verwenden Sie Subagenten, wenn Sie delegierte Ausführungen nativ in OpenClaw möchten.

| Bereich       | ACP-Sitzung                           | Subagent-Ausführung                 |
| ------------- | ------------------------------------- | ----------------------------------- |
| Laufzeit      | ACP-Backend-Plugin (zum Beispiel acpx) | Native OpenClaw-Subagent-Laufzeit   |
| Sitzungsschlüssel | `agent:<agentId>:acp:<uuid>`      | `agent:<agentId>:subagent:<uuid>`   |
| Hauptbefehle  | `/acp ...`                            | `/subagents ...`                    |
| Spawn-Tool    | `sessions_spawn` mit `runtime:"acp"`  | `sessions_spawn` (Standardlaufzeit) |

Siehe auch [Sub-agents](/de/tools/subagents).

## Wie ACP Claude Code ausführt

Für Claude Code über ACP ist der Stack:

1. OpenClaw-ACP-Sitzungs-Kontrollplane
2. gebündeltes `acpx`-Laufzeit-Plugin
3. Claude-ACP-Adapter
4. Claude-seitige Laufzeit-/Sitzungsmechanik

Wichtige Unterscheidung:

- ACP Claude ist eine Harness-Sitzung mit ACP-Steuerung, Sitzungsfortsetzung, Hintergrundaufgaben-Tracking und optionaler Konversations-/Thread-Bindung.
- CLI-Backends sind separate lokale Text-Fallback-Laufzeiten. Siehe [CLI Backends](/de/gateway/cli-backends).

Für Operatoren gilt praktisch:

- Wenn Sie `/acp spawn`, bindbare Sitzungen, Laufzeitsteuerung oder persistente Harness-Arbeit möchten: ACP verwenden
- Wenn Sie ein einfaches lokales Text-Fallback über die rohe CLI möchten: CLI-Backends verwenden

## Gebundene Sitzungen

### Bindungen an die aktuelle Konversation

Verwenden Sie `/acp spawn <harness> --bind here`, wenn Sie möchten, dass die aktuelle Konversation zu einem dauerhaften ACP-Workspace wird, ohne einen untergeordneten Thread zu erstellen.

Verhalten:

- OpenClaw bleibt Eigentümer von Channel-Transport, Authentifizierung, Sicherheit und Zustellung.
- Die aktuelle Konversation wird an den gestarteten ACP-Sitzungsschlüssel angeheftet.
- Folge-Nachrichten in dieser Konversation werden an dieselbe ACP-Sitzung weitergeleitet.
- `/new` und `/reset` setzen dieselbe gebundene ACP-Sitzung an Ort und Stelle zurück.
- `/acp close` schließt die Sitzung und entfernt die Bindung an die aktuelle Konversation.

Was das in der Praxis bedeutet:

- `--bind here` behält dieselbe Chat-Oberfläche bei. Auf Discord bleibt der aktuelle Channel der aktuelle Channel.
- `--bind here` kann trotzdem eine neue ACP-Sitzung erstellen, wenn Sie neue Arbeit starten. Die Bindung verknüpft diese Sitzung mit der aktuellen Konversation.
- `--bind here` erstellt nicht von selbst einen untergeordneten Discord-Thread oder ein Telegram-Thema.
- Die ACP-Laufzeit kann trotzdem ihr eigenes Arbeitsverzeichnis (`cwd`) oder einen backendverwalteten Workspace auf der Festplatte haben. Dieser Laufzeit-Workspace ist von der Chat-Oberfläche getrennt und impliziert keinen neuen Messaging-Thread.
- Wenn Sie zu einem anderen ACP-Agenten spawnen und kein `--cwd` übergeben, übernimmt OpenClaw standardmäßig den Workspace des **Ziel-Agenten**, nicht den des Anforderers.
- Wenn dieser übernommene Workspace-Pfad fehlt (`ENOENT`/`ENOTDIR`), fällt OpenClaw auf das Standard-`cwd` des Backends zurück, statt stillschweigend den falschen Baum wiederzuverwenden.
- Wenn der übernommene Workspace existiert, aber nicht zugänglich ist (zum Beispiel `EACCES`), gibt der Spawn den echten Zugriffsfehler zurück, statt `cwd` zu verwerfen.

Mentales Modell:

- Chat-Oberfläche: wo Menschen weiter sprechen (`Discord channel`, `Telegram topic`, `iMessage chat`)
- ACP-Sitzung: der dauerhafte Codex-/Claude-/Gemini-Laufzeitzustand, an den OpenClaw weiterleitet
- untergeordneter Thread/Thema: eine optionale zusätzliche Messaging-Oberfläche, die nur durch `--thread ...` erstellt wird
- Laufzeit-Workspace: der Dateisystemort, an dem das Harness ausgeführt wird (`cwd`, Repo-Checkout, Backend-Workspace)

Beispiele:

- `/acp spawn codex --bind here`: diesen Chat beibehalten, eine Codex-ACP-Sitzung starten oder anhängen und zukünftige Nachrichten hierhin weiterleiten
- `/acp spawn codex --thread auto`: OpenClaw kann einen untergeordneten Thread/ein Thema erstellen und die ACP-Sitzung dort binden
- `/acp spawn codex --bind here --cwd /workspace/repo`: dieselbe Chat-Bindung wie oben, aber Codex läuft in `/workspace/repo`

Unterstützung für die Bindung an die aktuelle Konversation:

- Chat-/Message-Channels, die Unterstützung für die Bindung an die aktuelle Konversation ausweisen, können `--bind here` über den gemeinsamen Konversations-Bindungspfad verwenden.
- Channels mit eigener Thread-/Themen-Semantik können hinter derselben gemeinsamen Schnittstelle weiterhin channelspezifische Kanonisierung bereitstellen.
- `--bind here` bedeutet immer „die aktuelle Konversation an Ort und Stelle binden“.
- Generische Bindungen an die aktuelle Konversation verwenden den gemeinsamen OpenClaw-Binding-Store und überstehen normale Gateway-Neustarts.

Hinweise:

- `--bind here` und `--thread ...` schließen sich bei `/acp spawn` gegenseitig aus.
- Auf Discord bindet `--bind here` den aktuellen Channel oder Thread an Ort und Stelle. `spawnAcpSessions` ist nur erforderlich, wenn OpenClaw für `--thread auto|here` einen untergeordneten Thread erstellen muss.
- Wenn der aktive Channel keine ACP-Bindungen an die aktuelle Konversation bereitstellt, gibt OpenClaw eine klare Meldung zurück, dass dies nicht unterstützt wird.
- `resume` und Fragen nach einer „neuen Sitzung“ sind ACP-Sitzungsfragen, keine Channel-Fragen. Sie können den Laufzeitzustand wiederverwenden oder ersetzen, ohne die aktuelle Chat-Oberfläche zu ändern.

### Thread-gebundene Sitzungen

Wenn Thread-Bindungen für einen Channel-Adapter aktiviert sind, können ACP-Sitzungen an Threads gebunden werden:

- OpenClaw bindet einen Thread an eine Ziel-ACP-Sitzung.
- Folge-Nachrichten in diesem Thread werden an die gebundene ACP-Sitzung weitergeleitet.
- ACP-Ausgaben werden an denselben Thread zurückgeliefert.
- Entfokussieren/Schließen/Archivieren/Ablauf durch Leerlauf-Timeout oder Maximalalter entfernt die Bindung.

Die Unterstützung für Thread-Bindungen ist adapterspezifisch. Wenn der aktive Channel-Adapter keine Thread-Bindungen unterstützt, gibt OpenClaw eine klare Meldung zurück, dass dies nicht unterstützt/verfügbar ist.

Erforderliche Feature-Flags für threadgebundenes ACP:

- `acp.enabled=true`
- `acp.dispatch.enabled` ist standardmäßig aktiviert (auf `false` setzen, um ACP-Dispatch zu pausieren)
- ACP-Thread-Spawn-Flag des Channel-Adapters aktiviert (adapterspezifisch)
  - Discord: `channels.discord.threadBindings.spawnAcpSessions=true`
  - Telegram: `channels.telegram.threadBindings.spawnAcpSessions=true`

### Channels mit Thread-Unterstützung

- Jeder Channel-Adapter, der die Fähigkeit zur Sitzungs-/Thread-Bindung bereitstellt.
- Aktuelle eingebaute Unterstützung:
  - Discord-Threads/-Channels
  - Telegram-Themen (Forum-Themen in Gruppen/Supergroups und DM-Themen)
- Plugin-Channels können Unterstützung über dieselbe Binding-Schnittstelle hinzufügen.

## Channelspezifische Einstellungen

Für nicht-ephemere Workflows konfigurieren Sie persistente ACP-Bindungen in Top-Level-Einträgen `bindings[]`.

### Binding-Modell

- `bindings[].type="acp"` kennzeichnet eine persistente ACP-Konversationsbindung.
- `bindings[].match` identifiziert die Zielkonversation:
  - Discord-Channel oder -Thread: `match.channel="discord"` + `match.peer.id="<channelOrThreadId>"`
  - Telegram-Forum-Thema: `match.channel="telegram"` + `match.peer.id="<chatId>:topic:<topicId>"`
  - BlueBubbles-DM-/Gruppenchat: `match.channel="bluebubbles"` + `match.peer.id="<handle|chat_id:*|chat_guid:*|chat_identifier:*>"`
    Bevorzugen Sie `chat_id:*` oder `chat_identifier:*` für stabile Gruppenbindungen.
  - iMessage-DM-/Gruppenchat: `match.channel="imessage"` + `match.peer.id="<handle|chat_id:*|chat_guid:*|chat_identifier:*>"`
    Bevorzugen Sie `chat_id:*` für stabile Gruppenbindungen.
- `bindings[].agentId` ist die zugehörige OpenClaw-Agent-ID.
- Optionale ACP-Überschreibungen befinden sich unter `bindings[].acp`:
  - `mode` (`persistent` oder `oneshot`)
  - `label`
  - `cwd`
  - `backend`

### Laufzeit-Standards pro Agent

Verwenden Sie `agents.list[].runtime`, um ACP-Standards einmal pro Agent zu definieren:

- `agents.list[].runtime.type="acp"`
- `agents.list[].runtime.acp.agent` (Harness-ID, zum Beispiel `codex` oder `claude`)
- `agents.list[].runtime.acp.backend`
- `agents.list[].runtime.acp.mode`
- `agents.list[].runtime.acp.cwd`

Priorität von Überschreibungen für gebundene ACP-Sitzungen:

1. `bindings[].acp.*`
2. `agents.list[].runtime.acp.*`
3. globale ACP-Standards (zum Beispiel `acp.backend`)

Beispiel:

```json5
{
  agents: {
    list: [
      {
        id: "codex",
        runtime: {
          type: "acp",
          acp: {
            agent: "codex",
            backend: "acpx",
            mode: "persistent",
            cwd: "/workspace/openclaw",
          },
        },
      },
      {
        id: "claude",
        runtime: {
          type: "acp",
          acp: { agent: "claude", backend: "acpx", mode: "persistent" },
        },
      },
    ],
  },
  bindings: [
    {
      type: "acp",
      agentId: "codex",
      match: {
        channel: "discord",
        accountId: "default",
        peer: { kind: "channel", id: "222222222222222222" },
      },
      acp: { label: "codex-main" },
    },
    {
      type: "acp",
      agentId: "claude",
      match: {
        channel: "telegram",
        accountId: "default",
        peer: { kind: "group", id: "-1001234567890:topic:42" },
      },
      acp: { cwd: "/workspace/repo-b" },
    },
    {
      type: "route",
      agentId: "main",
      match: { channel: "discord", accountId: "default" },
    },
    {
      type: "route",
      agentId: "main",
      match: { channel: "telegram", accountId: "default" },
    },
  ],
  channels: {
    discord: {
      guilds: {
        "111111111111111111": {
          channels: {
            "222222222222222222": { requireMention: false },
          },
        },
      },
    },
    telegram: {
      groups: {
        "-1001234567890": {
          topics: { "42": { requireMention: false } },
        },
      },
    },
  },
}
```

Verhalten:

- OpenClaw stellt vor der Verwendung sicher, dass die konfigurierte ACP-Sitzung existiert.
- Nachrichten in diesem Channel oder Thema werden an die konfigurierte ACP-Sitzung weitergeleitet.
- In gebundenen Konversationen setzen `/new` und `/reset` denselben ACP-Sitzungsschlüssel an Ort und Stelle zurück.
- Temporäre Laufzeit-Bindungen (zum Beispiel erstellt durch Thread-Focus-Abläufe) gelten weiterhin, sofern vorhanden.
- Bei agentübergreifenden ACP-Spawns ohne explizites `cwd` übernimmt OpenClaw den Workspace des Ziel-Agenten aus der Agent-Konfiguration.
- Fehlende übernommene Workspace-Pfade fallen auf das Standard-`cwd` des Backends zurück; echte Zugriffsfehler bei vorhandenen Pfaden werden als Spawn-Fehler ausgegeben.

## ACP-Sitzungen starten (Schnittstellen)

### Über `sessions_spawn`

Verwenden Sie `runtime: "acp"`, um eine ACP-Sitzung aus einem Agent-Turn oder Tool-Aufruf zu starten.

```json
{
  "task": "Open the repo and summarize failing tests",
  "runtime": "acp",
  "agentId": "codex",
  "thread": true,
  "mode": "session"
}
```

Hinweise:

- `runtime` hat standardmäßig den Wert `subagent`, setzen Sie also für ACP-Sitzungen explizit `runtime: "acp"`.
- Wenn `agentId` weggelassen wird, verwendet OpenClaw `acp.defaultAgent`, sofern konfiguriert.
- `mode: "session"` erfordert `thread: true`, um eine persistente gebundene Konversation beizubehalten.

Schnittstellendetails:

- `task` (erforderlich): initialer Prompt, der an die ACP-Sitzung gesendet wird.
- `runtime` (erforderlich für ACP): muss `"acp"` sein.
- `agentId` (optional): ACP-Ziel-Harness-ID. Fällt auf `acp.defaultAgent` zurück, wenn gesetzt.
- `thread` (optional, Standard `false`): Thread-Binding-Ablauf anfordern, wo unterstützt.
- `mode` (optional): `run` (einmalig) oder `session` (persistent).
  - Standard ist `run`
  - wenn `thread: true` und `mode` weggelassen wird, kann OpenClaw je nach Laufzeitpfad standardmäßig persistentes Verhalten wählen
  - `mode: "session"` erfordert `thread: true`
- `cwd` (optional): angefordertes Laufzeit-Arbeitsverzeichnis (validiert durch Backend-/Laufzeitrichtlinie). Wenn weggelassen, übernimmt ACP-Spawn bei entsprechender Konfiguration den Workspace des Ziel-Agenten; fehlende übernommene Pfade fallen auf Backend-Standards zurück, während echte Zugriffsfehler zurückgegeben werden.
- `label` (optional): für Operatoren sichtbares Label, das im Sitzungs-/Bannertext verwendet wird.
- `resumeSessionId` (optional): eine vorhandene ACP-Sitzung fortsetzen, statt eine neue zu erstellen. Der Agent spielt den Konversationsverlauf über `session/load` erneut ab. Erfordert `runtime: "acp"`.
- `streamTo` (optional): `"parent"` streamt Zusammenfassungen des Fortschritts des initialen ACP-Laufs als Systemereignisse zurück an die anfordernde Sitzung.
  - Wenn verfügbar, enthalten akzeptierte Antworten `streamLogPath`, das auf ein JSONL-Log pro Sitzung verweist (`<sessionId>.acp-stream.jsonl`), das Sie für den vollständigen Relay-Verlauf mitlesen können.

### Eine vorhandene Sitzung fortsetzen

Verwenden Sie `resumeSessionId`, um eine frühere ACP-Sitzung fortzusetzen, statt neu zu starten. Der Agent spielt den Konversationsverlauf über `session/load` erneut ab, sodass er mit dem vollständigen Kontext des Vorherigen fortsetzt.

```json
{
  "task": "Continue where we left off — fix the remaining test failures",
  "runtime": "acp",
  "agentId": "codex",
  "resumeSessionId": "<previous-session-id>"
}
```

Häufige Anwendungsfälle:

- Eine Codex-Sitzung vom Laptop auf das Telefon übergeben — weisen Sie Ihren Agenten an, dort weiterzumachen, wo Sie aufgehört haben
- Eine Coding-Sitzung fortsetzen, die Sie interaktiv in der CLI begonnen haben, jetzt headless über Ihren Agenten
- Arbeit fortsetzen, die durch einen Gateway-Neustart oder ein Idle-Timeout unterbrochen wurde

Hinweise:

- `resumeSessionId` erfordert `runtime: "acp"` — gibt einen Fehler zurück, wenn es mit der Subagent-Laufzeit verwendet wird.
- `resumeSessionId` stellt den vorgelagerten ACP-Konversationsverlauf wieder her; `thread` und `mode` gelten weiterhin normal für die neue OpenClaw-Sitzung, die Sie erstellen, daher erfordert `mode: "session"` weiterhin `thread: true`.
- Der Ziel-Agent muss `session/load` unterstützen (Codex und Claude Code tun das).
- Wenn die Sitzungs-ID nicht gefunden wird, schlägt der Spawn mit einem klaren Fehler fehl — kein stiller Fallback auf eine neue Sitzung.

### Operator-Smoketest

Verwenden Sie dies nach einem Gateway-Deploy, wenn Sie schnell live prüfen möchten, dass ACP-Spawn
wirklich Ende-zu-Ende funktioniert und nicht nur Unit-Tests besteht.

Empfohlenes Gate:

1. Prüfen Sie die bereitgestellte Gateway-Version/den Commit auf dem Ziel-Host.
2. Bestätigen Sie, dass der bereitgestellte Quellcode die ACP-Lineage-Akzeptanz in
   `src/gateway/sessions-patch.ts` enthält (`subagent:* or acp:* sessions`).
3. Öffnen Sie eine temporäre ACPX-Bridge-Sitzung zu einem Live-Agenten (zum Beispiel
   `razor(main)` auf `jpclawhq`).
4. Bitten Sie diesen Agenten, `sessions_spawn` mit Folgendem aufzurufen:
   - `runtime: "acp"`
   - `agentId: "codex"`
   - `mode: "run"`
   - Aufgabe: `Reply with exactly LIVE-ACP-SPAWN-OK`
5. Verifizieren Sie, dass der Agent Folgendes meldet:
   - `accepted=yes`
   - einen echten `childSessionKey`
   - keinen Validator-Fehler
6. Bereinigen Sie die temporäre ACPX-Bridge-Sitzung.

Beispiel-Prompt für den Live-Agenten:

```text
Use the sessions_spawn tool now with runtime: "acp", agentId: "codex", and mode: "run".
Set the task to: "Reply with exactly LIVE-ACP-SPAWN-OK".
Then report only: accepted=<yes/no>; childSessionKey=<value or none>; error=<exact text or none>.
```

Hinweise:

- Halten Sie diesen Smoketest bei `mode: "run"`, es sei denn, Sie testen absichtlich
  persistente threadgebundene ACP-Sitzungen.
- Verlangen Sie für das grundlegende Gate nicht `streamTo: "parent"`. Dieser Pfad hängt von
  den Fähigkeiten des Anforderers/der Sitzung ab und ist eine separate Integrationsprüfung.
- Behandeln Sie Tests mit threadgebundenem `mode: "session"` als zweiten, umfangreicheren Integrationsdurchlauf
  aus einem echten Discord-Thread oder Telegram-Thema.

## Sandbox-Kompatibilität

ACP-Sitzungen laufen derzeit auf der Host-Laufzeit, nicht innerhalb der OpenClaw-Sandbox.

Aktuelle Einschränkungen:

- Wenn die anfordernde Sitzung sandboxed ist, werden ACP-Spawns sowohl für `sessions_spawn({ runtime: "acp" })` als auch für `/acp spawn` blockiert.
  - Fehler: `Sandboxed sessions cannot spawn ACP sessions because runtime="acp" runs on the host. Use runtime="subagent" from sandboxed sessions.`
- `sessions_spawn` mit `runtime: "acp"` unterstützt `sandbox: "require"` nicht.
  - Fehler: `sessions_spawn sandbox="require" is unsupported for runtime="acp" because ACP sessions run outside the sandbox. Use runtime="subagent" or sandbox="inherit".`

Verwenden Sie `runtime: "subagent"`, wenn Sie eine durch die Sandbox erzwungene Ausführung benötigen.

### Über den Befehl `/acp`

Verwenden Sie `/acp spawn` bei Bedarf für explizite Operator-Steuerung aus dem Chat.

```text
/acp spawn codex --mode persistent --thread auto
/acp spawn codex --mode oneshot --thread off
/acp spawn codex --bind here
/acp spawn codex --thread here
```

Wichtige Flags:

- `--mode persistent|oneshot`
- `--bind here|off`
- `--thread auto|here|off`
- `--cwd <absolute-path>`
- `--label <name>`

Siehe [Slash Commands](/de/tools/slash-commands).

## Auflösung von Sitzungszielen

Die meisten `/acp`-Aktionen akzeptieren optional ein Sitzungsziel (`session-key`, `session-id` oder `session-label`).

Auflösungsreihenfolge:

1. Explizites Zielargument (oder `--session` für `/acp steer`)
   - versucht zuerst den Schlüssel
   - dann die UUID-förmige Sitzungs-ID
   - dann das Label
2. Aktuelle Thread-Bindung (wenn diese Konversation/dieser Thread an eine ACP-Sitzung gebunden ist)
3. Fallback auf die aktuelle Anforderer-Sitzung

Bindungen an die aktuelle Konversation und Thread-Bindungen nehmen beide an Schritt 2 teil.

Wenn kein Ziel aufgelöst werden kann, gibt OpenClaw einen klaren Fehler zurück (`Unable to resolve session target: ...`).

## Spawn-Bind-Modi

`/acp spawn` unterstützt `--bind here|off`.

| Modus | Verhalten                                                                |
| ------ | ------------------------------------------------------------------------ |
| `here` | Die aktuelle aktive Konversation an Ort und Stelle binden; fehlschlagen, wenn keine aktiv ist. |
| `off`  | Keine Bindung an die aktuelle Konversation erstellen.                    |

Hinweise:

- `--bind here` ist der einfachste Operator-Pfad für „diesen Channel oder Chat mit Codex hinterlegen“.
- `--bind here` erstellt keinen untergeordneten Thread.
- `--bind here` ist nur auf Channels verfügbar, die Unterstützung für die Bindung an die aktuelle Konversation bereitstellen.
- `--bind` und `--thread` können nicht im selben `/acp spawn`-Aufruf kombiniert werden.

## Spawn-Thread-Modi

`/acp spawn` unterstützt `--thread auto|here|off`.

| Modus | Verhalten                                                                                            |
| ------ | ---------------------------------------------------------------------------------------------------- |
| `auto` | In einem aktiven Thread: diesen Thread binden. Außerhalb eines Threads: einen untergeordneten Thread erstellen/binden, wenn unterstützt. |
| `here` | Aktiven aktuellen Thread verlangen; fehlschlagen, wenn Sie sich nicht in einem Thread befinden.      |
| `off`  | Keine Bindung. Die Sitzung startet ungebunden.                                                       |

Hinweise:

- Auf Oberflächen ohne Thread-Binding ist das Standardverhalten effektiv `off`.
- Thread-gebundener Spawn erfordert Unterstützung durch die Channel-Richtlinie:
  - Discord: `channels.discord.threadBindings.spawnAcpSessions=true`
  - Telegram: `channels.telegram.threadBindings.spawnAcpSessions=true`
- Verwenden Sie `--bind here`, wenn Sie die aktuelle Konversation anheften möchten, ohne einen untergeordneten Thread zu erstellen.

## ACP-Steuerung

Verfügbare Befehlsfamilie:

- `/acp spawn`
- `/acp cancel`
- `/acp steer`
- `/acp close`
- `/acp status`
- `/acp set-mode`
- `/acp set`
- `/acp cwd`
- `/acp permissions`
- `/acp timeout`
- `/acp model`
- `/acp reset-options`
- `/acp sessions`
- `/acp doctor`
- `/acp install`

`/acp status` zeigt die effektiven Laufzeitoptionen und, wenn verfügbar, sowohl Sitzungskennungen auf Laufzeit- als auch auf Backend-Ebene.

Einige Steuerungen hängen von den Fähigkeiten des Backends ab. Wenn ein Backend eine Steuerung nicht unterstützt, gibt OpenClaw einen klaren Fehler für nicht unterstützte Steuerung zurück.

## ACP-Befehls-Kochbuch

| Command              | What it does                                              | Example                                                       |
| -------------------- | --------------------------------------------------------- | ------------------------------------------------------------- |
| `/acp spawn`         | ACP-Sitzung erstellen; optionale Bindung an aktuelle Konversation oder Thread. | `/acp spawn codex --bind here --cwd /repo`                    |
| `/acp cancel`        | Laufenden Turn für die Zielsitzung abbrechen.             | `/acp cancel agent:codex:acp:<uuid>`                          |
| `/acp steer`         | Steueranweisung an laufende Sitzung senden.               | `/acp steer --session support inbox prioritize failing tests` |
| `/acp close`         | Sitzung schließen und Thread-Ziele entbinden.             | `/acp close`                                                  |
| `/acp status`        | Backend, Modus, Status, Laufzeitoptionen, Fähigkeiten anzeigen. | `/acp status`                                                 |
| `/acp set-mode`      | Laufzeitmodus für die Zielsitzung setzen.                 | `/acp set-mode plan`                                          |
| `/acp set`           | Generisches Schreiben einer Laufzeit-Konfigurationsoption. | `/acp set model openai/gpt-5.4`                               |
| `/acp cwd`           | Überschreibung für das Laufzeit-Arbeitsverzeichnis setzen. | `/acp cwd /Users/user/Projects/repo`                          |
| `/acp permissions`   | Profil der Genehmigungsrichtlinie setzen.                 | `/acp permissions strict`                                     |
| `/acp timeout`       | Laufzeit-Timeout (Sekunden) setzen.                       | `/acp timeout 120`                                            |
| `/acp model`         | Überschreibung des Laufzeitmodells setzen.                | `/acp model anthropic/claude-opus-4-6`                        |
| `/acp reset-options` | Überschreibungen der Sitzungs-Laufzeitoptionen entfernen. | `/acp reset-options`                                          |
| `/acp sessions`      | Aktuelle ACP-Sitzungen aus dem Store auflisten.           | `/acp sessions`                                               |
| `/acp doctor`        | Backend-Zustand, Fähigkeiten, umsetzbare Behebungen.      | `/acp doctor`                                                 |
| `/acp install`       | Deterministische Installations- und Aktivierungsschritte ausgeben. | `/acp install`                                                |

`/acp sessions` liest den Store für die aktuell gebundene Sitzung oder die Sitzung des Anforderers. Befehle, die `session-key`-, `session-id`- oder `session-label`-Token akzeptieren, lösen Ziele über die Gateway-Sitzungserkennung auf, einschließlich benutzerdefinierter `session.store`-Wurzeln pro Agent.

## Zuordnung von Laufzeitoptionen

`/acp` hat Komfortbefehle und einen generischen Setter.

Äquivalente Operationen:

- `/acp model <id>` wird dem Laufzeit-Konfigurationsschlüssel `model` zugeordnet.
- `/acp permissions <profile>` wird dem Laufzeit-Konfigurationsschlüssel `approval_policy` zugeordnet.
- `/acp timeout <seconds>` wird dem Laufzeit-Konfigurationsschlüssel `timeout` zugeordnet.
- `/acp cwd <path>` aktualisiert die Überschreibung des Laufzeit-`cwd` direkt.
- `/acp set <key> <value>` ist der generische Pfad.
  - Spezialfall: `key=cwd` verwendet den Pfad für die `cwd`-Überschreibung.
- `/acp reset-options` löscht alle Laufzeit-Überschreibungen für die Zielsitzung.

## Unterstützung für acpx-Harnesses (aktuell)

Aktuelle eingebaute acpx-Harness-Aliasse:

- `claude`
- `codex`
- `copilot`
- `cursor` (Cursor CLI: `cursor-agent acp`)
- `droid`
- `gemini`
- `iflow`
- `kilocode`
- `kimi`
- `kiro`
- `openclaw`
- `opencode`
- `pi`
- `qwen`

Wenn OpenClaw das acpx-Backend verwendet, bevorzugen Sie diese Werte für `agentId`, sofern Ihre acpx-Konfiguration keine benutzerdefinierten Agent-Aliasse definiert.
Wenn Ihre lokale Cursor-Installation ACP weiterhin als `agent acp` bereitstellt, überschreiben Sie den Befehl des `cursor`-Agenten in Ihrer acpx-Konfiguration, statt den eingebauten Standard zu ändern.

Die direkte Verwendung der acpx-CLI kann auch beliebige Adapter über `--agent <command>` ansteuern, aber dieser rohe Escape Hatch ist eine Funktion der acpx-CLI (nicht der normale OpenClaw-`agentId`-Pfad).

## Erforderliche Konfiguration

Core-ACP-Baseline:

```json5
{
  acp: {
    enabled: true,
    // Optional. Default is true; set false to pause ACP dispatch while keeping /acp controls.
    dispatch: { enabled: true },
    backend: "acpx",
    defaultAgent: "codex",
    allowedAgents: [
      "claude",
      "codex",
      "copilot",
      "cursor",
      "droid",
      "gemini",
      "iflow",
      "kilocode",
      "kimi",
      "kiro",
      "openclaw",
      "opencode",
      "pi",
      "qwen",
    ],
    maxConcurrentSessions: 8,
    stream: {
      coalesceIdleMs: 300,
      maxChunkChars: 1200,
    },
    runtime: {
      ttlMinutes: 120,
    },
  },
}
```

Die Konfiguration von Thread-Bindings ist channelspezifisch. Beispiel für Discord:

```json5
{
  session: {
    threadBindings: {
      enabled: true,
      idleHours: 24,
      maxAgeHours: 0,
    },
  },
  channels: {
    discord: {
      threadBindings: {
        enabled: true,
        spawnAcpSessions: true,
      },
    },
  },
}
```

Wenn threadgebundener ACP-Spawn nicht funktioniert, prüfen Sie zuerst das Feature-Flag des Adapters:

- Discord: `channels.discord.threadBindings.spawnAcpSessions=true`

Bindungen an die aktuelle Konversation erfordern keine Erstellung eines untergeordneten Threads. Sie erfordern einen aktiven Konversationskontext und einen Channel-Adapter, der ACP-Konversationsbindungen bereitstellt.

Siehe [Configuration Reference](/de/gateway/configuration-reference).

## Plugin-Setup für das acpx-Backend

Frische Installationen werden standardmäßig mit aktiviertem gebündeltem `acpx`-Laufzeit-Plugin ausgeliefert, daher funktioniert ACP
normalerweise ohne einen manuellen Schritt zur Plugin-Installation.

Beginnen Sie mit:

```text
/acp doctor
```

Wenn Sie `acpx` deaktiviert haben, es über `plugins.allow` / `plugins.deny` verweigert haben oder
zu einem lokalen Entwicklungs-Checkout wechseln möchten, verwenden Sie den expliziten Plugin-Pfad:

```bash
openclaw plugins install acpx
openclaw config set plugins.entries.acpx.enabled true
```

Lokale Workspace-Installation während der Entwicklung:

```bash
openclaw plugins install ./path/to/local/acpx-plugin
```

Prüfen Sie dann den Zustand des Backends:

```text
/acp doctor
```

### Konfiguration von acpx-Befehl und -Version

Standardmäßig verwendet das gebündelte acpx-Backend-Plugin (`acpx`) die pluginlokal angeheftete Binärdatei:

1. Der Befehl ist standardmäßig die pluginlokale `node_modules/.bin/acpx` innerhalb des ACPX-Plugin-Pakets.
2. Die erwartete Version ist standardmäßig an die Extension-Pin gebunden.
3. Beim Start wird das ACP-Backend sofort als nicht bereit registriert.
4. Ein Hintergrund-Ensure-Job prüft `acpx --version`.
5. Wenn die pluginlokale Binärdatei fehlt oder nicht übereinstimmt, wird Folgendes ausgeführt:
   `npm install --omit=dev --no-save acpx@<pinned>` und anschließend erneut geprüft.

Sie können Befehl/Version in der Plugin-Konfiguration überschreiben:

```json
{
  "plugins": {
    "entries": {
      "acpx": {
        "enabled": true,
        "config": {
          "command": "../acpx/dist/cli.js",
          "expectedVersion": "any"
        }
      }
    }
  }
}
```

Hinweise:

- `command` akzeptiert einen absoluten Pfad, relativen Pfad oder Befehlsnamen (`acpx`).
- Relative Pfade werden ausgehend vom OpenClaw-Workspace-Verzeichnis aufgelöst.
- `expectedVersion: "any"` deaktiviert die strikte Versionsprüfung.
- Wenn `command` auf eine benutzerdefinierte Binärdatei/einen benutzerdefinierten Pfad zeigt, wird die pluginlokale Auto-Installation deaktiviert.
- Der OpenClaw-Start bleibt nicht blockierend, während die Zustandsprüfung des Backends läuft.

Siehe [Plugins](/de/tools/plugin).

### Automatische Abhängigkeitsinstallation

Wenn Sie OpenClaw global mit `npm install -g openclaw` installieren, werden die acpx-
Laufzeitabhängigkeiten (plattformspezifische Binärdateien) automatisch über einen Postinstall-Hook installiert. Wenn die automatische Installation fehlschlägt, startet das Gateway trotzdem
normal und meldet die fehlende Abhängigkeit über `openclaw acp doctor`.

### Plugin-Tools-MCP-Bridge

Standardmäßig stellen ACPX-Sitzungen **keine** von OpenClaw-Plugins registrierten Tools für
das ACP-Harness bereit.

Wenn Sie möchten, dass ACP-Agenten wie Codex oder Claude Code installierte
OpenClaw-Plugin-Tools wie Memory recall/store aufrufen können, aktivieren Sie die dedizierte Bridge:

```bash
openclaw config set plugins.entries.acpx.config.pluginToolsMcpBridge true
```

Das bewirkt Folgendes:

- Es injiziert einen eingebauten MCP-Server namens `openclaw-plugin-tools` in den ACPX-Sitzungs-
  Bootstrap.
- Es stellt Plugin-Tools bereit, die bereits von installierten und aktivierten OpenClaw-
  Plugins registriert wurden.
- Das Feature bleibt explizit und standardmäßig deaktiviert.

Sicherheits- und Vertrauenshinweise:

- Dadurch wird die Tool-Oberfläche des ACP-Harnesses erweitert.
- ACP-Agenten erhalten nur Zugriff auf Plugin-Tools, die bereits im Gateway aktiv sind.
- Behandeln Sie dies als dieselbe Vertrauensgrenze, wie diesen Plugins die Ausführung in
  OpenClaw selbst zu erlauben.
- Prüfen Sie installierte Plugins, bevor Sie es aktivieren.

Benutzerdefinierte `mcpServers` funktionieren weiterhin wie bisher. Die eingebaute
Plugin-Tools-Bridge ist eine zusätzliche optionale Bequemlichkeit und kein Ersatz für generische MCP-Server-Konfiguration.

### Konfiguration des Laufzeit-Timeouts

Das gebündelte `acpx`-Plugin setzt standardmäßig für eingebettete Laufzeit-Turns ein
Timeout von 120 Sekunden. Das gibt langsameren Harnesses wie Gemini CLI genug Zeit, den
ACP-Start und die Initialisierung abzuschließen. Überschreiben Sie dies, wenn Ihr Host ein anderes
Laufzeitlimit benötigt:

```bash
openclaw config set plugins.entries.acpx.config.timeoutSeconds 180
```

Starten Sie das Gateway nach dem Ändern dieses Werts neu.

## Konfiguration von Berechtigungen

ACP-Sitzungen laufen nicht interaktiv — es gibt kein TTY, um Berechtigungsabfragen für Dateischreib- und Shell-Exec-Vorgänge zu bestätigen oder abzulehnen. Das acpx-Plugin stellt zwei Konfigurationsschlüssel bereit, die steuern, wie Berechtigungen behandelt werden:

Diese ACPX-Harness-Berechtigungen sind getrennt von OpenClaw-Exec-Genehmigungen und getrennt von CLI-Backend-Vendor-Bypass-Flags wie Claude CLI `--permission-mode bypassPermissions`. ACPX `approve-all` ist der Break-Glass-Schalter auf Harness-Ebene für ACP-Sitzungen.

### `permissionMode`

Steuert, welche Operationen der Harness-Agent ohne Rückfrage ausführen kann.

| Wert            | Verhalten                                                |
| ---------------- | -------------------------------------------------------- |
| `approve-all`   | Alle Dateischreib- und Shell-Befehle automatisch genehmigen. |
| `approve-reads` | Nur Lesevorgänge automatisch genehmigen; Schreibvorgänge und Exec erfordern Prompts. |
| `deny-all`      | Alle Berechtigungsabfragen ablehnen.                     |

### `nonInteractivePermissions`

Steuert, was passiert, wenn eine Berechtigungsabfrage angezeigt würde, aber kein interaktives TTY verfügbar ist (was bei ACP-Sitzungen immer der Fall ist).

| Wert   | Verhalten                                                        |
| ------ | ---------------------------------------------------------------- |
| `fail` | Sitzung mit `AcpRuntimeError` abbrechen. **(Standard)**          |
| `deny` | Die Berechtigung stillschweigend verweigern und fortfahren (Graceful Degradation). |

### Konfiguration

Über Plugin-Konfiguration setzen:

```bash
openclaw config set plugins.entries.acpx.config.permissionMode approve-all
openclaw config set plugins.entries.acpx.config.nonInteractivePermissions fail
```

Starten Sie das Gateway nach dem Ändern dieser Werte neu.

> **Wichtig:** OpenClaw verwendet derzeit standardmäßig `permissionMode=approve-reads` und `nonInteractivePermissions=fail`. In nicht interaktiven ACP-Sitzungen kann jeder Schreib- oder Exec-Vorgang, der eine Berechtigungsabfrage auslöst, mit `AcpRuntimeError: Permission prompt unavailable in non-interactive mode` fehlschlagen.
>
> Wenn Sie Berechtigungen einschränken müssen, setzen Sie `nonInteractivePermissions` auf `deny`, damit Sitzungen sich kontrolliert verschlechtern, statt abzustürzen.

## Fehlerbehebung

| Symptom                                                                     | Wahrscheinliche Ursache                                                           | Behebung                                                                                                                                                            |
| --------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ACP runtime backend is not configured`                                     | Backend-Plugin fehlt oder ist deaktiviert.                                        | Backend-Plugin installieren und aktivieren, dann `/acp doctor` ausführen.                                                                                          |
| `ACP is disabled by policy (acp.enabled=false)`                             | ACP ist global deaktiviert.                                                       | `acp.enabled=true` setzen.                                                                                                                                          |
| `ACP dispatch is disabled by policy (acp.dispatch.enabled=false)`           | Dispatch aus normalen Thread-Nachrichten ist deaktiviert.                         | `acp.dispatch.enabled=true` setzen.                                                                                                                                 |
| `ACP agent "<id>" is not allowed by policy`                                 | Agent ist nicht in der Allowlist.                                                 | Erlaubte `agentId` verwenden oder `acp.allowedAgents` aktualisieren.                                                                                                 |
| `Unable to resolve session target: ...`                                     | Ungültiges Schlüssel-/ID-/Label-Token.                                            | `/acp sessions` ausführen, exakten Schlüssel/Label kopieren, erneut versuchen.                                                                                      |
| `--bind here requires running /acp spawn inside an active ... conversation` | `--bind here` wurde ohne aktive bindbare Konversation verwendet.                  | Zum Ziel-Chat/-Channel wechseln und erneut versuchen oder ungebundenen Spawn verwenden.                                                                             |
| `Conversation bindings are unavailable for <channel>.`                      | Adapter besitzt keine ACP-Bindungsfähigkeit für aktuelle Konversationen.          | `/acp spawn ... --thread ...` verwenden, wo unterstützt, Top-Level-`bindings[]` konfigurieren oder zu einem unterstützten Channel wechseln.                       |
| `--thread here requires running /acp spawn inside an active ... thread`     | `--thread here` wurde außerhalb eines Thread-Kontexts verwendet.                  | Zum Ziel-Thread wechseln oder `--thread auto`/`off` verwenden.                                                                                                      |
| `Only <user-id> can rebind this channel/conversation/thread.`               | Ein anderer Benutzer besitzt das aktive Binding-Ziel.                             | Als Eigentümer neu binden oder eine andere Konversation bzw. einen anderen Thread verwenden.                                                                       |
| `Thread bindings are unavailable for <channel>.`                            | Adapter besitzt keine Thread-Bindungsfähigkeit.                                   | `--thread off` verwenden oder zu einem unterstützten Adapter/Channel wechseln.                                                                                     |
| `Sandboxed sessions cannot spawn ACP sessions ...`                          | ACP-Laufzeit läuft auf dem Host; die anfordernde Sitzung ist sandboxed.           | `runtime="subagent"` aus sandboxed Sitzungen verwenden oder ACP-Spawn aus einer nicht sandboxed Sitzung ausführen.                                                |
| `sessions_spawn sandbox="require" is unsupported for runtime="acp" ...`     | `sandbox="require"` wurde für die ACP-Laufzeit angefordert.                       | `runtime="subagent"` für obligatorische Sandbox-Ausführung verwenden oder ACP mit `sandbox="inherit"` aus einer nicht sandboxed Sitzung verwenden.                |
| Missing ACP metadata for bound session                                      | Veraltete/gelöschte ACP-Sitzungsmetadaten.                                        | Mit `/acp spawn` neu erstellen und dann Thread erneut binden/fokussieren.                                                                                          |
| `AcpRuntimeError: Permission prompt unavailable in non-interactive mode`    | `permissionMode` blockiert Schreib-/Exec-Vorgänge in nicht interaktiver ACP-Sitzung. | `plugins.entries.acpx.config.permissionMode` auf `approve-all` setzen und Gateway neu starten. Siehe [Konfiguration von Berechtigungen](#konfiguration-von-berechtigungen). |
| ACP-Sitzung schlägt früh mit wenig Ausgabe fehl                             | Berechtigungsabfragen werden durch `permissionMode`/`nonInteractivePermissions` blockiert. | Gateway-Logs auf `AcpRuntimeError` prüfen. Für vollständige Berechtigungen `permissionMode=approve-all` setzen; für Graceful Degradation `nonInteractivePermissions=deny` setzen. |
| ACP-Sitzung hängt nach Abschluss der Arbeit unbegrenzt                      | Harness-Prozess ist beendet, aber die ACP-Sitzung hat den Abschluss nicht gemeldet. | Mit `ps aux \| grep acpx` überwachen; veraltete Prozesse manuell beenden.                                                                                          |
