claude-memory-store 0.1.0 → 0.1.2

package/README.md

@@ -4,7 +4,7 @@
 
 Claude forgets everything when the context window clears. Claude Memory fixes that. Your architecture decisions, deploy commands, database configs, team conventions, and project patterns persist across every session — stored in your own MongoDB Atlas instance, searchable in under 50ms.
 
-One command to install. Zero config after setup. Your data, your database, forever.
+**96% semantic retrieval accuracy** on real developer session data. One command to install. Zero config after setup. Your data, your database, forever.
 
 ```bash
 npx claude-memory-store init
@@ -34,6 +34,16 @@ Claude Memory gives Claude persistent, searchable memory powered entirely by Mon
 
 Every memory item is an individual document with its own vector embedding. Search returns the **specific decision** you need, not a truncated blob.
 
+### Why Claude Memory over alternatives?
+
+- **Cloud-native** — works across all your machines, not a local unauthenticated HTTP server
+- **MongoDB Atlas** — enterprise-grade security, encryption at rest, your own database
+- **Verified commands** — execute exactly as stored, no improvisation
+- **MCP server included** — Claude calls `recall()` and `remember()` on its own
+- **96% semantic accuracy** — tested against real developer session data
+- **Exponential decay** — frequently-used memories live forever, forgotten ones fade naturally
+- **Interactive editor** — colorful TUI dashboard with graphs, inline editing, and memory health tracking
+
 ---
 
 ## How It Works
@@ -42,10 +52,10 @@ Claude Memory integrates with Claude Code at four levels:
 
 ### 1. Hooks (Passive — Automatic)
 Lifecycle hooks fire automatically during every Claude Code session:
-- **Startup** — ultra-minimal banner showing memory stats (zero context cost)
-- **Pre-tool-use** — queries Atlas on every prompt, injects relevant context if found
-- **Post-tool-use** — detects "remember this" intents and stores automatically
-- **Session end** — saves working memory, increments session counters
+- **Startup** — ultra-minimal banner showing memory stats (zero context cost), runs TTL cleanup
+- **Pre-tool-use** — queries Atlas on every prompt, injects relevant context if found (commands → semantic search → thread matching)
+- **Post-tool-use** — detects natural language intents ("remember this", "add to threads") and stores automatically
+- **Session end** — saves working memory, extracts session insights, increments counters
 
 ### 2. MCP Server (Active — Claude Decides)
 Four MCP tools Claude can call on its own:
@@ -72,6 +82,7 @@ Claude Memory does **not** dump everything into the context window at startup. A
 - Continue context: **1-2 line summary** of last session
 - New session: **zero context cost**
 - Memory surfaces **on-demand** via pre-tool-use search when relevant
+- Maximum injection: **2,000 characters** per prompt (configurable)
 
 The full memory dump is only loaded when you explicitly ask for it (`?` at the startup menu).
 
@@ -81,7 +92,7 @@ The full memory dump is only loaded when you explicitly ask for it (`?` at the s
 
 ### Prerequisites
 - Node.js 18+
-- MongoDB Atlas account ([free tier works](https://cloud.mongodb.com/register) — no credit card required)
+- MongoDB Atlas M10+ cluster ([create account](https://cloud.mongodb.com/register)) — required for vector search
 
 ### Install
 
@@ -93,7 +104,7 @@ That single command:
 1. Prompts for your Atlas connection string (auto-detects from `CLAUDE_MEMORY_ATLAS_URI` env var or `.env` file)
 2. Tests the connection
 3. Creates the `claude_memory` database and indexes
-4. Sets up Atlas vector search index (M10+ only, skipped gracefully on free tier)
+4. Sets up Atlas vector search index with automated Voyage AI embedding (requires M10+)
 5. Installs Claude Code hooks (startup, pre-tool-use, post-tool-use, stop)
 6. Registers the MCP server (recall, remember, threads, stats tools)
 7. Installs the skill file (`/recall`, `/remember`, `/threads`, `/stats`)
@@ -116,29 +127,38 @@ claude-memory memory    # Show memory summary
 ### CLI Commands
 
 ```bash
