---
read_when:
    - ACP के माध्यम से कोडिंग हार्नेस चलाना
    - मैसेजिंग चैनलों पर वार्तालाप से बंधे ACP सत्र सेट अप करना
    - संदेश-चैनल वार्तालाप को स्थायी ACP सत्र से संबद्ध करना
    - ACP बैकएंड, Plugin वायरिंग या पूर्णता डिलीवरी की समस्या निवारण
    - चैट से /acp कमांड संचालित करना
sidebarTitle: ACP agents
summary: ACP बैकएंड के माध्यम से बाहरी कोडिंग हार्नेस (Claude Code, Cursor, Gemini CLI, स्पष्ट Codex ACP, OpenClaw ACP, OpenCode) चलाएँ
title: ACP एजेंट्स
x-i18n:
    generated_at: "2026-07-27T18:38:56Z"
    model: gpt-5.6
    postprocess_version: locale-links-v1
    prompt_version: 32
    provider: openai
    source_hash: fc7f32ff927c7e949be1595f6aa00ed034a51185c6a6b1e0df01a242954667d1
    source_path: tools/acp-agents.md
    workflow: 16
---

[Agent Client Protocol (ACP)](https://agentclientprotocol.com/) सत्र OpenClaw को ACP बैकएंड Plugin के माध्यम से बाहरी कोडिंग हार्नेस (Claude Code, Cursor, Copilot, Droid,
OpenClaw ACP, OpenCode, Gemini CLI और अन्य समर्थित ACPX हार्नेस) चलाने देते हैं।
प्रत्येक स्पॉन को [बैकग्राउंड कार्य](/hi/automation/tasks) के रूप में ट्रैक किया जाता है।

<Note>
**ACP बाहरी हार्नेस का मार्ग है, डिफ़ॉल्ट Codex मार्ग नहीं।** नेटिव
Codex ऐप-सर्वर Plugin एजेंट टर्न के लिए `/codex ...` नियंत्रणों और डिफ़ॉल्ट
`openai/gpt-*` एम्बेडेड रनटाइम का स्वामी है; ACP `/acp ...` नियंत्रणों
और `sessions_spawn({ runtime: "acp" })` सत्रों का स्वामी है।

Codex या Claude Code को बाहरी MCP क्लाइंट के रूप में सीधे मौजूदा OpenClaw चैनल वार्तालापों से
कनेक्ट करने के लिए ACP के बजाय
[`openclaw mcp serve`](/hi/cli/mcp) का उपयोग करें।
</Note>

## मुझे कौन-सा पृष्ठ चाहिए?

| आप यह करना चाहते हैं...                                                                        | इसका उपयोग करें                      | टिप्पणियाँ                                                                                                                                                                  |
| ----------------------------------------------------------------------------------------------- | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| वर्तमान वार्तालाप में Codex को बाइंड या नियंत्रित करना                                         | `/codex bind`, `/codex threads`       | `codex` Plugin सक्षम होने पर नेटिव Codex ऐप-सर्वर मार्ग: बाइंड की गई चैट प्रतिक्रियाएँ, इमेज फ़ॉरवर्डिंग, मॉडल/तेज़/अनुमतियाँ, रोकना और दिशा देना। ACP एक स्पष्ट फ़ॉलबैक है |
| OpenClaw के _माध्यम से_ Claude Code, Gemini CLI, स्पष्ट Codex ACP या कोई अन्य बाहरी हार्नेस चलाना | यह पृष्ठ                              | चैट-बाइंड सत्र, `/acp spawn`, `sessions_spawn({ runtime: "acp" })`, बैकग्राउंड कार्य, रनटाइम नियंत्रण                                                                 |
| किसी एडिटर या क्लाइंट के लिए OpenClaw Gateway सत्र को ACP सर्वर _के रूप में_ एक्सपोज़ करना       | [`openclaw acp`](/hi/cli/acp)            | ब्रिज मोड: कोई IDE/क्लाइंट stdio/WebSocket पर ACP के माध्यम से OpenClaw से संचार करता है                                                                                   |
| किसी स्थानीय AI CLI को केवल-टेक्स्ट फ़ॉलबैक मॉडल के रूप में पुनः उपयोग करना                     | [CLI बैकएंड](/hi/gateway/cli-backends) | ACP नहीं: कोई OpenClaw टूल नहीं, कोई ACP नियंत्रण नहीं, कोई हार्नेस रनटाइम नहीं                                                                                             |

## क्या यह बिना अतिरिक्त सेटअप के काम करता है?

हाँ, आधिकारिक ACP रनटाइम Plugin इंस्टॉल करने के बाद:

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

सोर्स चेकआउट `pnpm install` के बाद स्थानीय `extensions/acpx` वर्कस्पेस Plugin का उपयोग कर सकते हैं।
तत्परता जाँच के लिए `/acp doctor` चलाएँ।

OpenClaw एजेंटों को ACP स्पॉनिंग के बारे में केवल तभी बताता है, जब ACP **वास्तव में उपयोग योग्य** हो:
ACP सक्षम होना चाहिए, डिस्पैच अक्षम नहीं होना चाहिए, वर्तमान सत्र
सैंडबॉक्स द्वारा अवरुद्ध नहीं होना चाहिए और रनटाइम बैकएंड लोड तथा स्वस्थ होना चाहिए। यदि
कोई भी शर्त विफल होती है, तो ACP Skills और `sessions_spawn` ACP मार्गदर्शन छिपे रहते हैं,
ताकि एजेंट किसी अनुपलब्ध बैकएंड का सुझाव न दे।

<AccordionGroup>
  <Accordion title="पहली बार चलाने की समस्याएँ">
    - यदि `plugins.allow` सेट है, तो यह एक प्रतिबंधात्मक Plugin सूची है और इसमें `acpx` **अवश्य** शामिल होना चाहिए, अन्यथा इंस्टॉल किया गया ACP बैकएंड जानबूझकर अवरुद्ध कर दिया जाता है (`/acp doctor` अनुपस्थित अनुमत-सूची प्रविष्टि की रिपोर्ट करता है)।
    - Codex ACP अडैप्टर `acpx` Plugin के साथ आता है और संभव होने पर स्थानीय रूप से लॉन्च होता है।
    - Codex ACP एक अलग `CODEX_HOME` के साथ चलता है। OpenClaw होस्ट Codex कॉन्फ़िगरेशन से विश्वसनीय प्रोजेक्ट ट्रस्ट प्रविष्टियाँ और सुरक्षित मॉडल/प्रोवाइडर रूटिंग कॉन्फ़िगरेशन (`model`, `model_provider`, `model_reasoning_effort`, `sandbox_mode` और सुरक्षित `model_providers.<name>` फ़ील्ड) कॉपी करता है; प्रमाणीकरण, सूचनाएँ और हुक केवल होस्ट कॉन्फ़िगरेशन में रहते हैं।
    - पहली बार उपयोग किए जाने पर अन्य लक्ष्य हार्नेस अडैप्टर `npx` के साथ माँग पर फ़ेच किए जा सकते हैं।
    - उस हार्नेस के लिए वेंडर प्रमाणीकरण होस्ट पर पहले से मौजूद होना चाहिए।
    - यदि होस्ट के पास npm या नेटवर्क पहुँच नहीं है, तो पहली बार अडैप्टर फ़ेच तब तक विफल होते हैं, जब तक कैश पहले से वार्म न किए जाएँ या अडैप्टर किसी अन्य तरीके से इंस्टॉल न किया जाए।

  </Accordion>
  <Accordion title="रनटाइम की पूर्वापेक्षाएँ">
    ACP एक वास्तविक बाहरी हार्नेस प्रक्रिया लॉन्च करता है। OpenClaw रूटिंग,
    बैकग्राउंड-कार्य स्थिति, डिलीवरी, बाइंडिंग और नीति का स्वामी है; हार्नेस
    अपने प्रोवाइडर लॉगिन, मॉडल कैटलॉग, फ़ाइल-सिस्टम व्यवहार और नेटिव टूल का स्वामी है।

    OpenClaw को दोष देने से पहले यह सत्यापित करें:

    - `/acp doctor` एक सक्षम, स्वस्थ बैकएंड की रिपोर्ट करता है।
    - जब अनुमत-सूची सेट हो, तब लक्ष्य आईडी को `acp.allowedAgents` द्वारा अनुमति प्राप्त हो।
    - हार्नेस कमांड Gateway होस्ट पर शुरू हो सके।
    - उस हार्नेस के लिए प्रोवाइडर प्रमाणीकरण मौजूद हो (`claude`, `codex`, `gemini`, `opencode`, `droid` आदि)।
    - चयनित मॉडल उस हार्नेस के लिए मौजूद हो - मॉडल आईडी हार्नेसों के बीच पोर्टेबल नहीं होते।
    - अनुरोधित `cwd` मौजूद और पहुँच योग्य हो, या `cwd` छोड़ दें और बैकएंड को अपना डिफ़ॉल्ट उपयोग करने दें।
    - अनुमति मोड कार्य से मेल खाता हो। गैर-इंटरैक्टिव सत्र नेटिव अनुमति प्रॉम्प्ट पर क्लिक नहीं कर सकते, इसलिए लिखने/निष्पादन पर अधिक निर्भर कोडिंग रन को सामान्यतः ऐसे ACPX अनुमति प्रोफ़ाइल की आवश्यकता होती है, जो हेडलेस रूप से आगे बढ़ सके।

  </Accordion>
</AccordionGroup>

OpenClaw Plugin टूल और अंतर्निहित OpenClaw टूल डिफ़ॉल्ट रूप से ACP हार्नेसों के लिए
एक्सपोज़ **नहीं** किए जाते। स्पष्ट MCP ब्रिजों को
[ACP एजेंट - सेटअप](/hi/tools/acp-agents-setup) में केवल तभी सक्षम करें, जब हार्नेस को
उन टूल को सीधे कॉल करना हो।

