Rho-plugins owns reusable functional capabilities: documents/code, files and artifacts, runtime adapters and object inspection, requirements, tables, media, charts, Agent integration and anchored feedback. Each capability owns its behavior, native preconditions, resources, results and checks. Project analysis workflows compose these capabilities; they are not plugins.
Rho-core supplies the execution foundation. Rho assembles components into an application. A component can serve headless callers and application users through optional CLI, Skills, MCP or UI entries to the same functionality.
The reusable plugin model defines capability ownership, headless and UI entries, resource/selection contracts and extraction acceptance. The concrete catalog names the first-party capabilities and their entries. UI entry designs do not establish shipped renderers. A plugin can contribute several views over one state owner. Rho selects and arranges those entries; a workflow's dataset, method choices and sequencing stay in project code or an example. The current source supplies twelve independently versioned capability packages and optional browser entries. The selected Rho composition determines which entries are installed and usable.
The twelve @rho-workspace/plugin-<id> packages have independent versions, pinned in
each package manifest and the selected application composition. Each
ships its own implementation and descriptor; the generic Contracts package is
shared infrastructure, not another capability. The source root is private and
cannot be packed as an aggregate runtime package.
| Plugin | Available headless behavior | Owner reference |
|---|---|---|
documents |
One shared Unicode buffer per document, edits/undo, conditional save and frozen snapshots | Documents |
files |
Scoped resource registration, immutable bytes, inventory and integrity checks | Files |
r |
Explicit script execution plans and bounded exported object snapshots; Core owns managed execution | R |
requirements |
Declared R dependency probes and explicit project-library preparation plans | Requirements |
tables |
Declared types/nulls/keys, bounded pages and keyed two-input comparisons | Tables |
media |
Original image/PDF bytes and metadata, checked coordinate context and a browser media view | Media |
charts |
Validated scatter bindings, stable entity mapping and explicit sampling | Charts |
agent |
Frozen context, bindings/receipts, durable caller intents and project-scoped stdio MCP | Agent |
annotations |
Version-anchored feedback and explicit replies over Documents drafts and source-owner-validated anchors | Annotations |
console |
Commands a person runs in the project folder, with kept output, stop and restart-honest endings | Console |
kernel |
Live R and Python sessions an Agent and the person share: cells, output, plots, variables, interrupt and restart-honest endings | Notebook |
skills |
How work is done in a project, as SKILL.md files every Agent reads: each change's author, reason, evidence and undo | Skills |
@rho-workspace/plugin-markdown and @rho-workspace/plugin-html are UI extensions
over Documents, rather than separate content owners
(Markdown, HTML).
@rho-workspace/plugin-agent-icons supplies browser assets and name matching
(Agent icons); it contributes no capability
operations, Skill or standalone view.
Each capability's public plugin descriptor records its own operations, optional
components and digest-bound Skills. A component declares its identity/version,
bindings, props schema and UI entry. A Skill declares its identity/version, digest
and content, with optional intent, required operations, example, failure guidance
and verification command. A verification command is guidance, not a current pass.
Documents also declares its native Claude Code Skill and edit hook in claudeCode.
Agent 0.4.33 declares the shared MCP entry in plugin.agent.mcp: its package export,
transport and the actual four tools. plugins/agent/src/mcp-entry.ts supplies both
this metadata and the stdio server's tool list. Other capabilities are reached
through operations on that bridge, within the connected Agent's grant; they do
not each imply another MCP server.
Rho projects these declarations into its live capability.list and a retained
build inventory, without copying Skill content into the descriptive inventory.
Its Plugins page reads the same records; UI extension views retain their own
package/version under their capability owner. An absent owner stays describable
without being imported or enabled. Runtime third-party packages instead supply
rho-plugin.json; their operations, Skills and views are read through
extension.describe. Application-owned workspace Skills and project-owned
Skills have separate owners. The application disclosure episode
records the observed gaps, browser results and remaining limits.
Every owner ships entryVersion:1.0, versioned operation input/output contracts,
dependency and side-effect declarations, and a digest-checked Skill in its compiled
npm entry. Skills install no global Agent configuration and grant no authority.
An owner may also declare claudeCode skills and hooks for the Claude Code sessions
an application starts; the Agent entry writes them into one plugin directory named by
its content (Documents: a native skill and a PreToolUse hook).
The shared MCP adapter filters both tool discovery and calls against the live
project catalog, grants and optional plugin filters. HTTP and MCP use the same
functional owners.
The collaboration guide covers the ninth owner and entry declarations. Documents validates exact UTF-16 ranges; Tables validates stable-key entities at an exact resource version. Annotations freezes submitted drafts and source snapshots without creating another mutable buffer. Context preparation, a tool fetch and an explicitly linked reply remain separate facts; none proves model understanding or work completion.
The headless guide, package inventory and public interface reference describe the original eight-owner foundation; the collaboration guide records its additive extension. Status is the current implementation and verification summary.
Agent evaluation is a separate development tool: isolated public Core CLI trials, domain-owned checks and offline regrading. Its recorded execution is independent of capability package and application acceptance.
The paired airway analysis is a scientific
example and acceptance consumer: DESeq2 analysis, donor sensitivity, simulations
and artifact checks. Its scientific/execution record
is retained. Neither it nor the ordinary base-R project
is shipped in any capability package. Both explicitly declare scripts, requirements,
artifacts and checks to the same r.execute capability.
The Python/R consumers, Node capability packages and selected browser views run today. A descriptor alone does not prove a renderer is installed: Rho checks the selected browser build separately. Component checks and application episodes retain their own verification scope in Status.
Use Node 22.22.x for the npm workspace. npm test builds the owners and runs their
component tests; test:examples additionally invokes native R examples. Packing
and isolated installation/import checks cover the selected capability tarballs,
not an installed Rho application. Neither example nor the evaluator is bundled.
Evaluation uses Python's standard library. Core trials take an explicitly
selected public rho-core binary. Model trials also require the configured
Claude Code CLI and model gateway described in the consumer documentation.
The R recipe uses existing R packages and ordinary files.
npm ci
npm test
npm run test:examples
npm run pack:plugins -- --destination /absolute/plugin-tarballs
npm run test:install -- /absolute/plugin-tarballs
python3 plugins/agent-eval/run.py --help
python3 plugins/agent-eval/run.py core-agent --binary /absolute/rho-core --baseline --trials 1
python3 plugins/agent-eval/run.py r-artifacts /absolute/airway/artifacts
python3 -m unittest discover -s plugins/agent-eval -p 'test_*.py' -v
RHO_EVAL_CORE_BINARY=/absolute/rho-core python3 -m unittest discover -s plugins/agent-eval/core-agent -p 'test_*.py' -vEach evaluation writes a new evidence directory. Retained artifact checks and regrading do not invoke a model or rerun the scientific analysis. Read each consumer's prerequisites, limits and evidence scope before execution.
Scientific code/data/plots, freely composed views and Agent-driven interaction evolve in one application flow. Rho delivers an npm local service and a React/TypeScript WebUI in one browser window. Its shell arranges registered views as tabs and splits. The application's technology stack records its current libraries; native desktop windows and cross-window movement remain later scope.
Architecture defines component responsibilities and the Action, Resource, Selection and View boundaries. The 0.4 headless owners use declared types, entity namespaces and fields without scientific workflow branches. Both R projects have passed actual headless execution in Rho. Browser rendering, input and layout have separately scoped application episodes. Roadmap defines the first integrated flow. Rho's collaboration acceptance records fixed installed Full and Collaboration-minimal compositions separately from component checks and the historical eight-owner baseline. There is no universal component loader, npm registry publication or signed distribution.
Execution completion, artifact completeness, domain checks and model judgments are distinct facts. Existing authorization is checked at the actual boundary; models and retrieved content cannot broaden its scope.
See Privacy, Security and contribution instructions. Source is licensed under AGPL-3.0.