Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

··फ़ीड·संपर्क·गोपनीयता·© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
superpowers-evals — व्यवहारिक मूल्यांकन प्रयोगशाला (Quorum) superpowers परियोजना के लिए जो वास्तविक कोडिंग-एजेंट CLI (Claude, Codex, Gemini, Kimi, और अन्य) को एक QA एजेंट के माध्यम से संचालित करती है और उन्हें परिदृश्य मानदंडों और नियतात्मक पोस्ट-चेक्स के विरुद्ध कार्यप्रवाह अनुपालन पर ग्रेड देती है। | Kitploit
उपकरण/GitHubGitHub/prime-radiant-inc/superpowers-evals
स्क्रिप्टिंग और स्वचालनपेनिट्रेशन टेस्टिंगउपयोगिताएँ और फ्रेमवर्कलर्निंग और शिक्षाAI सुरक्षालैब और अभ्यास
GitHubprime-radiant-inc/superpowers-evals

superpowers-evals

रिपॉजिटरी देखें
9712817घं 13मि पहलेKitploit द्वारा समीक्षित

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →

विवरण

व्यवहारिक मूल्यांकन प्रयोगशाला (Quorum) superpowers परियोजना के लिए जो वास्तविक कोडिंग-एजेंट CLI (Claude, Codex, Gemini, Kimi, और अन्य) को एक QA एजेंट के माध्यम से संचालित करती है और उन्हें परिदृश्य मानदंडों और नियतात्मक पोस्ट-चेक्स के विरुद्ध कार्यप्रवाह अनुपालन पर ग्रेड देती है।

साझा करें

Superpowers Evals

Behavioural evals lab for superpowers। Quorum वास्तविक कोडिंग-एजेंट CLI (Claude, Codex, Antigravity, Gemini, Kimi, OpenCode, Pi, और Copilot) को एक Gauntlet QA एजेंट के माध्यम से चलाता है और उन्हें परिदृश्य स्वीकृति मानदंडों और नियतात्मक पोस्ट-जांचों के विरुद्ध ग्रेड करता है।

कोड, CLI, पथ, और इनलाइन गद्य सभी lowercase quorum का उपयोग करते हैं; capitalized रूप Quorum शीर्षकों और एजेंट तालिका में दिखाई देता है।

यह एक सामान्य बेंचमार्क सूट नहीं है। यह वर्कफ़्लो अनुपालन के लिए एक मूल्यांकन प्रयोगशाला है: स्किल ट्रिगरिंग, वर्कट्री व्यवहार, सबएजेंट समन्वय, सत्यापन रिफ्लेक्सिस, समीक्षा गुणवत्ता, और लागत-आकार देने वाले पैटर्न।

Safety Model

quorum के दो बहुत अलग निष्पादन मोड हैं:

  • Static/unit checks सार्वजनिक CI के लिए सुरक्षित हैं। ये biome, tsc, और bun test चलाते हैं। ये मॉडल API को कॉल नहीं करते और एजेंट CLI लॉन्च नहीं करते।
  • Live evals trusted-maintainer संचालन हैं। ये Claude Code, Codex CLI, Antigravity CLI, Gemini CLI, Kimi Code, OpenCode CLI, Pi CLI, या Copilot CLI को अनुमेय मोड में लॉन्च करते हैं और कच्चे ट्रांसक्रिप्ट, टूल कॉल, फ़ाइलसिस्टम स्थिति, और सत्र लॉग एकत्र करते हैं।

सार्वजनिक CI को उस रेखा के static/unit पक्ष पर रहना चाहिए। सार्वजनिक CI में कभी भी API कुंजियाँ, लाइव quorum run … आह्वान, या खतरनाक-मोड एजेंट लॉन्च न जोड़ें।

Live Eval Risk

लाइव evals परीक्षण के तहत Coding-Agent को व्यापक निष्पादन शक्ति के साथ चलाते हैं:

  • Claude --dangerously-skip-permissions का उपयोग करता है।
  • Codex --dangerously-bypass-approvals-and-sandbox का उपयोग करता है।
  • Antigravity --dangerously-skip-permissions का उपयोग करता है और agy के लिए स्थानीय ब्राउज़र/कीरिंग प्रमाणीकरण पर निर्भर करता है।
  • Gemini --skip-trust --approval-mode=yolo का उपयोग करता है; API-कुंजी प्रमाणीकरण डिफ़ॉल्ट है, विश्वसनीय स्थानीय रनों के लिए वैकल्पिक OAuth प्रमाणीकरण के साथ।
  • Kimi --yolo का उपयोग करता है।
  • OpenCode --dangerously-skip-permissions का उपयोग करता है।
  • Pi स्पष्ट टूल अनुमति सूचियों और API-कुंजी प्रमाणीकरण का उपयोग करता है एक रन-लोकल कॉन्फ़िग डिर में।
  • Copilot --allow-all का उपयोग करता है।

