get-claudia 1.51.21 → 1.51.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.51.21",
+  "version": "1.51.22",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/template-v2/.claude/hooks/hooks.json

@@ -14,14 +14,14 @@
         ],
         "on_missing_me": "trigger_onboarding",
         "memory_verification": {
-          "step_1_check_cli": "BEFORE anything else, verify the `claudia` CLI is available by running `claudia system-health --project-dir \"$PWD\"` via Bash tool. If the command fails or is not found: (1) Do NOT fall back to plugin:episodic-memory, mcp__plugin_episodic-memory_*, or any other memory search tool as a substitute — these give inferior, unrelated results and mask the real problem. (2) Tell the user: 'My memory tools are not available. The Claudia CLI might not be installed or not on your PATH. To fix this, run: npm install -g get-claudia && claudia setup. Your context files are preserved.' (3) Continue with context files only (context/me.md, etc.) until fixed.",
-          "step_2_health_check": "Run `claudia memory session context --project-dir \"$PWD\"` via Bash tool. If it fails, the CLI may not be properly installed. Suggest: 'Claudia CLI may need reinstalling. Run: npm install -g get-claudia && claudia setup'",
-          "fallback": "If the `claudia` CLI is not available: (1) Do NOT use plugin:episodic-memory or any other memory search tool as a substitute. (2) Tell the user: 'My memory tools are not available. The Claudia CLI might not be installed. Run: npm install -g get-claudia && claudia setup.' (3) Read context files directly (context/me.md, context/commitments.md, context/learnings.md, context/patterns.md, context/waiting.md) as the fallback. Make clear to the user they are in degraded mode with no semantic search or cross-session learning."
+          "step_1_check_cli": "BEFORE anything else, verify the `claudia` CLI is available by running `claudia system-health --project-dir \"$PWD\"` via Bash tool. This checks that the claudia-memory daemon is configured and responsive. If the command fails or is not found: (1) Do NOT fall back to plugin:episodic-memory, mcp__plugin_episodic-memory_*, or any other memory search tool as a substitute — these give inferior, unrelated results and mask the real problem. (2) Tell the user: 'My memory tools are not available. The claudia-memory daemon may not be running or may not be configured as an MCP server. Check that the daemon is listed in your .mcp.json and that it starts without errors. Your context files are preserved.' (3) Continue with context files only (context/me.md, etc.) until fixed.",
+          "step_2_load_context": "Call the `memory.session_context` MCP tool to get a formatted context block with recent memories, commitments, and unsummarized session alerts. If the MCP tool is not available, the daemon may not be properly configured. Suggest: 'The claudia-memory daemon may need to be configured in .mcp.json. Run claudia system-health for diagnostics.'",
+          "fallback": "If memory MCP tools are not available: (1) Do NOT use plugin:episodic-memory or any other memory search tool as a substitute. (2) Tell the user: 'My memory tools are not available. The claudia-memory daemon may not be configured as an MCP server.' (3) Read context files directly (context/me.md, context/commitments.md, context/learnings.md, context/patterns.md, context/waiting.md) as the fallback. Make clear to the user they are in degraded mode with no semantic search or cross-session learning."
         },
         "enhanced_memory": {
-          "context_load": "Run `claudia memory session context --project-dir \"$PWD\"` via Bash tool to get a formatted context block with recent memories, commitments, and unsummarized session alerts.",
-          "catch_up": "If unsummarized sessions are reported in the context block, review buffered turns and run `claudia memory end-session --project-dir \"$PWD\"` with a retroactive narrative and structured extractions for each.",
-          "recall_context": "Use the loaded context for greeting. For deeper search on specific topics, run `claudia memory recall \"query\" --project-dir \"$PWD\"` via Bash tool."
+          "context_load": "Call the `memory.session_context` MCP tool to get a formatted context block with recent memories, commitments, and unsummarized session alerts.",
+          "catch_up": "If unsummarized sessions are reported in the context block, review buffered turns and call the `memory.end_session` MCP tool with a retroactive narrative and structured extractions for each.",
+          "recall_context": "Use the loaded context for greeting. For deeper search on specific topics, call the `memory.recall` MCP tool with the relevant query."
         },
         "proactive_surfacing": {
           "description": "Surface urgent items naturally in the greeting. Keep it to a brief mention, not a full report.",
@@ -30,12 +30,12 @@
             {
               "type": "overdue_commitments",
               "description": "Commitments older than 7 days without resolution",
-              "query_hint": "Run `claudia memory recall \"overdue commitments\" --type commitment --project-dir \"$PWD\"` and check dates"
+              "query_hint": "Call the `memory.recall` MCP tool with query about overdue commitments and check dates"
             },
             {
               "type": "cooling_relationships",
               "description": "Important people not mentioned in >30 days",
-              "query_hint": "Run `claudia memory entities search --type person --project-dir \"$PWD\"` and check last_mentioned dates"
+              "query_hint": "Call the `memory.search_entities` MCP tool with type: person and check last_mentioned dates"
             }
           ],
           "examples": [
@@ -58,7 +58,7 @@
         ],
         "save_mode": "merge",
         "enhanced_memory": {
-          "summarize": "Run `claudia memory end-session --summary \"...\" --narrative \"...\" --project-dir \"$PWD\"` via Bash tool with a narrative summary and structured extractions from the session's buffered turns. The narrative should enhance stored information with tone, context, unresolved threads, and nuance that structured fields cannot capture."
+          "summarize": "Call the `memory.end_session` MCP tool with a narrative summary and structured extractions from the session's buffered turns. The narrative should enhance stored information with tone, context, unresolved threads, and nuance that structured fields cannot capture."
         }
       }
     },
@@ -74,11 +74,11 @@
   ],
   "notes": {
     "implementation": "These hooks define intended behaviors. Claude Code will execute them as behavioral guidelines rather than traditional script execution.",
-    "memory_verification": "CRITICAL: At session start, verify the `claudia` CLI is available by running `claudia system-health --project-dir \"$PWD\"` BEFORE proceeding. If the command fails, do NOT use plugin:episodic-memory as a substitute. Tell the user to install the CLI: npm install -g get-claudia && claudia setup. Fall back to context files only (context/me.md, etc.) in the meantime.",
-    "session_start": "At session start: (1) Verify claudia CLI available, (2) Run `claudia memory session context --project-dir \"$PWD\"`, (3) Read context files, (4) Check for unsummarized sessions. If me.md is missing, trigger onboarding.",
-    "session_end": "Before session ends, Claudia should generate a session summary (enhanced memory) or update context files (markdown fallback). The summary includes both a free-form narrative and structured extractions.",
+    "memory_verification": "CRITICAL: At session start, verify memory availability by running `claudia system-health --project-dir \"$PWD\"` BEFORE proceeding. If memory MCP tools are not available, do NOT use plugin:episodic-memory as a substitute. Tell the user the claudia-memory daemon may need to be configured. Fall back to context files only (context/me.md, etc.) in the meantime.",
+    "session_start": "At session start: (1) Verify claudia system-health passes, (2) Call the `memory.session_context` MCP tool, (3) Read context files, (4) Check for unsummarized sessions. If me.md is missing, trigger onboarding.",
+    "session_end": "Before session ends, Claudia should generate a session summary via the `memory.end_session` MCP tool (enhanced memory) or update context files (markdown fallback). The summary includes both a free-form narrative and structured extractions.",
     "first_run": "The absence of context/me.md signals a first-run scenario requiring onboarding.",
-    "turn_buffering": "During sessions with enhanced memory, Claudia buffers each meaningful conversation turn via `claudia memory session buffer --project-dir \"$PWD\"`. This ensures nothing is lost even if the session ends abruptly. The buffered turns are summarized at session end or caught up at next session start.",
-    "source_filing": "CRITICAL: When processing transcripts, emails, or documents, ALWAYS run `claudia memory document store --project-dir \"$PWD\"` BEFORE extracting information. The Source Preservation principle (#12) is non-negotiable. Raw sources must be filed for provenance."
+    "turn_buffering": "During sessions with enhanced memory, Claudia buffers each meaningful conversation turn via the `memory.buffer_turn` MCP tool. This ensures nothing is lost even if the session ends abruptly. The buffered turns are summarized at session end or caught up at next session start.",
+    "source_filing": "CRITICAL: When processing transcripts, emails, or documents, ALWAYS call the `memory.file` MCP tool BEFORE extracting information. The Source Preservation principle (#12) is non-negotiable. Raw sources must be filed for provenance."
   }
 }

