@everme/claude-code 0.6.1 → 0.6.2

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "everme",
       "source": "./",
       "description": "Automatic memory recall for Claude Code through the EverMe gateway. Saves and recalls per-session context using your EverMe account credentials.",
-      "version": "0.6.1",
+      "version": "0.6.2",
       "homepage": "https://everme.evermind.ai",
       "license": "Apache-2.0"
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "everme",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "EverMe — automatic memory recall for Claude Code. Recalls relevant context from past sessions before each prompt and saves new turns through the EverMe gateway.",
   "author": {
     "name": "EverMind AI",

package/README.md

@@ -7,11 +7,12 @@ Automatic memory recall + persistence for Claude Code, backed by the EverMe gate
 - **SessionStart** → loads the profile snapshot from past sessions and injects it as `additionalContext` for the model + a one-line `🧠 EverMe loaded N memory items` system message for you.
 - **UserPromptSubmit** → searches your memory for content relevant to the prompt you just typed and injects it BEFORE the model sees the prompt. Silent when no relevant hit (no nag).
 - **Stop** → persists the just-finished raw turn (including tool calls/results) with `flush:false`; every fifth turn triggers extraction.
+- **SubagentStop** → persists the child transcript's assistant/tool trajectory under a stable child conversation id; internal task/user wrappers are excluded and a per-transcript checkpoint prevents repeats.
 - **SessionEnd** → sends a flush-only request so short sessions still extract memory without repeating messages.
 
 Plus:
 
-- **MCP server** exposing the canonical `mem_search` / `mem_context` / `mem_save_fact` / `mem_save_turn` tools for explicit recall and saves.
+- **MCP server** exposing the read-only `mem_search` / `mem_context` tools for explicit recall (saving is automatic via the hooks).
 - **Slash commands** `/recall <q>` and `/everme-help`.
 - **Skill** (`memory-tools`) that tells Claude when/how to use the search tool.
 
@@ -21,7 +22,7 @@ Plus:
 |---|---|---|
 | Format | Generic MCP server | Claude Code plugin (hooks + commands + skill + MCP) |
 | Recall trigger | User must call MCP tool manually | Automatic on every UserPromptSubmit |
-| Save trigger | Explicit MCP tool call | Every Stop add + every fifth turn / SessionEnd extraction flush |
+| Save trigger | Explicit MCP tool call | Stop + SubagentStop adds; every fifth root turn / SessionEnd extraction flush |
 | Auth | `EVERME_AGENT_TOKEN` (evt) | Recall supports `EVERME_API_KEY` or `EVERME_AGENT_TOKEN`; realtime writes require `EVERME_AGENT_TOKEN` + `EVERME_AGENT_ID` |
 | Backend | EverMe gateway (`/api/v1/mem/*`) | Same — runtime writes use `/mem/agent-memory`, not `/mem/sources` |
 
@@ -84,9 +85,10 @@ In a new Claude Code session:
 .claude-plugin/plugin.json           plugin metadata
 .claude-plugin/marketplace.json      marketplace listing
 .mcp.json                            MCP server registration
-hooks/hooks.json                     SessionStart / UserPromptSubmit / Stop / SessionEnd wiring
+hooks/hooks.json                     SessionStart / UserPromptSubmit / Stop / SubagentStop / SessionEnd wiring
 hooks/scripts/inject-memories.js     UserPromptSubmit handler
 hooks/scripts/store-memories.js      Stop handler
+hooks/scripts/store-subagent-memories.js  SubagentStop handler
 hooks/scripts/session-start.js       SessionStart handler
 hooks/scripts/session-summary.js     SessionEnd handler
 hooks/scripts/mcp-server.js          MCP server (canonical mem_* tools)

package/commands/everme-help.md

@@ -26,6 +26,4 @@ Slash:
 MCP tools:
   mem_search        — hybrid search across all memory buckets
   mem_context       — durable Profile snapshot only
-  mem_save_fact     — save a durable user fact to the Profile path
-  mem_save_turn     — save a reusable task trajectory
 ```

package/hooks/hooks.json

@@ -36,6 +36,18 @@
         ]
       }
     ],
+    "SubagentStop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/store-subagent-memories.js",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
     "SessionEnd": [
       {
         "matcher": "*",

package/hooks/scripts/lib/adapter.js

@@ -11,14 +11,20 @@ export const claudeCodeAdapter = {
     return process.env.EVERME_ENV_FILE_PATH || path.join(os.homedir(), ".claude", "everme.env");
   },
 
-  normalizeInput(rawInput) {
+  normalizeInput(rawInput, event) {
+    const isSubagent = event === "SubagentStop";
+    const parentSessionId = rawInput?.session_id || "claude-code-session";
+    const agentId = rawInput?.agent_id || "subagent";
     return {
-      sessionId: rawInput?.session_id || "claude-code-session",
-      transcriptPath: rawInput?.transcript_path || "",
+      sessionId: isSubagent ? `${parentSessionId}__${agentId}` : parentSessionId,
+      transcriptPath: isSubagent
+        ? rawInput?.agent_transcript_path || ""
+        : rawInput?.transcript_path || "",
       cwd: rawInput?.cwd || "",
       prompt: rawInput?.prompt || "",
       turnId: rawInput?.turn_id || "",
       source: rawInput?.source || "",
+      isSubagent,
     };
   },
 
@@ -45,13 +51,38 @@ export const claudeCodeAdapter = {
 
   async readLastTurn(input) {
     if (!input?.transcriptPath) return [];
-    const messages = extractAgentMessages(await readTranscript(input.transcriptPath));
+    const messages = extractAgentMessages(await readTranscript(input.transcriptPath), {
+      subagent: input.isSubagent,
+    });
     for (let index = messages.length - 1; index >= 0; index -= 1) {
       if (messages[index]?.role === "user") return messages.slice(index);
     }
     return messages;
   },
 
+  async readStoreBatches(input, { checkpointStore } = {}) {
+    if (!input?.transcriptPath) return [];
+    const messages = extractAgentMessages(await readTranscript(input.transcriptPath), {
+      subagent: input.isSubagent,
+    });
+    const stateId = `claude-code:${input.sessionId}`;
+    const checkpoint = checkpointStore
+      ? await checkpointStore.read(stateId)
+      : { initialized: false, uploadedCount: 0 };
+    let delta;
+    if (checkpoint.initialized && checkpoint.uploadedCount <= messages.length) {
+      delta = messages.slice(checkpoint.uploadedCount);
+    } else {
+      delta = input.isSubagent ? messages : lastRootTurn(messages);
+    }
+    if (!delta.length) return [];
+    return [{
+      conversationId: input.sessionId,
+      messages: delta,
+      checkpoint: { stateId, uploadedCount: messages.length },
+    }];
+  },
+
   formatOutput(event, { block = "", count = 0 } = {}) {
     if (!CONTEXT_EVENTS.has(event) || !block) return {};
     const systemMessage = event === "SessionStart"
@@ -66,3 +97,10 @@ export const claudeCodeAdapter = {
     };
   },
 };
+
+function lastRootTurn(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index]?.role === "user") return messages.slice(index);
+  }
+  return messages;
+}

package/hooks/scripts/lib/transcript.js

@@ -133,7 +133,7 @@ export function extractTurns(lines) {
   return turns;
 }
 
-export function extractAgentMessages(lines) {
+export function extractAgentMessages(lines, { subagent = false } = {}) {
   const messages = [];
   for (const line of lines) {
     let ev;
@@ -142,6 +142,7 @@ export function extractAgentMessages(lines) {
     } catch {
       continue;
     }
+    if (isInternalEvent(ev, subagent)) continue;
     const timestamp = normalizeTimestamp(ev.timestamp);
     // Real Claude Code transcript schema is nested: each line is
     //   { "type":"user"|"assistant", "message":{role, content}, ... }
@@ -161,8 +162,11 @@ export function extractAgentMessages(lines) {
       // multiple EverMe messages.
       const toolResults = extractToolResults(rawContent, timestamp);
       messages.push(...toolResults);
-      const text = textFromContent(rawContent);
-      if (text) messages.push({ role: AGENT_MEMORY_ROLES.USER, timestamp, content: text });
+      if (subagent) continue;
+      const text = normalizeClaudeUserText(textFromContent(rawContent));
+      if (text) {
+        messages.push({ role: AGENT_MEMORY_ROLES.USER, timestamp, content: text });
+      }
       continue;
     }
     if (role === AGENT_MEMORY_ROLES.ASSISTANT) {
@@ -182,6 +186,79 @@ export function extractAgentMessages(lines) {
   return messages;
 }
 
+function isInternalEvent(event, subagent) {
+  if (event?.isMeta === true) return true;
+  if (subagent) return false;
+  return event?.isSidechain === true
+    || (typeof event?.agentId === "string" && event.agentId.length > 0);
+}
+
+function normalizeClaudeUserText(text) {
+  let trimmed = String(text || "").trim();
+  const initialCommand = commandIntent(trimmed);
+  if (initialCommand) return initialCommand;
+  if (hasEnvelopePrefix(trimmed, "command-message")) return "";
+
+  const injectedTags = [
+    "system-reminder",
+    "preview-annotation-context",
+    "task-notification",
+    "local-command-caveat",
+    "local-command-stdout",
+    "bash-input",
+    "bash-stdout",
+    "command-name",
+    "turn_aborted",
+  ];
+  for (;;) {
+    let stripped = false;
+    for (const tag of injectedTags) {
+      const remaining = stripLeadingEnvelope(trimmed, tag);
+      if (remaining !== null) {
+        trimmed = remaining;
+        stripped = true;
+        break;
+      }
+    }
+    if (!stripped) break;
+  }
+  if (!trimmed) return "";
+  const command = commandIntent(trimmed);
+  if (command) return command;
+  return hasEnvelopePrefix(trimmed, "command-message") ? "" : trimmed;
+}
+
+function commandIntent(text) {
+  if (!hasEnvelopePrefix(text, "command-message")) return "";
+  const name = envelopeValue(text, "command-name");
+  if (!name.startsWith("/")) return "";
+  const args = envelopeValue(text, "command-args");
+  return `${name} ${args}`.trim();
+}
+
+function stripLeadingEnvelope(text, tag) {
+  if (!hasEnvelopePrefix(text, tag)) return null;
+  const close = `</${tag}>`;
+  const end = text.indexOf(close);
+  if (end < 0) return null;
+  return text.slice(end + close.length).trim();
+}
+
+function hasEnvelopePrefix(text, tag) {
+  if (!text.startsWith(`<${tag}`)) return false;
+  return [">", " ", "\t", "\n", "\r"].includes(text.at(tag.length + 1));
+}
+
+function envelopeValue(text, tag) {
+  const open = `<${tag}>`;
+  const close = `</${tag}>`;
+  const start = text.indexOf(open);
+  if (start < 0) return "";
+  const valueStart = start + open.length;
+  const end = text.indexOf(close, valueStart);
+  return end < 0 ? "" : text.slice(valueStart, end).trim();
+}
+
 // extractToolResults pulls every `tool_result` block out of a CC user-
 // envelope content array and converts each into an EverMe role=tool
 // message. CC encodes tool_result as a content block inside a user

package/hooks/scripts/mcp-server.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 /**
- * MCP server bundled with the Claude Code plugin. Exposes the canonical
- * EverMe four-tool catalogue (mem_search / mem_context / mem_save_turn /
- * mem_save_fact — the same public ABI as @everme/memory-mcp and the Go
- * hosted /mcp surface).
+ * MCP server bundled with the Claude Code plugin. Exposes the read-only
+ * EverMe tools (mem_search / mem_context — the same public ABI as
+ * @everme/memory-mcp and the Go hosted /mcp surface). Saving is automatic
+ * via the plugin's hooks; the MCP write tools were retired.
  *
  * Wire format: MCP stdio transport (JSON-RPC 2.0 framed by line).
  * We hand-roll the tiny subset Claude Code uses rather than pulling
@@ -21,9 +21,6 @@ import {
   createClient,
   getContext,
   searchMemory,
-  saveAgentMemory,
-  savePersonalMemory,
-  AGENT_MEMORY_ROLES,
   redactError,
   describeError,
   EvermeError,
@@ -76,13 +73,11 @@ function getClient() {
 const INSTRUCTIONS = [
   "EverMe memory is connected. This plugin's native hooks already inject a",
   "<everme_profile> block at session start and a <everme_recall> block before",
-  "each prompt, and they save the conversation automatically — so the tools",
-  "below are for the cases the hooks do not cover. Call them AUTONOMOUSLY when",
-  "a trigger fires; never wait for the user to say \"remember\" or \"recall\".",
+  "each prompt, and they save the conversation automatically — so saving needs",
+  "no tool call. These two READ tools are for the cases the hooks do not cover;",
+  "call them AUTONOMOUSLY when a trigger fires, never waiting to be asked.",
   "1. The <everme_recall> block is missing, empty, or clearly irrelevant AND the user references earlier conversations, decisions, conventions, or previously solved problems — call `mem_search` with a SHORT query. Do not repeat an identical query in the same turn.",
-  "2. The user states a durable fact about themselves (a preference, habit, trait, long-term goal, or decision) — call `mem_save_fact` immediately. Only `extracted:true` / `profileUpdated:true` means the profile really updated; on `no_extraction` do NOT tell the user the fact was remembered, and do not auto-retry.",
-  "3. A task was solved in a way worth reusing and the trajectory is NOT already captured by the hooks — call `mem_save_turn` with the COMPLETE trajectory. It feeds episodic / case / skill extraction; chat-dual-write backends may also update the Profile, reported by profileUpdated.",
-  "4. No <everme_profile> block was injected this session — call `mem_context` once. It returns the durable Profile ONLY (no search, no episodes).",
+  "2. No <everme_profile> block was injected this session — call `mem_context` once. It returns the durable Profile ONLY (no search, no episodes).",
 ].join("\n");
 
 const TOOLS = [
@@ -152,149 +147,6 @@ const TOOLS = [
       },
     },
   },
-  {
-    name: "mem_save_turn",
-    description:
-      "Persist a conversation trajectory in realtime via /mem/agent-memory. " +
-      "Use sessionKey as conversationId.\n\n" +
-      "Call this when a task was solved in a way worth reusing AND the " +
-      "trajectory is not already captured by the plugin's automatic " +
-      "transcript save. Pass the COMPLETE round-trip — messages: [{role, " +
-      "content, timestamp?, toolCalls?, toolCallId?}] — EverOS only " +
-      "extracts agent_case / agent_skill from trajectories carrying the " +
-      "full tool round-trip.\n\n" +
-      "By default flush=true: extraction into episodic / agent_case / " +
-      "agent_skill runs right away. Pass flush=false for append-only " +
-      "accumulation. The primary trajectory path extracts episodic / case / " +
-      "skill memory; chat-dual-write backends may also update the user's " +
-      "Profile. Check profileUpdated for the derived profile verdict, and " +
-      "use mem_save_fact for deliberate durable user facts.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        role: {
-          type: "string",
-          enum: ["user", "assistant", "tool"],
-          description: "Role for the single-message form. Ignored when messages[] is set.",
-        },
-        text: { type: "string", description: "Content for the single-message form. Ignored when messages[] is set." },
-        timestamp: { type: "integer", description: "Unix milliseconds; defaults to now. Single-message form only." },
-        toolCallId: { type: "string", description: "Required when role=tool. Single-message form only." },
-        toolCalls: {
-          type: "array",
-          description:
-            "Tool invocations made by an assistant message. Required when " +
-            "the assistant called tools — without this the tool round-trip " +
-            "can never be reconstructed downstream and EverOS will not " +
-            "produce agent_case / agent_skill from the turn.",
-          items: {
-            type: "object",
-            properties: {
-              id: { type: "string" },
-              name: { type: "string" },
-              arguments: { type: "string", description: "JSON-encoded tool arguments (stringified, not an object)." },
-            },
-            required: ["id", "name", "arguments"],
-          },
-        },
-        messages: {
-          type: "array",
-          description:
-            "Multi-message trajectory. Preferred for recording a complete " +
-            "user → assistant{tool_use} → tool{tool_result} → assistant cycle.",
-          items: {
-            type: "object",
-            properties: {
-              role: { type: "string", enum: ["user", "assistant", "tool"] },
-              content: { description: "String text, or array of content items (text / image / doc)." },
-              timestamp: { type: "integer" },
-              toolCallId: { type: "string", description: "Required when role=tool." },
-              toolCalls: {
-                type: "array",
-                items: {
-                  type: "object",
-                  properties: {
-                    id: { type: "string" },
-                    name: { type: "string" },
-                    arguments: { type: "string" },
-                  },
-                  required: ["id", "name", "arguments"],
-                },
-              },
-            },
-            required: ["role"],
-          },
-        },
-        sessionKey: { type: "string", description: "Session id; defaults to 'default'." },
-        flush: {
-          type: "boolean",
-          default: true,
-          description:
-            "true (default) = trigger EverOS extraction into " +
-            "episodic_memory / agent_case / agent_skill after writing; " +
-            "false = append-only, messages are searchable as raw_messages " +
-            "only and extraction is deferred until a later flush. The " +
-            "default flipped from false to true because callers rarely " +
-            "issued an explicit follow-up flush, leaving trajectories " +
-            "permanently stuck as raw_messages with zero case/skill.",
-        },
-      },
-    },
-  },
-  {
-    name: "mem_save_fact",
-    description:
-      "Persist a durable fact about the USER (a preference, habit, trait, " +
-      "or decision) via the long-term PROFILE write path — the block loaded " +
-      "at the start of every session.\n\n" +
-      "Call this proactively, without being asked, the moment the user " +
-      "states something true about themselves that should outlive this " +
-      "conversation (\"I love summer\", \"sign my docs as Alice\").\n\n" +
-      "This is the direct profile-producing sibling of mem_save_turn — " +
-      "mem_save_turn primarily records trajectories, though chat-dual-write " +
-      "backends may derive a profile update. With flush=true (default) " +
-      "the call runs the synchronous materialise path and returns the real " +
-      "EverOS verdict: only `extracted:true` / `profileUpdated:true` " +
-      "confirms the fact reached the profile. `status:\"no_extraction\"` " +
-      "means the profile did NOT update — never claim the fact was " +
-      "remembered in that case, and do not auto-retry.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        fact: {
-          type: "string",
-          description:
-            "A single user-stated fact, recorded as one user-role message. " +
-            "Ignored when messages[] is set.",
-        },
-        messages: {
-          type: "array",
-          description:
-            "Explicit user/assistant turns. Tool roles are not accepted on " +
-            "this path. Preferred when you want to capture both the user's " +
-            "statement and your acknowledgement.",
-          items: {
-            type: "object",
-            properties: {
-              role: { type: "string", enum: ["user", "assistant"] },
-              content: { description: "String text, or array of content items." },
-              timestamp: { type: "integer", description: "Unix milliseconds; defaults to now." },
-            },
-            required: ["role"],
-          },
-        },
-        sessionKey: { type: "string", description: "Session id; defaults to 'default'." },
-        flush: {
-          type: "boolean",
-          default: true,
-          description:
-            "true (default) = issue EverOS flush and return its verdict; " +
-            "false = skip extraction entirely (fact accepted but not in the " +
-            "profile block).",
-        },
-      },
-    },
-  },
 ];
 
 const handlers = {
@@ -341,78 +193,6 @@ const handlers = {
           const text = ctx?.context || "_(no profile available — your EverMe account has no extracted memories yet)_";
           return ok(appendRequestID(redactError(text), ctx?.requestId));
         }
-        case "mem_save_turn": {
-          let messages;
-          if (Array.isArray(args.messages) && args.messages.length) {
-            messages = args.messages.map(normaliseTurnMessage);
-          } else {
-            messages = [normaliseTurnMessage({
-              role: args.role || AGENT_MEMORY_ROLES.USER,
-              content: args.text,
-              timestamp: args.timestamp,
-              toolCallId: args.toolCallId,
-              toolCalls: args.toolCalls,
-            })];
-          }
-          const res = await saveAgentMemory(getClient(), {
-            conversationId: args.sessionKey || "default",
-            messages,
-            flush: args.flush !== false,
-          }, stderrLog);
-          return okJson({
-            saved: !!res,
-            accepted: !!res,
-            status: res?.status || null,
-            messageCount: res?.messageCount || 0,
-            flushed: !!res?.flushed,
-            profileStatus: res?.personalStatus || null,
-            profileUpdated: !!res?.personalExtracted,
-            requestId: res?.requestId || null,
-          });
-        }
-        case "mem_save_fact": {
-          let messages;
-          if (Array.isArray(args.messages) && args.messages.length) {
-            const bad = args.messages.find(
-              (m) => m?.role !== AGENT_MEMORY_ROLES.USER && m?.role !== AGENT_MEMORY_ROLES.ASSISTANT,
-            );
-            if (bad) {
-              return errResp(
-                `mem_save_fact accepts only 'user' or 'assistant' roles; got ${JSON.stringify(bad?.role)}. ` +
-                  "The personal-memory path does not record tool turns — use mem_save_turn for trajectories.",
-              );
-            }
-            messages = args.messages.map((m) => ({
-              role: m?.role,
-              content: m?.content !== undefined ? m.content : m?.text,
-              timestamp: Number(m?.timestamp) || Date.now(),
-            }));
-          } else if (typeof args.fact === "string" && args.fact.trim()) {
-            messages = [{ role: AGENT_MEMORY_ROLES.USER, content: args.fact, timestamp: Date.now() }];
-          } else {
-            return errResp("mem_save_fact requires either `fact` or a non-empty `messages` array");
-          }
-          const res = await savePersonalMemory(getClient(), {
-            conversationId: args.sessionKey || "default",
-            messages,
-            flush: args.flush !== false,
-          }, stderrLog);
-          if (!res) {
-            return errResp("mem_save_fact wrote nothing — every message had empty content after normalization");
-          }
-          return okJson({
-            saved: true,
-            accepted: true,
-            status: res?.status || null,
-            messageCount: res?.messageCount || 0,
-            flushed: !!res?.flushed,
-            extracted: !!res?.extracted,
-            // profileUpdated aliases extracted — the only signal that the
-            // fact really materialised into the profile.
-            profileUpdated: !!res?.extracted,
-            requestId: res?.requestId || null,
-          });
-        }
         default:
           return errResp(`unknown tool: ${name}`);
       }