quorum प्रत्येक Coding-Agent के HOME (साथ ही XDG बेस डिर और TMPDIR) को एक डिस्पोजेबल प्रति-रन होम पर पिन करता है <run>/home — लॉन्चर $QUORUM_HOME_ENV टोकन को जोड़ता है जो src/agents/home-env.ts (xdgHomeEnv, सत्य का एकमात्र स्रोत) द्वारा निर्मित होता है। प्रत्येक एजेंट का कॉन्फ़िग डिर उस होम के अंतर्गत समाहित होता है (Claude .claude, Codex .codex, Gemini ., OpenCode ., Antigravity ., Copilot .copilot, Kimi .kimi-code, Pi .pi/agent), ताकि Coding-Agent अपने स्वयं के $HOME डिफ़ॉल्ट के माध्यम से अपना कॉन्फ़िग ढूंढे और होस्ट के वास्तविक ~/.claude, ~/.codex, ~/.gemini, ~/.kimi-code, ~/.pi, ~/.copilot, ~/.config, या अन्य होम-संबंधित स्थिति, स्थापित प्लगइन्स, या पिछले सत्रों को कभी न देखे। प्रोविज़निंग कॉन्फ़िग को सीड करती है — और होस्ट OAuth क्रेडेंशियल्स जो प्रत्येक एजेंट को चाहिए — लॉन्च से पहले उस डिस्पोजेबल होम में, इसलिए कोई रन-टाइम लॉगिन नहीं होता। Copilot भी स्थानीय Superpowers प्लगइन को पृथक होम के अंतर्गत स्टेज करता है, एक अनुमत बाहरी वातावरण का उपयोग करता है, और एक गुप्त-युक्त chmod-0600 .copilot-env को रन डिर के अंदर लिखता है। यह विस्फोट त्रिज्या को कम करता है लेकिन सैंडबॉक्स नहीं है। OpenCode और Copilot लॉन्चर इसके अतिरिक्त अनुमत वातावरण का उपयोग करते हैं, लेकिन लाइव Coding-Agent अभी भी व्यापक फ़ाइलसिस्टम और कमांड निष्पादन शक्ति के साथ चलते हैं।

लाइव evals केवल एक विश्वसनीय स्थानीय वातावरण से चलाएं:

  • चयनित Coding-Agent के लिए आवश्यक API कुंजी ही निर्यात करें।
  • व्यापक उत्पादन या व्यक्तिगत गुप्त जानकारी को वातावरण में रखने से बचें।
  • results/, कच्चे सत्र लॉग, सत्र-स्थिति/टूल-कॉल आर्टिफैक्ट्स, और Gauntlet-Agent इनपुट को संवेदनशील मानें।
  • कच्चे रन आर्टिफैक्ट्स को पहले जांचे बिना कमिट या पेस्ट न करें।

Quick Start

स्थिर गेट्स स्थापित करें और चलाएं:```bash bun install bun run check bun run quorum check

root@kitploit:~
एक स्थानीय या break-glass परिदृश्य को कंटेनर के बाहर चलाएँ:```bash
export SUPERPOWERS_ROOT=/path/to/superpowers
export ANTHROPIC_API_KEY=...
bun run quorum run scenarios/triggering-writing-plans --coding-agent claude
bun run quorum show <run-dir>

Gauntlet-Agent (QA ड्राइवर) डिफ़ॉल्ट रूप से ANTHROPIC_API_KEY के साथ Anthropic को प्रमाणित करता है। इसके बजाय लॉग-इन किए गए Claude सब्सक्रिप्शन से इसे चलाने के लिए, पर्यावरण (जैसे .env) में CLAUDE_CODE_OAUTH_TOKEN (claude setup-token से) सेट करें; हार्नेस इसे पार्स करता है और gauntlet इसे API कुंजी पर प्राथमिकता देता है। नोट: एक सब्सक्रिप्शन में इंटरैक्टिव उपयोग के लिए आकार की उपयोग सीमाएँ होती हैं — उच्च-समवर्ती run-all बैच उन्हें हिट कर सकते हैं, इसलिए API कुंजी भारी लोड के लिए बेहतर विकल्प बनी हुई है।

एजेंट के नाम claude, codex, antigravity, gemini, kimi, opencode, pi, और copilot हैं। प्रत्येक परिदृश्य प्रत्येक एजेंट के लिए मान्य नहीं है।

ब्रेकिंग (क्रेडेंशियल एक्सिस): claude-haiku और claude-sonnet अब अलग एजेंट नाम नहीं हैं। Sonnet या Haiku के विरुद्ध Claude हार्नेस चलाने के लिए:```bash bun run quorum run scenarios/ --coding-agent claude --credential sonnet bun run quorum run scenarios/ --coding-agent claude --credential haiku

root@kitploit:~
`claude` एजेंट का डिफ़ॉल्ट क्रेडेंशियल `opus` है।

## Shared Eval Appliance

साझा रिमोट लाइव मूल्यांकन एक विश्वसनीय उपकरण होस्ट से चलाने के लिए डिज़ाइन किए गए हैं जिसमें
एक स्वीकृत क्रेडेंशियल बंडल, सटीक repo/ref उत्पत्ति, होस्ट लॉक, और
पुनर्प्राप्त करने योग्य कार्य रिकॉर्ड हों। एजेंट को कॉन्फ़िगर्ड होस्ट पर उपकरण सहायक का उपयोग करना चाहिए जब यह मौजूद हो:```bash
evals-appliance doctor --json
evals-appliance prepare --json --superpowers-ref <branch-tag-or-sha>
evals-appliance run-all --json --detach \
  --superpowers-ref <branch-tag-or-sha> \
  -- --tier sentinel \
     --coding-agents claude,codex,kimi \
     --jobs 4
