@everme/claude-code 0.3.4 → 0.4.0

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.3.4",
+      "version": "0.4.0",
       "homepage": "https://everme.evermind.ai",
       "license": "Apache-2.0"
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "everme",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "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

@@ -4,10 +4,10 @@ Automatic memory recall + persistence for Claude Code, backed by the EverMe gate
 
 ## What it does
 
-- **SessionStart** → loads recent context (profile + episodes) from past sessions and injects it as `additionalContext` for the model + a one-line `🧠 EverMe loaded N memory items` system message for you.
+- **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** → after each Claude reply, persists the just-finished raw turn (including tool calls/results) to `/mem/agent-memory`.
-- **SessionEnd** → no persistence; Stop owns runtime writes so Claude Code does not create `/mem/sources`.
+- **Stop** → persists the just-finished raw turn (including tool calls/results) with `flush:false`; every fifth turn triggers extraction.
+- **SessionEnd** → sends a flush-only request so short sessions still extract memory without repeating messages.
 
 Plus:
 
@@ -21,7 +21,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 | Buffer flushes by turn-count or byte threshold | Every Stop event via realtime agent memory |
+| Save trigger | Explicit MCP tool call | Every Stop add + every fifth 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` |
 
@@ -55,7 +55,12 @@ claude plugin install /path/to/everme/plugins/claude-code
 | `EVERME_AGENT_TOKEN` | Per-machine evt — written by `evercli plugin install claude-code`. Required for realtime writes and wins over emk when both are set. |
 | `EVERME_AGENT_ID` | Required with `EVERME_AGENT_TOKEN` for realtime writes; also pins recall to a specific cloud agent. |
 | `EVERME_API_BASE` | Gateway host. Defaults to `https://api.everme.evermind.ai`. Set to `http://localhost:8080` for local dev. |
-| `EVERME_DEBUG` | `1` to print hook traces to stderr (with token redaction). |
+| `EVERME_INJECT_TOPK` | Recall rows, default `10`, clamped to `1..20`. |
+| `EVERME_INJECT_PROFILE` | `1` includes profiles in per-prompt recall; default `0` because SessionStart already injects profile. |
+| `EVERME_INJECT_MIN_SCORE` | Positive-score cutoff, default `0.1`; unscored rows remain eligible. |
+| `EVERME_FLUSH_EVERY_TURNS` | Extraction cadence, default `5`; `0` disables cadence flush. |
+| `EVERME_FLUSH_MODE` | Set `legacy` to restore every-turn flush. |
+| `EVERME_STATE_DIR` | Turn counter directory, default `~/.everme/state`; files are `0600`. |
 
 ## Verifying the install
 
@@ -85,10 +90,10 @@ hooks/scripts/store-memories.js      Stop handler
 hooks/scripts/session-start.js       SessionStart handler
 hooks/scripts/session-summary.js     SessionEnd handler
 hooks/scripts/mcp-server.js          MCP server (everme_search / everme_context tools)
-hooks/scripts/lib/api.js             Gateway HTTP client (agent-memory, search, context)
+hooks/scripts/lib/adapter.js         Claude Code stdin/transcript/stdout adapter
+hooks/scripts/lib/run-hook.js        thin shared-runtime entry helper
 hooks/scripts/lib/config.js          Env-var resolution (emk vs evt)
 hooks/scripts/lib/transcript.js      Claude Code transcript JSONL reader
-hooks/scripts/lib/redact.js          evt/emk/X-Amz-Signature scrub for logs
 commands/recall.md                   /recall slash command
 commands/everme-help.md              /everme-help slash command
 skills/memory-tools.md               always-injected skill — tells Claude how to use the tools

package/commands/everme-help.md

@@ -26,6 +26,4 @@ Slash:
 MCP tools:
   everme_search     — ranked search
   everme_context    — server-rendered context block
