Rememora

What's new in v1.7.0 — Rememora no longer wires any automatic Claude Code / Gemini CLI hooks; rememora setup --apply self-heals any existing install by stripping them out. rememora dream is the new manual catch-up command (curate + evolve in one pass). v1.6.0 before it fixed memories written from a git worktree being unreachable (worktree-aware project resolution + rememora project reconcile) and made memory consolidation bounded and reversible (rememora evolve --apply/--undo-log). Full notes: v1.7.0 · v1.6.0 · CHANGELOG

Persistent, cross-agent memory for AI coding agents. One SQLite database, shared by every agent you use.

The problem: Claude Code, Codex, and Gemini CLI each lose context between sessions. Switch agents mid-task and you start from scratch. Come back to a project after a week and the agent has forgotten everything.

Rememora fixes this. A fast Rust CLI that any agent can call via Bash to save and retrieve memories, transfer working context between agents, and build up project knowledge over time — with LLM-powered curation that extracts memories from session transcripts on demand (rememora curate / rememora dream), never from an automatic hook.

# Agent A (Claude Code) saves a decision
rememora save "Chose Zustand over Redux for state management" \
  --category decision --project myapp --importance 0.9

# Agent B (Codex) picks up full context
rememora context --project myapp
# → Returns: project memories + last session state + working context

Features

Cross-agent memory — Claude Code, Codex, Gemini CLI, or any agent with Bash access
Session transfer — hand off working state between agents with full continuity
6 memory categories — preferences, entities, decisions, events, cases, patterns
Tiered loading — L0 abstracts (~100 tok) → L1 overviews (~500 tok) → L2 full content
Hotness scoring — frequently accessed + important memories surface first
Full-text search — BM25 via SQLite FTS5, zero external dependencies
Vector search — optional cosine similarity via sqlite-vec + sentence-transformers (feature-gated)
Hybrid search — reciprocal rank fusion (RRF) merging BM25 + vector results
On-demand curation — LLM-powered memory extraction from Claude Code session transcripts, triggered by rememora curate/rememora dream or the model's own judgment — never an automatic hook
Memory consolidation — smart dedup, merge, and pruning of stale memories via LLM
Agent orchestration — dispatch GitHub issues to Claude CLI with quality gates and retry loops
Eval benchmark — multi-scenario harness measuring instruction compliance and autonomous behavior
Fast — ~3ms startup, 3.6MB binary, single SQLite database with WAL
Local-first — everything stays on your machine

Install

# Homebrew (macOS & Linux)
brew install Rememora/tap/rememora

# From source
cargo install --path .

# Or download from GitHub Releases
# https://github.com/Rememora/rememora/releases

Staying up to date

rememora update                # hits GitHub, prints status + upgrade hint
rememora update --check        # respect 24h cache (use from scripts/hooks)
brew upgrade rememora          # actual upgrade (Homebrew)

rememora update detects your install method (Homebrew / cargo install / unknown) from the running binary's path and prints the appropriate upgrade command — it never auto-executes the upgrade. rememora setup --apply also prints the same hint inline when a newer release is cached. Set REMEMORA_NO_UPDATE_CHECK=1 to disable entirely.

Quick Start

# Register a project
rememora project add myapp --path /Users/me/myapp --description "Mobile app" --stack react-native,typescript

# Start a tracked session
rememora session start --agent claude-code --project myapp --intent "implementing auth flow"
# → prints session ID

# Save memories as you work
rememora save "Uses expo-secure-store for token storage" --category decision --project myapp --importance 0.8
rememora save "Stripe API requires idempotency keys for charges" --category entity --project myapp
rememora save "iOS build fails with Hermes + RN 0.76 — disable new arch" --category case --project myapp

# Search memories
rememora search "authentication" --project myapp

# End session with summary
rememora session end <session-id> \
  --summary "Auth flow complete. Login, signup, token refresh all working." \
  --working-state "Need to add biometric auth. Files: src/auth/"

