IronCurtain

स्वायत्त AI एजेंटों के लिए एक सुरक्षित* रनटाइम, जहाँ सुरक्षा नीति एक मानव-पठनीय संविधान से व्युत्पन्न होती है।

*जब कोई "secure" लिखता है, तो आपको तुरंत संदेह होना चाहिए। हमारा secure से क्या अभिप्राय है?

[!WARNING] शोध प्रोटोटाइप। IronCurtain एक प्रारंभिक चरण की शोध परियोजना है जो यह पता लगाती है कि AI एजेंटों को इतना सुरक्षित कैसे बनाया जाए कि वे वास्तव में उपयोगी हों। APIs, कॉन्फ़िगरेशन प्रारूप और आर्किटेक्चर बदल सकते हैं। योगदान और प्रतिक्रिया का स्वागत है।

डेमो

एजेंट को एक रिपॉज़िटरी क्लोन करने और परिवर्तन पुश करने के लिए कहा गया है। git_clone और git_push दोनों को नीति इंजन द्वारा उच्च-स्तरीय (escalated) किया जाता है, लेकिन स्वतः-अनुमोदक (auto-approver) उन्हें स्वचालित रूप से स्वीकृत कर देता है — कमांड मोड (Ctrl-A) से उपयोगकर्ता के विश्वसनीय इनपुट ने स्पष्ट इरादा प्रदान किया था, इसलिए किसी मैन्युअल /approve की आवश्यकता नहीं थी।

समस्या

स्वायत्त AI एजेंट आपकी ओर से फ़ाइलों को प्रबंधित कर सकते हैं, git कमांड चला सकते हैं, संदेश भेज सकते हैं और APIs के साथ इंटरैक्ट कर सकते हैं। लेकिन आज के एजेंट फ्रेमवर्क एजेंट को उपयोगकर्ता के समान विशेषाधिकार देते हैं, जैसे फ़ाइल सिस्टम, क्रेडेंशियल्स और नेटवर्क तक पूर्ण पहुँच। सुरक्षा शोधकर्ता इसे परिवेशी अधिकार (ambient authority) कहते हैं, और इसका अर्थ है कि एक एकल प्रॉम्प्ट इंजेक्शन या बहु-टर्न भटकाव (multi-turn drift) एजेंट को फ़ाइलें हटाने, डेटा बाहर भेजने या दुर्भावनापूर्ण कोड पुश करने का कारण बन सकता है।

सामान्य प्रतिक्रिया यह है कि या तो एजेंट को एक संकीर्ण सैंडबॉक्स तक सीमित कर दिया जाए (जिससे उनकी उपयोगिता सीमित हो जाती है) या उपयोगकर्ता से हर कार्य को अनुमोदित करने के लिए कहा जाए (जिससे उनकी स्वायत्तता सीमित हो जाती है)। इनमें से कोई भी संतोषजनक नहीं है।

दृष्टिकोण

IronCurtain एक अलग रास्ता अपनाता है: अपने सुरक्षा इरादे को सरल अंग्रेजी में व्यक्त करें, फिर सिस्टम को प्रवर्तन (enforcement) का पता लगाने दें।

आप एक संविधान (constitution) लिखते हैं, जो एक छोटा दस्तावेज़ है जो बताता है कि आपका एजेंट क्या कर सकता है और क्या नहीं। IronCurtain इसे LLM पाइपलाइन का उपयोग करके एक नियतात्मक (deterministic) सुरक्षा नीति में संकलित करता है, उत्पन्न परीक्षण परिदृश्यों के विरुद्ध संकलित नियमों को मान्य करता है, और फिर रनटाइम पर हर टूल कॉल पर नीति को लागू करता है। परिणाम एक ऐसा एजेंट है जो आपके द्वारा प्राकृतिक भाषा में परिभाषित सीमाओं के भीतर स्वायत्त रूप से काम कर सकता है।

मुख्य विचार:

