#Rerail in-session surfaces

• OMP and Pi: native extension commands. /rerail-create and /rerail-show-me hand instructions to the agent; /rerail-uninstall asks you with a selector.
• Claude Code: setup adds hooks, adds Rerail to your status line, and writes commands to ~/.claude/commands/ with their tool permissions. /rerail-start may run set-up's commands without re-asking, so in a repository not set up the agent relays each set-up question to you. /rerail-uninstall is not pre-approved; Claude Code asks first.
• Codex: one skill per command in ~/.codex/skills/<name>/SKILL.md, invoked as $rerail, $rerail-manage, and so on. Codex's hook trust and command approval still apply; it may ask before $rerail reads the local daemon.
• Cursor: the same commands in ~/.cursor/commands/.

• This includes a command a Git worktree inherits from its main checkout; later edits to it apply without reinstalling.
• It refreshes every five seconds unless you set your own interval.
• Re-running setup changes nothing. rerail install --remove restores your previous status line and interval and leaves other settings alone.
• What Rerail replaced is recorded in ~/.rerail/harness.sqlite.

• Rerail is on, silent until a rule is broken, and what a steer looks like.
• A steer is advice: fix it, or tell you in one line why not, and carry on.
• Answer "why?" from the steer: the rule id and what it matched.
• Ask before turning a rule off or changing its mode; never turn a rule off or stop Rerail on its own to get past one.
• The session's dashboard link, and that /rerail (Codex: $rerail) lists the commands.

Cursor shows you nothing from a hook, so there the note also asks the agent to begin its reply with each steer's line.

The note and steers guide the agent; nothing enforces its replies.

Findings appear in the order found. The place is path:line:col, the bare path for a whole-file finding, or omitted without a path.

A suggested fix follows its finding: Suggested fix: delete <range>, Suggested fix: replace <range> with <code>, or, over several lines, Suggested fix, replacing <range>: and a ~~~ fence. Ranges use an en dash (3:1–5:2). Fixes over 240 characters end in … (truncated).

The block has no Rerail vocabulary: no glyphs, modes, packs or links.

Repository text (paths, captured code, fixes) is cleaned: control and invisible characters go, and line breaks inside a line become spaces. Parts are capped and marked …: places, rule ids and tool names at 300 characters, message lines at 600, a whole message at 2,000, and snippets at their first line and 80 characters.

• Several findings read Fix these, …; a tool call's guidance reads Follow it or Follow these.
• The command names the rule when there is one; with several, the agent fills in <rule-id>.

Block-mode rules steer the same way; blocking is not built yet. Log-mode rules never reach a session.

• Mark: the footer's coloured R E R A I L where the agent draws colour (Claude Code, OMP); the word in Codex and Cursor.
• Link: why? appears only while a daemon answers on a loopback address. With none, or one bound to 0.0.0.0, the line has no link rather than a dead one.
• Glyphs: ◆ steered, ○ logged. Log-mode rules never reach a session, so sessions show ◆ only.

Where your line appears, and what happens to a steer found as the turn ends:

• Claude Code: under the tool call, after PostToolUse:<Tool> says:; two or more lines start on their own line. why? is a link in terminals known to draw them (below), else why? → <url>. A turn-end steer shows its line then; the block reaches the agent at its next tool call or session start as a late steer, never with your next prompt.
• Codex: under the tool call (↳ Hook · …), plain: … steered  ·  why? → <url>. A turn-end steer shows its line then; the block rides the next hook carrying context (your next prompt, a tool call, a session start) as a late steer.
• Cursor: no line of Rerail's own; the agent is asked to begin its reply with … steered  ·  [why?](<url>). A turn-end steer waits for the next tool result or session start.
• OMP: drawn in OMP's theme colours, why? a link where the terminal draws them. Ctrl+O expands it to show each rule's source and the block, dimmed. A steer riding an edit's tool result shows right after that call's results, before the next model call; the agent never sees the line. At turn end, the run waits up to 10 seconds for the turn's check, then pending steers continue the run before it reports done. A steer arriving once the session is idle waits for your next message.
• Pi: Pi's default message card, showing the whole block; Pi's extension API gives Rerail nothing to draw its own line with. Turn end as OMP.

