Recall — Local Project Memory for Claude Code
Durable, fully offline memory for Claude Code: capture every session locally and resume instantly without re-explaining your project or burning tokens.
README and SECURITY.md document least-privilege design (writes confined to output_dir, O_NOFOLLOW, hardened git subprocess, scoped transcript reads), with tests corroborating redaction and incremental capture; however, the core scripts (common.py, redact.py, etc.) are not in the provided evidence, so security claims rest on documentation plus partial tests — scored 2, not 3. User confirmation exists via SessionStart resume/logging questions, .capture-paused, and uninstall.
Files are self-consistent (README, SECURITY, pyproject, tests agree) and there are zero runtime deps with both numpy paths covered in the CI matrix, giving 2 for self-consistency and dependency availability; failure messaging is thin — hooks deliberately fail silent, and only the save output reports which path ran — hence 1.
Audience (local subscription users), scenarios (Claude Code primary, opencode opt-in), and triggers (Stop/SessionEnd/SessionStart hooks) are clearly described; boundaries are honestly stated (no fencing on opencode, silent no-op degradation); environment coverage (Python 3.9–3.13, numpy optional) is good — but all documentation-asserted, so 2.
Information architecture (Layout) and install notes (marketplace/local/opencode) are thorough: 3. Known limitations are candid (best-effort redaction, opencode drift): 3. MIT LICENSE present: 3. Deductions: no CHANGELOG and no visible plugin version (plugin. not in evidence), so versioning is 1; naming is consistent but stability unproven (2); maintenance has CONTRIBUTING/SECURITY templates but maintainer identity is unverified (2).
Output is diffable plaintext markdown with history/context separation: 2. Marginal value versus CLAUDE.md/--continue is argued clearly but not executed-verified: 2. Zero-token cost claims align with the local algorithm: 2 — all conservative pending any run.
Claims trace to named files (common.py:git_info etc.), but the referenced scripts are absent from the evidence and cannot be checked: 1. README/SECURITY/tests corroborate each other: 2. Fact/inference separation is good (explicit 'best-effort, not a guarantee'): 2.
- This is a static review; no code was executed. Security claims (redaction, confined writes, hardened git) rest on documentation and partial tests — core scripts were not in the evidence to verify.
- Redaction is best-effort; manually inspect .recall/ files before committing.
- Committing .recall/ as shared team memory carries prompt-injection risk; the opencode path has no untrusted-data fencing and deserves extra caution.
- No CHANGELOG or visible version number makes upgrade tracking difficult; publisher is unverified — audit the scripts yourself before adoption.
- Hooks fail silently by design; capture can stop without notice, so periodically confirm history.md is being updated.
What does this agent do, and when should you use it?
Recall is a fully-local plugin that solves Claude Code's cold-start problem — having to re-explain your project every session. Through SessionStart, Stop and SessionEnd hooks it incrementally appends session activity to `.recall/history.md` inside your project, then a local TF-IDF + TextRank summarizer condenses it into a ~1–2K token `context.md` for the next session. There are no LLM calls, no network requests and no API keys anywhere; the summarizer (with an optional numpy accelerator and an equivalent pure-Python path) is vendored in `scripts/summarizer.py`. Beyond the Claude Code plugin, an installer script provides opt-in support for opencode, and both tools can share the same `.recall/` memory files. The project also ships redaction, confined writes and hardened git invocation as security measures, under an MIT license.
During a session, Stop/SessionEnd hooks run capture.py to incrementally append your prompts, Claude's replies, files touched and commands run to .recall/history.md. At session start, session_start.py surfaces context.md and asks whether to resume and keep logging. When wrapping up, /recall:save triggers make_context.py, which calls scripts/summarizer.py (TF-IDF sentence vectors → cosine-similarity graph → TextRank PageRank power iteration → top-N sentences) and wraps the summary with deterministic facts from the transcript and git — first ask, files, commands, where you left off, git diff --stat — overwriting context.md. Alternatively set auto_save_context: "on_end" to regenerate automatically. Commands: /recall:save, /recall:show, /recall:log. For opencode projects, run python3 ~/recall/scripts/install.py --opencode --project <path> to generate a capture shim, a /recall-save command and an opencode. instructions entry.
- Developers on a Claude Code subscription who want to stop spending tokens re-explaining project context every session
- Engineers working on the same project across multiple days and sessions who need to quickly recover last progress and open threads
- Privacy-sensitive individuals or teams whose code, paths and occasional secrets must never leave the machine
- Teams mixing Claude Code and opencode on one repo who want a shared session memory in
.recall/ - Small teams who want to commit
.recall/as shared team memory so members can pick up each other's work (trusting repo writers)
What are this agent's strengths and limitations?
- Fully offline with zero model-token cost: summaries come from local TF-IDF + TextRank, with no external model or API calls
- Explicit privacy guarantees: no network calls, no API keys, plus best-effort redaction of API keys, tokens, .env assignments and PEM keys before writing
- Cheap resumption: a ~1–2K token compact context.md versus replaying a full transcript with --resume
- Cross-harness portability:
.recall/is plain markdown, shareable between Claude Code and opencode on the same repo
- Summaries are extractive (TF-IDF + TextRank), not LLM-written, limiting paraphrase quality and semantic compression
- opencode support tracks its public CLI (session list, export, plugin events API); fast upstream changes could silently degrade capture
- On opencode, context.md loads via instructions without Claude Code's untrusted-data fencing, requiring extra caution when committing shared memory
- Codex and other harnesses are not supported yet; new adapters must be built on the provided seam
- Redaction is best-effort, not a guarantee — review
.recall/files before committing
How do you install or deploy this agent?
From the marketplace (inside Claude Code):
/plugin marketplace add raiyanyahya/recall
/plugin install recall@recallLocal dev (no install step):
claude --plugin-dir /path/to/recallopencode (once per project):
git clone https://github.com/raiyanyahya/recall ~/recall
python3 ~/recall/scripts/install.py --opencode --project /path/to/your/projectNo pip install needed — the summarizer is vendored and stdlib-only (numpy optional). Run under your subscription login; if claude reports "Invalid API key", clear a stale variable with unset ANTHROPIC_API_KEY.
How do you use this agent?
- Start a Claude Code session normally; Recall shows
context.mdand asks whether to resume and whether to keep logging. - Work as usual — Stop/SessionEnd hooks automatically append session activity to
.recall/history.md. - Before wrapping up, run
/recall:saveto generate/overwritecontext.md(or setauto_save_context: "on_end"inrecall.config.for automatic regeneration). - Open a fresh session and resume from the compact summary without re-explaining.
Other commands: /recall:show prints context.md; /recall:log tails history.md. Optionally drop a recall.config. in your project root to override defaults (output dir, summary length, redaction, git inclusion); create .recall/.capture-paused to pause logging.
How does this agent compare with similar options?
The README directly compares against Claude Code's built-in options: CLAUDE.md (and the # shortcut) is hand-written rules and instructions that require manual upkeep and don't record what happened; --continue/--resume replays a full prior transcript (token-heavy, machine-bound); context compaction works only within a session. Recall fills the gap between them: an automatic, deterministic record of each session condensed into a compact resume point.
FAQ
Does using Recall cost anything extra?
Will my code or transcripts be sent anywhere?
.recall/ inside your project, with best-effort redaction of common secret shapes before writing.Is it safe to clone an untrusted repo while using Recall?
.recall/ as shared team memory, a repo writer could craft it for prompt injection — it is git-ignored by default.