evals-appliance status --json <job-id>
evals-appliance show --json <job-id>
evals-appliance costs --json <job-id>
evals-appliance cancel --json <job-id>

लक्ष्य इंटरफ़ेस और संचालन नियम यहाँ हैं docs/appliance-runbook.md, और इसके पीछे docs/superpowers/specs/2026-06-18-shared-eval-appliance-design.md है। doctor केवल-पढ़ने योग्य है। prepare एक सक्रिय कार्य चलने के दौरान refs बदलने के बजाय lock_busy लौटाता है। होस्ट एक्सेस और प्रदाता-विशिष्ट break-glass प्रक्रियाओं को जानबूझकर इस सार्वजनिक रिपॉजिटरी से बाहर रखा गया है; उन विवरणों के लिए निजी ops runbook का उपयोग करें। सीधे bun run quorum ... और scripts/evals-container exec quorum ... साझा लाइव eval के लिए स्थानीय या विश्वसनीय break-glass वर्कफ़्लो बने रहते हैं।

कंटेनर रनटाइम

डॉकर रनटाइम वास्तविक सुइट रन के लिए प्राथमिक रेसिपी है। यह evals चेकआउट, परीक्षण के तहत Superpowers चेकआउट, क्रेडेंशियल्स, प्रमाणीकरण स्रोत, और सभी रन आर्टिफैक्ट्स को होस्ट पर रखता है जबकि quorum एक समृद्ध Ubuntu वर्कस्पेस कंटेनर के अंदर चलता है।

.env.container बनाएं या up को एक स्पष्ट env फ़ाइल पास करें:```dotenv ANTHROPIC_API_KEY=... OPENAI_API_KEY=... OPENROUTER_API_KEY=... # Pi default: OpenRouter GLM 5.2 GEMINI_API_KEY=... # or GEMINI_AUTH_TYPE=oauth-personal KIMI_MODEL_API_KEY=... # unless using mounted Kimi OAuth PI_PROVIDER=... # only for raw/custom Pi env auth outside the default credential PI_MODEL=... PI_API_KEY=... COPILOT_GITHUB_TOKEN=...

root@kitploit:~
फिर कंटेनर का निर्माण, प्रारंभ और सत्यापन करें:```bash
scripts/evals-container build
scripts/evals-container down || true
scripts/evals-container --env-file .env.container up
scripts/evals-container exec evals-tool-versions
scripts/evals-container exec quorum check

रैपर इस evals चेकआउट को /workspace/evals पर, पैरेंट Superpowers चेकआउट को /workspace/superpowers पर, और होस्ट results/ को /workspace/evals/results पर माउंट करता है। जब डिफ़ॉल्ट पैरेंट पथ परीक्षणाधीन सिस्टम नहीं है, तो --superpowers-root <dir> के साथ Superpowers चेकआउट को ओवरराइड करें।

इमेज बिल्ड को एक स्थानीय Gauntlet चेकआउट की आवश्यकता होती है। रैपर इसे GAUNTLET_ROOT या Bun ग्लोबल bun link इंस्टॉल से खोजता है; स्पष्ट रूप से चुनने के लिए build के साथ --gauntlet-root <dir> का उपयोग करें।

क्रेडेंशियल्स केवल-पढ़ने योग्य माउंट हैं। डिफ़ॉल्ट रूप से, up पहले .env.container, फिर .env का उपयोग करता है, और मिलने वाली पहली फ़ाइल को /run/evals/credentials.env पर माउंट करता है। स्पष्ट रूप से चुनने के लिए up से पहले --env-file <file> पास करें। रैपर होस्ट वातावरण को पूरी तरह से पास नहीं करता; केवल कंटेनर के अंदर quorum शिम dotenv फ़ाइल को स्रोत करता है, इसलिए scripts/evals-container exec bash ... स्वचालित रूप से लाइव eval क्रेडेंशियल्स प्राप्त नहीं करता। किसी मौजूदा कंटेनर पर env-file माउंट बदलने से पहले down का उपयोग करें।

OAuth/फ़ाइल auth स्रोत भी केवल-पढ़ने योग्य हैं। मौजूदा ~/.codex, ~/.gemini, ~/.kimi-code, और ~/.pi निर्देशिकाएँ /auth/codex, /auth/gemini, /auth/kimi-code, और /auth/pi पर माउंट होती हैं। किसी स्रोत को ओवरराइड करने के लिए --auth codex=<dir>, --auth gemini=<dir>, --auth kimi=<dir>, या --auth pi=<dir> का उपयोग करें।

