failproofai 1.0.1-beta.1 → 1.0.1

package/.next/standalone/docs-old/hi/agenteye/queries.mdx

@@ -0,0 +1,57 @@
+---
+---
+title: "Queries"
+description: "अपने एजेंट डेटा से कोई भी सवाल पूछें और सेकंड में जवाब पाएं।"
+---
+
+
+अपने एजेंट डेटा से कोई भी सवाल पूछें और सेकंड में जवाब पाएं। Failproof AI Observability आपको आपकी इवेंट्स और evaluations पर सहेजे गए, चलने के लिए तैयार queries की एक लाइब्रेरी देता है, ताकि आप खाली SQL एडिटर के बजाय एक काम करने वाले उदाहरण से शुरुआत कर सकें।
+
+![सहेजे गए-queries की लाइब्रेरी: पुनः उपयोग योग्य queries का एक ग्रिड, दोनों built-in presets और कस्टम](/agenteye/images/queries.png)
+
+*आपकी सहेजी गई-queries लाइब्रेरी `/<org-slug>/queries` पर: built-in presets आपकी टीम द्वारा सहेजे गए queries के साथ बैठे हुए।*
+
+## एक blank page से नहीं, एक preset से शुरुआत करें
+
+आपको टेबल के नाम याद रखने या SQL को शुरुआत से लिखना नहीं है। लाइब्रेरी built-in presets के साथ खुलती है जो टीमें सबसे ज्यादा पूछती हैं, ठीक उसके आगे आपकी अपनी टीम द्वारा सहेजे गए और नामित queries बैठे हुए हैं। एक ऐसा चुनें जो आप जो चाहते हैं उसके करीब हो और आप लगभग आधे रास्ते पर एक जवाब पर पहुंच गए होंगे।
+
+हर सहेजा गया query org-scoped और साझा किया गया है, इसलिए उपयोगी queries जो आपके टीम के सदस्य लिखते हैं वह आपके भी बन जाती हैं। एक बार query का नाम दें और एक विवरण दें, और आपके org में कोई भी इसे खोज सकता है, इसे चला सकता है, या बाद में इसके परिणामों को एक डैशबोर्ड पर pin कर सकता है।
+
+`/<org-slug>/queries` पर इसे खोजें।
+
+## इसे SQL composer में tweaks करें और चलाएं
+
+कोई भी query खोलें और यह SQL composer में उतरता है, जहां आप इसे समायोजित कर सकते हैं और तुरंत जवाब देख सकते हैं: कोई export नहीं, कोई round-trip नहीं, किसी और के इंतजार में नहीं।
+
+![SQL query composer एक सहेजे गए query को चला रहा है, एक schema sidebar और एक live result grid के साथ](/agenteye/images/query-lab.png)
+
+*SQL composer: आपका query बाईं ओर, एक schema sidebar ताकि आप कभी column name का अनुमान न लगाएं, और नीचे एक live result grid।*
+
+- **एक schema sidebar** analytics tables और उनके columns को स्पष्ट करता है, ताकि आप field names की खोज किए बिना एक query आकार दे सकें।
+- **एक live result grid** वह पल में rows return करता है जब आप run करते हैं, ताकि आप अनुमान लगाने और फिर से अनुमान लगाने के बजाय सेकंड में iterate कर सकें।
+- **डिज़ाइन द्वारा read-only।** Queries आपकी event store के खिलाफ चलती हैं और सर्वर पर validate की जाती हैं: केवल `SELECT` और `WITH` statements की अनुमति है, एक statement timeout और एक row cap के साथ। एक exploratory query कभी आपके डेटा को modify नहीं कर सकता, और एक runaway को आपके लिए रोक दिया जाता है।
+
+परिणाम से खुश हैं? इसे लाइब्रेरी में वापस सहेजें ताकि पूरी टीम इसे inherit करे, या इसके output को एक डैशबोर्ड पर एक line, bar, area, या pie tile के रूप में pin करें।
+
+## उन्हें terminal से चलाएं, या assistant को उन्हें लिखने दें
+
+एक ही सहेजे गए queries आपके साथ कहीं भी चलते हैं:
+
+- **Terminal से।** `agenteye` CLI सूचीबद्ध करता है, चलाता है, और वही saved queries को सहेजता है, ताकि आप एक result को एक script में drop कर सकें, इसे CI में wire कर सकें, या इसे एक coding agent को दे सकें।
+
+```bash
+agenteye query list                 # वही सहेजे गए queries, आपके terminal से
+agenteye query run errs --arg prod  # एक को चलाएं और rows print करें (pipes के लिए --json जोड़ें)
+```
+
+  पूरे command set के लिए [CLI और agents](/hi/agenteye/cli-and-agents) देखें।
+
+- **AI assistant से।** निश्चित नहीं कि SQL को कैसे phrase करें? in-dashboard [AI assistant](/hi/agenteye/assistant) से plain English में पूछें और यह query को draft करेगा और इसे आपकी लाइब्रेरी में सहेज देगा।
+
+एक सहेजे गए query को चलाना `queries:run` permission द्वारा gated है, queries को create या delete करने की permissions से अलग रखा गया है, ताकि आप read access grant कर सकें बिना हर किसी को लाइब्रेरी को rewrite करने दिए।
+
+## संबंधित
+
+- [Dashboards](/hi/agenteye/dashboards): query results को shared, org-wide charts में pin करें।
+- [AI assistant](/hi/agenteye/assistant): plain English में सवाल पूछें और एक query वापस पाएं।
+- [CLI और agents](/hi/agenteye/cli-and-agents): आपके terminal से वही queries को चलाएं और सहेजें।