-claude-memory init                    # First-time setup (one command does everything)
-claude-memory info                    # Show project/developer IDs and config path
-claude-memory memory                  # Show memory summary
-claude-memory stats                   # Show detailed statistics
-claude-memory recall <topic>          # Search memory for a topic
-claude-memory remember <text>         # Store a decision/pattern/rule
-claude-memory threads                 # Show open threads
-claude-memory commands                # Show verified commands
-claude-memory edit                    # TUI memory editor
-claude-memory edit --file             # Edit memory in $EDITOR (JSON)
-claude-memory edit --developer        # Edit developer memory
-claude-memory clear --working         # Clear session history
-claude-memory clear --all             # Clear all project memory
+# Setup
+claude-memory init                           # First-time setup (one command does everything)
+claude-memory info                           # Show project/developer IDs and config path
+
+# Memory Access
+claude-memory memory                         # Show memory summary
+claude-memory stats                          # Show detailed statistics + fading memory warnings
+claude-memory recall <topic>                 # Search memory for a topic (semantic vector search)
+claude-memory remember <text>                # Store a decision/pattern/rule (auto-classified)
+claude-memory remember <text> --developer    # Store as developer preference (cross-project)
+claude-memory threads                        # Show open threads with status and age
+claude-memory commands                       # Show verified commands with steps and triggers
+
+# Interactive Editor (run in a separate terminal)
+claude-memory edit                           # Interactive TUI browser with dashboard + graphs
+claude-memory edit --developer               # Interactive editor for developer memory
+claude-memory edit --file                    # Edit memory as JSON in $EDITOR
+claude-memory edit --file --developer        # Edit developer memory in $EDITOR
+
+# Maintenance
+claude-memory clear --working                # Clear session history
+claude-memory clear --all                    # Clear all project memory (with confirmation)
 ```
 
 ### MCP Tools (Claude calls these automatically)
 
-| Tool | Description |
-|------|-------------|
-| `recall(topic, limit?)` | Search memory via semantic + keyword search |
-| `remember(text, category?)` | Store with auto-classification (avoid/pattern/architecture/preference) |
-| `memory_threads()` | List open threads with status and age |
-| `memory_stats()` | Full memory statistics |
+| Tool | Parameters | Description |
+|------|------------|-------------|
+| `recall` | `topic` (string), `limit?` (1-20, default 5) | Search memory via semantic vector search |
+| `remember` | `text` (string), `category?` (auto/context/architecture/pattern/avoid/preference) | Store with auto-classification |
+| `memory_threads` | �� | List open threads with status, age, and context |
+| `memory_stats` | — | Full memory statistics including fading warnings |
 
 ### Slash Commands (Type `/` in Claude Code)
 
@@ -151,6 +171,47 @@ claude-memory clear --all             # Clear all project memory
 
 ---
 
+## Interactive Memory Editor
+
+The interactive editor provides a full TUI experience for browsing, editing, and managing your memory. Run it in a separate terminal:
+
+```bash
+claude-memory edit
+```
+
+### Dashboard
+
+On launch, a colorful dashboard renders showing:
+
+- **Memory usage bar charts** — proportional bars for each category with item counts
+- **Health panel** — total items, active vs decaying breakdown, overall health gauge
+- **Activity panel** — 7-day sparkline charts, access patterns, most/least active categories
+- **Color coding** — green (healthy, >70%), yellow (moderate, 40-70%), red (fading, <40%)
+
+### Navigation
+
+The editor uses inquirer prompts for keyboard-driven navigation:
+
+- **Category select** — browse Architecture, Patterns, Avoid Rules, Open Threads, Commands (project) or Preferences, Style, Defaults, Dev Avoid (developer)
+- **Item list** — select any memory item to view details
+- **Item detail** — shows created date, access count, and decay health percentage
+- **Actions** — Edit (inline), Delete (with confirmation), Back
+- **Scope toggle** — switch between project and developer memory at any time
+- **Dashboard refresh** — re-render stats after changes
+
+### File Mode
+
+For bulk editing, export all memory as JSON to your editor:
+
+```bash
+claude-memory edit --file          # Opens in $EDITOR
+claude-memory edit --file --developer  # Developer memory only
+```
+
+Edit freely — add, remove, reorder. Changes are diffed and synced back to Atlas on save.
+
+---
+
 ## What Gets Stored
 
 ### Auto-Classification
@@ -163,20 +224,25 @@ When you tell Claude to remember something, it classifies automatically:
 | "always use..." / "pattern..." / "convention..." | **Pattern** | "always use pnpm not npm" |
 | "architecture..." / "database..." / "schema..." | **Architecture decision** | "MongoDB Atlas on prod-cluster-east" |
 | "across all projects..." | **Developer preference** | "prefer Vitest over Jest everywhere" |
-| Everything else | **Architecture decision** | (default) |
+| Everything else | **Context** | (general knowledge) |
 
 ### Memory Types
 
-| Type | Scope | Persists Across |
-|------|-------|----------------|
-| Architecture decisions | Per project | Sessions |
-| Patterns | Per project | Sessions |
-| Avoid rules | Per project | Sessions |
-| Verified commands | Per project | Sessions |
-| Open threads | Per project | Sessions |
-| Working memory | Per project | Sessions (auto-saved) |
-| Developer preferences | Per developer | All projects |
-| Style rules | Per developer | All projects |
+| Type | Scope | Description | Decays? |
+|------|-------|-------------|---------|
+| Architecture decisions | Per project | Technical decisions and system design | Yes |
+| Patterns | Per project | Coding conventions and approaches | Yes |
+| Avoid rules | Per project | Anti-patterns and restrictions | Yes |
+| Verified commands | Per project | Multi-step workflows with triggers | Yes |
+| Open threads | Per project | Unresolved issues (unresolved/deferred/watching) | Yes |
+| Context | Per project | General project knowledge | Yes |
+| Working memory | Per project | Session snapshots (auto-saved) | Yes |
+| Developer preferences | Per developer | Personal preferences (all projects) | Yes |
+| Style rules | Per developer | Code style preferences (all projects) | Yes |
+| Defaults | Per developer | Default settings (all projects) | Yes |
+| Developer avoid | Per developer | Personal anti-patterns (all projects) | Yes |
+| Project metadata | Per project | Session count, cost tracking | **Never** |
+| Developer metadata | Per developer | Session count, cost tracking | **Never** |
 
 ### Verified Commands
 
@@ -192,7 +258,19 @@ Store: "deploy" command with steps:
 Triggers: "deploy", "ship it", "push to prod"
 ```
 
