Reelier

---

你的智能体每次运行都会重新推导相同的工作流——消耗 token 并悄然漂移。Reelier 将一次成功的运行编译成一个 SKILL.md 文件，该文件可以确定性地重放（无需 LLM，0 token，每一步都被断言并记录为收据），然后对比运行结果，以捕捉它不再匹配的那一天。专为那些运行在周期性生产工作流中的智能体设计——在这些场景下，“它运行了”并不能作为证明。

安装 → 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 token 重放，并附上收据。
• 这不是脆弱的 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 将追踪记录确定性地（0 次 LLM 调用）转化为一个 SKILL.md——一个每一步都带有断言的配方，并且编译器会将其无法确定的空白部分打印为待解决问题（包括它标记为“这应该是一个变量吗？”的字面日期、UUID 和时间戳），而不是猜测。
3. 重放——reelier run 在 Level 0 运行它：无 LLM，毫秒级，字节级一致。默认只读——一个写入步骤（idempotent-write）除非你传入 --allow-writes，否则绝不会再次触发。
4. 对比——reelier diff 比较一个技能的两次运行，并逐步报告是相同还是漂移，并将失败的断言作为原因。漂移时退出码为 1，因此它可以作为定时重放的门禁。
5. 收据——每次运行都是一份收据（逐步结果、计时、0 token）。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> 调用）才会被编译进技能——原生的文件/Shell/搜索操作会被报告为已跳过，绝不会被捏造成一个步骤。传入 --agent <claude-code|codex|openclaw> 可以强制指定格式，而不是自动检测；reelier scan / reelier from-session --agent cursor（或 --agent windsurf）会诚实地报告磁盘上的内容，而不是猜测未记录的二进制格式。

三项测试，一个技能

一个录制的技能让你可以向它提出三个不同的问题，而不是一个：

• 确定性——reelier run <skill.md> 根据你录制的断言进行重放。相同的步骤，相同的断言，0 token。回答：它是否仍然像以前那样做？
• 恢复——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 token 确定性地重放一个技能（默认只读；写入由 --allow-writes 控制）
• reelier_diff — 比较两次运行：逐步报告是相同还是漂移，并将失败的断言作为原因；漂移时退出 1
• reelier_push — 将运行收据同步到账本以获得可分享的永久链接（可选加入）

可衡量的证明

来自一次真实的、实时的头对头基准测试（智能体 vs. Reelier，相同任务，相同数据）——完整表格 + 方法在 examples/benchmark 中：

• 1,000 / 1,000 次重放字节级一致（N=1000 尾部方差测试）
• 每次重放 0 token——从运行记录中验证，而非假设
• 成本降低约 50 倍（每次重放 $0.000000，对比智能体端平均每次运行 $0.019068）
• 速度提升约 59 倍（平均延迟 48 毫秒 vs. 2,842 毫秒）
• 一次真实的漂移自我修复成本约 $0.001，一次之后，每次重放都是免费的

延迟因网络而异——Level-0 重放会重新执行技能的工具调用，因此实际耗时取决于你的连接。不变的是：0 LLM token，每次运行相同的步骤，以及收据。独立证实——arXiv 2605.14237 发现相同的录制与重放模式可减少 93.3–99.98% 的 token。

适用于任何模型 (BYOK)

Level-0 重放（默认）从不调用模型——从设计上就是 0 token。升级（--max-level 1|2）是可选的，并通过一个狭窄的 BYOK 接口（--llm-base-url + --llm-model）进行通信：一个原生的 Anthropic Messages 适配器，以及一个用于其他所有服务的 OpenAI 兼容适配器（OpenRouter、Ollama、Gemini 的 OpenAI 端点、Groq、vLLM、LM Studio、Kimi 等）。将其指向一个更强的模型，每个技能的下一次自我修复都会免费变得更智能。

拥有它——MIT、BYOK、本地优先

在任何地方使用它，将其嵌入任何东西——没有 copyleft 限制，无需法律审查。你的技能、追踪记录和运行记录是你的数据——离开只需复制一个文件夹。格式在 SPEC.md 中指定，这是一个规范性的 RFC 风格参考，因此任何人都可以在不阅读源代码的情况下生成或使用它们。

贡献

欢迎提交 Issues 和 PRs——有关格式，请参阅 SPEC.md（规范优先于代码；修复代码，而不是规范）。npm test 运行完整的测试套件；在提交 PR 前运行 npm run build && npx tsc --noEmit。

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

Star 历史

许可证

MIT — 永久免费用于复刻、嵌入、审计和自托管。（版本 ≤0.16.0 根据 AGPL-3.0 发布，并保持如此。）