OpenClaw ACP-Agenten: Externe Coding-Tools effizient nutzen

Schneller Workflow für Operator

Nutze diese Anleitung, wenn du ein praktisches /acp Runbook brauchst:

1. Session starten:

   /acp spawn codex --mode persistent --thread auto

2. Im gebundenen Thread arbeiten (oder den Session-Key direkt ansprechen).
3. Runtime-Status prüfen:

   /acp status

4. Runtime-Optionen nach Bedarf anpassen:

   /acp model <provider/model>

   /acp permissions <profile>

   /acp timeout <seconds>

5. Eine aktive Session anstupsen, ohne den Kontext zu ersetzen:

   /acp steer tighten logging and continue

6. Arbeit beenden:
   • /acp cancel (aktuellen Turn stoppen) oder
   • /acp close (Session schließen + Bindings entfernen)

Schnellstart für Menschen

Beispiele für natürliche Anfragen:

• “Starte eine persistente Codex-Session in einem Thread und bleib fokussiert.”
• “Führe das als One-Shot Claude Code ACP-Session aus und fass das Ergebnis zusammen.”
• “Nutze Gemini CLI für diese Aufgabe in einem Thread und behalte Follow-ups im selben Thread.”

Was OpenClaw tun sollte:

1. runtime: "acp" wählen.
2. Das angeforderte Harness-Ziel auflösen (agentId, zum Beispiel codex).
3. Wenn eine Thread-Bindung angefordert wurde und der aktuelle Channel das unterstützt, die ACP-Session an den Thread binden.
4. Follow-up-Nachrichten im Thread an dieselbe ACP-Session leiten, bis der Fokus verloren geht, die Session geschlossen wird oder die Zeit abläuft.

ACP im Vergleich zu Sub-Agents

Nutze ACP, wenn du eine externe Harness-Runtime willst. Nutze Sub-Agents für OpenClaw-native delegierte Durchläufe.

Bereich	ACP-Session	Sub-Agent Run
Runtime	ACP Backend-Plugin (z. B. acpx)	OpenClaw native Sub-Agent Runtime
Session-Key	agent:<agentId>:acp:<uuid>	agent:<agentId>:subagent:<uuid>
Hauptbefehle	/acp ...	/subagents ...
Spawn-Tool	sessions_spawn mit runtime:"acp"	sessions_spawn (Standard-Runtime)

Siehe auch Sub-agents.

Thread-gebundene Sessions (Kanal-agnostisch)

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

• OpenClaw bindet einen Thread an eine Ziel-ACP-Session.
• Follow-up-Nachrichten in diesem Thread gehen an die gebundene ACP-Session.
• ACP-Output wird in denselben Thread zurückgeliefert.
• Unfocus, Schließen, Archivieren, Idle-Timeout oder das maximale Alter entfernen die Bindung.

Der Support für Thread-Binding ist adapterspezifisch. Wenn der aktive Channel-Adapter keine Thread-Bindings unterstützt, gibt OpenClaw eine klare Meldung aus, dass die Funktion nicht verfügbar ist.

Erforderliche Feature-Flags für Thread-gebundenes ACP:

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

Kanäle mit Thread-Support

• Jeder Channel-Adapter, der Session/Thread-Binding-Fähigkeiten bereitstellt.
• Discord Threads und Channels.
• Telegram Topics (Forum-Topics in Gruppen/Supergruppen und DM-Topics).
• Plugin-Channels können Support über dasselbe Binding-Interface hinzufügen.

Kanalspezifische Einstellungen

Für dauerhafte Workflows konfigurierst du persistente ACP-Bindings in den bindings[]-Einträgen auf oberster Ebene.

Binding-Modell

• bindings[].type="acp" markiert ein persistentes ACP-Konversations-Binding.
• bindings[].match identifiziert die Ziel-Konversation:
  • Discord-Kanal oder Thread: match.channel="discord" + match.peer.id="<channelOrThreadId>"
  • Telegram-Forum-Thema: match.channel="telegram" + match.peer.id="<chatId>:topic:<topicId>"
• bindings[].agentId ist die ID des besitzenden OpenClaw-Agents.
• Optionale ACP-Overrides findest du unter bindings[].acp:
  • mode (persistent oder oneshot)
  • label
  • cwd
  • backend

Runtime-Defaults pro Agent

Verwende agents.list[].runtime, um ACP-Defaults 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

Rangfolge der Overrides für ACP-gebundene Sessions:

1. bindings[].acp.*
2. agents.list[].runtime.acp.*
3. Globale ACP-Defaults (zum Beispiel acp.backend)

