reelier

name	reelier
description	Freeze a repeatable, tool-call-driven task into a replayable Reelier skill, and replay an existing skill instead of redoing deterministic work. Use after finishing a task that was mostly API/MCP tool calls (data pulls, report generation, deploy checks, CRUD sequences) — never for arbitrary coding/file-edit sessions, which Reelier cannot replay.

Reelier — record once, replay forever

Reelier turns a deterministic sequence of tool calls into a SKILL.md file that replays for free (zero LLM calls) instead of being re-reasoned from scratch every time. This skill teaches you when to reach for it. The tools themselves come from the reelier MCP server (see "Setup" below) — if it isn't connected yet, tell the user how to add it and stop; don't try to shell out to the reelier CLI directly when the MCP tools are missing.

The honesty boundary — read this first

Reelier can only replay deterministic tool calls: its own HTTP builtins (http.get/http.post) and MCP server tool calls (mcp__<server>__<tool>). It cannot replay:

• File edits (Edit, Write, NotebookEdit)
• Shell commands (Bash)
• Reads/searches (Read, Grep, Glob)
• Subagent dispatch (Task)
• Anything non-deterministic (web search results that vary, LLM-generated content, timestamps that aren't parameterized)

Never tell a user "I'll replay this session for you" about a coding session. A session that was mostly edits and greps has nothing replayable in it, and reelier_scan/reelier_from_session will say so honestly (an empty result, not an error) — that's expected, not a bug. Only offer to freeze a task when it was actually a sequence of API/MCP calls: pulling data from a CRM, hitting a deploy-status endpoint, walking a ticketing system, querying a database via its MCP server, and similar.

When to offer freezing a skill

After finishing a task, ask yourself: if the user (or I) needed to do this exact sequence again next week with different inputs, would it be the same tool calls with different arguments? If yes, offer it:

"That was a deterministic sequence of API calls — want me to freeze it into a Reelier skill so it replays instantly next time, without burning tokens re-reasoning through it?"

Good candidates:

• "Pull this week's numbers from PostHog and summarize them" (if the pull itself was tool calls, not the summarizing)
• "Check whether the last 5 deploys are green" (status-check loops)
• "Create these 10 contacts in the CRM from this CSV"
• Any recurring ops/support runbook driven through MCP tools

Bad candidates — do not offer:

• "Refactor this function" / "fix this bug" (pure code editing)
• "Investigate why X is slow" (open-ended reading/greeping)
• Anything where the value was your judgment, not the sequence of calls

How to freeze one

1. Call reelier_from_session with the current session's transcript path (Claude Code writes it under ~/.claude/projects/<project>/<uuid>.jsonl — if you don't know the exact path, call reelier_scan first to find it).
2. Report the result honestly:
   • Success: name the skill path, step/assert/bind counts, and read out the "Open questions" list verbatim if non-empty — those are gaps the compiler declined to guess about; tell the user to look at them before trusting the skill blindly.
   • Nothing replayable: say so plainly — "nothing in that session was a deterministic tool-call sequence Reelier can replay" — and don't manufacture a skill anyway.
3. Optionally call reelier_replay once against the new skill to prove it actually works before telling the user it's ready — report the real run record (passed/failed, per-step outcome), never an assumed pass.

How to replay instead of redoing

Before manually re-executing a sequence of tool calls, check whether a skill for it already exists (ask the user, check for *.skill.md files in the project, or call reelier_scan if session history might have one). If one exists, call reelier_replay with the skill path (and any vars/wrap it needs) instead of re-issuing the calls by hand — it's faster, costs zero tokens, and its assertions catch drift the calls themselves wouldn't surface. Report the real run record either way; if it fails, say so and fall back to doing the task manually rather than pretending the replay succeeded.

Setup — the MCP config snippet

If the reelier MCP server isn't connected, tell the user to add this to their MCP config (project .mcp.json or ~/.claude.json for Claude Code; the equivalent file for Cursor/Windsurf — see integrations/README.md):

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

This starts reelier serve — the tool-server that exposes reelier_scan, reelier_from_session, reelier_replay, and reelier_push. Do not confuse it with reelier mcp, which is a different command (the recorder that fronts other MCP servers) and is not what this skill uses.