Ecosystem¶

NurCLI ships with an auto-provisioned knowledge stack.

The v0.41.0 refresh records upstream skill commits and resource hashes. Complete managed trees refresh together; local additions and Nur adaptations remain available. Explicit ecosystem ensure --force updates installed companions as well as missing ones. Headroom uses its isolated uv interpreter when installed as a tool, so inline compression works without installing the library into global Python.

nur ecosystem refresh-skills refreshes only global metadata and confirms that a complete snapshot was saved. It does not resolve credentials or install packages.

Components¶

Component	Role
sgrep	Context.dev sgrep (MIT) local semantic code search behind the `sgrep` tool - static embeddings + BM25 over ripgrep's file list, exact identifiers first, piped rerank of a focused `rg` run. Built with `cargo install --git https://github.com/context-dot-dev/sgrep --locked` when cargo is present (retried at most weekly), then the 32 MB model is warmed once. `NUR_SGREP_BIN` pins or (empty) disables it. Docs: tools.md
Graphify	Code knowledge graph (`graphify-out/`) - query / path / explain
PLUR	Shared engram memory across tools and sessions
Ruflo	Vector memory + swarm / hive-mind patterns
Executor	MCP / OpenAPI gateway catalog
GraphJin	GraphJin - governed GraphQL→SQL over live databases (`graphjin` tool · `/graphjin`). npm-installed when Node is present, with a SQLite demo config seeded under `~/.nur/graphjin/` so `graphjin serve --demo --path <dir>` works out of the box; point `GRAPHJIN_CONFIG_PATH` at a real database to go live
dogwood	Dogwood runtime verification for AI agents - a Cedar-extending policy language with temporal logic (since / formerly / once / count_within) over the tool-call event stream (`dogwood` tool). Auto-installed via cargo when available (`cargo install --git https://github.com/dogwood-policy/dogwood amzn-dogwood-cli`); default policy pack under `~/.nur/dogwood/`. The reference interpreter is an on-demand evaluation/guardrail, not a runtime gate
omp	Oh My Pi coding-agent backend - metered, cancellation-aware `omp -p` delegation with authenticated economy-model discovery and isolated focused prompts (requires omp >= 18.4.4, Bun >= 1.3.14; `ecosystem ensure` auto-upgrades)
browser	agent-browser-cli real default browser bridge (Arc / Chrome / Edge / Brave / …) - perception + control via the `browser` tool; `nur browser setup` stages the extension once
terminal-browser	terminal-browser.com in-terminal Chromium (`terminal_browser` tool · `/tb`). Native/WSL when the upstream binary is present; on Windows Nur falls back to agent-browser-cli so open/snapshot/click still work
Cua	trycua/cua computer-use driver (`cua-driver`) - full-desktop automation via MCP + CLI. Auto-installed on single-shot install without the elevated autostart daemon (`-NoAutoStart`). Toggle the always-on background daemon in-app with `/cua on` / `/cua off` (`/cua status` to check); or use it on demand with `cua-driver serve` / wire its MCP with `cua-driver mcp-config`
Skills	Progressive packs (design-eng, clone-website, cybersecurity, sc-research, …) via `skill`
Plugins	In-product marketplace (`/plugins` · `nur plugins`) - install Superpowers, Vercel, Firecrawl, Chrome DevTools, Figma, Sentry, Fable, … into `~/.nur/plugins`
Takeover	`/takeover` (alias `/hijack`) imports Claude Code · Codex · Cursor · Nur · Grok Build sessions, powered by the bundled `resume-session` reader
AKM	Agent knowledge package manager (requires Node.js)
t3code	t3code driver compatibility layer - env-isolated vendor-CLI auth probing, atomic `auth.json` writes, delegate probe, and pairing tokens (`t3code` tool). Probe-only: it stores no secrets and adds no provider
Headroom	headroom-ai inline tool-result compression (default on; disable with `[headroom] enabled = false`)
OptMem	OptMem permanent memory under upstream `~/.optmem` (`/optmem` · `/memo`). `nap lines=[...]` drains up to 24 blocks in one call and never forwards upstream's next imperative
Connectome	Agent-native memory + continuity (arXiv:2606.24775 · animalabs.ai/connectome): hierarchical memories (recent / l1 / l2 / l3), an append-only chronicle, and checkpoints. `connectome` tool; injected into the system prompt while `native_memory = true` (default)
mem (HelixDB)	Harmonized memory read/write across vector, knowledge graph, and hierarchical stores (`mem` tool). Optional HelixDB graph-vector resident via `[helix_memory]` (`HELIX_URL` / `NUR_HELIX_URL`, `HELIX_API_KEY`); local native memory stays authoritative with a durable outbox for failed mirrors
TypeSafe (Jev)	TypeSafe System One typed judgments wired through the harness (`typesafe` tool · `/typesafe` · `/jev` · `[typesafe]`). Provider-agnostic: one key lifts every provider and is never the active model. The pinned `/login` entry is a sidecar (bordered, first) so catalog counts and chat routing are untouched. Docs: typesafe.md
Local Jev engines	Keyless System One backends served by one bridge (`src/jev_local.rs` + `scripts/jev_local_bridge.py`, embedded in the binary): openJev-verdict-2.0 (CPU), Bespoke-Nimble-9B (NVIDIA GPU / Apple Silicon MLX), Laya Core ML (Apple Silicon ANE, macOS 15+), plus a deterministic mock. `nur jev start` · `use` · `status` · `stop` · `selftest` · `probe`; engine flags are forwarded verbatim (`--verdict-model`, `--nimble-dir`, `--laya-model`, `--device`). Per-device refusals are actionable. Docs: jev-local.md
egaki	egaki image/video/speech (`/egaki`; ChatGPT / xAI OAuth / BYOK / Egaki plan - bare `/image` attaches a file for vision instead)
tldraw	Offline tldraw boards (`tldraw` tool · `/draw <file.tldraw>` or `/draw <idea>`; `/draw excalidraw` and `/draw pen` route to those tools)
excalidraw	Hand-drawn, publishable diagrams via excalidraw-cli (`excalidraw` tool · `/excalidraw <idea>`, also reachable through `/draw excalidraw`)
penecho	penecho canvas beyond the chat box - ink, MathJax, plots, animations (npm `penecho` sidecar · `penecho` tool · `/pen` · `/drawings` · `/penecho`)
akarso	akarso post, schedule, and reply across 14 social platforms (npm `akarso` · `akarso` tool · `/akarso` · `akarso` skill). Publishing, deleting, and connecting accounts are outward-facing and gated in manual mode
fractal	fractal hierarchical loops - Unix only; ecosystem ensure + loud warn on `node start`
infinite-headcount	Factory skill pack auto-provisioned via ecosystem packs
sc-research	First-party whitehat DeFi pack in-repo at `skills/security/SCA/` (`/sc-research` + protocol/tool playbooks + `hunting-x-linked-bounties` + historical vuln library + investigator-ops). DarkNavy `web3-skills` and Cyfrin `solskill` auto-provisioned. Lawful/in-scope only
CAD Skills	Text-to-CAD STEP-first CAD, DXF, G-code, robot-description, part sourcing, validation, and local review skills (`/cad`, `/cad-viewer`, `/dxf`, `/urdf`, `/sdf`, …)
mobile-harness	DroidRun Mobile Harness portable Android, iOS, and cloud-phone operating guides for `mobilerun-core` (`/mobile-harness`)
Interior	ddoemonn/interior / interior.dev - finished React micro-interactions (bundled `/interior` skill + `/plugins install interior` for the component source tree)