Beispiel:

{
  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 sicher, dass die konfigurierte ACP-Session vor der Nutzung existiert.
• Nachrichten in diesem Kanal oder Thema werden an die konfigurierte ACP-Session geleitet.
• In gebundenen Konversationen setzen /new und /reset denselben ACP-Session-Key direkt zurück.
• Temporäre Runtime-Bindings (etwa durch Thread-Focus-Flows) bleiben aktiv, sofern sie existieren.

ACP-Sessions starten (Interfaces)

Über sessions_spawn

Nutze runtime: "acp", um eine ACP-Session aus einem Agent-Turn oder Tool-Call zu starten.

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

Hinweise:

• runtime ist standardmäßig subagent. Setze runtime: "acp" explizit für ACP-Sessions.
• Wenn agentId fehlt, nutzt OpenClaw acp.defaultAgent, falls konfiguriert.
• mode: "session" erfordert thread: true, um eine persistente, gebundene Konversation beizubehalten.

Interface-Details:

• task (erforderlich): Initialer Prompt an die ACP-Session.
• runtime (erforderlich für ACP): Muss "acp" sein.
• agentId (optional): ACP-Ziel-Harness-ID. Nutzt acp.defaultAgent als Fallback.
• thread (optional, Standard false): Fordert Thread-Binding-Flow an, wo unterstützt.
• mode (optional): run (einmalig) oder session (persistent).
  • Standard ist run.
  • Wenn thread: true gesetzt und der Modus weggelassen wird, wählt OpenClaw je nach Runtime-Pfad eventuell persistentes Verhalten.
  • mode: "session" setzt thread: true voraus.
• cwd (optional): Gewünschtes Arbeitsverzeichnis der Runtime (validiert durch Backend/Runtime-Policy).
• label (optional): Label für den Operator, das in Session- oder Banner-Texten erscheint.
• resumeSessionId (optional): Setzt eine bestehende ACP-Session fort, statt eine neue zu erstellen. Der Agent spielt den Konversationsverlauf via session/load ab. Benötigt runtime: "acp".
• streamTo (optional): "parent" streamt Fortschrittszusammenfassungen des initialen ACP-Runs als System-Events zurück zur anfordernden Session.
  • Falls verfügbar, enthalten akzeptierte Antworten einen streamLogPath, der auf ein Session-spezifisches JSONL-Log (<sessionId>.acp-stream.jsonl) zeigt. Dieses kannst du für den vollständigen Verlauf auslesen.

Bestehende Session fortsetzen

Nutze resumeSessionId, um eine vorherige ACP-Session weiterzuführen. Der Agent lädt die Historie über session/load und arbeitet mit dem vollen Kontext weiter.

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

Typische Anwendungsfälle:

• Übergib eine Codex-Session von deinem Laptop an dein Handy – dein Agent macht genau dort weiter, wo du aufgehört hast.
• Führe eine Coding-Session fort, die du interaktiv im CLI gestartet hast, jetzt aber headless über deinen Agenten steuerst.
• Setze Arbeit fort, die durch einen Gateway-Neustart oder ein Idle-Timeout unterbrochen wurde.

Hinweise:

• resumeSessionId benötigt zwingend runtime: "acp". Bei Nutzung mit der Sub-Agent-Runtime erhältst du eine Fehlermeldung.
• resumeSessionId stellt die Upstream-ACP-Historie wieder her. thread und mode gelten weiterhin für die neue OpenClaw-Session, daher erfordert mode: "session" immer noch thread: true.
• Der Ziel-Agent muss session/load unterstützen (Codex und Claude Code tun dies).
• Wird die Session-ID nicht gefunden, schlägt der Spawn mit einer klaren Fehlermeldung fehl – es gibt keinen stillen Fallback auf eine neue Session.

Smoke-Test für Operatoren

Nutze diesen Test nach einem Gateway-Deploy, um sicherzustellen, dass der ACP-Spawn end-to-end funktioniert und nicht nur Unit-Tests besteht.

Empfohlener Ablauf:

1. Prüfe die installierte Gateway-Version/Commit auf dem Ziel-Host.
2. Bestätige, dass der Quellcode die ACP-Lineage-Akzeptanz in src/gateway/sessions-patch.ts enthält (subagent:* oder acp:* sessions).
3. Öffne eine temporäre ACPX-Bridge-Session zu einem Live-Agenten (zum Beispiel razor(main) auf jpclawhq).
4. Weise diesen Agenten an, sessions_spawn aufzurufen mit:
   • runtime: "acp"
   • agentId: "codex"
   • mode: "run"
   • task: Reply with exactly LIVE-ACP-SPAWN-OK
5. Überprüfe die Rückmeldung des Agenten:
   • accepted=yes
   • eine echte childSessionKey
   • kein Validator-Fehler
6. Schließe die temporäre ACPX-Bridge-Session.

Beispiel-Prompt für den Live-Agenten:

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:

• Nutze für diesen Smoke-Test mode: "run", außer du testest gezielt thread-gebundene persistente ACP-Sessions.
• Fordere für den Basis-Check kein streamTo: "parent" an. Dieser Pfad hängt von den Fähigkeiten der anfordernden Session ab und ist ein separater Integrationsschritt.
• Teste thread-gebundene mode: "session"-Szenarien in einem zweiten, tiefergehenden Durchlauf aus einem echten Discord-Thread oder Telegram-Thema.

Sandbox-Kompatibilität

ACP-Sessions laufen derzeit auf der Host-Runtime, nicht innerhalb der OpenClaw-Sandbox.

Aktuelle Einschränkungen:

• Wenn die anfordernde Session sandboxed ist, werden ACP-Spawns blockiert. Das gilt für sessions_spawn({ runtime: "acp" }) und /acp spawn.
  • 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 kein sandbox: "require".
  • Fehler: sessions_spawn sandbox="require" is unsupported for runtime="acp" because ACP sessions run outside the sandbox. Use runtime="subagent" or sandbox="inherit".

Verwende runtime: "subagent", wenn du eine durch die Sandbox erzwungene Ausführung benötigst.

Über den /acp-Befehl

Nutze /acp spawn für die explizite Steuerung durch den Operator direkt aus dem Chat.

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

Wichtige Flags:

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

Siehe Slash Commands.

Auflösung des Session-Ziels

Die meisten /acp-Aktionen akzeptieren ein optionales Session-Ziel (session-key, session-id oder session-label).

Reihenfolge der Auflösung:

1. Explizites Ziel-Argument (oder --session für /acp steer)
   • prüft zuerst den Key
   • dann die UUID-förmige Session-ID
   • schließlich das Label
2. Aktuelles Thread-Binding (falls diese Konversation/dieser Thread an eine ACP-Session gebunden ist)
3. Fallback auf die aktuelle anfordernde Session

Wenn kein Ziel aufgelöst werden kann, gibt OpenClaw eine Fehlermeldung zurück (Unable to resolve session target: ...).

AI Setup Assistant

Nächste Schritte

• Slash Commands
• Agent Configuration

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 Child-Thread erstellen/binden, wenn unterstützt.
here	Erfordert den aktuellen aktiven Thread; schlägt fehl, wenn du dich in keinem befindest.
off	Keine Bindung. Die Session startet ungebunden.

Hinweise:

• Auf Oberflächen ohne Thread-Binding ist das Standardverhalten effektiv off.
• Ein Thread-gebundener Spawn erfordert die Unterstützung der Channel-Policy:
  • Discord: channels.discord.threadBindings.spawnAcpSessions=true
  • Telegram: channels.telegram.threadBindings.spawnAcpSessions=true

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 dir die effektiven Runtime-Optionen an. Wenn verfügbar, siehst du dort sowohl die Session-Identifier der Runtime-Ebene als auch der Backend-Ebene.

Manche Steuerungen hängen von den Backend-Capabilities ab. Falls ein Backend eine Steuerung nicht unterstützt, gibt OpenClaw eine klare Fehlermeldung für nicht unterstützte Befehle aus.

ACP-Befehlsübersicht

Befehl	Funktion	Beispiel
/acp spawn	Erstelle eine ACP-Session; optionale Thread-Bindung.	/acp spawn codex --mode persistent --thread auto --cwd /repo
/acp cancel	Laufenden Turn für die Ziel-Session abbrechen.	/acp cancel agent:codex:acp:<uuid>
/acp steer	Steer-Anweisung an eine laufende Session senden.	/acp steer --session support inbox prioritize failing tests
/acp close	Session schließen und Thread-Bindungen aufheben.	/acp close
/acp status	Backend, Modus, Status, Runtime-Optionen und Capabilities anzeigen.	/acp status
/acp set-mode	Runtime-Modus für die Ziel-Session festlegen.	/acp set-mode plan
/acp set	Generisches Schreiben von Runtime-Konfigurationsoptionen.	/acp set model openai/gpt-5.2
/acp cwd	Runtime Working Directory Override festlegen.	/acp cwd /Users/user/Projects/repo
/acp permissions	Approval-Policy-Profil festlegen.	/acp permissions strict
/acp timeout	Runtime-Timeout festlegen (Sekunden).	/acp timeout 120
/acp model	Runtime-Model-Override festlegen.	/acp model anthropic/claude-opus-4-5
/acp reset-options	Runtime-Option-Overrides der Session entfernen.	/acp reset-options
/acp sessions	Letzte ACP-Sessions aus dem Speicher auflisten.	/acp sessions
/acp doctor	Backend-Status, Capabilities, Fehlerbehebungen und System-Checks.	/acp doctor
/acp install	Deterministische Installations- und Aktivierungsschritte ausgeben.	/acp install

Mapping der Runtime-Optionen

/acp bietet dir praktische Befehle und einen generischen Setter.

Gleichwertige Operationen:

• /acp model <id> wird auf den Runtime-Config-Key model gemappt.
• /acp permissions <profile> wird auf den Runtime-Config-Key approval_policy gemappt.
• /acp timeout <seconds> wird auf den Runtime-Config-Key timeout gemappt.
• /acp cwd <path> aktualisiert den Runtime-cwd-Override direkt.
• /acp set <key> <value> ist der generische Pfad.
  • Spezialfall: key=cwd nutzt den Pfad für den cwd-Override.

acpx Harness-Unterstützung (aktuell)

Aktuell integrierte Harness-Aliase in acpx:

• pi
• claude
• codex
• opencode
• gemini
• kimi

Wenn OpenClaw das acpx-Backend verwendet, solltest du diese Werte für agentId bevorzugen, es sei denn, deine acpx-Konfiguration definiert eigene Agent-Aliase.

Die direkte Nutzung der acpx CLI kann über --agent <command> auch beliebige Adapter ansteuern. Dieser direkte Escape-Hatch ist ein Feature der acpx CLI und nicht der normale Pfad für die OpenClaw agentId.

Erforderliche Konfiguration

Core ACP Baseline:

{
  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: ["pi", "claude", "codex", "opencode", "gemini", "kimi"],
    maxConcurrentSessions: 8,
    stream: {
      coalesceIdleMs: 300,
      maxChunkChars: 1200,
    },
    runtime: {
      ttlMinutes: 120,
    },
  },
}