सेंटिनल सुइट से शुरू करें:```bash scripts/evals-container exec quorum run-all
--tier sentinel
--coding-agents claude,codex,kimi
--jobs 4

for agent in gemini opencode pi copilot; do scripts/evals-container exec quorum run-all
--tier sentinel
--coding-agents "$agent"
--jobs 1 done

root@kitploit:~
पूर्ण तैयार सूट के लिए `--tier sentinel` के बिना वही कमांड चलाएं।
`run-all` प्रत्येक बैच को `results/batches/<batch-id>/` के अंतर्गत और प्रत्येक रन को
`results/<scenario>-<agent>-<os>-<timestamp>-<nonce>/` के अंतर्गत लिखता है; एक बैच को रेंडर करें
इसके साथ:```bash
scripts/evals-container exec quorum show <batch-id>

run-all एक आवधिक लाइवनेस हार्टबीट प्रिंट करता है (⋯ … · running N/jobs · done D · queued Q · [agent:scenario, …]); इसे --heartbeat-seconds <n> (0 निष्क्रिय करता है) से समायोजित करें। एक बैच को बाधित करना — Ctrl-C, या exec सत्र बंद होना — इसे सुचारू रूप से रोकता है: कतार रद्द कर दी जाती है, चल रहे रन SIGINT'd (और रुके हुए के रूप में रिकॉर्ड किए जाते हैं), और बैच फुटर अभी भी लिखा जाता है, इसलिए finished_at कभी null नहीं छोड़ा जाता।

कंटेनर रनटाइम Docker सॉकेट माउंट नहीं करता, डैशबोर्ड पोर्ट प्रकाशित नहीं करता, या डेस्कटॉप IDE शामिल नहीं करता। इमेज Antigravity के डेस्कटॉप agy इंस्टॉलर को छोड़ देती है; जब तक एक हेडलेस इंस्टॉल पथ नहीं है, Antigravity को होस्ट-साइड पर चलाएं:```bash bun run quorum run-all --coding-agents antigravity --jobs 1

root@kitploit:~
समूहबद्ध सभी-एजेंट होस्ट स्वीप, प्रति-एजेंट क्रेडेंशियल, प्रमाणीकरण माउंट विवरण,
और समस्या निवारण के लिए, [docs/coding-agent-care-and-feeding.md](https://github.com/prime-radiant-inc/superpowers-evals/blob/main/docs/coding-agent-care-and-feeding.md) का उपयोग करें।

## विंडोज रनटाइम

विंडोज 11 पर मूल्यांकन के लिए, `--os windows` का उपयोग करें (केवल Linux+KVM होस्ट):```bash
bun run quorum run scenarios/<name> --coding-agent claude --os windows

सेटअप और तैनाती के लिए docs/windows/eval-runtime.md देखें।

प्रामाणिक अभिनेता

अभिनेताओं को सीधा रखें; उन्हें भ्रमित करना सबसे आम ट्रायेज त्रुटि है। ये नाम हर जगह उपयोग किए जाते हैं — दस्तावेज़, CLI आउटपुट, कोड, फ़ाइलनाम, कमिट संदेश।

अभिनेतायह क्या हैयह कहाँ रहता है / इसकी फ़ाइलें
Gauntletसामान्य-उद्देश्य QA फ्रेमवर्क; gauntlet CLI. एक ब्लैक-बॉक्स परीक्षक।repo github.com/prime-radiant-inc/gauntlet; PATH पर gauntlet के रूप में (bun link या GAUNTLET_ROOT के माध्यम से)
Gauntlet-AgentGauntlet के अंदर का LLM जो Coding-Agent को चलाता है और कहानी के ACs के विरुद्ध स्व-ग्रेड करता है।मॉडल जैसे claude-sonnet-4-6; घटना स्ट्रीम → <run>/gauntlet-agent/results/<runId>/run.jsonl; फैसला → result.{json,md}
Coding-Agentपरीक्षण के तहत एजेंट — SUT। उदाहरण: Claude, Codex, Antigravity, Gemini, Kimi, OpenCode, Pi, Copilot।इसके अस्थायी $HOME के तहत कॉन्फ़िग + सत्र लॉग <run>/home/… पर; यह जो फ़ाइलें लिखता है → <run>/coding-agent-workdir/
QuorumTypeScript/Bun रैपर। सेटअप, Coding-Agent अनुकूलन, नियतात्मक जाँच, और अंतिम फैसले का मालिक है।repo superpowers-evals/src/; <run>/verdict.json

एक रन में दो LLMs शामिल होते हैं — Gauntlet-Agent (QA परीक्षक) और Coding-Agent (विषय)। अलग मॉडल, अलग लॉग, अलग टोकन लागत।