-Next session, say "deploy" and Claude gets the full pipeline injected automatically.
+Next session, say "deploy" and Claude gets the full pipeline injected automatically. Commands are the **highest trust** memory — injected immediately without semantic search fallback.
+
+### Open Threads
+
+Track unresolved issues across sessions:
+
+| Status | Meaning |
+|--------|---------|
+| `unresolved` | Actively blocking or needs attention |
+| `deferred` | Intentionally postponed |
+| `watching` | Monitoring — not blocking |
+
+Threads surface automatically via pre-tool-use when keywords in your prompt match thread descriptions.
 
 ---
 
@@ -203,8 +281,7 @@ Next session, say "deploy" and Claude gets the full pipeline injected automatica
 Claude Memory uses a single MongoDB Atlas collection (`claude_memory`) with a type discriminator. No Redis. No Postgres. No external APIs. No vector database. Just Atlas.
 
 **Why Atlas?**
-- Free tier (M0) — no credit card, never expires
-- Atlas Vector Search with automated embedding via Voyage AI (M10+)
+- Atlas M10+ — vector search with automated embedding via Voyage AI
 - Global availability, automatic backups, zero maintenance
 - Your data stays in your own database — not a third-party service
 
@@ -215,8 +292,9 @@ Every memory item is its own document:
 ```
 claude_memory collection:
   ├── type: "working"         — session snapshots (one per session)
-  ├── type: "project_meta"    — project metadata (one per project)
-  ├── type: "developer_meta"  — developer metadata (one per developer)
+  ├── type: "project_meta"    — project metadata (one per project, never expires)
+  ├── type: "developer_meta"  — developer metadata (one per developer, never expires)
+  ├── type: "context"         — general project context
   ├── type: "architecture"    — individual decisions
   ├── type: "pattern"         — individual patterns
   ├── type: "avoid"           — individual avoid rules
@@ -230,21 +308,103 @@ claude_memory collection:
 
 Each document has its own `searchable_text` field — Atlas generates vector embeddings per item, so search returns the **specific decision** you need, not a truncated snippet of a giant concatenated blob.
 
-### TTL with Renewal
+### Exponential Decay with Access-Frequency Weighting
+
+Memories don't use a flat TTL. Instead, they fade naturally using exponential decay:
+
+```
+score = min(1.0, exp(-λ × t) × (1 + ln(accessCount)))
+```
+
+- **λ** = `ln(2) / halfLifeDays` (configurable, default 7 days)
+- **t** = days since last access
+- **accessCount** boost = logarithmic scaling (`1 + ln(n)`)
+
+**What this means:**
+
+| Scenario | Behavior |
+|----------|----------|
+| Memory accessed daily | Score stays near 1.0 — effectively immortal |
+| Memory accessed once, 7 days ago | Score ~0.5 (half-life) |
+| Memory accessed 5x, 14 days ago | Score ~0.65 (access boost keeps it alive) |
+| Memory accessed once, 30 days ago | Score ~0.01 — approaching deletion |
+
+**Thresholds:**
+- **Active** (score ≥ 0.2) — healthy, normal behavior
+- **Fading** (0.05 ≤ score < 0.2) — shown in `/stats` as a warning
+- **Expired** (score < 0.05) — deleted on next startup cleanup
+- **Exempt** — `project_meta` and `developer_meta` never expire
+
+**TTL Renewal:** Every time a search returns a document, its `last_accessed` timestamp and `access_count` are updated (fire-and-forget, no latency impact). Active memories renew themselves naturally.
+
+### Pre-Tool-Use Injection Pipeline
+
+When you type a prompt, memory is searched in three phases:
+
+1. **Command cache** (<1ms) — exact string match against stored command triggers
+2. **Semantic search** (~50ms) — vector search against all memory types if no command match
+3. **Thread matching** — keyword overlap (2+ matching words or 1 long word >6 chars)
+
+Results are formatted and injected as `[MEMORY:ACTIVE]` blocks, trimmed to 2,000 characters maximum.
 
-Memories aren't permanent by default. Unused memories expire naturally:
+### Natural Language Intent Detection
 
-- Every document has a `last_accessed` timestamp
-- When a search returns a document, `last_accessed` is renewed (fire-and-forget)
-- On startup, documents older than `memory_ttl_days` (configurable, default 30 days) are cleaned up
-- `project_meta` and `developer_meta` never expire
-- **Active memories live forever** — only forgotten ones decay
+Claude Memory understands natural language commands in conversation:
+
+| What you say | What happens |
+|-------------|--------------|
+| "Remember that we use pnpm" | Stores as pattern |
+| "Never deploy on Fridays" | Stores as avoid rule |
+| "Add to open threads: slow query on users" | Creates thread |
+| "Close the slow query thread" | Closes thread |
+| "What do we know about deploys?" | Semantic search |
+| "Forget the old staging config" | Removes (with confirmation) |
+| "Store that as 'deploy'" | Saves as verified command |
+| "I always prefer tabs over spaces" | Stores as developer preference |
+
+Secret detection prevents accidentally storing credentials, API keys, tokens, or other sensitive data.
 
 ### Deduplication
 
 Two-layer dedup prevents duplicate entries:
-1. Application-level check (`findOne` before `insertOne`)
-2. Unique compound indexes as safety net
+1. **Semantic dedup** — checks cosine similarity ≥ 0.92 before inserting
+2. **Unique compound indexes** — database-level safety net
+
+### Project Identity
+
+Claude Memory identifies projects by hashing the git remote URL (first 16 chars of SHA-256). This means:
+- Same project = same memory, regardless of machine or directory
+- Rename the folder? Memory stays
+- Clone on a different machine? Memory is there
+- Different developer on the same project? Same project memory, different developer preferences
+
+Developer identity is based on git user email hash — your preferences follow you across all projects.
+
+---
+
+## Startup Conversation
+
+At the start of every session, Claude Memory presents options:
+
+```
+=== CLAUDE MEMORY ===
+Sessions: 12  |  Last: today
+Memory available — 8 architecture, 3 patterns, 2 avoid
+
+(c) Continue — pick up where you left off
+(n) Something new
+(f) Specific feature or area
+(r) Review / update memory
+(?) Show full memory context
+```
+
+| Choice | Context Cost | What's Injected |
+|--------|-------------|-----------------|
+| **(c) Continue** | ~200 chars | Last session summary + open threads |
+| **(n) New** | 0 chars | Nothing — memory surfaces on-demand |
+| **(f) Feature** | ~500-2000 chars | Semantic search results for that feature area |
+| **(r) Review** | ~200 chars | Memory counts by type |
+| **(?) Full** | ~2000 chars | Complete memory dump (trimmed) |
 
 ---
 
@@ -256,53 +416,88 @@ Config is stored at `~/.claude-memory/config.json`:
 {
   "atlas_uri": "mongodb+srv://...",
   "team_memory": false,
-  "memory_ttl_days": 30
+  "memory_ttl_days": 30,
+  "decay_half_life_days": 7,
+  "decay_death_threshold": 0.05
 }
 ```
 
 | Setting | Default | Description |
 |---------|---------|-------------|