Die Konfiguration für das Thread-Binding ist spezifisch für den jeweiligen Channel-Adapter. Hier ist ein Beispiel für Discord:

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

Falls das Erstellen von ACP-Sessions via Thread-Binding nicht funktioniert, solltest du zuerst das Feature-Flag des Adapters prüfen:

• Discord: channels.discord.threadBindings.spawnAcpSessions=true

Schau dir dazu die Configuration Reference an.

Plugin-Einrichtung für das acpx-Backend

Installiere und aktiviere das Plugin:

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

Lokale Installation im Workspace während der Entwicklung:

openclaw plugins install ./extensions/acpx

Überprüfe danach den Status des Backends:

/acp doctor

acpx Befehl und Versionskonfiguration

Standardmäßig nutzt das acpx-Plugin (veröffentlicht als @openclaw/acpx) das lokal im Plugin gepinnte Binary:

1. Der Befehl nutzt standardmäßig extensions/acpx/node_modules/.bin/acpx.
2. Die erwartete Version entspricht standardmäßig dem Extension-Pin.
3. Beim Start wird das ACP-Backend sofort als “not-ready” registriert.
4. Ein Hintergrundjob verifiziert acpx --version.
5. Falls das lokale Binary fehlt oder die Version nicht passt, wird npm install --omit=dev --no-save acpx@<pinned> ausgeführt und erneut geprüft.

