Reelier

---

आपका एजेंट हर रन में उसी वर्कफ़्लो को फिर से प्राप्त करता है — टोकन जलाता है और चुपचाप विचलित होता है। Reelier एक ऐसे रन को, जो काम कर गया, एक SKILL.md फ़ाइल में संकलित करता है जो नियतात्मक रूप से दोबारा चलती है (कोई LLM नहीं, 0 टोकन, हर कदम एक रसीद में सुनिश्चित), फिर रनों की तुलना करके उस दिन को पकड़ता है जब यह मेल खाना बंद कर देता है। आवर्ती उत्पादन वर्कफ़्लो पर एजेंटों के लिए — जहाँ "यह चल गया" सबूत नहीं है।

इंस्टॉल करें → 60 सेकंड में आपकी पहली रसीद

npm i -g reelier && reelier init

reelier init पहले आपके द्वारा किए गए काम को स्कैन करता है — Claude Code, Codex, Windsurf, और OpenClaw में — और एक वास्तविक पिछले सत्र को एक पुन: चलाने योग्य कौशल में बदलने की पेशकश करता है। ऐसा कोई इतिहास नहीं है? यह एक शून्य-सेटअप डेमो चलाता है और एक वास्तविक रसीद के साथ बंद होता है:

Your receipt:
  skill:        reelier-init-demo
  steps:        2 total, 2 passed, 0 unchecked, 0 failed
  replay time:  44ms  [measured]
  LLM tokens:   0     [measured]

  An agent doing a comparable task re-reasons every run (~2.8s, ~18k tokens on
  our benchmark). Your replay: 44ms, 0 tokens.

या इसे Docker के साथ चलाएँ — कोई Node इंस्टॉल नहीं

docker run --rm ghcr.io/seldonframe/reelier --help

# Replay a skill from the current directory:
docker run --rm -v "$PWD:/work" -w /work ghcr.io/seldonframe/reelier run my.skill.md

# Record from your agent history (mount it read-only):
docker run --rm -v "$HOME/.claude:/root/.claude:ro" -v "$PWD:/work" -w /work \
  ghcr.io/seldonframe/reelier scan

क्यों

• आपका एजेंट हर रन में काम फिर से सीखता है — फिर चुपचाप विचलित हो जाता है। हर रन वर्कफ़्लो को फिर से प्राप्त करता है, और हर छोटा "तार्किक" सुधार जुड़ता जाता है — जिसे दीर्घकालिक संचालक निशान ऊतक कहते हैं। एक संकलित कौशल कभी फिर से नहीं सीखता और विचलित नहीं हो सकता।
• असली समस्या बिल है। "इसकी लागत कितनी आई?" यह हर लंबे एजेंट रन को मिलने वाला पहला उत्तर है। Reelier 0 टोकन के लिए, एक रसीद के साथ दोबारा चलता है।
• यह भंगुर RPA नहीं है। टूल कॉल (टाइप किए गए JSON इन/आउट) को दोबारा चलाता है, पिक्सेल नहीं — और हर कदम अपना स्वयं का अभिकथन रखता है, इसलिए एक टूटा हुआ कदम जोर से विफल होता है, कभी चुपचाप पास नहीं होता।
• मॉडल अपग्रेड किया? एक रीप्ले पिन किया गया है — नए मॉडल पर फिर से रिकॉर्ड करें और reelier diff अपनी स्थिर आधाररेखा के विरुद्ध: प्रति कदम समान या विचलित, उत्पादन तक पहुँचने से पहले।
• "कुछ भी नियतात्मक बस कोड होना चाहिए।" सहमत — आपके एजेंट ने इसे पहले ही लिख दिया। Reelier इसके वास्तविक, काम करने वाले रन को एक परीक्षित फ़ाइल में कैद करता है। हाथ से कोडिंग के बिना नियतिवाद।

यह कैसे काम करता है — रिकॉर्ड → संकलित → रीप्ले → अंतर → रसीद