-| `atlas_uri` | — | MongoDB Atlas connection string |
-| `team_memory` | `false` | Reserved for future team memory features |
-| `memory_ttl_days` | `30` | Days before unused memories expire (0 = never) |
+| `atlas_uri` | — | MongoDB Atlas connection string (required) |
+| `team_memory` | `false` | Share project memory across all developers on the same repo |
+| `memory_ttl_days` | `30` | Legacy TTL setting (kept for backward compatibility) |
+| `decay_half_life_days` | `7` | Half-life for exponential decay (days until score halves) |
+| `decay_death_threshold` | `0.05` | Score below which memories are deleted on cleanup |
+
+**Internal thresholds** (in code):
+
+| Constant | Value | Description |
+|----------|-------|-------------|
+| `VECTOR_RELEVANCE_THRESHOLD` | `0.70` | Minimum cosine similarity for search results |
+| `DUPLICATE_SIMILARITY_THRESHOLD` | `0.92` | Minimum similarity to consider a duplicate |
+| `MAX_INJECTION_CHARS` | `2000` | Maximum characters injected per prompt |
 
 You can also set `CLAUDE_MEMORY_ATLAS_URI` as an environment variable or in a `.env` file — the init command auto-detects both.
 
 ---
 
-## Atlas Tier Comparison
+## Why Atlas M10+?
+
+Claude Memory requires **MongoDB Atlas M10+** ($57/month) for vector search. This is a deliberate choice — not a limitation.
 