Plugin marketplace¶

Browse and install skill packs from the TUI with the same picker UX as /login (filter, ↑↓/wheel, ↵, click).

/plugins                 # open marketplace picker
/plugins list
/plugins install superpowers
/plugins enable|disable <id>
/plugins uninstall <id>

CLI (same registry):

nur plugins list
nur plugins install vercel
nur plugins install firecrawl
nur plugins disable superpowers

On disk	Role
`~/.nur/plugins/<id>/`	git clone of the plugin
`~/.nur/plugins/registry.json`	installed + enabled flags
`~/.nur/skills/`	skill packs mirrored on install so discovery always finds them

Enabled plugins are scanned on each agent turn. Catalog includes Superpowers, Vercel, Chrome DevTools, Firecrawl, Figma, Sentry, Cloudflare, MongoDB, Axiom, Railway, Fable.

On install, skill packs are mirrored in full (including references/) into ~/.nur/skills/<name>/ so discovery paths stay complete.

Default auto-install (on nur install / ecosystem ensure): superpowers, fable, mattpocock, addyosmani, builderio.

Also auto-provisioned via the skills CLI into ~/.agents/skills: design (Emil), clone-website, cybersecurity (large), infinite-headcount, Text-to-CAD, mobile-harness, DarkNavy web3-skills, and Cyfrin solskill, plus dual-write of the default set when the CLI is available. First-party /sc-research (whitehat DeFi playbooks) ships bundled. Schema 27 re-pulls those packs and the default plugins so upstream skill edits land on the next ensure.