## समर्थित हार्नेस लक्ष्य

`acpx` बैकएंड के साथ इन आईडी का उपयोग `/acp spawn <id>` या
`sessions_spawn({ runtime: "acp", agentId: "<id>" })` लक्ष्य के रूप में करें:

| हार्नेस आईडी   | सामान्य बैकएंड                                | टिप्पणियाँ                                                                               |
| ------------ | ---------------------------------------------- | ----------------------------------------------------------------------------------- |
| `claude`     | Claude Code ACP अडैप्टर                        | होस्ट पर Claude Code प्रमाणीकरण आवश्यक है।                                              |
| `codex`      | Codex ACP अडैप्टर                              | केवल तब स्पष्ट ACP फ़ॉलबैक, जब नेटिव `/codex` अनुपलब्ध हो या ACP का अनुरोध किया गया हो। |
| `copilot`    | GitHub Copilot ACP अडैप्टर                     | Copilot CLI/रनटाइम प्रमाणीकरण आवश्यक है।                                                  |
| `cursor`     | Cursor CLI ACP (`cursor-agent acp`)            | यदि कोई स्थानीय इंस्टॉलेशन अलग ACP एंट्रीपॉइंट एक्सपोज़ करता है, तो acpx कमांड ओवरराइड करें।    |
| `droid`      | Factory Droid CLI                              | हार्नेस परिवेश में Factory/Droid प्रमाणीकरण या `FACTORY_API_KEY` आवश्यक है।        |
| `fast-agent` | fast-agent-mcp ACP अडैप्टर                     | `uvx` के साथ माँग पर फ़ेच किया जाता है।                                                       |
| `gemini`     | Gemini CLI ACP अडैप्टर                         | Gemini CLI प्रमाणीकरण या API कुंजी सेटअप आवश्यक है।                                          |
| `iflow`      | iFlow CLI                                      | अडैप्टर की उपलब्धता और मॉडल नियंत्रण इंस्टॉल किए गए CLI पर निर्भर करते हैं।                 |
| `kilocode`   | Kilo Code CLI                                  | अडैप्टर की उपलब्धता और मॉडल नियंत्रण इंस्टॉल किए गए CLI पर निर्भर करते हैं।                 |
| `kimi`       | Kimi/Moonshot CLI                              | होस्ट पर Kimi/Moonshot प्रमाणीकरण आवश्यक है।                                            |
| `kiro`       | Kiro CLI                                       | अडैप्टर की उपलब्धता और मॉडल नियंत्रण इंस्टॉल किए गए CLI पर निर्भर करते हैं।                 |
| `mux`        | Mux CLI ACP अडैप्टर                            | `npx` के साथ माँग पर फ़ेच किया जाता है।                                                       |
| `opencode`   | OpenCode ACP अडैप्टर                           | OpenCode CLI/प्रोवाइडर प्रमाणीकरण आवश्यक है।                                                |
| `openclaw`   | `openclaw acp` के माध्यम से OpenClaw Gateway ब्रिज | ACP-सक्षम हार्नेस को OpenClaw Gateway सत्र से वापस संचार करने देता है।                 |
| `qoder`      | Qoder CLI                                      | अडैप्टर की उपलब्धता और मॉडल नियंत्रण इंस्टॉल किए गए CLI पर निर्भर करते हैं।                 |
| `qwen`       | Qwen Code / Qwen CLI                           | होस्ट पर Qwen-संगत प्रमाणीकरण आवश्यक है।                                          |
| `trae`       | Trae CLI ACP अडैप्टर                           | अडैप्टर की उपलब्धता और मॉडल नियंत्रण इंस्टॉल किए गए CLI पर निर्भर करते हैं।                 |

`pi` (pi-acp) भी acpx बैकएंड में पंजीकृत है, लेकिन यह ऊपर दिए गए अन्य हार्नेसों के समान अर्थ में
कोडिंग हार्नेस नहीं है।

कस्टम acpx एजेंट उपनाम acpx में ही कॉन्फ़िगर किए जा सकते हैं, लेकिन OpenClaw
नीति डिस्पैच से पहले फिर भी `acp.allowedAgents` और किसी भी
`agents.entries.*.runtime.acp.agent` मैपिंग की जाँच करती है।

## ऑपरेटर रनबुक

चैट से त्वरित `/acp` प्रवाह:

<Steps>
  <Step title="स्पॉन करें">
    `/acp spawn claude --bind here`,
    `/acp spawn gemini --mode persistent --thread auto`, या स्पष्ट
    `/acp spawn codex --bind here`।
  </Step>
  <Step title="काम करें">
    बाइंड की गई वार्तालाप या थ्रेड में जारी रखें (या सत्र कुंजी को
    स्पष्ट रूप से लक्षित करें)।
  </Step>
  <Step title="स्थिति जाँचें">
    `/acp status`
  </Step>
  <Step title="समायोजित करें">
    `/acp model <provider/model>`, `/acp permissions <profile>`,
    `/acp timeout <seconds>`।
  </Step>
  <Step title="दिशा दें">
    संदर्भ बदले बिना: `/acp steer tighten logging and continue`।
  </Step>
  <Step title="रोकें">
    `/acp cancel` (वर्तमान टर्न) या `/acp close` (सत्र + बाइंडिंग)।
  </Step>
</Steps>