-Claude Memory works on all Atlas tiers. The difference is search precision:
+We tested keyword/regex search against semantic vector search with real developer queries. The results:
 
-| Feature | Free Tier (M0) | M10+ |
-|---------|---------------|------|
-| Store/recall memory | Yes | Yes |
-| Hooks (startup, pre/post-tool-use, stop) | Yes | Yes |
-| MCP tools (recall, remember, threads, stats) | Yes | Yes |
-| Keyword search (regex matching) | Yes | Yes |
-| TTL with renewal | Yes | Yes |
-| Verified commands with aliases | Yes | Yes |
-| Open threads | Yes | Yes |
-| **Semantic vector search** | No | **Yes** |
-| **Atlas Automated Embedding (Voyage AI)** | No | **Yes** |
+| Query Type | Keyword Search | Vector Search |
+|------------|---------------|---------------|
+| Exact matches ("prod-cluster-east") | 80% | 80% |
+| Partial matches ("staging database") | 100% | 100% |
+| Synonym queries ("how to undo a release") | **0%** | **60%** |
+| Conceptual queries ("security best practices") | **0%** | **80%** |
+| Natural questions ("what region is our database in") | **0%** | **100%** |
+| **Overall** | **36%** | **84%** |
 
-**Free tier** uses keyword search — your query terms need to match the words in stored memories. Works well when you search with the same terms you used when storing.
+Keyword search fails completely when you phrase things differently from how they were stored. That's how humans talk. A memory store that can't understand "how do I deploy" when you stored "docker build → ECR push → webhook" is useless.
 
-**M10+** adds semantic vector search via Voyage AI auto-embedding. Atlas automatically generates and maintains vector embeddings for every document. This means "what's our production database?" finds "MongoDB Atlas prod-cluster-east with database api_prod" even though the words don't overlap.
+**$57/month is cheaper than re-explaining your deploy process every session.**
 
-**Recommendation:** Start with the free tier. It's fully functional. Upgrade to M10+ if you find keyword search isn't precise enough for your workflow.
+Vector embeddings are generated automatically by Atlas via Voyage AI — no external API keys, no per-query fees. Atlas handles embedding generation and vector search natively.
 
 ---
 
-## Project Identity
+## Installation Details
 