-
-Tip: Set EVERME_DEBUG=1 to see hook traces on stderr.
 ```

package/hooks/scripts/inject-memories.js

@@ -1,141 +1,8 @@
 #!/usr/bin/env node
-/**
- * UserPromptSubmit hook — recall relevant memories and inject them
- * into Claude's context BEFORE it sees the user's prompt.
- *
- * Hook contract (from Claude Code):
- *   stdin  = JSON { prompt, transcript_path, cwd, ... }
- *   stdout = JSON {
- *     systemMessage: "...",      // shown to user inline
- *     hookSpecificOutput: {
- *       hookEventName: "UserPromptSubmit",
- *       additionalContext: "..." // injected for the model only
- *     }
- *   }
- *
- * On any error or "no relevant memories" we exit 0 silently — never
- * block the user's prompt on a memory backend hiccup.
- */
 
 process.on("uncaughtException", () => process.exit(0));
 process.on("unhandledRejection", () => process.exit(0));
 
-import { buildMemoryPrompt } from "@everme/agent-sdk";
-import { isConfigured } from "./lib/config.js";
-import { searchMemories } from "./lib/api.js";
-import { redactError, debug } from "./lib/redact.js";
+import { runClaudeCodeHook } from "./lib/run-hook.js";
 
-const MIN_PROMPT_WORDS = 3;
-const TOP_K = 5;
-const MIN_SCORE = 0.1;
-
-async function main() {
-  const data = await readStdinJSON();
-  const prompt = String(data?.prompt || "");
-  if (!isConfigured()) {
-    debug("inject", "skip: not configured");
-    return process.exit(0);
-  }
-  if (countTokens(prompt) < MIN_PROMPT_WORDS) {
-    debug("inject", "skip: prompt too short");
-    return process.exit(0);
-  }
-
-  // /mem/search with the gateway's default memoryTypes returns episodes
-  // + profiles + raw_messages + agent_memory in a single call, ranked
-  // by query relevance. That's strictly more than /mem/context (a
-  // queryless full-profile snapshot) — context is kept for SessionStart
-  // where there is no prompt, but per-turn inject goes through search.
-  let block = "";
-  let count = 0;
-  let degraded = null;
-  try {
-    // The raw prompt can be a huge paste; the SDK's searchMemory clamps
-    // the query to the backend's MaxSearchQueryRunes limit, so we pass it
-    // through as-is rather than capping here too.
-    const res = await searchMemories(prompt, { topK: TOP_K });
-    // EverOS frequently returns score=null on episodic hits (decoded as
-    // 0 over the wire) — that's "unscored", not "score zero". Treat
-    // 0/null as unscored and keep the row; only drop rows with an
-    // explicit positive score below the threshold.
-    const filteredMemories = (res?.memories || []).filter((m) => {
-      const s = m?.score ?? m?.relevanceScore;
-      return s == null || s === 0 || s >= MIN_SCORE;
-    });
-    const bundle = {
-      memories: filteredMemories,
-      profiles: res?.profiles || [],
-      rawMessages: res?.rawMessages || [],
-      agentMemory: res?.agentMemory || { cases: [], skills: [] },
-    };
-    count =
-      filteredMemories.length +
-      bundle.profiles.length +
-      (bundle.agentMemory.cases?.length || 0) +
-      (bundle.agentMemory.skills?.length || 0) +
-      bundle.rawMessages.length;
-    // Reuse the SDK renderer so Claude Code and OpenClaw inject the
-    // same sectioned shape. wrapInCodeBlock=false because Claude Code
-    // wraps the body in an <everme_recall> envelope below — fenced
-    // markdown nested in XML reads worse than the bare section list.
-    const inner = buildMemoryPrompt(bundle, { wrapInCodeBlock: false });
-    if (inner) block = `<everme_recall>\n${inner}\n</everme_recall>`;
-  } catch (err) {
-    const reason = redactError(err?.message || String(err));
-    degraded = reason;
-    debug("inject", "search failed:", reason);
-  }
-
-  if (!block || count === 0) {
-    if (degraded) {
-      // Visible single-line WARN — the hook is by design non-blocking,
-      // but a fully silent failure means the user thinks EverMe is
-      // running while every recall is dropped. Surface it once per
-      // hook invocation so persistent issues (expired token, backend
-      // unreachable) bubble up without forcing EVERME_DEBUG=1.
-      process.stderr.write(`EverMe inject hook degraded: ${degraded}\n`);
-    } else {
-      debug("inject", "no memories above threshold");
-    }
-    return process.exit(0);
-  }
-
-  const systemMessage = `🧠 Recalling ${count} relevant ${count === 1 ? "memory" : "memories"} from EverMe`;
-  const out = {
-    systemMessage,
-    hookSpecificOutput: {
-      hookEventName: "UserPromptSubmit",
-      additionalContext: block,
-    },
-  };
-  process.stdout.write(JSON.stringify(out));
-  process.exit(0);
-}
-
-// Multilingual rough word count (CJK characters count individually,
-// other languages by whitespace tokens). Mirrors the reference
-// plugin's heuristic so users get the same min-prompt feel.
-function countTokens(text) {
-  if (!text) return 0;
-  const cjkRe = /[一-鿿㐀-䶿぀-ゟ゠-ヿ가-힯]/g;
-  const cjk = (text.match(cjkRe) || []).length;
-  const ascii = text
-    .replace(cjkRe, " ")
-    .split(/\s+/)
-    .filter(Boolean).length;
-  return cjk + ascii;
-}
-
-async function readStdinJSON() {
-  const chunks = [];
-  for await (const c of process.stdin) chunks.push(c);
-  const raw = Buffer.concat(chunks).toString("utf8");
-  if (!raw) return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-
-main();
+runClaudeCodeHook("UserPromptSubmit");

package/hooks/scripts/lib/adapter.js

@@ -0,0 +1,68 @@
+import os from "node:os";
+import path from "node:path";
+import { readTranscript, extractAgentMessages } from "./transcript.js";
+
+const CONTEXT_EVENTS = new Set(["SessionStart", "UserPromptSubmit"]);
+
+export const claudeCodeAdapter = {
+  platform: "claude-code",
+
+  envFile() {
+    return process.env.EVERME_ENV_FILE_PATH || path.join(os.homedir(), ".claude", "everme.env");
+  },
+
+  normalizeInput(rawInput) {
+    return {
+      sessionId: rawInput?.session_id || "claude-code-session",
+      transcriptPath: rawInput?.transcript_path || "",
+      cwd: rawInput?.cwd || "",
+      prompt: rawInput?.prompt || "",
+      turnId: rawInput?.turn_id || "",
+      source: rawInput?.source || "",
+    };
+  },
+
+  // Claude Code's documented Stop stdin carries no turn_id (only
+  // session_id / transcript_path / cwd / stop_hook_active), so keying dedup
+  // on rawInput.turn_id alone never fires. Derive a stable per-turn key
+  // from the transcript instead: the uuid of the last recorded event. A
+  // re-fired Stop over an unchanged transcript resolves to the same key and
+  // is deduped; a new turn appends new events and yields a new key. Returns
+  // "" (dedup disabled) when the transcript has no uuids.
+  async resolveTurnId(input) {
+    if (!input?.transcriptPath) return "";
+    const lines = await readTranscript(input.transcriptPath);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      try {
+        const event = JSON.parse(lines[index]);
+        if (typeof event?.uuid === "string" && event.uuid) return event.uuid;
+      } catch {
+        continue;
+      }
+    }
+    return "";
+  },
+
+  async readLastTurn(input) {
+    if (!input?.transcriptPath) return [];
+    const messages = extractAgentMessages(await readTranscript(input.transcriptPath));
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+      if (messages[index]?.role === "user") return messages.slice(index);
+    }
+    return messages;
+  },
+
+  formatOutput(event, { block = "", count = 0 } = {}) {
+    if (!CONTEXT_EVENTS.has(event) || !block) return {};
+    const systemMessage = event === "SessionStart"
+      ? `🧠 EverMe loaded ${count} memory ${count === 1 ? "item" : "items"} from past sessions`
+      : `🧠 Recalling ${count} relevant ${count === 1 ? "memory" : "memories"} from EverMe`;
+    return {
+      systemMessage,
+      hookSpecificOutput: {
+        hookEventName: event,
+        additionalContext: block,
+      },
+    };
+  },
+};

package/hooks/scripts/lib/config.js

@@ -108,7 +108,7 @@ export function getConfig() {
     apiBase: process.env.EVERME_API_BASE,
     agentId: process.env.EVERME_AGENT_ID,
     agentToken,
-    topK: 5,
+    topK: 10,
   });
 
   cached = {

package/hooks/scripts/lib/run-hook.js

@@ -0,0 +1,18 @@
+import { runHook } from "@everme/agent-sdk";
+import { claudeCodeAdapter } from "./adapter.js";
+
+export async function runClaudeCodeHook(event) {
+  const output = await runHook(event, await readStdinJSON(), claudeCodeAdapter);
+  if (output && Object.keys(output).length) process.stdout.write(JSON.stringify(output));
+}
+
+async function readStdinJSON() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  if (!chunks.length) return {};
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    return {};
+  }
+}

package/hooks/scripts/mcp-server.js

@@ -18,11 +18,15 @@
 
 import { createInterface } from "readline";
 import { createRequire } from "node:module";
-import { buildMemoryPrompt } from "@everme/agent-sdk";
-import { searchMemories, getContext, EvermeError } from "./lib/api.js";
-import { isConfigured } from "./lib/config.js";
-import { renderProfileBlock } from "./lib/profile.js";
-import { redactError, debug } from "./lib/redact.js";
+import {
+  buildMemoryPrompt,
+  createClient,
+  searchMemory,
+  renderProfileBlock,
+  redactError,
+  EvermeError,
+} from "@everme/agent-sdk";
+import { getConfig, isConfigured } from "./lib/config.js";
 
 // Derive serverInfo.version from package.json so the value tracks the
 // plugin release rather than rotting as a hard-coded literal. We sit at
@@ -41,6 +45,12 @@ const { version: PKG_VERSION } = createRequire(import.meta.url)("../../package.j
 // Claude Code already negotiates "2025-03-26".
 const SUPPORTED_PROTOCOL_VERSIONS = new Set(["2024-11-05", "2025-03-26"]);
 const LATEST_PROTOCOL_VERSION = "2025-03-26";
+let client;
+
+function getClient() {
+  if (!client) client = createClient(getConfig());
+  return client;
+}
 
 const TOOLS = [
   {
@@ -59,12 +69,12 @@ const TOOLS = [
   {
     name: "everme_context",
     description:
-      "Fetch the server-rendered context block (profile + recent episodes) the gateway uses for prompt injection. Useful when you want a single ready-to-paste summary. Params: query (optional), topK (default 5).",
+      "Fetch the server-rendered context block (profile + recent episodes) the gateway uses for prompt injection. Useful when you want a single ready-to-paste summary. Params: query (optional), topK (default 10).",
     inputSchema: {
       type: "object",
       properties: {
         query: { type: "string", description: "Optional query for relevance-biased context" },
-        topK: { type: "number", description: "Max items to include (default 5)" },
+        topK: { type: "number", description: "Max items to include (default 10)" },
       },
     },
   },
@@ -99,7 +109,7 @@ const handlers = {
           // host LLM to peel a JSON envelope and decode escaped
           // newlines before any of the section bullets were readable.
           const topK = Math.min(Number(args.topK) || 10, 25);
-          const res = await searchMemories(String(args.query || ""), { topK });
+          const res = await searchMemory(getClient(), { query: String(args.query || ""), topK });
           const body = buildMemoryPrompt(res, { wrapInCodeBlock: false });
           const header = `## EverMe search results for "${String(args.query || "")}"`;
           const trimmed = body.replace(/^## Relevant memory\n\n?/, "");
@@ -116,7 +126,7 @@ const handlers = {
           // uses for the SessionStart hook injection) so the Tools
           // path matches what users already see in the injected
           // <everme_profile> block.
-          const res = await getContext(String(args.query || ""), {});
+          const res = await getClient().request("POST", "/mem/context", {});
           // renderProfileBlock returns "" when profile exists but has no
           // facts/traits yet (new account). Check the rendered output, not
           // just the wrapper object, so the empty case yields a fallback
@@ -130,7 +140,6 @@ const handlers = {
       }
     } catch (err) {
       const safe = redactError(err instanceof EvermeError ? err.message : err?.message || String(err));
-      debug("mcp", `tool ${name} failed:`, safe);
       return errResp(safe);
     }
   },