`/plugins` catalog (browse by category)¶

Type a category in the picker filter (design, finance, trading, workflow, …). Rows sort by category then name.

Category	What lives there
`workflow`	Superpowers, Fable, Builder.io, Compound Engineering, gstack, agent toolkits
`engineering`	Matt Pocock, Addy Osmani, Anthropic official, Microsoft, curated AI skills
`specs`	Spec Kit, Spec-Driven Development, AI Dev Tasks
`engineering` (cont.)	Vercel Agent Skills, nanocodex
`design`	Impeccable, Meng To, UI Craft, Design Skills, Taste Skill, Oh My Design, Superdesign, Anydesign, UI/UX Pro Max, Awesome Design Skills, Interior (ddoemonn/interior.dev micro-interactions), recent.design set: Emil Kowalski, ibelick UI Skills, Make-Interfaces-Feel-Better, OKLCH, UserInterface Wiki, Dialkit
`design-system`	Extract Design System, Brand→Design.md, Feature-Sliced Design
`browser`	Agent Browser (vercel-labs), Chrome DevTools, Firecrawl, Playwright Skill, Figma
`deploy`	Vercel, Railway
`cloud`	Cloudflare, Google Skills, NVIDIA Skills
`data`	MongoDB, LangExtract
`observability`	Axiom, Sentry
`marketing`	AI Marketing Skills, coreyhaines marketingskills, OpenSEO, Akarso
`finance`	Finance Skills, Longbridge, Buffett, CRE, CC Finance
`trading`	Alpaca Skills, Vibe Trade
`security`	Claude Red (authorized red-team)
`science`	Scientific Agent Skills, Awesome Journal Skills
`robotics`	Robotics Agent Skills
`catalog`	Mega packs / awesome indexes (install selectively)

Install: /plugins or nur plugins install <id>. Nested SKILL.md layouts are discovered recursively and mirrored into ~/.nur/skills/<name>/ so /skill-name works.

Slash skill invocation¶

Every installed skill is addressable as a slash command - no per-skill hardcoding required.

Form	Behavior
`/skill-name`	Toggle sticky mode for this session (skill body rides every turn)
`/skill-name on` / `off`	Force sticky on or off
`/skill-name <prompt>`	One-shot turn: activate the skill and run `<prompt>` immediately

Examples:

/adhd
/fable-method fix the flaky auth test
/site-cli build a CLI for this restaurant site from capture.har
/design-eng polish the settings modal

The slash palette lists built-in commands plus matching installed skills as you type (e.g. /fab → /fable-method). Up to 40 skill hits are shown so a large install (800+) does not drown the list - type more characters to narrow.

Sticky skills appear on /status and /skills. Clear with /skill-name off.

Natural-language skill activation¶

Opt-in. Set [skills] auto_activate = true in ~/.nur/config.toml first; off by default, explicit /skill-name and the skill tool always work. When enabled and your wording matches a high-signal workflow skill that is installed, Nur auto-injects that skill's full body into the system prompt for the turn and shows a status chip:

fable-method · activated from your wording (no slash command needed)