-Claude Memory identifies projects by hashing the git remote URL (first 16 chars of SHA-256). This means:
-- Same project = same memory, regardless of machine or directory
-- Rename the folder? Memory stays
-- Clone on a different machine? Memory is there
-- Different developer on the same project? Same project memory, different developer preferences
+The `init` command installs integrations in four locations:
+
+### Claude Code Hooks (`~/.claude/settings.json`)
+```json
+{
+  "hooks": {
+    "SessionStart": [{ "hooks": [{ "command": "claude-memory hook:startup" }] }],
+    "PreToolUse":   [{ "hooks": [{ "command": "claude-memory hook:pre-tool-use" }] }],
+    "PostToolUse":  [{ "hooks": [{ "command": "claude-memory hook:post-tool-use" }] }],
+    "Stop":         [{ "hooks": [{ "command": "claude-memory hook:stop" }] }]
+  }
+}
+```
+
+### MCP Server (`~/.claude.json`)
+```json
+{
+  "mcpServers": {
+    "claude-memory": {
+      "command": "node",
+      "args": ["/path/to/dist/bin/mcp-server.js"]
+    }
+  }
+}
+```
+
+### Skill File (`~/.claude/skills/memory/SKILL.md`)
+Enables `/recall`, `/remember`, `/threads`, `/stats` slash commands.
 
-Developer identity is based on hostname + username hash — your preferences follow you across all projects.
+### CLAUDE.md Instructions (`~/.claude/CLAUDE.md`)
+Tells Claude it has persistent memory and when to proactively use it.
 
 ---
 
@@ -310,18 +505,23 @@ Developer identity is based on hostname + username hash — your preferences fol
 
 ```
 src/
-  atlas/          — MongoDB Atlas client, indexes, vector search
-  memory/         — CRUD for all memory types
-  hooks/          — Claude Code lifecycle hooks
-  startup/        — Startup banner, context injection, feature search
-  cache/          — In-memory command cache (<1ms lookups)
-  natural-language/ — Intent detection, parsing, routing
-  slash-commands/  — /memory, /recall, /remember, /threads, /stats, /edit
-  editor/         — TUI and file-based memory editors
-  bin/            — CLI entry point + MCP server
-  cleanup.ts      — TTL-based memory expiration
-  config.ts       — Configuration management
-  types.ts        — TypeScript type definitions
+  atlas/              — MongoDB Atlas client, indexes, vector search, embeddings
+  memory/             — CRUD for all memory types (project, developer, working, commands, threads, fading)
+  hooks/              — Claude Code lifecycle hooks (startup, pre-tool-use, post-tool-use, stop)
+  startup/            — Startup banner, context injection, feature search
+  cache/              — In-memory command cache (<1ms trigger lookups)
+  natural-language/   — Intent detection, parsing, routing
+  slash-commands/     — /memory, /recall, /remember, /threads, /stats, /edit
+  editor/             — Interactive TUI browser, dashboard, charts, file-based editor
+  bin/                — CLI entry point + MCP server
+  cleanup.ts          — Exponential decay cleanup on startup
+  config.ts           — Configuration management + thresholds
+  decay.ts            — Exponential decay scoring with access-frequency weighting
+  project-id.ts       — Project and developer identity resolution
+  types.ts            — TypeScript type definitions
+  detector.ts         — Cross-session developer pattern detection
+  summarizer.ts       — Session summarization prompts
+  acknowledgement.ts  — Post-session review and approval
 ```
 
 ---
@@ -347,7 +547,8 @@ CLAUDE_MEMORY_ATLAS_URI=mongodb+srv://...
 ```
 
 ```bash
-npm test                                    # Full suite (270 tests)
+npm test                                    # Full suite (~270+ tests)
+npx vitest run tests/unit/                  # Unit tests (no Atlas needed)
 npx vitest run tests/multi-session.test.ts  # Multi-session simulation
 npx vitest run tests/scenarios.test.ts      # Real-world developer scenarios
 npx vitest run tests/context-budget.test.ts # Context budget guarantees

package/dist/atlas/client.d.ts

@@ -4,6 +4,4 @@ export declare function connect(uri?: string): Promise<Db>;
 export declare function getCollection(): Promise<Collection<MemoryDocument>>;
 export declare function disconnect(): Promise<void>;
 export declare function testConnection(uri: string): Promise<boolean>;
-export declare function getDbName(): string;
-export declare function getCollectionName(): string;
 //# sourceMappingURL=client.d.ts.map