package/template-v2/.claude/hooks/pre-compact.py

@@ -1,35 +1,21 @@
 #!/usr/bin/env python3
 """Cross-platform pre-compact hook for Claudia.
 
-Runs lightweight consolidation and injects context advisory before compaction.
+Injects context advisory before compaction so Claude knows to preserve
+important information via MCP tools. Shell scripts cannot call MCP tools
+directly, so this advisory tells Claude what to do after compaction.
 """
 
 import json
-import os
-import shutil
-import subprocess
-
-# Run lightweight decay if claudia is available
-claudia_bin = shutil.which("claudia")
-if claudia_bin:
-    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
-    try:
-        subprocess.run(
-            [claudia_bin, "memory", "consolidate", "--lightweight",
-             "--project-dir", project_dir],
-            capture_output=True, timeout=10
-        )
-    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
-        pass
 
 print(json.dumps({
     "additionalContext": (
         "Context compaction advisory: If important information was discussed recently, "
-        "ensure it has been stored. Check: (1) Commitments: run claudia memory save "
-        "--type commitment for any promises not yet stored. (2) People: run claudia memory "
-        "entities create for anyone discussed in detail. (3) Relationships: run claudia memory "
-        "relate for connections mentioned. (4) Buffer: run claudia memory session buffer with "
-        "a summary if recent exchanges weren't buffered. With 1M context, compaction is "
-        "less frequent, but proactive capture remains good practice."
+        "ensure it has been stored via MCP tools. Check: (1) Commitments: call the "
+        "memory.remember MCP tool for any promises not yet stored. (2) People: call the "
+        "memory.entity MCP tool for anyone discussed in detail. (3) Relationships: call the "
+        "memory.relate MCP tool for connections mentioned. (4) Buffer: call the "
+        "memory.buffer_turn MCP tool with a summary if recent exchanges were not buffered. "
+        "With 1M context, compaction is less frequent, but proactive capture remains good practice."
     )
 }))

package/template-v2/.claude/hooks/pre-compact.sh

@@ -1,16 +1,12 @@
 #!/bin/bash
 # PreCompact hook: Advisory checkpoint before context compaction
-# Runs lightweight consolidation and injects advisory into compacted context
-
-# Run lightweight decay if claudia is available
-if command -v claudia &>/dev/null; then
-  claudia memory consolidate --lightweight --project-dir "${CLAUDE_PROJECT_DIR:-.}" 2>/dev/null || true
-fi
+# Injects advisory into compacted context so Claude knows to preserve important information via MCP tools.
+# Note: Shell scripts cannot call MCP tools directly. The advisory tells Claude what to do after compaction.
 
 # Inject advisory into compacted context
 cat <<EOF
 {
-  "additionalContext": "Context compaction advisory: If important information was discussed recently, ensure it has been stored. Check: (1) Commitments: run claudia memory save --type commitment for any promises not yet stored. (2) People: run claudia memory entities create for anyone discussed in detail. (3) Relationships: run claudia memory relate for connections mentioned. (4) Buffer: run claudia memory session buffer with a summary if recent exchanges weren't buffered. With 1M context, compaction is less frequent, but proactive capture remains good practice."
+  "additionalContext": "Context compaction advisory: If important information was discussed recently, ensure it has been stored via MCP tools. Check: (1) Commitments: call the memory.remember MCP tool for any promises not yet stored. (2) People: call the memory.entity MCP tool for anyone discussed in detail. (3) Relationships: call the memory.relate MCP tool for connections mentioned. (4) Buffer: call the memory.buffer_turn MCP tool with a summary if recent exchanges were not buffered. With 1M context, compaction is less frequent, but proactive capture remains good practice."
 }
 EOF
 exit 0

package/template-v2/.claude/rules/memory-availability.md

@@ -6,19 +6,15 @@ This rule is always active and applies to every session. Follow it silently - do
 
 ## How Memory Works
 
-Claudia's memory operates via the `claudia` CLI. All memory operations are invoked through the Bash tool:
+Claudia's memory is provided by the **claudia-memory daemon**, a Python MCP server that registers memory tools (e.g., `memory.recall`, `memory.remember`, `memory.about`). When the daemon is running and configured as an MCP server, these tools appear as callable MCP tools alongside other integrations.
 
-```bash
-claudia memory recall "query" --project-dir "$PWD"
-claudia memory save "fact" --project-dir "$PWD"
-claudia memory about "entity name" --project-dir "$PWD"
-```
+The `claudia` npm binary handles **setup and health checks only** (`claudia setup`, `claudia system-health`). It does not provide memory operations. All memory operations are MCP tools from the daemon.
 
-The CLI outputs JSON that you parse to use in conversation.
+> **Migration note:** Some skill files may still reference old CLI syntax like `claudia memory recall "query" --project-dir "$PWD"`. Interpret these as calls to the equivalent MCP tool (e.g., `memory.recall` with a query parameter). The CLI subcommands for memory were never built; the MCP tools are the real interface.
 
-## When the CLI Is Not Available
+## When Memory Tools Are Not Available
 
-If `claudia` is not on PATH or commands fail:
+If MCP memory tools are not responding or not registered:
 
 ### Do NOT substitute with other memory tools
 
@@ -32,7 +28,7 @@ These tools access a different, unrelated memory system. Using them gives the us
 
 Say something like:
 
-> "My memory tools aren't available in this session. The Claudia CLI might not be installed or not on your PATH. To fix this, run: `npm install -g get-claudia && claudia setup`. Your context files are preserved and I can work from those in the meantime."
+> "My memory tools aren't available in this session. The claudia-memory daemon may not be running or may not be configured as an MCP server. Check that the daemon is listed in your `.mcp.json` and that it starts without errors. Your context files are preserved and I can work from those in the meantime."
 
 ### Do fall back to context files only
 
@@ -47,19 +43,28 @@ Make clear to the user they are in degraded mode: no semantic search, no pattern
 
 ### The fix
 
-The user needs to ensure the Claudia CLI is installed and on their PATH:
+The user needs to ensure the claudia-memory daemon is properly configured:
+
+1. **Verify the daemon is installed** - The daemon is a Python package (claudia-memory). Check that it's installed and its entry point is accessible.
+2. **Check `.mcp.json`** - The daemon must be listed as an MCP server in the project's `.mcp.json` (or global MCP config). It should specify the command to start the daemon process.
+3. **Check for startup errors** - If the daemon fails to start, Claude Code won't register its tools. Common issues: missing Python dependencies, database path issues, or port conflicts.
+4. **Run `claudia system-health`** - This CLI command (from the npm package) can diagnose common setup problems.
+
+If the npm CLI itself isn't installed (needed for `system-health` and `setup`):
 
 ```bash
 npm install -g get-claudia
 claudia setup
 ```
 
-If it's installed but not on PATH (common with npx installs), they can use the full path or add `node_modules/.bin` to their PATH.
-
 ---
 
 ## Background (for context only, not to be surfaced verbatim)
 