• एजेंट अविश्वसनीय है। IronCurtain मानता है कि LLM प्रॉम्प्ट इंजेक्शन या भटकाव से समझौता हो सकता है। सुरक्षा मॉडल के "अच्छा होने" पर निर्भर नहीं करती।
• अंग्रेजी इनपुट, प्रवर्तन आउटपुट। आप इरादा लिखते हैं ("अनुमोदन के बिना कोई विनाशकारी git ऑपरेशन नहीं"); सिस्टम इसे नियतात्मक नियमों में संकलित करता है जो रनटाइम पर आगे LLM भागीदारी के बिना लागू होते हैं।
• सिमेंटिक इंटरपोज़िशन। एजेंट को कच्चा सिस्टम एक्सेस देने के बजाय, सभी इंटरैक्शन MCP सर्वरों (filesystem, git, आदि) से होकर गुजरते हैं। हर टूल कॉल एक नीति इंजन से गुजरती है जो अनुमति दे सकता है, अस्वीकार कर सकता है, या अनुमोदन के लिए उपयोगकर्ता के पास बढ़ा सकता है (escalate)।
• गहराई में सुरक्षा (defense in depth)। एजेंट कोड होस्ट तक सीधी पहुँच के बिना V8 आइसोलेट में चलता है। बाहर निकलने का एकमात्र रास्ता सिमेंटिक रूप से सार्थक MCP टूल कॉल है, और हर एक की जाँच नीति के विरुद्ध की जाती है।

आर्किटेक्चर

IronCurtain दो सत्र मोड का समर्थन करता है जिनमें अलग-अलग विश्वास मॉडल होते हैं:

• बिल्ट-इन एजेंट (कोड मोड) — IronCurtain का अपना LLM एजेंट TypeScript स्निपेट लिखता है जो V8 सैंडबॉक्स में निष्पादित होते हैं। IronCurtain एजेंट, सैंडबॉक्स और नीति इंजन को नियंत्रित करता है। हर टूल कॉल सैंडबॉक्स से एक संरचित MCP अनुरोध के रूप में बाहर निकलती है, नीति इंजन (allow / deny / escalate) से गुजरती है, और उसके बाद ही वास्तविक MCP सर्वर तक पहुँचती है।

• Docker एजेंट मोड — एक बाहरी एजेंट (Claude Code, Goose, आदि) नेटवर्क पहुँच के बिना एक Docker कंटेनर के अंदर चलता है। IronCurtain बाहरी प्रभावों की मध्यस्थता करता है: LLM API कॉल एक TLS-समाप्त करने वाले MITM प्रॉक्सी (होस्ट allowlist, नकली-से-वास्तविक कुंजी स्वैप) से गुजरते हैं, MCP टूल कॉल उसी नीति इंजन से गुजरते हैं, और पैकेज इंस्टॉलेशन (npm/PyPI) एक सत्यापनकारी रजिस्ट्री प्रॉक्सी से होकर जाते हैं।

दोनों मोड में, एजेंट अविश्वसनीय है। सुरक्षा मॉडल के निर्देशों का पालन करने पर निर्भर नहीं करती — इसे सीमा पर लागू किया जाता है।

पूर्ण आर्किटेक्चर के लिए आरेख, परत-दर-परत विश्वास विश्लेषण और macOS प्लेटफ़ॉर्म नोट्स के साथ SANDBOXING.md देखें।

त्वरित प्रारंभ

पूर्वापेक्षाएँ

• Node.js 22, 24, या 26 — वे सम-क्रमांकित प्रमुख लाइनें जिनका IronCurtain परीक्षण करता है (isolated-vm के लिए आवश्यक; 24 और 26 प्रीबिल्ट बाइनरी स्थापित करते हैं, Node 22 स्थापना पर स्रोत से संकलित होता है और उसे C/C++ टूलचेन की आवश्यकता होती है)। विषम-क्रमांकित लाइनें (23, 25) चलती हैं लेकिन परीक्षण नहीं की गई हैं — ironcurtain doctor चेतावनी देता है।
• Docker — आवश्यक नहीं है लेकिन अत्यधिक अनुशंसित है Docker एजेंट मोड के लिए, जो सबसे मजबूत अलगाव प्रदान करता है। macOS 26+ (Apple silicon) पर, Apple container एक वैकल्पिक बैकएंड के रूप में काम करता है (प्रति कंटेनर VM; इसकी सेवाएँ चल रही हों तो स्वचालित रूप से उपयोग होता है — ironcurtain config में containerRuntime देखें)
• कम से कम एक LLM प्रदाता (Anthropic, Google, या OpenAI) के लिए एक API कुंजी

स्थापना

वैश्विक CLI उपकरण के रूप में (अंतिम उपयोगकर्ता):```bash npm install -g @provos/ironcurtain

**स्रोत से (विकास):**```bash
git clone https://github.com/provos/ironcurtain.git
cd ironcurtain
npm install

एकमुश्त सेटअप

