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

ทำไม

• เอเจนต์ของคุณเรียนรู้งานใหม่ทุกครั้งที่รัน — แล้วก็เบี่ยงเบนไปอย่างเงียบๆ ทุกการรันต้องคิดค้นเวิร์กโฟลว์ใหม่ และทุกการแก้ไข "ที่มีเหตุผล" เล็กๆ น้อยๆ ก็สะสม — สิ่งที่ผู้ดำเนินการระยะยาวเรียกว่า scar tissue สกิลที่คอมไพล์แล้วไม่ต้องเรียนรู้ใหม่และไม่สามารถเบี่ยงเบนได้
• ปัญหาที่แท้จริงคือบิล "นั่นราคาเท่าไหร่?" คือคำตอบแรกที่ทุกการรันเอเจนต์ที่ยาวนานได้รับ 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) — สูตรที่มี การตรวจสอบในทุกขั้นตอน และช่องว่างที่ตรงไปตรงมาของคอมไพเลอร์จะถูกพิมพ์เป็น คำถามเปิด (รวมถึงวันที่ตามตัวอักษร, UUID และการประทับเวลาที่มันตั้งค่าสถานะว่า "นี่ควรเป็นตัวแปรหรือไม่?") แทนที่จะเดา
3. เล่นซ้ำ — reelier run รันมันที่ระดับ 0: ไม่มี LLM, มิลลิวินาที, เหมือนเดิมทุกไบต์ อ่านอย่างเดียวโดยค่าเริ่มต้น — ขั้นตอนการเขียน (idempotent-write) จะไม่ถูกยิงซ้ำเว้นแต่คุณจะส่ง --allow-writes
4. เปรียบเทียบ — reelier diff เปรียบเทียบการรันสองครั้งของสกิลและรายงาน เหมือนเดิม หรือ เบี่ยงเบน ต่อขั้นตอน พร้อมการตรวจสอบที่ล้มเหลวเป็น เหตุผล รหัสออก 1 เมื่อเบี่ยงเบน ดังนั้นมันจึงเป็นประตูสู่การเล่นซ้ำตามกำหนดการ
5. ใบเสร็จ — ทุกการรันคือใบเสร็จ (ผลลัพธ์ต่อขั้นตอน, เวลา, 0 โทเค็น) reelier push เลือกซิงค์ไปยังบัญชีแยกประเภทใบเสร็จเพื่อลิงก์ถาวรที่แชร์ได้ + ป้าย verified-replay ที่ฝังได้

แปลงสกิลเอเจนต์

เปลี่ยนสกิลคำสั่ง + หนึ่งการรันที่บันทึกไว้เป็นการเล่นซ้ำแบบกำหนดได้ — สกิลของคุณ, ลบโมเดล:

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 (ด้านล่าง), นี่คือวิธีที่คุณจับได้ว่าสกีมาของเครื่องมือเปลี่ยนไปจากใต้เท้าคุณก่อนที่การเล่นซ้ำจริงจะทำ

อนุกรมวิธานจากรีวิวของ Mads Hansen ต่อโพสต์เปิดตัว

การเบี่ยงเบนของสกีมาเครื่องมือ: 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 — ซิงค์ใบเสร็จการรันไปยัง บัญชีแยกประเภท เพื่อลิงก์ถาวรที่แชร์ได้ (เลือกเข้าร่วม)

ข้อพิสูจน์ที่วัดได้

จากการเปรียบเทียบสดจริงแบบตัวต่อตัว (เอเจนต์ vs. 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, ปลายทาง OpenAI ของ Gemini, Groq, vLLM, LM Studio, Kimi, …) ชี้ไปที่โมเดลที่แข็งแกร่งกว่าและการรักษาตัวเอง ครั้งต่อไป ของทุกสกิลจะฉลาดขึ้นฟรี

เป็นเจ้าของมัน — MIT, BYOK, โลคอลเฟิร์ส

ใช้มันได้ทุกที่, ฝังมันในอะไรก็ได้ — ไม่มีข้อผูกมัด copyleft, ไม่ต้องตรวจสอบทางกฎหมาย สกิล, เทรซ, และบันทึกการรันของคุณคือ ข้อมูลของคุณ — การจากไปคือการคัดลอกโฟลเดอร์ รูปแบบถูกระบุใน SPEC.md, เอกสารอ้างอิงสไตล์ RFC เชิงบรรทัดฐานเพื่อให้ใครๆ ก็สามารถปล่อยหรือบริโภคพวกมันได้โดยไม่ต้องอ่านซอร์ส

การมีส่วนร่วม

ยินดีต้อนรับ Issues และ PRs — ดู SPEC.md สำหรับรูปแบบ (สเปกชนะเหนือโค้ด; แก้โค้ด, ไม่ใช่สเปก) npm test รันชุดทดสอบเต็ม; npm run build && npx tsc --noEmit ก่อน PR

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

ประวัติการกดดาว

ใบอนุญาต

MIT — ฟรีที่จะ fork, ฝัง, ตรวจสอบ, และโฮสต์เองตลอดไป (เวอร์ชัน ≤0.16.0 ถูกปล่อยภายใต้ AGPL-3.0 และยังคงเป็นเช่นนั้น)