Say something like…	Activates (if installed)
think like fable, how fable would, fable method, do it like fable	`fable-method`
fable loop, run the fable loop	`fable-loop`
fable judge, verify like fable	`fable-judge`
debug systematically, find the root cause	`systematic-debugging`
TDD this, tests first, red green refactor	`test-driven-development`
let’s brainstorm, brainstorm this	`brainstorming`
write a plan, plan first then…	`writing-plans`
execute the plan, implement the plan	`executing-plans`
verify before claiming done, check your work thoroughly	`verification-before-completion`
code review this, review my changes	`requesting-code-review`
polish the UI, emil style, design eng	`design-eng`
skeuomorphic component, neumorphic dark, rotary dial ui, `/skeuo`	`skeuomorphic-ui`
cache hit rate, cache busting, route through my proxy, own gateway	`gateway-cache-awareness`
post to X/LinkedIn, schedule a post, cross-post, `/akarso`	`akarso` (native tool)
keyword research, backlinks, rank tracking, site audit, `/openseo`	`openseo` (MCP)
dial in the …, tune parameters live, tuning panel, `/dialkit`	`dialkit`
clone this website, pixel-perfect clone	`clone-website-meta`
draw a diagram, excalidraw	`excalidraw`
resume from Claude / Grok / Codex / Cursor / Nur	matching `resume-*` skill
toolcraft, design app scaffold, craft tooling	`toolcraft` (pointer → live docs)
site cli, HAR file, watch network requests, derive a client	`site-cli`
adhd mode, i have adhd, `/adhd`	`adhd` (also sticky slash)
write a tech spec, architecture handoff	`tech-spec`
make a skill for…, fable domain	`fable-domain`
next.js app router, `/nextjs`	`nextjs`
shadcn/ui, `/shadcn`	`shadcn`
vercel ai sdk, `/ai-sdk`	`ai-sdk`

Only installed skills fire (marketplace plugin or skill pack). Unrelated chat does not activate anything. The injected skill is mandatory for that turn - the model must follow it, not freestyle a shorter path.

Skill trust and invocation flags¶

Skills that live inside a project (./.nur/skills, ./.claude/skills, ./.agents/skills) are inert until you trust them, because a cloned repo must not inject instructions into your agent on first open. /skills trust records a digest of every project SKILL.md in ~/.nur/trusted-skills.json; editing any project skill holds it again until you re-trust. While a project has untrusted skills the TUI notes it once per session. Global skills (~/.nur/skills, ~/.agents/skills, …) are already yours and need no trust.

Two frontmatter flags shape who can invoke a skill:

Flag	Effect
`disable-model-invocation: true`	User-only: never NL-activated and `skill` tool `read` refuses it; `/skill-name` still loads it
`user-invocable: false`	Engine-only: hidden from slash resolution and the `/skills` palette

Context discipline (why 1,000+ skills do not blow the prompt)¶

Skills are never bulk-catalogued into the system prompt (that burned tokens and Claude/Anthropic usage on large installs). Activation is on-demand only:

Layer	What is injected	When
Default	nothing skill-related	every normal turn
NL activation	full `SKILL.md` body for one matched skill	built-in intent phrases, skill name in the query, or unique description intent
Slash one-shot	full body + user prompt for one turn	`/skill-name <prompt>`
Slash sticky	full body every turn until off	`/skill-name` / `on` / `off`
On demand	`skill(action=list\\|read, name=…)`	model loads more when needed
`poor_mode`	skip PLUR + long memory only	cost saver - skills still activate

Works the same on every provider (Claude, Grok, OpenAI, …). Accidental discovery still works: saying a skill’s name (grill-me, superpowers) or a distinctive description phrase can activate that installed pack without a slash command.

Pointer skills (e.g. toolcraft) stay short on purpose: they route to external docs instead of embedding a long guide. Prefer specific activation phrases so casual chat does not false-fire.

Install Fable (and others) with:

nur plugins install fable
nur plugins install superpowers

First-party skill pack: the skills NurCLI ships itself - plur, ruflo, graphify, excalidraw, startup-skill, how-to-illustrate, typesafe-ai, the resume-session engine, the bro, coding-standards, prelude, tech-spec, cloudflare-composition-root, herdr skills (from dmmulroy/skills), pointer skill toolcraft, and the whitehat DeFi pack under skills/security/SCA/ - are listed in skills/bundled.json and published with every release as nur-skills.zip (signed with the same minisign key as the binaries). They are not compiled into the binary: on install / nur ecosystem ensure / nur ecosystem refresh-skills, nur downloads the pack for its own version, verifies the signature, and writes it to ~/.nur/skills (mirrored to ~/.agents/skills). ~/.nur/skills/.bundled-pack.json records the installed version; a pack that cannot be fetched leaves the previous one in place and is noted in nur ecosystem status. NUR_SKILL_PACK=<zip or checkout> installs from a local copy instead (debug builds use their own checkout).