• Claude Code, Codex, Cursor wait up to one second after an edit for its check, so the agent sees the steer under the edit and can act that turn. Checks usually take tens of milliseconds.
• OMP and Pi wait up to 10 seconds at a tool result and at turn end, so a shell command that wrote thousands of files does not stall the agent for minutes.

Slower checks steer at the next hook, reply or poll. The waits are fixed, not per rule.

A steer never becomes your message, before or after the agent compacts its context:

• OMP and Pi: a steer from an edit's own check goes into that tool result. Later ones are Rerail messages, which compaction summaries label automated rule checks, not your messages.
• Claude Code and Cursor: context beside a tool result or at session start, never with your prompt.
• Codex: a developer message, which can arrive with your next prompt but is not part of it.

• A shell result, or a turn end, waits up to 10 seconds for Rerail to find what the shell wrote. Later finds are steered at a later step, and the dashboard timeline says rules had not yet seen shell edits there.
• A file the shell deleted is reported only if Rerail had seen it.

In a large repository, Rerail indexes at session start before code rules can run; nothing waits for it.

• Edits made meanwhile are not checked at their own result; the first pass after indexing checks every changed file.
• OMP's footer shows · indexing while it lasts, only if it takes over half a second.
• The dashboard timeline says code rules were not yet running at those steps.

• Only a session start may start the daemon. Other hooks that find none let the call go at once, so you get no hook error under every call.
• In OMP and Pi, a Rerail tool hook releases the tool after 25 seconds regardless.
• Codex, with no footer, shows Rerail ✕ not running · start it with: rerail daemon start once at session start.

Events the OMP or Pi extension cannot hand to the daemon are recorded as a gap, not lost silently. Meanwhile the footer adds Rerail: N session events dropped — daemon not answering (not under silent), and the dashboard timeline counts the events that never arrived.

• · worktree after the rule count, while the checkout runs its own rules from .rerail/rules (a worktree's own rules). Links to their pack page: R E R A I L ● 27 rules · worktree · steered 3×.
• · N to approve while N rules or packs on here run in Log awaiting approval; a pack counts once. Links to the repository's Overview, which lists them.
• · indexing in OMP, not Pi, during indexing (above).
• engine unavailable if the rule engine could not load.
• audit failed (N failures) if the latest audit failed; N counts every failure, including any beyond its list of at most 20.
• For a completed audit with gaps: N files not checked, N rules ran out of work, N rules stopped by file work.

The footer never animates. Full audits and rule lists are on the dashboard.

• Rules is the session's configured coverage: code and conversation rules that are on, including mid-session changes. Not rules matching the current file, nor checks that passed.
• Steered counts lines you saw: two rules in one edit count 2; a delivery naming no rule counts 1. A Claude Code turn-end steer counts once, when its line shows. Logs, matches, queued guidance and failed sends don't count.
• Unknown is not zero. Older sessions, and history lost in a reset, show steering unavailable; recomputing coverage shows rules unavailable.
• A steer proves nothing about whether the agent read it or fixed anything. A crash right after sending can leave it uncounted.
• Violations are not a to-do list or a review-ready signal. Rerail running normally and an audit reporting failures are separate states.

• The six letters run from #A5ADFB to #ECDAE4: 24-bit where COLORTERM is truecolor or 24bit, else the nearest of 256 colours, none under NO_COLOR.
• The state mark is coloured by state (● green, ○ dim, ✕ red); nothing else is.

• Supported: kitty, Ghostty, WezTerm, iTerm2, VS Code, Alacritty, Windows Terminal, Orca, and tmux 3.4 or later; never GNU screen.
• Override: RERAIL_NO_HYPERLINKS=1 or RERAIL_FORCE_HYPERLINKS=1 (OMP: PI_NO_HYPERLINKS / PI_FORCE_HYPERLINKS).

The footer always carries its links; your terminal decides if they are clickable.

A preference is compact (default) or silent, keyed by repository and coding agent; empty means all. The most specific wins: repository and agent, repository, agent, database default, then compact. Removing an override reveals the next.

Preferences live in the Rerail database and survive rerail reset.

• repository is an absolute path; symlinked spellings (/tmp, /private/tmp) match.
• Changes show at the footer's next refresh.
• Preferences are read through the daemon, so without one the footer shows not running even if silent is stored.