@agent-native/core 0.76.5 → 0.76.6

package/docs/content/locales/hi-IN/pr-visual-recap.md

@@ -0,0 +1,384 @@
+---
+title: "पीआर विज़ुअल रिकैप"
+description: "एक GitHub एक्शन जो प्रत्येक पीआर पर आपके रेपो के विज़ुअल-रीकैप कौशल को चलाता है। एक LLM कोडिंग एजेंट अंतर को पढ़ता है, एक इंटरैक्टिव रीकैप योजना प्रकाशित करता है, एक सूचनात्मक जांच दिखाता है, और एक इनलाइन स्क्रीनशॉट के साथ एक चिपचिपा पीआर टिप्पणी पोस्ट करता है। सूचनात्मक और गैर-अवरोधक."
+---
+
+# पीआर विज़ुअल रिकैप
+
+पीआर विज़ुअल रिकैप एक GitHub एक्शन है जो प्रत्येक पुल अनुरोध को **विज़ुअल कोड समीक्षा** में बदल देता है। प्रत्येक पुश पर, एक LLM कोडिंग एजेंट पीआर अंतर के विरुद्ध नवीनतम बंडल [`visual-recap`](/docs/template-plan) कौशल (या `VISUAL_RECAP_SKILL_SOURCE=repo` होने पर आपके रेपो की प्रतिबद्ध प्रतिलिपि) चलाता है, होस्टेड प्लान्स ऐप पर एक संरचित पुनर्कथन योजना प्रकाशित करता है, चलने के दौरान एक सूचनात्मक `Visual Recap` चेक दिखाता है, और ** एक चिपचिपा पीआर टिप्पणी ** डालता है जो इंटरैक्टिव योजना से लिंक करता है ** इनलाइन स्क्रीनशॉट ** के साथ सही में एम्बेडेड होता है। टिप्पणी करें.
+
+यह एक नियतात्मक अंतर रेंडरर नहीं है। कार्रवाई एक वास्तविक कोडिंग एजेंट (डिफ़ॉल्ट रूप से Claude कोड CLI, या OpenAI Codex CLI) को आमंत्रित करती है जो परिवर्तन को पढ़ता है, निर्णय लेता है कि क्या मायने रखता है, और प्लान MCP टूल `create-visual-recap` को कॉल करके पुनर्कथन लिखता है - वही टूल जो `/visual-recap` स्लैश कमांड उपयोग करता है। आपको कच्चे अंतर की दीवार के बजाय परिवर्तन का एक उच्च-ऊंचाई, स्कीमा/API/पहले-बाद का दृश्य मिलता है।
+
+पुनरावर्तन **सूचनापूर्ण और गैर-अवरुद्ध** है। यह एक चेक पंक्ति बनाता है ताकि समीक्षक देख सकें कि पीढ़ी प्रगति पर है, लेकिन यह एक आवश्यक जांच नहीं है, यह कभी भी पीआर को अवरुद्ध नहीं करता है, और यह कभी भी वास्तविक अंतर को पढ़ने की जगह नहीं लेता है। चिपचिपी टिप्पणी एक समीक्षा सहायता है, साइन-ऑफ़ नहीं।
+
+## यह क्या करता है
+
+प्रत्येक पीआर पुश पर, वर्कफ़्लो:
+
+1. पीआर बेस और हेड के बीच एक सीमित अंतर एकत्रित करता है।
+2. `Visual recap in progress` के साथ एक सूचनात्मक `Visual Recap` GitHub चेक बनाता है।
+3. उस अंतर के विरुद्ध कॉन्फ़िगर किए गए कोडिंग एजेंट को चलाता है। एजेंट बंडल किए गए `visual-recap` कौशल मार्गदर्शन (या आपकी रेपो-पिन की गई कॉपी) को पढ़ता है और एक पुनर्कथन लिखता है, इसे `create-visual-recap` के साथ प्रकाशित करता है।
+4. एजेंट द्वारा `recap-url.txt` को लिखी गई प्रकाशित योजना URL पढ़ता है।
+5. उस URL को हेडलेस क्रोम में खोलता है और रेंडर किए गए प्लान को प्रकाश और अंधेरे मोड में स्क्रीनशॉट करता है।
+6. पीएनजी को योजना ऐप पर एक हस्ताक्षरित सार्वजनिक छवि मार्ग पर अपलोड करता है।
+7. एक एकल चिपचिपा पीआर टिप्पणी डालता है जो इंटरैक्टिव रीकैप के लिंक के बगल में एक `<picture>` तत्व (GitHub के कैमो इमेज प्रॉक्सी के माध्यम से परोसा गया) के साथ स्क्रीनशॉट **इनलाइन** को एम्बेड करता है।
+8. `Visual Recap` चेक को सफल, छोड़े गए या तटस्थ के रूप में पूरा करता है।
+
+```an-diagram title="What happens on each PR push" summary="A bounded diff feeds a real coding agent, which authors a recap; the workflow screenshots it and upserts one sticky comment."
+{
+  "html": "<div class=\"diagram-recap\"><div class=\"diagram-node\">PR push<br><small class=\"diagram-muted\">bounded base&hellip;head diff</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-node\">Coding agent<br><small class=\"diagram-muted\">Claude Code / Codex reads diff</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-panel center\"><span class=\"diagram-pill accent\">create-visual-recap</span><small class=\"diagram-muted\">publishes recap plan</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-node\">Headless Chrome<br><small class=\"diagram-muted\">light + dark screenshots</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-box\">One sticky PR comment<br><small class=\"diagram-muted\">inline screenshot + plan link</small></div></div><div class=\"diagram-foot diagram-muted\">Plus an informational <span class=\"diagram-pill\">Visual Recap</span> check &mdash; non-blocking, never required.</div>",
+  "css": ".diagram-recap{display:flex;align-items:center;gap:10px;flex-wrap:wrap}.diagram-recap .diagram-arrow{font-size:20px;line-height:1}.diagram-recap .center{display:flex;flex-direction:column;align-items:center;gap:4px;text-align:center}.diagram-recap .diagram-foot{flex-basis:100%;margin-top:10px;font-size:13px}"
+}
+```
+
+एक री-पुश उसी योजना को अपडेट करता है और उसी स्थान पर वही चिपचिपी टिप्पणी करता है - कोई अनाथ योजना नहीं, कोई टिप्पणी स्पैम नहीं।
+
+## इसे स्थापित करना
+
+जब आप इंटरैक्टिव रूप से प्लान इंस्टॉल करते हैं, तो Agent-Native CLI पूछता है कि क्या जोड़ना है
+स्वचालित पीआर विज़ुअल रिकैप्स। GitHub एक्शन लिखने के लिए हाँ कहें, या इसे जोड़ें
+स्पष्ट रूप से किसी भी समय:
+
+```bash
+npx @agent-native/core@latest skills add visual-plan --with-github-action
+```
+
+यह `visual-plan` कौशल स्थापित करता है (जिसमें `visual-recap` कौशल शामिल है जो क्रिया चलाता है) और आपके रेपो में `.github/workflows/pr-visual-recap.yml` लिखता है। वर्कफ़्लो `npx @agent-native/core@latest recap <subcommand>` के माध्यम से **प्रकाशित CLI उपकमांड** को कॉल करता है - जिसमें `gate`, `collect-diff`, `block-reference`, `scan`, `build-prompt`, `publish`, `shot`, `comment`, `check`, और शामिल हैं। `usage` - इसलिए आपके रेपो में सहायक स्क्रिप्ट के रूप में कुछ भी कॉपी नहीं किया गया है। `setup` और `doctor` आपके द्वारा स्थानीय स्तर पर चलाए जाने वाले इंटरैक्टिव सहायक हैं; `gate` सुरक्षा-द्वार चरण है जो वर्कफ़्लो प्रत्येक पुनर्कथन से पहले चलता है।
+
+फिर निर्देशित सेटअप सहायक चलाएँ:
+
+```bash
+npx @agent-native/core@latest recap setup
+npx @agent-native/core@latest recap doctor
+```
+
+`recap setup` वर्कफ़्लो को ताज़ा करता है, GitHub Actions सेट करने के लिए `gh` का उपयोग करता है
+रहस्य/चर जब मान env या स्थानीय योजनाओं से उपलब्ध होते हैं
+पब्लिश-टोकन स्टोर, और किसी भी चीज़ के लिए बिल्कुल गायब कमांड प्रिंट करता है
+सेट. गुप्त मान `gh` को stdin के माध्यम से भेजे जाते हैं, कमांड तर्कों के माध्यम से नहीं। प्रतिबद्ध
+जनरेट की गई वर्कफ़्लो फ़ाइल और इसे चलाने के लिए एक पीआर खोलें।
+
+डिफ़ॉल्ट रूप से, वर्कफ़्लो नवीनतम बंडल से अपना एजेंट प्रॉम्प्ट बनाता है
+`@agent-native/core@latest` में `visual-recap` मार्गदर्शन, किसी भी भाई-बहन सहित
+संदर्भ फ़ाइलें कौशल भेजती हैं। यदि आपका रेपो जानबूझकर अनुकूलित करता है और
+अपने प्रतिबद्ध `visual-recap` फ़ोल्डर को पिन करता है, रिपॉजिटरी वेरिएबल सेट करता है
+`VISUAL_RECAP_SKILL_SOURCE=repo`.
+
+## बैकएंड चयन
+
+चुनें कि कौन सा कोडिंग एजेंट `VISUAL_RECAP_AGENT` रिपॉजिटरी वेरिएबल के साथ कौशल चलाता है:
+
+| `VISUAL_RECAP_AGENT`  | कोडिंग एजेंट     | आवश्यक API कुंजी    |
+| --------------------- | ---------------- | ------------------- |
+| `claude` _(डिफ़ॉल्ट)_ | Claude कोड CLI   | `ANTHROPIC_API_KEY` |
+| `codex`               | OpenAI Codex CLI | `OPENAI_API_KEY`    |
+
+यदि वेरिएबल अनसेट है, तो कार्रवाई `claude` का उपयोग करती है।
+
+## मॉडल और तर्क
+
+बैकएंड से परे, दो रिपॉजिटरी वैरिएबल एजेंट को चलाने के तरीके को ट्यून करते हैं:
+
+- **`VISUAL_RECAP_MODEL`** मॉडल को CLI (`--model`) में पिन करता है - उदाहरण के लिए Codex के लिए `gpt-5.5`, या Claude मॉडल आईडी। CLI के अपने डिफ़ॉल्ट मॉडल का उपयोग करने के लिए इसे अनसेट छोड़ दें।
+- **`VISUAL_RECAP_REASONING`** तर्क की गहराई निर्धारित करता है: `none`, `minimal`, `low`, `medium`, `high`, या `xhigh`। यह Codex बैकएंड पर लागू होता है; Claude का तर्क मॉडल-चालित है, इसलिए इस चर को वहां नजरअंदाज कर दिया गया है।
+- **`VISUAL_RECAP_SKILL_SOURCE`** त्वरित ताजगी को नियंत्रित करता है: `auto`/unset नवीनतम बंडल कौशल मार्गदर्शन का उपयोग करता है, जबकि `repo` प्रतिबद्ध रेपो-स्थानीय `visual-recap` कौशल फ़ोल्डर में पिन करता है।
+
+उदाहरण के लिए, Codex पर GPT-5.5 के साथ उच्च तर्क पर रिकैप चलाने के लिए, रिपॉजिटरी वेरिएबल `VISUAL_RECAP_AGENT=codex`, `VISUAL_RECAP_MODEL=gpt-5.5`, और `VISUAL_RECAP_REASONING=high` सेट करें।
+
+## रहस्य और चर
+
+इन्हें अपने भंडार की **सेटिंग्स → रहस्य और चर → Actions** में सेट करें।
+
+### रहस्य (केवल दो आवश्यक)
+
+| गुप्त               | उद्देश्य                                                                                                                                              |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `PLAN_RECAP_TOKEN`  | `npx @agent-native/core@latest connect` द्वारा प्रतिसंहरणीय टोकन ढाला गया। पुनर्कथन योजना और स्क्रीनशॉट अपलोड को प्रकाशित करने के लिए अधिकृत करता है। |
+| `ANTHROPIC_API_KEY` | डिफ़ॉल्ट Claude कोड बैकएंड के लिए LLM कुंजी।                                                                                                          |
+
+**टीमें: एक संगठन सेवा टोकन का उपयोग करें।** एक व्यक्तिगत टोकन व्यक्ति से जुड़ा होता है
+इसे किसने बनाया - यदि वे संगठन छोड़ देते हैं या अपने टोकन रद्द कर देते हैं, तो प्रत्येक रेपो का उपयोग किया जाता है
+वह रहस्य 401 के साथ विफल होना शुरू हो जाता है, और सीआई-निर्मित योजनाएं उसी के स्वामित्व में होती हैं
+टीम के बजाय व्यक्तिगत। एक संगठन सेवा टोकन का स्वामित्व आपके
+**संगठन**: यह एक सेवा प्रिंसिपल (`svc-<name>@service.<orgId>`) के रूप में कार्य करता है,
+किसी भी व्यक्ति के जाने से बच जाता है, इसके द्वारा प्रकाशित पुनर्कथन ऑर्ग-दृश्यमान होते हैं, और
+कोई भी संगठन स्वामी या व्यवस्थापक इसे सूचीबद्ध या रद्द कर सकता है। टकसाल एक (केवल संगठन स्वामी/व्यवस्थापक):
+
+```bash
+npx @agent-native/core@latest connect https://plan.agent-native.com --service-token pr-recap
+```
+
+कमांड आपको ब्राउज़र में प्रमाणित करता है, फिर सेवा टोकन प्रिंट करता है
+बिल्कुल एक बार - इसे `PLAN_RECAP_TOKEN` रहस्य के रूप में संग्रहीत करें। इसे बाद में
+`list-org-service-tokens` और `revoke-org-service-token` actions पर
+योजना ऐप.
+
+**सोलो: एक व्यक्तिगत टोकन अभी भी काम करता है।** इसे `npx @agent-native/core@latest connect` के साथ मिंट करें
+आपके प्लान ऐप के विरुद्ध। होस्ट किए गए ऐप के लिए, यह एक स्थानीय भी लिखता है
+प्रकाशन-टोकन फ़ाइल जिसे `npx @agent-native/core@latest recap setup` पढ़ सकता है:
+
+```bash
+npx @agent-native/core@latest connect https://plan.agent-native.com --client codex
+npx @agent-native/core@latest recap setup
+```
+
+यदि आप मैन्युअल सेटअप पसंद करते हैं, तो टोकन को GitHub सीक्रेट में पेस्ट करें। ए
+केवल उदाहरणों के लिए `plan_recap_xxxxxxxxxxxxxxxx` जैसे प्लेसहोल्डर - कभी भी प्रतिबद्ध न हों
+वास्तविक टोकन।
+
+### वैकल्पिक (केवल यदि आप डिफ़ॉल्ट बदलते हैं)
+
+| गुप्त/चर                 | डिफ़ॉल्ट                        | जब आपको इसकी आवश्यकता हो                                                                                                                                    |
+| ------------------------ | ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `OPENAI_API_KEY`         | —                               | गुप्त. इसके बजाय Codex के साथ रिकैप चलाने के लिए `VISUAL_RECAP_AGENT=codex` के साथ सेट करें।                                                                |
+| `VISUAL_RECAP_AGENT`     | `claude`                        | परिवर्तनीय. कोडिंग-एजेंट बैकएंड (`claude` या `codex`) का चयन करता है।                                                                                       |
+| `VISUAL_RECAP_MODEL`     | प्रत्येक CLI का डिफ़ॉल्ट        | चर। मॉडल को पिन करें - उदा. Codex के लिए `gpt-5.5`, या Claude मॉडल आईडी। अनसेट CLI के स्वयं के डिफ़ॉल्ट का उपयोग करता है।                                   |
+| `VISUAL_RECAP_REASONING` | प्रत्येक मॉडल का डिफ़ॉल्ट       | परिवर्तनीय. तर्क की गहराई: `none`, `minimal`, `low`, `medium`, `high`, या `xhigh`। Codex बैकएंड पर लागू होता है।                                            |
+| `RECAP_CLI_VERSION`      | `latest`                        | चर। वर्कफ़्लो इंस्टॉल होने पर `@agent-native/core` CLI संस्करण को पिन करें - उदाहरण के लिए `1.5.0`. [Version pinning](#version-pinning-copy-variant) देखें. |
+| `PLAN_RECAP_APP_URL`     | `https://plan.agent-native.com` | गुप्त. केवल तभी जब प्लान्स ऐप को किसी भिन्न मूल पर स्वयं-होस्ट किया जाए।                                                                                    |
+
+वर्कफ़्लो स्वचालित रूप से पता लगाता है कि इसके सहायक CLI (इस मोनोरेपो के अंदर स्थानीय स्रोत, कहीं और प्रकाशित `@agent-native/core`) को कैसे लागू किया जाए, इसलिए सेट करने के लिए कोई `RECAP_CLI` वेरिएबल नहीं है।
+
+## टिप्पणी में इनलाइन स्क्रीनशॉट
+
+एजेंट द्वारा पुनर्कथन प्रकाशित करने के बाद, वर्कफ़्लो प्रकाश और अंधेरे दोनों मोड में हेडलेस क्रोम में रेंडर किए गए प्लान का स्क्रीनशॉट लेता है और पीएनजी को प्लान ऐप पर एक हस्ताक्षरित सार्वजनिक छवि रूट पर अपलोड करता है। चिपचिपा पीआर टिप्पणी तब उन स्क्रीनशॉट को `<picture>` तत्व के साथ ** इनलाइन ** एम्बेड करती है - GitHub उन्हें अपने कैमो प्रॉक्सी के माध्यम से फिर से परोसती है, इसलिए समीक्षक एक पूर्वावलोकन देखते हैं जो बिना कुछ भी खोले सीधे टिप्पणी में उनकी GitHub थीम से मेल खाता है। जब वे अन्वेषण करना, टिप्पणी करना या टिप्पणी करना चाहते हैं तो पूर्ण इंटरैक्टिव योजना का लिंक इसके ठीक बगल में होता है।
+
+## फोर्क पीआर
+
+### डिफ़ॉल्ट व्यवहार (कोई कार्रवाई आवश्यक नहीं)
+
+मुख्य `pr-visual-recap.yml` वर्कफ़्लो सादे `pull_request` ट्रिगर पर सक्रिय होता है, **नहीं** `pull_request_target`। इसलिए फोर्क पीआर **रिपॉजिटरी सीक्रेट्स तक कोई पहुंच नहीं** के साथ चलते हैं, इसलिए वर्कफ़्लो को कोई `PLAN_RECAP_TOKEN` नहीं मिलता है और साफ़ तौर पर नो-ऑप्स मिलता है - कोई असफल प्रकाशन नहीं, कोई क्रेडेंशियल उजागर नहीं होता है। उसी भंडार में शाखाओं से पीआर के लिए रीकैप स्वचालित रूप से चलते हैं, जहां रहस्य उपलब्ध हैं।
+
+इसका मतलब यह भी है कि आप वर्कफ़्लो फ़ाइल को **इससे पहले** मर्ज कर सकते हैं कि रहस्य मौजूद हैं: बिना किसी टोकन कॉन्फ़िगर के, जब तक आप रहस्य सेट नहीं करते, हर रन एक शांत नो-ऑप है। `gate` चरण स्वचालित रूप से ड्राफ्ट पीआर और बॉट-लिखित पीआर को भी छोड़ देता है, इसलिए कोई भी ट्रिगर रिकैप डिफ़ॉल्ट रूप से नहीं चलता है।
+
+### लेबल-गेटेड फोर्क वर्कफ़्लो के साथ ऑप्ट-इन करें
+
+यदि आप फोर्क पीआर के लिए रीकैप्स जेनरेट करना चाहते हैं, तो एक दूसरी वर्कफ़्लो फ़ाइल उपलब्ध है: `.github/workflows/pr-visual-recap-fork.yml`। यह `pull_request_target` (जो बेस-रेपो रहस्यों के साथ चलता है) का उपयोग करता है लेकिन कभी भी फोर्क कोड की जांच या निष्पादन नहीं करता है। GitHub लेखक संघ `OWNER`, `MEMBER`, या `COLLABORATOR` के साथ विश्वसनीय कांटा लेखक स्वचालित रूप से चलते हैं। आउटसाइड फोर्क पीआर को रिकैप एजेंट चलने से पहले एक ताजा `recap` लेबल इवेंट के माध्यम से एक स्पष्ट **प्रति-हेड मेंटेनर ऑप्ट-इन** की आवश्यकता होती है।
+
+इसे स्थापित करने के लिए, फ़ाइल को [BuilderIO/agent-native](https://github.com/BuilderIO/agent-native/blob/main/.github/workflows/pr-visual-recap-fork.yml) से मौजूदा `pr-visual-recap.yml` के साथ अपने रेपो की `.github/workflows/` निर्देशिका में कॉपी करें। वही रहस्य (`PLAN_RECAP_TOKEN`, `ANTHROPIC_API_KEY`) लागू होते हैं।
+
+```an-diagram title="Fork PR consent gate" summary="Fork PRs get no secrets by default; trusted authors run automatically, and outside contributors require a fresh maintainer recap label."
+{
+  "html": "<div class=\"diagram-fork\"><div class=\"diagram-node\">Fork PR opened<br><small class=\"diagram-muted\">main workflow has no secrets</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-card\"><span class=\"diagram-pill ok\">Trusted author</span><small class=\"diagram-muted\">OWNER, MEMBER, or COLLABORATOR runs automatically</small></div><div class=\"diagram-card\"><span class=\"diagram-pill warn\">Outside contributor</span><small class=\"diagram-muted\">maintainer reviews diff, then applies <code>recap</code></small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-panel center\">Gate checks<br><small class=\"diagram-muted\">fork PR? &amp; trusted or fresh label?</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-box ok\">Recap runs<br><small class=\"diagram-muted\">base-repo code only · fork diff is text input</small></div></div>",
+  "css": ".diagram-fork{display:flex;align-items:center;gap:10px;flex-wrap:wrap}.diagram-fork .diagram-arrow{font-size:20px;line-height:1}.diagram-fork .center{display:flex;flex-direction:column;align-items:center;gap:4px;text-align:center}.diagram-fork .diagram-card{display:flex;flex-direction:column;gap:6px;padding:12px 14px}"
+}
+```
+
+### लेबल गेट कैसे काम करता है
+
+1. एक कांटा योगदानकर्ता एक पीआर खोलता है। सामान्य `pull_request` वर्कफ़्लो रुक जाता है क्योंकि GitHub फोर्क रन से रहस्य छुपाता है।
+2. फोर्क वर्कफ़्लो पीआर लेखक एसोसिएशन की जाँच करता है। विश्वसनीय लेखक (`OWNER`, `MEMBER`, या `COLLABORATOR`) ओपन, सिंक्रोनाइज़, रीओपन और समीक्षा के लिए तैयार इवेंट पर स्वचालित रूप से चलते हैं।
+3. बाहरी योगदानकर्ताओं को वर्तमान अंतर की समीक्षा करने के लिए एक अनुरक्षक की आवश्यकता होती है (विशेष रूप से शीघ्र-इंजेक्शन-आकार की सामग्री के लिए - नीचे देखें), फिर पीआर पर `recap` लेबल लागू करें।
+4. बाहरी-योगदानकर्ता लेबल गेट प्रति हेड SHA है: यदि योगदानकर्ता अधिक प्रतिबद्धताओं को दबाता है, तो अगला सिंक्रोनाइज़ ईवेंट तब तक रुक जाता है जब तक कि कोई अनुरक्षक नए अंतर की समीक्षा करने के बाद `recap` को हटा नहीं देता और पुनः लागू नहीं कर देता।
+
+### फोर्क वर्कफ़्लो क्या करता है और NOT क्या करता है
+
+| कार्यप्रवाह DOES                                                                                                                       | वर्कफ़्लो NOT                                                                                         |
+| -------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
+| **बेस रिपॉजिटरी** को **बेस ब्रांच रेफरी** पर चेकआउट करें - केवल विश्वसनीय कोड                                                          | फोर्क से किसी भी कोड को जांचें या निष्पादित करें                                                      |
+| फोर्क हेड को रिमोट रेफ (`git fetch origin pull/<n>/head:refs/recap/fork-head`) के रूप में प्राप्त करें - कमिट प्राप्त करना सुरक्षित है | फोर्क से पैकेज इंस्टॉल करें, फोर्क स्क्रिप्ट चलाएं, या कोड के रूप में फोर्क सामग्री का मूल्यांकन करें |
+| `git diff base...refs/recap/fork-head` चलाएँ - पहले से प्राप्त दो वस्तुओं का शुद्ध पाठ अंतर                                            | LLM में टेक्स्ट इनपुट के अलावा किसी अन्य चीज़ के रूप में अंतर का उपयोग करें                           |
+| **बेस रेपो** विज़ुअल-रीकैप कौशल और एजेंट कॉन्फ़िगरेशन चलाएँ                                                                            | फोर्क से कोई भी कौशल या कॉन्फ़िगरेशन लोड करें                                                         |
+| प्रथम-पक्ष पीआर के समान गुप्त-स्कैन चरण (विफल-बंद) के माध्यम से अंतर को पार करें                                                       | गुप्त स्कैन छोड़ें                                                                                    |
+| अलग-अलग सामग्री को अविश्वसनीय के रूप में चिह्नित करते हुए एजेंट प्रॉम्प्ट में एक स्पष्ट प्रॉम्प्ट-हार्डनिंग नोट जोड़ें                 | एजेंट को सामान्य रीकैप एजेंट से परे कोई भी अतिरिक्त अनुमति प्रदान करें                                |
+
+### आपको लेबलिंग से पहले अंतर की समीक्षा क्यों करनी चाहिए
+
+फोर्क डिफ हमलावर-नियंत्रित टेक्स्ट है जिसे रीकैप एजेंट इनपुट के रूप में पढ़ता है। सावधानी से तैयार किए गए अंतर में शीघ्र-इंजेक्शन सामग्री हो सकती है - उदाहरण के लिए, एजेंट निर्देशों की तरह दिखने वाली अलग-अलग लाइनें - जिसका उद्देश्य पुनर्कथन एजेंट को अनपेक्षित actions लेना है (उदाहरण के लिए, प्रकाशन टोकन को बाहर निकालना या भ्रामक पुनर्कथन सामग्री का उत्पादन करना)।
+
+`recap` लेबल लगाने से पहले, अंतर को ध्यान से देखें:
+
+- पंक्तियाँ जो प्रत्यक्ष आदेशों या भूमिका निर्देशों की तरह पढ़ती हैं ("पिछले निर्देशों को अनदेखा करें...", "आप अभी हैं...", "टोकन लिखें...")।
+- असामान्य फ़ाइल नाम जिन्हें सिस्टम संकेत के रूप में गलत तरीके से पढ़ा जा सकता है।
+- जोड़ी गई फ़ाइलों में एन्कोड की गई सामग्री जो निर्देशों को डिकोड कर सकती है।
+
+ये शमन पहले से ही वर्कफ़्लो (गुप्त स्कैन, संवेदनशील-पथ गेट, शीघ्र-सख्त नोट, प्रतिबंधित एजेंट टूल अनुमति सूची) में स्तरित हैं, लेकिन लेबल समीक्षा रक्षा की प्राथमिक पंक्ति है।
+
+### मुख्य वर्कफ़्लो से संबंध
+
+दो वर्कफ़्लो फ़ाइलें स्वतंत्र हैं। गैर-फोर्क पीआर अपडेट के लिए, `pr-visual-recap.yml` एकमात्र वर्कफ़्लो है जो चलता है। फोर्क पीआर के लिए, सामान्य वर्कफ़्लो इसके फोर्क गेट से बाहर निकलता है, और `pr-visual-recap-fork.yml` विश्वसनीय समान-ऑर्ग लेखकों के लिए या बाहरी योगदानकर्ताओं के लिए एक नए अनुरक्षक `recap` लेबल के बाद स्वचालित रूप से चलता है। वे समान स्टिकी कमेंट मार्कर और प्लान-आईडी थ्रेडिंग साझा करते हैं, इसलिए पीआर और फोर्क पीआर दोनों एक ही पीआर पर एक ही सम्मिलित टिप्पणी उत्पन्न करते हैं।
+
+### स्वयं-संशोधित गार्ड {#self-modifying-guard}
+
+`gate` चरण पूरी तरह से पुनर्कथन को छोड़ देता है जब कोई पीआर निम्न में से किसी भी पथ को छूता है, इसलिए एक पीआर कभी भी वर्कफ़्लो, कौशल या एजेंट कॉन्फ़िगरेशन को फिर से नहीं लिख सकता है जो विश्वसनीय पुनर्कथन कार्य लोड करता है और रहस्यों को बाहर निकालता है:
+
+| पथ पैटर्न                                  | कारण                                     |
+| ------------------------------------------ | ---------------------------------------- |
+| `.github/workflows/pr-visual-recap.yml`    | वर्कफ़्लो स्वयं                          |
+| `**/skills/visual-(recap\|plan\|plans)/**` | The visual-recap skill the agent follows |
+| `**/.claude/**`                            | एजेंट सेटिंग रनर लोड करता है             |
+| `**/CLAUDE.md`                             | एजेंट रनर को लोड करने का निर्देश देता है |
+| `**/AGENTS.md`                             | एजेंट रनर को लोड करने का निर्देश देता है |
+| `**/.mcp.json`                             | MCP सर्वर कॉन्फिगरेशन रनर लोड            |
+
+`BuilderIO/agent-native` मोनोरेपो में, वर्कफ़्लो पीआर-हेड स्रोत के बजाय विश्वसनीय बेस-ब्रांच स्रोत से रिकैप CLI चलाता है। यह `packages/core/**` सहित सामान्य पैकेज परिवर्तनों को बनाए रखता है, जो PR-संशोधित CLI कोड को निष्पादित किए बिना पुनर्कथन के लिए पात्र है।
+
+## स्थानीय-फ़ाइलें गोपनीयता मोड
+
+GitHub एक्शन होस्ट की गई, साझा करने योग्य पीआर समीक्षा के लिए डिज़ाइन किया गया है। यदि आप एक
+Agent-Native योजना डेटाबेस में पुनर्कथन सामग्री भेजे बिना, चलाएँ
+इसके बजाय स्थानीय-फ़ाइल मोड में समान सहायक प्रवाह स्थानीय रूप से होता है:
+
+```bash
+npx @agent-native/core@latest recap collect-diff --base main --head HEAD --out recap.diff --stat recap.stat
+npx @agent-native/core@latest recap scan --diff recap.diff
+npx @agent-native/core@latest recap build-prompt --pr 123 --diff recap.diff --stat recap.stat --local-files --local-dir plans/pr-123-visual-recap
+```
+
+जनरेट किए गए `recap-prompt.md` को अपने कोडिंग एजेंट को दें। स्थानीय-फ़ाइलें मोड
+प्रॉम्प्ट एजेंट को `plans/pr-123-visual-recap/plan.mdx` लिखने का निर्देश देता है
+प्लस वैकल्पिक दृश्य फ़ाइलें और फिर चलाएँ:
+
+```bash
+npx @agent-native/core@latest plan local serve --dir plans/pr-123-visual-recap --kind recap --open
+```
+
+लौटा हुआ URL होस्ट किए गए प्लान UI को खोलता है जबकि ब्राउज़र पुनर्कथन MDX पढ़ता है
+लोकलहोस्ट ब्रिज से। पुनर्कथन सामग्री होस्ट की गई योजना पर नहीं लिखी गई है
+डेटाबेस, और URL केवल ब्रिज चलाने वाली मशीन पर काम करता है। यदि आप दौड़ते हैं
+स्थानीय रूप से समान `PLAN_LOCAL_DIR` के साथ प्लान ऐप,
+`/local-plans/pr-123-visual-recap` मार्ग भी मान्य है। रेपो-समर्थित फ़ोल्डर
+`/local-plans/pr-123-visual-recap?path=plans%2Fpr-123-visual-recap` के रूप में खोलें।
+यह मोड होस्ट किए गए स्टिकी पीआर कमेंट, इनलाइन स्क्रीनशॉट अपलोड को अक्षम कर देता है
+उपयोग अनुलग्नक, और ब्राउज़र टिप्पणियाँ जब तक आप स्पष्ट रूप से प्रकाशित नहीं करते।
+
+## यह सूचनात्मक है, गेट नहीं
+
+पुनरावर्तन सामान्य पीआर प्रवाह के शीर्ष पर एक समीक्षा सहायता है:
+
+- यह दृश्यता के लिए एक `Visual Recap` चेक पंक्ति दिखाता है, लेकिन यह **कभी भी आवश्यक चेक** नहीं होता है और कभी भी विलय को अवरुद्ध नहीं करता है।
+- एक पीढ़ी या प्रकाशन विफलता तटस्थ रूप से पूरी होती है और एक व्याख्यात्मक चिपचिपी टिप्पणी के रूप में सामने आती है, न कि असंबंधित कोड पर लाल एक्स के रूप में।
+- पुनरावर्तन और उसका स्क्रीनशॉट **इसका मतलब यह नहीं है कि अंतर की समीक्षा की गई है**। समीक्षकों को अभी भी वास्तविक परिवर्तित पंक्तियों को पढ़ने की आवश्यकता है।
+
+## संस्करण पिनिंग (कॉपी संस्करण) {#version-pinning-copy-variant}
+
+डिफ़ॉल्ट रूप से कॉपी-वेरिएंट वर्कफ़्लो रन टाइम पर `@agent-native/core@latest` इंस्टॉल करता है इसलिए प्रत्येक रीकैप रन स्वचालित रूप से नवीनतम CLI चुनता है। यदि आपके CI को प्रतिलिपि प्रस्तुत करने योग्य टूलींग की आवश्यकता है, तो स्थापित संस्करण को पिन करने के लिए **`RECAP_CLI_VERSION`** रिपोजिटरी वेरिएबल सेट करें:
+
+1. अपने रेपो की **सेटिंग्स → रहस्य और वेरिएबल्स → Actions → वेरिएबल्स** पर जाएं।
+2. `1.5.0` जैसे मान के साथ `RECAP_CLI_VERSION` नाम का एक वेरिएबल बनाएं।
+
+वेरिएबल वैकल्पिक है. नवीनतम रिलीज़ को ट्रैक करने के लिए इसे अनसेट छोड़ दें (या इसे `latest` पर सेट करें)।
+
+पुन: प्रयोज्य-कॉलर संस्करण के लिए, इसके बजाय `cli-version` इनपुट का उपयोग करें (पुन: प्रयोज्य अनुभाग में [Version pinning](#version-pinning) देखें)।
+
+## गुप्त-स्कैन अनुमति सूची
+
+रिकैप प्रकाशित करने से पहले वर्कफ़्लो अंतर में संभावित रहस्यों का पता लगाने के लिए `npx @agent-native/core@latest recap scan` चलाता है। कोई भी पीआर जिसका अंतर ज्ञात-गुप्त पैटर्न से मेल खाता है, उसे एक व्याख्यात्मक टिप्पणी के साथ अवरुद्ध कर दिया जाता है - पुनर्कथन प्रकाशित नहीं किया जाता है, और कोडिंग एजेंट को कोई भिन्न सामग्री नहीं भेजी जाती है।
+
+दुर्लभ मामलों में किसी रेपो में जानबूझकर परीक्षण फिक्स्चर या गैर-गुप्त स्ट्रिंग्स होती हैं जो सतही तौर पर गुप्त पैटर्न से मिलती जुलती होती हैं (उदाहरण के लिए, परीक्षण फ़ाइल में एक फिक्स्चर कुंजी)। झूठी सकारात्मकता को दबाने के लिए, अपने रिपॉजिटरी के रूट में `.github/recap-scan-allowlist` बनाएं।
+
+### प्रारूप
+
+प्रत्येक गैर-रिक्त, गैर-टिप्पणी पंक्ति या तो एक **शाब्दिक सबस्ट्रिंग** या **`/regex/flags`** पैटर्न है:
+
+```
+# Lines starting with # are comments.
+
+# Literal substring — any diff line containing this string is allowed.
+sk-test-fixture1234567890abcdef
+
+# Regex pattern — written as /pattern/flags (JS syntax).
+/^.STRIPE_KEY=sk-test-/i
+
+# Another literal.
+EXAMPLE_API_KEY=placeholder-value
+```
+
+नियम:
+
+- एक पंक्ति **दबी हुई** (अनुमत) होती है जब उसमें शाब्दिक अर्थ होता है, या जब पूरी पंक्ति रेगेक्स से मेल खाती है।
+- फ़ाइल **विफल-बंद** है: यदि यह अनुपस्थित है, तो कोई दमन लागू नहीं होता है - स्कैनर पहले की तरह व्यवहार करता है।
+- एक खाली फ़ाइल बिना किसी फ़ाइल के बराबर है।
+- विकृत रेगेक्स पंक्तियों को शाब्दिक स्ट्रिंग के रूप में माना जाता है।
+
+अनुमति सूची की जांच केवल गुप्त-स्कैन गेट द्वारा की जाती है। यह प्रभावित नहीं करता है कि कोडिंग एजेंट क्या पढ़ सकता है - यदि गेट पास हो जाता है, तो एजेंट को पूर्ण अंतर प्राप्त होता है।
+
+## पुन: प्रयोज्य वर्कफ़्लो के रूप में अपनाएं
+
+### पुनः प्रयोज्य संस्करण का उपयोग क्यों करें?
+
+डिफ़ॉल्ट इंस्टॉलर पूर्ण ~360-लाइन वर्कफ़्लो YAML को आपके रेपो (**कॉपी** विकल्प) में कॉपी करता है। यह एयर-गैप्ड रिपोज़ या रिपोज़ के लिए सही विकल्प है, जिन्हें चलने वाली प्रत्येक पंक्ति का ऑडिट करने की आवश्यकता होती है। नकारात्मक पक्ष यह है कि बग फिक्स और सुधार कभी भी आप तक नहीं पहुंचते हैं - आपको प्रत्येक रिलीज़ के बाद `npx @agent-native/core@latest recap setup` को मैन्युअल रूप से फिर से चलाने की आवश्यकता होती है।
+
+**पुन: प्रयोज्य** विकल्प इसके बजाय एक पतली ~20-लाइन कॉलर लिखता है। यह `uses:` के माध्यम से `BuilderIO/agent-native/.github/workflows/pr-visual-recap-reusable.yml` को सौंपता है। जब वर्कफ़्लो चलता है तो प्रत्येक कॉलर स्वचालित रूप से नवीनतम तर्क उठाता है, बिना किसी स्थानीय अपडेट की आवश्यकता के।
+
+|                                        | कॉपी करें (डिफ़ॉल्ट)               | पुनः प्रयोज्य                        |
+| -------------------------------------- | ---------------------------------- | ------------------------------------ |
+| आपके रेपो में वर्कफ़्लो का आकार        | ~360 पंक्तियाँ                     | ~20 पंक्तियाँ                        |
+| स्वचालित रूप से सुधार उठाता है         | नहीं - `recap setup` को पुनः चलाएँ | हां                                  |
+| एयर-गैप / पूर्ण ऑडिटेबिलिटी            | हां                                | नहीं                                 |
+| किसी विशिष्ट संस्करण पर पिन करने योग्य | केवल स्थानीय रूप से संपादन करके    | हां - `uses:` में `@v1.2.3` सेट करें |
+
+### कॉलर स्निपेट
+
+`npx @agent-native/core@latest recap setup --reusable` यही लिखता है (या आप इसे मैन्युअल रूप से पेस्ट कर सकते हैं):
+
+```yaml
+name: PR Visual Recap
+
+# Thin caller — the full workflow logic lives in BuilderIO/agent-native.
+# Fixes and improvements reach this repo automatically on each run.
+# To pin a specific version for reproducibility replace '@main' with a
+# tag or SHA, e.g. '@v1.2.3' or '@abc1234'.
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review, closed]
+
+jobs:
+  visual-recap:
+    permissions:
+      actions: write
+      contents: read
+      checks: write
+      issues: write
+      pull-requests: write
+    uses: BuilderIO/agent-native/.github/workflows/pr-visual-recap-reusable.yml@main
+    secrets:
+      PLAN_RECAP_TOKEN: ${{ secrets.PLAN_RECAP_TOKEN }}
+      ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+      PLAN_RECAP_APP_URL: ${{ secrets.PLAN_RECAP_APP_URL }}
+    with:
+      agent: ${{ vars.VISUAL_RECAP_AGENT || 'claude' }}
+      model: ${{ vars.VISUAL_RECAP_MODEL || '' }}
+      reasoning: ${{ vars.VISUAL_RECAP_REASONING || '' }}
+      skill-source: ${{ vars.VISUAL_RECAP_SKILL_SOURCE || 'auto' }}
+      # cli-version: "latest"  # pin to a specific @agent-native/core version
+```
+
+[Secrets and variables](#secrets-and-variables) में वर्णित समान रहस्य और चर लागू होते हैं - उन्हें कॉपी संस्करण के समान ही अपनी रेपो सेटिंग्स में सेट करें।
+
+### CLI के माध्यम से स्थापित करना
+
+```bash
+# Write the thin caller instead of the full copy:
+npx @agent-native/core@latest recap setup --reusable
+
+# Or with a pinned ref for reproducibility:
+npx @agent-native/core@latest recap setup --reusable --ref v1.2.3
+```
+
+दोनों वेरिएंट वर्कफ़्लो को `.github/workflows/pr-visual-recap.yml` पर लिखते हैं। यदि कोई मौजूदा वर्कफ़्लो पहले से मौजूद है और भिन्न है, तो कमांड अस्वीकार कर देता है और आपको ओवरराइट करने के लिए `--force` पास करने के लिए कहता है।
+
+लिखने के बाद, रहस्य कॉन्फ़िगर किए जाने की पुष्टि करने के लिए हमेशा की तरह `npx @agent-native/core@latest recap doctor` चलाएं।
+
+### संस्करण पिन करना
+
+डिफ़ॉल्ट रूप से कॉलर `@main` का संदर्भ देता है, जो हमेशा पुन: प्रयोज्य वर्कफ़्लो के नवीनतम प्रकाशित संस्करण का उपयोग करता है। उत्पादन रेपो के लिए जिन्हें प्रतिलिपि प्रस्तुत करने योग्य सीआई की आवश्यकता है, एक टैग या SHA पर पिन करें:
+
+```yaml
+uses: BuilderIO/agent-native/.github/workflows/pr-visual-recap-reusable.yml@v1.2.3
+```
+
+`cli-version` इनपुट नियंत्रित करता है कि वर्कफ़्लो के अंदर कौन सा `@agent-native/core` CLI संस्करण चलता है - नवीनतम रिलीज़ को ट्रैक करने के लिए इसे `"latest"` पर छोड़ दें, या पूर्ण प्रतिलिपि प्रस्तुत करने योग्यता के लिए इसे संस्करण स्ट्रिंग (जैसे `"1.5.0"`) पर पिन करें।
+
+### वर्कफ़्लो_कॉल ईवेंट संदर्भ
+
+`workflow_call` वर्कफ़्लो **कॉलर के** ईवेंट संदर्भ को इनहेरिट करता है। पुन: प्रयोज्य वर्कफ़्लो PR नंबर, हेड SHA, बेस SHA, मर्ज टाइमस्टैम्प और PR मेटाडेटा को पढ़ने के लिए `github.event.pull_request.*` अभिव्यक्तियों का उपयोग करता है - ये तभी सही ढंग से काम करते हैं जब कॉलर `pull_request` पर ट्रिगर होता है। उपरोक्त कॉलर स्निपेट में पहले से ही सही ईवेंट प्रकार शामिल हैं। `closed` ईवेंट को शामिल किया गया है, इसलिए मर्ज किए गए पीआर रिकैप्स पर `merged_at` की मुहर लगाई जा सकती है और बाद में शिप किए गए कार्य के रूप में खोजा जा सकता है।
+
+`workflow_dispatch` या `push` पर कॉलर को ट्रिगर न करें - उन घटनाओं में `pull_request` पेलोड नहीं होता है, और गेट "नो पुल_रेक्वेस्ट पेलोड" के साथ रिकैप को छोड़ देगा।
+
+## संबंधित
+
+- [Visual Plans](/docs/template-plan) - `/visual-plan` और `/visual-recap` skills, होस्टेड प्लान कनेक्टर, और इंटरैक्टिव समीक्षा सतह जिस पर यह क्रिया प्रकाशित होती है।
+- [Skills](/docs/skills-guide) - अपने कोडिंग एजेंट में एजेंट-नेटिव skills इंस्टॉल करना।

package/docs/content/locales/hi-IN/processors.md

@@ -0,0 +1,106 @@
+---
+title: "इन-लूप प्रोसेसर"
+description: "लूप-आंतरिक पर्यवेक्षक/रेलिंग हुक जो मॉडल के स्ट्रीम किए गए आउटपुट और टूल कॉल को मध्य-रन पर नज़र रखते हैं और इसे निरस्त कर सकते हैं - वास्तविक समय रेलिंग और प्रूफ़-ऑफ़-डन गेट्स के लिए सीम।"
+---
+
+# इन-लूप प्रोसेसर
+
+ए `Processor` एजेंट रन के लिए एक लूप-आंतरिक **ऑब्जर्वर/रेलिंग** है। यह मॉडल के स्ट्रीम किए गए आउटपुट को देखता है और टूल इसे अनुरोध कहता है _जैसे-जैसे रन आगे बढ़ता है_, अपनी स्वयं की स्क्रैच स्थिति रखता है, और "पूर्ण" का दावा करने से पहले रन को **निरस्त** कर सकता है। यह वास्तविक समय रेलिंग (मध्य-धारा में अस्वीकृत आउटपुट को ब्लॉक करें) और एक प्रूफ-ऑफ-डन/कवरेज गेट (मॉडल क्या करने वाला है और इसे रोकें) के लिए संरचनात्मक शर्त है।
+
+```an-diagram title="Where the three hooks fire in the run" summary="processOutputStream watches every chunk, processOutputStep gates tool calls per response, processOutputResult records a verdict at the end. Any hook can abort with a TripWire."
+{
+  "html": "<div class=\"diagram-proc\"><div class=\"diagram-node\" data-rough>stream chunks<br><small class=\"diagram-muted\">processOutputStream</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-node\" data-rough>per model response<br><small class=\"diagram-muted\">processOutputStep — gate tool calls</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-node\" data-rough>run end<br><small class=\"diagram-muted\">processOutputResult — verdict</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&darr;</div><div class=\"diagram-pill warn\">abort() &rarr; TripWire &rarr; tripwire event</div></div>",
+  "css": ".diagram-proc{display:flex;align-items:center;gap:12px;flex-wrap:wrap}.diagram-proc .diagram-arrow{font-size:22px;line-height:1}.diagram-proc .diagram-pill{flex-basis:100%}"
+}
+```
+
+> [!WARNING]
+> एक प्रोसेसर **कॉन्फिगरेशन** है, एक उपकरण नहीं, एक क्रिया नहीं, और एक संलेखन DSL नहीं है। प्रोसेसर केवल अपने स्वयं के स्ट्रीम-स्कोप्ड राज्य और `abort()` का निरीक्षण करते हैं, उन्हें बदलते हैं। वे कभी भी ऐप व्यवहार को परिभाषित नहीं करते हैं, actions को प्रतिस्थापित नहीं करते हैं, या मॉडल में दिखाई नहीं देते हैं। ऐप संचालन [actions](/docs/actions) से संबंधित है।
+
+## हुक {#hooks}
+
+एक प्रोसेसर तीन वैकल्पिक जीवनचक्र हुक के किसी भी सबसेट को लागू करता है (आकार मास्ट्रा के आउटपुट प्रोसेसर से उधार लिया गया है):
+
+| हुक                   | आग...                                                        | इसका उपयोग करें...                                       |
+| --------------------- | ------------------------------------------------------------ | -------------------------------------------------------- |
+| `processOutputStream` | प्रति स्ट्रीम खंड (पाठ/सोच डेल्टा) जबकि मॉडल उत्पन्न होता है | पूरा टर्न आने से पहले आउटपुट पर प्रतिक्रिया करें         |
+| `processOutputStep`   | प्रति मॉडल प्रतिक्रिया में एक बार, टूल निष्पादन के आसपास     | मॉडल चलने वाले टूल कॉल का निरीक्षण करें; उन्हें गेट करें |
+| `processOutputResult` | एक बार रन समाप्ति पर, अंतिम सहायक पाठ के साथ                 | पूर्ण उत्तर पर निर्णय / किए गए सबूत को रिकॉर्ड करें      |
+
+प्रत्येक प्रोसेसर को अपना स्वयं का परिवर्तनशील, रन-स्कोप्ड `state` ऑब्जेक्ट मिलता है जो एक ही रन के भीतर उसके प्रत्येक हुक इनवोकेशन में बना रहता है और अन्य प्रोसेसर की स्थिति से **पृथक** होता है।
+
+```ts
+import type { Processor } from "@agent-native/core";
+
+const noSecretsInOutput: Processor = {
+  name: "no-secrets",
+  processOutputStream({ part, abort }) {
+    if (part.type === "text" && /sk-live_/.test(part.text)) {
+      abort("Model attempted to emit a live secret token.", {
+        kind: "secret-leak",
+      });
+    }
+  },
+};
+
+const coverageGate: Processor = {
+  name: "proof-of-done",
+  processOutputStep({ toolCalls, state }) {
+    // Track what the model has actually done this run...
+    for (const call of toolCalls) {
+      (state.ran ??= new Set<string>()).add(call.name);
+    }
+  },
+  processOutputResult({ text, state }) {
+    // ...and record a verdict over the final answer.
+    const ran = state.ran as Set<string> | undefined;
+    state.verdict = ran?.has("run-tests") ? "verified" : "unverified";
+  },
+};
+```
+
+## `TripWire` के साथ गर्भपात {#tripwire}
+
+एक हुक `abort(reason, meta?)` को कॉल करके रन को रोक देता है, जो **`TripWire`** फेंकता है। लूप इसे पकड़ता है, एक एकल **`tripwire` ईवेंट** उत्सर्जित करता है, सफाई से रोकता है, और अंतिम सहायक संदेश के रूप में कारण सामने लाता है।
+
+```ts
+import { TripWire } from "@agent-native/core";
+```
+
+`tripwire` इवेंट में शामिल हैं:
+
+| फ़ील्ड      | प्रकार   | नोट्स                                                     |
+| ----------- | -------- | --------------------------------------------------------- |
+| `reason`    | `string` | मानव-पठनीय कारण `abort` को दिया गया।                      |
+| `processor` | `string` | उस प्रोसेसर का नाम जो `name` घोषित होने पर निरस्त हो गया। |
+
+`TripWire` वैकल्पिक संरचित `meta` और प्रोग्रामेटिक उपभोक्ताओं के लिए मूल `processor` नाम भी रखता है जो `instanceof`-चेक करते हैं। चूँकि रुकना सुशोभित होता है, `processOutputResult` अभी भी (रुके हुए) अंतिम पाठ पर सक्रिय होता है ताकि प्रूफ-ऑफ-डन प्रोसेसर रन निरस्त होने पर भी अपना फैसला रिकॉर्ड कर सके।
+
+## वायरिंग प्रोसेसर {#wiring}
+
+प्रोसेसर को `runAgentLoop` पर `processors` सरणी के माध्यम से कोड में कॉन्फ़िगर किया गया है:
+
+```ts
+await runAgentLoop({
+  engine,
+  model,
+  systemPrompt,
+  tools,
+  messages,
+  actions,
+  send,
+  signal,
+  processors: [noSecretsInOutput, coverageGate],
+});
+```
+
+**अप्रयुक्त होने पर शून्य-ओवरहेड।** लूप प्रोसेसर श्रृंखला केवल तभी बनाता है जब कम से कम एक प्रोसेसर की आपूर्ति की जाती है; जब `processors` छोड़ा या खाली होता है, तो कोई भी सीम कोड नहीं चलता है और लूप बाइट-दर-बाइट अपरिवर्तित रहता है। हुक पंजीकरण क्रम में चलते हैं और सिंक या एसिंक हो सकते हैं।
+
+> [!NOTE]
+> लूप-लेवल सीम आज डिलिवरेबल है और उप-एजेंटों, A2A, MCP और परीक्षणों द्वारा सीधे कॉल करने योग्य है। HTTP चैट हैंडलर के माध्यम से `processors` को थ्रेड करना (ताकि एक प्रति-अनुरोध रिज़ॉल्वर सीधे `runAgentLoop` को कॉल किए बिना उन्हें कॉन्फ़िगर कर सके) सुविधा प्लंबिंग है जो अभी तक वायर्ड नहीं है - अभी के लिए `runAgentLoop` कॉल साइट पर प्रोसेसर कॉन्फ़िगर करें।
+
+## संबंधित
+
+- [**Durable Resume**](/docs/durable-resume) - कैसे लूप पूर्ण दुष्प्रभावों को दोबारा चलाए बिना रुकावटों से बचता है।
+- [**Custom Agents & Teams**](/docs/agent-teams) - उप-एजेंट एक ही लूप चलाते हैं और अपने स्वयं के प्रोसेसर ले जा सकते हैं।
+- [**Observability**](/docs/observability) - रन ट्रेस के साथ प्रोसेसर के फैसले रिकॉर्ड करें।