@@ -440,22 +220,6 @@ function appendRequestID(text, requestId) {
   return `${text}\n\n_(requestId: ${requestId})_`;
 }
 
-// normaliseTurnMessage coerces an LLM-provided message into the SDK
-// agent-memory shape — accepts both legacy {role, text} and canonical
-// {role, content, toolCalls, toolCallId} forms. Mirrors the equivalent
-// helper in @everme/memory-mcp (kept local: host packages must not
-// import each other).
-function normaliseTurnMessage(m) {
-  const role = m?.role || AGENT_MEMORY_ROLES.USER;
-  const out = { role, timestamp: Number(m?.timestamp) || Date.now() };
-  if (m?.content !== undefined) out.content = m.content;
-  else if (m?.text !== undefined) out.content = String(m.text);
-  if (Array.isArray(m?.toolCalls) && m.toolCalls.length) out.toolCalls = m.toolCalls;
-  if (role === AGENT_MEMORY_ROLES.TOOL && (m?.toolCallId || m?.tool_call_id)) {
-    out.toolCallId = String(m.toolCallId || m.tool_call_id);
-  }
-  return out;
-}
 
 const rl = createInterface({ input: process.stdin, terminal: false });
 rl.on("line", async (line) => {

package/hooks/scripts/store-subagent-memories.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runClaudeCodeHook } from "./lib/run-hook.js";
+
+runClaudeCodeHook("SubagentStop");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everme/claude-code",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "type": "module",
   "description": "EverMe native plugin for Claude Code — automatic memory recall via SessionStart/UserPromptSubmit/Stop/SessionEnd hooks, plus /recall slash + bundled MCP server.",
   "license": "Apache-2.0",
@@ -21,7 +21,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@everme/agent-sdk": "^0.6.1"
+    "@everme/agent-sdk": "^0.6.2"
   },
   "keywords": [
     "evermind",

package/skills/memory-tools.md

@@ -5,16 +5,11 @@ alwaysInclude: true
 
 # EverMe Memory Tools
 
-You have four canonical MCP tools for memory EverMe persists across past Claude Code sessions:
+You have two MCP tools for memory EverMe persists across past Claude Code sessions. Both are read-only; the native hooks own every write.
 
-Recall:
 - `mem_search` — semantic + keyword hybrid search over the user's memory store (episodic, profile, agent cases/skills, recent raw transcript). Rows under "Recent unextracted transcript" are provisional, not established facts.
 - `mem_context` — the user's durable Profile snapshot ONLY. It never searches and never returns episodes; do not use it to recall past decisions or task context.
 
-Write:
-- `mem_save_fact` — save a durable user fact (preference, habit, trait, long-term decision). Call it proactively the moment the user states one ("以后文档签名用 Alice", "I hate Friday meetings") — do NOT wait for the user to say "remember this".
-- `mem_save_turn` — persist a complete task trajectory worth reusing. Chat-dual-write backends may also update the user's Profile; check `profileUpdated`. Use `mem_save_fact` for a deliberate durable fact.
-
 ## Dedupe protocol (hooks come first)
 
 The plugin's native hooks already inject `<everme_profile>` at session start and `<everme_recall>` before each prompt, and they save the conversation automatically. So:
@@ -24,10 +19,6 @@ The plugin's native hooks already inject `<everme_profile>` at session start and
 - Never repeat an identical query within the same turn.
 - Call `mem_context` only when no `<everme_profile>` block was injected this session.
 
-## Save honesty
-
-`mem_save_fact` returns the real extraction verdict. Only `extracted: true` / `profileUpdated: true` means the profile updated — then you may tell the user the fact is remembered. On `status: "no_extraction"` the profile did NOT update: say so plainly, do not auto-retry, and do not claim success.
-
 ## Best practices
 
 1. Search with the user's specific terms first; only broaden if zero hits.