1. अपनी API कुंजी सेट करें:```bash export ANTHROPIC_API_KEY=sk-ant-...

आप कुंजियों को प्रोजेक्ट रूट में `.env` फ़ाइल में भी रख सकते हैं (`dotenv` के माध्यम से स्वचालित रूप से लोड होता है), या `ironcurtain config` के माध्यम से `~/.ironcurtain/config.json` में जोड़ सकते हैं। पर्यावरण चर कॉन्फ़िग फ़ाइल मानों पर प्राथमिकता लेते हैं। समर्थित: `ANTHROPIC_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY`, `OPENAI_API_KEY`।

**2. प्रथम-प्रारंभ विज़ार्ड चलाएँ** (अनुशंसित mux पथ का उपयोग करने से पहले इसे स्पष्ट रूप से चलाएँ; यह पहले गैर-mux `ironcurtain start` पर स्वचालित रूप से भी चलता है):```bash
ironcurtain setup

आपको GitHub टोकन सेटअप, वेब खोज प्रदाता, मॉडल चयन और अन्य सेटिंग्स के माध्यम से मार्गदर्शन करता है। आपकी पसंद के साथ ~/.ironcurtain/config.json बनाता है।

IronCurtain चलाना

IronCurtain डेवलपर अनुभव को ध्यान में रखकर तैयार की गई एक डिफ़ॉल्ट नीति के साथ आता है — रीड-ओनली ऑपरेशन की अनुमति है, परिवर्तनकारी क्रियाएँ (राइट, पुश, PR निर्माण) मानवीय अनुमोदन के लिए आगे बढ़ाई जाती हैं। आप सेटअप के तुरंत बाद इसका उपयोग शुरू कर सकते हैं।

टर्मिनल मल्टीप्लेक्सर (अनुशंसित)

IronCurtain का उपयोग करने का अनुशंसित तरीका। यह आपको आपके एजेंट के इंटरैक्टिव TUI (Claude Code या Goose) की पूरी क्षमता प्रदान करता है, जबकि IronCurtain अपने पॉलिसी इंजन के माध्यम से प्रत्येक टूल कॉल की मध्यस्थता करता है — सब कुछ एक ही टर्मिनल में।```bash ironcurtain mux

**मुख्य क्षमताएँ:**

- **पूर्ण एजेंट TUI** — एजेंट बिना नेटवर्क एक्सेस के एक Docker कंटेनर के अंदर PTY में चलता है। आप इसके साथ ठीक वैसे ही इंटरैक्ट करते हैं जैसे यह स्थानीय रूप से चल रहा हो।
- **इनलाइन एस्केलेशन हैंडलिंग** — जब किसी टूल कॉल को अनुमोदन की आवश्यकता होती है, तो एक एस्केलेशन पिकर सिंगल-की एक्शन (a/d/w: अनुमोदन/अस्वीकार/व्हाइटलिस्ट के लिए) के साथ व्यूपोर्ट पर ओवरले होता है। बाकी सत्र के लिए किसी डोमेन या पथ को व्हाइटलिस्ट करने के लिए `/approve+ N` का उपयोग करें।
- **विश्वसनीय उपयोगकर्ता इनपुट** — कमांड मोड (Ctrl-A) में टाइप किया गया टेक्स्ट कंटेनर में प्रवेश करने से पहले होस्ट पक्ष पर कैप्चर किया जाता है। यह एक सत्यापित इरादा सिग्नल बनाता है जिसका उपयोग ऑटो-अप्रूवर कर सकता है — जैसे, "मेरे बदलावों को origin पर पुश करें" टाइप करने से बाद के `git_push` एस्केलेशन को स्वतः अनुमोदित कर दिया जाएगा।
- **टैब प्रबंधन** — एकाधिक समवर्ती सत्र बनाएँ (`/new`), उनके बीच स्विच करें (`/tab N`, Alt-1..9), उन्हें बंद करें (`/close`)। कई mux इंस्टेंस समानांतर में चल सकते हैं।

पूर्ण वॉकथ्रू के लिए [DEVELOPER_GUIDE.md](https://github.com/provos/ironcurtain/blob/HEAD/DEVELOPER_GUIDE.md) देखें: इनपुट मोड, विश्वसनीय इनपुट सुरक्षा मॉडल, एस्केलेशन वर्कफ़्लो, और कीबोर्ड संदर्भ।

### गैर-mux सत्र

त्वरित एक-शॉट कार्यों, स्क्रिप्ट्स, या जब आप स्पष्ट रूप से स्थानीय अंतर्निहित एजेंट चाहते हैं, तो `ironcurtain start` का उपयोग करें। सामान्य इंटरैक्टिव Docker-एजेंट कार्य के लिए, `ironcurtain mux` का उपयोग करें।```bash
ironcurtain start "Summarize the files in ./src"     # Single-shot mode
ironcurtain start -w ./my-project "Fix the tests"    # Single-shot workspace mode
ironcurtain start --agent builtin                    # Local builtin REPL, no Docker
ironcurtain start --persona my-assistant "Check my email"  # Use a persona