package/.next/standalone/docs-old/hi/agenteye/security.mdx

@@ -0,0 +1,68 @@
+---
+title: "सुरक्षा"
+description: "Failproof AI Observability आपके उत्पादन एजेंटों के पास रखने के लिए बनाया गया है, जिसका अर्थ है कि यह आपके prompts, tool inputs, और outputs को देखता है।"
+---
+
+
+Failproof AI Observability आपके उत्पादन एजेंटों के पास रखने के लिए बनाया गया है, जिसका अर्थ है कि यह आपके prompts, tool inputs, और outputs को देखता है। यह पृष्ठ बताता है कि यह उस डेटा को कैसे अलग-थलग, नियंत्रित, और आपके हाथों में रखता है। यदि आप सुरक्षा समीक्षा के लिए Failproof AI Observability का मूल्यांकन कर रहे हैं, तो यहाँ से शुरू करें।
+
+---
+
+## आपका डेटा आपके परिवेश में रहता है
+
+Failproof AI Observability self-hosted है। Events, prompts, मॉडल responses, और analytics आपके अपने डेटाबेस में, आपके अपने परिवेश में संग्रहीत हैं। कोई भी डेटा storage के लिए किसी third-party SaaS को नहीं भेजा जाता है, और आपका डेटा आपके अपने cloud account में रहता है।
+
+---
+
+## टेनेंट isolation
+
+एक Failproof AI Observability instance कई संगठनों को host कर सकता है, और प्रत्येक को storage layer पर अलग किया जाता है — सिर्फ UI द्वारा नहीं, बल्कि डेटाबेस द्वारा लागू किया जाता है:
+
+- किसी संगठन का operational data (users, keys, dashboards, saved queries) उस org तक सीमित है, और cross-org reads को डेटाबेस द्वारा ही block किया जाता है।
+- प्रत्येक ingested event को अपने owning org के साथ stamp किया जाता है, इसलिए एक संगठन की events को कभी भी दूसरे द्वारा नहीं पढ़ा जा सकता।
+
+प्रत्येक dashboard route एक org slug (`/<org-slug>/…`) के अंतर्गत scoped है।
+
+---
+
+## Sign-in
+
+Failproof AI Observability passwordless, email-based sign-in का उपयोग करता है। phish या leak करने के लिए कोई password नहीं है। एक उपयोगकर्ता एक one-time code (या एक one-click magic link) का अनुरोध करता है, जो उन्हें email किया जाता है और जल्दी expire हो जाता है। Sign-in को एक **allowlist** द्वारा gate किया जाता है: केवल email addresses (या domains) जिन्हें आप permit करते हैं, authenticate कर सकते हैं।
+
+![Failproof AI Observability sign-in screen, जो आपके email को एक single-use code भेजता है](/agenteye/images/login.png)
+
+---
+
+## API keys के साथ scoped access
+
+प्रत्येक client एक API key के साथ authenticate करता है जो granular, least-privilege permissions रखता है। एक collector को केवल `events:add` की जरूरत है; एक dashboard या assistant key read-only हो सकता है; destructive actions (delete, regenerate) अलग grants हैं जिन्हें आप शामिल करना चुनते हैं।
+
+![API keys page: प्रत्येक key की permission grants, read, write, और destructive scope द्वारा colour-coded](/agenteye/images/api-keys.png)
+
+Admin bootstrap key को setup के लिए रखें, और बाकी सब कुछ के लिए narrow keys जारी करें। [API keys](/hi/agenteye/api-keys) देखें।
+
+---
+
+## एक read-only, approval-gated assistant
+
+Dashboard में [AI assistant](/hi/agenteye/assistant) आपके डेटा पर प्रश्नों का उत्तर देता है, लेकिन यह design द्वारा constrained है:
+
+- यह **डिफ़ॉल्ट रूप से read-only है**: इसका SQL एक guard के माध्यम से चलता है जो केवल `SELECT`/`WITH` queries को permit करता है, single-statement, एक row cap के साथ।
+- जो कुछ भी यह creates करता है (एक saved query, एक dashboard) **approval-gated है**: आप प्रत्येक write से पहले review और approve करते हैं।
+- यह **कभी delete नहीं कर सकता**।
+
+इसलिए एक teammate यह पूछ सकता है "इस सप्ताह किन agents में सबसे अधिक errors थीं?" और answer पर कार्रवाई कर सकता है, बिना इसके कि assistant अपने आप पर आपके डेटा को change या remove कर सके।
+
+---
+
+## Transit में
+
+सभी traffic HTTPS के माध्यम से चलता है। आप अपने अपने certificates के साथ TLS को terminate करते हैं, इसलिए collector-to-server और browser-to-server traffic transit में encrypted है।
+
+---
+
+## अगले कदम
+
+- [Overview](/hi/agenteye/overview): Failproof AI Observability कैसे एक साथ आता है।
+- [API keys](/hi/agenteye/api-keys): collector, dashboard, और assistant के लिए access scope करें।
+- [Observability](/hi/agenteye/observability): Failproof AI Observability आपके agents से क्या captures करता है।