ऑपरेटर गाइड्स

  • docs/scenario-authoring.md - परिदृश्य शरीर रचना, कहानी/AC शिल्प, सेटअप सहायक, जाँच क्रियाएँ, और लेखन जाल।
  • docs/appliance-runbook.md - एजेंटों के लिए साझा दूरस्थ उपकरण संचालन नियम।
  • docs/coding-agent-care-and-feeding.md - क्रेडेंशियल्स, स्वीप, प्रति-एजेंट रनटाइम नोट्स, और समस्या निवारण।
  • docs/adding-a-coding-agent.md - नया एजेंट लक्ष्य, लॉन्चर, प्रावधानकर्ता, सामान्यीकरणकर्ता, और स्मोक जोड़ने के लिए चेकलिस्ट।
  • docs/superpowers/skills/triaging-a-failing-eval.md - गैर-पासिंग रन के लिए एट्रिब्यूशन एटलस।
  • docs/baselines/ - बैकएंड द्वारा वर्तमान ज्ञात-अच्छे बेसलाइन।

क्रेडेंशियल अक्ष

ईवल आयाम (परिदृश्य, कोडिंग-एजेंट, क्रेडेंशियल, os) है। रेपो रूट पर credentials.yaml नामित क्रेडेंशियल्स को परिभाषित करता है; प्रत्येक प्रविष्टि मॉडल, वायर प्रोटोकॉल (api: openai-chat, openai-responses, anthropic, या gemini), गैर-डिफ़ॉल्ट एंडपॉइंट के लिए वैकल्पिक base_url, प्रमाणीकरण प्रकार (api-key, subscription, या oauth), वैकल्पिक api_key_env, यह जिन रनटाइम परिवारों की सेवा करता है (harnesses), और वैकल्पिक शेड्यूलर ओवरराइड (max_concurrency, launch_spacing_seconds) और एक compat ब्लॉक (thinking_format, max_tokens_field) घोषित करता है।

प्रत्येक एजेंट YAML एक default_credential घोषित करता है। रनटाइम पर ओवरराइड करें:```bash

run against a named credential

bun run quorum run scenarios/ --coding-agent claude --credential sonnet

run-all against multiple credentials (incompatible cells are skipped)

bun run quorum run-all --coding-agents claude,opencode --credentials sonnet,haiku,opencode_gpt5 --jobs 4

root@kitploit:~
`quorum check` `credentials.yaml` और प्रत्येक एजेंट के `default_credential` को मान्य करता है।

शेड्यूलर अपनी समवर्ती सीमा (concurrency cap) और दर-सीमा लैच (rate-limit latch) को क्रेडेंशियल के **limiterKey** से जोड़ता है — क्रेडेंशियल का `base_url` यदि सेट हो, अन्यथा क्रेडेंशियल का नाम, उसके `api` से जुड़ा हुआ (जैसे `https://…/v1|openai-chat`, या `opus|anthropic` बिना `base_url` वाले मूल क्रेडेंशियल के लिए)। एक समान limiterKey साझा करने वाले सेल एक ही कैप और एक ही दर-सीमा लैच साझा करते हैं: किसी भी सेल पर दर-सीमा प्रतिक्रिया तुरंत उस एंडपॉइंट के सभी शेष कतारबद्ध सेल को छोड़ देती है।

मानक नामांकित क्रेडेंशियल्स (`credentials.yaml` देखें): `opus`, `sonnet`, `haiku` (क्लॉड हार्नेस), `codex_sub` (Codex सब्सक्रिप्शन), `kimi_default`, `openrouter_glm_5_2` (Pi डिफ़ॉल्ट), `pi_default` (मूल Pi OAuth वैकल्पिक), `opencode_gpt5`, `gemini_default`, `serf_default`, `glm_5_2_chat`, `glm_5_2_responses`, `ollama_local`।

### बाहरी Serf अभियान

अल्पकालिक Serf मॉडल/प्रदाता अभियान रिपॉजिटरी के विहित `credentials.yaml` के बजाय एक बाहरी क्रेडेंशियल फ़ाइल का उपयोग करते हैं। इसे `quorum run`, `quorum run-all`, या `quorum check` के साथ `--credentials-file` का उपयोग करके स्पष्ट रूप से पास करें। वास्तविक अभियान YAML और सभी कच्चे रन आर्टिफैक्ट को Git के बाहर रखें: YAML में रूटिंग लेबल और चयनित API-कुंजी पर्यावरण-चर का नाम होता है, कभी भी कुंजी मान नहीं।

प्रत्येक अभियान प्रीसेट को एक ही मॉडल और एक ही प्रदाता को पिन करना चाहिए, फ़ॉलबैक अक्षम करने चाहिए, और इसमें कोई प्रॉम्प्ट, सैंपलिंग, रीज़निंग, टूल, या टोकन-सीमा ओवरराइड नहीं होना चाहिए। अपनी समर्पित कुंजी विश्वसनीय रनटाइम क्रेडेंशियल बंडल के माध्यम से प्रदान करें। कुंजी को अभियान के इच्छित डेटा नीति को लागू करना चाहिए, एक अभियान खर्च सीमा होनी चाहिए, और साझा-क्षमता वाले अभियान के लिए, कोई BYOK बंधन नहीं होना चाहिए। एक BYOK तुलना एक अलग अभियान है जिसमें एक अलग कुंजी और उम्मीदवार फ़ाइल होती है।