<AccordionGroup>
  <Accordion title="जीवनचक्र विवरण">
    - स्पॉन किसी ACP रनटाइम सत्र को बनाता या फिर से शुरू करता है, OpenClaw सत्र स्टोर में ACP मेटाडेटा दर्ज करता है, और जब रन का स्वामित्व पैरेंट के पास हो, तब एक पृष्ठभूमि कार्य बना सकता है।
    - पैरेंट-स्वामित्व वाले ACP सत्रों को पृष्ठभूमि कार्य माना जाता है, भले ही रनटाइम सत्र स्थायी हो; पूर्णता और विभिन्न सतहों पर डिलीवरी सामान्य उपयोगकर्ता-दृश्य चैट सत्र की तरह व्यवहार करने के बजाय पैरेंट कार्य सूचक के माध्यम से होती है।
    - कार्य रखरखाव टर्मिनल या अनाथ पैरेंट-स्वामित्व वाले एकल-रन ACP सत्रों को बंद करता है। सक्रिय वार्तालाप बाइंडिंग बने रहने तक स्थायी ACP सत्र संरक्षित रहते हैं; सक्रिय बाइंडिंग के बिना पुराने स्थायी सत्र बंद कर दिए जाते हैं, ताकि स्वामी कार्य पूरा हो जाने या उसका कार्य रिकॉर्ड मिट जाने के बाद उन्हें चुपचाप फिर से शुरू न किया जा सके।
    - बाइंड किए गए अनुवर्ती संदेश सीधे ACP सत्र में जाते हैं, जब तक कि बाइंडिंग बंद, अनफोकस, रीसेट या समाप्त न हो जाए।
    - Gateway कमांड स्थानीय रहते हैं। `/acp ...`, `/status`, और `/unfocus` को बाइंड किए गए ACP हार्नेस में सामान्य प्रॉम्प्ट टेक्स्ट के रूप में कभी नहीं भेजा जाता।
    - `cancel` बैकएंड द्वारा रद्दीकरण समर्थित होने पर सक्रिय टर्न को निरस्त करता है; यह बाइंडिंग या सत्र मेटाडेटा को नहीं मिटाता।
    - `close` OpenClaw के दृष्टिकोण से ACP सत्र समाप्त करता है और बाइंडिंग हटा देता है। यदि कोई हार्नेस पुनरारंभ का समर्थन करता है, तो वह अपना अपस्ट्रीम इतिहास अब भी रख सकता है।
    - acpx Plugin `close` के बाद OpenClaw-स्वामित्व वाले रैपर और अडैप्टर प्रोसेस ट्री साफ़ करता है, और Gateway स्टार्टअप के दौरान पुराने OpenClaw-स्वामित्व वाले ACPX अनाथ प्रोसेस हटाता है।
    - निष्क्रिय रनटाइम वर्कर अंतर्निर्मित निष्क्रिय अवधि के बाद सफ़ाई के योग्य होते हैं; संग्रहीत सत्र मेटाडेटा `/acp sessions` के लिए उपलब्ध रहता है।

  </Accordion>
  <Accordion title="नेटिव Codex रूटिंग नियम">
    स्वाभाविक भाषा के वे ट्रिगर जिन्हें सक्षम होने पर **नेटिव Codex Plugin**
    पर रूट होना चाहिए:

    - "इस Discord चैनल को Codex से बाइंड करें।"
    - "इस चैट को Codex थ्रेड `<id>` से अटैच करें।"
    - "Codex थ्रेड दिखाएँ, फिर इसे बाइंड करें।"

    नेटिव Codex वार्तालाप बाइंडिंग डिफ़ॉल्ट चैट-नियंत्रण पथ है।
    OpenClaw डायनेमिक टूल अब भी OpenClaw के माध्यम से निष्पादित होते हैं, जबकि Codex-नेटिव
    टूल, जैसे shell/apply-patch, Codex के भीतर निष्पादित होते हैं। Codex-नेटिव
    टूल इवेंट के लिए, OpenClaw प्रत्येक टर्न पर एक नेटिव हुक रिले इंजेक्ट करता है, ताकि Plugin हुक
    `before_tool_call` को ब्लॉक कर सकें, `after_tool_call` का निरीक्षण कर सकें, और Codex
    `PermissionRequest` इवेंट को OpenClaw अनुमोदनों के माध्यम से रूट कर सकें। Codex `Stop` हुक
    OpenClaw `before_agent_finalize` में रिले किए जाते हैं, जहाँ Plugin
    Codex द्वारा उत्तर को अंतिम रूप देने से पहले मॉडल का एक और पास अनुरोध कर सकते हैं। रिले को
    जानबूझकर रूढ़िवादी रखा गया है: यह Codex-नेटिव टूल आर्ग्युमेंट को परिवर्तित
    या Codex थ्रेड रिकॉर्ड को दोबारा नहीं लिखता। ACP रनटाइम/सत्र मॉडल चाहिए
    तभी स्पष्ट ACP का उपयोग करें। एम्बेडेड Codex समर्थन सीमा का दस्तावेज़ीकरण
    [Codex हार्नेस v1 समर्थन अनुबंध](/hi/plugins/codex-harness-runtime#v1-support-contract)
    में किया गया है।

  </Accordion>
  <Accordion title="मॉडल / प्रदाता / रनटाइम चयन संक्षिप्त मार्गदर्शिका">
    - लेगेसी Codex मॉडल संदर्भ - लेगेसी Codex OAuth/सदस्यता मॉडल रूट, जिसे डॉक्टर द्वारा सुधारा जाता है।
    - `openai/*` - OpenAI एजेंट टर्न के लिए नेटिव Codex ऐप-सर्वर एम्बेडेड रनटाइम।
    - `/codex ...` - नेटिव Codex वार्तालाप नियंत्रण।
    - `/acp ...` या `runtime: "acp"` - स्पष्ट ACP/acpx नियंत्रण।

  </Accordion>
  <Accordion title="ACP-रूटिंग के स्वाभाविक भाषा ट्रिगर">
    वे ट्रिगर जिन्हें ACP रनटाइम पर रूट होना चाहिए:

    - "इसे एकल-रन Claude Code ACP सत्र के रूप में चलाएँ और परिणाम का सारांश दें।"
    - "इस कार्य के लिए किसी थ्रेड में Gemini CLI का उपयोग करें, फिर अनुवर्ती संदेश उसी थ्रेड में रखें।"
    - "Codex को ACP के माध्यम से किसी पृष्ठभूमि थ्रेड में चलाएँ।"

    OpenClaw `runtime: "acp"` चुनता है, हार्नेस `agentId` का समाधान करता है, समर्थित होने पर
    वर्तमान वार्तालाप या थ्रेड से बाइंड करता है, और बंद होने/समाप्ति तक अनुवर्ती संदेशों को
    उस सत्र पर रूट करता है। Codex इस पथ का अनुसरण केवल तभी करता है जब
    ACP/acpx स्पष्ट हो या अनुरोधित कार्रवाई के लिए नेटिव Codex Plugin
    उपलब्ध न हो।

    `sessions_spawn` के लिए, `runtime: "acp"` का विज्ञापन केवल तभी किया जाता है जब ACP
    सक्षम हो, अनुरोधकर्ता सैंडबॉक्स में न हो, और ACP रनटाइम बैकएंड
    लोड हो। `acp.dispatch.enabled=false` स्वचालित ACP थ्रेड प्रेषण रोकता है,
    लेकिन स्पष्ट `sessions_spawn({ runtime: "acp" })` कॉल को छिपाता या ब्लॉक नहीं
    करता। यह `codex`, `claude`, `droid`,
    `gemini`, या `opencode` जैसे ACP हार्नेस आईडी को लक्षित करता है। `agents_list`
    से सामान्य OpenClaw कॉन्फ़िग एजेंट आईडी तब तक न दें, जब तक वह प्रविष्टि स्पष्ट रूप से
    `agents.entries.*.runtime.type="acp"` के साथ कॉन्फ़िगर न हो; अन्यथा डिफ़ॉल्ट उप-एजेंट
    रनटाइम का उपयोग करें। जब कोई OpenClaw एजेंट
    `runtime.type="acp"` के साथ कॉन्फ़िगर होता है, तो OpenClaw अंतर्निहित
    हार्नेस आईडी के रूप में `runtime.acp.agent` का उपयोग करता है।

  </Accordion>
</AccordionGroup>

## ACP बनाम उप-एजेंट

जब बाहरी हार्नेस रनटाइम चाहिए, तब ACP का उपयोग करें। `codex` Plugin
सक्षम होने पर Codex वार्तालाप बाइंडिंग/नियंत्रण के लिए **नेटिव Codex
ऐप-सर्वर** का उपयोग करें। OpenClaw-नेटिव प्रत्यायोजित रन चाहिए, तब **उप-एजेंट** का उपयोग करें।

| क्षेत्र          | ACP सत्र                           | उप-एजेंट रन                      |
| ------------- | ------------------------------------- | ---------------------------------- |
| रनटाइम       | ACP बैकएंड Plugin (उदाहरण के लिए acpx) | OpenClaw नेटिव उप-एजेंट रनटाइम  |
| सत्र कुंजी   | `agent:<agentId>:acp:<uuid>`          | `agent:<agentId>:subagent:<uuid>`  |
| मुख्य कमांड | `/acp ...`                            | `/subagents ...`                   |
| स्पॉन टूल    | `sessions_spawn`, `runtime:"acp"` के साथ | `sessions_spawn` (डिफ़ॉल्ट रनटाइम) |

[उप-एजेंट](/hi/tools/subagents) भी देखें।

## ACP Claude Code को कैसे चलाता है

ACP के माध्यम से Claude Code के लिए स्टैक यह है:

1. OpenClaw ACP सत्र नियंत्रण प्लेन।
2. आधिकारिक `@openclaw/acpx` रनटाइम Plugin।
3. Claude ACP अडैप्टर।
4. Claude-पक्षीय रनटाइम/सत्र तंत्र।

ACP Claude, ACP नियंत्रणों, सत्र पुनरारंभ,
पृष्ठभूमि-कार्य ट्रैकिंग और वैकल्पिक वार्तालाप/थ्रेड बाइंडिंग वाला एक **हार्नेस सत्र** है।

CLI बैकएंड अलग, केवल-टेक्स्ट वाले स्थानीय फ़ॉलबैक रनटाइम हैं - देखें
[CLI बैकएंड](/hi/gateway/cli-backends)।

ऑपरेटरों के लिए व्यावहारिक नियम यह है:

- **`/acp spawn`, बाइंड किए जा सकने वाले सत्र, रनटाइम नियंत्रण या स्थायी हार्नेस कार्य चाहिए?** ACP का उपयोग करें।
- **रॉ CLI के माध्यम से सरल स्थानीय टेक्स्ट फ़ॉलबैक चाहिए?** CLI बैकएंड का उपयोग करें।

## बाइंड किए गए सत्र

### मानसिक मॉडल

- **चैट सतह** - वह स्थान जहाँ लोग बातचीत जारी रखते हैं (Discord चैनल, Telegram विषय, iMessage चैट)।
- **ACP सत्र** - स्थायी Codex/Claude/Gemini रनटाइम स्थिति, जिस पर OpenClaw रूट करता है।
- **चाइल्ड थ्रेड/विषय** - केवल `--thread ...` द्वारा बनाई जाने वाली वैकल्पिक अतिरिक्त संदेश सतह।
- **रनटाइम वर्कस्पेस** - वह फ़ाइल-सिस्टम स्थान (`cwd`, रिपॉज़िटरी चेकआउट, बैकएंड वर्कस्पेस) जहाँ हार्नेस चलता है। चैट सतह से स्वतंत्र।

### वर्तमान-वार्तालाप बाइंड

`/acp spawn <harness> --bind here` वर्तमान वार्तालाप को
स्पॉन किए गए ACP सत्र से पिन करता है - कोई चाइल्ड थ्रेड नहीं, वही चैट सतह। OpenClaw
ट्रांसपोर्ट, प्रमाणीकरण, सुरक्षा और डिलीवरी का स्वामित्व बनाए रखता है। उस
वार्तालाप के अनुवर्ती संदेश उसी सत्र पर रूट होते हैं; `/new` और `/reset` सत्र को
उसी स्थान पर रीसेट करते हैं; `/acp close` बाइंडिंग हटाता है।

उदाहरण:

```text
/codex bind                                              # नेटिव Codex बाइंड, भविष्य के संदेश यहाँ रूट करें
/codex model gpt-5.4                                     # बाइंड किए गए नेटिव Codex थ्रेड को समायोजित करें
/codex stop                                              # सक्रिय नेटिव Codex टर्न नियंत्रित करें
/acp spawn codex --bind here                             # Codex के लिए स्पष्ट ACP फ़ॉलबैक
/acp spawn codex --thread auto                           # चाइल्ड थ्रेड/विषय बना सकता है और वहाँ बाइंड कर सकता है
/acp spawn codex --bind here --cwd /workspace/repo       # वही चैट बाइंडिंग, Codex /workspace/repo में चलता है
```

<AccordionGroup>
  <Accordion title="बाइंडिंग नियम और विशिष्टता">
    - `--bind here` और `--thread ...` परस्पर अनन्य हैं।
    - `--bind here` केवल उन चैनलों पर काम करता है जो वर्तमान-वार्तालाप बाइंडिंग उपलब्ध बताते हैं; अन्यथा OpenClaw एक स्पष्ट असमर्थित संदेश लौटाता है। बाइंडिंग Gateway पुनरारंभ के बाद भी बनी रहती हैं।
    - Discord पर, `spawnSessions`, `--thread auto|here` के लिए चाइल्ड थ्रेड निर्माण को नियंत्रित करता है - `--bind here` के लिए नहीं।
    - यदि `--cwd` के बिना किसी अलग ACP एजेंट पर स्पॉन किया जाता है, तो OpenClaw डिफ़ॉल्ट रूप से **लक्ष्य एजेंट का** वर्कस्पेस विरासत में लेता है। अनुपलब्ध विरासत पथ (`ENOENT`/`ENOTDIR`) बैकएंड डिफ़ॉल्ट पर फ़ॉलबैक करते हैं; अन्य एक्सेस त्रुटियाँ (जैसे `EACCES`) स्पॉन त्रुटियों के रूप में दिखाई देती हैं।
    - बाइंड किए गए वार्तालापों में Gateway प्रबंधन कमांड स्थानीय रहते हैं - सामान्य अनुवर्ती टेक्स्ट के बाइंड किए गए ACP सत्र पर रूट होने पर भी `/acp ...` कमांड OpenClaw द्वारा संभाले जाते हैं; उस सतह के लिए कमांड प्रबंधन सक्षम होने पर `/status` और `/unfocus` भी हमेशा स्थानीय रहते हैं।

  </Accordion>
  <Accordion title="थ्रेड-बाइंड सत्र">
    जब किसी चैनल अडैप्टर के लिए थ्रेड बाइंडिंग सक्षम होती हैं:

    - OpenClaw किसी थ्रेड को लक्ष्य ACP सत्र से बाइंड करता है।
    - उस थ्रेड के अनुवर्ती संदेश बाइंड किए गए ACP सत्र पर रूट होते हैं।
    - ACP आउटपुट उसी थ्रेड में वापस डिलीवर किया जाता है।
    - अनफोकस/बंद/आर्काइव/निष्क्रियता-टाइमआउट या अधिकतम-आयु समाप्ति बाइंडिंग हटा देती है।
    - `/acp close`, `/acp cancel`, `/acp status`, `/status`, और `/unfocus` Gateway कमांड हैं, ACP हार्नेस के लिए प्रॉम्प्ट नहीं।

    थ्रेड-बाइंड ACP के लिए आवश्यक फ़ीचर फ़्लैग:

    - `acp.enabled=true`
    - `acp.dispatch.enabled` डिफ़ॉल्ट रूप से चालू है (स्वचालित ACP थ्रेड प्रेषण रोकने के लिए `false` सेट करें; स्पष्ट `sessions_spawn({ runtime: "acp" })` कॉल अब भी काम करती हैं)।
    - चैनल-अडैप्टर थ्रेड सत्र स्पॉन सक्षम (डिफ़ॉल्ट: `true`):
      - Discord/Telegram: `session.threadBindings.spawnSessions=true`

    थ्रेड बाइंडिंग समर्थन अडैप्टर-विशिष्ट है। यदि सक्रिय चैनल अडैप्टर
    थ्रेड बाइंडिंग का समर्थन नहीं करता, तो OpenClaw एक स्पष्ट
    असमर्थित/अनुपलब्ध संदेश लौटाता है।

  </Accordion>
  <Accordion title="थ्रेड समर्थित चैनल">
    - कोई भी चैनल अडैप्टर जो सत्र/थ्रेड बाइंडिंग क्षमता उपलब्ध कराता है।
    - वर्तमान अंतर्निर्मित समर्थन: **Discord** थ्रेड/चैनल, **Telegram** विषय (समूहों/सुपरग्रुपों के फ़ोरम विषय और DM विषय)।
    - Plugin चैनल उसी बाइंडिंग इंटरफ़ेस के माध्यम से समर्थन जोड़ सकते हैं।

  </Accordion>
</AccordionGroup>

## स्थायी चैनल बाइंडिंग

गैर-अल्पकालिक वर्कफ़्लो के लिए, शीर्ष-स्तरीय
`bindings[]` प्रविष्टियों में स्थायी ACP बाइंडिंग कॉन्फ़िगर करें।

### बाइंडिंग मॉडल

<ParamField path="bindings[].type" type='"acp"'>
  स्थायी ACP वार्तालाप बाइंडिंग चिह्नित करता है।
</ParamField>
<ParamField path="bindings[].match" type="object">
  लक्ष्य वार्तालाप की पहचान करता है। प्रत्येक चैनल के आकार:

- **Discord चैनल/थ्रेड:** `match.channel="discord"` + `match.peer.id="<channelOrThreadId>"`
- **Slack चैनल/DM:** `match.channel="slack"` + `match.peer.id="<channelId|channel:<channelId>|#<channelId>|userId|user:<userId>|slack:<userId>|<@userId>>"`. स्थिर Slack आईडी को प्राथमिकता दें; चैनल बाइंडिंग उस चैनल के थ्रेड के भीतर उत्तरों से भी मेल खाती हैं।
- **Telegram फ़ोरम विषय:** `match.channel="telegram"` + `match.peer.id="<chatId>:topic:<topicId>"`
- **WhatsApp DM/समूह:** `match.channel="whatsapp"` + `match.peer.id="<E.164|group JID>"`. सीधे चैट के लिए `+15555550123` जैसी E.164 संख्याएँ और समूहों के लिए `120363424282127706@g.us` जैसे WhatsApp समूह JID का उपयोग करें।
- **iMessage DM/समूह:** `match.channel="imessage"` + `match.peer.id="<handle|chat_id:*|chat_guid:*|chat_identifier:*>"`. स्थिर समूह बाइंडिंग के लिए `chat_id:*` को प्राथमिकता दें।

</ParamField>
<ParamField path="bindings[].agentId" type="string">
  स्वामित्व रखने वाले OpenClaw एजेंट की आईडी।
</ParamField>
<ParamField path="bindings[].acp.mode" type='"persistent" | "oneshot"'>
  वैकल्पिक ACP ओवरराइड।
</ParamField>
<ParamField path="bindings[].acp.label" type="string">
  वैकल्पिक ऑपरेटर-दृश्य लेबल।
</ParamField>
<ParamField path="bindings[].acp.cwd" type="string">
  वैकल्पिक रनटाइम कार्यशील डायरेक्टरी।
</ParamField>
<ParamField path="bindings[].acp.backend" type="string">
  वैकल्पिक बैकएंड ओवरराइड।
</ParamField>

### प्रति एजेंट रनटाइम डिफ़ॉल्ट

प्रति एजेंट ACP डिफ़ॉल्ट को एक बार परिभाषित करने के लिए `agents.entries.*.runtime` का उपयोग करें:

- `agents.entries.*.runtime.type="acp"`
- `agents.entries.*.runtime.acp.agent` (हार्नेस आईडी, जैसे `codex` या `claude`)
- `agents.entries.*.runtime.acp.backend`
- `agents.entries.*.runtime.acp.mode`
- `agents.entries.*.runtime.acp.cwd`

**ACP-बाउंड सत्रों के लिए ओवरराइड प्राथमिकता:**

1. `bindings[].acp.*`
2. `agents.entries.*.runtime.acp.*`
3. वैश्विक ACP डिफ़ॉल्ट (जैसे `acp.backend`)

### उदाहरण

```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 } },
        },
      },
    },
  },
}
```

### व्यवहार

- OpenClaw यह सुनिश्चित करता है कि चैनल-विशिष्ट प्रवेश के बाद और उपयोग से पहले कॉन्फ़िगर किया गया ACP सत्र मौजूद हो।
- उस चैनल, विषय या चैट के संदेश कॉन्फ़िगर किए गए ACP सत्र पर रूट होते हैं।
- कॉन्फ़िगर की गई ACP बाइंडिंग अपने सत्र रूट की स्वामी होती हैं। चैनल ब्रॉडकास्ट फ़ैन-आउट मेल खाने वाली बाइंडिंग के लिए कॉन्फ़िगर किए गए ACP सत्र को प्रतिस्थापित नहीं करता।
- बाउंड वार्तालापों में, `/new` और `/reset` उसी ACP सत्र कुंजी को उसी स्थान पर रीसेट करते हैं।
- अस्थायी रनटाइम बाइंडिंग (उदाहरण के लिए, थ्रेड-फ़ोकस प्रवाहों द्वारा बनाई गई) मौजूद होने पर अब भी लागू होती हैं।
- स्पष्ट `cwd` के बिना क्रॉस-एजेंट ACP स्पॉन के लिए, OpenClaw एजेंट कॉन्फ़िगरेशन से लक्ष्य एजेंट का कार्यक्षेत्र विरासत में लेता है।
- अनुपलब्ध विरासत में मिले कार्यक्षेत्र पथ बैकएंड के डिफ़ॉल्ट cwd पर वापस आते हैं; मौजूद पथों पर पहुँच संबंधी विफलताएँ स्पॉन त्रुटियों के रूप में दिखाई देती हैं।

## ACP सत्र प्रारंभ करें

ACP सत्र प्रारंभ करने के दो तरीके:

<Tabs>
  <Tab title="sessions_spawn से">
    किसी एजेंट टर्न या टूल कॉल से ACP सत्र प्रारंभ करने के लिए
    `runtime: "acp"` का उपयोग करें।

    ```json
    {
      "task": "रिपॉज़िटरी खोलें और विफल परीक्षणों का सारांश दें",
      "runtime": "acp",
      "agentId": "codex",
      "thread": true,
      "mode": "session"
    }
    ```

    <Note>
    `runtime` का डिफ़ॉल्ट `subagent` है, इसलिए ACP सत्रों के लिए
    `runtime: "acp"` स्पष्ट रूप से सेट करें। यदि `agentId` छोड़ दिया जाता है, तो कॉन्फ़िगर होने पर
    OpenClaw `acp.defaultAgent` का उपयोग करता है। स्थायी बाउंड
    वार्तालाप बनाए रखने के लिए `mode: "session"` को `thread: true` की आवश्यकता होती है।
    </Note>

  </Tab>
  <Tab title="/acp कमांड से">
    चैट से स्पष्ट ऑपरेटर नियंत्रण के लिए `/acp spawn` का उपयोग करें।

    ```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
    ```

    प्रमुख फ़्लैग:

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

    [स्लैश कमांड](/hi/tools/slash-commands) देखें।

  </Tab>
</Tabs>

### `sessions_spawn` पैरामीटर

<ParamField path="task" type="string" required>
  ACP सत्र को भेजा गया प्रारंभिक प्रॉम्प्ट।
</ParamField>
<ParamField path="runtime" type='"acp"' required>
  ACP सत्रों के लिए `"acp"` होना आवश्यक है।
</ParamField>
<ParamField path="agentId" type="string">
  ACP लक्ष्य हार्नेस आईडी। सेट होने पर `acp.defaultAgent` पर वापस आता है।
</ParamField>
<ParamField path="thread" type="boolean" default="false">
  जहाँ समर्थित हो, वहाँ थ्रेड बाइंडिंग प्रवाह का अनुरोध करें।
</ParamField>
<ParamField path="mode" type='"run" | "session"' default="run">
  `"run"` एक-बार का है; `"session"` स्थायी है। यदि `thread: true` हो और
  `mode` छोड़ दिया जाए, तो OpenClaw रनटाइम पथ के अनुसार स्थायी व्यवहार को
  डिफ़ॉल्ट बना सकता है। `mode: "session"` को `thread: true` की आवश्यकता होती है।
</ParamField>
<ParamField path="cwd" type="string">
  अनुरोधित रनटाइम कार्यशील डायरेक्टरी (बैकएंड/रनटाइम नीति द्वारा सत्यापित)।
  यदि इसे छोड़ दिया जाए, तो कॉन्फ़िगर होने पर ACP स्पॉन लक्ष्य एजेंट का कार्यक्षेत्र विरासत में लेता है;
  अनुपलब्ध विरासत में मिले पथ बैकएंड डिफ़ॉल्ट पर वापस आते हैं, जबकि वास्तविक पहुँच
  त्रुटियाँ लौटा दी जाती हैं।
</ParamField>
<ParamField path="label" type="string">
  सत्र/बैनर टेक्स्ट में उपयोग किया जाने वाला ऑपरेटर-दृश्य लेबल।
</ParamField>
<ParamField path="resumeSessionId" type="string">
  नया ACP सत्र बनाने के बजाय मौजूदा सत्र को फिर से शुरू करें। एजेंट
  `session/load` के माध्यम से अपना वार्तालाप इतिहास पुनः चलाता है। इसके लिए
  `runtime: "acp"` आवश्यक है।
</ParamField>
<ParamField path="streamTo" type='"parent"'>
  `"parent"` प्रारंभिक ACP रन की प्रगति के सारांश अनुरोधकर्ता
  सत्र को सिस्टम इवेंट के रूप में स्ट्रीम करता है। OpenClaw पूर्ण रिले इतिहास को
  चाइल्ड एजेंट की SQLite स्थिति में दर्ज करता है और चाइल्ड सत्र के साथ उसे हटा देता है। पैरेंट
  प्रगति स्ट्रीम डिफ़ॉल्ट रूप से सहायक टिप्पणी और ACP स्थिति प्रगति दिखाती हैं, जब तक कि
  `streaming.progress.commentary=false` न हो। जब कोई स्ट्रीम मोड कॉन्फ़िगर न किया गया हो, तब Discord भी पैरेंट
  पूर्वावलोकनों को डिफ़ॉल्ट रूप से प्रगति मोड में रखता है। स्थिति
  प्रगति फिर भी `acp.stream.tagVisibility` का पालन करती है, इसलिए `plan` जैसे टैग
  स्पष्ट रूप से सक्षम किए बिना छिपे रहते हैं।
</ParamField>

ACP `sessions_spawn` रन अपनी डिफ़ॉल्ट चाइल्ड टर्न सीमा के लिए
`agents.defaults.subagents.runTimeoutSeconds` का उपयोग करते हैं। टूल प्रति-कॉल टाइमआउट
ओवरराइड स्वीकार नहीं करता (`runTimeoutSeconds`/`timeoutSeconds` को
डिफ़ॉल्ट-कॉन्फ़िगर-करें त्रुटि के साथ अस्वीकार किया जाता है)।

<ParamField path="model" type="string">
  ACP चाइल्ड सत्र के लिए स्पष्ट मॉडल ओवरराइड। Codex ACP स्पॉन
  `session/new` से पहले `openai/gpt-5.4` जैसे OpenAI संदर्भों को Codex ACP स्टार्टअप कॉन्फ़िगरेशन में
  सामान्यीकृत करते हैं; `openai/gpt-5.4/high` जैसे स्लैश रूप भी
  Codex ACP तर्क प्रयास सेट करते हैं। इसे छोड़ने पर, कॉन्फ़िगर होने की स्थिति में `sessions_spawn({ runtime: "acp" })`
  मौजूदा सबएजेंट मॉडल डिफ़ॉल्ट (`agents.defaults.subagents.model` या
  `agents.entries.*.subagents.model`) का उपयोग करता है; अन्यथा यह ACP
  हार्नेस को अपना डिफ़ॉल्ट मॉडल उपयोग करने देता है। अन्य हार्नेस को ACP
  `models` घोषित करना और `session/set_model` का समर्थन करना आवश्यक है; अन्यथा OpenClaw/acpx
  लक्ष्य एजेंट डिफ़ॉल्ट पर चुपचाप वापस आने के बजाय स्पष्ट रूप से विफल होता है।
</ParamField>
<ParamField path="thinking" type="string">
  स्पष्ट चिंतन/तर्क प्रयास। Codex ACP के लिए, `minimal` कम
  प्रयास पर मैप होता है, `low`/`medium`/`high`/`xhigh` सीधे मैप होते हैं, और `off`
  तर्क-प्रयास स्टार्टअप ओवरराइड छोड़ देता है। इसे छोड़ने पर, ACP स्पॉन चयनित
  मॉडल के लिए मौजूदा सबएजेंट चिंतन डिफ़ॉल्ट और प्रति-मॉडल
  `agents.defaults.models["provider/model"].params.thinking` का उपयोग करते हैं।
</ParamField>

## स्पॉन बाइंड और थ्रेड मोड

<Tabs>
  <Tab title="--bind here|off">
    | मोड   | व्यवहार                                                               |
    | ------ | ----------------------------------------------------------------------- |
    | `here` | वर्तमान सक्रिय वार्तालाप को उसी स्थान पर बाइंड करें; कोई सक्रिय वार्तालाप न होने पर विफल हों। |
    | `off`  | वर्तमान-वार्तालाप बाइंडिंग न बनाएँ।                          |

    टिप्पणियाँ:

    - `--bind here` "इस चैनल या चैट को Codex-समर्थित बनाएँ" के लिए सबसे सरल ऑपरेटर पथ है।
    - `--bind here` चाइल्ड थ्रेड नहीं बनाता।
    - `--bind here` केवल उन चैनलों पर उपलब्ध है जो वर्तमान-वार्तालाप बाइंडिंग समर्थन प्रदान करते हैं।
    - `--bind` और `--thread` को एक ही `/acp spawn` कॉल में संयोजित नहीं किया जा सकता।

  </Tab>
  <Tab title="--thread auto|here|off">
    | मोड   | व्यवहार                                                                                            |
    | ------ | ------------------------------------------------------------------------------------------------- |
    | `auto` | सक्रिय थ्रेड में: उस थ्रेड को बाइंड करें। थ्रेड के बाहर: समर्थित होने पर चाइल्ड थ्रेड बनाएँ/बाइंड करें। |
    | `here` | वर्तमान सक्रिय थ्रेड आवश्यक है; उसमें न होने पर विफल हों।                                                  |
    | `off`  | कोई बाइंडिंग नहीं। सत्र अनबाउंड प्रारंभ होता है।                                                                 |

    टिप्पणियाँ:

    - गैर-थ्रेड बाइंडिंग सतहों पर, डिफ़ॉल्ट व्यवहार प्रभावी रूप से `off` होता है।
    - थ्रेड-बाउंड स्पॉन के लिए चैनल नीति समर्थन आवश्यक है:
      - Discord/Telegram: `session.threadBindings.spawnSessions=true`
    - जब आप चाइल्ड थ्रेड बनाए बिना वर्तमान वार्तालाप को पिन करना चाहते हैं, तब `--bind here` का उपयोग करें।

  </Tab>
</Tabs>

## डिलीवरी मॉडल

ACP सत्र या तो इंटरैक्टिव कार्यक्षेत्र हो सकते हैं या पैरेंट के स्वामित्व वाला पृष्ठभूमि
कार्य। डिलीवरी पथ उस स्वरूप पर निर्भर करता है।

<AccordionGroup>
  <Accordion title="इंटरैक्टिव ACP सत्र">
    इंटरैक्टिव सत्र किसी दृश्यमान चैट सतह पर बातचीत जारी रखने के लिए होते हैं:

    - `/acp spawn ... --bind here` वर्तमान वार्तालाप को ACP सत्र से बाइंड करता है।
    - `/acp spawn ... --thread ...` किसी चैनल थ्रेड/विषय को ACP सत्र से बाइंड करता है।
    - स्थायी रूप से कॉन्फ़िगर किया गया `bindings[].type="acp"` मेल खाने वाले वार्तालापों को उसी ACP सत्र पर रूट करता है।

    बाउंड वार्तालाप में आगे के संदेश सीधे ACP
    सत्र पर रूट होते हैं, और ACP आउटपुट उसी
    चैनल/थ्रेड/विषय पर वापस भेजा जाता है।

    OpenClaw हार्नेस को क्या भेजता है:

    - सामान्य सीमित फ़ॉलो-अप प्रॉम्प्ट टेक्स्ट के रूप में भेजे जाते हैं, और अटैचमेंट केवल तभी भेजे जाते हैं जब हार्नेस/बैकएंड उनका समर्थन करता हो।
    - `/acp` प्रबंधन कमांड और स्थानीय Gateway कमांड ACP डिस्पैच से पहले इंटरसेप्ट किए जाते हैं।
    - रनटाइम द्वारा जनरेट किए गए पूर्णता इवेंट प्रत्येक लक्ष्य के लिए मूर्त रूप दिए जाते हैं। OpenClaw एजेंट को OpenClaw का आंतरिक रनटाइम-कॉन्टेक्स्ट एनवेलप मिलता है; बाहरी ACP हार्नेस को चाइल्ड परिणाम और निर्देश सहित एक सादा प्रॉम्प्ट मिलता है। कच्चा `<<<BEGIN_OPENCLAW_INTERNAL_CONTEXT>>>` एनवेलप कभी भी बाहरी हार्नेस को नहीं भेजा जाना चाहिए या ACP उपयोगकर्ता ट्रांसक्रिप्ट टेक्स्ट के रूप में सहेजा नहीं जाना चाहिए।
    - ACP ट्रांसक्रिप्ट प्रविष्टियाँ उपयोगकर्ता को दिखाई देने वाले ट्रिगर टेक्स्ट या सादे पूर्णता प्रॉम्प्ट का उपयोग करती हैं। जहाँ संभव हो, आंतरिक इवेंट मेटाडेटा OpenClaw में संरचित रहता है और उसे उपयोगकर्ता द्वारा लिखी गई चैट सामग्री नहीं माना जाता।

  </Accordion>
  <Accordion title="पैरेंट-स्वामित्व वाले एकबारगी ACP सत्र">
    किसी अन्य एजेंट रन द्वारा उत्पन्न एकबारगी ACP सत्र, उप-एजेंटों की तरह,
    बैकग्राउंड चाइल्ड होते हैं:

    - पैरेंट `sessions_spawn({ runtime: "acp", mode: "run" })` के साथ कार्य करने को कहता है।
    - चाइल्ड अपने स्वयं के ACP हार्नेस सत्र में चलता है।
    - चाइल्ड टर्न उसी बैकग्राउंड लेन पर चलते हैं जिसका उपयोग नेटिव उप-एजेंट स्पॉन करते हैं, इसलिए धीमा ACP हार्नेस असंबंधित मुख्य-सत्र कार्य को ब्लॉक नहीं करता।
    - पूर्णता की रिपोर्ट कार्य-पूर्णता घोषणा पथ के माध्यम से वापस आती है। OpenClaw आंतरिक पूर्णता मेटाडेटा को बाहरी हार्नेस को भेजने से पहले सादे ACP प्रॉम्प्ट में बदलता है, इसलिए हार्नेस को केवल OpenClaw के रनटाइम कॉन्टेक्स्ट मार्कर दिखाई नहीं देते।
    - जब उपयोगकर्ता के लिए उत्तर उपयोगी हो, तो पैरेंट चाइल्ड परिणाम को सामान्य सहायक शैली में दोबारा लिखता है।

    इस पथ को पैरेंट और चाइल्ड के बीच पीयर-टू-पीयर चैट **नहीं**
    मानें। चाइल्ड के पास पैरेंट तक वापस पहुँचने के लिए पहले से ही पूर्णता चैनल है।

  </Accordion>
  <Accordion title="sessions_send और A2A डिलीवरी">
    `sessions_send` स्पॉन के बाद किसी अन्य सत्र को लक्षित कर सकता है। सामान्य पीयर
    सत्रों के लिए, OpenClaw संदेश इंजेक्ट करने के बाद एजेंट-टू-एजेंट (A2A)
    फ़ॉलो-अप पथ का उपयोग करता है:

    - लक्ष्य सत्र के उत्तर की प्रतीक्षा करें।
    - वैकल्पिक रूप से अनुरोधकर्ता और लक्ष्य को सीमित संख्या में फ़ॉलो-अप टर्न का आदान-प्रदान करने दें।
    - लक्ष्य से घोषणा संदेश तैयार करने को कहें।
    - उस घोषणा को दृश्यमान चैनल या थ्रेड पर डिलीवर करें।

    यह A2A पथ उन पीयर प्रेषणों के लिए फ़ॉलबैक है जहाँ प्रेषक को
    दृश्यमान फ़ॉलो-अप चाहिए। जब कोई असंबंधित सत्र ACP लक्ष्य को देख और
    संदेश भेज सकता है, उदाहरण के लिए व्यापक `tools.sessions.visibility`
    सेटिंग्स के अंतर्गत, तब यह सक्षम रहता है।

    OpenClaw A2A फ़ॉलो-अप को केवल तभी छोड़ता है जब अनुरोधकर्ता अपने
    स्वयं के पैरेंट-स्वामित्व वाले एकबारगी ACP चाइल्ड का पैरेंट हो। उस स्थिति में,
    कार्य पूर्णता के ऊपर A2A चलाने से चाइल्ड के परिणाम के साथ पैरेंट सक्रिय हो सकता है,
    पैरेंट का उत्तर वापस चाइल्ड को अग्रेषित हो सकता है, और पैरेंट/चाइल्ड प्रतिध्वनि
    लूप बन सकता है। उस स्वामित्व वाले चाइल्ड की स्थिति में `sessions_send` परिणाम
    `delivery.status="skipped"` रिपोर्ट करता है क्योंकि परिणाम के लिए पूर्णता पथ पहले से ही
    उत्तरदायी है।

  </Accordion>
  <Accordion title="किसी मौजूदा सत्र को फिर से शुरू करें">
    नया सत्र शुरू करने के बजाय पिछले ACP सत्र को जारी रखने के लिए `resumeSessionId`
    का उपयोग करें। एजेंट `session/load` के माध्यम से अपना वार्तालाप इतिहास
    दोबारा चलाता है, इसलिए वह पहले हुई सभी बातों के पूर्ण संदर्भ के साथ आगे बढ़ता है।

    ```json
    {
      "task": "जहाँ हमने छोड़ा था वहाँ से जारी रखें - शेष परीक्षण विफलताएँ ठीक करें",
      "runtime": "acp",
      "agentId": "codex",
      "resumeSessionId": "<previous-session-id>"
    }
    ```

    सामान्य उपयोग के मामले:

    - Codex सत्र को अपने लैपटॉप से फ़ोन पर सौंपें—अपने एजेंट से कहें कि वह वहीं से आगे बढ़े जहाँ आपने छोड़ा था।
    - CLI में इंटरैक्टिव रूप से शुरू किए गए कोडिंग सत्र को अब अपने एजेंट के माध्यम से हेडलेस रूप में जारी रखें।
    - Gateway रीस्टार्ट या निष्क्रियता टाइमआउट से बाधित हुआ कार्य फिर से शुरू करें।

    टिप्पणियाँ:

    - `resumeSessionId` केवल तब लागू होता है जब `runtime: "acp"`; डिफ़ॉल्ट उप-एजेंट रनटाइम केवल ACP के इस फ़ील्ड को अनदेखा करता है।
    - `streamTo` केवल तब लागू होता है जब `runtime: "acp"`; डिफ़ॉल्ट उप-एजेंट रनटाइम केवल ACP के इस फ़ील्ड को अनदेखा करता है।
    - `resumeSessionId` एक होस्ट-स्थानीय ACP/हार्नेस पुनःआरंभ आईडी है, OpenClaw चैनल सत्र कुंजी नहीं; OpenClaw डिस्पैच से पहले अब भी ACP स्पॉन नीति और लक्ष्य एजेंट नीति की जाँच करता है, जबकि उस अपस्ट्रीम आईडी को लोड करने के प्राधिकरण का स्वामी ACP बैकएंड या हार्नेस होता है।
    - `resumeSessionId` अपस्ट्रीम ACP वार्तालाप इतिहास पुनर्स्थापित करता है; आपके द्वारा बनाए जा रहे नए OpenClaw सत्र पर `thread` और `mode` अब भी सामान्य रूप से लागू होते हैं, इसलिए `mode: "session"` के लिए अब भी `thread: true` आवश्यक है।
    - लक्ष्य एजेंट को `session/load` का समर्थन करना आवश्यक है (Codex और Claude Code करते हैं)।
    - यदि सत्र आईडी नहीं मिलती, तो स्पॉन स्पष्ट त्रुटि के साथ विफल होता है—नए सत्र पर कोई मौन फ़ॉलबैक नहीं होता।

  </Accordion>
  <Accordion title="डिप्लॉयमेंट के बाद स्मोक परीक्षण">
    Gateway डिप्लॉयमेंट के बाद, यूनिट परीक्षणों पर भरोसा करने के बजाय लाइव
    एंड-टू-एंड जाँच चलाएँ:

    1. लक्ष्य होस्ट पर डिप्लॉय किए गए Gateway संस्करण और कमिट की पुष्टि करें।
    2. लाइव एजेंट के लिए एक अस्थायी ACPX ब्रिज सत्र खोलें।
    3. उस एजेंट से `sessions_spawn` को `runtime: "acp"`, `agentId: "codex"`, `mode: "run"`, और कार्य `Reply with exactly LIVE-ACP-SPAWN-OK` के साथ कॉल करने को कहें।
    4. `accepted=yes`, वास्तविक `childSessionKey`, और किसी वैलिडेटर त्रुटि के न होने की पुष्टि करें।
    5. अस्थायी ब्रिज सत्र साफ़ करें।

    गेट को `mode: "run"` पर रखें और `streamTo: "parent"` छोड़ दें—
    थ्रेड-बाउंड `mode: "session"` और स्ट्रीम-रिले पथ अलग, अधिक समृद्ध
    इंटीग्रेशन पास हैं।

  </Accordion>
</AccordionGroup>

## सैंडबॉक्स संगतता

ACP सत्र वर्तमान में होस्ट रनटाइम पर चलते हैं, OpenClaw
सैंडबॉक्स के भीतर **नहीं**।

<Warning>
**सुरक्षा सीमा:**

- बाहरी हार्नेस अपनी CLI अनुमतियों और चयनित `cwd` के अनुसार पढ़/लिख सकता है।
- OpenClaw की सैंडबॉक्स नीति ACP हार्नेस निष्पादन को आवृत **नहीं** करती।
- OpenClaw अब भी ACP फ़ीचर गेट, अनुमत एजेंट, सत्र स्वामित्व, चैनल बाइंडिंग और Gateway डिलीवरी नीति लागू करता है।
- सैंडबॉक्स द्वारा लागू किए गए OpenClaw-नेटिव कार्य के लिए `runtime: "subagent"` का उपयोग करें।

</Warning>

वर्तमान सीमाएँ:

- यदि अनुरोधकर्ता सत्र सैंडबॉक्स में है, तो `sessions_spawn({ runtime: "acp" })` और `/acp spawn` दोनों के लिए ACP स्पॉन ब्लॉक हो जाते हैं।
- `sessions_spawn` के साथ `runtime: "acp"`, `sandbox: "require"` का समर्थन नहीं करता।

## सत्र लक्ष्य रिज़ॉल्यूशन

अधिकांश `/acp` कार्रवाइयाँ एक वैकल्पिक सत्र लक्ष्य (`session-key`,
`session-id`, या `session-label`) स्वीकार करती हैं।

**रिज़ॉल्यूशन क्रम:**

1. स्पष्ट लक्ष्य आर्ग्युमेंट (या `/acp steer` के लिए `--session`)
   - पहले कुंजी आज़माता है
   - फिर UUID-आकार का सत्र आईडी
   - फिर लेबल
2. वर्तमान थ्रेड बाइंडिंग (यदि यह वार्तालाप/थ्रेड किसी ACP सत्र से बंधा है)।
3. वर्तमान अनुरोधकर्ता सत्र फ़ॉलबैक।

वर्तमान-वार्तालाप बाइंडिंग और थ्रेड बाइंडिंग दोनों चरण 2 में भाग लेते हैं।

यदि कोई लक्ष्य रिज़ॉल्व नहीं होता, तो OpenClaw स्पष्ट त्रुटि
(`Unable to resolve session target: ...`) लौटाता है।

## ACP नियंत्रण

| कमांड              | यह क्या करता है                                              | उदाहरण                                                       |
| -------------------- | --------------------------------------------------------- | ------------------------------------------------------------- |
| `/acp spawn`         | ACP सत्र बनाएँ; वैकल्पिक वर्तमान बाइंड या थ्रेड बाइंड। | `/acp spawn codex --bind here --cwd /repo`                    |
| `/acp cancel`        | लक्ष्य सत्र का जारी टर्न रद्द करें।                 | `/acp cancel agent:codex:acp:<uuid>`                          |
| `/acp steer`         | चल रहे सत्र को दिशा-निर्देश भेजें।                | `/acp steer --session support inbox prioritize failing tests` |
| `/acp close`         | सत्र बंद करें और थ्रेड लक्ष्यों की बाइंडिंग हटाएँ।                  | `/acp close`                                                  |
| `/acp status`        | बैकएंड, मोड, स्थिति, रनटाइम विकल्प और क्षमताएँ दिखाएँ। | `/acp status`                                                 |
| `/acp set-mode`      | लक्ष्य सत्र का रनटाइम मोड सेट करें।                      | `/acp set-mode plan`                                          |
| `/acp set`           | सामान्य रनटाइम कॉन्फ़िगरेशन विकल्प लिखें।                      | `/acp set model openai/gpt-5.4`                               |
| `/acp cwd`           | रनटाइम कार्यशील डायरेक्टरी ओवरराइड सेट करें।                   | `/acp cwd /Users/user/Projects/repo`                          |
| `/acp permissions`   | अनुमोदन नीति प्रोफ़ाइल सेट करें।                              | `/acp permissions strict`                                     |
| `/acp timeout`       | रनटाइम टाइमआउट (सेकंड) सेट करें।                            | `/acp timeout 120`                                            |
| `/acp model`         | रनटाइम मॉडल ओवरराइड सेट करें।                               | `/acp model anthropic/claude-opus-4-6`                        |
| `/acp reset-options` | सत्र के रनटाइम विकल्प ओवरराइड हटाएँ।                  | `/acp reset-options`                                          |
| `/acp sessions`      | स्टोर से हाल के ACP सत्र सूचीबद्ध करें।                      | `/acp sessions`                                               |
| `/acp doctor`        | बैकएंड स्वास्थ्य, क्षमताएँ और कार्रवाई योग्य सुधार।           | `/acp doctor`                                                 |
| `/acp install`       | नियतात्मक इंस्टॉल और सक्षम करने के चरण प्रिंट करें।             | `/acp install`                                                |

रनटाइम नियंत्रणों (`spawn`, `cancel`, `steer`, `close`, `status`, `set-mode`,
`set`, `cwd`, `permissions`, `timeout`, `model`, और `reset-options`) के लिए
बाहरी चैनलों से स्वामी पहचान और आंतरिक Gateway क्लाइंट से `operator.admin`
आवश्यक है। अधिकृत गैर-स्वामी प्रेषक अब भी `sessions`,
`doctor`, `install`, और `help` का उपयोग कर सकते हैं। गैर-स्वामी प्रेषकों के लिए, `/acp sessions`
केवल वर्तमान बाउंड या अनुरोधकर्ता सत्र सूचीबद्ध करता है; स्वामी पहचान और
`operator.admin` क्लाइंट सभी हाल के सत्र देखते हैं।

`/acp status` प्रभावी रनटाइम विकल्पों के साथ रनटाइम-स्तरीय और
बैकएंड-स्तरीय सत्र पहचानकर्ता दिखाता है। जब किसी बैकएंड में कोई क्षमता नहीं होती,
तो असमर्थित-नियंत्रण त्रुटियाँ स्पष्ट रूप से दिखाई देती हैं। लक्ष्य टोकन स्वीकार करने वाले
कमांड (`session-key`, `session-id`, या `session-label`) उन्हें Gateway
सत्र खोज के माध्यम से रिज़ॉल्व करते हैं, जिसमें कस्टम प्रति-एजेंट `session.store` रूट शामिल हैं। `/acp sessions`
लक्ष्य टोकन स्वीकार नहीं करता।

### रनटाइम विकल्प मैपिंग

`/acp` में सुविधाजनक कमांड और एक सामान्य सेटर है। समतुल्य कार्रवाइयाँ:

| कमांड                      | इससे मैप होता है                              | टिप्पणियाँ                                                                                                                                                                                                      |
| ---------------------------- | ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `/acp model <id>`            | रनटाइम कॉन्फ़िगरेशन कुंजी `model`           | Codex ACP के लिए, OpenClaw `openai/<model>` को अडैप्टर मॉडल आईडी में सामान्यीकृत करता है और `openai/gpt-5.4/high` जैसे स्लैश रीजनिंग प्रत्ययों को `reasoning_effort` से मैप करता है।                                         |
| `/acp set thinking <level>`  | कैनोनिकल विकल्प `thinking`          | उपलब्ध होने पर OpenClaw बैकएंड द्वारा विज्ञापित समतुल्य मान भेजता है, जिसमें पहले `thinking`, फिर `effort`, `reasoning_effort`, या `thought_level` को प्राथमिकता दी जाती है। Codex ACP के लिए, अडैप्टर मानों को `reasoning_effort` से मैप करता है। |
| `/acp permissions <profile>` | कैनोनिकल विकल्प `permissionProfile` | उपलब्ध होने पर OpenClaw बैकएंड द्वारा विज्ञापित समतुल्य मान भेजता है, जैसे `approval_policy`, `permission_profile`, `permissions`, या `permission_mode`।                                                       |
| `/acp timeout <seconds>`     | कैनोनिकल विकल्प `timeoutSeconds`    | उपलब्ध होने पर OpenClaw बैकएंड द्वारा विज्ञापित समतुल्य मान भेजता है, जैसे `timeout` या `timeout_seconds`।                                                                                                     |
| `/acp cwd <path>`            | रनटाइम cwd ओवरराइड                 | प्रत्यक्ष अपडेट।                                                                                                                                                                                             |
| `/acp set <key> <value>`     | सामान्य                              | `key=cwd` cwd ओवरराइड पथ का उपयोग करता है।                                                                                                                                                                      |
| `/acp reset-options`         | सभी रनटाइम ओवरराइड साफ़ करता है         | -                                                                                                                                                                                                          |

## acpx हार्नेस, Plugin सेटअप और अनुमतियाँ

acpx हार्नेस कॉन्फ़िगरेशन (Claude Code / Codex / Gemini CLI उपनाम),
plugin-tools और OpenClaw-tools MCP ब्रिज, तथा ACP अनुमति मोड के लिए,
[ACP एजेंट—सेटअप](/hi/tools/acp-agents-setup) देखें।

## समस्या निवारण

| लक्षण                                                                                   | संभावित कारण                                                                                                           | समाधान                                                                                                                                                                      |
| ----------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `ACP runtime backend is not configured`                                                   | बैकएंड Plugin अनुपलब्ध, अक्षम या `plugins.allow` द्वारा अवरुद्ध है।                                                       | बैकएंड Plugin इंस्टॉल और सक्षम करें, जब वह अनुमति-सूची सेट हो तो `plugins.allow` में `acpx` शामिल करें, फिर `/acp doctor` चलाएँ।                                                 |
| `ACP is disabled by policy (acp.enabled=false)`                                           | ACP वैश्विक रूप से अक्षम है।                                                                                                 | `acp.enabled=true` सेट करें।                                                                                                                                                  |
| `ACP dispatch is disabled by policy (acp.dispatch.enabled=false)`                         | सामान्य थ्रेड संदेशों से स्वचालित डिस्पैच अक्षम है।                                                               | स्वचालित थ्रेड रूटिंग फिर शुरू करने के लिए `acp.dispatch.enabled=true` सेट करें; स्पष्ट `sessions_spawn({ runtime: "acp" })` कॉल फिर भी काम करते हैं।                                      |
| `ACP agent "<id>" is not allowed by policy`                                               | एजेंट अनुमति-सूची में नहीं है।                                                                                                | अनुमत `agentId` का उपयोग करें या `acp.allowedAgents` अपडेट करें।                                                                                                                     |
| स्टार्टअप के तुरंत बाद `/acp doctor` बैकएंड तैयार न होने की रिपोर्ट करता है                               | बैकएंड Plugin अनुपलब्ध, अक्षम, अनुमति/निषेध नीति द्वारा अवरुद्ध है या उसका कॉन्फ़िगर किया गया एक्ज़ीक्यूटेबल उपलब्ध नहीं है।        | बैकएंड Plugin इंस्टॉल/सक्षम करें, `/acp doctor` दोबारा चलाएँ और यदि वह अस्वस्थ बना रहता है तो बैकएंड इंस्टॉलेशन या नीति त्रुटि जाँचें।                                           |
| हार्नेस कमांड नहीं मिला                                                                 | अडैप्टर CLI इंस्टॉल नहीं है, बाहरी Plugin अनुपलब्ध है या किसी गैर-Codex अडैप्टर के लिए पहली बार `npx` फ़ेच विफल रहा। | `/acp doctor` चलाएँ, Gateway होस्ट पर अडैप्टर इंस्टॉल/प्रीवॉर्म करें या acpx एजेंट कमांड को स्पष्ट रूप से कॉन्फ़िगर करें।                                                      |
| हार्नेस से मॉडल न मिलने की त्रुटि                                                          | मॉडल आईडी किसी अन्य प्रोवाइडर/हार्नेस के लिए मान्य है, लेकिन इस ACP लक्ष्य के लिए नहीं।                                                | उस हार्नेस द्वारा सूचीबद्ध मॉडल का उपयोग करें, हार्नेस में मॉडल कॉन्फ़िगर करें या ओवरराइड हटा दें।                                                                            |
| हार्नेस से वेंडर प्रमाणीकरण त्रुटि                                                        | OpenClaw स्वस्थ है, लेकिन लक्ष्य CLI/प्रोवाइडर में लॉग इन नहीं किया गया है।                                                     | Gateway होस्ट परिवेश पर लॉग इन करें या आवश्यक प्रोवाइडर कुंजी उपलब्ध कराएँ।                                                                                             |
| `Unable to resolve session target: ...`                                                   | अमान्य कुंजी/आईडी/लेबल टोकन।                                                                                                | `/acp sessions` चलाएँ, सटीक कुंजी/लेबल कॉपी करें और पुनः प्रयास करें।                                                                                                                        |
| `--bind here requires running /acp spawn inside an active ... conversation`               | `--bind here` का उपयोग सक्रिय बाइंड करने योग्य वार्तालाप के बिना किया गया है।                                                            | लक्ष्य चैट/चैनल पर जाएँ और पुनः प्रयास करें या अनबाउंड स्पॉन का उपयोग करें।                                                                                                         |
| `Conversation bindings are unavailable for <channel>.`                                    | अडैप्टर में वर्तमान-वार्तालाप ACP बाइंडिंग क्षमता नहीं है।                                                             | जहाँ समर्थित हो वहाँ `/acp spawn ... --thread ...` का उपयोग करें, शीर्ष-स्तरीय `bindings[]` कॉन्फ़िगर करें या किसी समर्थित चैनल पर जाएँ।                                                     |
| `--thread here requires running /acp spawn inside an active ... thread`                   | `--thread here` का उपयोग थ्रेड संदर्भ के बाहर किया गया है।                                                                         | लक्ष्य थ्रेड पर जाएँ या `--thread auto`/`off` का उपयोग करें।                                                                                                                      |
| `Only <user-id> can rebind this channel/conversation/thread.`                             | सक्रिय बाइंडिंग लक्ष्य का स्वामी कोई अन्य उपयोगकर्ता है।                                                                           | स्वामी के रूप में फिर से बाइंड करें या किसी अलग वार्तालाप अथवा थ्रेड का उपयोग करें।                                                                                                               |
| `Thread bindings are unavailable for <channel>.`                                          | अडैप्टर में थ्रेड बाइंडिंग क्षमता नहीं है।                                                                               | `--thread off` का उपयोग करें या किसी समर्थित अडैप्टर/चैनल पर जाएँ।                                                                                                                 |
| `Sandboxed sessions cannot spawn ACP sessions ...`                                        | ACP रनटाइम होस्ट-साइड है; अनुरोधकर्ता सत्र सैंडबॉक्स में है।                                                              | सैंडबॉक्स किए गए सत्रों से `runtime="subagent"` का उपयोग करें या किसी गैर-सैंडबॉक्स सत्र से ACP स्पॉन चलाएँ।                                                                         |
| `sessions_spawn sandbox="require" is unsupported for runtime="acp" ...`                   | ACP रनटाइम के लिए `sandbox="require"` का अनुरोध किया गया है।                                                                         | आवश्यक सैंडबॉक्सिंग के लिए `runtime="subagent"` का उपयोग करें या गैर-सैंडबॉक्स सत्र से `sandbox="inherit"` के साथ ACP का उपयोग करें।                                                      |
| `Cannot apply --model ... did not advertise model support`                                | लक्ष्य हार्नेस सामान्य ACP मॉडल स्विचिंग उपलब्ध नहीं कराता है।                                                        | ACP `models`/`session/set_model` विज्ञापित करने वाले हार्नेस का उपयोग करें, Codex ACP मॉडल संदर्भों का उपयोग करें या यदि हार्नेस का अपना स्टार्टअप फ़्लैग है तो मॉडल को सीधे हार्नेस में कॉन्फ़िगर करें। |
| बाउंड सत्र के लिए ACP मेटाडेटा अनुपलब्ध है                                                    | ACP सत्र मेटाडेटा पुराना है या हटा दिया गया है।                                                                                    | `/acp spawn` के साथ फिर से बनाएँ, फिर थ्रेड को दोबारा बाइंड/फ़ोकस करें।                                                                                                                    |
| `PermissionPromptUnavailableError: Permission prompt unavailable in non-interactive mode` | `permissionMode` गैर-इंटरैक्टिव ACP सत्र में लेखन/निष्पादन को अवरुद्ध करता है।                                                    | `plugins.entries.acpx.config.permissionMode` को `approve-all` पर सेट करें और Gateway पुनः आरंभ करें। [अनुमति कॉन्फ़िगरेशन](/hi/tools/acp-agents-setup#permission-configuration) देखें। |
| ACP सत्र बहुत कम आउटपुट के साथ जल्दी विफल हो जाता है                                                | अनुमति संकेत `permissionMode`/`nonInteractivePermissions` द्वारा अवरुद्ध हैं।                                        | `AcpRuntimeError` के लिए Gateway लॉग जाँचें। पूर्ण अनुमतियों के लिए `permissionMode=approve-all` सेट करें; सुचारु अवनति के लिए `nonInteractivePermissions=deny` सेट करें।        |
| काम पूरा करने के बाद ACP सत्र अनिश्चितकाल तक अटक जाता है                                     | हार्नेस प्रक्रिया समाप्त हो गई, लेकिन ACP सत्र ने पूर्णता की रिपोर्ट नहीं की।                                                    | OpenClaw अपडेट करें; वर्तमान acpx क्लीनअप बंद होते समय और Gateway स्टार्टअप पर OpenClaw के स्वामित्व वाली पुरानी रैपर और अडैप्टर प्रक्रियाओं को समाप्त करता है।                                             |
| हार्नेस को `<<<BEGIN_OPENCLAW_INTERNAL_CONTEXT>>>` दिखाई देता है                                      | आंतरिक इवेंट एनवेलप ACP सीमा के पार लीक हो गया है।                                                                | OpenClaw अपडेट करें और पूर्णता प्रवाह दोबारा चलाएँ; बाहरी हार्नेस को केवल सादे पूर्णता प्रॉम्प्ट मिलने चाहिए।                                                          |

<Note>
`Command blocked by PreToolUse hook: Native hook relay unavailable` मूल Codex हुक रिले से संबंधित है,
ACP/acpx से नहीं। बाउंड Codex चैट में, `/new` या `/reset` के साथ
नया सत्र शुरू करें; यदि यह एक बार काम करता है और फिर अगले मूल टूल कॉल पर लौट आता है,
तो `/new` दोहराने के बजाय Codex ऐप-सर्वर या OpenClaw Gateway
पुनः आरंभ करें। [Codex हार्नेस समस्या निवारण](/hi/plugins/codex-harness#troubleshooting)
देखें।
</Note>

## संबंधित

- [ACP एजेंट - सेटअप](/hi/tools/acp-agents-setup)
- [एजेंट प्रेषण](/hi/tools/agent-send)
- [CLI बैकएंड](/hi/gateway/cli-backends)
- [Codex हार्नेस](/hi/plugins/codex-harness)
- [Codex हार्नेस रनटाइम](/hi/plugins/codex-harness-runtime)
- [मल्टी-एजेंट सैंडबॉक्स टूल](/hi/tools/multi-agent-sandbox-tools)
- [`openclaw acp` (ब्रिज मोड)](/hi/cli/acp)
- [उप-एजेंट](/hi/tools/subagents)