package/.next/standalone/docs-old/hi/agenteye/sessions.mdx

@@ -0,0 +1,57 @@
+---
+title: "सेशन और एक्सीक्यूशन ग्राफ"
+description: "किसी भी रन से हर ईवेंट, एक पठनीय पंक्ति में, और गिट-स्टाइल एक्सीक्यूशन ग्राफ के रूप में आरेखित, जिसे आप सेकंड में समझ सकते हैं।"
+---
+
+
+यह अनुमान लगाना बंद करें कि कोई रन क्यों विफल हुआ। Failproof AI Observability किसी रन के हर ईवेंट को एक पठनीय पंक्ति में रखता है, फिर पूरे रन को गिट-स्टाइल चित्र के रूप में खींचता है जिसे आप सेकंड में समझ सकते हैं, इसलिए आप देखते हैं कि आपके एजेंट ने क्या किया, चरण दर चरण।
+
+![सेशन की सूची: प्रति रन एक पंक्ति, सभी वातावरण और एजेंट्स के साथ, स्टेटस पिल्स और मूल्यांकन स्कोर बैजेज के साथ](/agenteye/images/sessions-list.png)
+
+*प्रति रन एक पंक्ति: स्टेटस पिल आपको एक नज़र में बताता है कि रन कैसे समाप्त हुआ, और एक स्कोर बैज एक बार एक मूल्यांकनकर्ता जुड़ जाता है।*
+
+<div style={{ position: "relative", width: "100%", paddingBottom: "56.25%", height: 0, overflow: "hidden", borderRadius: "12px", margin: "1.5rem 0" }}>
+  <iframe src="https://www.youtube.com/embed/VWxukZc5k7s?autoplay=1&mute=1&loop=1&playlist=VWxukZc5k7s&rel=0&playsinline=1" title="Watch: Agent Tracing by Failproof AI (2 min)" allow="autoplay; encrypted-media; picture-in-picture; fullscreen" allowFullScreen style={{ position: "absolute", top: 0, left: 0, width: "100%", height: "100%", border: 0 }}></iframe>
+</div>
+
+*एजेंट ट्रेसिंग: एक ही रन को चरण दर चरण फॉलो करें, लक्ष्य से लेकर टूल्स तक अंतिम उत्तर तक।*
+
+---
+
+## हर रन को एक नज़र में देखें
+
+कच्चा ईवेंट ट्रेल हर चरण का सत्य है, लेकिन जब आपके पास दर्जनों रन्स में हज़ारों चरण हों, तो आपको चरण नहीं, रन की ज़रूरत है। सेशन पेज किसी भी रन के सभी ईवेंट्स को एक पंक्ति में रोल कर देता है, इसलिए एक दिन की गतिविधि एक स्कैन करने योग्य सूची बन जाती है, न कि सूचना की बाढ़।
+
+हर पंक्ति में एक स्टेटस पिल होता है, इसलिए कोई विफल रन स्वस्थ रन से अलग नज़र आता है, इससे पहले कि आप कुछ भी क्लिक करें। तारीख की रेंज, वातावरण, एजेंट, या सेशन द्वारा फ़िल्टर करें, ताकि "सब कुछ" से "जिस रन की मुझे परवाह है" तक कुछ ही क्लिक में पहुंचें।
+
+एक बार जब आप एक मूल्यांकनकर्ता को कनेक्ट कर देते हैं, तो हर पूर्ण रन को स्वचालित रूप से स्कोर किया जाता है और इसका सबसे हाल ही का स्कोर पंक्ति पर एक बैज के रूप में दिखाई देता है। आप किसी भी स्कोर रेंज द्वारा फ़िल्टर कर सकते हैं, इसलिए "इस हफ़्ते हर कम-स्कोर करने वाला प्रोड रन दिखाएं" एक फ़िल्टर है, मैनुअल समीक्षा नहीं। जब तक आप एक सेट नहीं करते, सेशन भी पूरे रन को कैप्चर करते हैं; उनके पास बस अभी तक एक स्कोर नहीं है।
+
+---
+
+## पूरे रन को चित्र के रूप में पढ़ें
+
+![एक सेशन के गिट-स्टाइल एक्सीक्यूशन ग्राफ के बगल में इसका ईवेंट टाइमलाइन, टूल, मॉडल, और हुक ब्रेकडाउन पैनल के साथ](/agenteye/images/session-detail.png)
+
+*एक्सीक्यूशन ग्राफ (बाएं) ईवेंट टाइमलाइन के बगल में बैठता है; दाहिनी रेल रन के लिए टूल्स, मॉडल्स, हुक्स, और टोकन खर्च को विभाजित करता है।*
+
+किसी भी सेशन को क्लिक करें इसके एक्सीक्यूशन ग्राफ को खोलने के लिए: एजेंट्स, टूल्स, हुक्स, और मॉडल कॉल्स के समय के आधार पर कैसे सामने आए, इसका एक गिट-स्टाइल दृश्य। समानांतर उप-एजेंट अपनी-अपनी लेन पर शाखा बनाते हैं, इसलिए आप देख सकते हैं कि कौन सा काम साथ-साथ चला, कौन सा उप-एजेंट रुका, और रन कहां गलत हुआ, इसे अपने सिर में फिर से चलाए बिना लॉग्स की दीवार से।
+
+दाहिनी रेल आपको प्रति-रन ब्रेकडाउन देता है: कौन से टूल्स और मॉडल्स चले, कौन से हुक्स फायर हुए, और रन ने टोकन में क्या खर्च किया। यह "इस रन की लागत इतनी अधिक क्यों थी?" या "कौन सा टूल धीमा है?" का उत्तर है, ठीक इसके बगल में ग्राफ बैठा है जो इसका कारण बना।
+
+व्यक्तिगत ईवेंट्स एड्रेसेबल हैं, इसलिए आप किसी को "सेशन, लगभग दो तिहाई नीचे" के बजाय एक ही पल के लिए एक लिंक दे सकते हैं। किसी भी ईवेंट से लिंक कॉपी करें, या [ऑडिट](/hi/agenteye/audits) ढूंढ से या कोई त्रुटि से एक लिंक फॉलो करें, और सेशन उस ईवेंट को चुना हुआ और स्क्रॉल किए गए के साथ खुलता है। यह बहुत लंबे रन्स के लिए भी होता है: टाइमलाइन आपके ब्राउज़र की खातिर एक सीमित खिड़की लोड करता है, और एक लिंक जो उस खिड़की के बाहर इंगित करता है फिर भी अपना ईवेंट पाता है, न कि शुरुआत में आपको छोड़ देता है। अगर ईवेंट आपकी रिटेंशन विंडो से बाहर हो गया है, तो पेज आपको बताता है कि इसके बजाय शांति से कुछ नहीं चुनता।
+
+---
+
+## इसे कहाँ खोजें
+
+हर डैशबोर्ड पेज आपके संगठन (`/<org-slug>/…`) के लिए स्कॉप किया गया है। सेशन **Observe** के अंतर्गत बाईं साइडबार में रहता है, ईवेंट्स के बगल में, सूची के शीर्ष में तारीख की रेंज, वातावरण, एजेंट, और सेशन फ़िल्टर के साथ। हर पंक्ति इसके पूर्ण एक्सीक्यूशन ग्राफ से एक क्लिक दूर है।
+
+स्कोर बैजेज़ और स्कोर-रेंज फ़िल्टरिंग को चालू करने के लिए, एक मूल्यांकनकर्ता को कनेक्ट करें: [Evaluations](/hi/agenteye/evaluations) देखें।
+
+---
+
+## संबंधित
+
+- [Event stream](/hi/agenteye/event-stream): कच्चा, प्रति-चरण ट्रेल जिससे हर सेशन रोल किया जाता है।
+- [Evaluations](/hi/agenteye/evaluations): एक मूल्यांकनकर्ता को कनेक्ट करें, इसलिए हर रन को एक स्कोर बैज मिलता है जिससे आप फ़िल्टर कर सकते हैं।
+- [Telemetry](/hi/agenteye/telemetry): रन्स अपने एजेंट से इन सेशन्स में कैसे जाते हैं।