@@ -177,5 +186,3 @@ function respond(id, result, error) {
     : { jsonrpc: "2.0", id, result };
   process.stdout.write(JSON.stringify(env) + "\n");
 }
-
-debug("mcp", "everme MCP server ready");

package/hooks/scripts/session-start.js

@@ -1,70 +1,8 @@
 #!/usr/bin/env node
-/**
- * SessionStart hook — surface a recent-context block when a new
- * Claude Code session begins. Helps the user (and Claude) pick up
- * where the previous session left off without manually pasting
- * context.
- *
- * Hook contract:
- *   stdin  = JSON { cwd, session_id, ... }
- *   stdout = JSON { systemMessage, hookSpecificOutput: { ..., additionalContext } }
- */
 
 process.on("uncaughtException", () => process.exit(0));
 process.on("unhandledRejection", () => process.exit(0));
 
-import { isConfigured } from "./lib/config.js";
-import { getContext } from "./lib/api.js";
-import { redactError, debug } from "./lib/redact.js";
-import { renderProfileBlock, profileItemCount } from "./lib/profile.js";
+import { runClaudeCodeHook } from "./lib/run-hook.js";
 
-const TOP_K = 6;
-
-async function main() {
-  if (!isConfigured()) {
-    debug("start", "skip: not configured");
-    return process.exit(0);
-  }
-  await readStdinJSON(); // drain stdin (may be empty)
-
-  let block = "";
-  let count = 0;
-  try {
-    // Empty query — the gateway returns the user's profile snapshot.
-    // Shape: { profile: {explicit_info, implicit_traits, ...} }
-    const ctx = await getContext("", { topK: TOP_K });
-    block = renderProfileBlock(ctx?.profile);
-    count = profileItemCount(ctx?.profile);
-  } catch (err) {
-    debug("start", "context failed:", redactError(err?.message));
-    return process.exit(0);
-  }
-  if (!block || count === 0) {
-    debug("start", "no context");
-    return process.exit(0);
-  }
-
-  const out = {
-    systemMessage: `🧠 EverMe loaded ${count} memory ${count === 1 ? "item" : "items"} from past sessions`,
-    hookSpecificOutput: {
-      hookEventName: "SessionStart",
-      additionalContext: block,
-    },
-  };
-  process.stdout.write(JSON.stringify(out));
-  process.exit(0);
-}
-
-async function readStdinJSON() {
-  const chunks = [];
-  for await (const c of process.stdin) chunks.push(c);
-  const raw = Buffer.concat(chunks).toString("utf8");
-  if (!raw) return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-
-main();
+runClaudeCodeHook("SessionStart");

package/hooks/scripts/session-summary.js

@@ -1,24 +1,8 @@
 #!/usr/bin/env node
-/**
- * SessionEnd hook — no runtime persistence here.
- *
- * Claude Code runtime memory is written turn-by-turn by the Stop hook through
- * /mem/agent-memory. SessionEnd must not upload a markdown summary to
- * /mem/sources, otherwise long-lived sessions create document sources.
- *
- * Hook contract:
- *   stdin  = JSON { transcript_path, session_id, cwd, ... }
- *   stdout = empty (no UI surface needed)
- */
 
 process.on("uncaughtException", () => process.exit(0));
 process.on("unhandledRejection", () => process.exit(0));
 
-import { debug } from "./lib/redact.js";
+import { runClaudeCodeHook } from "./lib/run-hook.js";
 
-async function main() {
-  debug("summary", "skip: runtime persistence is handled by Stop via /mem/agent-memory");
-  process.exit(0);
-}
-
-main();
+runClaudeCodeHook("SessionEnd");

package/hooks/scripts/store-memories.js

@@ -1,122 +1,8 @@
 #!/usr/bin/env node
-/**
- * Stop hook — fires after Claude finishes responding to a turn.
- * We read the transcript JSONL Claude Code wrote, extract the
- * just-completed raw turn, and POST it through the realtime gateway
- * (/mem/agent-memory). Runtime turns must not create /mem/sources.
- *
- * Hook contract (from Claude Code):
- *   stdin  = JSON { transcript_path, cwd, session_id, ... }
- *   stdout = empty (no need to surface anything to the user)
- *
- * Failure-mode: silent exit 0 — host must NEVER notice memory
- * persistence is broken. The gateway has its own retry loop on the
- * worker side, so a single dropped Stop event isn't catastrophic.
- */
 
 process.on("uncaughtException", () => process.exit(0));
 process.on("unhandledRejection", () => process.exit(0));
 
-import { isConfigured, getConfig } from "./lib/config.js";
-import {
-  saveAgentMemory,
-  EvermeError,
-} from "./lib/api.js";
-import { AGENT_MEMORY_ROLES } from "@everme/agent-sdk";
-import { readTranscript, extractAgentMessages } from "./lib/transcript.js";
-import { redactError, debug } from "./lib/redact.js";
+import { runClaudeCodeHook } from "./lib/run-hook.js";
 
-const MIN_MESSAGES = 1;
-
-async function main() {
-  if (!isConfigured()) {
-    debug("store", "skip: not configured");
-    return process.exit(0);
-  }
-  const cfg = getConfig();
-  if (cfg.authMode !== "evt" || !cfg.agentId) {
-    debug("store", "skip: realtime agent memory requires EVERME_AGENT_TOKEN + EVERME_AGENT_ID");
-    return process.exit(0);
-  }
-  const data = await readStdinJSON();
-  const transcriptPath = data?.transcript_path;
-  const sessionId = data?.session_id || "claude-code-session";
-  if (!transcriptPath) {
-    debug("store", "skip: no transcript_path");
-    return process.exit(0);
-  }
-
-  const lines = await readTranscript(transcriptPath);
-  const messages = extractAgentMessages(lines);
-  // Only persist the LAST user/assistant pair from this Stop event so
-  // we don't re-upload the entire history every turn — backend chains
-  // versions per documentKey, so each call appends.
-  const tail = lastTurn(messages);
-  if (tail.length < MIN_MESSAGES) {
-    debug("store", `skip: tail < ${MIN_MESSAGES} messages (got ${tail.length})`);
-    return process.exit(0);
-  }
-
-  try {
-    // Stop is the natural session-end signal for Claude Code; flush
-    // so EverOS extracts episodes/profiles instead of letting
-    // raw_messages accumulate indefinitely.
-    const res = await saveAgentMemory({
-      conversationId: sessionId,
-      messages: tail,
-      flush: true,
-    });
-    debug("store", `ok agent-memory status=${res?.status || "unknown"} flushed=${!!res?.flushed} messages=${res?.messageCount || tail.length}`);
-  } catch (err) {
-    // Visible single-line WARN — Stop hook is non-blocking by design,
-    // but silently dropping every turn means a misconfigured machine
-    // looks healthy while EverMe never receives a write. Surface
-    // it once per Stop so persistent issues (401, network, schema
-    // drift) bubble up without forcing EVERME_DEBUG=1.
-    let reason;
-    if (err instanceof EvermeError) {
-      reason = `${err.type}: ${redactError(err.message)}`;
-      debug("store", `failed type=${err.type}:`, redactError(err.message));
-    } else {
-      reason = redactError(err?.message || String(err));
-      debug("store", "unexpected:", reason);
-    }
-    process.stderr.write(`EverMe store hook degraded: ${reason}\n`);
-  }
-  process.exit(0);
-}
-
-/**
- * Take the latest user prompt + assistant reply pair (plus any
- * tool/tool_result events that fall between them). The gateway's
- * realtime write API receives only this delta — uploading the whole
- * history would duplicate memories on every turn.
- */
-function lastTurn(messages) {
-  if (messages.length === 0) return [];
-  // Walk backwards: take everything from the last `user` event
-  // through the end. That captures user → tool... → assistant flow.
-  let startIdx = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === AGENT_MEMORY_ROLES.USER) {
-      startIdx = i;
-      break;
-    }
-  }
-  if (startIdx === -1) return messages;
-  return messages.slice(startIdx);
-}
-
-async function readStdinJSON() {
-  const chunks = [];
-  for await (const c of process.stdin) chunks.push(c);
-  const raw = Buffer.concat(chunks).toString("utf8");
-  if (!raw) return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-
-main();
+runClaudeCodeHook("Stop");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everme/claude-code",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "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.3.4"
+    "@everme/agent-sdk": "^0.4.0"
   },
   "keywords": [
     "evermind",

package/hooks/scripts/lib/api.js

@@ -1,54 +0,0 @@
-/**
- * Thin wrapper around `@everme/agent-sdk` for the Claude Code hooks.
- *
- * Why this file still exists:
- *   - The hooks call `searchMemories(query, { topK })` / `getContext` /
- *     `saveAgentMemory` against an SDK-managed client created from our config.
- *     Centralising the client construction here keeps each hook script short.
- *   - Re-exports keep the rest of the codebase (and tests) stable —
- *     a future SDK rename would only land here.
- */
-
-import {
-  createClient,
-  searchMemory as sdkSearchMemory,
-  saveAgentMemory as sdkSaveAgentMemory,
-  EvermeError,
-} from "@everme/agent-sdk";
-import { getConfig } from "./config.js";
-
-let _client = null;
-
-function getClient() {
-  if (_client) return _client;
-  _client = createClient(getConfig());
-  return _client;
-}
-
-export async function searchMemories(query, opts = {}) {
-  // agent is bound from the MemAuth token; no agentId in the body.
-  return sdkSearchMemory(getClient(), { query, ...opts });
-}
-
-/**
- * Direct POST /mem/context that returns the gateway's raw shape
- * {profile, cachedAt, generatedAt}. The hooks render `profile`
- * themselves (see inject-memories.js / session-start.js's
- * renderProfileBlock). The SDK's `getContext` is too opinionated for
- * our needs (it extracts a server-rendered .context string the
- * gateway doesn't currently produce), so we bypass it and call the
- * client directly.
- *
- * Body is `{ forceRefresh: bool }` only — the agent is bound from
- * the MemAuth token, so `query`/`topK` are no longer forwarded.
- */
-export async function getContext(_query, opts = {}) {
-  const body = opts.forceRefresh ? { forceRefresh: true } : {};
-  return getClient().request("POST", "/mem/context", body);
-}
-
-export async function saveAgentMemory(req, log) {
-  return sdkSaveAgentMemory(getClient(), req, log);
-}
-
-export { EvermeError };

package/hooks/scripts/lib/profile.js

@@ -1,75 +0,0 @@
-/**
- * Renderers for the gateway's /mem/context profile snapshot.
- *
- * Profile shape (from EverMe gateway):
- *   { explicit_info: [{ category, description, evidence?, sources?[] }],
- *     implicit_traits: [{ trait, description, basis?, evidence? }],
- *     scenario, memcell_count, ... }
- *
- * `renderProfileBlock` is shared by:
- *   - SessionStart hook (kicks off the conversation with a snapshot)
- *   - UserPromptSubmit hook (fallback when search comes up empty)
- *
- * Centralising here so a tweak — wider truncation, extra fields, an
- * empty-state message — lands once instead of drifting between two
- * copies. The previous setup duplicated the whole function and we'd
- * already accumulated minor divergences (truncation lengths matched
- * but the function-name comments did not).
- */
-
-/**
- * Render `profile` into a markdown block wrapped in <everme_profile>.
- * Returns "" when there's nothing to show — callers skip injection in
- * that case.
- */
-export function renderProfileBlock(profile) {
-  if (!profile) return "";
-  const explicit = Array.isArray(profile.explicit_info) ? profile.explicit_info : [];
-  const implicit = Array.isArray(profile.implicit_traits) ? profile.implicit_traits : [];
-  if (explicit.length === 0 && implicit.length === 0) return "";
-
-  const lines = ["<everme_profile>"];
-  if (explicit.length > 0) {
-    lines.push("Profile facts:");
-    for (const e of explicit.slice(0, 12)) {
-      const cat = e.category ? `[${e.category}] ` : "";
-      const desc = e.description || e.evidence || "";
-      if (!desc) continue;
-      lines.push(`- ${cat}${truncate(desc, 240)}`);
-    }
-  }
-  if (implicit.length > 0) {
-    lines.push("Implicit traits:");
-    for (const t of implicit.slice(0, 6)) {
-      const name = t.trait || t.name || "trait";
-      const desc = t.description || "";
-      lines.push(`- ${name}: ${truncate(desc, 200)}`);
-    }
-  }
-  lines.push("</everme_profile>");
-  return lines.join("\n");
-}
-
-/**
- * Number of items the gateway included in this profile — used by the
- * hook output's `systemMessage` ("loaded N items"). Counts both the
- * explicit and implicit lists; matches what renderProfileBlock will
- * surface (modulo per-list truncation, which is fine for a count).
- */
-export function profileItemCount(profile) {
-  if (!profile) return 0;
-  return (
-    (Array.isArray(profile.explicit_info) ? profile.explicit_info.length : 0) +
-    (Array.isArray(profile.implicit_traits) ? profile.implicit_traits.length : 0)
-  );
-}
-
-/**
- * One-line truncation: collapse whitespace, cap to `n` chars, append
- * ellipsis. Both block renderers use the same shape so the output is
- * visually consistent across SessionStart and UserPromptSubmit.
- */
-export function truncate(s, n) {
-  s = String(s).replace(/\s+/g, " ").trim();
-  return s.length <= n ? s : s.slice(0, n - 1) + "…";
-}

package/hooks/scripts/lib/redact.js

@@ -1,43 +0,0 @@
-/**
- * Re-exports the SDK's redactError so hook scripts have a single
- * import target. `debug` is plugin-local because it formats output
- * with the [everme:<prefix>] tag specific to Claude Code stderr.
- */
-
-import { redactError } from "@everme/agent-sdk";
-
-export { redactError };
-
-const DEBUG = process.env.EVERME_DEBUG === "1";
-
-/**
- * Synchronous stderr trace, gated on EVERME_DEBUG=1. Earlier revisions
- * dynamic-imported `redactError` here to "guard against tests mocking
- * the SDK at module-load time" — but the static export above already
- * load-fails in that scenario, AND the dynamic import is async, so
- * any line written after `process.exit(0)` was silently dropped. Using
- * the static `redactError` makes debug logging actually appear.
- */
-export function debug(prefix, ...args) {
-  if (!DEBUG) return;
-  try {
-    process.stderr.write(
-      `[everme:${prefix}] ` +
-        args
-          .map((a) => (typeof a === "string" ? a : safeStringify(a)))
-          .map(redactError)
-          .join(" ") +
-        "\n",
-    );
-  } catch {
-    /* never throw from debug */
-  }
-}
-
-function safeStringify(v) {
-  try {
-    return JSON.stringify(v);
-  } catch {
-    return String(v);
-  }
-}