Du kannst den Befehl oder die Version in der Plugin-Konfiguration überschreiben:

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

Hinweise:

• command akzeptiert absolute Pfade, relative Pfade oder den Befehlsnamen (acpx).
• Relative Pfade beziehen sich auf das OpenClaw-Workspace-Verzeichnis.
• expectedVersion: "any" deaktiviert den strikten Versionsabgleich.
• Wenn command auf ein benutzerdefiniertes Binary oder einen Pfad zeigt, wird die automatische Installation deaktiviert.
• Der OpenClaw-Start bleibt non-blocking, während der Health Check des Backends läuft.

Siehe Plugins.

Berechtigungskonfiguration

ACP-Sessions laufen non-interaktiv – es gibt kein TTY, um Bestätigungsanfragen für Schreibzugriffe oder Shell-Befehle zu beantworten. Das acpx-Plugin bietet zwei Konfigurationsschlüssel, um den Umgang mit Berechtigungen zu steuern:

permissionMode

Steuert, welche Operationen der Agent ohne Rückfrage ausführen darf.

Wert	Verhalten
approve-all	Alle Schreibzugriffe und Shell-Befehle automatisch erlauben.
approve-reads	Nur Lesezugriffe erlauben; Schreiben und Ausführen erfordern Bestätigung.
deny-all	Alle Berechtigungsanfragen ablehnen.