package/.next/standalone/docs-old/hi/agenteye/telemetry.mdx

@@ -0,0 +1,51 @@
+---
+title: "प्रदर्शन मेट्रिक्स"
+description: "तुरंत देखें कि आपके मॉडल, टूल या हुक कब धीमे हो रहे हैं या खर्च बढ़ रहा है, और अपने उपयोगकर्ताओं को महसूस होने से पहले टेल-लेटेंसी स्पाइक को पकड़ें।"
+---
+
+तुरंत देखें कि आपके मॉडल, टूल या हुक कब धीमे हो रहे हैं या खर्च बढ़ रहा है, और अपने उपयोगकर्ताओं को महसूस होने से पहले टेल-लेटेंसी स्पाइक को पकड़ें। तीन समर्पित पृष्ठ कच्चे समय को p50, p95, और p99 में बदलते हैं जिन्हें आप एक नज़र में पढ़ सकते हैं।
+
+![मॉडल पृष्ठ लेटेंसी हीट-मैप, प्रतिशतक बैंड, और प्रति-मॉडल टोकन, लागत और संदर्भ-विंडो आंकड़े दिखाता है](/agenteye/images/models.png)
+*मॉडल पृष्ठ: लेटेंसी हीट-मैप, प्रतिशतक बैंड, और प्रति-मॉडल टोकन, अनुमानित लागत, और संदर्भ-विंडो भरण।*
+
+## औसत को अपने सबसे बुरे रन को छिपाने दें
+
+औसत लेटेंसी संख्या सुकून देने वाली और बेकार है: यह उस एक कॉल को छिपाती है जो पचास में से एक है जो रुक जाती है और सुबह 2 बजे आपके ऑन-कॉल को पेज करती है। मॉडल, टूल और हुक पेज ऐसा करने से इनकार करते हैं। प्रत्येक समान आकार साझा करता है, इसलिए आप इसे एक बार सीखते हैं:
+
+- एक **24-बिन स्पार्कलाइन** एक नज़र में ट्रेंड के लिए: क्या यह बदतर हो रहा है?
+- एक **वाइटल्स स्ट्रिप** p50, p95, और p99 लेटेंसी के साथ, ताकि विशिष्ट रन और टेल एक दूसरे के बगल में बैठें।
+- एक **लेटेंसी हीट-मैप**, 24 समय बिन द्वारा लेटेंसी बकेट, जो दिखाता है कि *कब* धीमी कॉलें क्लस्टर हुई थीं।
+- एक **प्रतिशतक बैंड**: p50 लाइन के साथ p25 से p75 और p10 से p90 छायांकित रिबन और p99 डॉट्स, इसलिए फैलाव औसत से दूर दिखाई देता रहता है।
+
+एक साझा होवर क्रॉसहेयर हीट-मैप और बैंड को जोड़ता है, इसलिए एक टेल स्पाइक समय में दोनों के बीच संरेखित होती है एकल माध्य लाइन के पीछे छिपने के बजाय। अपने डैशबोर्ड के **observe** सेक्शन में सभी तीन पृष्ठ खोजें, प्रत्येक आपके संगठन के लिए स्कोप किया गया है और तारीख रेंज, पर्यावरण, एजेंट और सत्र द्वारा फ़िल्टर योग्य है।
+
+## मॉडल: देखें कि प्रत्येक मॉडल आपको कितना खर्च कर रहा है
+
+मॉडल पृष्ठ (ऊपर दिखाया गया है) दो सवालों का जवाब देता है जो एक बिल हमेशा उठाता है: कौन सा मॉडल, और कितना। साझा लेटेंसी दृश्य के शीर्ष पर, यह **प्रति-मॉडल टोकन खपत**, **अनुमानित लागत**, और **संदर्भ-विंडो भरण** जोड़ता है, इसलिए भागते हुए प्रॉम्प्ट वृद्धि और आसन्न संपीड़न आपको आश्चर्य करने से पहले दिखाई देते हैं।
+
+Failproof AI Observability सामान्य मॉडल ID को स्वचालित रूप से पहचानता है। यदि कोई विंडो गलत दिखता है, या आप अपना निजी मॉडल चलाते हैं, तो इसे **Settings** के तहत, **model context windows** में सही करें या जोड़ें, और भरण पठन अनुसरण करते हैं।
+
+## टूल: धीमे को टूटे हुए से अलग करें
+
+एक टूल कॉल धीमा हो सकता है, या यह शांति से विफल हो सकता है, और आप इसे सेकंड में जानना चाहते हैं, लॉग के माध्यम से खोदने के बाद नहीं।
+
+![टूल पृष्ठ साझा लेटेंसी हीट-मैप और प्रतिशतक बैंड को सफलता और विफलता विभाजन और टूल-वितरण बार के बगल में दिखाता है](/agenteye/images/tools.png)
+*टूल पृष्ठ: समान हीट-मैप और प्रतिशतक बैंड, प्लस सफलता और विफलता विभाजन और टूल-वितरण बार।*
+
+साझा लेटेंसी दृश्य के साथ, टूल पृष्ठ एक **सफलता और विफलता विभाजन** और एक **टूल-वितरण बार** जोड़ता है, इसलिए आप एक नज़र में देखते हैं कि आप कौन से टूल पर सबसे अधिक निर्भर हैं और कौन सी आपकी त्रुटि बजट को खा रही हैं।
+
+## हुक: सटीक हुक और ट्रिगर को इंगित करें
+
+जब एक लाइफसाइकल हुक एक रन को खींचता है, तो "हुक धीमे हैं" कुछ ऐसा नहीं है जिस पर आप कार्य कर सकते हैं। हुक पृष्ठ आपको वह लाता है जो महत्वपूर्ण है।
+
+![हुक पृष्ठ साझा हीट-मैप और प्रतिशतक बैंड पर हुक नाम और ट्रिगर ईवेंट द्वारा विभाजित लेटेंसी दिखाता है](/agenteye/images/hooks.png)
+*हुक पृष्ठ: हुक नाम और ट्रिगर ईवेंट द्वारा विभाजित लेटेंसी।*
+
+समान लेटेंसी हीट-मैप और प्रतिशतक बैंड के ऊपर, हुक पृष्ठ गतिविधि को **हुक नाम** और **ट्रिगर ईवेंट** द्वारा विभाजित करता है, इसलिए आप एकल हुक और एकल ईवेंट पर उतरते हैं जिन्हें ध्यान देने की आवश्यकता है।
+
+## संबंधित
+
+- [Event stream](/hi/agenteye/event-stream): हर ईवेंट का लाइव, रंग-कोडित ट्रेल।
+- [Sessions](/hi/agenteye/sessions): ईवेंट को एक पंक्ति प्रति रन में रोल करें और इसके निष्पादन ग्राफ को खोलें।
+- [Error tracking](/hi/agenteye/error-tracking): डैशबोर्ड को लाल रंग में पेंट करने वाली हर चीज़ के लिए एक ट्रिएज सतह।
+- [Dashboards](/hi/agenteye/dashboards): अपने फ्लीट में रोल-अप दृश्य।