Cross-Agent Transfer

The core use case — seamless handoff between agents:

# 1. Claude Code finishes work, hands off
rememora session end <id> --status transferred \
  --summary "Auth flow 80% done" \
  --working-state "Login UI done. Token refresh blocked on secure storage decision."

# 2. Switch to Codex — it loads full context
rememora context --project myapp
# Returns markdown with:
#   - All project memories (decisions, entities, cases, patterns)
#   - Last session summary + working state
#   - Transfer status

# 3. Codex continues where Claude Code left off
rememora session start --agent codex --project myapp \
  --intent "resolve secure storage and finish token refresh" \
  --parent <previous-session-id>

Curation

Rememora extracts memories from Claude Code sessions on demand — nothing runs automatically:

# Auto-discover and curate all Claude Code session transcripts
rememora curate --auto

# Curate a specific session file
rememora curate --file ~/.claude/projects/.../session.jsonl --project myapp

# Preview what would be extracted (dry-run)
rememora curate --auto --dry-run

How it works:

JSONL parsing — reads Claude Code session transcripts incrementally (watermark-based, never re-processes old content)
Signal gate — fast Haiku classification: does this transcript contain memorable knowledge? (YES/NO)
AUDN curation — Sonnet subagent with Bash access runs the full Add/Update/Delete/Noop cycle via rememora save/search/supersede
Consolidation — BM25 clustering + an LLM that proposes merges. Nothing in this pipeline retires a memory: applying consolidation is always a deliberate rememora evolve --apply.

Run it yourself whenever you want to catch up, or reach for rememora dream to curate and evolve in one pass — see Agent Setup.

Memory Consolidation

Over time, memories accumulate duplicates and stale entries. Rememora consolidates them:

# Preview clusters and what the LLM would do with them (the default)
rememora evolve --project myapp

# Actually write the decisions
rememora evolve --project myapp --apply

# Read back what an applied run did, and the SQL that reverses it
rememora evolve --project myapp --undo-log

# Ask a subagent what it would consolidate (advisory — never writes)
rememora consolidate --project myapp

# Check if consolidation gate is met (24h + 5 new memories)
rememora consolidate --project myapp --check-only

The consolidation system uses BM25 cross-search to find similar memory clusters, then an LLM decides whether to merge, supersede, or keep each cluster.

Both commands are dry-run by default. evolve writes only with --apply (or REMEMORA_APPLY=1); --dry-run overrides both.

Only evolve can apply changes. consolidate hands its clusters to a Claude Code subagent that would run rememora supersede itself, so none of evolve's safety machinery applies to it. It therefore proposes and never writes: it runs its subagent with the CLI in read-only mode (REMEMORA_READONLY=1), under which every write command is refused.

When evolve --apply writes, each decision is bounded and recorded:

the ids the model names must exist in the cluster it was shown
one decision may retire at most 5 memories; clusters larger than 8 are never sent to the model at all
the writes and their undo record are one transaction — if the record cannot be written, nothing is
the undo record lives in the evolve_undo table inside the encrypted database (not in a cleartext file), and carries SQL that reverses exactly that decision. Read it with rememora evolve --undo-log.

Agent Orchestration

Dispatch GitHub issues to Claude CLI agents with quality gates:

# Run a single issue
rememora agent-run --repo owner/repo --issue 42 --retries 3

# Watch project board and auto-dispatch Ready-For-Dev issues
rememora agent-loop --repo owner/repo --poll 300

# One-shot: process current Ready-For-Dev items and exit
rememora agent-loop --repo owner/repo --once

agent-run workflow:

Fetch issue from GitHub → move to "In Progress"
Create isolated git worktree
Run Claude CLI with issue context
Quality gate: run tests, retry on failure (configurable retries)
Open PR → move to "Ready for Review"

agent-loop polls the GitHub project board continuously, dispatching Ready-For-Dev issues and merging Cherry-Picked PRs.