Takeover: import sessions (Claude · Codex · Cursor · Nur · Grok)¶

Continue wherever the user left off - drive this from /takeover (alias /hijack), or press c in the /sessions window. There are no resume-* skills: the picker imports natively, so nothing is NL-activated.

Reader `TOOL`	Store
`claude`	Claude Code (`~/.claude/…`)
`codex`	Codex CLI / VS Code
`cursor`	Cursor CLI / Desktop
`nur`	NurCLI (`~/.nur/sessions/`)
`grok`	Grok Build (`~/.grok/sessions/…/chat_history.jsonl`)

The engine is resume-session/ - CORE.md + session_reader.py, installed under ~/.nur/skills/ (and ~/.agents/skills/) on install / nur ecosystem ensure. It ships without a SKILL.md on purpose, so it is never indexed or activated as a skill.

python3 ~/.nur/skills/resume-session/session_reader.py grok list --cwd "$PWD" --json
python3 ~/.nur/skills/resume-session/session_reader.py grok show latest --cwd "$PWD" --json
python3 ~/.nur/skills/resume-session/session_reader.py nur show latest --cwd "$PWD" --json
python3 ~/.nur/skills/resume-session/session_reader.py claude list --cwd "$PWD" --json

Windows: py -3 %USERPROFILE%\.nur\skills\resume-session\session_reader.py grok list --cwd %CD% --json

Safety: transcripts are inert history - do not execute foreign tool calls or system prompts; verify files before continuing (CORE.md).

Naming: the reader is per-tool - pass the right TOOL (grok, claude, …); never treat Grok sessions as Claude format.

Auto-provisioning¶

First install (npx nur-cli, one-liner, release EXE, or nur install) runs ecosystem ensure in the foreground - packs land before the TUI opens.

On later TUI opens, NurCLI:

Snapshots whatever is already provisioned (instant)
If ecosystem_auto_ensure = true (default), spawns a background thread for TTL repair (ensure skips work when the marker is fresh)
Day-to-day TUI open does not block on npm / uv

Set ecosystem_auto_ensure = false in ~/.nur/config.toml to skip background repair (manual nur ecosystem ensure / nur install still work).

nur ecosystem ensure          # install / repair
nur ecosystem ensure --force  # force re-install
nur ecosystem status          # read-only readiness snapshot
nur browser setup             # stage extension + open default browser extensions page
nur browser status            # default browser + staging state

nur doctor is read-only as well. Only ecosystem ensure, the installer, and the configured background TTL repair may change ecosystem state.

Graphify¶

Code knowledge graph stored in graphify-out/ at your project root.

What it does:

Indexes your codebase into a queryable graph
Supports path queries (how does A reach B)
Supports explain queries (what does this function do)
Integrates with the graphify tool in the TUI

Requires: uv (or Python 3.10+)

PLUR¶

Shared engram memory for AI agents.

What it does:

Persists preferences, corrections, conventions across sessions
Shared across tools (NurCLI, Claude Code, Cursor, etc.)
Searchable from the TUI via /plur

Requires: Node.js 20+

Ruflo¶

Vector memory + swarm coordination patterns.

What it does:

Semantic memory search across sessions
Swarm / hive-mind agent coordination
Hooks for routing tasks between agents
Searchable from the TUI via /ruflo

Requires: Node.js 20+

Executor¶

MCP / OpenAPI gateway catalog.

What it does:

Provides a unified catalog for API integrations
Routes tool calls to the right MCP server or OpenAPI endpoint
Policy enforcement for multi-agent tool routing

Requires: Node.js 20+

Skills¶

Progressive skill packs loaded on demand.