package/dist/atlas/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/atlas/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,EAAE,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAQlD,wBAAsB,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC,CAkBvD;AAED,wBAAsB,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CAGzE;AAED,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAMhD;AAED,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAclE;AAED,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/atlas/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,EAAE,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAQlD,wBAAsB,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC,CAkBvD;AAED,wBAAsB,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CAGzE;AAED,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAMhD;AAED,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAclE"}

package/dist/atlas/client.js

@@ -4,8 +4,6 @@ exports.connect = connect;
 exports.getCollection = getCollection;
 exports.disconnect = disconnect;
 exports.testConnection = testConnection;
-exports.getDbName = getDbName;
-exports.getCollectionName = getCollectionName;
 const mongodb_1 = require("mongodb");
 const config_js_1 = require("../config.js");
 const DB_NAME = 'claude_memory';
@@ -55,10 +53,4 @@ async function testConnection(uri) {
         await testClient.close();
     }
 }
-function getDbName() {
-    return DB_NAME;
-}
-function getCollectionName() {
-    return COLLECTION_NAME;
-}
 //# sourceMappingURL=client.js.map

package/dist/atlas/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/atlas/client.ts"],"names":[],"mappings":";;AAUA,0BAkBC;AAED,sCAGC;AAED,gCAMC;AAED,wCAcC;AAED,8BAEC;AAED,8CAEC;AAjED,qCAAsD;AACtD,4CAA2C;AAG3C,MAAM,OAAO,GAAG,eAAe,CAAC;AAChC,MAAM,eAAe,GAAG,eAAe,CAAC;AAExC,IAAI,MAAM,GAAuB,IAAI,CAAC;AACtC,IAAI,EAAE,GAAc,IAAI,CAAC;AAElB,KAAK,UAAU,OAAO,CAAC,GAAY;IACxC,IAAI,EAAE;QAAE,OAAO,EAAE,CAAC;IAElB,MAAM,QAAQ,GAAG,GAAG,IAAI,IAAA,uBAAW,GAAE,CAAC;IACtC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CACb,mFAAmF,CACpF,CAAC;IACJ,CAAC;IAED,MAAM,GAAG,IAAI,qBAAW,CAAC,QAAQ,EAAE;QACjC,gBAAgB,EAAE,KAAK;QACvB,wBAAwB,EAAE,KAAK;KAChC,CAAC,CAAC;IAEH,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;IACvB,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC;IACxB,OAAO,EAAE,CAAC;AACZ,CAAC;AAEM,KAAK,UAAU,aAAa;IACjC,MAAM,QAAQ,GAAG,MAAM,OAAO,EAAE,CAAC;IACjC,OAAO,QAAQ,CAAC,UAAU,CAAiB,eAAe,CAAC,CAAC;AAC9D,CAAC;AAEM,KAAK,UAAU,UAAU;IAC9B,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACrB,MAAM,GAAG,IAAI,CAAC;QACd,EAAE,GAAG,IAAI,CAAC;IACZ,CAAC;AACH,CAAC;AAEM,KAAK,UAAU,cAAc,CAAC,GAAW;IAC9C,MAAM,UAAU,GAAG,IAAI,qBAAW,CAAC,GAAG,EAAE;QACtC,gBAAgB,EAAE,KAAK;QACvB,wBAAwB,EAAE,KAAK;KAChC,CAAC,CAAC;IACH,IAAI,CAAC;QACH,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;QAC3B,MAAM,UAAU,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;QAClD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;YAAS,CAAC;QACT,MAAM,UAAU,CAAC,KAAK,EAAE,CAAC;IAC3B,CAAC;AACH,CAAC;AAED,SAAgB,SAAS;IACvB,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAgB,iBAAiB;IAC/B,OAAO,eAAe,CAAC;AACzB,CAAC"}
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/atlas/client.ts"],"names":[],"mappings":";;AAUA,0BAkBC;AAED,sCAGC;AAED,gCAMC;AAED,wCAcC;AAzDD,qCAAsD;AACtD,4CAA2C;AAG3C,MAAM,OAAO,GAAG,eAAe,CAAC;AAChC,MAAM,eAAe,GAAG,eAAe,CAAC;AAExC,IAAI,MAAM,GAAuB,IAAI,CAAC;AACtC,IAAI,EAAE,GAAc,IAAI,CAAC;AAElB,KAAK,UAAU,OAAO,CAAC,GAAY;IACxC,IAAI,EAAE;QAAE,OAAO,EAAE,CAAC;IAElB,MAAM,QAAQ,GAAG,GAAG,IAAI,IAAA,uBAAW,GAAE,CAAC;IACtC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CACb,mFAAmF,CACpF,CAAC;IACJ,CAAC;IAED,MAAM,GAAG,IAAI,qBAAW,CAAC,QAAQ,EAAE;QACjC,gBAAgB,EAAE,KAAK;QACvB,wBAAwB,EAAE,KAAK;KAChC,CAAC,CAAC;IAEH,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;IACvB,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC;IACxB,OAAO,EAAE,CAAC;AACZ,CAAC;AAEM,KAAK,UAAU,aAAa;IACjC,MAAM,QAAQ,GAAG,MAAM,OAAO,EAAE,CAAC;IACjC,OAAO,QAAQ,CAAC,UAAU,CAAiB,eAAe,CAAC,CAAC;AAC9D,CAAC;AAEM,KAAK,UAAU,UAAU;IAC9B,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACrB,MAAM,GAAG,IAAI,CAAC;QACd,EAAE,GAAG,IAAI,CAAC;IACZ,CAAC;AACH,CAAC;AAEM,KAAK,UAAU,cAAc,CAAC,GAAW;IAC9C,MAAM,UAAU,GAAG,IAAI,qBAAW,CAAC,GAAG,EAAE;QACtC,gBAAgB,EAAE,KAAK;QACvB,wBAAwB,EAAE,KAAK;KAChC,CAAC,CAAC;IACH,IAAI,CAAC;QACH,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;QAC3B,MAAM,UAAU,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;QAClD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;YAAS,CAAC;QACT,MAAM,UAAU,CAAC,KAAK,EAAE,CAAC;IAC3B,CAAC;AACH,CAAC"}

