dsh-auto-review 0.4.0

package/README.hi.md

@@ -0,0 +1,226 @@
+<!-- भाषा लिंक -->
+[English](README.md) · [中文](README.zh.md) · [Español](README.es.md) · [Português](README.pt.md) · [हिन्दी](README.hi.md)
+
+<div align="center">
+
+# 🤖 dsh-auto-review
+
+**DeepSeek Harness के लिए द्वितीय-मॉडल AI स्वतः-समीक्षा** — Codex का `approvals_reviewer=auto_review` / Claude Code का *auto mode* पैटर्न, एक शुद्ध Cordis प्लगइन के रूप में।
+
+जब एजेंट की कोई क्रिया sandbox की सीमा पार करती है, तो एक **केवल-पढ़ने वाला समीक्षक सबएजेंट** allow/deny का फ़ैसला करता है — कारण सहित — ताकि इंसान को कुछ भी स्वीकृत न करना पड़े और कुछ भी असुरक्षित चुपचाप न निकल जाए।
+
+[![license](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+[![dsh](https://img.shields.io/badge/dsh-0.1.0--rc.6-4c51bf.svg)](https://www.npmjs.com/package/@deepseek-ai/dsh)
+[![tests](https://img.shields.io/github/actions/workflow/status/PerryLink/dsh-auto-review/ci.yml?label=tests&logo=githubactions)](.github/workflows/ci.yml)
+[![typescript](https://img.shields.io/badge/TypeScript-strict-3178c6.svg)](src)
+[![type](https://img.shields.io/badge/type-cordis%20bundle-8a5cf6.svg)](cordis.patch.yml)
+[![repo](https://img.shields.io/badge/repo-PerryLink%2Fdsh--auto--review-181717.svg)](https://github.com/PerryLink/dsh-auto-review)
+
+**शून्य मानव हस्तक्षेप।** अनुरोध AI समीक्षक के पास जाता है, फ़ैसला allow/deny + कारण + जोखिम स्तर होता है, और हर निर्णय सत्र लॉग से पूरी तरह पुनर्निर्मित किया जा सकता है: `approval/asked` → `autoReview/verdict` (या हार्ड-डिसेबल के लिए `autoReview/rejection`) → `approval/decided`।
+
+<img src="docs/demo-auto-review.gif" alt="dsh-auto-review डेमो" width="720"/>
+
+*एक वास्तविक साक्ष्य-रन (वास्तविक सर्वर, वास्तविक API कुंजी, दो वास्तविक मॉडल राउंड): AI समीक्षक workspace के अंदर escalated लेखन को **अनुमति** देता है (कम जोखिम, 5.2 s), फिर workspace के बाहर recursive विलोपन को **अस्वीकार** करता है (उच्च जोखिम, 8.9 s) — अस्वीकृति का कारण मॉडल को वापस दिया जाता है और ट्रांसक्रिप्ट में दिखाई देता है।*
+
+</div>
+
+## नियमों के बजाय दूसरा मॉडल क्यों?
+
+पैटर्न-आधारित स्वतः-स्वीकर्ता dispatch से पहले, बिना साक्ष्य के फ़ैसला करते हैं। `dsh-auto-review` निर्णय एक **समीक्षक सबएजेंट** को सौंपता है जो वास्तविक workspace (अपने केवल-पढ़ने वाले टूल-सेट से), पहले से प्रस्तुत टूल-कॉल आर्गुमेंट (संवेदनशील मान हटाकर), अनुरोध का कारण और आपके जोखिम नियम पढ़ता है — फिर एक संरचित फ़ैसला लौटाता है। अस्वीकृति का **कारण कॉल करने वाले मॉडल को वापस** दिया जाता है, ताकि एजेंट अंधाधुंध दोबारा कोशिश करने के बजाय कारण सीखे।
+
+## ✨ विशेषताएँ
+
+| | |
+|---|---|
+| 🔌 **आधिकारिक seam** | `approval/request` waterfall पर एक answerer। जो अनुरोध उसके नहीं हैं वे `next()` से आगे भेजे जाते हैं — मानव स्वीकृति प्रवाह कभी नहीं रोका जाता। |
+| 🧠 **द्वितीय-मॉडल फ़ैसला** | एक बार का fork सबएजेंट, केवल-पढ़ने वाली टूल अनुमति-सूची (`read`/`glob`/`grep`) और संरचित फ़ैसला schema `{ decision, reason, riskLevel }`। |
+| 🛡️ **Fail closed** | समीक्षक का क्रैश, टाइमआउट या गलत schema कभी द्वार नहीं खोलता: `fallbackPolicy` लागू होती है, डिफ़ॉल्ट `rejected`। |
+| 🧩 **कॉन्फ़िग-चालित रूटिंग** | प्रति-टूल नीतियाँ (`ai`/`human`/`never`) + regex जोखिम नियम, सब cordis.yml से बदले जा सकते हैं। |
+| 💬 **अस्वीकृति के कारण मॉडल तक पहुँचते हैं** | समीक्षक का कारण अस्वीकृत टूल के परिणाम में (callId से जुड़ा) डाला जाता है, ताकि एजेंट खुद को ढाल सके। Fail-closed fallback अस्वीकृतियाँ और `never` नीति की हार्ड-डिसेबल अस्वीकृतियाँ भी ऑडिट-योग्य पाठ डालती हैं (`[auto-review]` / `[auto-review-fallback]` / `[auto-review-never]` मार्कर)। |
+| 📜 **पूर्ण ऑडिट शृंखला** | `autoReview/verdict` + `autoReview/rejection` सत्र-ईवेंट (समीक्षक की पहचान, फ़ैसला, कारण, जोखिम, अवधि) + एक invariant companion जो *model-visible ⟺ logged* लागू करता है। |
+| 🔁 **कोई पुनरावृत्ति नहीं** | समीक्षक के अपने अनुरोध पहचान से पहचाने जाते हैं और आगे भेजे जाते हैं; `maxDepth` + अनुमति-सूची समीक्षक को आगे delegation से रोकते हैं। |
+| 🧯 **अस्वीकृति circuit breaker** | एक टर्न में 3 लगातार अस्वीकृतियाँ (या पिछले 10 फ़ैसलों में 6) breaker को ट्रिप कर देती हैं: बाद के अनुरोध सौंपे जाते हैं, अस्वीकार होते हैं या टर्न निरस्त होता है — अस्वीकृति का कोई अंतहीन चक्र नहीं। |
+| 🎚️ **जोखिम-स्तर नीति** | एक `allow` फ़ैसला जिसका जोखिम `riskPolicy.maxAutoAllow` से ऊपर है, अनुरोध को कभी निपटाता नहीं: वह मानव को सौंपता है या अस्वीकार करता है। |
+| ✋ **एक-बार मानव ओवरराइड** | `/auto-review approve [n]` हाल की एक अस्वीकृति के लिए एक बार पुनः-प्रयास अधिकृत करता है; अगली उसी-टूल समीक्षा उस अधिकार को समीक्षक संदर्भ के रूप में ले जाती है (समीक्षक फिर भी फ़ैसला करता है)। |
+| 📜 **समीक्षक संदर्भ** | वैकल्पिक संक्षिप्त ट्रांसक्रिप्ट (हाल के संदेश और टूल परिणाम, सीमित) + एक Codex-शैली Markdown `reviewerPolicyText` निर्णय-नीति। |
+| ⌨️ **सत्र कमांड** | `/auto-review on|off|status|approve [n]` — टिकाऊ प्रति-सत्र ओवरराइड जो restore के बाद भी बना रहता है और संचयी सत्र आँकड़े। |
+| 🖥️ **वेब समीक्षा पैनल** | सत्र-शीर्षक पैनल (वेब GUI) स्विच (ऑन/ऑफ बटन के साथ), दोनों प्रति-टर्न बजट, संचयी आँकड़े, circuit ट्रिप, हाल के फ़ैसले और एक-बार अनुमोदन बटन दिखाता है — `autoReview` सत्र प्रोजेक्शन द्वारा संचालित। |
+
+## कैसे काम करता है
+
+```text
+                       approval/request waterfall (answerer शृंखला)
+                        │
+┌───────────────────────┴──────────────────────┐
+│ dsh-auto-review answerer                     │
+│  · सत्र सक्रिय?  · नीति = ai?               │   नहीं ── next() ──▶ मानव answerer (UI)
+│  · जोखिम नियम → toolsPolicy → डिफ़ॉल्ट      │
+└───────────────────────┬──────────────────────┘
+                        │ हाँ
+                        ▼
+        ┌───────────────────────────────────┐
+        │ समीक्षक सबएजेंट (fork, एक बार)     │
+        │  · toolFilter: read/glob/grep     │
+        │  · outputSchema: {decision,       │
+        │    reason, riskLevel}             │
+        │  · टाइमआउट + req.signal abort     │
+        └───────────────┬───────────────────┘
+                        │ फ़ैसला / विफलता (fail-closed fallback)
+                        ▼
+ allow → allowed-once        deny → rejected + कारण अस्वीकृत टूल के
+                                       परिणाम में डाला जाता है
+                        │   never → rejected + [auto-review-never] फ़ीडबैक
+                        │            (हार्ड-डिसेबल, समीक्षक नहीं चलता)
+                        ▼
+ ऑडिट: approval/asked → autoReview/verdict | autoReview/rejection
+        → approval/decided (सत्र-ईवेंट, log-only, invariant-जाँचित)
+```
+
+**संरचना क्रम।** उत्तरदाता waterfall में अपनी पंजीकरण-स्थिति पर चलता है: यदि कोई मानव UI उत्तरदाता `auto-review` पंक्ति से पहले संयोजित है, तो मानव पहले उत्तर देते हैं और समीक्षक केवल वही देखता है जो आगे सौंपा जाता है। `dsh --profile <name> --dump-config` से सत्यापित करें; यदि ai-नीति उपकरण पहले समीक्षक के पास जाने चाहिए, तो `auto-review` पंक्ति को मानव उत्तरदाता पंक्तियों से पहले रखें।
+
+## 🚀 त्वरित शुरुआत
+
+चार इंस्टॉल चैनल; प्लगइन एक **bundle** है (`"dsh": { "bundle": { "patch": "./cordis.patch.yml" } }`)।
+
+```sh
+# 1. npm (प्रकाशित आर्टिफ़ैक्ट, कोई बिल्ड चरण नहीं)
+dsh plugin --profile web add dsh-auto-review
+dsh --profile web               # पुनः आरंभ करें
+
+# 2. npm tarball (पहले से बने आर्टिफ़ैक्ट, ऑफ़लाइन इंस्टॉल)
+pnpm pack                       # → dsh-auto-review-<version>.tgz
+dsh plugin --profile web add ./dsh-auto-review-<version>.tgz
+dsh --profile web               # पुनः आरंभ करें
+
+# 3. git स्रोत (commit पिन करें; self-contained `prepare` बिल्ड करता है)
+#    pnpm ≥ 10 lifecycle बिल्ड रोकता है: पहले प्रिंट हुई allowBuilds कुंजी को
+#    प्रोफ़ाइल के pnpm-workspace.yaml में जोड़ें।
+dsh plugin --profile web add "github:PerryLink/dsh-auto-review#<commit>"
+
+# 4. स्थानीय link (विकास)
+dsh plugin --profile web add link:/path/to/dsh-auto-review
+```
+
+जाँचें:
+
+```sh
+dsh --profile web --dump-config | grep -A4 'id: auto-review'
+```
+
+डिफ़ॉल्ट पैच में `bash` और `write` AI समीक्षा से गुज़रते हैं; बाकी हर टूल (`edit` — स्थान-स्थान संशोधन — सहित) मानव शृंखला को सौंपा जाता है। यदि आप मानव के बिना स्थान-स्थान संपादन स्वीकार करते हैं तो `edit: ai` स्पष्ट रूप से जोड़ें।
+
+## ⚙️ कॉन्फ़िगरेशन
+
+सभी समायोज्य Schemastery `Config` फ़ील्ड हैं (cordis.yml से बदले जा सकते हैं)। `id`-आधारित ओवरराइड **पूरी config पंक्ति बदल देता है** — ज़रूरी हर कुंजी दोबारा लिखें।
+
+| कुंजी | डिफ़ॉल्ट | अर्थ |
+|---|---|---|
+| `enableByDefault` | `true` | सत्र auto-review सक्रिय होकर शुरू होते हैं; `/auto-review on\|off` एक टिकाऊ ओवरराइड लिखता है जो इससे ऊपर होता है |
+| `toolsPolicy.default` | `human` | सूची से बाहर के टूल की नीति (मानव answerer को सौंपना) |
+| `toolsPolicy.overrides` | `{}` | प्रति-टूल नीति: `ai` (समीक्षक तय करे), `human` (मानव अनिवार्य), `never` (निश्चित अस्वीकृति) |
+| `riskRules` | `[]` | `{pattern, policy, field?}` — टूल-तालिका से **पहले** मिलान (पहला मिलान जीतता है); `field` `reason` (डिफ़ॉल्ट), `toolName`, या `arguments` (प्रस्तुत redacted कॉल आर्गुमेंट) चुनता है |
+| `reviewerProvider` | `fork` | समीक्षक के लिए सबएजेंट provider (इन-प्रोसेस fork बैकएंड) |
+| `reviewerModel` | *(विरासत)* | समीक्षक मॉडल id; खाली रहने पर सत्र एजेंट की रूट विरासत में मिलती है |
+| `reviewerTimeoutMs` | `60000` | फ़ैसले की समय-सीमा; समाप्त होने पर fallback नीति लागू |
+| `reviewerTools` | `[read, glob, grep]` | समीक्षक बच्चे की टूल अनुमति-सूची (गैर-खाली होनी चाहिए) — बाकी सब वहाँ अदृश्य |
+| `fallbackPolicy` | `rejected` | समीक्षक विफलता: `rejected` (fail closed), `delegate` (शृंखला जारी), `allow-once` (अनुमति — सुरक्षा देखें)। 0.2.0 में `allow-readonly` से नाम बदला; पुरानी वर्तनी ज़ोर से विफल होती है |
+| `maxReviewsPerTurn` | `10` | प्रति खुले टर्न वास्तविक AI-फ़ैसला बजट; खत्म होने पर अनुरोध मानवों को सौंपे जाते हैं |
+| `maxFailuresPerTurn` | `10` | प्रति खुले टर्न समीक्षक-विफलता बजट (टाइमआउट/अनुपलब्ध/schema, रद्दीकरण नहीं); खत्म होने पर अनुरोध दूसरा पूरा टाइमआउट चुकाने के बजाय मानवों को सौंपे जाते हैं। डिफ़ॉल्ट `maxReviewsPerTurn` के बराबर |
+| `reasonMaxChars` | `2000` | समीक्षक के कारणों, अनुरोध के कारण और redacted आर्गुमेंट पूर्वावलोकन की सीमा |
+| `reviewerGuidance` | *(कोई नहीं)* | समीक्षक prompt में जोड़ा जाने वाला वैकल्पिक मार्गदर्शन (सलाह, कठोर नियम नहीं) |
+| `reviewerPolicyText` | *(कोई नहीं)* | समीक्षक prompt में डाली जाने वाली Markdown निर्णय-नीति (Codex-शैली; टेम्पलेट `fixtures/config/policy-template.md` पर) |
+| `denyGuidance` | *(circumvention-विरोधी पाठ)* | हर डाले गए अस्वीकृति कारण के अंत में जोड़ा जाने वाला मार्गदर्शन |
+| `contextBudget` | `{turns: 0, maxChars: 4000}` | समीक्षक prompt के लिए संक्षिप्त ट्रांसक्रिप्ट बजट; `turns: 0` निष्क्रिय करता है |
+| `riskPolicy` | `{maxAutoAllow: high, onHighRisk: delegate}` | `maxAutoAllow` से ऊपर के `allow` फ़ैसले सौंपते हैं (`delegate`) या अस्वीकार करते हैं (`deny`) |
+| `circuitBreaker` | `{consecutiveDenies: 3, windowDenies: 6, windowSize: 10, action: delegate}` | अस्वीकृति circuit breaker; 3 लगातार अस्वीकृतियों या टर्न के पिछले 10 फ़ैसलों में से 6 पर ट्रिप होता है; `action`: `delegate` / `reject` / `abort-turn` |
+| `overrideTtlMs` | `300000` | `/auto-review approve` ओवरराइड कितनी देर उपयोग-योग्य रहता है |
+| `language` | `en` | `/auto-review` कमांड आउटपुट की UI भाषा (`en` \| `zh`) |
+
+उदाहरण (टिप्पणी-सहित पूर्ण रूप: `fixtures/config/config-full.yaml`):
+
+```yaml
+- insert:
+    - id: auto-review
+      name: dsh-auto-review
+      config:
+        toolsPolicy:
+          overrides: { bash: ai, write: ai }
+        riskRules:
+          - pattern: '(?i)(rm\s+(-[a-z]+\s+)*/|git\s+push\s+--force)'
+            policy: never
+          - pattern: 'write'
+            policy: never
+            field: toolName
+        reviewerTimeoutMs: 30000
+        fallbackPolicy: delegate
+        riskPolicy: { maxAutoAllow: medium, onHighRisk: delegate }
+        circuitBreaker: { consecutiveDenies: 3, windowDenies: 6, windowSize: 10, action: delegate }
+```
+
+## ⌨️ सत्र कमांड
+
+```
+/auto-review on|off|status|approve [n]
+```
+
+`on`/`off` टिकाऊ `autoReview/state` ओवरराइड जोड़ते हैं (fold पुनः आरंभ/restore के बाद भी बना रहता है — रीप्ले ही स्थिति है) और मॉडल को दिखने वाला स्विच-नोटिस डालते हैं (`user/message` ईवेंट के रूप में दर्ज)। `status` प्रभावी स्थिति, दोनों प्रति-टर्न बजट (AI फ़ैसले और समीक्षक विफलताएँ), टर्न में सक्रिय होने पर ट्रिप हुआ circuit breaker, और सत्र के संचयी आँकड़े (अनुमति/अस्वीकृति/fallback/हार्ड-डिसेबल अस्वीकृति, औसत अवधि, हाल के फ़ैसले) दिखाता है। `approve [n]` n-वीं सबसे हाल की अस्वीकृति (1 = सबसे हाल) के लिए एक बार उपयोग होने वाला `autoReview/override` दर्ज करता है: `overrideTtlMs` के भीतर अगली उसी-टूल समीक्षा उस अधिकार को समीक्षक संदर्भ के रूप में ले जाती है — समीक्षक फिर भी फ़ैसला करता है, और ओवरराइड उस समीक्षा द्वारा उपभोग हो जाता है चाहे उसका परिणाम कुछ भी हो।
+
+## 🖥️ वेब समीक्षा पैनल
+
+वेब GUI (वेब प्रोफ़ाइल) में, पैकेज एक सत्र-शीर्षक क्रिया (**AI Review**) देता है जो सत्र की ऑटो-समीक्षा स्थिति वाला पैनल खोलती है: ऑन/ऑफ बटन वाला स्विच (ये `/auto-review on|off` चलाते हैं), दोनों प्रति-टर्न बजट, संचयी आँकड़े (हार्ड-डिसेबल अस्वीकृतियों सहित), circuit ट्रिप, हाल के फ़ैसले, और हाल की अस्वीकृतियों के लिए एक-बार **अनुमोदन** बटन (ये `/auto-review approve [n]` चलाते हैं)।
+
+वायरिंग:
+
+- होस्ट एक `autoReview` **सत्र प्रोजेक्शन** पंजीकृत करता है (log-only `autoReview/*` ईवेंट से मुड़ा हुआ) और उसे सत्र-प्रोजेक्शन चैनल से परोसता है।
+- ब्राउज़र आधा एक **client module** है (`dsh.client` घोषणा से स्वतः खोजा गया) जो `conversation.session.header.actions` सीट पर पंजीकृत होता है।
+- कोई अतिरिक्त patch पंक्ति नहीं चाहिए: पैनल तब लोड होता है जब प्लगइन ऐसे प्रोफ़ाइल में स्थापित हो जिसकी वेब बिल्ड सत्र-प्रोजेक्शन क्षमता देती है (वेब प्रोफ़ाइल देती है)। उस क्षमता के बिना पैनल स्वयं को अनुपलब्ध बताता है; उत्तरदाता अप्रभावित रहता है।
+
+पैनल केवल संपूर्ण प्रोजेक्शन मान पढ़ता है — ब्राउज़र प्लगइन को कच्ची सत्र-ईवेंट धारा कभी नहीं मिलती।
+
+## 🔒 सुरक्षा
+
+- समीक्षक **केवल-पढ़ने वाले टूल-सेट** (`toolFilter` अनुमति-सूची) में चलता है। वह लिख, बदल, shell चला, नेटवर्क छू या आगे delegation नहीं कर सकता (`maxDepth` = उसकी अपनी गहराई)। उसका सत्र लॉग स्थायी और ऑडिट-योग्य है।
+- **संवेदनशील आर्गुमेंट पहले हटाए जाते हैं** (कुंजी-नाम मिलान: `token`, `password`, `api_key`, `Authorization`, क्रेडेंशियल, निजी कुंजियाँ …) फिर समीक्षक prompt में जाते हैं; प्लगइन समीक्षित आर्गुमेंट कभी निष्पादित नहीं करता। यह कुंजी-आधारित redaction है, सामग्री-आधारित नहीं — जिन टूल के मान मॉडल को दिखाना जोखिम भरा हो, उन्हें AI समीक्षा में न डालें।
+- **डिफ़ॉल्ट रूप से fail closed।** हर असामान्य रास्ता (provider गायब, क्षमता-अंतराल, start अस्वीकृत, टाइमआउट, गैर-`completed` stopReason, फ़ैसला गायब/विकृत, ऑडिट-सहसंबंध विफलता) `fallbackPolicy` से हल होता है, डिफ़ॉल्ट `rejected` — और अस्वीकृति सामान्य "user rejected" पाठ के बजाय एक ऑडिट-योग्य कारण मॉडल को वापस देती है। `allow-once` बिना शर्त अनुमति देता है — केवल उन अप्रबंधित परिनियोजनों के लिए जिनका व्यवस्थापक यह जोखिम स्वीकार करता है।
+- **हार्ड-डिसेबल खुद को समझाते हैं।** `never` टूल या जोखिम नियम निश्चित रूप से अस्वीकार करता है और मिली हुई नियम/तालिका-प्रविष्टि के साथ एक log-only `autoReview/rejection` ईवेंट दर्ज करता है, फिर अस्वीकृत टूल के परिणाम में `[auto-review-never]` मार्कर पाठ डालता है — मॉडल दोबारा कोशिश करने के बजाय सीख लेता है कि क्रिया हार्ड-डिसेबल है (invariant-जाँचित: मार्कर ⟺ ईवेंट)।
+- **अस्वीकृति circuit breaker।** एक टर्न में अस्वीकृतियों का सिलसिला breaker को ट्रिप कर देता है (`windowSize` के भीतर `consecutiveDenies` / `windowDenies`), log-only `autoReview/circuit` ईवेंट के रूप में दर्ज; बाद के अनुरोध उसके `action` (`delegate` / `reject` / `abort-turn`) का पालन करते हैं। `abort-turn` मॉडल को दिखने वाली चेतावनी डालता है और एजेंट रद्द करता है।
+- **समीक्षक संदर्भ प्रस्तुत ट्रांसक्रिप्ट है।** `contextBudget` पहले से प्रस्तुत सत्र सामग्री (संदेश, टूल परिणाम) समीक्षक को देता है। डिफ़ॉल्ट समान-रूट समीक्षक मॉडल के साथ वह सामग्री एक ही provider के भीतर रहती है; `reviewerModel` को किसी भिन्न provider पर तभी सेट करें जब आप उस ट्रांसक्रिप्ट को उसके सामने प्रस्तुत करना स्वीकार करते हों।
+- **`never` इस परत पर एकतरफ़ा है।** `never` टूल या जोखिम नियम मानव शृंखला के अनुरोध देखने से पहले ही अस्वीकार कर देता है — यह ताला है, डिफ़ॉल्ट नहीं।
+- **समीक्षक भी एक मॉडल है।** उसके फ़ैसले सलाहकार नीति हैं, सुरक्षा कर्नेल नहीं। अपरिवर्तनीय कार्यों के लिए `human`/`never` नियम रखें।
+
+## ⚠️ ज्ञात सीमाएँ
+
+- समीक्षक को एक कार्यशील LLM रूट चाहिए (डिफ़ॉल्ट में सत्र एजेंट से विरासत); उसके बिना हर समीक्षा `fallbackPolicy` पर गिरती है — कभी भी मौन अनुमति नहीं।
+- `reviewerTools` के नाम प्रोफ़ाइल में वास्तविक वैश्विक टूल होने चाहिए; अज्ञात नाम समीक्षक बच्चे को सबसे पहले बिंदु पर ज़ोर से विफल करता है और fallback पर गिरता है।
+- जोखिम नियम अपने `field` के अनुसार अनुरोध के `reason`, `toolName` या redacted कॉल `arguments` से मिलते हैं; बाकी शर्तें `toolsPolicy.overrides` में रखें।
+- `/auto-review approve` ओवरराइड अगली उसी-टूल समीक्षा को अधिकृत करता है, सटीक ऐतिहासिक कॉल को नहीं; उसी टूल पर कोई भिन्न क्रिया उसे उपभोग कर लेती है।
+- फ़ैसला ईवेंट log-only हैं; समर्पित वेब समीक्षा पैनल मुड़ा हुआ `autoReview` प्रोजेक्शन पढ़ता है (कच्ची ईवेंट धारा ब्राउज़र प्लगइन तक कभी नहीं पहुँचती)।
+- `autoReview/state` और `autoReview/verdict` एन्वेलप के `ignorable: true` मार्कर के साथ लिखे जाते हैं, इसलिए कोई भी harness बिल्ड लॉग लोड कर लेता है — जो पाठक इन आउट-ऑफ-रेपो प्रकारों को नहीं जानते वे सत्र अस्वीकार करने के बजाय केवल उन रिकॉर्ड्स को छोड़ देते हैं। (rc.6 होस्ट मार्कर को स्वीकार कर अनदेखा करते हैं, पहले जैसा ही व्यवहार बना रहता है; 0.1.1 से पहले के संस्करणों द्वारा लिखे सत्र `dsh-permission-rules` के `scripts/repair-session-logs.mjs` से एक बार मरम्मत किए जा सकते हैं।)
+- git चैनल को केवल वही एक `allowBuilds` कुंजी चाहिए जो `dsh` CLI स्वयं `dsh-auto-review` के लिए प्रिंट करता है। रेपो अपना `pnpm-workspace.yaml` लेकर आता है जिसमें `allowBuilds: { esbuild: true }` है, ताकि अलग-थलग prepare वातावरण esbuild के (हानिरहित प्लेटफ़ॉर्म-बाइनरी सत्यापन) postinstall पर विफल न हो; `typescript` + `tsdown` नियमित `dependencies` हैं ताकि उस वातावरण में बिल्ड टूल हमेशा मौजूद रहें।
+- वैकल्पिक invariant companion (`dsh-auto-review/invariant`) को `invariants` सेवा चाहिए (agent-spine संयोजन जैसे headless/ACP); सामान्य web प्रोफ़ाइल उसे नहीं देती, इसलिए वह पंक्ति bundle पैच में टिप्पणी रूप में जाती है।
+
+## 🏷️ GitHub टॉपिक
+
+प्रकाशन पर सुझावित: `dsh` · `dsh-plugin` · `deepseek-harness` · `deepseek` · `cordis` · `ai-safety` · `approval` · `sandbox` · `subagent` · `llm`
+
+## 🔗 संबंधित कार्य
+
+- [Andy8647/dsh-auto-approval](https://github.com/Andy8647/dsh-auto-approval) — `tools/pre-execute` waterfall पर दो-अवस्था allow/deny क्लासिफ़ायर, फ़ाइल-लॉग ऑडिट के साथ। `dsh-auto-review` जानबूझकर अलग है: आधिकारिक **answerer** शृंखला, जो उसका नहीं उसे हमेशा आगे भेजता है, संरचित फ़ैसले वाला केवल-पढ़ने वाला दूसरा मॉडल, अस्वीकृति के कारण मॉडल को वापस, सत्र-लॉग ऑडिट।
+- [ACP automation bridge](https://github.com/deepseek-ai/deepseek-harness/tree/master/packages/acp/acp) — अपने ACP एजेंटों के लिए एक बार के मशीन निर्णय। `dsh-auto-review` इंटरैक्टिव harness की सत्र और टूल-नीति परिधि के लिए है; यह कभी स्थायी अनुमतियाँ नहीं मानता।
+
+## 🧑‍💻 विकास
+
+```sh
+pnpm install                # node ^22.19 || >=24
+pnpm run typecheck          # tsc, src + टेस्ट
+pnpm test                   # vitest: 135 टेस्ट, 8 सुइट
+pnpm run build              # tsc डिक्लेरेशन + tsdown बंडल (lib/)
+pnpm run verify:self-contained
+pnpm pack                   # प्रकाशन आर्टिफ़ैक्ट
+```
+
+रेपो संरचना (plugin-template संरचना): `src/index.ts` (प्लगइन अनुबंध) · `src/config.ts` (Schemastery schema + रिज़ॉल्यूशन) · `src/runtime.ts` (answerer, कमांड, अस्वीकृति-कारण इंजेक्शन) · `src/review.ts` (समीक्षक ऑर्केस्ट्रेशन, prompt, redaction) · `src/events.ts` (सत्र-ईवेंट शब्दावली + folds) · `src/projection.ts` + `src/projection-types.ts` (`autoReview` सत्र प्रोजेक्शन) · `src/invariant.ts` (invariant companion) · `src/client/` (ब्राउज़र आधा: समीक्षा पैनल, locales, स्टाइल) · `test/` · `fixtures/`।
+
+## 📄 लाइसेंस
+
+[Apache License 2.0](LICENSE)

package/README.md

@@ -0,0 +1,226 @@
+<!-- language links -->
+[English](README.md) · [中文](README.zh.md) · [Español](README.es.md) · [Português](README.pt.md) · [हिन्दी](README.hi.md)
+
+<div align="center">
+
+# 🤖 dsh-auto-review
+
+**Second-model AI approval for DeepSeek Harness** — the Codex `approvals_reviewer=auto_review` / Claude Code *auto mode* pattern, built as a pure Cordis plugin.
+
+When an agent's action crosses the sandbox boundary, a **read-only reviewer subagent** decides allow/deny — with a reason — so humans approve nothing while nothing unsafe slips through.
+
+[![license](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+[![dsh](https://img.shields.io/badge/dsh-0.1.0--rc.6-4c51bf.svg)](https://www.npmjs.com/package/@deepseek-ai/dsh)
+[![tests](https://img.shields.io/github/actions/workflow/status/PerryLink/dsh-auto-review/ci.yml?label=tests&logo=githubactions)](.github/workflows/ci.yml)
+[![typescript](https://img.shields.io/badge/TypeScript-strict-3178c6.svg)](src)
+[![type](https://img.shields.io/badge/type-cordis%20bundle-8a5cf6.svg)](cordis.patch.yml)
+[![repo](https://img.shields.io/badge/repo-PerryLink%2Fdsh--auto--review-181717.svg)](https://github.com/PerryLink/dsh-auto-review)
+
+**Zero human operations.** The request goes to the AI reviewer, the verdict is allow/deny + reason + risk level, and every decision is reconstructable from the session log: `approval/asked` → `autoReview/verdict` (or `autoReview/rejection` for hard disables) → `approval/decided`.
+
+<img src="docs/demo-auto-review.gif" alt="dsh-auto-review demo" width="720"/>
+
+*One real evidence run (real server, real API key, two real model rounds): the AI reviewer **allows** an escalated workspace write (risk low, 5.2 s), then **denies** a recursive out-of-workspace delete (risk high, 8.9 s) — the deny reason is fed back to the model, visible in the transcript.*
+
+</div>
+
+## Why a second model instead of rules?
+
+Pattern-based auto-approvers decide before dispatch, with no evidence. `dsh-auto-review` gives the decision to a **reviewer subagent** that reads the actual workspace (through its read-only tool face), the already-streamed tool-call arguments (sensitive values redacted), the request reason, and your risk rules — then returns a structured verdict. A deny verdict feeds its **reason back to the calling model**, so the agent learns why instead of retrying blindly.
+
+## ✨ Features
+
+| | |
+|---|---|
+| 🔌 **Official seam** | An answerer on the `approval/request` waterfall. Requests it does not own are delegated via `next()` — the human approval flow is never short-circuited. |
+| 🧠 **Second-model verdict** | One-shot fork subagent with a read-only tool allow-list (`read`/`glob`/`grep`) and a structured verdict schema `{ decision, reason, riskLevel }`. |
+| 🛡️ **Fail closed** | Reviewer crash, timeout, or schema mismatch never opens the gate: `fallbackPolicy` applies, default `rejected`. |
+| 🧩 **Config-driven routing** | Per-tool policies (`ai`/`human`/`never`) + regex risk rules, all changeable from cordis.yml. |
+| 💬 **Deny reasons reach the model** | The reviewer's reason is injected into the denied tool result (callId-linked), so the agent adapts. Fail-closed fallback rejections and `never`-policy hard disables inject auditable failure texts too (`[auto-review]` / `[auto-review-fallback]` / `[auto-review-never]` markers). |
+| 📜 **Full audit trail** | `autoReview/verdict` + `autoReview/rejection` session events (reviewer identity, verdict, reason, risk, duration) + an invariant companion enforcing *model-visible ⟺ logged*. |
+| 🔁 **No recursion** | Reviewer asks are recognized by identity and delegated; `maxDepth` + the tool allow-list keep the reviewer non-delegating. |
+| 🧯 **Rejection circuit breaker** | 3 consecutive denials (or 6 within the last 10 verdicts) in one turn trip the breaker: later requests delegate, reject, or abort the turn — no endless denial loops. |
+| 🎚️ **Risk-level policy** | An `allow` verdict whose risk exceeds `riskPolicy.maxAutoAllow` never settles the request: it delegates to a human or denies. |
+| ✋ **One-shot human override** | `/auto-review approve [n]` authorizes ONE retry of a recent denial; the next same-tool review carries that authorization as reviewer context (the reviewer still decides). |
+| 📜 **Reviewer context** | Optional compact transcript (recent messages and tool results, bounded) + a Codex-style Markdown `reviewerPolicyText` ruling policy. |
+| ⌨️ **Session command** | `/auto-review on|off|status|approve [n]` with a durable per-session override that survives restore and cumulative session statistics. |
+| 🖥️ **Web review panel** | A session-header panel (Web GUI) shows the switch (with on/off buttons), both per-turn budgets, cumulative statistics, the circuit trip, recent verdicts, and one-shot approve buttons — driven by the `autoReview` session projection. |
+
+## How it works
+
+```text
+                       approval/request waterfall (answerer chain)
+                        │
+┌───────────────────────┴──────────────────────┐
+│ dsh-auto-review answerer                     │
+│  · session enabled?  · policy = ai?         │   no ── next() ──▶ human answerer (UI)
+│  · risk rules → toolsPolicy → default       │
+└───────────────────────┬──────────────────────┘
+                        │ yes
+                        ▼
+        ┌───────────────────────────────────┐
+        │ reviewer subagent (fork, one-shot)│
+        │  · toolFilter: read/glob/grep     │
+        │  · outputSchema: {decision,       │
+        │    reason, riskLevel}             │
+        │  · timeout + req.signal abort     │
+        └───────────────┬───────────────────┘
+                        │ verdict / failure (fail-closed fallback)
+                        ▼
+ allow → allowed-once        deny → rejected + reason injected into the
+                                       denied tool result (callId-linked)
+                        │   never → rejected + [auto-review-never] feedback
+                        │            (hard disable, no reviewer runs)
+                        ▼
+ audit: approval/asked → autoReview/verdict | autoReview/rejection
+        → approval/decided (session events, log-only, invariant-checked)
+```
+
+**Composition order.** The answerer runs at its registration position in the waterfall: if a human UI answerer is composed BEFORE the `auto-review` row, humans answer first and the reviewer only sees what is delegated downstream. Verify with `dsh --profile <name> --dump-config` and place the `auto-review` row before your human answerer rows when you want ai-policy tools routed to the reviewer first.
+
+## 🚀 Quick start
+
+Three install channels; the plugin is a **bundle** (`"dsh": { "bundle": { "patch": "./cordis.patch.yml" } }`).
+
+```sh
+# 1. npm (published artifact, no build step)
+dsh plugin --profile web add dsh-auto-review
+dsh --profile web               # restart
+
+# 2. npm tarball (built artifacts, offline install)
+pnpm pack                       # → dsh-auto-review-<version>.tgz
+dsh plugin --profile web add ./dsh-auto-review-<version>.tgz
+dsh --profile web               # restart
+
+# 3. git source (pin the commit; self-contained `prepare` builds it)
+#    pnpm ≥ 10 blocks lifecycle builds: add the printed allowBuilds key
+#    to the profile's pnpm-workspace.yaml first.
+dsh plugin --profile web add "github:PerryLink/dsh-auto-review#<commit>"
+
+# 4. local link (development)
+dsh plugin --profile web add link:/path/to/dsh-auto-review
+```
+
+Verify:
+
+```sh
+dsh --profile web --dump-config | grep -A4 'id: auto-review'
+```
+
+Out of the box the shipped patch AI-reviews `bash` and `write`; every other tool (including `edit` — in-place modification) delegates to the human chain. Add `edit: ai` explicitly if you accept in-place edits without a human in the loop.
+
+## ⚙️ Configuration
+
+All tunables are Schemastery `Config` fields (changeable from cordis.yml). An id-targeted override **replaces the whole config row** — restate every key you need.
+
+| Key | Default | Meaning |
+|---|---|---|
+| `enableByDefault` | `true` | Sessions start with auto-review enabled; `/auto-review on\|off` writes a durable override that beats this |
+| `toolsPolicy.default` | `human` | Policy for unlisted tools (delegate to the human answerer) |
+| `toolsPolicy.overrides` | `{}` | Per-tool policy: `ai` (reviewer decides), `human` (force human), `never` (deterministic reject) |
+| `riskRules` | `[]` | `{pattern, policy, field?}` matched (first match wins) before the tool table; `field` selects `reason` (default), `toolName`, or `arguments` (the redacted presented call arguments) |
+| `reviewerProvider` | `fork` | Subagent provider for the reviewer (in-process fork backend) |
+| `reviewerModel` | *(inherit)* | Reviewer model id; unset inherits the session agent's route |
+| `reviewerTimeoutMs` | `60000` | Verdict deadline; on expiry the fallback policy applies |
+| `reviewerTools` | `[read, glob, grep]` | The reviewer child's tool allow-list (must be non-empty) — everything else is invisible there |
+| `fallbackPolicy` | `rejected` | Reviewer failure: `rejected` (fail closed), `delegate` (continue the chain), `allow-once` (grant — see Security). Renamed from `allow-readonly` in 0.2.0; the old spelling fails loudly |
+| `maxReviewsPerTurn` | `10` | Real AI-verdict budget per open turn; beyond it, requests delegate to humans |
+| `maxFailuresPerTurn` | `10` | Reviewer-failure budget per open turn (timeout/unavailable/schema, not cancellations); beyond it, requests delegate instead of paying another full timeout. Defaults to `maxReviewsPerTurn` |
+| `reasonMaxChars` | `2000` | Cap for reviewer reasons, the request reason, and the redacted argument preview |
+| `reviewerGuidance` | *(none)* | Optional advisory guidance appended to the reviewer prompt |
+| `reviewerPolicyText` | *(none)* | Markdown ruling policy injected into the reviewer prompt (Codex-style; template at `fixtures/config/policy-template.md`) |
+| `denyGuidance` | *(anti-circumvention text)* | Guidance appended to every injected deny reason |
+| `contextBudget` | `{turns: 0, maxChars: 4000}` | Compact transcript budget for the reviewer prompt; `turns: 0` disables |
+| `riskPolicy` | `{maxAutoAllow: high, onHighRisk: delegate}` | `allow` verdicts above `maxAutoAllow` delegate (`delegate`) or deny (`deny`) |
+| `circuitBreaker` | `{consecutiveDenies: 3, windowDenies: 6, windowSize: 10, action: delegate}` | Rejection circuit breaker; trips on 3 consecutive denies or 6 of the last 10 verdicts in a turn; `action`: `delegate` / `reject` / `abort-turn` |
+| `overrideTtlMs` | `300000` | How long a `/auto-review approve` override stays usable |
+| `language` | `en` | UI language of the `/auto-review` command output (`en` \| `zh`) |
+
+Example (annotated full form: `fixtures/config/config-full.yaml`):
+
+```yaml
+- insert:
+    - id: auto-review
+      name: dsh-auto-review
+      config:
+        toolsPolicy:
+          overrides: { bash: ai, write: ai }
+        riskRules:
+          - pattern: '(?i)(rm\s+(-[a-z]+\s+)*/|git\s+push\s+--force)'
+            policy: never
+          - pattern: 'write'
+            policy: never
+            field: toolName
+        reviewerTimeoutMs: 30000
+        fallbackPolicy: delegate
+        riskPolicy: { maxAutoAllow: medium, onHighRisk: delegate }
+        circuitBreaker: { consecutiveDenies: 3, windowDenies: 6, windowSize: 10, action: delegate }
+```
+
+## ⌨️ Session command
+
+```
+/auto-review on|off|status|approve [n]
+```
+
+`on`/`off` append the durable `autoReview/state` override (the fold survives restart/resume — replay IS the state) and inject a switch notice the model sees (logged as a `user/message` event). `status` reports the effective state, both per-turn budgets (AI verdicts and reviewer failures), a tripped circuit breaker when one is active, and the session's cumulative statistics (allows/denies/fallbacks/never rejects, mean duration, recent verdicts). `approve [n]` records a single-use `autoReview/override` for the n-th most recent denial (1 = most recent): the next same-tool review within `overrideTtlMs` carries the authorization as reviewer context — the reviewer still decides, and the override is consumed by that review regardless of its outcome.
+
+## 🖥️ Web review panel
+
+In the Web GUI (web profile), the package contributes a session-header action (**AI Review**) that opens a panel with the session's auto-review state: the switch with on/off buttons (they execute `/auto-review on|off`), both per-turn budgets, cumulative statistics (including hard-disable rejections), the circuit trip, the recent verdicts, and one-shot **approve** buttons for recent denials (they execute `/auto-review approve [n]`).
+
+How it is wired:
+
+- The host registers an `autoReview` **session projection** (folded from the log-only `autoReview/*` events) and serves it through the session-projection channel.
+- The browser half is a **client module** (auto-discovered from the `dsh.client` declaration) registered on the `conversation.session.header.actions` seat.
+- No extra patch rows are needed: the panel loads whenever the plugin is installed in a profile whose web build provides the session-projection capability (the web profile does). Without that capability the panel reports itself unavailable; the answerer is unaffected.
+
+The panel reads only whole projection values — it never receives the raw session event stream.
+
+## 🔒 Security
+
+- The reviewer runs in a **read-only tool face** (`toolFilter` allow-list). It cannot write, edit, run bash, fetch the network, or delegate (`maxDepth` = its own depth). Its session log is persisted and auditable.
+- **Sensitive arguments are redacted** (key-name matching: `token`, `password`, `api_key`, `Authorization`, credentials, private keys …) before entering the reviewer prompt; the plugin never executes the reviewed arguments. Redaction is key-based, not content-based — do not AI-review tools whose argument values you cannot afford to show a model.
+- **Fail closed by default.** Every abnormal path (provider missing, capability gaps, start rejection, timeout, non-`completed` stop reason, missing/malformed verdict, audit-correlation failure) resolves through `fallbackPolicy`, default `rejected` — and the rejection feeds an auditable reason back to the model instead of the generic "user rejected" text. `allow-once` grants unconditionally — it exists only for unattended deployments whose admin accepts that risk.
+- **Hard disables explain themselves.** A `never` tool or risk rule rejects deterministically AND records a log-only `autoReview/rejection` event with the matched rule/table entry, then injects a `[auto-review-never]` marker text into the denied tool result — the model learns the action is hard-disabled instead of retrying it (invariant-checked: marker ⟺ event).
+- **Rejection circuit breaker.** A run of denials in one turn trips the breaker (`consecutiveDenies` / `windowDenies` inside `windowSize`), recorded as a log-only `autoReview/circuit` event; later requests follow its `action` (`delegate` / `reject` / `abort-turn`). `abort-turn` injects a model-visible warning and cancels the agent.
+- **Reviewer context is presented transcript.** `contextBudget` feeds already-presented session content (messages, tool results) to the reviewer. With the default same-route reviewer model that content stays inside one provider; configure `reviewerModel` to a different provider only if you accept presenting that transcript to it.
+- **`never` is one-way at this layer.** A `never` tool or risk rule rejects before the human chain sees the request — a lockdown knob, not a default.
+- **The reviewer is a model.** Its verdicts are advisory policy, not a security kernel. Prefer `human`/`never` rules for irreversible operations.
+
+## ⚠️ Known limitations
+
+- The reviewer needs a working LLM route (inherited from the session agent by default); without one every review falls back per `fallbackPolicy` — never a silent grant.
+- `reviewerTools` names must exist as global tools in the profile; an unknown name fails the reviewer child loudly at the earliest point and falls back.
+- Risk rules match the request `reason`, the `toolName`, or the redacted call `arguments` per their `field`; other conditions belong in `toolsPolicy.overrides`.
+- The `/auto-review approve` override authorizes the next same-tool review, not the exact historical call; a different action on the same tool consumes it.
+- The verdict events are log-only; the dedicated Web review panel reads the folded `autoReview` projection (the raw event stream never reaches browser plugins).
+- `autoReview/state` and `autoReview/verdict` are appended with the envelope's `ignorable: true` marker, so any harness build loads the log — readers that do not know the out-of-repo types simply skip those records instead of refusing the session. (rc.6 hosts accept and ignore the marker, keeping the exact pre-marker behavior; sessions written by pre-0.1.1 versions can be repaired with `scripts/repair-session-logs.mjs` from `dsh-permission-rules`.)
+- The git channel needs the single `allowBuilds` key the `dsh` CLI prints for `dsh-auto-review` itself. The repo ships its own `pnpm-workspace.yaml` with `allowBuilds: { esbuild: true }` so the isolated prepare environment does not fail on esbuild's (harmless platform-binary validation) postinstall; `typescript` + `tsdown` are regular `dependencies` so that environment always has the build tools.
+- The optional invariant companion (`dsh-auto-review/invariant`) needs the `invariants` service (agent-spine compositions such as headless/ACP); the plain web profile does not provide it, so the row ships commented out in the bundle patch.
+
+## 🏷️ GitHub topics
+
+Recommended when you publish: `dsh` · `dsh-plugin` · `deepseek-harness` · `deepseek` · `cordis` · `ai-safety` · `approval` · `sandbox` · `subagent` · `llm`
+
+## 🔗 Related work
+
+- [Andy8647/dsh-auto-approval](https://github.com/Andy8647/dsh-auto-approval) — two-state allow/deny classifier on the `tools/pre-execute` waterfall with file-log audit. `dsh-auto-review` deliberately differs: official **answerer** chain, always delegates what it does not own, read-only second model with a structured verdict, deny reasons fed back to the model, session-log audit.
+- [ACP automation bridge](https://github.com/deepseek-ai/deepseek-harness/tree/master/packages/acp/acp) — one-shot machine decisions for its own ACP-owned agents. `dsh-auto-review` is session- and tool-policy-scoped for the interactive harness; it never infers durable grants.
+
+## 🧑‍💻 Development
+
+```sh
+pnpm install                # node ^22.19 || >=24
+pnpm run typecheck          # tsc, src + tests
+pnpm test                   # vitest: 135 tests, 8 suites
+pnpm run build              # tsc declarations + tsdown bundles (lib/, incl. the client bundle)
+pnpm run verify:self-contained
+pnpm pack                   # publish artifact
+```
+
+Repository layout (plugin-template structure): `src/index.ts` (plugin contract) · `src/config.ts` (Schemastery schema + resolution) · `src/runtime.ts` (answerer, command, deny-reason injection) · `src/review.ts` (reviewer orchestration, prompt, sanitization) · `src/events.ts` (session-event vocabulary + folds) · `src/projection.ts` + `src/projection-types.ts` (the `autoReview` session projection) · `src/invariant.ts` (invariant companion) · `src/client/` (browser half: review panel, locales, styles) · `test/` · `fixtures/`.
+
+## 📄 License
+
+[Apache License 2.0](LICENSE)