memoryai-mcp 2.4.2 → 2.4.4

package/README.md

@@ -1,362 +1,362 @@
-# memoryai-mcp
-
-MCP server for [MemoryAI](https://memoryai.dev) — a living brain for your AI agent.
-
-Your AI agent gets persistent memory that works like a real brain:
-- Remembers what matters, forgets what doesn't
-- Strengthens memories you use often (Hebbian learning)
-- Consolidates knowledge while idle (Sleep cycles)
-- Protects core identity (DNA memories never fade)
-- Adapts to your emotional state
-
-**Install once. Everything auto from there.**
-
-Automation level by platform:
-- **Mechanism-level (hands-off, guaranteed):** OpenAI Proxy, Kiro (Agent Hooks), Claude Code (HTTP hooks via `memoryai-claude-setup`).
-- **Soft (rules-file, depends on the model following instructions):** Cursor, Windsurf, VS Code Copilot. MCP tools are available; add the rules file shown below.
-
-## Quick Start (2 minutes)
-
-### 1. Run setup — that's it
-
-You don't need to provision a key first. The setup command auto-provisions a
-free key for you if you don't pass one:
-
-```bash
-# Claude Code
-npx -y -p memoryai-mcp memoryai-claude-setup
-
-# Kiro
-npx -y -p memoryai-mcp memoryai-kiro-setup
-```
-
-Already have a key? Pass it to skip provisioning: `HM_API_KEY=hm_sk_... npx -y -p memoryai-mcp memoryai-claude-setup`.
-
-<details>
-<summary>Manual key provisioning (optional)</summary>
-
-```bash
-curl -X POST https://memoryai.dev/v1/admin/provision \
-  -H "Content-Type: application/json" \
-  -d '{"name": "my-agent", "tos_accepted": true}'
-```
-
-Save the `api_key` from the response.
-
-</details>
-
-### 2. Other tools (MCP config)
-
-For tools without a one-command installer, choose your platform below. Config once — memory works automatically forever.
-
----
-
-## IDE Setup
-
-### Claude Code (CLI) — one command, fully automatic
-
-```bash
-HM_API_KEY=hm_sk_your_key_here npx -y -p memoryai-mcp memoryai-claude-setup
-```
-
-This wires three HTTP hooks into `~/.claude/settings.json` plus the MCP server.
-Claude Code injects each hook's context directly into the model — **memory then
-works at the mechanism level, no agent cooperation required**:
-
-- **SessionStart** → loads DNA + recent context when a session opens
-- **UserPromptSubmit** → recalls relevant memory before each prompt
-- **Stop** → stores decisions/preferences automatically when a turn ends
-
-Re-running is safe (idempotent merge). For a project-only install set
-`MEMORYAI_SCOPE=project`. After setup, restart Claude Code and just work — you
-never call a memory tool by hand.
-
-<details>
-<summary>Manual setup (MCP only, soft automation via CLAUDE.md)</summary>
-
-If you prefer not to use hooks, add the MCP server to `~/.claude/settings.json`:
-
-```json
-{
-  "mcpServers": {
-    "memoryai": {
-      "command": "npx",
-      "args": ["-y", "memoryai-mcp"],
-      "env": {
-        "HM_ENDPOINT": "https://memoryai.dev",
-        "HM_API_KEY": "hm_sk_your_key_here"
-      }
-    }
-  }
-}
-```
-
-Then create `~/.claude/CLAUDE.md`:
-
-```markdown
-## Memory Protocol
-At the start of every conversation, call `memory_bootstrap` to load context from MemoryAI.
-Before context gets large (>100K tokens), call `memory_compact` to save important context.
-Use `memory_store` to save important decisions, preferences, and facts.
-Use `memory_recall` to search past memories when relevant.
-```
-
-Note: without hooks, memory depends on the model following CLAUDE.md (soft
-automation). The hook setup above is the guaranteed, mechanism-level path.
-
-</details>
-
-### Kiro — one command, fully automatic
-
-```bash
-HM_API_KEY=hm_sk_your_key_here npx -y -p memoryai-mcp memoryai-kiro-setup
-```
-
-Writes `.kiro/settings/mcp.json` (with autoApprove), `.kiro/steering/memoryai.md`,
-and two Agent Hooks (`promptSubmit` → recall, `agentStop` → store/compact) so
-memory is automatic at the event level.
-
-### Cursor — `~/.cursor/mcp.json`
-
-```json
-{
-  "mcpServers": {
-    "memoryai": {
-      "command": "npx",
-      "args": ["-y", "memoryai-mcp"],
-      "env": {
-        "HM_ENDPOINT": "https://memoryai.dev",
-        "HM_API_KEY": "hm_sk_your_key_here"
-      }
-    }
-  }
-}
-```
-
-Auto-bootstrap — create `.cursor/rules/memoryai.mdc`:
-
-```
-At the start of every session, call memory_bootstrap to load context.
-After completing tasks, call memory_compact to save context.
-Store important decisions and preferences with memory_store.
-```
-
-### VS Code — `.vscode/mcp.json`
-
-```json
-{
-  "servers": {
-    "memoryai": {
-      "command": "npx",
-      "args": ["-y", "memoryai-mcp"],
-      "env": {
-        "HM_ENDPOINT": "https://memoryai.dev",
-        "HM_API_KEY": "hm_sk_your_key_here"
-      }
-    }
-  }
-}
-```
-
-### Kiro — `.kiro/settings/mcp.json`
-
-```json
-{
-  "mcpServers": {
-    "memoryai": {
-      "command": "npx",
-      "args": ["-y", "memoryai-mcp"],
-      "env": {
-        "HM_ENDPOINT": "https://memoryai.dev",
-        "HM_API_KEY": "hm_sk_your_key_here"
-      }
-    }
-  }
-}
-```
-
-### Windsurf — `~/.codeium/windsurf/mcp_config.json`
-
-```json
-{
-  "mcpServers": {
-    "memoryai": {
-      "command": "npx",
-      "args": ["-y", "memoryai-mcp"],
-      "env": {
-        "HM_ENDPOINT": "https://memoryai.dev",
-        "HM_API_KEY": "hm_sk_your_key_here"
-      }
-    }
-  }
-}
-```
-
-### Claude Desktop — `claude_desktop_config.json`
-
-macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
-Windows: `%APPDATA%\Claude\claude_desktop_config.json`
-
-```json
-{
-  "mcpServers": {
-    "memoryai": {
-      "command": "npx",
-      "args": ["-y", "memoryai-mcp"],
-      "env": {
-        "HM_ENDPOINT": "https://memoryai.dev",
-        "HM_API_KEY": "hm_sk_your_key_here"
-      }
-    }
-  }
-}
-```
-
-### Antigravity — `~/.antigravity/mcp.json`
-
-```json
-{
-  "mcpServers": {
-    "memoryai": {
-      "command": "npx",
-      "args": ["-y", "memoryai-mcp"],
-      "env": {
-        "HM_ENDPOINT": "https://memoryai.dev",
-        "HM_API_KEY": "hm_sk_your_key_here"
-      }
-    }
-  }
-}
-```
-
-### Any MCP-compatible tool
-
-```json
-{
-  "mcpServers": {
-    "memoryai": {
-      "command": "npx",
-      "args": ["-y", "memoryai-mcp"],
-      "env": {
-        "HM_ENDPOINT": "https://memoryai.dev",
-        "HM_API_KEY": "hm_sk_your_key_here"
-      }
-    }
-  }
-}
-```
-
----
-
-## Auto-Bootstrap (Make It Fully Automatic)
-
-After MCP config, add a system rule so your agent auto-loads memory every session:
-
-| Platform | Rule File | Content |
-|----------|-----------|---------|
-| Claude Code | `~/.claude/CLAUDE.md` | See above |
-| Cursor | `.cursor/rules/memoryai.mdc` | See above |
-| Kiro | `.kiro/rules/memoryai.md` | Same content |
-| Windsurf | `.windsurfrules` | Same content |
-| VS Code | `.github/copilot-instructions.md` | Same content |
-
-Rule content (copy-paste for any platform):
-
-```
-## Memory Protocol
-At the start of every conversation, call `memory_bootstrap` to load context from MemoryAI.
-Before context gets large, call `memory_compact` to save important context.
-Use `memory_store` to save important decisions, preferences, and facts.
-Use `memory_recall` to search past memories when relevant.
-```
-
----
-
-## How It Works
-
-```
-Open IDE → MCP auto-connects → Agent reads rules → Calls bootstrap
-    → Loads your identity, preferences, recent work
-    → Works normally (auto-stores important stuff)
-    → Context getting full? Auto-compacts
-    → Close IDE → Sleep workers consolidate overnight
-    → Open IDE next day → Bootstrap loads everything back
-    → Cycle repeats. Memory grows smarter over time.
-```
-
-**You do nothing.** The agent handles everything automatically.
-
----
-
-## Tools Available
-
-| Tool | What It Does |
-|------|-------------|
-| `memory_bootstrap` | Wake up with full context (identity + recent + preferences) |
-| `memory_store` | Save a memory (fact, decision, preference, identity) |
-| `memory_recall` | Search memories by meaning (semantic + graph + FTS) |
-| `memory_compact` | Save conversation context before it's lost |
-| `memory_recover` | Recover session after a break |
-| `memory_health` | Check context pressure (safe/warning/critical) |
-| `memory_explore` | Explore connections between memories |
-| `memory_clusters` | View topic clusters in your knowledge graph |
-| `learn` | Store action + result + lesson learned |
-| `entity_list` | List tracked entities (files, people, packages) |
-| `reasoning_store` | Deep reasoning memory (Pro+) |
-| `reasoning_recall` | Recall reasoned insights (Pro+) |
-| `snapshot_create` | Backup memory state |
-| `snapshot_restore` | Restore from backup |
-
----
-
-## Context Guard (Built-in)
-
-Context Guard monitors your session and prevents context loss:
-
-| State | Meaning | Agent Action |
-|-------|---------|-------------|
-| SAFE | Context < 40% full | Continue normally |
-| COMPACT_SOON | Context 40-55% full | Prepare to compact |
-| COMPACT_NOW | Context > 55% full | Must compact immediately |
-
-The agent handles this automatically when rules are configured. No manual intervention needed.
-
----
-
-## What Gets Remembered (DNA System)
-
-| Memory Type | Example | Persistence |
-|-------------|---------|-------------|
-| `preference` | "I prefer Python over Java" | **Forever** (DNA-protected) |
-| `decision` | "Chose PostgreSQL for this project" | **Forever** (DNA-protected) |
-| `identity` | "Senior backend engineer, 10 years" | **Forever** (DNA-protected) |
-| `fact` | "API endpoint is /v1/users" | Decays if unused |
-| `goal` | "Launch v2.0 by June" | Decays if unused |
-
-DNA memories (preference/decision/identity) **never decay, never get deleted, never get overwritten** by any background process. They define who you are.
-
----
-
-## Pricing
-
-| Plan | Features | Price |
-|------|----------|-------|
-| Free | Basic store/recall, 100 memories | Free |
-| Pro | Full brain (reasoning, consolidation, personality) | Paid |
-| ProMax | Multi-agent mesh, advanced features | Paid |
-| God | Everything + deep graph traversal | Internal |
-
-Get started free: https://memoryai.dev
-
----
-
-## Links
-
-- Website: https://memoryai.dev
-- Python SDK: `pip install hmc-memory`
-- npm MCP: `npx memoryai-mcp`
-- GitHub: https://github.com/memoryai-dev/memoryai
-
-## License
-
-MIT
+# memoryai-mcp
+
+MCP server for [MemoryAI](https://memoryai.dev) — a living brain for your AI agent.
+
+Your AI agent gets persistent memory that works like a real brain:
+- Remembers what matters, forgets what doesn't
+- Strengthens memories you use often (Hebbian learning)
+- Consolidates knowledge while idle (Sleep cycles)
+- Protects core identity (DNA memories never fade)
+- Adapts to your emotional state
+
+**Install once. Everything auto from there.**
+
+Automation level by platform:
+- **Mechanism-level (hands-off, guaranteed):** OpenAI Proxy, Kiro (Agent Hooks), Claude Code (HTTP hooks via `memoryai-claude-setup`).
+- **Soft (rules-file, depends on the model following instructions):** Cursor, Windsurf, VS Code Copilot. MCP tools are available; add the rules file shown below.
+
+## Quick Start (2 minutes)
+
+### 1. Run setup — that's it
+
+You don't need to provision a key first. The setup command auto-provisions a
+free key for you if you don't pass one:
+
+```bash
+# Claude Code
+npx -y -p memoryai-mcp memoryai-claude-setup
+
+# Kiro
+npx -y -p memoryai-mcp memoryai-kiro-setup
+```
+
+Already have a key? Pass it to skip provisioning: `HM_API_KEY=hm_sk_... npx -y -p memoryai-mcp memoryai-claude-setup`.
+
+<details>
+<summary>Manual key provisioning (optional)</summary>
+
+```bash
+curl -X POST https://memoryai.dev/v1/admin/provision \
+  -H "Content-Type: application/json" \
+  -d '{"name": "my-agent", "tos_accepted": true}'
+```
+
+Save the `api_key` from the response.
+
+</details>
+
+### 2. Other tools (MCP config)
+
+For tools without a one-command installer, choose your platform below. Config once — memory works automatically forever.
+
+---
+
+## IDE Setup
+
+### Claude Code (CLI) — one command, fully automatic
+
+```bash
+HM_API_KEY=hm_sk_your_key_here npx -y -p memoryai-mcp memoryai-claude-setup
+```
+
+This wires three HTTP hooks into `~/.claude/settings.json` plus the MCP server.
+Claude Code injects each hook's context directly into the model — **memory then
+works at the mechanism level, no agent cooperation required**:
+
+- **SessionStart** → loads DNA + recent context when a session opens
+- **UserPromptSubmit** → recalls relevant memory before each prompt
+- **Stop** → stores decisions/preferences automatically when a turn ends
+
+Re-running is safe (idempotent merge). For a project-only install set
+`MEMORYAI_SCOPE=project`. After setup, restart Claude Code and just work — you
+never call a memory tool by hand.
+
+<details>
+<summary>Manual setup (MCP only, soft automation via CLAUDE.md)</summary>
+
+If you prefer not to use hooks, add the MCP server to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "memoryai": {
+      "command": "npx",
+      "args": ["-y", "memoryai-mcp"],
+      "env": {
+        "HM_ENDPOINT": "https://memoryai.dev",
+        "HM_API_KEY": "hm_sk_your_key_here"
+      }
+    }
+  }
+}
+```
+
+Then create `~/.claude/CLAUDE.md`:
+
+```markdown
+## Memory Protocol
+At the start of every conversation, call `memory_bootstrap` to load context from MemoryAI.
+Before context gets large (>100K tokens), call `memory_compact` to save important context.
+Use `memory_store` to save important decisions, preferences, and facts.
+Use `memory_recall` to search past memories when relevant.
+```
+
+Note: without hooks, memory depends on the model following CLAUDE.md (soft
+automation). The hook setup above is the guaranteed, mechanism-level path.
+
+</details>
+
+### Kiro — one command, fully automatic
+
+```bash
+HM_API_KEY=hm_sk_your_key_here npx -y -p memoryai-mcp memoryai-kiro-setup
+```
+
+Writes `.kiro/settings/mcp.json` (with autoApprove), `.kiro/steering/memoryai.md`,
+and two Agent Hooks (`promptSubmit` → recall, `agentStop` → store/compact) so
+memory is automatic at the event level.
+
+### Cursor — `~/.cursor/mcp.json`
+
+```json
+{
+  "mcpServers": {
+    "memoryai": {
+      "command": "npx",
+      "args": ["-y", "memoryai-mcp"],
+      "env": {
+        "HM_ENDPOINT": "https://memoryai.dev",
+        "HM_API_KEY": "hm_sk_your_key_here"
+      }
+    }
+  }
+}
+```
+
+Auto-bootstrap — create `.cursor/rules/memoryai.mdc`:
+
+```
+At the start of every session, call memory_bootstrap to load context.
+After completing tasks, call memory_compact to save context.
+Store important decisions and preferences with memory_store.
+```
+
+### VS Code — `.vscode/mcp.json`
+
+```json
+{
+  "servers": {
+    "memoryai": {
+      "command": "npx",
+      "args": ["-y", "memoryai-mcp"],
+      "env": {
+        "HM_ENDPOINT": "https://memoryai.dev",
+        "HM_API_KEY": "hm_sk_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Kiro — `.kiro/settings/mcp.json`
+
+```json
+{
+  "mcpServers": {
+    "memoryai": {
+      "command": "npx",
+      "args": ["-y", "memoryai-mcp"],
+      "env": {
+        "HM_ENDPOINT": "https://memoryai.dev",
+        "HM_API_KEY": "hm_sk_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Windsurf — `~/.codeium/windsurf/mcp_config.json`
+
+```json
+{
+  "mcpServers": {
+    "memoryai": {
+      "command": "npx",
+      "args": ["-y", "memoryai-mcp"],
+      "env": {
+        "HM_ENDPOINT": "https://memoryai.dev",
+        "HM_API_KEY": "hm_sk_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop — `claude_desktop_config.json`
+
+macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "memoryai": {
+      "command": "npx",
+      "args": ["-y", "memoryai-mcp"],
+      "env": {
+        "HM_ENDPOINT": "https://memoryai.dev",
+        "HM_API_KEY": "hm_sk_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Antigravity — `~/.antigravity/mcp.json`
+
+```json
+{
+  "mcpServers": {
+    "memoryai": {
+      "command": "npx",
+      "args": ["-y", "memoryai-mcp"],
+      "env": {
+        "HM_ENDPOINT": "https://memoryai.dev",
+        "HM_API_KEY": "hm_sk_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Any MCP-compatible tool
+
+```json
+{
+  "mcpServers": {
+    "memoryai": {
+      "command": "npx",
+      "args": ["-y", "memoryai-mcp"],
+      "env": {
+        "HM_ENDPOINT": "https://memoryai.dev",
+        "HM_API_KEY": "hm_sk_your_key_here"
+      }
+    }
+  }
+}
+```
+
+---
+
+## Auto-Bootstrap (Make It Fully Automatic)
+
+After MCP config, add a system rule so your agent auto-loads memory every session:
+
+| Platform | Rule File | Content |
+|----------|-----------|---------|
+| Claude Code | `~/.claude/CLAUDE.md` | See above |
+| Cursor | `.cursor/rules/memoryai.mdc` | See above |
+| Kiro | `.kiro/rules/memoryai.md` | Same content |
+| Windsurf | `.windsurfrules` | Same content |
+| VS Code | `.github/copilot-instructions.md` | Same content |
+
+Rule content (copy-paste for any platform):
+
+```
+## Memory Protocol
+At the start of every conversation, call `memory_bootstrap` to load context from MemoryAI.
+Before context gets large, call `memory_compact` to save important context.
+Use `memory_store` to save important decisions, preferences, and facts.
+Use `memory_recall` to search past memories when relevant.
+```
+
+---
+
+## How It Works
+
+```
+Open IDE → MCP auto-connects → Agent reads rules → Calls bootstrap
+    → Loads your identity, preferences, recent work
+    → Works normally (auto-stores important stuff)
+    → Context getting full? Auto-compacts
+    → Close IDE → Sleep workers consolidate overnight
+    → Open IDE next day → Bootstrap loads everything back
+    → Cycle repeats. Memory grows smarter over time.
+```
+
+**You do nothing.** The agent handles everything automatically.
+
+---
+
+## Tools Available
+
+| Tool | What It Does |
+|------|-------------|
+| `memory_bootstrap` | Wake up with full context (identity + recent + preferences) |
+| `memory_store` | Save a memory (fact, decision, preference, identity) |
+| `memory_recall` | Search memories by meaning (semantic + graph + FTS) |
+| `memory_compact` | Save conversation context before it's lost |
+| `memory_recover` | Recover session after a break |
+| `memory_health` | Check context pressure (safe/warning/critical) |
+| `memory_explore` | Explore connections between memories |
+| `memory_clusters` | View topic clusters in your knowledge graph |
+| `learn` | Store action + result + lesson learned |
+| `entity_list` | List tracked entities (files, people, packages) |
+| `reasoning_store` | Deep reasoning memory (Pro+) |
+| `reasoning_recall` | Recall reasoned insights (Pro+) |
+| `snapshot_create` | Backup memory state |
+| `snapshot_restore` | Restore from backup |
+
+---
+
+## Context Guard (Built-in)
+
+Context Guard monitors your session and prevents context loss:
+
+| State | Meaning | Agent Action |
+|-------|---------|-------------|
+| SAFE | Context < 40% full | Continue normally |
+| COMPACT_SOON | Context 40-55% full | Prepare to compact |
+| COMPACT_NOW | Context > 55% full | Must compact immediately |
+
+The agent handles this automatically when rules are configured. No manual intervention needed.
+
+---
+
+## What Gets Remembered (DNA System)
+
+| Memory Type | Example | Persistence |
+|-------------|---------|-------------|
+| `preference` | "I prefer Python over Java" | **Forever** (DNA-protected) |
+| `decision` | "Chose PostgreSQL for this project" | **Forever** (DNA-protected) |
+| `identity` | "Senior backend engineer, 10 years" | **Forever** (DNA-protected) |
+| `fact` | "API endpoint is /v1/users" | Decays if unused |
+| `goal` | "Launch v2.0 by June" | Decays if unused |
+
+DNA memories (preference/decision/identity) **never decay, never get deleted, never get overwritten** by any background process. They define who you are.
+
+---
+
+## Pricing
+
+| Plan | Features | Price |
+|------|----------|-------|
+| Free | Basic store/recall, 100 memories | Free |
+| Pro | Full brain (reasoning, consolidation, personality) | Paid |
+| ProMax | Multi-agent mesh, advanced features | Paid |
+| Enterprise | Everything + deep graph traversal + on-prem | Custom |
+
+Get started free: https://memoryai.dev
+
+---
+
+## Links
+
+- Website: https://memoryai.dev
+- Python SDK: `pip install hmc-memory`
+- npm MCP: `npx memoryai-mcp`
+- GitHub: https://github.com/memoryai-dev/memoryai
+
+## License
+
+MIT

package/dist/claude-setup.js

@@ -69,19 +69,19 @@ function ensureHook(settings, event, handler) {
     settings.hooks[event].push({ hooks: [handler] });
     return true;
 }
-const CLAUDE_MD = `
-# MemoryAI — Persistent Memory (automatic)
-
-MemoryAI is wired into this Claude Code via HTTP hooks, so memory works
-automatically at the mechanism level — you don't have to call tools by hand:
-
-- Relevant past context is injected before each prompt (UserPromptSubmit hook).
-- Session-start context (preferences, decisions, recent work) loads on open.
-- Decisions and preferences are stored automatically when each turn ends.
-
-The MemoryAI MCP server is also connected for advanced use. You may call
-\`memory_recall\` explicitly when you need deeper history, but for everyday work
-the hooks handle it. Never store secrets or credentials.
+const CLAUDE_MD = `
+# MemoryAI — Persistent Memory (automatic)
+
+MemoryAI is wired into this Claude Code via HTTP hooks, so memory works
+automatically at the mechanism level — you don't have to call tools by hand:
+
+- Relevant past context is injected before each prompt (UserPromptSubmit hook).
+- Session-start context (preferences, decisions, recent work) loads on open.
+- Decisions and preferences are stored automatically when each turn ends.
+
+The MemoryAI MCP server is also connected for advanced use. You may call
+\`memory_recall\` explicitly when you need deeper history, but for everyday work
+the hooks handle it. Never store secrets or credentials.
 `;
 const MCP_BLOCK = (apiKey, endpoint) => ({
     command: "npx",
@@ -199,14 +199,14 @@ async function main() {
     else {
         console.log(`  skip  ${claudeMdPath} (note already present)`);
     }
-    console.log(`
-Done. MemoryAI runs automatically in Claude Code — nothing else to do.
-  - Context is recalled before each prompt and injected for you.
-  - Decisions/preferences are stored when each turn ends.
-
-Next steps:
-  1. Restart Claude Code (loads the hooks + MCP server).
-  2. Just work normally. Memory persists across sessions on its own.
+    console.log(`
+Done. MemoryAI runs automatically in Claude Code — nothing else to do.
+  - Context is recalled before each prompt and injected for you.
+  - Decisions/preferences are stored when each turn ends.
+
+Next steps:
+  1. Restart Claude Code (loads the hooks + MCP server).
+  2. Just work normally. Memory persists across sessions on its own.
 `);
     rl.close();
 }

package/dist/index.js

@@ -11,7 +11,7 @@ import { z } from "zod";
 const API_URL = process.env.MEMORYAI_ENDPOINT || process.env.HM_ENDPOINT || "http://localhost:8420";
 const API_KEY = process.env.MEMORYAI_API_KEY || process.env.HM_API_KEY || "";
 const REQUEST_TIMEOUT_MS = 30_000; // P2 #6: 30s default timeout for API requests
-const MCP_VERSION = "2.4.1";
+const MCP_VERSION = "2.4.3";
 // Context Guard — per-IDE settings via env vars.
 // HM_COMPACT_AT and HM_CRITICAL_AT are now ABSOLUTE token counts (e.g. "100000",
 // "150000"). The legacy meaning ("30" = 30%) is detected automatically: any
@@ -24,6 +24,13 @@ const MCP_VERSION = "2.4.1";
 const CG_CONTEXT_CAP = parseInt(process.env.MEMORYAI_CONTEXT_CAP || process.env.HM_CONTEXT_CAP || "0", 10);
 const CG_COMPACT_RAW = parseInt(process.env.MEMORYAI_COMPACT_AT || process.env.HM_COMPACT_AT || "0", 10);
 const CG_CRITICAL_RAW = parseInt(process.env.MEMORYAI_CRITICAL_AT || process.env.HM_CRITICAL_AT || "0", 10);
+// Model hint for server-side window auto-detection. When set, the server
+// resolves the context window from the model name and picks the adaptive
+// trigger percentage (<=200K → 95%, >200K → 30%). Falls back to the model
+// the caller passes per-request, then to the 200K default.
+//   e.g. MEMORYAI_MODEL=claude-opus-4-6[1m]  → 1M window → 30% trigger
+//        MEMORYAI_MODEL=claude-sonnet-4-6     → 200K window → 95% trigger
+const CG_MODEL = (process.env.MEMORYAI_MODEL || process.env.HM_MODEL || "").trim() || null;
 // Heuristic: small numbers are legacy percentages; large numbers are absolute tokens.
 // Threshold "<= 100" is generous enough to catch any sensible % (max 95%) and
 // well below any sensible absolute count (min would be ~10K tokens).
@@ -152,7 +159,7 @@ function err(e) {
     return { content, isError: true };
 }
 // --- MCP Server ---
-const server = new McpServer({ name: "memoryai", version: "2.4.1" }, {
+const server = new McpServer({ name: "memoryai", version: "2.4.3" }, {
     capabilities: { tools: {} },
     instructions: "MemoryAI persistent memory. Call memory_bootstrap on session start. After decisions/preferences, call memory_store. Context compaction is automatic via piggybacking — follow any [Context Guard] directives in tool responses.",
 });
@@ -1013,12 +1020,13 @@ server.tool("context_guard_check", "[CORE] Check context pressure — returns re
     model: z.string().optional().describe("Model name for auto-detecting context window size (e.g. claude-sonnet-4-6)"),
 }, async (args) => {
     try {
-        // Use env var HM_CONTEXT_CAP as default if max_tokens not provided
+        // Use env var HM_CONTEXT_CAP as default if max_tokens not provided.
+        // 0 → server auto-detects the window from the model name.
         const maxTokens = args.max_tokens || CG_CONTEXT_CAP || 0;
         const payload = {
             estimated_tokens: args.estimated_tokens,
             max_tokens: maxTokens,
-            model: args.model || null,
+            model: args.model || CG_MODEL,
         };
         // Per-IDE threshold overrides. Absolute (CG_*_AT_TOKENS) is preferred —
         // server treats it as the authoritative trigger. Decimal % is the
@@ -1097,7 +1105,7 @@ server.tool("ide_turn_check", "[CORE] Server-authoritative context check for IDE
             max_tokens: args.max_tokens ?? CG_CONTEXT_CAP ?? 200_000,
             avg_tokens_per_turn: args.avg_tokens_per_turn ?? 8000,
             skip_below_turns: args.skip_below_turns ?? 10,
-            model: args.model ?? null,
+            model: args.model ?? CG_MODEL,
         };
         // Per-IDE threshold overrides. Absolute first (preferred), % fallback.
         if (CG_COMPACT_AT_TOKENS > 0)
@@ -1210,7 +1218,7 @@ server.tool("bot_guard_check", "Advanced: Bot context guard — checks context p
         const payload = {
             estimated_tokens: args.estimated_tokens,
             max_tokens: args.max_tokens || CG_CONTEXT_CAP || 200000,
-            model: args.model || null,
+            model: args.model || CG_MODEL,
         };
         if (args.compress_threshold)
             payload.compress_threshold = args.compress_threshold;

package/dist/kiro-setup.d.ts

@@ -4,13 +4,19 @@
  * Zero-dependency setup script that creates, in the current project:
  *   - .kiro/settings/mcp.json            (MCP server wiring)
  *   - .kiro/steering/memoryai.md         (always-on instructions, soft fallback)
- *   - .kiro/hooks/memoryai-auto-recall.kiro.hook   (promptSubmit → bootstrap/recall)
- *   - .kiro/hooks/memoryai-auto-capture.kiro.hook  (agentStop → store/compact)
+ *   - .kiro/hooks/memoryai-auto-recall.kiro.hook   (promptSubmit → recall + guard)
  *
- * The two hooks are what make memory TRULY automatic: they fire on IDE events
- * (every prompt / end of every turn) instead of relying on the agent to
- * remember the steering instructions. Result: the user installs once and never
- * has to think about memory again — recall happens before answers, persistence
- * happens after turns, compaction happens when context fills.
+ * ONE hook only (v0.2.4+). It fires on promptSubmit — BEFORE the answer — and
+ * does three things in a single pass: recall relevant memory, persist anything
+ * memorable from the previous turn, and run the context-guard release check.
+ *
+ * Why not a second agentStop hook? The old design had a separate
+ * memoryai-auto-capture.kiro.hook on agentStop. agentStop fires AFTER the
+ * reply and forces a fresh askAgent reasoning pass whose only job is to "stay
+ * silent" — which leaks a stray "." into the chat and burns ~1.5 credits per
+ * idle turn. Folding the capture/guard logic into the promptSubmit hook fixes
+ * both problems: the background work finishes before the model answers, so the
+ * reply is clean and nothing fires on an idle turn-end. The setup below also
+ * deletes any pre-0.2.4 auto-capture hook left on disk.
  */
 export {};

package/dist/kiro-setup.js

@@ -4,17 +4,23 @@
  * Zero-dependency setup script that creates, in the current project:
  *   - .kiro/settings/mcp.json            (MCP server wiring)
  *   - .kiro/steering/memoryai.md         (always-on instructions, soft fallback)
- *   - .kiro/hooks/memoryai-auto-recall.kiro.hook   (promptSubmit → bootstrap/recall)
- *   - .kiro/hooks/memoryai-auto-capture.kiro.hook  (agentStop → store/compact)
+ *   - .kiro/hooks/memoryai-auto-recall.kiro.hook   (promptSubmit → recall + guard)
  *
- * The two hooks are what make memory TRULY automatic: they fire on IDE events
- * (every prompt / end of every turn) instead of relying on the agent to
- * remember the steering instructions. Result: the user installs once and never
- * has to think about memory again — recall happens before answers, persistence
- * happens after turns, compaction happens when context fills.
+ * ONE hook only (v0.2.4+). It fires on promptSubmit — BEFORE the answer — and
+ * does three things in a single pass: recall relevant memory, persist anything
+ * memorable from the previous turn, and run the context-guard release check.
+ *
+ * Why not a second agentStop hook? The old design had a separate
+ * memoryai-auto-capture.kiro.hook on agentStop. agentStop fires AFTER the
+ * reply and forces a fresh askAgent reasoning pass whose only job is to "stay
+ * silent" — which leaks a stray "." into the chat and burns ~1.5 credits per
+ * idle turn. Folding the capture/guard logic into the promptSubmit hook fixes
+ * both problems: the background work finishes before the model answers, so the
+ * reply is clean and nothing fires on an idle turn-end. The setup below also
+ * deletes any pre-0.2.4 auto-capture hook left on disk.
  */
 import { createInterface } from "node:readline";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join, dirname } from "node:path";
 const rl = createInterface({ input: process.stdin, output: process.stdout });
 function ask(question, fallback) {
@@ -92,71 +98,61 @@ const MCP_CONFIG = (apiKey, endpoint) => JSON.stringify({
         },
     },
 }, null, 2) + "\n";
-const STEERING = `---
-inclusion: always
----
-
-# MemoryAI — Persistent Memory (mostly automatic)
-
-You have MemoryAI tools via MCP. Two Agent Hooks automate the common path:
-- **Auto-Recall** (on every prompt) loads memory before you answer.
-- **Auto-Capture** (end of every turn) stores important memory and compacts when full.
-
-So you normally do NOT need to manage memory by hand. This file is a fallback
-for cases the hooks don't cover, plus the rules for HOW to use memory well.
-
-## What the hooks already handle
-- Session-start \`memory_bootstrap\`, per-prompt \`memory_recall\`.
-- Post-turn \`memory_store\` for decisions/preferences/facts/pitfalls/procedures.
-- \`context_guard_check\` → \`context_guard_compact\` when context fills.
-
-Don't duplicate these on your own unless a hook clearly didn't run.
-
-## Memory types
-- \`decision\` — architectural/technical decisions (DNA-protected, never decays)
-- \`preference\` — user preferences and conventions (DNA-protected)
-- \`fact\` — codebase facts, API details, configs
-- \`pitfall\` — a mistake + its lesson (DNA-protected)
-- \`procedure\` — a reusable workflow (DNA-protected)
-- \`error\` / \`goal\` — lessons and current objectives
-
-## Rules
-- Recall only when past context is actually needed — not on every trivial message.
-- Store important outcomes, not every interaction. Dedup is automatic.
-- Integrate recalled info naturally; never show raw tool output.
-- Never store secrets, credentials, tokens, or full API keys.
-- Use \`zone: "critical"\` for things that must never be forgotten.
-- Use \`retention: "forever"\` for permanent project knowledge.
+const STEERING = `---
+inclusion: always
+---
+
+# MemoryAI — Persistent Memory (mostly automatic)
+
+You have MemoryAI tools via MCP. ONE Agent Hook automates the common path:
+- **Auto-Recall** (on every prompt, before you answer) loads memory, persists
+  anything memorable from the previous turn, and runs the context-guard check.
+
+So you normally do NOT need to manage memory by hand. This file is a fallback
+for cases the hook doesn't cover, plus the rules for HOW to use memory well.
+
+## What the hook already handles
+- Session-start \`memory_bootstrap\`, per-prompt \`memory_recall\`.
+- \`memory_store\` for decisions/preferences/facts/pitfalls/procedures.
+- \`ide_turn_check\` → \`context_guard_compact\` when context fills.
+
+Don't duplicate these on your own unless the hook clearly didn't run.
+
+## Memory types
+- \`decision\` — architectural/technical decisions (DNA-protected, never decays)
+- \`preference\` — user preferences and conventions (DNA-protected)
+- \`fact\` — codebase facts, API details, configs
+- \`pitfall\` — a mistake + its lesson (DNA-protected)
+- \`procedure\` — a reusable workflow (DNA-protected)
+- \`error\` / \`goal\` — lessons and current objectives
+
+## Rules
+- Recall only when past context is actually needed — not on every trivial message.
+- Store important outcomes, not every interaction. Dedup is automatic.
+- Integrate recalled info naturally; never show raw tool output.
+- Never store secrets, credentials, tokens, or full API keys.
+- Use \`zone: "critical"\` for things that must never be forgotten.
+- Use \`retention: "forever"\` for permanent project knowledge.
 `;
-// ── Agent Hooks — event-level automation (the real "zero-action" layer) ──
-// These fire on IDE events so memory works even if the agent ignores steering.
+// ── Agent Hook — event-level automation (the real "zero-action" layer) ──
+// ONE hook on promptSubmit. Fires BEFORE the answer so all background work
+// (recall + persist + guard) finishes first and the reply stays clean. This
+// replaces the old two-hook design (auto-recall + auto-capture); the
+// agentStop auto-capture hook is retired because it leaked a stray "." and
+// cost ~1.5 credits per idle turn.
 const HOOK_AUTO_RECALL = JSON.stringify({
     enabled: true,
     name: "MemoryAI Auto-Recall",
-    description: "Before answering each user message, automatically load relevant memory so the agent always has prior context — zero user action.",
-    version: "1",
+    description: "Before answering each user message: load relevant memory, persist anything memorable from the previous turn, and run the context-guard check. One hook, fires on promptSubmit so all background work finishes before the reply — zero user action.",
+    version: "2",
     when: { type: "promptSubmit" },
     then: {
         type: "askAgent",
-        prompt: "Before responding, ensure you have the relevant long-term memory (do this silently, integrate naturally, never show raw tool output):\n\n" +
-            "1. If this is the first turn of the session, call memory_bootstrap once to load preferences, decisions, and recent project context.\n" +
-            "2. If the user's message references past work, decisions, preferences, or anything that might be stored (\"what did we\", \"last time\", \"our approach\", \"why did we\", or a question about the project), call memory_recall with a focused query first, then answer using what you find.\n" +
-            "3. If the message is trivial small-talk, skip recall.\n\n" +
-            "Use recalled memory to inform the answer; do not announce that a memory system exists unless asked.",
-    },
-}, null, 2) + "\n";
-const HOOK_AUTO_CAPTURE = JSON.stringify({
-    enabled: true,
-    name: "MemoryAI Auto-Capture",
-    description: "Fully automatic: persist memorable events to MemoryAI after every turn, and persist session state silently when pressure thresholds hit. No user action ever required — the IDE host handles window eviction on its own and the auto-recall hook rehydrates context afterwards.",
-    version: "5",
-    when: { type: "agentStop" },
-    then: {
-        type: "askAgent",
-        prompt: "Run two background tasks SILENTLY. Do not tell the user about either task, do not change your normal reply, do not suggest /compact or 'open a new conversation' — those are not user actions in this design.\n\n" +
-            "1. PERSIST: If the turn produced a decision, preference, important project fact, lesson from a mistake (pitfall), or reusable procedure, call memory_store with the correct memory_type. Skip greetings and trivia. Dedup is automatic. Never store secrets.\n\n" +
-            "2. RELEASE CHECK: Count the assistant turns in this conversation, then call ide_turn_check with turn_count = (your count) and max_tokens = 200000. Read the response's action_prompt field and follow it VERBATIM. Every action_prompt in this design tells you to act SILENTLY — call context_guard_compact when asked, do nothing when asked. Never message the user from this hook.\n\n" +
-            "The design: MemoryAI persists to DB on threshold; the IDE host (Kiro auto-summarize, Claude Code /clear, Cursor /reset) evicts the window on its own schedule; the auto-recall hook on the next user message rehydrates context. From the user's view, nothing ever happens — the chat just keeps working.",
+        prompt: "Before responding, run these background tasks SILENTLY — integrate naturally, never show raw tool output, never tell the user a memory system exists unless asked:\n\n" +
+            "1. RECALL: If this is the first turn of the session, call memory_bootstrap once to load preferences, decisions, and recent project context. If the user's message references past work, decisions, preferences, or anything that might be stored (\"what did we\", \"last time\", \"our approach\", \"why did we\", or a question about the project), call memory_recall with a focused query. Trivial small-talk: skip recall.\n\n" +
+            "2. PERSIST: If the PREVIOUS turn produced a decision, preference, important project fact, lesson from a mistake (pitfall), or reusable procedure, call memory_store with the correct memory_type. Skip greetings and trivia. Dedup is automatic. Never store secrets.\n\n" +
+            "3. RELEASE CHECK: Count the assistant turns in this conversation. If the count is 15 or higher, call ide_turn_check with turn_count = (your count) and max_tokens = 200000, then follow the response's action_prompt field VERBATIM. Below turn 15, skip the guard. Every action_prompt acts SILENTLY — call context_guard_compact when asked, do nothing when asked. The ONLY message you may ever surface is the single \"context is full\" notice, and only when the action_prompt explicitly contains it, once per session.\n\n" +
+            "Then answer the user normally using whatever you recalled.",
     },
 }, null, 2) + "\n";
 async function main() {
@@ -179,16 +175,28 @@ async function main() {
     writeIfMissing(join(cwd, ".kiro", "settings", "mcp.json"), MCP_CONFIG(apiKey, endpoint), ".kiro/settings/mcp.json");
     writeIfMissing(join(cwd, ".kiro", "steering", "memoryai.md"), STEERING, ".kiro/steering/memoryai.md");
     writeIfMissing(join(cwd, ".kiro", "hooks", "memoryai-auto-recall.kiro.hook"), HOOK_AUTO_RECALL, ".kiro/hooks/memoryai-auto-recall.kiro.hook");
-    writeIfMissing(join(cwd, ".kiro", "hooks", "memoryai-auto-capture.kiro.hook"), HOOK_AUTO_CAPTURE, ".kiro/hooks/memoryai-auto-capture.kiro.hook");
-    console.log(`
-Done. MemoryAI now runs automatically — you don't have to do anything.
-  - Auto-Recall hook loads relevant memory before each answer.
-  - Auto-Capture hook stores decisions/preferences and compacts when full.
-
-Next steps:
-  1. Restart Kiro (loads the MCP server + hooks)
-  2. Just work normally. Memory persists across sessions on its own.
-  3. Optional check: ask "What do you remember about this project?"
+    // Retire the pre-0.2.4 agentStop hook if it exists. It fired AFTER every
+    // turn, forced an askAgent pass that leaked a stray "." into chat, and cost
+    // ~1.5 credits per idle turn. Its logic now lives in the auto-recall hook.
+    const legacyCapture = join(cwd, ".kiro", "hooks", "memoryai-auto-capture.kiro.hook");
+    if (existsSync(legacyCapture)) {
+        try {
+            rmSync(legacyCapture);
+            console.log("  remove  .kiro/hooks/memoryai-auto-capture.kiro.hook (retired agentStop hook)");
+        }
+        catch {
+            console.log("  warn    could not remove legacy memoryai-auto-capture.kiro.hook");
+        }
+    }
+    console.log(`
+Done. MemoryAI now runs automatically — you don't have to do anything.
+  - Auto-Recall hook (before each answer) loads memory, persists what matters,
+    and runs the context-guard check — all silently.
+
+Next steps:
+  1. Restart Kiro (loads the MCP server + hook)
+  2. Just work normally. Memory persists across sessions on its own.
+  3. Optional check: ask "What do you remember about this project?"
 `);
     rl.close();
 }

package/package.json

@@ -1,46 +1,46 @@
-{
-  "name": "memoryai-mcp",
-  "version": "2.4.2",
-  "description": "MCP server for MemoryAI v2.3 — One brain. Every AI you use. Forever. Persistent memory and context guard tools for IDEs and bots.",
-  "homepage": "https://memoryai.dev",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/memoryai-dev/memoryai"
-  },
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "memoryai-mcp": "dist/index.js",
-    "memoryai-kiro-setup": "dist/kiro-setup.js",
-    "memoryai-claude-setup": "dist/claude-setup.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "tsx src/index.ts"
-  },
-  "keywords": [
-    "mcp",
-    "memory",
-    "ai",
-    "llm",
-    "context"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.19.15",
-    "tsx": "^4.0.0",
-    "typescript": "^5.5.0"
-  }
-}
+{
+  "name": "memoryai-mcp",
+  "version": "2.4.4",
+  "description": "MCP server for MemoryAI v2.3 — One brain. Every AI you use. Forever. Persistent memory and context guard tools for IDEs and bots.",
+  "homepage": "https://memoryai.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/memoryai-dev/memoryai"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "memoryai-mcp": "dist/index.js",
+    "memoryai-kiro-setup": "dist/kiro-setup.js",
+    "memoryai-claude-setup": "dist/claude-setup.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "keywords": [
+    "mcp",
+    "memory",
+    "ai",
+    "llm",
+    "context"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.15",
+    "tsx": "^4.0.0",
+    "typescript": "^5.5.0"
+  }
+}