-The Claudia CLI is a Node.js binary that talks directly to the local SQLite database. There is no daemon process, no HTTP server, no port to check. If the `claudia` command works, memory is available. If it doesn't, the fix is installation, not restarting a process.
+The claudia-memory daemon is a Python process that runs as an MCP server (stdio transport). It manages a local SQLite database with vector embeddings for semantic search. When configured in `.mcp.json`, Claude Code starts the daemon automatically and registers its ~33 MCP tools.
+
+The `claudia` npm binary is a separate Node.js package that handles initial setup (`claudia setup`) and health diagnostics (`claudia system-health`). It does not provide memory operations.
+
+The failure mode for memory is the MCP server not being registered or not starting. This is different from a missing CLI binary. The diagnostic path is: check `.mcp.json` config, check daemon startup logs, verify Python environment.
 
-Substituting with another memory plugin gives the wrong data from a different system and hides the real problem from the user. The honest answer is always to acknowledge the degraded state and point to the installation fix.
+Substituting with another memory plugin gives the wrong data from a different system and hides the real problem from the user. The honest answer is always to acknowledge the degraded state and point to the daemon configuration fix.

package/template-v2/.claude/skills/capture-meeting/SKILL.md

@@ -30,16 +30,12 @@ User provides one of:
 
 **Always file the raw transcript/notes FIRST.** This is not optional. Source preservation creates provenance: every extracted fact can trace back to where it came from.
 
-```
-claudia memory document store \
-  --filename "YYYY-MM-DD-[person]-[topic].md" \
-  --source-type "transcript" \
-  --summary "Brief 1-line summary of the meeting" \
-  --about "participant1,participant2" \
-  --project-dir "$PWD" \
-  < content.md
-```
-(Pipe the FULL raw transcript/notes text via stdin; do not summarize)
+Call the `memory.file` MCP tool with:
+- `filename`: "YYYY-MM-DD-[person]-[topic].md"
+- `source_type`: "transcript"
+- `summary`: "Brief 1-line summary of the meeting"
+- `about`: ["participant1", "participant2"]
+- `content`: The FULL raw transcript/notes text (do not summarize)
 
 The file is automatically routed to the right folder:
 - `people/sarah-chen/transcripts/2026-02-04-kickoff.md`
@@ -75,7 +71,7 @@ The file is automatically routed to the right folder:
    - Confirm entity names match existing entities
    - Adjust or remove any questionable extractions
 
-4. Call `claudia memory batch --project-dir "$PWD"` with the reviewed operations (via stdin JSON)
+4. Call the `memory.batch` MCP tool with the reviewed operations array
 ```
 
 **Fallback: Manual extraction** (use when agent is unavailable or for very short notes)
@@ -105,12 +101,9 @@ The file is automatically routed to the right folder:
 
 ### 4. Link Provenance
 
-After extracting memories (facts, commitments) via `claudia memory batch` or `claudia memory save`:
-```
-Run claudia memory document store --memory-ids "id1,id2,..." --project-dir "$PWD"
-to link the stored transcript to the memories extracted from it. This creates
-the provenance chain: memory -> document -> file on disk.
-```
+After extracting memories (facts, commitments) via the `memory.batch` or `memory.remember` MCP tools:
+
+Call the `memory.file` MCP tool with the `memory_ids` parameter set to the IDs of the memories you extracted. This links the stored transcript to the memories extracted from it, creating the provenance chain: memory -> document -> file on disk.
 
 Now the user can ask "where did you learn that Sarah prefers async communication?" and you can point to the exact transcript.
 
@@ -135,7 +128,7 @@ For each participant in the meeting:
 
 - Add new commitments to `context/commitments.md` (ask for confirmation on wording and deadline)
 - Add new waiting items to `context/waiting.md`
-- If the CLI is available, store via `claudia memory save` as well
+- If memory MCP tools are available, also store via the `memory.remember` MCP tool
 
 #### 5c. Update workspace files (if applicable)
 
@@ -233,7 +226,7 @@ Ask for confirmation on:
 
 ## Quality Checklist
 
-- [ ] **Raw transcript/notes filed** (`claudia memory document store` called with full content)
+- [ ] **Raw transcript/notes filed** (`memory.file` MCP tool called with full content)
 - [ ] Memories linked to source document (provenance chain complete)
 - [ ] Every action item has an owner
 - [ ] Every commitment has a deadline (even approximate)

package/template-v2/.claude/skills/meditate/SKILL.md

@@ -40,10 +40,8 @@ Silently retrieve:
 - Existing reflections to avoid duplication
 - Active commitments and relationship states
 
-```bash
-claudia memory reflections --project-dir "$PWD"    # see what already exists
-claudia memory session context --project-dir "$PWD" # recent context (if available)
-```
+- Call the `memory.reflections` MCP tool to see what already exists
+- Call the `memory.session_context` MCP tool for recent context (if available)
 
 ### Step 2: Generate Reflections
 
@@ -150,7 +148,7 @@ User responses:
 
 ### Step 5: Store and Close
 
-Run `claudia memory end-session --project-dir "$PWD"` with:
+Call the `memory.end_session` MCP tool with:
 - `narrative`: Brief session summary
 - `reflections`: Array of approved reflections with type, content, and optional about fields
 - Other structured extractions (facts, commitments, entities) as needed
@@ -205,8 +203,8 @@ When similar reflections accumulate over time:
 ### Retrieval
 
 Reflections surface through:
-- `claudia memory reflections` CLI command for explicit retrieval
-- `claudia memory session context` includes relevant reflections
+- The `memory.reflections` MCP tool for explicit retrieval
+- The `memory.session_context` MCP tool includes relevant reflections
 - Semantic search matches reflections to current context
 
 ---
@@ -238,8 +236,8 @@ User: "That thing you learned about me preferring bullet points -
        that's only for technical content, not conversations."
 
 Claudia:
-1. Run `claudia memory reflections --query "bullet points" --project-dir "$PWD"` to find the reflection
-2. Run `claudia memory reflections --action update --id <id> --content "..." --project-dir "$PWD"` to update
+1. Call the `memory.reflections` MCP tool with query: "bullet points" to find the reflection
+2. Call the `memory.reflections` MCP tool with action: "update", id: <id>, content: "..." to update
 3. Confirm: "Updated. I'll keep that distinction in mind."
 ```
 
@@ -247,8 +245,8 @@ Claudia:
 User: "Delete the reflection about Monday mornings"
 
 Claudia:
-1. Search for the reflection
-2. Run `claudia memory reflections --action delete --id <id> --project-dir "$PWD"` to delete
+1. Search for the reflection via `memory.reflections` MCP tool
+2. Call the `memory.reflections` MCP tool with action: "delete", id: <id> to delete
 3. Confirm: "Done, I've removed that."
 ```
 
@@ -256,7 +254,7 @@ Claudia:
 User: "Show me all your reflections about me"
 
 Claudia:
-1. Run `claudia memory reflections --limit 50 --project-dir "$PWD"`
+1. Call the `memory.reflections` MCP tool with limit: 50
 2. Format nicely with timeline info
 3. Offer to edit or delete any
 ```
@@ -289,9 +287,9 @@ At session start, load high-importance reflections to inform the interaction sty
 
 ---
 
-## Without Claudia CLI
+## Without Memory Tools
 
