Rashomon

---
name: rashomon
description: 'Start recording what this Claude Code session asks to run. Use when the user says "rashomon", "start rashomon", "claude rashomon", "watch this session", "record my session", asks to turn the recorder on, or wants an easier way to launch recorded sessions. For reports use rashomon-report; to stop use rashomon-stop; for install state use rashomon-status.'
---

Install the rashomon recorder so every tool call from now on is recorded as a
declaration (identifiers; shape, including a command's program name; the
hostnames the call names, meaning URL hosts and ssh/scp/sftp/rsync
destinations; and the working directory and transcript path. No prompts,
responses, file contents or other argument values).

1. Resolve the binary, in this order. Set `$RASHOMON` to the first absolute
   path that works:
   - `~/.local/bin/rashomon` if present and executable
   - `~/go/bin/rashomon` if present and executable (where `go install` puts it)
   - `/opt/homebrew/bin/rashomon` or `/usr/local/bin/rashomon` (brew installs;
     checked explicitly because a GUI-launched app's PATH may not carry them)
   - `command -v rashomon`, kept only when it returns an absolute path
   - None found: if `command -v go` also fails, stop and point the user at the
     README's install options instead of building. With Go present, build from
     this repository when the cwd is the rashomon repo
     (`go build -o ~/.local/bin/rashomon ./cmd/rashomon`; on Windows,
     PowerShell does not expand `~` for go — use
     `go install ./cmd/rashomon`, which lands `rashomon.exe` in
     `"$(go env GOPATH)\bin"`). Outside the repo, ask the user where their
     rashomon checkout is rather than fetching an unpinned module from the
     network.
   Never install from a `go run` path — `watch` refuses temporary build
   directories because the installed hook entry records the absolute path.

2. Run `$RASHOMON watch`. It writes eight hook entries (PreToolUse,
   PostToolUse, PostToolUseFailure, SessionStart, SessionEnd, Stop,
   StopFailure, UserPromptSubmit) into `~/.claude/settings.json` and prints an install id plus
   the exact `detach --install <id>` line that undoes it. Quote that undo
   line back to the user verbatim.

3. Run `$RASHOMON status` and show the result, so the user sees the eight
   entries as present and where the store lives.

4. Tell the user, briefly, and say the SCOPE first — it is the part they are
   actually agreeing to:
   - Recording is USER-WIDE AND OPEN-ENDED, not this session and not this
     project. The entries go in `~/.claude/settings.json`, which Claude Code
     reads for every project on this machine, so every session from now on is
     recorded — including unrelated repositories and client work — until
     `/rashomon-stop` or the `detach --install <id>` line removes them.
     Someone who is under an agreement not to instrument a particular
     codebase needs to know that before saying yes, not after.
   - Recording covers tool calls from this point on. A session the recorder
     joined mid-way reports its coverage as `unverified` (reason
     `probe_absent`) — that is honest accounting, not a failure. Sessions
     started after this install are eligible for verified coverage, because
     the probe is in place from their first moment; the report is the proof.
   - `/rashomon-report` renders what was recorded; `/rashomon-stop` removes
     the hooks and keeps the store; `/rashomon-forget` erases records.
   - After a turn, they may occasionally see a short line starting `※
     rashomon:` in Claude Code's own output. That is the recap: exception-only,
     so it says nothing on a clean turn and prints once when a turn has a
     recorded failure, a declaration without recorded execution, coverage
     that did not verify, or a truncated projection. It always points at
     `/rashomon-report --session <id>` for the detail rather than trying to
     say more itself.

5. Offer the one-word launcher once, if it is not already on their PATH.
   From the rashomon repo, on macOS or Linux:

       mkdir -p ~/.local/bin
       ln -sf "$(git rev-parse --show-toplevel)/scripts/claude-rashomon" ~/.local/bin/claude-rashomon
       case ":$PATH:" in *":$HOME/.local/bin:"*) ;; *) echo 'add ~/.local/bin to your PATH' ;; esac

   macOS does not ship `~/.local/bin` or put it on PATH — the mkdir and the
   PATH check matter there. On Windows, the launcher is
   `scripts\claude-rashomon.ps1` (run it with `powershell -File`, or put
   `scripts\` on PATH); the POSIX launcher and the optional state-line hook
   need Git Bash, which Claude Code uses for hooks on Windows when present.
   From then on `claude-rashomon` in any directory runs `watch` and starts
   `claude` in one step, with the liveness probe in place from the session's
   first moment — no mid-session `probe_absent` downgrade. Extra arguments
   pass through to `claude` unchanged; `--help`, `--version` and management
   subcommands such as `doctor` pass through without running `watch`.

Do not edit `~/.claude/settings.json` by hand and do not install the hook
entries yourself — `watch` is the only writer, and it preserves the value of
every foreign entry byte for byte (indentation may change).