Agent Setup

Rememora fires nothing automatically — no hook captures memory on your behalf, in the plugin or otherwise. Every path below works the same way: an agent instructions file (CLAUDE.md/ AGENTS.md/GEMINI.md) tells the agent when to search, save, and manage sessions, and it invokes rememora itself as it works. Run rememora dream whenever you want a manual catch-up pass (curate pending sessions + evolve) — by hand, or from your own cron/launchd job.

Claude Code (Recommended: Plugin)

Install Rememora as a Claude Code plugin:

# 1. Add the Rememora marketplace
claude plugin marketplace add Rememora/rememora

# 2. Install the plugin
claude plugin install rememora@rememora

# For project-wide install (shared via git):
claude plugin install rememora@rememora --scope project

This gives you the instructions block plus three components:

Component	What it does
rememora-save skill	Claude autonomously saves decisions, bug fixes, patterns
rememora-search skill	Claude autonomously searches before implementations
`/rememora` command	Manual save, search, or status check

After installing, restart Claude Code. The plugin auto-detects your project from the working directory.

Updating the plugin:

claude plugin marketplace update rememora    # refresh the marketplace cache
claude plugin update rememora@rememora       # update the plugin (note the @marketplace suffix)

Claude Code (Alternative: CLAUDE.md)

Equivalent to the plugin's instructions block, without installing the plugin — add to ~/.claude/CLAUDE.md:

## Rememora Memory System
On session start:
1. `rememora context --auto` — load prior context
2. `rememora session start --agent claude-code --project <name> --intent "..."`

During work, save important discoveries:
- `rememora save "..." --category decision --project <name>`

Before ending: `rememora session end <id> --summary "..." --working-state "..."`

Codex

Add to ~/.codex/config.toml:

system_prompt = """
On session start: run `rememora context --auto` and `rememora session start --agent codex ...`
Save important discoveries with `rememora save ...`
Before ending: `rememora session end <id> --summary "..." --working-state "..."`
"""

Gemini CLI

Add to ~/.gemini/GEMINI.md using the same pattern as the Claude Code CLAUDE.md approach.

Auto-Setup (All Agents)

# Detect installed agents and show what would be configured
rememora setup

# Apply the configuration
rememora setup --apply

Auto-detects Claude Code, Codex, and Gemini CLI, then patches their config files with rememora instructions.

Desktop App

A native macOS app built with Tauri that renders your local memory database. v0 is deliberately minimal: it opens the encrypted DB read-only, never prompts for the key, and renders every non-superseded context newest-first, paginated. No editing, no search, no charts yet — see docs/spikes/83-desktop-viewer.md for the longer-term design.

cd app
pnpm install
pnpm tauri dev      # dev loop
pnpm tauri build    # unsigned .app + .dmg

Requires Rust (stable), Node 22+, pnpm 9+, and Xcode Command Line Tools. If the app reports "Encryption key not available", run rememora init first.

Commands