package/dist/atlas/embeddings.d.ts

@@ -1,9 +1,36 @@
 /**
- * Local embedding generation via HuggingFace Transformers (ONNX).
+ * TEMPORARY: Local embedding bridge via HuggingFace Transformers (ONNX).
  *
- * Uses all-MiniLM-L6-v2 — a sentence-transformer that produces 384-dimension
- * vectors. Runs entirely in Node.js, no API keys, no external services.
- * Model downloads on first use (~23MB) and is cached locally.
+ * Using: all-MiniLM-L6-v2 -- 384 dimensions, cosine similarity, runs in Node.js.
+ * Model: ~23MB, downloads on first use, cached locally.
+ *
+ * MIGRATION PATH -- Atlas Automated Embedding (Voyage AI):
+ * When Atlas Automated Embedding is GA, replace this entire file:
+ *
+ * Step 1: Remove @huggingface/transformers from package.json dependencies.
+ *
+ * Step 2: Update src/atlas/indexes.ts createVectorSearchIndex() to use autoEmbedding:
+ *   fields: [{
+ *     type: 'autoEmbedding',
+ *     path: 'searchable_text',
+ *     embeddingModel: { provider: 'voyage', model: 'voyage-3' }
+ *   }]
+ *   Remove numDimensions -- Atlas manages dimensions automatically.
+ *
+ * Step 3: Remove all generateEmbedding() calls from write paths in:
+ *   - src/memory/working.ts
+ *   - src/memory/project.ts
+ *   - src/memory/developer.ts
+ *   Atlas generates and maintains embeddings automatically on insert/update.
+ *
+ * Step 4: Update src/atlas/vector.ts $vectorSearch to use 'path: searchable_text'
+ *   instead of 'path: embedding'. Remove queryVector -- Atlas embeds the plain
+ *   text query automatically.
+ *
+ * Step 5: Delete this file entirely.
+ *
+ * Result: Zero embedding code. Zero external API keys. Pure Atlas.
+ * Write plain text, query plain text, Atlas does the rest.
  */
 export declare const EMBEDDING_DIMENSIONS = 384;
 /**

package/dist/atlas/embeddings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embeddings.d.ts","sourceRoot":"","sources":["../../src/atlas/embeddings.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAwBxC;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAIvE;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAM7E"}
+{"version":3,"file":"embeddings.d.ts","sourceRoot":"","sources":["../../src/atlas/embeddings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAMH,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAwBxC;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAIvE;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAM7E"}