reelier init                        # 60s: record → compile → replay → your receipt
reelier run  <name>.skill.md        # replay deterministically — 0 tokens (read-only by default)
reelier diff <name>                 # SAME or DRIFTED, per step — exit 1 on drift
reelier push <name>.skill.md        # sync receipts to your ledger (opt-in)

1. रिकॉर्ड — तीन तरीके: reelier mcp --wrap "<your mcp server>" (आपके एजेंट के टूल्स के सामने एक दोषरहित प्रॉक्सी), सीधे एक मौजूदा सत्र से (reelier scan / reelier from-session), या निर्देशित reelier init।
2. संकलित — reelier compile एक ट्रेस को नियतात्मक रूप से एक SKILL.md (0 LLM कॉल) में बदलता है — हर कदम पर एक अभिकथन के साथ एक विधि, और संकलक के ईमानदार अंतराल अनुमान लगाने के बजाय खुले प्रश्नों (शाब्दिक तिथियों, UUIDs, और टाइमस्टैम्प सहित जिन्हें यह "क्या यह एक चर होना चाहिए?" के रूप में चिह्नित करता है) के रूप में मुद्रित होते हैं।
3. रीप्ले — reelier run इसे स्तर 0 पर चलाता है: कोई LLM नहीं, मिलीसेकंड, बाइट-समान। डिफ़ॉल्ट रूप से केवल-पढ़ने के लिए — एक लेखन चरण (idempotent-write) कभी भी फिर से सक्रिय नहीं होता जब तक आप --allow-writes पास नहीं करते।
4. अंतर — reelier diff एक कौशल के दो रनों की तुलना करता है और प्रति कदम समान या विचलित रिपोर्ट करता है, विफल अभिकथन के साथ क्यों के रूप में। विचलन पर निकास कोड 1, इसलिए यह एक निर्धारित रीप्ले को रोकता है।
5. रसीद — हर रन एक रसीद है (प्रति-कदम परिणाम, समय, 0 टोकन)। reelier push वैकल्पिक रूप से उन्हें एक साझा करने योग्य पर्मालिंक + एक एम्बेड करने योग्य सत्यापित-रीप्ले बैज के लिए एक रसीद बहीखाता में सिंक करता है।

एक एजेंट कौशल परिवर्तित करें

एक निर्देश कौशल + एक रिकॉर्ड किए गए रन को एक नियतात्मक रीप्ले में बदलें — आपका कौशल, मॉडल घटाकर:

reelier mcp --wrap "<your mcp server>"                 # record: agent runs the skill's task once
reelier compile trace.jsonl --from-skill ./my-skill/SKILL.md
# → my-skill.skill.md — name + description carried from your SKILL.md,
#   steps ONLY from the recorded run (never generated from instruction text)

किसी भी एजेंट से सत्र आयात करें

आपके पास पहले से ही आपके एजेंट के अपने सत्र लॉग में पुन: चलाने योग्य वर्कफ़्लो मौजूद हैं। reelier scan उन्हें ढूंढता है; reelier from-session एक को कौशल में बदलता है। प्रारूप फ़ाइल की सामग्री से सूंघा जाता है — समर्थित एजेंटों के लिए किसी फ़्लैग की आवश्यकता नहीं:

reelier scan                                          # discovers sessions from every known agent under your home dir
reelier from-session ~/.claude/projects/*/*.jsonl      # Claude Code
reelier from-session ~/.codex/sessions/**/rollout-*.jsonl   # Codex CLI
reelier from-session ~/.openclaw/agents/*/sessions/*.jsonl  # OpenClaw

एजेंट	सत्र स्थान	स्थिति
Claude Code	~/.claude/projects/<project>/<uuid>.jsonl	समर्थित
Codex CLI	~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl	समर्थित
OpenClaw	~/.openclaw/agents/<agentId>/sessions/<sessionId>.jsonl	समर्थित
Cursor	.../User/globalStorage/state.vscdb (SQLite, अप्रलेखित)	पता चला, अभी तक पार्स करने योग्य नहीं
Windsurf	.../User/globalStorage/state.vscdb (SQLite, अप्रलेखित)	पता चला, अभी तक पार्स करने योग्य नहीं

केवल पुन: चलाने योग्य कॉल (Reelier के अपने बिल्टइन, या mcp__<server>__<tool> कॉल) कभी भी एक कौशल में संकलित होते हैं — मूल फ़ाइल/शेल/खोज क्रियाएँ छोड़ी गई के रूप में रिपोर्ट की जाती हैं, कभी भी एक कदम में गढ़ी नहीं जातीं। स्वतः-पता लगाने के बजाय एक प्रारूप बाध्य करने के लिए --agent <claude-code|codex|openclaw> पास करें; reelier scan / reelier from-session --agent cursor (या --agent windsurf) एक अप्रलेखित बाइनरी प्रारूप पर अनुमान लगाने के बजाय ईमानदारी से रिपोर्ट करते हैं कि डिस्क पर क्या है।

तीन परीक्षण, एक कौशल

एक रिकॉर्ड किया गया कौशल आपको इससे पूछने के लिए तीन अलग-अलग प्रश्न देता है, एक नहीं:

• नियतिवाद — reelier run <skill.md> आपके द्वारा रिकॉर्ड किए गए अभिकथनों के विरुद्ध रीप्ले करता है। समान चरण, समान अभिकथन, 0 टोकन। उत्तर: क्या यह अब भी वही करता है जो यह करता था?
• पुनर्प्राप्ति — reelier run <skill.md> --fail N[=status] उस चरण के वास्तविक टूल कॉल को भेजने के बजाय चरण N (डिफ़ॉल्ट स्थिति 500; --fail N=429 के साथ ओवरराइड करें, दोहराने योग्य) पर एक कृत्रिम विफलता इंजेक्ट करता है, फिर वही वृद्धि सीढ़ी चलाता है जो एक वास्तविक विफलता हिट करेगी। नेटवर्क के बाहर वास्तव में कुछ भी नहीं होता — एक नकली चरण कभी भी अपने टूल को कॉल नहीं करता, इसलिए आप बिना किसी --allow-writes और बिना किसी दुष्प्रभाव के एक लेखन चरण का पुनर्प्राप्ति-परीक्षण कर सकते हैं। उत्तर: अगर यह टूट गया, तो क्या कौशल नोटिस करेगा और ठीक होगा? (एक नकली रन केवल एक स्थानीय परीक्षण है — reelier push एक को प्रकाशित करने से मना करता है; नीचे देखें।)
• विचलन — reelier run <skill.md> --wrap "<your mcp server>" रिकॉर्ड किए गए ट्रेस के बजाय आपकी लाइव, केवल-पढ़ने के लिए निर्भरताओं के विरुद्ध रीप्ले करता है। reelier manifest (नीचे) के साथ जोड़ा गया, इस तरह आप एक वास्तविक रीप्ले से पहले एक टूल के स्कीमा को अपने नीचे से खिसकते हुए पकड़ते हैं।

लॉन्च पोस्ट की मैड्स हैनसेन की समीक्षा के कारण वर्गीकरण।

टूल-स्कीमा विचलन: reelier manifest

एक कौशल के चरण विशिष्ट तर्क आकृतियों के साथ विशिष्ट टूल्स को कॉल करते हैं। यदि किसी रैप किए गए MCP सर्वर का टूल स्कीमा तब से बदल गया है जब आपने इसके विरुद्ध रिकॉर्ड किया था, तो रीप्ले को जोर से मना कर देना चाहिए, चुपचाप गलत तर्क नहीं भरने चाहिए। reelier manifest हर उस टूल के लिए एक स्कीमा डाइजेस्ट मुहर लगाता है जिसका कौशल के चरण वास्तव में उपयोग करते हैं:

reelier manifest <skill.md> --wrap "<your mcp server>"   # stamp/refresh the manifest from live servers
reelier run <skill.md> --wrap "<your mcp server>"         # preflight checks the manifest BEFORE step 1 runs

यदि किसी मुहर लगे टूल का स्कीमा विचलित हो गया है (या टूल गायब है), तो reelier run कुछ भी निष्पादित होने से पहले — MANIFEST DRIFT — refusing to replay — बंद होकर विफल हो जाता है। --ignore-manifest उस समय के लिए स्पष्ट आपातकालीन ओवरराइड है जब आप जानते हैं कि विचलन ठीक है; यह अभी भी रन (manifestIgnored: true) पर दर्ज है, इसलिए यह कभी भी एक मूक बाईपास नहीं है। बिना किसी घोषणापत्र वाला कौशल बस एक सलाहकारी नोट प्राप्त करता है — हर पूर्व-घोषणापत्र कौशल बिना संशोधन के काम करता रहता है।

प्रति-कदम लेखन अनुमोदन: reelier approve

--allow-writes/--yes व्यापक फ़्लैग हैं — वे कहते हैं "यह रन लिख सकता है," न कि "इस सटीक लेखन की समीक्षा की गई है।" reelier approve एक विशिष्ट चरण के टूल + तर्क टेम्पलेट के लिए हैश-बाइंड अनुमोदन करता है:

reelier approve <skill.md>          # walk each write/destructive step, y/N to approve
reelier approve <skill.md> --all    # approve every write step non-interactively

एक स्वीकृत चरण जिसका टूल/तर्क अभी भी उसके मुहर लगे हैश से मेल खाता है, बिना किसी फ़्लैग के निष्पादित होता है। यदि अनुमोदन के बाद से चरण का टूल या तर्क बदल गया है, तो रीप्ले बंद होकर विफल हो जाता है — Approval mismatch — और कोई फ़्लैग इसे ओवरराइड नहीं करता; आप फिर से समीक्षा करें और फिर से अनुमोदन करें। बिना किसी approve: फ़ील्ड वाला एक लेखन चरण आज के सटीक --allow-writes/--yes व्यवहार को अपरिवर्तित रखता है।

मूल्य पर जोर दें, न कि केवल आकृति पर

एक कौशल के अभिकथन वह हैं जो एक रीप्ले को प्रमाण बनाते हैं। व्याकरण स्थिति, संरचना, और मूल्य की जाँच करता है:

- assert: status == 200
- assert: json.results is array
- assert: json.count >= 1              # numeric range
- assert: json.plan is string          # type
- assert: json.id matches /^usr_/      # value pattern
- assert: body contains "ok"

इसे अपने कोडिंग एजेंट (MCP) के अंदर उपयोग करें

reelier serve Reelier के अपने कमांड को MCP टूल्स के रूप में उजागर करता है, ताकि Claude Code / Cursor / Windsurf / Codex इसे मध्य-सत्र कॉल कर सकें:

{ "mcpServers": { "reelier": { "command": "npx", "args": ["-y", "reelier", "serve"] } } }

एजेंट को reelier_scan, reelier_from_session, reelier_replay, reelier_diff, और reelier_push मिलते हैं — विवरण के साथ जो इसे बताते हैं कि प्रत्येक का उपयोग कब करना है (और कब नहीं)। यह एक बार एक नियतात्मक कार्य रिकॉर्ड करता है, फिर पुन: तर्क करने के बजाय रीप्ले करता है।

टूल्स

• reelier_scan — पुन: चलाने योग्य टूल-कॉल वर्कफ़्लो के लिए एजेंट सत्र इतिहास (Claude Code, Codex, Windsurf, OpenClaw) स्कैन करें
• reelier_from_session — एक रिकॉर्ड किए गए सत्र को हर कदम पर एक अभिकथन के साथ एक पुन: चलाने योग्य SKILL.md में संकलित करें
• reelier_replay — 0 LLM टोकन पर नियतात्मक रूप से एक कौशल रीप्ले करें (डिफ़ॉल्ट रूप से केवल-पढ़ने के लिए; लेखन --allow-writes के पीछे रोके गए)
• reelier_diff — दो रनों की तुलना करें: प्रति कदम समान या विचलित, विफल अभिकथन के साथ क्यों के रूप में; विचलन पर 1 से बाहर निकलें
• reelier_push — एक साझा करने योग्य पर्मालिंक (ऑप्ट-इन) के लिए एक रन रसीद को बहीखाता में सिंक करें

मापा गया प्रमाण

एक वास्तविक, लाइव आमने-सामने बेंचमार्क (एजेंट बनाम Reelier, समान कार्य, समान डेटा) से — पूर्ण तालिकाएँ + कार्यप्रणाली examples/benchmark में:

• 1,000 / 1,000 रीप्ले बाइट-समान (N=1000 टेल-वेरिएंस परीक्षण)
• 0 टोकन प्रति रीप्ले — रन रिकॉर्ड से सत्यापित, अनुमानित नहीं
• ~50× सस्ता ($0.000000/रीप्ले बनाम एजेंट आर्म पर औसत $0.019068/रन)
• ~59× तेज़ (48ms बनाम 2,842ms औसत विलंबता)
• एक वास्तविक विचलन ~$0.001 में स्व-उपचारित, एक बार, फिर उसके बाद हर रीप्ले मुफ़्त

विलंबता नेटवर्क के अनुसार बदलती है — स्तर-0 रीप्ले कौशल के टूल कॉल को फिर से निष्पादित करता है, इसलिए वास्तविक समय आपके कनेक्शन पर निर्भर करता है। जो नहीं बदलता: 0 LLM टोकन, हर रन में समान चरण, और रसीद। स्वतंत्र रूप से पुष्टि की गई — arXiv 2605.14237 ने समान रिकॉर्ड-एंड-रीप्ले पैटर्न के लिए 93.3–99.98% टोकन कमी पाई।

किसी भी मॉडल के साथ काम करता है (BYOK)

स्तर-0 रीप्ले (डिफ़ॉल्ट) कभी किसी मॉडल को कॉल नहीं करता — निर्माण द्वारा, 0 टोकन। वृद्धि (--max-level 1|2) ऑप्ट-इन है और एक संकीर्ण BYOK सतह (--llm-base-url + --llm-model) के माध्यम से बोलती है: एक मूल Anthropic Messages एडाप्टर, और बाकी सभी चीज़ों के लिए एक OpenAI-संगत एडाप्टर (OpenRouter, Ollama, Gemini का OpenAI एंडपॉइंट, Groq, vLLM, LM Studio, Kimi, …)। इसे एक मजबूत मॉडल पर इंगित करें और हर कौशल का अगला स्व-उपचार मुफ्त में अधिक स्मार्ट हो जाता है।

इसके मालिक बनें — MIT, BYOK, स्थानीय-प्रथम

इसे कहीं भी उपयोग करें, इसे किसी भी चीज़ में एम्बेड करें — कोई कॉपीलेफ्ट बंधन नहीं, कोई कानूनी समीक्षा की आवश्यकता नहीं। आपके कौशल, ट्रेस और रन रिकॉर्ड आपका डेटा हैं — छोड़ना एक फ़ोल्डर की प्रतिलिपि बनाना है। प्रारूप SPEC.md में निर्दिष्ट हैं, एक मानक RFC-शैली संदर्भ ताकि कोई भी स्रोत को पढ़े बिना उन्हें उत्सर्जित या उपभोग कर सके।

योगदान

मुद्दे और PR स्वागत योग्य हैं — प्रारूपों के लिए SPEC.md देखें (स्पेक कोड पर जीतता है; कोड को ठीक करें, स्पेक को नहीं)। npm test पूर्ण सूट चलाता है; PR से पहले npm run build && npx tsc --noEmit।

git clone https://github.com/seldonframe/reelier && cd reelier
npm install && npm test

स्टार इतिहास

लाइसेंस

MIT — फोर्क करने, एम्बेड करने, ऑडिट करने और हमेशा के लिए स्व-होस्ट करने के लिए स्वतंत्र। (संस्करण ≤0.16.0 AGPL-3.0 के तहत जारी किए गए थे और ऐसे ही रहेंगे।)