package/.next/standalone/docs-old/hi/architecture.mdx

@@ -0,0 +1,332 @@
+---
+title: Architecture
+description: "हुक हैंडलर, कॉन्फ़िग लोडिंग और पॉलिसी मूल्यांकन आंतरिक रूप से कैसे काम करते हैं"
+icon: sitemap
+---
+
+यह दस्तावेज़ बताता है कि failproofai आंतरिक रूप से कैसे काम करता है: हुक सिस्टम एजेंट टूल कॉल को कैसे इंटरसेप्ट करता है, कॉन्फ़िग कैसे लोड और मर्ज होता है, पॉलिसीज़ का मूल्यांकन कैसे होता है, और डैशबोर्ड एजेंट गतिविधि की निगरानी कैसे करता है।
+
+---
+
+## Overview
+
+failproofai के दो स्वतंत्र सबसिस्टम हैं:
+
+1. **हुक हैंडलर** - एक तेज़ CLI सबप्रोसेस जो Claude Code हर एजेंट टूल कॉल पर शुरू करता है। पॉलिसीज़ का मूल्यांकन करता है और एक निर्णय लौटाता है।
+2. **एजेंट मॉनिटर (डैशबोर्ड)** - एजेंट सेशन की निगरानी और पॉलिसीज़ प्रबंधन के लिए एक Next.js वेब एप्लिकेशन।
+
+दोनों सबसिस्टम `~/.failproofai/` और प्रोजेक्ट की `.failproofai/` डायरेक्टरी में कॉन्फ़िग फाइलें साझा करते हैं, लेकिन वे अलग-अलग प्रक्रियाओं के रूप में चलते हैं और केवल फाइलसिस्टम के माध्यम से संचार करते हैं।
+
+---
+
+## हुक हैंडलर
+
+### Claude Code के साथ एकीकरण
+
+जब आप `failproofai policies --install` चलाते हैं, तो यह `~/.claude/settings.json` में इस तरह की entries लिखता है:
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "failproofai --hook PreToolUse"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [ ... ]
+  }
+}
+```
+
+Claude Code फिर हर टूल कॉल से पहले `failproofai --hook PreToolUse` को सबप्रोसेस के रूप में शुरू करता है, stdin पर एक JSON पेलोड पास करता है।
+
+### पेलोड फॉर्मेट
+
+```json
+{
+  "session_id": "abc123",
+  "transcript_path": "/home/user/.claude/projects/myproject/sessions/abc123.jsonl",
+  "cwd": "/home/user/myproject",
+  "permission_mode": "default",
+  "hook_event_name": "PreToolUse",
+  "tool_name": "Bash",
+  "tool_input": { "command": "sudo apt install nodejs" }
+}
+```
+
+`PostToolUse` events के लिए, पेलोड में टूल के आउटपुट के साथ `tool_result` भी होता है।
+
+हैंडलर 1 MB stdin सीमा लागू करता है। इस सीमा से अधिक पेलोड को छोड़ दिया जाता है और सभी पॉलिसीज़ निहित रूप से allow करती हैं।
+
+### Response फॉर्मेट
+
+**Deny (PreToolUse):**
+```json
+{
+  "hookSpecificOutput": {
+    "permissionDecision": "deny",
+    "permissionDecisionReason": "Blocked by failproofai: sudo command blocked"
+  }
+}
+```
+
+**Deny (PostToolUse):**
+```json
+{
+  "hookSpecificOutput": {
+    "additionalContext": "Blocked by failproofai because: API key detected in output"
+  }
+}
+```
+
+**Instruct (Stop को छोड़कर कोई भी event):**
+```json
+{
+  "hookSpecificOutput": {
+    "additionalContext": "Instruction from failproofai: Verify tests pass before committing."
+  }
+}
+```
+
+**Stop event instruct:**
+- Exit code: `2`
+- Reason stderr में लिखा जाता है (stdout में नहीं)
+
+**Allow:**
+- Exit code: `0`
+- खाली stdout
+
+**संदेश के साथ Allow:**
+
+`allow(message)` एक पॉलिसी को Claude को सूचनात्मक context भेजने देता है भले ही ऑपरेशन की अनुमति हो। हुक हैंडलर निम्नलिखित JSON को **stdout** में लिखता है (एक कॉन्फ़िग फाइल में नहीं — यह हैंडलर का Claude Code को response है, deny और instruct responses की तरह):
+
+```json
+// हुक हैंडलर प्रक्रिया द्वारा stdout में लिखा गया
+{
+  "hookSpecificOutput": {
+    "additionalContext": "All CI checks passed on branch 'feat/my-feature'."
+  }
+}
+```
+- Exit code: `0` (ऑपरेशन अनुमति है)
+- जब कई पॉलिसीज़ संदेश के साथ `allow` लौटाती हैं, उनके संदेश newlines के साथ एक एकल `additionalContext` string में जोड़े जाते हैं
+- अगर कोई पॉलिसी संदेश प्रदान नहीं करती, तो stdout खाली है (पहले की तरह)
+
+### Processing पाइपलाइन
+
+`src/hooks/handler.ts` पूरी पाइपलाइन को लागू करता है:
+
+```text
+stdin JSON
+  → पेलोड को parse करें (अधिकतम 1 MB)
+  → सेशन मेटाडेटा निकालें (session_id, cwd, tool_name, tool_input, आदि)
+  → readMergedHooksConfig(cwd)    ← प्रोजेक्ट + local + global कॉन्फ़िग को merge करता है
+  → resolved params के साथ सक्षम builtin पॉलिसीज़ को register करें
+  → customPoliciesPath से custom पॉलिसीज़ लोड करें (यदि सेट है)
+  → custom पॉलिसीज़ को policy registry में register करें
+  → सभी पॉलिसीज़ का मूल्यांकन करें (पहले builtins, फिर custom)
+      → पहला deny short-circuits करता है
+      → instruct decisions जमा होते हैं
+      → allow messages जमा होते हैं
+  → JSON निर्णय को stdout में लिखें
+  → event को ~/.failproofai/hook-activity/current.jsonl में persist करें
+  → exit करें
+```
+
+पूरी प्रक्रिया 100ms से कम में चलती है typical payloads के लिए कोई LLM कॉल के साथ।
+
+---
+
+## कॉन्फ़िग लोडिंग
+
+`src/hooks/hooks-config.ts` तीन-scope कॉन्फ़िग लोडिंग को लागू करता है।
+
+```text
+[1] {cwd}/.failproofai/policies-config.json        ← प्रोजेक्ट  (सर्वोच्च प्राथमिकता)
+[2] {cwd}/.failproofai/policies-config.local.json  ← local
+[3] ~/.failproofai/policies-config.json             ← global   (न्यूनतम प्राथमिकता)
+```
+
+Merge logic:
+- `enabledPolicies` - सभी तीनों फाइलों में deduplicated union
+- `policyParams` - प्रति-पॉलिसी key, पहली फाइल जो इसे परिभाषित करती है पूरी तरह जीतती है
+- `customPoliciesPath` - पहली फाइल जो इसे परिभाषित करती है जीतती है
+- `llm` - पहली फाइल जो इसे परिभाषित करती है जीतती है
+
+वेब डैशबोर्ड `readHooksConfig()` (केवल global) का उपयोग पढ़ने और लिखने के लिए करता है, क्योंकि यह प्रोजेक्ट cwd के साथ शुरू नहीं होता है।
+
+---
+
+## पॉलिसी मूल्यांकन
+
+`src/hooks/policy-evaluator.ts` क्रम में पॉलिसीज़ चलाता है।
+
+प्रत्येक पॉलिसी के लिए:
+
+1. पॉलिसी के `params` schema को देखें (यदि इसमें एक है)।
+2. merged कॉन्फ़िग से `policyParams[policy.name]` को पढ़ें।
+3. `ctx.params` देने के लिए schema defaults पर user-provided values को merge करें।
+4. resolved context के साथ `policy.fn(ctx)` को कॉल करें।
+5. यदि result `deny` है, तो तुरंत रुकें और वह निर्णय लौटाएं।
+6. यदि result `instruct` है, तो संदेश को जमा करें और जारी रखें।
+7. यदि result `allow` है, तो अगली पॉलिसी पर जाएं।
+
+सभी पॉलिसीज़ चलने के बाद:
+- यदि कोई `deny` लौटाया गया था, तो deny response emit करें।
+- यदि कोई `instruct` returns collect किए गए थे, तो एक एकल instruct response emit करें सभी संदेशों के साथ joined।
+- अन्यथा, एक allow response emit करें (खाली stdout, exit 0)।
+
+---
+
+## Builtin पॉलिसीज़
+
+`src/hooks/builtin-policies.ts` सभी 39 built-in पॉलिसीज़ को `BuiltinPolicyDefinition` objects के रूप में परिभाषित करता है:
+
+```typescript
+interface BuiltinPolicyDefinition {
+  name: string;
+  description: string;
+  fn: (ctx: PolicyContext) => PolicyResult;
+  match: {
+    events: HookEventType[];
+    tools?: string[];
+  };
+  defaultEnabled: boolean;
+  category: string;
+  beta?: boolean;
+  params?: PolicyParamsSchema;
+}
+```
+
+जो पॉलिसीज़ `params` स्वीकार करती हैं वे `PolicyParamsSchema` के साथ प्रत्येक parameter के लिए types और defaults के साथ घोषणा करती हैं। पॉलिसी evaluator resolved values को `ctx.params` में `fn` को कॉल करने से पहले inject करता है। पॉलिसी functions `ctx.params` को null-guarding के बिना पढ़ते हैं क्योंकि defaults हमेशा पहले apply होते हैं।
+
+पॉलिसीज़ के अंदर pattern matching parsed command tokens (argv) का उपयोग करता है, raw string matching नहीं। यह shell operator injection के माध्यम से bypass को रोकता है (उदाहरण के लिए `sudo systemctl status *` के लिए एक pattern को command के अंत में `; rm -rf /` append करके bypass नहीं किया जा सकता)।
+
+---
+
+## Custom पॉलिसीज़
+
+`src/hooks/custom-hooks-registry.ts` `globalThis`-backed registry को लागू करता है:
+
+```typescript
+const REGISTRY_KEY = "__failproofai_custom_hooks__";
+
+export const customPolicies = {
+  add(hook: CustomHook): void { ... }
+};
+
+export function getCustomHooks(): CustomHook[] { ... }
+export function clearCustomHooks(): void { ... }  // tests में उपयोग किया जाता है
+```
+
+`src/hooks/custom-hooks-loader.ts` user की policy फाइल लोड करता है:
+
+1. कॉन्फ़िग से `customPoliciesPath` पढ़ें; यदि अनुपस्थित है तो छोड़ दें।
+2. Absolute path को resolve करें; फाइल की मौजूदगी की जांच करें।
+3. सभी `from "failproofai"` imports को actual dist path पर फिर से लिखें ताकि `customPolicies` same `globalThis` registry को resolve करे।
+4. ESM compatibility सुनिश्चित करने के लिए transitive local imports को recursively फिर से लिखें।
+5. अस्थायी `.mjs` फाइलें लिखें और entry फाइल को `import()` करें।
+6. registered hooks को retrieve करने के लिए `getCustomHooks()` को कॉल करें।
+7. `finally` block में सभी temp फाइलें साफ करें।
+
+किसी भी error (फाइल नहीं मिली, syntax error, import failure) पर, error को `~/.failproofai/hook.log` में log किया जाता है और loader एक खाली array लौटाता है। Built-in पॉलिसीज़ प्रभावित नहीं होती हैं।
+
+Custom पॉलिसीज़ सभी built-in पॉलिसीज़ के बाद मूल्यांकन होती हैं। एक custom policy `deny` अभी भी आगे custom पॉलिसीज़ को short-circuits करता है (लेकिन सभी built-ins उस बिंदु तक पहले ही चल चुकी होंगी)।
+
+---
+
+## Activity लॉगिंग
+
+हर हुक event के बाद, हैंडलर `~/.failproofai/hook-activity/current.jsonl` में एक JSONL line जोड़ता है, जो एक page तक पहुंचने पर `page-<timestamp>-<seq>.jsonl` में rotate होता है:
+
+```json
+{
+  "timestamp": "2026-04-06T12:34:56.789Z",
+  "sessionId": "abc123",
+  "eventType": "PreToolUse",
+  "toolName": "Bash",
+  "policyName": "block-sudo",
+  "decision": "deny",
+  "reason": "sudo command blocked by failproofai",
+  "durationMs": 12
+}
+```
+
+एक line प्रत्येक पॉलिसी के लिए जिसने non-allow निर्णय लिया। Allow निर्णय log नहीं होते हैं (फाइल को छोटा रखने के लिए)।
+
+---
+
+## डैशबोर्ड architecture
+
+डैशबोर्ड एक **Next.js 16** एप्लिकेशन है जो App Router के साथ React Server Components और Server Actions का उपयोग करती है।
+
+```text
+app/
+  layout.tsx                  ← Root layout (theme, telemetry, nav)
+  projects/page.tsx           ← Server component: सभी Claude projects को list करें
+  project/[name]/page.tsx     ← Server component: एक project में sessions को list करें
+  project/[name]/session/
+    [sessionId]/page.tsx      ← Server component: session viewer को render करें
+  policies/page.tsx           ← Client component: policy management + activity log
+  actions/
+    get-hooks-config.ts       ← कॉन्फ़िग + policy list पढ़ें
+    update-hooks-config.ts    ← Policy को on/off करें
+    update-policy-params.ts   ← Policy parameters को update करें
+    get-hook-activity.ts      ← Activity log को paginate/search करें
+    install-hooks-web.ts      ← Browser से hooks को install/remove करें
+  api/
+    download/[project]/[session]/route.ts   ← Per-CLI session export (JSONL या JSON)
+```
+
+**डेटा flow:**
+
+- Page components `lib/projects.ts` और `lib/log-entries.ts` को कॉल करते हैं प्रोजेक्ट/सेशन डेटा को फाइलसिस्टम से सीधे पढ़ने के लिए (reads के लिए कोई API layer नहीं)।
+- Policies page सभी mutations के लिए Server Actions का उपयोग करता है (toggle, params update, install/remove)।
+- Session viewer Claude के JSONL transcript format को parse करता है और messages और tool calls की एक timeline को render करता है।
+
+**मुख्य design निर्णय:**
+
+- कोई डेटाबेस नहीं - सभी persistent state plain फाइलों में है (`~/.failproofai/`, `~/.claude/projects/`)।
+- Mutations के लिए Server Actions - CRUD operations के लिए कोई REST API की ज़रूरत नहीं।
+- Read pages के लिए React Server Components - तेज़ initial load, data fetching के लिए कोई client bundle नहीं।
+- Client components केवल जहां interactivity की ज़रूरत है (policy toggles, activity search, log viewer)।
+
+---
+
+## फाइल layout
+
+```text
+failproofai/
+├── bin/
+│   └── failproofai.mjs           # CLI router (hook / dashboard / install / आदि)
+├── src/hooks/
+│   ├── handler.ts                # Hook event pipeline
+│   ├── builtin-policies.ts       # 39 policy definitions
+│   ├── policy-evaluator.ts       # Policy execution engine
+│   ├── policy-registry.ts        # Policy registration और lookup
+│   ├── policy-types.ts           # TypeScript interfaces
+│   ├── hooks-config.ts           # Multi-scope config loading
+│   ├── custom-hooks-registry.ts  # globalThis-backed hook registry
+│   ├── custom-hooks-loader.ts    # User JS hooks के लिए ESM loader
+│   ├── manager.ts                # install / remove / list operations
+│   ├── install-prompt.ts         # Interactive policy selection prompt
+│   ├── hook-logger.ts            # hook.log में logging
+│   ├── hook-activity-store.ts    # hook-activity/ में activity को persist करें
+│   └── llm-client.ts             # LLM API client (AI-powered policies के लिए)
+├── app/                          # Next.js dashboard (pages + server actions)
+├── lib/                          # Shared utilities
+│   ├── projects.ts               # फाइलसिस्टम से Claude projects को enumerate करें
+│   ├── log-entries.ts            # Claude transcript JSONL format को parse करें
+│   ├── paths.ts                  # System paths को resolve करें
+│   └── ...
+├── components/                   # Shared React UI components
+├── contexts/                     # React context providers (theme, auto-refresh, telemetry)
+├── examples/                     # Example custom hook files
+└── __tests__/                    # Unit और E2E tests
+```