nonInteractivePermissions

Steuert, was passiert, wenn eine Berechtigungsanfrage erscheint, aber kein interaktives TTY verfügbar ist (was bei ACP-Sessions immer der Fall ist).

Wert	Verhalten
fail	Bricht die Session mit AcpRuntimeError ab. (Standard)
deny	Lehnt die Berechtigung lautlos ab und fährt fort (graceful degradation).

Konfiguration

Die Einstellung erfolgt über die Plugin-Konfiguration:

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

Starte das Gateway nach der Änderung dieser Werte neu.

Wichtig: OpenClaw nutzt standardmäßig permissionMode=approve-reads und nonInteractivePermissions=fail. In non-interaktiven ACP-Sessions führt jeder Schreib- oder Ausführungsbefehl, der eine Bestätigung auslöst, zu einem Fehler: AcpRuntimeError: Permission prompt unavailable in non-interactive mode.

Wenn du Berechtigungen einschränken musst, setze nonInteractivePermissions auf deny, damit Sessions kontrolliert weiterlaufen, statt abzustürzen.

Fehlerbehebung

Symptom	Wahrscheinliche Ursache	Lösung
ACP runtime backend is not configured	Backend-Plugin fehlt oder ist deaktiviert.	Installiere und aktiviere das Backend-Plugin, führe dann /acp doctor aus.
ACP is disabled by policy (acp.enabled=false)	ACP ist global deaktiviert.	Setze acp.enabled=true.
ACP dispatch is disabled by policy (acp.dispatch.enabled=false)	Dispatch von normalen Thread-Nachrichten ist deaktiviert.	Setze acp.dispatch.enabled=true.
ACP agent "<id>" is not allowed by policy	Agent ist nicht auf der Allowlist.	Nutze eine erlaubte agentId oder aktualisiere acp.allowedAgents.
Unable to resolve session target: ...	Falscher Key, ID oder Label-Token.	Führe /acp sessions aus, kopiere den exakten Key oder das Label und versuche es erneut.
--thread here requires running /acp spawn inside an active ... thread	--thread here wurde außerhalb eines Thread-Kontexts genutzt.	Wechsle in den Ziel-Thread oder nutze --thread auto bzw. off.
Only <user-id> can rebind this thread.	Ein anderer User besitzt die Thread-Bindung.	Binde den Thread als Besitzer neu oder nutze einen anderen Thread.
Thread bindings are unavailable for <channel>.	Der Adapter unterstützt keine Thread-Bindung.	Nutze --thread off oder wechsle zu einem unterstützten Adapter oder Channel.
Sandboxed sessions cannot spawn ACP sessions ...	Die ACP-Runtime läuft host-seitig; die anfragende Session ist in einer Sandbox.	Nutze runtime="subagent" aus Sandboxed-Sessions oder starte ACP aus einer Session ohne Sandbox.
sessions_spawn sandbox="require" is unsupported for runtime="acp" ...	sandbox="require" wurde für die ACP-Runtime angefordert.	Nutze runtime="subagent" für erforderliches Sandboxing oder ACP mit sandbox="inherit" aus einer Session ohne Sandbox.
Fehlende ACP-Metadaten für gebundene Session	Veraltete oder gelöschte ACP-Session-Metadaten.	Erstelle die Session mit /acp spawn neu und binde den Thread erneut.
AcpRuntimeError: Permission prompt unavailable in non-interactive mode	permissionMode blockiert Schreibzugriffe in non-interaktiver Session.	Setze plugins.entries.acpx.config.permissionMode auf approve-all und starte das Gateway neu. Siehe Berechtigungskonfiguration.
ACP-Session bricht frühzeitig mit wenig Output ab	Berechtigungsanfragen werden blockiert.	Prüfe die Gateway-Logs auf AcpRuntimeError. Setze permissionMode=approve-all für volle Rechte oder nonInteractivePermissions=deny.
ACP-Session hängt unendlich nach Abschluss der Arbeit	Der Harness-Prozess ist beendet, aber die Session meldet keinen Abschluss.	Überwache den Status mit ps aux | grep acpx und beende hängende Prozesse manuell.