Command	Description
`rememora save "..." --category <cat>`	Save a memory
`rememora search "query" [--format compact\|context\|full]`	Search memories (BM25 + optional vector)
`rememora timeline --anchor <uri> [--before N] [--after N]`	Chronological (or hotness-ranked) slice around an anchor
`rememora context --project <name>`	Load full project context (L0 + L1)
`rememora context --auto`	Auto-detect project from cwd
`rememora context --cheatsheet`	Compact top-5 summary
`rememora get <uri>`	Get specific context by URI
`rememora session start`	Start a tracked session
`rememora session end <id>`	End session with summary
`rememora session end-active`	End active session (hook-friendly)
`rememora session resume --project <name>`	Show last session state
`rememora session list`	List recent sessions
`rememora project add <name>`	Register a project
`rememora project list`	List all projects
`rememora project show <name>`	Show project details
`rememora project reconcile [--apply]`	Re-home memories filed under project namespaces no project claims (dry run by default)
`rememora supersede <old-id> --by <new-id>`	Replace outdated memory
`rememora relate <uri-a> <uri-b>`	Link two contexts
`rememora extract`	Extract memories from text via LLM
`rememora curate --auto`	Curate memories from session transcripts
`rememora evolve --project <name>`	LLM-driven memory consolidation (add `--apply` to write)
`rememora evolve --undo-log`	Show what applied runs did, and the SQL that reverses them
`rememora consolidate --project <name>`	Propose dedup via subagent, behind a dual gate (advisory — never writes)
`rememora dream [--project <name>]`	Manual catch-up: curate + evolve (apply) in one pass
`rememora agent-run --repo X --issue N`	Dispatch issue to Claude CLI
`rememora agent-loop --repo X`	Watch board + auto-dispatch
`rememora setup`	Configure agents to use rememora
`rememora update [--check]`	Check GitHub for a newer release; print upgrade hint
`rememora eval`	DB compliance metrics
`rememora status`	Show DB stats
`rememora usage [--hooks]`	Aggregate LLM telemetry (or hook gate-outcomes with `--hooks`)
`rememora export --project <name>`	Export as JSON or markdown

All commands support --json for structured output.

Progressive Disclosure: search → timeline → get

Retrieving a single memory at full fidelity eats tokens fast. Rememora splits retrieval into three cheap steps so agents can filter before paying the full cost:

# 1. Filter — one line per hit, ~75 tokens each
rememora search "auth flow" --project myapp --format compact
# [case] Bug fixed: token refresh race … — rememora://…/bug-fixed-token-refresh-race (rank=-3.82)
# [decision] Chose JWT over session cookies … — rememora://…/chose-jwt-over-session-cookies  (rank=-3.41)
# [pattern] Auth middleware composition … — rememora://…/auth-middleware-composition       (rank=-3.05)

# 2. Zoom — chronological slice around an anchor to understand what surrounded the decision
rememora timeline --anchor "rememora://projects/myapp/memories/decision/chose-jwt-over-session-cookies" \
    --before 3 --after 3
# Before
# - [case] Investigated session-cookie CSRF hardening … — 2026-03-14T…
# - [event] Benchmarked JWT verify latency in middleware … — 2026-03-15T…
# - [pattern] Double-submit cookie pattern for CSRF … — 2026-03-15T…
# Anchor
# - [decision] Chose JWT over session cookies … — 2026-03-16T…
# After
# - [case] Refresh-token rotation leak caught in review — 2026-03-18T…
# …

# 3. Fetch — full content (L2) of a single URI when you're sure you want it
rememora get "rememora://projects/myapp/memories/decision/chose-jwt-over-session-cookies"

Output formats for search:

`--format`	Shape	Typical use
`full` (default)	Multi-line per hit with name + URI	Human in terminal
`compact`	One line per hit with score, ~75 tok/hit	Agent filtering
`context`	One line per hit, byte-capped (2 KB)	Injecting into a prompt cheaply

Timeline ordering: --by ts (default, creation time) or --by hotness (importance × recency × active_count). Project scope: explicit --project wins; otherwise inferred from the anchor URI.

Project scope for search: an explicit --project is put through the same resolution ladder writes use; with no --project, scope is inferred from the working directory. --cwd <dir> overrides which directory that is — pass the session cwd through it explicitly, so a search issued from a git worktree still filters to the main checkout's project.

rememora search "auth flow" --cwd /path/to/myapp/.agents/worktrees/issue-42
# → scoped to "myapp", not to "issue-42"

Auto-Extract Memories

Extract memories from session transcripts, notes, or any text using an LLM:

# Pipe text and preview what would be extracted
cat session_log.txt | rememora extract --project myapp

# Extract and save directly
cat session_log.txt | rememora extract --project myapp --save --agent claude-code

# From a file
rememora extract --file notes.md --project myapp --save

# JSON output for programmatic use
rememora extract --file notes.md --project myapp --json