अन्य रनिंग मोड

IronCurtain सत्र पुनः आरंभ (--resume <session-id>), एक विरासत रॉ PTY/डीबग मोड, मोबाइल अनुमोदन के लिए एक Signal मैसेजिंग ट्रांसपोर्ट, और निर्धारित cron कार्यों के लिए एक डेमन मोड का भी समर्थन करता है। डेमन में ब्राउज़र-आधारित निगरानी और एस्केलेशन हैंडलिंग के लिए एक वैकल्पिक web UI (--web-ui) है। विवरण के लिए RUNNING_MODES.md देखें।

मल्टी-एजेंट वर्कफ़्लो

IronCurtain संरचित वर्कफ़्लो के माध्यम से कई AI एजेंटों का समन्वय करता है। बंडल किया गया vulnerability discovery वर्कफ़्लो libFuzzer/AFL++ कवरेज गेटिंग, परिकल्पना-संचालित discover/triage अवस्थाओं और एक अंतिम मानव रिपोर्ट-समीक्षा गेट के साथ एक स्तरीकृत हार्नेस पाइपलाइन (Tier 1 पृथक फ़ंक्शन → Tier 2 बहु-घटक → Tier 3 पूर्ण बिल्ड) के माध्यम से नेटिव कोड में मेमोरी-सुरक्षा और लॉजिक बग्स की खोज करता है। design-and-code वर्कफ़्लो योजना / डिज़ाइन / कार्यान्वयन / समीक्षा चक्र चलाता है, जिसमें भी मानव गेट शामिल हैं। प्रत्येक एजेंट भूमिका-विशिष्ट पॉलिसी सीमाओं के साथ अपने स्वयं के Docker कंटेनर में चलता है; इंजन स्थिति संक्रमण, आर्टिफैक्ट पासिंग और क्रैश-रिज़्यूम चेकपॉइंटिंग को स्वचालित रूप से प्रबंधित करता है। ओपन सोर्स, पूरी तरह से आपकी मशीन पर चलता है, संविधान-आधारित पॉलिसी इंजन के माध्यम से प्रति-एजेंट सुरक्षा नीतियों को लागू करता है, और किसी भी Docker-कंटेनरीकृत एजेंट के साथ काम करता है — कोडिंग कार्यों के लिए Amazon Kiro और Google Jules के दायरे में तुलनीय, लेकिन प्रथम श्रेणी की सुरक्षा और एक विस्तार योग्य वर्कफ़्लो परिभाषा प्रारूप के साथ।

वेब UI वर्कफ़्लो रन के लिए अभीष्ट इंटरफ़ेस है। डेमन प्रारंभ करें, मुद्रित URL खोलें, और Workflows पृष्ठ से रन संचालित करें — ऊपर दिया गया स्टेट-मशीन ग्राफ़ लाइव है, एजेंट-संदेश टाइमलाइन मार्कडाउन रेंडरिंग के साथ स्ट्रीम होती है, गेट समीक्षाओं में एक वर्कस्पेस + आर्टिफैक्ट ब्राउज़र शामिल होता है, और पिछले रन सूचीबद्ध रहते हैं।```bash ironcurtain daemon --web-ui

स्क्रिप्टिंग, स्वचालन और डिबगिंग के लिए CLI एक्सेस उपलब्ध है:```bash
ironcurtain workflow start vuln-discovery \
  "Find memory-safety bugs in libical" --workspace ~/src/libical
ironcurtain workflow start design-and-code \
  "Build a REST API with authentication"

पूर्ण दस्तावेज़ीकरण के लिए WORKFLOWS.md देखें।

अपनी नीति को अनुकूलित करना

डिफ़ॉल्ट नीति सामान्य विकास के लिए अच्छी तरह काम करती है, लेकिन आप इसे अपने कार्यप्रवाह के अनुसार अनुकूलित कर सकते हैं:

1. अपना संविधान अनुकूलित करें (वैकल्पिक लेकिन अनुशंसित):```bash ironcurtain customize-policy

एक LLM-सहायता प्राप्त वार्तालाप जो आपके कार्यप्रवाह के अनुरूप एक संविधान तैयार करता है, जिसे `~/.ironcurtain/constitution-user.md` में सहेजा जाता है। आप इस फ़ाइल को सीधे संपादित भी कर सकते हैं।

**2. नीति संकलित करें:**```bash
ironcurtain compile-policy