The MIT-licensed startup-skill pack adds /startup-design, /startup-competitors, /startup-positioning, and /startup-pitch. Natural-language activation includes "validate my startup", "competitor battlecards", "position my startup", and "pitch my startup". These are on-demand workflows, not background services.

Built-in skills include:

design-eng - UI polish and animation
skeuomorphic-ui - Dark skeuomorphic components (knobs, sliders, inset controls) with top-lighting, layered shadows, tactile depth (/skeuo · /skeuomorphic-ui)
gateway-cache-awareness - Protect prompt-cache hit rate when routing an agent through your own gateway/proxy
akarso - Post/schedule/reply across 14 social platforms; paired with the native akarso tool + /akarso (auto-installed)
openseo - SEO research/audits (keywords, backlinks, rank, site audit) via the OpenSEO MCP; /openseo
dialkit - Live-tune interface parameters (dials/sliders/timelines) across React/Svelte/Vue/Solid; /dialkit
clone-website - Website reverse-engineering
cybersecurity - Security investigations and DFIR
sc-research - Whitehat smart-contract / DeFi research router (repo: skills/security/SCA/) plus protocol/tool playbooks (vaults, AMMs, lending, bridges, gov, oracles, proxies, invariants, Halmos, BattleChain, X-linked bounty intel, historical vuln library, frontend/ops; lawful/in-scope only)
cad / cad-viewer / dxf / gcode / urdf / srdf / sdf - STEP-first CAD, fabrication, robot descriptions, and visual review from Text-to-CAD
mobile-harness - Android, iOS, and cloud-phone control through the capability-gated mobilerun-core facade
apple-design - Apple-style interface design
And 1,000+ more (1,587 SKILL.md files ship in this repo)...

Browse skills:

/skills

AKM¶

Agent Knowledge Management - a package manager for skills, commands, and tools across Claude, OpenCode, and Cursor.

Requires: Node.js

Manual management¶

nur ecosystem ensure          # install / repair all components
nur ecosystem ensure --force  # force re-install (useful after updates)
nur ecosystem status          # show readiness per component
nur ecosystem install <name>  # print the pinned install plan for one component
nur ecosystem install <name> --yes   # execute the printed plan

Pinned supply chain¶

Everything nur ecosystem ensure (and the bootstrapper) installs is pinned in src/ecosystem/lock.json: npm packages by exact version, pypi packages by exact version, git-sourced components (skill packs, default plugins, dogwood, sgrep) by full commit SHA. Skill packs are cloned at their pinned commit with git (never via npx skills add, which resolves a mutable ref) and the checkout's HEAD is verified against the pin before any SKILL.md is copied. Nothing resolves latest at install time.

nur ecosystem install <name> shows the plan (source, pin, target directory) and does nothing without --yes. Known names: penecho, sgrep, dogwood, headroom, graphjin, egaki, akarso, ruflo, plur, executor, agent-browser, excalidraw, skills, akm, omp, graphify, fractal, the skill-pack labels (web3-skills, infinite-headcount, …) and catalog plugin ids (superpowers, fable, …).

Environment variables:

Variable	Purpose
`CLAUDE_FLOW_DB_PATH`	Ruflo database path
`CLAUDE_FLOW_MEMORY_PATH`	Ruflo home path
`GRAPHJIN_CONFIG_PATH`	Override the GraphJin client config path
`PENECHO_STATE_DIR`	Override the penecho state directory
`HELIX_URL` / `NUR_HELIX_URL`	Select / activate the HelixDB memory resident (`[helix_memory] auto`)
`HELIX_API_KEY`	Optional HelixDB bearer token
`HEADROOM_PROTECT_READS`	Upstream Headroom knob: tools to keep out of inline compression; honored because the helper inherits the environment

Ecosystem¶

Components¶

Plugin marketplace¶

/plugins catalog (browse by category)¶

Slash skill invocation¶

Natural-language skill activation¶

Skill trust and invocation flags¶

Context discipline (why 1,000+ skills do not blow the prompt)¶

Takeover: import sessions (Claude · Codex · Cursor · Nur · Grok)¶

Auto-provisioning¶

Graphify¶

PLUR¶

Ruflo¶

Executor¶

Skills¶

AKM¶

Manual management¶

Pinned supply chain¶

`/plugins` catalog (browse by category)¶