Requires ANTHROPIC_API_KEY environment variable. Uses Claude Haiku for fast, cheap extraction.

Memory Categories

Category	Use for	Example
`preference`	User/project preferences	"prefers Zustand over Redux"
`entity`	Key concepts, APIs, tools	"Stripe API uses idempotency keys"
`decision`	Architecture & design choices	"chose expo-router over React Navigation"
`event`	Milestones, releases, incidents	"v2.0 shipped 2026-03-01"
`case`	Specific problem + solution	"iOS build fails with Hermes + RN 0.76"
`pattern`	Reusable processes	"always run migrations before seeding"

Project Resolution

--project is a request, not the answer. Every write path used to name the project after whatever directory it happened to be standing in — basename $PWD, or Claude Code's encoded transcript directory (-Users-me-Projects-myapp). Agent work happens in git worktrees, so this produced project namespaces matching no registered project. Because the project filter is a hard uri LIKE 'rememora://projects/<name>/%' prefix match, those memories were unreachable from the moment they were written. On a real 300-context store, 55 contexts (18%) were filed under fabricated names and re-homed by project reconcile, across worktree basenames, encoded transcript paths, and case drift (Ana vs ana).

Writes now resolve through a ladder — first match wins:

--project naming a registered project wins verbatim, case-insensitively, in its canonical spelling — what keeps a deliberate cross-project save working.
An encoded filesystem path resolves against the filesystem. The encoding is lossy (both / and . become -), so candidates are tried longest-first, and one is accepted only if it resolves to a registered project or is itself a git working-tree root. Nothing else qualifies. This rung exists for curate, watch-transcript and project reconcile, which derive the encoded name from a transcript directory; to exercise it by hand you must use --project=-Users-… (the space-separated form is parsed as a flag, since the value starts with -).
The working directory resolves it, walking a git worktree back to its main checkout — but only for a name the tooling synthesised, never one you chose.
Same gate: in a linked worktree with nothing registered, the main checkout's directory name — never the worktree's, so the name survives the worktree being deleted.
Otherwise the requested name, verbatim.

Omitting --project still means global scope. Nothing is auto-namespaced.

Only a name the tooling invented can be overridden. Rungs 3 and 4 apply solely when the requested name is an encoded path, or the basename of the working directory, its toplevel, or its main checkout — exactly the shapes the curator synthesises. A name you chose is left alone even when no project by that name is registered yet, because "save first, rememora project add later" is the normal workflow. Without that gate, --project ana from inside the myapp worktree would silently write ana's memory into myapp, search --project ana would return myapp's memories, and evolve --project ana would consolidate myapp's.

Resolution gives up rather than guesses. Rung 2 walks shortened prefixes, and shortening a path until something exists always succeeds eventually — so accepting any real directory would reliably land on a generic ancestor and mint a project called Projects or your own username, colliding across every unrelated repo beneath it. A project is a repository; ~/Projects and ~ are containers. When nothing qualifies, the name falls through the ladder untouched and project reconcile reports it instead of rewriting it.

Applied on save, extract --save, session start, session end-active, curate, watch-transcript, search, context, consolidate and evolve. Not applied on export, timeline, session resume / session list, eval or status — those take the name you give them.

Reads degrade differently from writes. With no --project, a resolution failure yields no filter at all (search everything) rather than a guessed name: an unfiltered search scores only marginally worse, while a wrong project name scores zero.

rememora save --json returns the resolved project, worktree and branch. The plain-text path prints a note on stderr whenever it rewrites what you asked for:

note: --project foo resolved to myapp (worktree/main checkout)

Provenance is kept, not folded away. Migration 007 adds worktree and branch columns to both contexts and sessions, with partial indexes on worktree IS NOT NULL. A NULL worktree means "written from the main checkout" — a real answer, not a missing one. These are columns rather than tags entries because tags is agent-supplied free text that context::update overwrites wholesale, it feeds the FTS5 index (a worktree: tag would pollute BM25 for anyone searching the word "worktree"), and provenance wants an equality filter.