Translates your constitution into deterministic rules, generates test scenarios, and verifies them. Compiled artifacts go to ~/.ironcurtain/generated/.

Personas

Personas are named policy profiles — each bundles a constitution, compiled policy, persistent workspace, and semantic memory. Use them to run agents with different roles or access levels.```bash ironcurtain persona create my-assistant # Create a persona ironcurtain persona compile my-assistant # Compile its policy ironcurtain start --persona my-assistant "Check my calendar"

मक्स मोड में, `/new my-assistant` उस पर्सोना का उपयोग करके एक टैब बनाता है। पर्सोना को क्रॉन जॉब्स से भी जोड़ा जा सकता है। अनुसूचित जॉब कॉन्फ़िगरेशन के लिए [DAEMON.md](https://github.com/provos/ironcurtain/blob/HEAD/DAEMON.md) देखें।

पर्सोना को [वेब UI](https://github.com/provos/ironcurtain/blob/HEAD/DAEMON.md#persona-policy-management) से भी प्रबंधित किया जा सकता है — ब्राउज़ करें, संविधान बनाएँ, संपादित करें, और लाइव प्रगति के साथ नीतियों को संकलित करें। चूँकि नीति एक सुरक्षा सीमा है, वेब UI के परिवर्तन नियंत्रण केवल-पठनीय होते हैं, जब तक कि डेमन को `--allow-policy-mutation` के साथ प्रारंभ न किया जाए (डिफ़ॉल्ट रूप से बंद)।

### कौशल

`~/.ironcurtain/skills/<name>/` के अंतर्गत SKILL.md पैकेज रखें ताकि उद्देश्य-विशिष्ट मार्गदर्शन (सहायक स्क्रिप्ट, नियतात्मक जाँच, डोमेन ज्ञान) हर Docker एजेंट सत्र के लिए उपलब्ध हो सके। विलयित सेट को प्रति-बंडल होस्ट निर्देशिका में रखा जाता है और सक्रिय एजेंट की native discovery जिस पथ को स्कैन करती है, उसी पथ पर कंटेनर में **केवल-पठनीय** bind-mount किया जाता है — Claude Code को `--add-dir` के माध्यम से स्टेजिंग निर्देशिका की ओर इंगित किया जाता है, Goose `~/.config/goose/skills/<name>/SKILL.md` को स्कैन करता है। एजेंट उन्हें स्वचालित रूप से खोज लेता है और प्रत्येक कौशल के frontmatter विवरण के आधार पर तय करता है कि उन्हें कब पढ़ना है। SKILL.md का _प्रारूप_ Claude Code, Goose और Codex द्वारा अपनाया गया खुला मानक है; केवल _खोज पथ_ प्रत्येक एजेंट के अनुसार भिन्न होता है। वर्कफ़्लो अपने पैकेज के भीतर प्रति-अवस्था कौशल शामिल कर सकते हैं — [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/HEAD/WORKFLOWS.md#skills) देखें।

## नीति: संविधान → प्रवर्तन

आप सरल अंग्रेज़ी में अपना इरादा लिखते हैं; IronCurtain इसे नियतात्मक नियमों में संकलित करता है:```
constitution.md → [Annotate] → [Compile] → [Resolve Lists] → [Generate Scenarios] → [Verify & Repair]
                      │              │              │                  │                     │
                      ▼              ▼              ▼                  ▼                     ▼
              tool-annotations  compiled-policy  dynamic-lists   test-scenarios       verified policy
                  .json            .json            .json            .json          (or build failure)

1. Annotate — प्रत्येक MCP टूल के तर्कों को भूमिका (read-path, write-path, delete-path, none) के अनुसार वर्गीकृत करें।
2. Compile — अंग्रेज़ी में लिखे संविधान को नियतात्मक if/then नियमों में रूपांतरित करें। श्रेणीगत संदर्भों ("प्रमुख समाचार साइटें", "मेरे संपर्क") को @list-name प्रतीकात्मक संदर्भों के रूप में आउटपुट किया जाता है।
3. Resolve Lists — प्रतीकात्मक सूचियों को LLM ज्ञान या MCP टूल-उपयोग के माध्यम से ठोस मानों में हल करें (उदा., संपर्क डेटाबेस क्वेरी करना)। dynamic-lists.json में लिखा जाता है, उपयोगकर्ता-संपादन योग्य। जब कोई सूची मौजूद न हो तो छोड़ दिया जाता है।
4. Generate Scenarios — संविधान से परीक्षण परिदृश्य बनाएं, साथ ही अनिवार्य हस्तलिखित इनवेरिएंट परीक्षण भी।
5. Verify & Repair — परिदृश्यों को वास्तविक पॉलिसी इंजन के विरुद्ध चलाएं। एक LLM जज विफलताओं का विश्लेषण करता है और लक्षित मरम्मत उत्पन्न करता है (अधिकतम 2 राउंड)। यदि पॉलिसी सत्यापित नहीं की जा सकती तो बिल्ड विफल हो जाता है।

