plugins

anu/plugins

The single marketplace for the Claude Code / Pi plugins used with anu — developed in place, alongside the harness. anu init registers this directory as a local-directory Claude Code marketplace (named anu) from the stable path ~/.local/share/anu/plugins, so edits here are live immediately: no reinstall, no push, no GitHub round-trip. Every plugin listed in marketplace.json is installed at user scope on anu init, so the set stays reproducible across machines.

Harness plugins — fluency in anu itself

Plugin	What it does
orchestration	Choose a swarm topology for a task, write worker briefs, run contained (cxc) agents unattended, collect & merge. Skill driving-anu + /orchestrate.
map	Repo dossier as one fixed-template HTML page in the anu atlas (~/.anu/atlas/<repo>): summary, component tree, choices, divergences, open questions. Fans out reader agents via the Workflow tool; keeps per-run history for diffing. Invoked by /map.
ncn	Node connection: connect a host conductor (cxx) to a chosen execution node and adapt the channel to the node type — Slurm+Apptainer+tunnel for a cluster, contained box for a Mac/localhost, a live shell for remote Linux. Router skill ncn + per-profile skills; driven by ncn.
trail	The research decision trail: record hypotheses, decisions, the alternatives not taken, and outcomes as commit-message trailers; the graph reconstructs from git log (no LLM) and renders as a B&W decision graph + tempo timeline in ~/.anu/trail/<repo>, open hypotheses highlighted as awaiting a verdict. Skill trail teaches the trailer discipline; run trail.

Work plugins — find, then communicate research

Plugin	What it does
ideas	Map the idea-space around a research direction: /prior-art (prior work + honest novelty read), /similar-code (codebases already doing it), /lineage (what a paper builds on + what cites it), /study (situate + understand one paper → a dossier site in the atlas), /delve (explore a paper end to end → dossier + interactive demo, the conductor composing /study and /present). Grounded retrieval via the bundled scholar engine (OpenAlex + GitHub) — every result is a real, fetchable source, never recalled. Fresh-context screener agent for novelty calls.
science-writing	Audit/polish papers post-writing: /verify-citations, /check-claims (Crossref/OpenAlex/Semantic Scholar), /peer-review (ICLR/ARR guidelines), /rebuttal, /presubmit, /arxiv-prep, /critique-figures, /style-critic; IMRaD/abstract/citation craft. Never autogenerates.
tikz	Publication-quality TikZ, tikz-cd, pgfplots; /render-tikz runs a compile → render → visual-audit loop.
writing-styles	Rewrite prose as Hemingway, academic, plain-language, or technical-blog.
explore	Self-contained interactive HTML codebase report — architecture tree, design choices inferred from code + git history, traced main path, churn hotspots. (Single-file, harness-agnostic sibling of map.)
marimo	Author reactive marimo notebooks; /new-marimo; post-edit marimo check hook.
manim	Manim CE scenes/animations/3D; manim-ce-vs-gl disambiguation; /manim-preview and a /manim-review that watches rendered frames.
investigate	Run the research loop, don't just record it — the doing-stage twin of /study. Frame a question (or a /study gap) into falsifiable hypotheses, test each in its own git worktree agent (one per hypothesis — cxc contained by default, cxx host when they share a toolchain), adversarially verify the outcomes against their real evidence, and render one fixed-template investigation in the atlas (~/.anu/atlas/investigations/<slug>): verdict, what was learned, every hypothesis with its prediction/evidence/verdict, the roads not taken, the open frontier, and a link to the decision trail. Launch + watch it converge in one shot: investigate "<question>" opens a window with the swarm + a live investigate watch cockpit (the delve twin); trail swarm watch draws the same as a browser matrix. Execution = the swarm; decision record = trail. Composes trail + swarm + box; /investigate, launcher investigate, worker skill running-experiments.
present	Turn an exploration — or a distilled idea/mechanism from a /study gap — into a served, visual presentation: pick the medium per result, tooling-aware (Manim animation · marimo app · static figure · served notebook · a zero-dependency interactive HTML when no stack is installed), render on the right compute via ncn, assemble, and serve reachable over Tailscale. Composes manim + marimo + ncn; /present.

The research arc — ideas and its siblings form one pipeline: find (/prior-art, /lineage, /similar-code — grounded command-flows that answer in chat) → understand (/study) → do (/investigate) → show (/present), with trail recording the decision graph throughout. The last three each render a fixed-template artefact in the atlas — a dossier, an investigation, a served demo — by different engines (a fan-out workflow, the swarm, and curation respectively). /delve conducts understand→show end to end; its delve shell launcher shows the run live as tmux panes (delve watch) or a browser control room (delve dash). /investigate is the do stage, run on the swarm.

explore and map are both repo-mappers, kept as deliberate siblings: explore is a single self-contained HTML file (works in any Claude session); map is the anu-native version that writes to the atlas and diffs over time.

How it's wired

plugins/                              # this marketplace's root
├── .claude-plugin/marketplace.json   # name: "anu" — lists every plugin
└── <plugin>/
    ├── .claude-plugin/plugin.json
    ├── skills/<skill>/SKILL.md
    ├── commands/<cmd>.md
    ├── agents/<agent>.md
    └── hooks/hooks.json              # optional (e.g. marimo)

anu init → claude plugin marketplace add ~/.local/share/anu/plugins → installs every plugin in marketplace.json at user scope. Adding a plugin = create the dir, add it to marketplace.json, re-run anu init (or claude plugin install <name>@anu --scope user).

map and ncn reference their bundled assets (workflow.js, render.py, .sbatch) by the stable path ~/.local/share/anu/plugins/<plugin>/skills/…, so they resolve regardless of how Claude Code caches the plugin — fine, since both are anu-coupled.

Adding a plugin

1. mkdir -p plugins/<name>/{.claude-plugin,skills,commands} and write plugin.json.
2. Register it in .claude-plugin/marketplace.json.
3. Live in the next Claude session (local-dir marketplace), or claude plugin install <name>@anu --scope user now.

Keep command filenames globally unique across plugins (Pi has a flat /command namespace), and give every skill a rich description (both harnesses route on it; Pi drops skills without one).