Repairing already-stranded memories

Memories written before this existed are still filed under namespaces no project claims. rememora project reconcile finds them and re-homes them — dry run by default:

# Report every stranded namespace, where it belongs, and by what route
rememora project reconcile

# Commit the rewrite (a single transaction)
rememora project reconcile --apply

# Machine-readable plan or outcome
rememora project reconcile --json

The dry run names the route it used for each namespace — case-insensitive project name, encoded path, session cwd, or session cwd → main checkout — because those carry different confidence and you should be able to judge each rewrite rather than trust the batch. Three outcomes: rewritten; "already coherent, just unregistered" (the fix there is rememora project add); or unresolved. Rows whose destination URI is already taken — the same memory saved twice, once under each name — are left in place and counted as conflicts for you to review.

Architecture

Core Storage

Single SQLite database at ~/.rememora/rememora.db with WAL mode for concurrent access
URI-based hierarchy: rememora://projects/{name}/memories/{category}/{slug}
Unified contexts table — memories, projects, resources all in one table, differentiated by type
Tiered loading — each context has L0 (abstract), L1 (overview), L2 (content) fields
Hotness scoring: sigmoid(log1p(access_count)) * exp(-age/half_life) blended 30/70 with importance
FTS5 full-text search with auto-synced triggers on insert/update/delete
Soft deletion via superseded_by pointers (audit trail, no data loss)

Search

BM25 — FTS5-based search across name, abstract, overview, content, tags, category
Vector search — optional cosine similarity via sqlite-vec + all-MiniLM-L6-v2 (384-dim, feature-gated)
Hybrid RRF — reciprocal rank fusion merges BM25 + vector results: RRF(d) = Σ 1/(k+rank) with k=60
Pluggable embedding backend — EmbedBackend trait with Candle implementation (Metal GPU + CPU fallback)

Curation Pipeline

Session JSONL → Watermark (incremental) → Signal Gate (Haiku) → AUDN Curator (Sonnet) → rememora save/search/supersede

Watermark tracking — byte offset per session file, never re-processes old content
Signal gate — fast Haiku YES/NO classification (min 500 chars, max 32KB transcript)
AUDN cycle — Sonnet subagent with Bash access runs Add/Update/Delete/Noop
Consolidation — BM25 clustering + LLM merge/supersede proposals with dual gate (24h + 5 new memories); applying is opt-in (rememora evolve --apply)
Audit trail — curator log tracks every action with model, reason, and timestamp

Three-Layer Integration

┌─────────────────────────────────────────────┐
│ Layer 3: Multi-Agent Orchestration          │
│ agent-run, agent-loop, developer/triage     │
│ agents, atomic locking, git worktrees       │
├─────────────────────────────────────────────┤
│ Layer 2: Claude Code Plugin                 │
│ Skills (save, search, init) — model-invoked │
├─────────────────────────────────────────────┤
│ Layer 1: CLI Core                           │
│ save, search, context, session, curate,     │
│ evolve, extract, agent-run, eval, export    │
└─────────────────────────────────────────────┘

Database Schema (7 migrations)

Table	Purpose
`contexts`	Unified memory storage (20 columns, ULID PKs, URI hierarchy, L0/L1/L2 layers, `worktree`/`branch` provenance)
`contexts_fts`	FTS5 virtual table (auto-synced via triggers)
`sessions`	Agent session tracking (15 columns) with parent chains for transfer and `worktree`/`branch` provenance
`relations`	Bidirectional inter-context links (related, depends_on, derived_from, supersedes)
`context_embeddings`	Vector storage (f32 BLOB, feature-gated)
`vec_contexts`	sqlite-vec KNN index (feature-gated)
`watermarks`	Incremental curation byte offsets per session file
`curator_log`	Audit trail of curation actions (add/update/delete/noop)
`consolidation_runs`	Memory consolidation run history