सभी आर्टिफैक्ट content-hash के आधार पर कैश किए जाते हैं — केवल बदले गए इनपुट पुनर्संकलन को ट्रिगर करते हैं।

संकलित नियम कैसे दिखते हैं

एक संविधान खंड जैसे:```markdown

• The agent may perform read-only git operations (status, diff, log) within the sandbox without approval.
• The agent must receive human approval before git push, pull, fetch, or any remote-contacting operation.

संकलित होता है:```json
[
  { "tool": "git_status", "decision": "allow", "condition": { "directory": { "within": "$SANDBOX" } } },
  { "tool": "git_diff", "decision": "allow", "condition": { "directory": { "within": "$SANDBOX" } } },
  { "tool": "git_push", "decision": "escalate", "reason": "Remote-contacting git operations require human approval" }
]

कोई भी कॉल जो किसी स्पष्ट allow या escalate नियम से मेल नहीं खाती, डिफ़ॉल्ट रूप से अस्वीकृत कर दी जाती है।```bash ironcurtain annotate-tools --server filesystem # Annotate one server (merge with existing) ironcurtain annotate-tools --all # Re-annotate all servers ironcurtain compile-policy # Compile constitution into rules and verify ironcurtain refresh-lists # Re-resolve dynamic lists without full recompilation ironcurtain refresh-lists --list major-news # Refresh a single list

जनरेट की गई `~/.ironcurtain/generated/compiled-policy.json` फ़ाइल की समीक्षा करें — ये रनटाइम पर लागू किए जाने वाले सटीक नियम हैं।

## कॉन्फ़िगरेशन

IronCurtain कॉन्फ़िगरेशन और सत्र डेटा `~/.ironcurtain/` में संग्रहीत करता है:```
~/.ironcurtain/
├── config.json              # User configuration
├── constitution.md          # User-local base constitution (overrides package default)
├── constitution-user.md     # Your policy customizations (generated by customize-policy)
├── generated/               # User-compiled policy artifacts (overrides package defaults)
├── personas/                # Persona directories (constitution, policy, workspace, memory)
├── skills/                  # User-global SKILL.md packages, mounted into every Docker session
├── jobs/                    # Cron job definitions, workspaces, and run records
├── sessions/
│   └── {sessionId}/
│       ├── sandbox/         # Per-session filesystem sandbox
│       ├── escalations/     # File-based IPC for human approval
│       ├── audit.jsonl      # Per-session audit log
│       └── session.log      # Diagnostics
└── workflow-runs/           # Shared-container workflow runs (see below)

एकल-सत्र रन (ironcurtain start, mux टैब, क्रॉन जॉब) sessions/ के अंतर्गत लिखते हैं। साझा-कंटेनर वर्कफ़्लो रन इसके बजाय workflow-runs/ के अंतर्गत लिखते हैं — अगला अनुभाग देखें।

वर्कफ़्लो रन लेआउट

एक वर्कफ़्लो परिभाषा अपने YAML में settings.sharedContainer: true सेट करके एक साझा Docker कंटेनर का विकल्प चुन सकती है। उस मोड में हर एजेंट स्थिति उसी लंबे समय तक चलने वाले कंटेनर के अंदर चलती है और एक ही पॉलिसी इंजन इंस्टेंस साझा करती है; स्थितियों के बीच ऑर्केस्ट्रेटर सक्रिय पॉलिसी को हॉट-स्वैप करता है ताकि प्रत्येक पर्सोना को अपने नियम दिखें। रन के सभी आर्टिफैक्ट एक ही ट्री में जमा होते हैं:``` ~/.ironcurtain/workflow-runs// ├── audit.jsonl # Persona-tagged append-only audit ├── messages.jsonl # Orchestrator message log ├── workspace/ # Agent workspace (filesystem MCP root) ├── bundle/ # Shared container support (claude-state, orientation, sockets, escalations, system-prompt.txt) ├── states/ │ └── ./ # session.log + session-metadata.json per invocation └── proxy-control.sock # Coordinator UDS for policy hot-swap

No per-session entries are created under `~/.ironcurtain/sessions/` for a shared-container workflow run. User-visible commands (`ironcurtain workflow start|resume|inspect|list`) are unchanged. See [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/HEAD/WORKFLOWS.md) for authoring workflow definitions and the full lifecycle.

Edit configuration interactively:```bash
ironcurtain config