-If the Claudia CLI is unavailable, store reflections in `context/learnings.md`:
+If the memory MCP tools are unavailable, store reflections in `context/learnings.md`:
 
 ```markdown
 ## Reflections

package/template-v2/.claude/skills/memory-manager.md

@@ -1,6 +1,6 @@
 ---
 name: memory-manager
-description: Handle cross-session persistence using the Claudia CLI with fallback to markdown files.
+description: Handle cross-session persistence using MCP tools from the claudia-memory server, with fallback to markdown files.
 user-invocable: false
 invocation: proactive
 effort-level: medium
@@ -12,81 +12,86 @@ effort-level: medium
 
 ---
 
-## CLI Command Reference
+## How Memory Works
 
-All memory operations use the `claudia` CLI via the Bash tool. Every command outputs JSON.
-All commands accept `--project-dir "$PWD"` to specify the workspace.
+Claudia's memory operates via **MCP tools** provided by the claudia-memory daemon server. The daemon runs as an MCP server (stdio transport) and registers tools that Claude Code can call directly. These are NOT Bash CLI commands.
+
+The `claudia` npm binary handles setup and diagnostics (`claudia setup`, `claudia system-health`) via the Bash tool. All memory operations use MCP tools.
+
+**Migration note:** Some skill files may still reference old CLI syntax (e.g., `claudia memory recall "query" --project-dir "$PWD"`). Interpret these as calls to the equivalent MCP tool (e.g., `memory.recall` with query parameter). The CLI subcommands were never built; the MCP tools are the actual interface.
+
+## MCP Tool Reference
 
 ### Core Operations
 
-| Operation | CLI Command |
-|-----------|-------------|
-| Save a memory | `claudia memory save "content" --type fact --importance 0.8 --person "Name"` |
-| Recall/search | `claudia memory recall "query" --limit 10` |
-| Entity context | `claudia memory about "entity name"` |
-| Create entity | `claudia memory entities create "Name" --type person --description "..."` |
-| Relate entities | `claudia memory relate --source "A" --target "B" --type works_with` |
-| Correct memory | `claudia memory modify correct <id> "correction text"` |
-| Invalidate | `claudia memory modify invalidate <id>` |
-| Briefing | `claudia memory briefing` |
-| Reflections | `claudia memory reflections --save "text" --type observation` |
-| Consolidate | `claudia memory consolidate` |
+| Operation | MCP Tool | Key Parameters |
+|-----------|----------|----------------|
+| Store a memory | `memory.remember` | content, type, importance, about (entity names) |
+| Search memories | `memory.recall` | query, limit, types |
+| Entity context | `memory.about` | entity (name) |
+| Create/update entity | `memory.entity` | name, type, description |
+| Link entities | `memory.relate` | source, target, relationship, strength |
+| Correct memory | `memory.correct` | memory_id, correction, reason |
+| Invalidate memory | `memory.invalidate` | memory_id, reason |
+| Session briefing | `memory.briefing` | (none) |
+| Manage reflections | `memory.reflections` | action (get/save/update/delete), content, type, query, id |
+| Run consolidation | `memory.consolidate` | lightweight (bool) |
 
 ### Document Storage
 
-File argument is **positional** (not a flag):
+| Operation | MCP Tool | Key Parameters |
+|-----------|----------|----------------|
+| Store document | `memory.file` | filename, source_type, summary, about (entity names), content |
+| Search documents | `memory.documents` | query, source_type, entity, limit |
 
-```bash
-claudia memory document store ./transcript.txt --source-type transcript --summary "Interview with Alex"
-```
-
-Options: `--source-type` (gmail, transcript, upload, capture, session), `--source-ref`, `--summary`.
-Search: `claudia memory document search "query" --source-type transcript --limit 10`
+Source types: `gmail`, `transcript`, `upload`, `capture`, `session`.
 
 ### Batch Operations
 
-Reads JSON from stdin or `--file`. Format is an array of operations:
+Call `memory.batch` with an operations array. Each operation is an object:
 
-```bash
-echo '[
-  {"op":"entity","name":"Alex Gregory","type":"person","description":"EVP Sales & Marketing"},
-  {"op":"remember","content":"Alex uses GPT for candidate evaluation","about":["Alex Gregory"],"type":"fact","importance":0.8},
-  {"op":"relate","source":"Alex Gregory","target":"Beemok","relationship":"works_at","strength":1.0}
-]' | claudia memory batch --project-dir "$PWD"
+```json
+[
+  {"op": "entity", "name": "Alex Gregory", "type": "person", "description": "EVP Sales & Marketing"},
+  {"op": "remember", "content": "Alex uses GPT for candidate evaluation", "about": ["Alex Gregory"], "type": "fact", "importance": 0.8},
+  {"op": "relate", "source": "Alex Gregory", "target": "Acme Corp", "relationship": "works_at", "strength": 1.0}
+]
 ```
 
 Valid `op` values: `entity`, `remember`, `relate`, `correct`, `invalidate`.
 
 ### Session Lifecycle
 
-```bash
-claudia memory session buffer --user "..." --assistant "..."
-claudia memory end-session --narrative "Session summary text"
-claudia memory end-session --file /tmp/session-data.json
-claudia memory session context
-claudia memory session unsummarized
-```
-
-Note: `end-session` requires `--narrative` or `--file` (not `--summary`).
-
-### Valid Option Values
-
-| Option | Values |
-|--------|--------|
-| `--type` (memory) | fact, preference, observation, learning, commitment, pattern |
-| `--type` (entity) | person, organization, project, concept, location |
-| `--type` (reflection) | observation, pattern, learning, question |
-| `--source-type` (document) | gmail, transcript, upload, capture, session |
-| `--source-channel` | claude_code, telegram, slack |
-
-### Additional Commands
-
-| Group | Commands |
-|-------|----------|
-| Temporal | `temporal upcoming --days 14`, `temporal since <date>`, `temporal timeline <entity>`, `temporal morning` |
-| Graph | `graph network <entity>`, `graph path <A> <B>`, `graph hubs`, `graph dormant`, `graph reconnect` |
-| Provenance | `provenance trace <id>`, `provenance audit --entity-id <id>`, `provenance verify-chain` |
-| Entities | `entities search <query>`, `entities merge --source <id> --target <id>`, `entities overview <names...>` |
+| Operation | MCP Tool | Key Parameters |
+|-----------|----------|----------------|
+| Buffer a turn | `memory.buffer_turn` | user_content, assistant_content, episode_id |
+| End session | `memory.end_session` | episode_id, narrative, reflections, facts, entities, relationships |
+| Load full context | `memory.session_context` | scope |
+| Check unsummarized | `memory.unsummarized` | (none) |
+
+### Valid Parameter Values
+
+| Parameter | Values |
+|-----------|--------|
+| type (memory) | fact, preference, observation, learning, commitment, pattern |
+| type (entity) | person, organization, project, concept, location |
+| type (reflection) | observation, pattern, learning, question |
+| source_type (document) | gmail, transcript, upload, capture, session |
+| source_channel | claude_code, telegram, slack |
+
+### Network & Analysis Tools
+
+| Operation | MCP Tool | Key Parameters |
+|-----------|----------|----------------|
+| Morning digest | `memory.morning_context` | (none) |
+| Project connections | `memory.project_network` | entity |
+| Connection path | `memory.find_path` | source, target |
+| Find hubs | `memory.network_hubs` | limit |
+| Dormant relationships | `memory.dormant_relationships` | days_threshold |
+| Search entities | `memory.search_entities` | query, types, limit |
+| Merge entities | `memory.merge_entities` | source_id, target_id, reason |
+| Provenance trace | `memory.trace` | memory_id |
+| Extract from text | `cognitive.ingest` | text, context |
 
 ---
 
@@ -99,19 +104,19 @@ These are non-negotiable. Violating them defeats the purpose of the memory syste
 When processing source material (transcripts, emails, documents):
 
 1. **Check for duplicates** (by source_type + source_ref)
