memoryai-mcp 2.4.3 → 2.4.4

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) {
@@ -98,19 +104,19 @@ 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.
+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 hooks don't cover, plus the rules for HOW to use memory well.
+for cases the hook doesn't cover, plus the rules for HOW to use memory well.
 
-## What the hooks already handle
+## What the hook already handles
 - 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.
+- \`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 a hook clearly didn't run.
+Don't duplicate these on your own unless the hook clearly didn't run.
 
 ## Memory types
 - \`decision\` — architectural/technical decisions (DNA-protected, never decays)
@@ -128,35 +134,25 @@ Don't duplicate these on your own unless a hook clearly didn't run.
 - 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,14 +175,26 @@ 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");
+    // 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 loads relevant memory before each answer.
-  - Auto-Capture hook stores decisions/preferences and compacts when full.
+  - 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 + hooks)
+  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?"
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoryai-mcp",
-  "version": "2.4.3",
+  "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": {