मुख्य कॉन्फ़िगरेशन क्षेत्र: मॉडल और API कुंजियाँ, संसाधन बजट (टोकन/चरण/समय/लागत सीमाएँ), स्वतः-अनुमोदन एस्केलेशन, वेब खोज प्रदाता, ऑडिट रिडक्शन, और मेमोरी सर्वर LLM सेटिंग्स। पूर्ण संदर्भ के लिए CONFIG.md देखें।

LiteLLM या OpenRouter जैसे गेटवे के माध्यम से LLM ट्रैफ़िक रूट करने के लिए (कोड मोड और Docker एजेंट मोड दोनों में), MODEL_ROUTING.md देखें।

Docker एजेंटों को मॉडल-प्रदाता प्रोफ़ाइल के माध्यम से रूट करें (जैसे OpenRouter के माध्यम से GLM-5.2, बिना साइडकार) ironcurtain config → Model Providers के साथ, फिर /new पर या --provider-profile के साथ एक प्रोफ़ाइल चुनें — देखें MODEL_ROUTING.md।

अंतर्निहित क्षमताएँ

IronCurtain छह पूर्व-कॉन्फ़िगर MCP सर्वरों के साथ आता है। सभी टूल कॉल (मेमोरी को छोड़कर) आपकी संकलित नीति द्वारा नियंत्रित होते हैं।

रीड-ओनली ऑपरेशन डिफ़ॉल्ट नीति द्वारा अनुमत हैं; म्यूटेशन (राइट, पुश, PR निर्माण) मानव अनुमोदन के लिए एस्केलेट होते हैं। टूल्स server.tool नामकरण का उपयोग करते हैं (जैसे, filesystem.read_file, memory.recall)। अपने स्वयं के जोड़ने के लिए ADDING_MCP_SERVERS.md देखें।

नेटवर्क पासथ्रू (Docker एजेंट मोड)

Docker एजेंट मोड में, कंटेनर के पास कोई नेटवर्क एक्सेस नहीं होता — सभी ट्रैफ़िक IronCurtain के MITM प्रॉक्सी के माध्यम से जाता है। डिफ़ॉल्ट रूप से, केवल LLM प्रदाता डोमेन तक पहुँच संभव है। एजेंट रनटाइम पर proxy वर्चुअल MCP सर्वर (add_proxy_domain) के माध्यम से अतिरिक्त डोमेन तक पहुँच का अनुरोध कर सकता है। प्रत्येक अनुरोध के लिए एस्केलेशन प्रवाह के माध्यम से मानव अनुमोदन आवश्यक है।

अनुमोदित डोमेन को रॉ पासथ्रू टनल मिलती है — HTTP, HTTPS और WebSocket कनेक्शन बिना सामग्री निरीक्षण या क्रेडेंशियल इंजेक्शन के अग्रेषित किए जाते हैं। यह एजेंट को अधिक उपयोगिता देता है (तृतीय-पक्ष API कॉल करना, बाहरी सेवाओं से डेटा स्ट्रीम करना), लेकिन इसका मतलब है कि उन डोमेन तक ट्रैफ़िक बिना मध्यस्थता का होता है। खतरे के मॉडल के लिए SECURITY_CONCERNS.md का Section 2b-i देखें और उपयोग विवरण के लिए DEVELOPER_GUIDE.md देखें।

सुरक्षा मॉडल

IronCurtain एक विशिष्ट खतरे के मॉडल के इर्द-गिर्द डिज़ाइन किया गया है: LLM विद्रोही हो जाता है। यह प्रॉम्प्ट इंजेक्शन (एक दुर्भावनापूर्ण ईमेल या वेब पेज एजेंट को हाईजैक कर लेता है) या मल्टी-टर्न ड्रिफ्ट (एजेंट लंबे सत्र में धीरे-धीरे उपयोगकर्ता के इरादे से भटक जाता है) के माध्यम से हो सकता है।

IronCurtain क्या लागू करता है