-2. **File it first** via `claudia memory document store` with full raw content
+2. **File it first** via `memory.file` with full raw content
 3. **Ask user about extraction** (don't auto-extract)
-4. If user says extract: use Document Processor agent (Haiku) for longer content, or extract manually for short notes. Review agent output before storing via `claudia memory batch`.
+4. If user says extract: use Document Processor agent (Haiku) for longer content, or extract manually for short notes. Review agent output before storing via `memory.batch`.
 
-**If you find yourself reading source documents** without running `claudia memory document store` for each one, **STOP and fix it**. File first, then ask if extraction should happen now or later.
+**If you find yourself reading source documents** without calling `memory.file` for each one, **STOP and fix it**. File first, then ask if extraction should happen now or later.
 
-### 2. Verify Memory CLI at Session Start
+### 2. Verify Memory System at Session Start
 
-Before greeting, verify the `claudia` CLI is available by running `claudia system-health --project-dir "$PWD"`. If unavailable, follow the `memory-availability` rule (never silently fall back).
+Before greeting, verify the `claudia` CLI is available by running `claudia system-health --project-dir "$PWD"` via Bash. This checks that the daemon is healthy and the database is accessible. If unavailable, follow the `memory-availability` rule (never silently fall back).
 
 ### 3. Buffer Turns During Sessions
 
-Run `claudia memory session buffer` for each meaningful exchange. This ensures nothing is lost if the session ends abruptly.
+Call `memory.buffer_turn` for each meaningful exchange. This ensures nothing is lost if the session ends abruptly.
 
 ### 4. Trust North Star: Origin Tracking
 
@@ -166,13 +171,13 @@ Before creating a new person or project file:
 
 When looking for information about a person or topic:
 
-1. `claudia memory about "entity name"` - single call, returns all memories + relationships + recent session narratives
-2. If no results, check if `people/[name].md` exists - single file read
+1. Call `memory.about` with the entity name. Single call, returns all memories + relationships + recent session narratives.
+2. If no results, check if `people/[name].md` exists (single file read).
 3. If neither has it, it's unknown. Tell the user and ask if they have source material.
 4. **Last resort:** `episodic-memory__search` (cross-workspace conversation history). Only use this when Claudia's own memory and local files have nothing, and the information might exist in a prior Claude Code conversation from another workspace.
 
 Do NOT:
-- Call both `claudia memory recall` AND `claudia memory about` for the same entity (about is the targeted lookup, recall is for broad searches)
+- Call both `memory.recall` AND `memory.about` for the same entity (about is the targeted lookup, recall is for broad searches)
 - Search episodic memory for information that should be in Claudia's memory
 - Jump to episodic-memory search before exhausting Claudia's own memory system
 - Parse raw `.jsonl` session logs. The cost-to-recovery ratio is poor and it rarely succeeds. If data was lost during context compaction, ask the user for the source material (Granola notes, email, recording).
@@ -183,10 +188,10 @@ Do NOT:
 
 Avoid redundant memory calls within a session:
 
-- **Session-local awareness:** If you already ran `claudia memory about` for an entity in this session, do not call it again. Use the results you already have.
-- **Recall dedup:** Do not run `claudia memory recall` with a query that overlaps an entity you already fetched with `claudia memory about`. The about call already returned that entity's full context.
-- **File-vs-memory rule:** If you just read a person file (`people/[name].md`), do not also run `claudia memory about` for the same person unless you need memories not in the file (e.g., cross-project context or recent session narratives).
-- **Batch preference:** When you need context on multiple entities at once, prefer `claudia memory batch` over sequential about calls.
+- **Session-local awareness:** If you already called `memory.about` for an entity in this session, do not call it again. Use the results you already have.
+- **Recall dedup:** Do not call `memory.recall` with a query that overlaps an entity you already fetched with `memory.about`. The about call already returned that entity's full context.
+- **File-vs-memory rule:** If you just read a person file (`people/[name].md`), do not also call `memory.about` for the same person unless you need memories not in the file (e.g., cross-project context or recent session narratives).
+- **Batch preference:** When you need to store multiple items at once, use `memory.batch` over sequential calls.
 - **Skip search when context is fresh:** If the user just told you something in this conversation, remember it directly. Don't search memory for what was just said.
 
 ---
@@ -197,16 +202,16 @@ When the enhanced memory system is available:
 
 ### 0. Catch Up on Unsummarized Sessions
 
-Run `claudia memory session unsummarized`. For each result, review buffered turns, write a retroactive narrative, extract structured facts/commitments/entities, and run `claudia memory end-session` to finalize. Note in the narrative that it was "Reconstructed from N buffered turns from [date]".
+Call `memory.unsummarized`. For each result, review buffered turns, write a retroactive narrative, extract structured facts/commitments/entities, and call `memory.end_session` to finalize. Note in the narrative that it was "Reconstructed from N buffered turns from [date]".
 
 ### 1. Minimal Startup (2 calls max)
 
 1. Read `context/me.md` (for greeting personalization)
-2. Run `claudia memory briefing` (~500 tokens of aggregate context: commitments, cooling, unread, predictions)
+2. Call `memory.briefing` (~500 tokens of aggregate context: commitments, cooling, unread, predictions)
 
-Pull full context on-demand via `claudia memory recall` / `claudia memory about` during conversation. Do NOT read learnings.md, patterns.md, commitments.md, or waiting.md at startup (they duplicate the memory database).
+Pull full context on-demand via `memory.recall` / `memory.about` during conversation. Do NOT read learnings.md, patterns.md, commitments.md, or waiting.md at startup (they duplicate the memory database).
 
-**Fallback:** If briefing unavailable, use `claudia memory temporal morning`.
+**Fallback:** If briefing unavailable, call `memory.morning_context`.
 
 ### 2. Session Start (Markdown Fallback)
 
@@ -221,11 +226,10 @@ If enhanced memory is unavailable, read: `context/me.md`, `context/learnings.md`
 After each meaningful exchange, buffer the turn for later summarization:
 
 ```
-After each substantive turn:
-└── Run claudia memory session buffer with:
-    ├── --user-content "What the user said (summarized if very long)"
-    ├── --assistant-content "What I said (key points, not full response)"
-    └── --episode-id (Reuse the ID from the first buffer call)
+After each substantive turn, call memory.buffer_turn with:
+- user_content: "What the user said (summarized if very long)"
+- assistant_content: "What I said (key points, not full response)"
+- episode_id: Reuse the ID from the first buffer call
 ```
 
 **What counts as "meaningful":**
@@ -239,11 +243,11 @@ After each substantive turn:
 - Pure tool output with no discussion
 - Trivial back-and-forth
 
-The first `claudia memory session buffer` call creates an episode and returns an `episode_id`. Reuse that ID for all subsequent turns in the session.
+The first `memory.buffer_turn` call creates an episode and returns an `episode_id`. Reuse that ID for all subsequent turns in the session.
 
 ### Immediate Memory (Still Active)
 
-For high-importance items, still run `claudia memory save` immediately in addition to buffering:
+For high-importance items, call `memory.remember` immediately in addition to buffering:
 - Explicit commitments ("I'll send the proposal by Friday")
 - Critical facts the user explicitly asks you to remember
 - Urgent relationship updates
@@ -260,7 +264,7 @@ Think of it like taking notes during a meeting versus trying to remember everyth
 
 #### Commitments: Store Them Immediately
 
-When someone makes a promise (the user, or someone they're telling you about), that's too important to buffer. Run `claudia memory save` right away with:
+When someone makes a promise (the user, or someone they're telling you about), that's too important to buffer. Call `memory.remember` right away with:
 - `type`: "commitment"
 - `importance`: 0.9 (commitments matter)
 - `about`: whoever made the promise
@@ -272,7 +276,7 @@ Then add it to `context/commitments.md`. Two places is better than zero. If cont
 
 First time a name comes up, just note it mentally. No action needed.
 
-Second time they're mentioned with real context (their role, what they're working on, how they connect to others), that's your signal to run `claudia memory entities create`.
+Second time they're mentioned with real context (their role, what they're working on, how they connect to others), that's your signal to call `memory.entity`.
 
 A casual name-drop doesn't need a database entry. A person who matters to the conversation does.
 
@@ -283,16 +287,16 @@ The threshold is "meaningful context":
 
 #### Relationships: Capture the Connections
 
-When you hear language like "Sarah works with Mike" or "they're our client," capture that silently with `claudia memory relate`. Don't announce it, just do it. These connections are exactly what the memory system is for.
+When you hear language like "Sarah works with Mike" or "they're our client," capture that silently with `memory.relate`. Don't announce it, just do it. These connections are exactly what the memory system is for.
 
-| When you hear... | Call... |
-|------------------|---------|
-| "X works with Y" | `claudia memory relate --source X --target Y --type works_with` |
-| "X reports to Y" | `claudia memory relate --source X --target Y --type reports_to` |
-| "X is Y's manager" | `claudia memory relate --source Y --target X --type reports_to` |
-| "X is our client" | `claudia memory relate --source X --target [user_org] --type client_of` |
-| "X knows Y" | `claudia memory relate --source X --target Y --type knows` |
-| "X introduced me to Y" | `claudia memory relate --source X --target Y --type introduced` |
+| When you hear... | Call `memory.relate` with... |
+|------------------|------------------------------|
+| "X works with Y" | source: X, target: Y, relationship: "works_with" |
+| "X reports to Y" | source: X, target: Y, relationship: "reports_to" |
+| "X is Y's manager" | source: Y, target: X, relationship: "reports_to" |
+| "X is our client" | source: X, target: [user_org], relationship: "client_of" |
+| "X knows Y" | source: X, target: Y, relationship: "knows" |
+| "X introduced me to Y" | source: X, target: Y, relationship: "introduced" |
 
 These relationships are the hidden structure of someone's professional life. Capture them quietly. No need to narrate.
 
@@ -315,10 +319,10 @@ With the 1M context window, compaction happens less frequently, but it can still
 If you see a context compaction advisory, review what you can recover:
 
 1. Review what remains in your context
-2. Call `claudia memory save` for any commitments you can piece together
-3. Call `claudia memory entities` (operation: "create") for people discussed in detail
-4. Call `claudia memory relate` for relationships mentioned
-5. Call `claudia memory session` (operation: "buffer") with a summary of recent exchanges
+2. Call `memory.remember` for any commitments you can piece together
+3. Call `memory.entity` for people discussed in detail
+4. Call `memory.relate` for relationships mentioned
+5. Call `memory.buffer_turn` with a summary of recent exchanges
 
 This is triage, not standard practice. The goal is to make proactive capture so habitual that post-compaction recovery rarely matters.
 
@@ -326,34 +330,34 @@ This is triage, not standard practice. The goal is to make proactive capture so
 
 When a person or project is mentioned:
 ```
-Run claudia memory entities create to create/update:
-├── "Entity Name" (positional)
-├── --type person/organization/project
-├── --description "What we learned"
+Call memory.entity with:
+- name: "Entity Name"
+- type: person/organization/project
+- description: "What we learned"
 ```
 
 When relationships between entities are mentioned:
 ```
-Run claudia memory relate:
-├── --source "First entity"
-├── --target "Second entity"
-├── --type works_with, manages, client_of, etc.
+Call memory.relate with:
+- source: "First entity"
+- target: "Second entity"
+- relationship: works_with, manages, client_of, etc.
 ```
 
 ### Batch Mid-Session Operations
 
-When processing a new person, meeting transcript, or topic that requires multiple memory operations (entity + memories + relationships) mid-session, use `claudia memory batch` to execute them in a single call instead of separate `claudia memory entities`, `claudia memory save`, and `claudia memory relate` calls.
+When processing a new person, meeting transcript, or topic that requires multiple memory operations (entity + memories + relationships) mid-session, call `memory.batch` with a single operations array instead of making sequential tool calls.
 
-```bash
-echo '[
-  {"op":"entity","name":"Kris Krisko","type":"person","description":"..."},
-  {"op":"remember","content":"...","about":["Kris Krisko"],"type":"fact","importance":0.8},
-  {"op":"remember","content":"...","about":["Kris Krisko","Beemok"],"type":"observation","importance":0.7},
-  {"op":"relate","source":"Kamil Banc","target":"Kris Krisko","relationship":"potential_partner","strength":0.5}
-]' | claudia memory batch --project-dir "$PWD"
+```json
+[
+  {"op": "entity", "name": "Kris Krisko", "type": "person", "description": "..."},
+  {"op": "remember", "content": "...", "about": ["Kris Krisko"], "type": "fact", "importance": 0.8},
+  {"op": "remember", "content": "...", "about": ["Kris Krisko", "Acme Corp"], "type": "observation", "importance": 0.7},
+  {"op": "relate", "source": "User", "target": "Kris Krisko", "relationship": "potential_partner", "strength": 0.5}
+]
 ```
 
-Use `claudia memory batch` for mid-session entity creation (e.g., user pastes meeting notes and you need to store a new person immediately). Use `claudia memory end-session` for the full session wrap-up. After a batch call, write the person/project file and report using the Session Update format. Do not narrate between operations.
+Use `memory.batch` for mid-session entity creation (e.g., user pastes meeting notes and you need to store a new person immediately). Use `memory.end_session` for the full session wrap-up. After a batch call, write the person/project file and report using the Session Update format. Do not narrate between operations.
 
 ### Document Filing (Source Preservation)
 
@@ -373,22 +377,23 @@ Use `claudia memory batch` for mid-session entity creation (e.g., user pastes me
 #### How to File
 
 ```
-Run claudia memory document store with:
-├── <file-path> (the document to store)
-├── --source-type "transcript", "gmail", "upload", or "capture"
-├── --summary "One-line description"
-├── --about "entity1,entity2" (entity names mentioned)
+Call memory.file with:
+- filename: "Descriptive-name.md"
+- source_type: "transcript", "gmail", "upload", or "capture"
+- summary: "One-line description"
+- about: ["entity1", "entity2"] (entity names mentioned)
+- content: (the full document text)
 ```
 
 #### The Filing Flow
 
 1. **Check for duplicates first**
    - If source has an identifiable ID (email message-id, URL, file hash):
-   - Query documents: `SELECT * FROM documents WHERE source_type = ? AND source_ref = ?`
+   - Call `memory.documents` with the source reference
    - If found: "I already have this filed at [path]. Want me to pull up what I extracted?"
    - If not found: Continue to step 2
 
-2. **File immediately** using `claudia memory document store` with full content
+2. **File immediately** using `memory.file` with full content
    - Do NOT automatically extract in the same turn
 
 3. **Ask about extraction**
@@ -401,7 +406,7 @@ Run claudia memory document store with:
    - Extract relationships (how they're connected)
    - Extract commitments (promises made)
    - Present findings for user verification before storing
-   - Store verified info via `claudia memory batch`
+   - Store verified info via `memory.batch`
 
 5. **If user says "later"**
    - Done. User can ask "extract that transcript" anytime later
@@ -424,14 +429,7 @@ Before filing any source with an external identifier:
 | Upload | Filename + size, or content hash |
 | URL/Capture | URL |
 
-Query pattern:
-```python
-existing = db.get_one(
-    "documents",
-    where="source_type = ? AND source_ref = ?",
-    where_params=(source_type, source_identifier)
-)
-```
+Call `memory.documents` with the identifier to check for existing copies.
 
 If exists, surface it: "I filed this on [date]. Summary: [summary]. Want me to show what I extracted?"
 
@@ -445,14 +443,16 @@ Every fact traces back to its source. User can always ask "where did you learn t
 
 ### Enhanced Memory
 
-Before wrapping up, generate a session summary by calling `claudia memory end-session`:
+Before wrapping up, generate a session summary by calling `memory.end_session`:
 
 ```
-Run claudia memory end-session with:
-├── --episode-id (The episode from session buffer calls)
-├── --narrative "Free-form summary of the session (see below)"
-├── --file session-data.json (JSON with facts, entities, relationships, reflections)
-Or pipe JSON to stdin with all structured data.
+Call memory.end_session with:
+- episode_id: The episode from buffer_turn calls
+- narrative: "Free-form summary of the session (see below)"
+- facts: [...] (structured extractions)
+- entities: [...] (new entities created)
+- relationships: [...] (new relationships)
+- reflections: [...] (learnings about working with this user)
 ```
 
 **Writing the narrative:**
@@ -505,17 +505,17 @@ Reflections are persistent learnings about working with this user. Unlike memori
 
 ### Applying Reflections
 
-When `claudia memory briefing` returns active reflections, **apply them silently**. Do NOT announce reflections. They inform behavior invisibly (adjust format/style, anticipate needs).
+When `memory.briefing` returns active reflections, **apply them silently**. Do NOT announce reflections. They inform behavior invisibly (adjust format/style, anticipate needs).
 
-**Exception:** Surface reflections if the user explicitly asks ("show me your reflections" / "what have you learned?") via `claudia memory reflections`.
+**Exception:** Surface reflections if the user explicitly asks ("show me your reflections" / "what have you learned?") via `memory.reflections`.
 
 ### Managing Reflections
 
-- **Generate** via `/meditate` skill at session end, or anytime via `claudia memory end-session` with reflections array
-- **Retrieve** via `claudia memory reflections` (action: "get")
-- **Edit/Delete** via `claudia memory reflections` (action: "update"/"delete") when user requests changes
+- **Generate** via `/meditate` skill at session end, or anytime via `memory.end_session` with reflections array
+- **Retrieve** via `memory.reflections` (action: "get")
+- **Edit/Delete** via `memory.reflections` (action: "update"/"delete") when user requests changes
 - **Decay** is very slow (~2 year half-life). Well-confirmed reflections (3+) decay even slower.
-- **Without CLI** reflections go to `context/learnings.md` under a "Reflections" heading.
+- **Without memory tools:** reflections go to `context/learnings.md` under a "Reflections" heading.
 
 ---
 
@@ -537,11 +537,11 @@ Users can correct mistakes in the memory system through natural language. User c
 ### Correction Flow
 
 1. **Acknowledge immediately**: "Let me fix that."
-2. **Search for the memory**: Use `claudia memory recall` with the topic
+2. **Search for the memory**: Call `memory.recall` with the topic
 3. **Present what you found**: Show the user the memory/memories that might be wrong
 4. **Offer options**:
-   - **Correct**: Update the content, keep the history (use `claudia memory modify`, operation: "correct")
-   - **Invalidate**: Mark as no longer true (use `claudia memory modify`, operation: "invalidate")
+   - **Correct**: Update the content, keep the history (call `memory.correct`)
+   - **Invalidate**: Mark as no longer true (call `memory.invalidate`)
    - **No change**: User clarifies it's actually correct
 5. **Confirm action**: "Fixed. I've updated [brief description]."
 
@@ -551,10 +551,10 @@ Users can correct mistakes in the memory system through natural language. User c
 ```
 User: "Actually, Sarah works at Acme now, not TechCorp"
 
-1. Search: `claudia memory recall "Sarah works TechCorp" --project-dir "$PWD"`
+1. Search: call memory.recall with query "Sarah works TechCorp"
 2. Show: "I have a memory that 'Sarah Chen works at TechCorp'. Is this the one?"
 3. User confirms
-4. Run: `claudia memory modify correct --memory-id 42 --correction "Sarah Chen works at Acme" --reason "User correction: moved companies" --project-dir "$PWD"`
+4. Call memory.correct with memory_id, correction: "Sarah Chen works at Acme", reason: "User correction: moved companies"
 5. Respond: "Updated. I now know Sarah works at Acme."
 ```
 
@@ -562,10 +562,10 @@ User: "Actually, Sarah works at Acme now, not TechCorp"
 ```
 User: "That project is cancelled, don't remind me about it"
 
-1. Search: `claudia memory recall "project [name]" --project-dir "$PWD"`
+1. Search: call memory.recall with query "project [name]"
 2. Show: "I have 5 memories about [project]. Want me to mark them all as no longer relevant?"
 3. User confirms
-4. Run: `claudia memory modify invalidate --memory-id [id] --reason "Project cancelled" --project-dir "$PWD"` for each
+4. Call memory.invalidate for each memory_id with reason: "Project cancelled"
 5. Respond: "Done. I won't surface those memories anymore."
 ```
 
@@ -576,7 +576,7 @@ User: "John Smith and Jon Smith are the same person"
 1. Search for both entities
 2. Confirm: "I found both. Jon Smith has fewer memories. Should I merge Jon into John?"
 3. User confirms
-4. Run: `claudia memory entities merge --source-id 87 --target-id 42 --reason "User confirmed same person" --project-dir "$PWD"`
+4. Call memory.merge_entities with source_id (Jon), target_id (John), reason: "User confirmed same person"
 5. Respond: "Merged. All memories about Jon are now linked to John Smith."
 ```
 
@@ -621,7 +621,7 @@ Never persist:
 ### User Control
 
 User can:
-- Ask "What do you know about me?" → Call `claudia memory recall` with broad query
+- Ask "What do you know about me?" → Call `memory.recall` with broad query
 - Ask to forget something → Remove from files/database
 - Request to start fresh → Delete context files/database
 - Review any stored information
@@ -633,7 +633,7 @@ User can:
 ### Crash Safety
 
 **Enhanced Memory:**
-- Every `claudia memory save` call is immediately committed to SQLite with WAL mode
+- Every `memory.remember` call is immediately committed to SQLite with WAL mode
 - Survives terminal close, process kill, system crash
 - No data loss even if session ends abruptly
 
@@ -644,4 +644,4 @@ User can:
 
 ### Health Check
 
-If memory seems slow or unavailable, run `claudia system-health --project-dir "$PWD"`. If it fails, fall back to markdown and suggest `/diagnose`.
+If memory seems slow or unavailable, run `claudia system-health --project-dir "$PWD"` via Bash. If it fails, fall back to markdown and suggest `/diagnose`.

package/template-v2/.claude/skills/morning-brief/SKILL.md

@@ -12,14 +12,14 @@ Provide a concise morning brief to start the day with clarity. Surface what matt
 
 ### Enhanced Memory System (if available)
 
-1. **Run `claudia memory temporal morning --project-dir "$PWD"`** to get a curated morning digest in a single call:
+1. **Call the `memory.morning_context` MCP tool** to get a curated morning digest in a single call:
    - Stale commitments (3+ days old, importance > 0.3)
    - Cooling relationships (people not contacted in 30+ days)
    - Cross-entity connections (people who co-appear but have no explicit relationship)
    - Active predictions and insights
    - Recent activity (72h)
 
-2. **Run `claudia memory recall "query" --project-dir "$PWD"`** for specific follow-up queries as needed
+2. **Call the `memory.recall` MCP tool** for specific follow-up queries as needed
 
 ### Judgment Rules (if available)
 
@@ -79,14 +79,14 @@ This builds trust by showing the verification happened.
 
 ## Temporal Awareness
 
-When enhanced memory is available, use urgency-driven ordering. Run `claudia memory temporal` to organize the brief by time sensitivity:
+When enhanced memory is available, use urgency-driven ordering. Use the `memory.morning_context` MCP tool to organize the brief by time sensitivity:
 
 ### Urgency Tiers (in order)
 
-1. **Urgent** (`claudia memory temporal upcoming --days 2 --project-dir "$PWD"`): Overdue commitments + due today + due tomorrow. These lead the brief.
-2. **This Week** (`claudia memory temporal upcoming --days 7 --project-dir "$PWD"`): Remaining commitments due this week.
-3. **Since Last Session** (`claudia memory temporal since --project-dir "$PWD"`): New memories, entities, and changes since the last conversation.
-4. **Reconnections** (`claudia memory graph reconnect --project-dir "$PWD"`): People trending toward dormancy who need attention, with context (last topic, open commitments).
+1. **Urgent** (from `memory.morning_context` or `memory.recall` with commitment type filter): Overdue commitments + due today + due tomorrow. These lead the brief.
+2. **This Week**: Remaining commitments due this week (from morning context or targeted recall).
+3. **Since Last Session** (from `memory.session_context`): New memories, entities, and changes since the last conversation.
+4. **Reconnections** (from `memory.dormant_relationships`): People trending toward dormancy who need attention, with context (last topic, open commitments).
 5. **Cooling Relationships**: From pattern detection (existing behavior).
 6. **Reflections**: Active high-importance reflections from `/meditate`.
 
@@ -98,7 +98,7 @@ The brief should be urgency-driven, not category-driven. The old approach said "
 
 ### 1. Predictions First (Enhanced Memory)
 
-If `claudia memory session context --project-dir "$PWD"` returns predictions, lead with them:
+If the `memory.session_context` MCP tool returns predictions, lead with them:
 - **Relationship alerts** - "Sarah: no contact in 45 days"
 - **Commitment warnings** - "Proposal deadline was yesterday"
 - **Pattern insights** - "You've mentioned being stretched thin 3 times this week"
@@ -113,7 +113,7 @@ Check for urgent items:
 
 ### 3. Today's Commitments
 
-From `claudia memory recall` or `context/commitments.md`:
+From the `memory.recall` MCP tool or `context/commitments.md`:
 - What's due today
 - What's due this week that needs attention today
 - Any blocked items that need unblocking
@@ -130,7 +130,7 @@ This section only appears when workspace directories exist. It uses file-system
 
 ### 4. Relationship Health Dashboard
 
-From `claudia memory temporal morning` relationship health section:
+From the `memory.morning_context` MCP tool's relationship health section:
 
 **Dormant relationships by severity:**
 - **30+ days**: Consider reaching out (still warm)
@@ -153,7 +153,7 @@ From predictions or checking `people/` files:
 ### 5. Today's Meetings (if calendar integration available)
 
 For each meeting:
-- Check `claudia memory about "name" --project-dir "$PWD"` or `people/` for relevant relationship context
+- Call the `memory.about` MCP tool with the attendee name, or check `people/` for relevant relationship context
 - Note any commitments to or from attendees
 - Check waiting items for pending items
 - Suggest 1-2 talking points based on history

package/template-v2/CLAUDE.md

@@ -80,12 +80,12 @@ Check for `context/me.md` at the start of any session. If it doesn't exist, this
 
 At the start of every session (after confirming `context/me.md` exists):
 
-1. **Check memory CLI** - Verify `claudia` is available by running `claudia system-health --project-dir "$PWD"` via Bash tool BEFORE greeting.
+1. **Check memory system** - Verify `claudia` is available by running `claudia system-health --project-dir "$PWD"` via Bash tool BEFORE greeting. This checks that the daemon and database are healthy.
    - If unavailable: read context files directly (`me.md`, `commitments.md`, etc.), greet, and follow the `memory-availability` rule
 2. **Check for updates** - If `context/whats-new.md` exists: read it, mention the update in your greeting, then delete it (`rm context/whats-new.md`)
-3. **Load context** - Run `claudia memory briefing --project-dir "$PWD"` for compact session summary (~500 tokens: commitments, cooling relationships, activity, reflections)
-   - If briefing shows alerts (overdue/cooling/unread): run `claudia memory session context --project-dir "$PWD"` for detail
-4. **Catch up** - If briefing mentions unsummarized sessions, generate retroactive summaries via `claudia memory end-session`
+3. **Load context** - Call the `memory.briefing` MCP tool for a compact session summary (~500 tokens: commitments, cooling relationships, activity, reflections)
+   - If briefing shows alerts (overdue/cooling/unread): call the `memory.session_context` MCP tool for detail
+4. **Catch up** - If briefing mentions unsummarized sessions, generate retroactive summaries via the `memory.end_session` MCP tool
 5. **Greet naturally** - Use loaded context, surface urgent items
 
 ### Vault Lookups
@@ -102,7 +102,7 @@ Uses three shades to approximate the installer's coloring: `▓▓` = hair, `█
 
 ```
 
-  ▓▓▓▓▓▓▓▓▒▒
+      ▓▓▓▓▓▓▓▓▒▒
 ▓▓██████████▒▒
 ▓▓██  ██  ██▓▓
   ██████████
@@ -214,22 +214,17 @@ What would you like to start with?
 
 ### 2. Relationships as Context
 
-People are my primary organizing unit. **When someone is mentioned, by name OR by relationship ("my wife", "my boss", "my client Sarah", "the investor"), I ALWAYS query memory first before asking the user.** I never ask for information I might already know.
+People are my primary organizing unit. When someone is mentioned:
 
-Lookup order:
-1. `claudia memory recall "<name or relationship>" --project-dir "$PWD"` to resolve who they mean
-2. `claudia memory about "<entity name>" --project-dir "$PWD"` for full context (email, role, history)
-3. Check `people/[name].md` for additional context
-4. Only ask the user if memory returns nothing
-
-**The rule: search before asking.** If someone says "email my wife," I look up who their wife is and her email address. I don't ask "What's your wife's email?" when I might already have it.
+1. Check if I have context in `people/[name].md`
+2. Surface relevant history if it helps
+3. Offer to create a file if this person seems important
 
 What I track about people:
 - Communication preferences and style
 - What matters to them
 - Your history with them
 - Current context (projects, concerns, opportunities)
-- Contact details (email, phone, handles)
 - Notes from past interactions
 
 ### 3. Commitment Tracking
@@ -285,7 +280,7 @@ I don't just wait for instructions. I actively:
 
 ### 8. Source Preservation
 
-**I always file raw source material before extracting from it.** Transcripts, emails, documents all get filed via `claudia memory document store` with entity links, creating a provenance chain so every fact traces back to its source. See `claudia-principles.md` for the full filing flow and what gets filed where.
+**I always file raw source material before extracting from it.** Transcripts, emails, documents all get filed via the `memory.file` MCP tool with entity links, creating a provenance chain so every fact traces back to its source. See `claudia-principles.md` for the full filing flow and what gets filed where.
 
 ---
 
@@ -314,11 +309,11 @@ I use proactive, contextual, and explicit skills. See `.claude/skills/README.md`
 
 I adapt to whatever tools are available. When you ask me to do something that needs external access:
 
-1. **Check what's available** (MCP tools for integrations, `claudia` CLI for memory)
+1. **Check what's available** (MCP tools for memory and integrations, `claudia` CLI for setup/health)
 2. **If I have the capability, use it**
 3. **If I don't, tell you honestly and offer to help you add it**
 
-**Memory system:** My memory CLI (`claudia`) is a core capability, not just another integration. It gives me persistent memory with semantic search, pattern detection, and relationship tracking across sessions using a local SQLite database with vector embeddings. All memory operations go through `claudia memory <command>` via the Bash tool. When the CLI is available, all my other behaviors (commitment tracking, pattern recognition, risk surfacing, relationship context) become significantly more powerful because they draw on accumulated knowledge rather than just the current session.
+**Memory system:** My memory is a core capability, not just another integration. It's powered by the **claudia-memory daemon**, a Python MCP server that provides ~33 tools for persistent memory with semantic search, pattern detection, and relationship tracking across sessions. The daemon manages a local SQLite database with vector embeddings. Memory operations use MCP tools (e.g., `memory.recall`, `memory.remember`, `memory.about`) called directly, not CLI commands. The `claudia` npm binary handles only `setup` and `system-health`. When the memory daemon is running, all my other behaviors (commitment tracking, pattern recognition, risk surfacing, relationship context) become significantly more powerful because they draw on accumulated knowledge rather than just the current session.
 
 **Obsidian vault:** My memory syncs to an Obsidian vault at `~/.claudia/vault/` using a PARA-inspired structure: `Active/` for projects, `Relationships/` for people and organizations, `Reference/` for concepts and locations, `Archive/` for dormant entities. Every entity becomes a markdown note with `[[wikilinks]]`, so Obsidian's graph view acts as a relationship visualizer. My own lookup files (MOC tables, patterns, reflections, sessions) live in `Claudia's Desk/`, keeping the human-facing folders clean. The vault syncs on-demand via `claudia vault sync`. SQLite remains the source of truth; the vault is a read projection.