Notable changes to the rius Claude Code plugin. Versions follow
semantic versioning. The version in
.claude-plugin/plugin.json is what the marketplace installs.
- Claude Code: each turn's last model call is now sent with its turn, when the turn ends. Claude Code writes the final answer to the transcript just after the end-of-turn hook fires, so it used to reach Rius at the next hook event: minutes later, or never if the session went idle. The background export now waits up to 2 seconds for it. A prompt you queued while Claude worked keeps its own turn.
- Claude Code: a session you named (
claude --name Xor/rename) now files under that name as its agent, instead ofclaude-code. A rename mid-session applies from the next export. - Claude Code: the
/rius:*commands now run in Claude Code's default manual permission mode. They used to fail with a "shell command permission check failed" error and only worked in auto mode.
- Claude Code: a compaction becomes a
CHAINspan (gen_ai.operation.namecompaction,rius.compaction.*) beside the generations of the turn it happened in. It carries the trigger (autoormanual), the tokens before and after, the tokens dropped, the messages kept and the size of the summary that replaced the history. The summary text is content, so it is sent only where content is. The first model call after a compaction hasgen_ai.conversation.compactedset. - Codex: each
compactedline in the rollout becomes the samecompactionspan, withexecutorclientorproviderand the token counts Codex reports. Written from Codex's source and a synthetic rollout; no real Codex session with a compaction has been checked yet. - Cursor: the
preCompacthook becomes arius.compactionevent on the running generation'sLLMspan, and the nextLLMspan is flagged withgen_ai.conversation.compacted. Built from Cursor's hooks documentation; no real Cursor compaction has been checked yet. - Claude Code: a line in the session when the context first passes 70% of the
model's window, one more at 90% (only on a window above 200k), and one after
a compaction saying how much it dropped. Computed on your machine from the
transcript, shown to you only.
RIUS_CONTEXT_WARN=0turns them off. - Every Claude Code tool span carries
gen_ai.tool.call.id, the id of the model's tool_use, as Cursor's already did. - A
Skillcall's span names the Agent Skill it loaded, with the OTel GenAI conventions'gen_ai.skill.name, and, in content mode, the folder Claude Code loaded it from, asgen_ai.skill.source.uri(file://...). A built-in skill, which Claude Code unpacks to a temporary folder, gets no source. A call that failed, such as an unknown skill, names none. - Experimental, off unless
RIUS_CLAUDE_EXPERIMENTAL_TOOL_DECISIONS=true: each tool span carries agen_ai.tool.call.decisionevent for the decision Claude Code made before running the call (allow,deny, orrequire_approvalwhen it asked you first), read from thepermissionDecisionClaude Code 2.1.296 and later records, or thetoolDenialKindof an earlier version's denial. It follows an open OTel GenAI proposal, so its names may change before it is final. - Claude Code: when Claude Code stops a turn because compaction kept
refilling the context (autocompact thrashing), the model call where it
stopped is marked as an error on its
LLMspan, witherror.typeautocompact_thrashingand an exception event, so the stop shows up as a failure on the trace. Its message is sent only where content is.
-
An
agent-observabilityskill, installed withnpx skills add glassflow/rius-coding-agents: it adds Rius tracing to an AI agent or LLM app with the Python or TypeScript SDK and checks the first trace. It ships in.agents/skills/and is not part of the plugin. -
A
coding-agent-observabilityskill, installed the same way: a coding agent asked how to track Claude Code, Codex or Cursor usage and cost can set Rius up. The listings gain thecoding-agentsandtoken-usagekeywords (token-usagenot on Cursor), and the Codex listing's short and long descriptions name usage, cost and subagents. -
The plugin and marketplace listings for Claude Code, Codex and Cursor describe what a session trace holds, and carry more search keywords. The Cursor listing leaves out tokens and cost, which Cursor does not report.
-
Codex: a command that fails inside a code-mode script that does not throw now marks the
execspan as an error (exec.exit_<n>) and setsprocess.exit.code, read from the rollout's command events (as codex-cli 0.162.1 writes them). A probe such asrgortest -fthat returns 1 on purpose reads as an error too, as it does forexec_command. A call interrupted after such a command keeps that error instead of reading as unset. -
Attribute names now come from the Rius attribute registry (rius-semconv), vendored at
scripts/rius_cc/_semconv_generated.py, and CI fails when the copy drifts from its pinned release. What changes on the wire, for all three agents:- The folder, git branch and agent version are sent as the OpenTelemetry
keys
process.working_directory,vcs.ref.head.nameandservice.version, instead ofcc.cwd,cc.git_branchandcc.version(and theircodex.*andcursor.*twins). - The resource carries
telemetry.distro.name=rius-coding-agentsand the plugin's version, which tells Rius the folder and branch belong to a coding session. - A running span is marked
rius.span.pendinginstead ofglassflow.span.pending, and the instrumentation scope isriusinstead ofglassflow. - Cursor's context fill is sent as a number with a fraction
(
cursor.context.context_usage_percent).
Rius shows the folder and branch from either spelling, so older and newer sessions sit side by side in the console. Update the Rius backend before this plugin release: one that predates the new keys shows no folder or branch for new sessions.
- The folder, git branch and agent version are sent as the OpenTelemetry
keys
- Every span carries
user.id: the email you signed in with at/rius:login, which the workspace already holds as the key's approver. The console lists coding sessions by developer from it, a running one included. A key stored withuse-keyis often shared, so it sends nouser.id. Nothing in the environment can set it. - Traces are now sent as OTLP/JSON (
application/json) instead of OTLP protobuf, so the wire format is readable text and the hand-written binary encoder is gone. The receiver has accepted both since 2026-10-05. Same spans, same attributes; nothing changes in what is traced. - A square icon for the plugin's directory listing.
--env local: send traces to a Rius stack on this machine (use-key --env local).- A shell call's span says what kind of command it ran:
rius.command.classistest,build,lint,package,gitorother, withprocess.exit.codewhen the agent reports one. Worked out on your machine and sent with capture off; the command itself is not sent. Claude Code (Bash), Codex (exec_command, and code-mode scripts that call it) and Cursor (Shell). The console can then say "tests failed" instead of "Bash failed". - Codex code mode: an
execcall whose script throws is now a failed span (exec.script_failed). - Cursor: spool pruning no longer mistakes a conversation id with a dot for another one.
- Codex code mode: a secret file named through a JavaScript escape
(
"\x2eenv") now withholds the call's output.
Fixes for the Codex and Cursor betas. Claude Code: no change in what is traced or sent.
- A code-mode tool span is now named after the tools its script calls
(
exec_command,apply_patch,mcp__server__tool) instead of every span beingexec. Only identifiers outside string literals reach the name, so it is the same with content capture off. - When several code-mode calls run at once, a subagent is placed under the call that spawned it rather than the last one begun.
- With the opt-in
multi_agent_v2, subagents are no longer dropped from the trace. - The state file no longer holds turn text, replies, tool input or MCP errors while content capture is on. It keeps a reference into the rollout and the text is read back when the span is finished.
- A subagent started in a
cursor-agent --resumerun is now sent. Cursor does not firesessionStarton resume, so the subagent is linked to the chat in the same folder that is waiting on a Task call.
- The
rius_ctlusage text lists every action with the flags it takes, and the--pathlabel says it is the path of a hooks.json file. - The "no key" hints tell Codex and Cursor users to run
use-keywith--agent, so the key lands where their agent looks for it. - The note about an ignored
RIUS_CLAUDE_ENABLEDnames the agent's own variable (RIUS_CODEX_ENABLED,RIUS_CURSOR_ENABLED), and Cursor's sign-in text no longer promises token counts, which Cursor does not send.
Rius for Codex and Cursor, in beta, with the 0.5.0 hardening applied to both. Claude Code: no change in what is traced or sent.
- The plugin traces Codex CLI sessions (tested with codex-cli 0.144.1).
Install with
codex plugin marketplace add glassflow/rius-coding-agentsandcodex plugin add rius@rius-coding-agents, trust the hooks in/hooks, then type$rius:rius-loginand$rius:rius-enable-here. Each session is one trace of turns, model calls with token counts (cached and reasoning split out), tool calls and subagents; a resumed session continues it. Codex has no SessionEnd, so a Codex trace is closed by a later Codex session once the old process has exited and it has been idle for an hour. (#27, #31) - Codex keeps its own key, settings and state in
~/.codex/rius, under the home folder the operating system reports.CODEX_HOMEis not used for them, so a repository cannot point Rius at a key or rules it ships. - The bundled MCP server signs in with OAuth:
codex mcp login rius. - A subagent spawned with
fork_contextstarts from a copy of its parent's history; those inherited turns are not sent again, so the parent's model calls are counted once. Nested subagents (depth 2 and more) stay under the subagent that spawned them. - In Codex's code mode (on by default), a subagent spawned from inside an
execcall hangs under that call; before, it and its model calls were never sent. The text ofexecoutput is scrubbed as text, one line per part, so aname = secretline is no longer missed, and a script that reads a secret-shaped file has its output replaced whole as well. - With content on, Codex and Cursor remove secrets as Claude Code does:
every content attribute and error line is scrubbed, and a read of a
secret-shaped file (
.env*,*.pem,id_rsa*, ...) is replaced whole. - The skills only run when you type them (
allow_implicit_invocation: false).$rius:rius-enable-content-hereis the Codex form of/rius:enable-content-here.
- The repo also ships a Cursor plugin (
.cursor-plugin/): one trace per conversation with turns, model answers, tool calls and subagents. Cursor reports no token usage, so there is no token count or cost. Install it with "Import from Repo";rius_ctl.sh install-hooks --agent cursorcoverscursor-agentbuilds that ignore plugin hooks. (#25, #28) - Cursor keeps its own key and state in
~/.cursor/rius. Spools of conversations idle for 7 days are deleted once their trace is closed. - Built from real
cursor-agent(2026.10.01) payloads: a headless run is one turn, a Task subagent hangs under its Task call (parallel Tasks each under their own), and the local spool holds content only with secrets removed, never the output of a secret-shaped file read. - The bundled MCP server signs in with OAuth (Connect in Cursor's MCP
settings). The
/rius-*commands only run when you type them.
RIUS_API_KEYandRIUS_ENDPOINTare ignored, as for Claude Code: sign in with the login skill or command, or store a console key withrius_ctl.sh use-key --agent codex|cursor.RIUS_CODEX_ENABLEDandRIUS_CURSOR_ENABLEDcan only turn tracing off.- Hooks go through the same launcher as Claude Code's (
python -I, no interpreter from inside the project), with 10 s / 5 s timeouts. A signed-out Codex or Cursor user starts no Python on a tool call. - Conversation and subagent ids must look like ids before they name a
file.
--agentis checked like every otherrius_ctlflag.
Hardening for Anthropic's plugin directory: safer defaults, sign-ins that can't be redirected, and no slowdown when Rius is off.
Update with claude plugin marketplace update rius-coding-agents && claude plugin update rius@rius-coding-agents (see Updating),
then restart Claude Code or run /reload-plugins.
- Querying traces needs one OAuth sign-in. Run
/mcp, pickriusand sign in. The/rius:loginkey no longer reaches the MCP server. RIUS_API_KEY,RIUS_ENDPOINT,RIUS_ENVandRIUS_CLAUDE_ENABLED=truein the environment are ignored. For staging, run/rius:login --env staging. Sign in with/rius:login, or store a console key withrius_ctl.sh use-key(see API keys). Use/rius:enable-hereto turn a folder on.- Folders you enabled before keep sending content until you pick:
/rius:statusasks. New folders send structure only unless you run/rius:enable-content-here. - A plain
http://endpoint that isn't on this machine is refused.
- Cursor and Codex can run Claude Code plugin hooks: Cursor does so by
default through its third-party compatibility setting, and Codex installs
this plugin from the same marketplace. Their sessions no longer show up
as empty "claude-code session" traces with a heartbeat. The hook now
ignores a payload that carries Cursor's
cursor_versionorconversation_id, or whose transcript is a Codexrollout-*.jsonlor lies underCODEX_HOME(~/.codexby default). (#24) - The bundled Rius MCP server now signs in with Claude Code's own MCP OAuth:
run
/mcp, pickriusand sign in with your Rius account. It no longer uses the/rius:loginkey, which from now on is only for sending traces./rius:statusand/rius:loginsay this in two lines:Tracing: signed in as workspace XandQuerying traces: run /mcp and sign in to rius. - The bundled server's URL is fixed to
https://mcp.eu.console.rius-glassflow.com/mcp.RIUS_MCP_URLis gone, along with the headers helper and theMCP:andMCP key:lines in/rius:status. To query staging, register the staging server yourself (see "Signing in to staging" in the getting started guide). - After a staging sign-in,
/rius:statusand/rius:loginprint the command that registers the staging MCP server instead of pointing you at production, and/rius:statussays whenRIUS_MCP_URLis still set. - New sign-ins no longer store an
mcp_urlincredentials.json. Older files that have one keep working. (#35) - Private content is off by default, and secrets are removed.
/rius:enable-herenow sends structure only: models, tokens, cost, timing, tool names and error types, but no prompts, replies, file contents or command output. The new/rius:enable-content-heresends those too, for that folder only, after replacing the secrets the plugin recognises (cloud, GitHub, Slack, Stripe, OpenAI, Anthropic and Rius keys, JWTs, private keys,password=style values, Authorization headers) with a marker such as[redacted:aws-key], and dropping the output of reads of.env, key and credential files. Claude can run neither command for you, and each command's permission grant now covers only its own subcommand. A folder enabled before this release keeps sending content, and/rius:statusasks you to pick. A session turned on with/rius:onin a folder no rule enables sends structure only. A failed tool's withheld detail now readscontent capture off. (#38) - A repo you clone can no longer turn tracing on, or redirect your traces
or your key. Claude Code hands hooks the
envblock of a project's committed.claude/settings.json, so the environment may now only turn things off:RIUS_CLAUDE_ENABLED=falsestill turns tracing off.=trueis ignored: only/rius:enable-hereor/rius:onturn tracing on, and a/rius:disable-herefolder stays off unless you run/rius:onin that session.RIUS_CAPTURE_CONTENTcan only lower capture.RIUS_API_KEYandRIUS_ENDPOINTare ignored. The plugin traces only with the/rius:loginkey, and sends it only to the server stored with it, which must behttpson one of the hosts Rius runs for that environment./rius:loginrefuses to store a key whose ingest or MCP server is not one. If you usedRIUS_API_KEY, run/rius:login, or store a console key withrius_ctl.sh use-key [--env staging], which reads it from stdin and takes the endpoint from the environment you name.- The plugin finds your home folder from the operating system, not
HOMEorUSERPROFILE, which a repo could point at a folder it ships with its own key and path rules. RIUS_CLAUDE_MAX_ATTR_BYTEScan only lower the cap, andRIUS_SERVICE_NAMEmust be a short plain name./rius:statusprints one line for each setting that is ignored, and the session's start logs it in~/.claude/rius/log/. (#37)
- Each session now starts with one short line saying whether Rius is
tracing it, and to which workspace, with content on or off. A folder you
enabled before signing in says to run
/rius:login. Right after install, Rius says once how to get started, then stays quiet until you opt in. It is a status line for you, with no instructions for Claude, and a resumed or compacted session sees it again only if it changed. A session that stopped tracing when its folder was disabled is not told it is tracing. - When the backend refuses data because the trial ended or the workspace is
locked or paused (HTTP 402), the plugin used to drop it without a word.
Now the next session and
/rius:statussay so. The notice clears after the next successful export. (#33) - Zero values show up correctly in traces: attributes holding 0, 0.0 or
an empty string keep their value and type, so a filter for
= 0finds them. Unknown resource values (no git branch, no Claude Code version) are left out instead of sent empty. Ints outside int64, lone surrogates, dicts and bytes are encoded instead of wrapping or crashing. (#29) - The key is only sent over https (plain http only to this machine), and
redirects are never followed. Everything under
~/.claude/riusis owner-only (0700 folders, 0600 files), a path-shaped session id is ignored,/rius:enable-hererefuses your home folder and its parents, and the temporary hook payload never lingers. (#30) - The plugin never slows a session down: with no stored key and nothing to
report,
hook.shexits before starting Python. Every hook declares a timeout (SessionEnd 5 s). Python runs isolated (-I), never from inside the project folder or a relativePATHentry, and never as the macOS Command Line Tools stub. An absolute path in~/.claude/rius/pythonpins the interpreter. (#36) - Only you can run
/rius:*commands: every command setsdisable-model-invocation, each action accepts only its own flags and values, typed text reaches the script as one quoted word, and each command's permission grant covers only its own subcommand. (#32) /rius:loginno longer hangs over SSH or on a machine with no display: it opens a browser only on a desktop session, and never a console browser. The printed link and code always work. (#34)- Internal: paths and names come from an agent profile, in preparation for Codex and Cursor. Claude Code's behaviour and wire bytes are unchanged. (#26)
- A session that is killed or crashes, and so never sends SessionEnd, no
longer stays pending forever and missing from the Agents and Users tabs.
The next session you start with the same API key closes its trace once
it has been silent for 12 hours and Claude Code is no longer running.
The trace ends at the last thing the session did, and the closing spans
carry no content. A trace opened with a different key, such as a
project's own
RIUS_API_KEYfor another workspace, is never closed this way, because its closing spans would land in the wrong workspace. To tell keys apart, the state file keeps a short hash of the key and endpoint, never the key. (#21)
- On macOS,
/rius:enable-herein a folder under/tmp, in any folder reached through a symlink, or in a folder typed in the wrong letter case, now works. The rule kept the shell's spelling,/tmp/proj, while Claude Code gives the hooks the resolved folder,/private/tmp/proj. No rule matched, so every hook quietly sent nothing, and/rius:statusstill saidonwith 0 spans exported./rius:enable-hereand/rius:disable-herenow store the resolved folder. Rules are still matched as written: a rule never follows a symlink that is created or repointed later. A rule an earlier version wrote through a symlink still does not match./rius:statusnames it, and running/rius:enable-herein that folder again replaces it. Old disables are repaired by any rule change, so enabling a parent again never traces a folder that was disabled under it. /rius:statusdecides for the folder the hooks see and shows it when it differs, as incwd: /tmp/proj (hooks see /private/tmp/proj). When tracing is on but no hook has traced the session, it says to restart Claude Code. A plugin installed mid-session is not hooked into that session.- A path rule whose fixed part is the filesystem root, such as
/*orC:\*, matches nothing, like/already did./rius:enable-hereand/rius:disable-herenow refuse such a folder instead of saying they changed it.
- A conversation Claude Code moves to a new session id (sending a session
to the background does this) stays one trace, like a resumed session.
The new session's transcript opens with a copy of the whole history, and
the plugin sent it all again as a second trace: both traces started at
the same millisecond, every token, cost and error before the move counted
twice, and the first trace never closed. The new session now skips the
copied history and carries on in the same trace, under the same root and
session.id, as a new instance. Its turns carrycc.continued_from. Subagents still running at the move keep landing in the trace, the conversation's root closes at the continued session's end, and a mid-session disable carries over to the continued session. (#12) - The trace is titled with the Claude Code session's name instead of
claude-code session: the/renameor--nametitle, else the title Claude Code generates from the first prompt. A rename mid-session renames the trace at the next hook event. WithRIUS_CAPTURE_CONTENT=falseno name is sent. The agent staysclaude-code. (#16) - No behavior change: a code comment says the tool-error message cap bounds size, not content (#13); the bug form says where to find the plugin version (#15); and a test pins the late continuation check that keeps a stopped conversation from sending content (#17).
/rius:statussays when a session was stopped by a mid-session disable: it readsRius tracing: offwith aStopped:line, instead of theonthe folder rules alone would give.- Each model API response is one generation span. Claude Code writes a
response as one transcript line per content block, each repeating the
usage, and the plugin made a span per line: tokens and cost were counted
once per block, often 2-6 times over. Lines are now grouped by
message.id, the usage is counted once (from the response's last line, since streamed subagent lines carry partial counts), and the response's tool calls all sit under it. - Background subagents' model calls are traced. A background subagent's
Agentcall returns a launch acknowledgement at once, and the plugin stopped reading the subagent's file there, when it held only the brief: the subagent showed 0 tokens and no children, and its span ended at the acknowledgement. The file is now read for as long as it grows, and the subagent's span runs from its first line to its last, not from theAgenttool_use line, which can be stamped tens of seconds before a parallel batch of subagents starts. gen_ai.usage.input_tokensincludes the cache reads and writes, as the OTel GenAI conventions, the Rius attribute reference and the Rius SDKs define it. Anthropic's own count leaves them out (2 fresh tokens next to 50k cached is normal), so Rius token totals left out every cached token. Thinking tokens are sent asgen_ai.usage.reasoning.output_tokens.- Each generation carries
rius.context.sizes: the byte sizes of what its prompt held (user and assistant history, the current turn, each tool's calls and results), estimated from the transcript. The console's Context panel showed only "cached prefix" and "fresh input" for Claude Code sessions because the plugin sent neither content nor sizes. Sizes are not content and are sent with capture off too. - A failed tool call carries an
exceptionevent whose type is the tool and how it failed (Bash.exit_1,Write.tool_error) and whose message is the one line that says why, such as a traceback's last line. The console groups errors by that event. Without it the whole tool output was the error's type and message, so an 80-line file piped before a failinggrepbecame an error type, and each distinct output was its own group. The status message is that same line; the full output stays inoutput.value.
- A session whose folder is disabled mid-session (
/rius:disable-here,/rius:off,RIUS_CLAUDE_ENABLED=false) still closes its trace when it ends, so it is counted on the console's Agents and Users tabs. Nothing from after the disable is sent, the closing spans carry no content, and re-enabling the folder does not resume that session; a new session does. - A tool call that never returned (interrupted, or the session ended mid-call) is closed at session end instead of staying pending, which kept the whole session out of those counts too.
- The README leads with what Rius shows and how to install. Reference
material moved into
docs/pages (installing and updating, how it works, API keys), and the design records moved todocs/design/.
Production is the default.
/rius:loginsigns in to production (console.rius-glassflow.com). Staging needs/rius:login --env stagingorRIUS_ENV=staging;--envwins overRIUS_ENV.- An unknown environment name is refused instead of falling back to production.
- Polling the sign-in host never runs faster than every 2 seconds, whatever interval the server asks for.
- The bundled MCP server points at the production MCP host
(
mcp.eu.console.rius-glassflow.com) by default. /rius:statusprints the MCP URL in use. When the stored key belongs to another environment,/rius:statusand the login flow print theRIUS_MCP_URL=setting that fixes it.- The bundled MCP server always uses the
/rius:loginkey. Claude Code withholds credential-named variables from a plugin's headers helper, soRIUS_API_KEYapplies to tracing only./rius:statusprints which key the MCP server has (MCP key:). /rius:enable-heresays what the folder will upload and to which workspace (or that it will send once you sign in, when there is no key yet), names disabled subfolders it does not reach, and shows how to stop.- README and getting started cover production hosts, with staging as its own section.
Renamed from rius-claude-code to rius. See
Installing and updating
to move over without duplicate hooks.
- One slash command per action:
/rius:login,/rius:logout,/rius:enable-here,/rius:disable-here,/rius:status,/rius:on,/rius:off. /rius:loginopens the Rius console in the browser, where you pick a workspace and the plugin receives a key for it. It replaces the device-code flow from 0.2.0./rius:logout, and a re-login, revoke the previous key on the server before deleting it locally./rius:disable-hereturns a folder off. A disabled folder beats any enabled parent, and/rius:enable-hereunder a disabled parent says the folder is still off.- Only one login wait runs at a time, and it stays inside its time budget.
- The Rius MCP server is bundled as
riusand authenticates with the key from the login command through a headers helper, so the key never lands in an MCP config file. - A 401 from ingest is treated as transient, so spans sent right after login are not lost while the new key propagates.
- The login code is shown before the wait starts.
- The slash command passes its arguments through literally.
- A login command: sign in with a device code and store a key with
ingestandreadscopes.
First version.
- One OTLP GenAI trace per Claude Code session: turns, generations with token counts and cache reads, tool calls with input and output.
- Subagents are read from their own transcript files and nested under the tool call that spawned them.
- Spans are sent while the session runs, and a heartbeat marks the session alive every 15 seconds.
- Tracing is off until a folder is enabled.
RIUS_CAPTURE_CONTENT=falsekeeps structure, tokens and timing and drops content. - macOS, Linux and Windows (through Git Bash), Python 3.9+, standard library only.