Eval Benchmark

A TypeScript harness for measuring rememora instruction compliance and autonomous agent behavior.

cd bench

# Quick scenario eval (6 scenarios)
pnpm run eval -- --cli claude-code

# Multi-task sequence with experiment condition
pnpm run eval:long -- --sequence tasks/instruction-mode-eval.json --condition conditions/full-hybrid.json

# Run all conditions in matrix mode
pnpm run eval:matrix -- --sequence tasks/instruction-mode-eval.json

# Compare results across conditions
pnpm run compare:conditions

Quick scenarios test isolated rememora CLI compliance: session start, save decision, save case, search, transfer handoff, session end.

Long-run sequences measure autonomous behavior across multi-task workflows (8 tasks simulating real project development). Five instruction delivery modes are compared:

Condition	Description
`none`	No rememora instructions (baseline)
`reference-card`	Quick command reference
`behavioral-triggers`	"When to SEARCH", "When to SAVE" guidance
`hooks-only`	Minimal reminders
`full-hybrid`	Comprehensive MANDATORY protocol

Results are exported as Braintrust-aligned JSONL (input/output/expected/scores/metadata), importable into AI Foundry, Langfuse, LangSmith, and OpenAI Evals with thin adapters.

Runners: Claude Code, Codex, Claude Tmux (interactive).

Development

cargo test          # 345 tests (lib + integration)
cargo build         # Debug build
cargo clippy        # Lint

Source Structure

Module	Purpose
`main.rs`	CLI entry point (clap, 28 commands)
`db.rs`	SQLite connection, WAL, 7 migrations (006/007 `ADD COLUMN`s are guarded in Rust, not SQL)
`uri.rs`	`rememora://` URI parsing & building
`models/context.rs`	Context CRUD + FTS5
`models/session.rs`	Session lifecycle + transfer chains
`models/project.rs`	Project metadata, worktree-aware write-target resolution (`resolve_write_target`), stranded-namespace reconcile
`models/relation.rs`	Bidirectional context links
`models/watermark.rs`	Curation watermarks + curator log + consolidation runs
`hierarchy.rs`	L0/L1 context assembly
`hotness.rs`	Scoring: sigmoid(log1p(access)) * exp(-age/7)
`search.rs`	BM25 + vector + reciprocal rank fusion
`format.rs`	Markdown/JSON output formatting
`curator.rs`	Signal gate + AUDN subagent curation
`jsonl.rs`	Claude Code session JSONL parser + noise filtering
`evolve.rs`	BM25 clustering for memory consolidation
`embed/mod.rs`	EmbedBackend trait
`embed/candle.rs`	Candle implementation (all-MiniLM-L6-v2, 384-dim)
`commands/*`	Individual command implementations

Dependencies

Core: rusqlite (bundled), clap 4, serde, ulid, chrono, dirs, anyhow, cliclack, ureq

Embedding (feature-gated): candle-core/nn/transformers, hf-hub, tokenizers, sqlite-vec

Feature flags: embed-candle (vector search via Candle), embed-llamacpp (stub), metal (Apple GPU)

Roadmap

Insights

Non-obvious gotchas and design decisions discovered while building rememora: Engineering Insights

License

MIT

Name		Name	Last commit message	Last commit date
.agents		.agents
.claude-plugin		.claude-plugin
.claude		.claude
.github		.github
app		app
bench		bench
docker		docker
docs		docs
plugin		plugin
prompts		prompts
scripts		scripts
src		src
tests		tests
.dockerignore		.dockerignore
.gitignore		.gitignore
AGENTS.md		AGENTS.md
CHANGELOG.md		CHANGELOG.md
CLAUDE.md		CLAUDE.md
Cargo.lock		Cargo.lock
Cargo.toml		Cargo.toml
LICENSE		LICENSE
README.md		README.md
VERSION		VERSION

Latest commit

History

Folders and files

Repository files navigation