प्रेषण से पहले, `run-all` बाहरी फ़ाइल को एक बार पार्स करता है और इसका विहित स्नैपशॉट `results/batches/<batch-id>/credentials.snapshot.yaml` पर लिखता है; प्रत्येक चाइल्ड को वह अपरिवर्तनीय स्नैपशॉट प्राप्त होता है। एक सीधा `quorum run` अपने रन निर्देशिका के अंतर्गत वही विहित स्नैपशॉट लिखता है। बैच शुरू होने के बाद स्रोत YAML को संपादित करने से बाद के सेल नहीं बदल सकते। स्नैपशॉट में स्कीमा-ज्ञात रूटिंग मेटाडेटा और पर्यावरण-चर के नाम होते हैं, गुप्त मान नहीं, लेकिन वे संवेदनशील रन आर्टिफैक्ट का हिस्सा बने रहते हैं।

पहले एजेंट-तटस्थ स्मोक चलाएँ, फिर केवल उन क्रेडेंशियल के लिए महँगा परिदृश्य चलाएँ जिनका अंतिम स्मोक फैसला `pass` है:```bash
quorum run-all \
  --scenarios 00-quorum-smoke-hello-world \
  --include-drafts \
  --coding-agents serf \
  --credentials-file /secure/campaign.yaml \
  --credentials serf_example_a \
  --jobs 1

quorum run-all \
  --scenarios serf-builder-fractals \
  --coding-agents serf \
  --credentials-file /secure/campaign.yaml \
  --credentials serf_example_a \
  --jobs 1

--jobs 1 अनुक्रमिक विलंबता/लागत आधार रेखा है। एक मैट्रिक्स सेल एक भुगतान प्रयास है; अभियान शेड्यूलर स्वचालित रूप से किसी सेल को पुनः प्रयास या दोहराता नहीं है। लेबल किए गए तुलना को quorum costs <batch-id> के साथ प्रस्तुत करें। केवल अंतिम pass पंक्तियों को तुलनीय चिह्नित किया जाता है; fail और indeterminate दिखाई देते रहते हैं लेकिन अश्रेणीबद्ध रहते हैं, और लापता माप शून्य के बजाय लापता के रूप में प्रस्तुत होते हैं। चार्ज, अनुमानित और डेल्टा कॉलम कोडिंग-एजेंट लागतें हैं। मौजूदा --with-gauntlet कॉलम अलग गौंटलेट-एजेंट हार्नेस ओवरहेड हैं।

लाइव स्वीकृति मैन्युअल विश्वसनीय-अनुरक्षक कार्य है, कभी सार्वजनिक CI ऑटोमेशन नहीं:

  1. --jobs 1 के साथ एक ज्ञात-अच्छा हैलो-वर्ल्ड सेल चलाएं।
  2. verdict.json, trajectory.json, openrouter-generations.json, coding-agent-token-usage.json, और quorum costs <batch-id> का निरीक्षण करें। मॉडल, प्रदाता, प्रीसेट संस्करण, BYOK गलत है, टोकन/कैश बकेट, अवधि, चार्ज की गई लागत, अनुमान, डेल्टा, और उम्मीदवार लेबल की पुष्टि करें, जिसमें क्वांटाइज़ेशन और कैटलॉग तिथि शामिल है।
  3. --jobs 1 के साथ एक Fractals सेल चलाएं; अंतिम pass, प्रत्येक निर्धारणात्मक जांच, प्रतिबद्ध मुख्य-चेकआउट वितरण, और एक पूर्ण तुलना पंक्ति की आवश्यकता है।
  4. --jobs 2 के साथ दो हैलो-वर्ल्ड उम्मीदवार चलाएं; कोई क्रॉस-संदूषित कुंजी, पीढ़ी, लेबल या अर्थशास्त्र न होने के साथ अलग आरोपण की पुष्टि करें।
  5. तभी प्रति स्मोक-पासिंग उम्मीदवार एक अनुक्रमिक Fractals सेल चलाएं।

केवल रिलीज़-समीक्षित, स्वच्छ निष्कर्षों को दिनांकित docs/experiments/ नोट में प्रकाशित करें, विफलताओं के साथ-साथ सफलताओं को भी रिकॉर्ड करें। बाहरी अभियान YAML और कच्ची कलाकृतियाँ Git के बाहर रहती हैं।

मुख्य कमांड```bash

bun run quorum list bun run quorum new my-new-scenario bun run quorum check my-new-scenario bun run quorum run scenarios/ --coding-agent bun run quorum run scenarios/ --coding-agent claude --credential sonnet bun run quorum run-all --coding-agents claude,codex --jobs 2 bun run quorum run-all --coding-agents claude --credentials sonnet,haiku --jobs 2 bun run quorum show bun run quorum costs

root@kitploit:~
`quorum check` with no arguments validates every scenario and `credentials.yaml`.
`run-all` runs every included scenario against every selected Coding-Agent,
filtered by each scenario's `# coding-agents:` directive.

## Verdicts And Artifacts

quorum produces a three-valued verdict:

- `pass` - Gauntlet-Agent passed and every post-check passed.
- `fail` - Gauntlet-Agent failed, or a post-check failed.
- `indeterminate` - setup/pre-check/capture/quorum failure, Gauntlet
  `investigate`, or empty trace when trace checks are present.

Exit codes are 0 for `pass`, 1 for `fail`, and 2 for `indeterminate`.

Each run produces one directory under `results/`:```text
results/<scenario>-<coding-agent>-<os>-<timestamp>-<nonce>/
|-- verdict.json                     composed result; start here
|-- gauntlet-agent/                  Gauntlet-Agent evidence
|-- coding-agent-workdir/            files the Coding-Agent produced
|-- home/                            throwaway Coding-Agent HOME
|-- trajectory.json                  normalized ATIF trace
`-- coding-agent-token-usage.json    Coding-Agent token cost, when priced

results/ को gitignore किया गया है क्योंकि रन आर्टिफैक्ट्स में संवेदनशील ट्रांसक्रिप्ट, क्रेडेंशियल्स, टूल कॉल्स और फ़ाइलसिस्टम स्थिति हो सकती है।

सुरक्षित जाँचें

ये वे जाँचें हैं जो CI और नियमित PRs पर अपेक्षित हैं:```bash bun run check # biome ci . && tsc --noEmit && bun test — the full gate bun run quorum check # validate every scenario directory

root@kitploit:~
`bun run check` एक एकल गेट है (Biome lint/format + full-strict `tsc` +
`bun test`); अलग-अलग चरण हैं `bun run lint`, `bun run typecheck`, और
`bun test`.

## आर्किटेक्चर

quorum **Bun पर TypeScript** है। कंसोल `bun run quorum <cmd>` है (एक
[commander](https://github.com/tj/commander.js) CLI `src/cli/index.ts` पर, जो
`quorum` bin के रूप में भी उपलब्ध है); गेट `bun run check` है
(Biome + full-strict `tsc` + `bun test`).

प्रक्रिया और फ़ाइल सीमाओं को पार करने वाले आकार — `verdict.json`, बैच
इंडेक्स, अर्थशास्त्र, Gauntlet परिणाम, एजेंट YAML — `src/contracts/` में **zod schemas** हैं,
हर सीमा पर मान्य किए जाते हैं, ताकि एक विकृत बाहरी फ़ाइल
किसी verdict को भ्रष्ट करने के बजाय ज़ोर से विफल हो जाए। `cli/` लेयर कमांड पार्स करती है
और उन्हें `runner/` पाइपलाइन (एक परिदृश्य × एक Coding-Agent) या
`run-all/` (मैट्रिक्स) में भेजती है। प्रति Coding-Agent अंतर दो समानांतर
फैन-आउट में रहते हैं जो एजेंट नाम से कुंजीबद्ध हैं: `agents/` एजेंट के कॉन्फ़िग को
प्रति-रन थ्रोअवे `$HOME` (`<run>/home`) के तहत सीड करता है, और `normalize/` उस एजेंट के
सत्र लॉग को एक समान टूल-कॉल ट्रेस में बदलता है। लाइव एजेंट-CLI कॉल और अन्य
गैर-हर्मेटिक उपप्रक्रियाएँ `agents/command-runner.ts` सीम के माध्यम से जाती हैं,
इसलिए यूनिट सूट नकली इंजेक्ट करता है और कभी वास्तविक CLI लॉन्च नहीं करता। `scheduler/`
`run-all/` के तहत साझा समवर्ती इंजन है। डैशबोर्ड एक अलग केवल-पढ़ने वाला पैकेज है जो `results/`
और `grid-manifest.json` को स्कैन करता है। `env.ts` एकमात्र मॉड्यूल है जो `process.env` पढ़ता है।```text
src/
  cli/                  commander CLI: run, list, new, check, show, costs, run-all, grid-manifest
    index.ts              command wiring + run / costs / run-all / grid-manifest actions
    render.ts             verdict renderer for triage (quorum show)
    render-batch.ts       batch-matrix renderer (quorum show <batch>)
    resolve-target.ts     run/batch target resolution; scenario.ts scenario loading
  runner/               per-run orchestration (one scenario × one Coding-Agent)
    index.ts              setup → pre-checks → gauntlet drive → capture → post-checks → compose
    context.ts            populate the Gauntlet-Agent context dir (HOWTO + launch-agent shim)
    phase.ts              phase.json (setup/agent/checks) for the dashboard
    stopped.ts            SIGINT → stopped (indeterminate) verdict; errors.ts staged run-error stages
  agents/               per-Coding-Agent provisioning (resolveAgent dispatch)
    index.ts              agent registry + dispatch (incl. the inline Claude/Default adapters)
    command-runner.ts     injectable subprocess seam (live CLIs faked in tests)
    <agent>.ts            codex/gemini/kimi/opencode/pi/copilot/antigravity adapters
  normalize/            session-log → normalized tool-call trace, one module per dialect
  capture/              session-log snapshot/diff + tool-call capture + token usage; cwd-filter
  obol/                 obol cost estimation (session-log + gauntlet sidecar)
  economics.ts          token-cost composition → coding-agent-token-usage.json
  composer.ts           three-valued verdict from the gauntlet + checks layers
  checks/               sources prelude.sh + checks.sh, runs pre()/post(), collects check records
    prelude.sh            bare-verb DSL: defines each check verb as a bash function that
                          delegates to the TS dispatchers (no bin/ shims, no PATH prepend)
  scheduler/            central concurrency dispatcher (one global slot pool, per-harness limits + spacing)
  run-all/              scenario × Coding-Agent matrix over the scheduler; batch index
  setup-helpers/        scenario fixture builders + the `setup-helpers` CLI (dispatch registry)
  contracts/            zod schemas at the JSON boundaries (verdict, batch, economics, gauntlet, agent-config)
  scaffold.ts           `quorum new` / `quorum check`
  setup-step.ts         runs scenario setup.sh (sources prelude.sh via BASH_ENV so bare verbs resolve)
  story-meta.ts         story.md frontmatter (quorum_max_time, quorum_tier, status)
  env.ts                the single process.env boundary
  paths.ts              repo root, UTC stamps, nonces
  invariant.ts          assertNever exhaustiveness guard for closed unions
  check/                typed check verbs: fs-verbs.ts (file/git/env + bootstrap),
                        dispatch.ts (table + `not`), transcript-dispatch.ts, record.ts (sole emitter)
  cli/check-tool.ts     the dispatcher behind every check verb function (file-exists,
                        file-contains, command-succeeds, git-*, assert-checkout-clean,
                        requires-tool, not, files-exist, the *-installed/hook/extension
                        checks); check-transcript.ts and setup-helpers/cli.ts are the
                        other two dispatchers the prelude delegates to
  cli/list-check-verbs.ts  prints the FS_VERBS verb set the prelude loops over (drift-proof)