• Filesystem कंटेनमेंट — Symlink-जागरूक पाथ रिज़ॉल्यूशन पाथ ट्रैवर्सल और symlink-escape हमलों को रोकता है।
• Per-tool नीति — प्रत्येक MCP टूल कॉल संकलित नियमों के विरुद्ध मूल्यांकित की जाती है। नीति इंजन टूल तर्कों को भूमिका (read-path, write-path, delete-path) द्वारा वर्गीकृत करता है ताकि सूक्ष्म निर्णय लिए जा सकें।
• संरचनात्मक इनवेरिएंट — कुछ सुरक्षाएँ हार्डकोडेड हैं और संविधान द्वारा इन्हें ओवरराइड नहीं किया जा सकता: एजेंट अपनी स्वयं की नीति फ़ाइलें, ऑडिट लॉग या कॉन्फ़िगरेशन को कभी संशोधित नहीं कर सकता।
• मानव एस्केलेशन — जब नीति "escalate" कहती है, एजेंट रुक जाता है और उपयोगकर्ता को स्पष्ट रूप से अनुमोदन या अस्वीकार करना होता है। वैकल्पिक रूप से, एक LLM-आधारित ऑटो-अनुमोदक स्पष्ट मामलों को संभालता है (CONFIG.md देखें)।
• ऑडिट ट्रेल — प्रत्येक टूल कॉल और नीति निर्णय एक append-only JSONL ऑडिट लॉग में लॉग किया जाता है।
• संसाधन सीमाएँ — टोकन, चरण, समय और लागत बजट अनियंत्रित सत्रों को रोकते हैं।

ज्ञात सीमाएँ

यह एक शोध प्रोटोटाइप है। ज्ञात कमियों में शामिल हैं:

• नीति संकलन निष्ठा — LLM-आधारित कंपाइलर संविधान के इरादे को गलत समझ सकता है। सत्यापन पाइपलाइन कई त्रुटियों को पकड़ लेती है लेकिन संपूर्ण नहीं है। हमेशा संकलित compiled-policy.json की समीक्षा करें।
• V8 आइसोलेट सीमाएँ — कोड मोड OS-स्तरीय वर्चुअलाइज़ेशन के बजाय V8 आइसोलेट का उपयोग करता है। V8 ज़ीरो-डे एस्केप की अनुमति दे सकता है।
• कोई आउटबाउंड सामग्री निरीक्षण नहीं — फ़ाइलें लिखने की अनुमति वाला एजेंट सामग्री-स्तर नियंत्रणों को बायपास करने के लिए संवेदनशील डेटा एन्कोड कर सकता है। योजना: आउटबाउंड सामग्री पर LLM-आधारित सुगमता जाँच।
• एस्केलेशन थकान — बहुत अधिक गलत-सकारात्मक एस्केलेशन आदतन अनुमोदन की ओर ले जा सकते हैं। अनावश्यक प्रॉम्प्ट को कम करने के लिए अपने संविधान को ट्यून करें।

विस्तृत खतरे के विश्लेषण के लिए docs/SECURITY_CONCERNS.md देखें।

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

विकास```bash

npm test # Run all tests npm test -- test/policy-engine.test.ts # Run a single test file npm test -- -t "denies delete_file" # Run a single test by name npm run lint # Lint npm run build # TypeScript compilation + asset copy

संपूर्ण परीक्षण मार्गदर्शिका के लिए [TESTING.md](https://github.com/provos/ironcurtain/blob/HEAD/TESTING.md) देखें, जिसमें एकीकरण परीक्षण फ़्लैग और परंपराएँ शामिल हैं।

### परियोजना संरचना```
src/
├── index.ts                    # Entry point
├── cli.ts                      # CLI command dispatcher
├── config/                     # Configuration loading, constitution, MCP server definitions
├── session/                    # Multi-turn session management, budgets, loop detection
├── sandbox/                    # V8 isolated execution environment
├── trusted-process/            # Policy engine, MCP proxy, audit log, escalation handler
├── pipeline/                   # Constitution → policy compilation pipeline
├── escalation/                 # Escalation listener: session registry, TUI dashboard, state
├── mux/                        # Terminal multiplexer: PTY bridge, renderer, trusted input
├── persona/                    # Persona management (create, compile, resolve)
├── memory/                     # Memory server integration (config, annotations, path resolution)
├── signal/                     # Signal messaging transport (bot daemon, setup, formatting)
├── daemon/                     # Unified daemon (Signal + cron scheduler, control socket)
├── cron/                       # Cron job management (scheduler, job store, git sync, policy)
├── docker/                     # Docker agent mode, PTY session, MITM proxy, registry proxy
├── workflow/                   # Multi-agent workflow engine (orchestrator, state machine, gates)
├── web-ui/                     # Web UI backend (JSON-RPC dispatch, event bus, workflow manager)
├── servers/                    # Built-in MCP servers (fetch, web search providers)
└── types/                      # Shared type definitions
packages/
└── memory-mcp-server/          # Standalone memory MCP server (publishable npm package)

लाइसेंस

Apache-2.0