Two lines to install. Two more to start remembering.
Run these one at a time inside Claude Code. The engine is a separate Rust CLI you can build from source in a minute.
-
1.1
Add the marketplace
/plugin marketplace add anishfyi/troveSSH error? Use
https://github.com/anishfyi/trove.gitinstead. -
1.2
Install the plugin
/plugin install trove@velofy-troveSkills plus SessionStart and SessionEnd hooks. Read it as plugin@marketplace.
-
1.3
Reload, then create your trove
/reload-plugins /trove:init
From here say "remember this" or run
/trove:remember, and/trove:recallto search it back.
# requires Rust $ git clone https://github.com/anishfyi/trove && cd trove $ cargo build --release -p trove-cli $ ./target/release/trove index Indexed 50 files, 203 symbols, 50 modules, 2 subsystems $ ./target/release/trove query "how does progressive retrieval respect the context budget" ## L4 Architecture Memory ## L3 Subsystem Memory crates ## L2 Module Memory crates/trove-retrieve/src/budget.rs Estimated tokens: 669 / 200000
Every project gets a trove. Loaded as three skills.
Each repo where an agent works keeps its own trove under .claude/trove/. Trove renders it into
three skills that Claude Code lists and loads on intent, and an AGENTS.md pointer lets Codex,
Cursor and pi read the same files.
How this repo is built
Style, structure, naming, commit and PR rules, and the things to never do.
What we decided, and why
Decisions, gotchas and history. /trove:remember routes each entry to the right place.
The current map
Architecture, subsystems and key modules from the engine, refreshed by /trove:index.
.claude/trove/ ├── conventions/INDEX.md ├── memory/INDEX.md └── context/INDEX.md .claude/skills/ ├── your-app-conventions/SKILL.md ├── your-app-memory/SKILL.md └── your-app-context/SKILL.md AGENTS.md # same files, any agent
- Stop re-explaining. Sessions open already aware of your conventions and past decisions.
- Stop repeating mistakes. A footgun you hit once is written down for good.
- Onboard instantly. A teammate or a new machine inherits the project trove with the repo.
- Secret-guarded. Writes are checked so tokens and keys never land in a trove.
One command for what you know. And every tool you have.
trove is a dense, single entry point on macOS and Linux. Ask a question and get an answer grounded in
your personal trove, the project trove, the engine index and a catalog of every CLI on your $PATH,
with citations. Retrieval-only mode works offline; an LLM step is opt-in.
$ trove ask "where is the context budget enforced?" ContextBudget::for_total splits the budget by layer; the pipeline stops once it has enough detail. [1] crates/trove-retrieve/src/budget.rs [2] crates/trove-retrieve/src/pipeline.rs [3] memory/why-architecture-first.md $ trove tools search json jq command-line JSON processor gron make JSON greppable fx terminal JSON viewer
| Command | What it does |
|---|---|
trove | Interactive REPL over everything you know. |
trove ask | Answer one question with cited sources. |
trove tools | List, search and describe installed CLIs. |
trove index | Index the repo into memory layers. |
trove query | Progressive retrieval within a token budget. |
--json | Machine output for agents. |
Hand off the docs. Keep the secrets.
trove ship turns a project and its trove into handoff-ready developer docs: overview, architecture,
setup, conventions, decisions and gotchas. A redaction pass runs before anything leaves your machine, and it
fails closed if a high-confidence secret survives. Also available as /trove:ship inside an agent session.
$ trove ship --out handoff/ wrote overview.md architecture.md setup.md conventions.md decisions.md gotchas.md redacted 7 2 tokens, 3 emails, 1 internal host, 1 local path report: handoff/REDACTIONS.md
- Deterministic detectors first, so the common leaks never depend on a model.
- Optional agent review with Claude Code, Codex or pi to catch what patterns miss.
- A redaction report lists every removal and why.
- Your format: a Markdown folder, a single file or a static site.
Higher information density. Not larger prompts.
Trove answers with architecture first and drills into modules and symbols only when it needs to. Here is the engine run against its own repository.
669 tokens of layered context versus about 21,900 for the raw source of crates/ and plugins/.
Progressive retrieval over the index, from architecture down to symbols, with a token budget.
50 files, 203 symbols, 50 modules and 2 subsystems. Re-indexing only rebuilds what changed.
Method: Trove v0.2.0 release build on Linux, run on this repository. Query: "how does progressive retrieval respect the context budget". Tokens are estimated at 4 characters per token, the same heuristic the engine uses. Reproduce with the commands in 01 Install.
Two layers, one system. Structure and memory.
The engine answers "what is in this codebase and where". The plugin answers "what did we decide and why". Retrieval flows top-down and stops as soon as it has enough. See VISION.md for the full L0 to L6 design.
Functions, types, traits and tests in Rust, Python, JS/TS, Go and Bash.
Per-file summaries: exports, dependencies, assumptions, side effects.
Package-level clusters with their key files.
Repo-wide design map and dependency graph.
Decisions and gotchas imported from your troves.
Loads your trove index into context so every session starts ahead.
Prompts a reflection and a re-index when the repo changed.
Work memory on your desktop. Every trove, one place.
A macOS app, with a Linux build, that keeps your work memory across every project and agent: your personal trove and every project trove on the machine, browsable and searchable together. Local by default, with any sync strictly opt-in.
It is in design now. Follow along or share what you would want from it on issue #24.