coding-agents/          per-Coding-Agent material:
  <name>.yaml             CLI config
  <name>-context/         HOWTO prose and launchers for the Gauntlet-Agent
scenarios/              scenarios (one directory each)
fixtures/               shared static fixture repos (e.g. template-repo/, sdd-*/)
test/                   bun test suite
docs/                   design notes, specs, plans, testing protocols, baselines
packages/dashboard/     read-only web matrix UI: scan/view, typed HTML templates, SSE bus, Bun.serve

त्रैज

एक असफल रन की त्रैज करना इससे शुरू होता है:```bash bun run quorum show []

root@kitploit:~
फिर [docs/superpowers/skills/triaging-a-failing-eval.md](https://github.com/prime-radiant-inc/superpowers-evals/blob/main/docs/superpowers/skills/triaging-a-failing-eval.md) का उपयोग करें  
एट्रिब्यूशन एटलस के लिए। एजेंट-विशिष्ट प्रमाणीकरण, प्रावधान और कैप्चर  
जाँचों के लिए, [docs/coding-agent-care-and-feeding.md](https://github.com/prime-radiant-inc/superpowers-evals/blob/main/docs/coding-agent-care-and-feeding.md) का उपयोग करें।

वर्तमान ज्ञात-अच्छा बेसलाइन देखने के लिए, [docs/baselines/](https://github.com/prime-radiant-inc/superpowers-evals/blob/main/docs/baselines) देखें।

## योगदान नियम

यह रिपॉजिटरी `superpowers` के गुणवत्ता मानक को प्राप्त करती है।

- प्रति PR एक समस्या।
- उत्पन्न रन आर्टिफैक्ट्स या सीक्रेट्स को कमिट न करें।
- सार्वजनिक CI में लाइव इवैल्स न जोड़ें।
- PR टेम्पलेट का उपयोग करें और उन परिवर्तनों के लिए सुरक्षा/इवैल-लैब जोखिम समझाएं जो  
  Coding-Agent कॉन्फिग्स, शेल निष्पादन, सेटअप हेल्पर्स, चेक टूल्स, या  
  Gauntlet-Agent इनपुट को छूते हैं।
- व्यवहार-आकार देने वाली इवैल पद्धति में परिवर्तनों के लिए सिर्फ गद्य नहीं, बल्कि सबूत चाहिए।

## पैरेंट सबमॉड्यूल बंप

`superpowers-evals` को `superpowers` द्वारा `evals` सबमॉड्यूल के रूप में उपभोग किया जाता है।  
यहाँ `main` में कोई PR मर्ज होने के बाद, पैरेंट `superpowers` रिपॉजिटरी में `dev` को लक्षित करते हुए एक अनुवर्ती PR खोलें जो `evals` सबमॉड्यूल पॉइंटर को मर्ज किए गए `superpowers-evals` कमिट पर बंप करता है।

`superpowers-evals` मर्ज को पूरी तरह प्रचारित न मानें जब तक वह पैरेंट सबमॉड्यूल बंप PR मौजूद न हो।

---

सुरक्षा रिपोर्टिंग → [SECURITY.md](https://github.com/prime-radiant-inc/superpowers-evals/blob/main/SECURITY.md).
टूल डाउनलोड करें