@everme/claude-code 0.1.0 → 0.3.1

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

package/{plugin.json → .claude-plugin/plugin.json}

@@ -1,12 +1,18 @@
 {
   "name": "everme",
-  "version": "0.1.0",
+  "version": "0.3.1",
   "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",
     "url": "https://everme.evermind.ai"
   },
   "homepage": "https://everme.evermind.ai",
-  "keywords": ["memory", "context", "recall", "persistence", "everme"],
+  "keywords": [
+    "memory",
+    "context",
+    "recall",
+    "persistence",
+    "everme"
+  ],
   "license": "Apache-2.0"
 }

package/README.md

@@ -43,7 +43,7 @@ The installer:
 
 ```bash
 export EVERME_API_KEY="emk_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"   # from EverMe Web UI
-export EVERME_API_BASE="http://localhost:8080"                  # optional — defaults to everme.evermind.ai
+export EVERME_API_BASE="http://localhost:8080"                  # optional — defaults to api.everme.evermind.ai
 claude plugin install /path/to/everme/plugins/claude-code
 ```
 
@@ -54,7 +54,7 @@ claude plugin install /path/to/everme/plugins/claude-code
 | `EVERME_API_KEY` | Account-level emk. Supports recall-only mode. |
 | `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://everme.evermind.ai`. Set to `http://localhost:8080` for local dev. |
+| `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). |
 
 ## Verifying the install
@@ -76,9 +76,9 @@ In a new Claude Code session:
 ## Files
 
 ```
-plugin.json                          plugin metadata
-.claude-plugin/.mcp.json             MCP server registration
+.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/scripts/inject-memories.js     UserPromptSubmit handler
 hooks/scripts/store-memories.js      Stop handler

package/commands/everme-help.md

@@ -11,7 +11,7 @@ EverMe for Claude Code
 ─────────────────────
 Auth:      EVERME_API_KEY  (account emk_*) — recall-only mode
            EVERME_AGENT_TOKEN + EVERME_AGENT_ID — required for realtime writes
-Gateway:   EVERME_API_BASE — defaults to https://everme.evermind.ai
+Gateway:   EVERME_API_BASE — defaults to https://api.everme.evermind.ai
 
 Hooks:
   SessionStart      → loads recent context from past sessions

package/hooks/scripts/inject-memories.js

@@ -48,6 +48,7 @@ async function main() {
   // where there is no prompt, but per-turn inject goes through search.
   let block = "";
   let count = 0;
+  let degraded = null;
   try {
     const res = await searchMemories(prompt, { topK: TOP_K });
     // EverOS frequently returns score=null on episodic hits (decoded as
@@ -77,11 +78,22 @@ async function main() {
     const inner = buildMemoryPrompt(bundle, { wrapInCodeBlock: false });
     if (inner) block = `<everme_recall>\n${inner}\n</everme_recall>`;
   } catch (err) {
-    debug("inject", "search failed:", redactError(err?.message));
+    const reason = redactError(err?.message || String(err));
+    degraded = reason;
+    debug("inject", "search failed:", reason);
   }
 
   if (!block || count === 0) {
-    debug("inject", "no memories above threshold");
+    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);
   }
 

package/hooks/scripts/lib/config.js

@@ -14,7 +14,7 @@
  *   users may legitimately want to override these from a shell or from
  *   Claude Code's mcp .env block, and evercli does not own them.
  *
- *   Compiled defaults (everme.evermind.ai, no token) sit at the bottom.
+ *   Compiled defaults (api.everme.evermind.ai, no token) sit at the bottom.
  *
  * Auth modes (mutually exclusive, both wire-compatible):
  *   evt — set EVERME_AGENT_TOKEN (per-machine token from evercli)

package/hooks/scripts/lib/transcript.js

@@ -36,7 +36,23 @@ const RETRY_DELAY_MS = 100;
 export async function readTranscript(path) {
   if (!path || !existsSync(path)) return [];
   for (let i = 0; i < READ_RETRIES; i++) {
-    const raw = await readFile(path, "utf8");
+    // readFile errors must NOT escape this function. The Stop hook
+    // installs a process-wide unhandledRejection handler that exits 0
+    // silently — an ENOENT here (the transcript file was rotated /
+    // removed mid-read) used to fall into that catch-all and the
+    // entire Stop write was silently dropped. Treating ENOENT as
+    // "transient, retry" and other fs errors as "give up, return []"
+    // surfaces the right signal: zero lines means no Stop work to do.
+    let raw;
+    try {
+      raw = await readFile(path, "utf8");
+    } catch (err) {
+      if (err?.code === "ENOENT" && i < READ_RETRIES - 1) {
+        await sleep(RETRY_DELAY_MS);
+        continue;
+      }
+      return [];
+    }
     const lines = raw.trim().split("\n").filter(Boolean);
     if (lines.length === 0) {
       await sleep(RETRY_DELAY_MS);
@@ -127,27 +143,80 @@ export function extractAgentMessages(lines) {
       continue;
     }
     const timestamp = normalizeTimestamp(ev.timestamp);
-    if (ev.role === AGENT_MEMORY_ROLES.USER) {
-      const content = textFromContent(ev.content);
-      if (content) messages.push({ role: AGENT_MEMORY_ROLES.USER, timestamp, content });
+    // Real Claude Code transcript schema is nested: each line is
+    //   { "type":"user"|"assistant", "message":{role, content}, ... }
+    // with content.string OR content[]={text|thinking|tool_use|tool_result}.
+    // Tool results live INSIDE a user-role envelope (with content[].type=tool_result
+    // carrying tool_use_id). The legacy flat-shape fixture (top-level
+    // ev.role + ev.content) is accepted as a fallback so existing tests
+    // and any external producers keep working.
+    const inner = ev.message && typeof ev.message === "object" ? ev.message : null;
+    const role = inner?.role ?? ev.role;
+    const rawContent = inner?.content ?? ev.content;
+
+    if (role === AGENT_MEMORY_ROLES.USER) {
+      // Split the user envelope: tool_result blocks become role=tool
+      // messages (with their own toolCallId), free text becomes a
+      // role=user message. A single CC user event can therefore emit
+      // 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 });
       continue;
     }
-    if (ev.role === AGENT_MEMORY_ROLES.ASSISTANT) {
-      const msg = agentAssistantMessage(ev.content, timestamp);
+    if (role === AGENT_MEMORY_ROLES.ASSISTANT) {
+      const msg = agentAssistantMessage(rawContent, timestamp);
       if (msg) messages.push(msg);
       continue;
     }
-    if (ev.role === AGENT_MEMORY_ROLES.TOOL || ev.type === "tool_result") {
+    // Legacy flat tool-role fallback: { role:"tool", content, toolCallId }
+    if (role === AGENT_MEMORY_ROLES.TOOL || ev.type === "tool_result") {
       const toolCallId = ev.toolCallId || ev.tool_call_id || ev.tool_use_id;
       if (!toolCallId) continue;
       const content =
-        typeof ev.content === "string" ? ev.content : safeJsonStringify(ev.content);
+        typeof rawContent === "string" ? rawContent : safeJsonStringify(rawContent);
       messages.push({ role: AGENT_MEMORY_ROLES.TOOL, timestamp, toolCallId, content });
     }
   }
   return messages;
 }
 
+// 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
+// envelope (not a separate top-level event), so without this step the
+// entire tool round-trip is lost.
+function extractToolResults(content, timestamp) {
+  if (!Array.isArray(content)) return [];
+  const out = [];
+  for (const b of content) {
+    if (!b || typeof b !== "object") continue;
+    if (b.type !== "tool_result") continue;
+    const toolCallId = b.tool_use_id || b.toolCallId || b.tool_call_id;
+    if (!toolCallId) continue;
+    let text;
+    if (typeof b.content === "string") {
+      text = b.content;
+    } else if (Array.isArray(b.content)) {
+      // tool_result.content can itself be a list of typed blocks (e.g.
+      // [{type:"text", text:...}]) — flatten the text-bearing ones.
+      text = b.content
+        .map((c) => {
+          if (typeof c === "string") return c;
+          if (c?.type === "text" && typeof c.text === "string") return c.text;
+          return "";
+        })
+        .filter(Boolean)
+        .join("\n");
+    } else {
+      text = safeJsonStringify(b.content);
+    }
+    out.push({ role: AGENT_MEMORY_ROLES.TOOL, timestamp, toolCallId, content: text });
+  }
+  return out;
+}
+
 function agentAssistantMessage(content, timestamp) {
   if (typeof content === "string") {
     return content ? { role: AGENT_MEMORY_ROLES.ASSISTANT, timestamp, content } : null;

package/hooks/scripts/mcp-server.js

@@ -17,10 +17,25 @@
  */
 
 import { createInterface } from "readline";
+import { createRequire } from "node:module";
 import { searchMemories, getContext, EvermeError } from "./lib/api.js";
 import { isConfigured } from "./lib/config.js";
 import { redactError, debug } from "./lib/redact.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
+// hooks/scripts/mcp-server.js, package.json is three levels up.
+const { version: PKG_VERSION } = createRequire(import.meta.url)("../../../package.json");
+
+// Protocol versions this hand-rolled server knows about. Clients that
+// announce one of these in `initialize` get their version echoed back
+// (per MCP spec the server SHOULD agree to the client's version when
+// supported); anything else falls back to the newest we support so the
+// session can still establish. Prior code hard-coded "2024-11-05" while
+// 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";
+
 const TOOLS = [
   {
     name: "everme_search",
@@ -50,11 +65,17 @@ const TOOLS = [
 ];
 
 const handlers = {
-  initialize: () => ({
-    protocolVersion: "2024-11-05",
-    capabilities: { tools: { listChanged: false } },
-    serverInfo: { name: "everme", version: "0.1.0" },
-  }),
+  initialize: (params) => {
+    const requested = typeof params?.protocolVersion === "string" ? params.protocolVersion : "";
+    const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.has(requested)
+      ? requested
+      : LATEST_PROTOCOL_VERSION;
+    return {
+      protocolVersion,
+      capabilities: { tools: { listChanged: false } },
+      serverInfo: { name: "everme", version: PKG_VERSION },
+    };
+  },
   "tools/list": () => ({ tools: TOOLS }),
   "tools/call": async (params) => {
     const name = params?.name;

package/hooks/scripts/store-memories.js

@@ -68,11 +68,20 @@ async function main() {
     });
     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 {
-      debug("store", "unexpected:", redactError(err?.message || String(err)));
+      reason = redactError(err?.message || String(err));
+      debug("store", "unexpected:", reason);
     }
+    process.stderr.write(`EverMe store hook degraded: ${reason}\n`);
   }
   process.exit(0);
 }

package/install.sh

@@ -93,7 +93,7 @@ elif [ -f "$ENV_FILE" ]; then
     echo -e "${GREEN}✓${NC} Existing $ENV_FILE detected — leaving credentials as-is"
 fi
 
-# Optional API base override (default https://everme.evermind.ai).
+# Optional API base override (default https://api.everme.evermind.ai).
 if [ -n "${EVERME_API_BASE:-}" ]; then
     echo -e "${GREEN}✓${NC} Using EVERME_API_BASE=$EVERME_API_BASE"
 fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everme/claude-code",
-  "version": "0.1.0",
+  "version": "0.3.1",
   "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",
@@ -8,11 +8,11 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "test": "node --test tests/redact.test.js tests/config.test.js tests/transcript.test.js"
+    "test": "node --test tests/redact.test.js tests/config.test.js tests/transcript.test.js tests/hooks.test.js"
   },
   "files": [
-    "plugin.json",
     ".claude-plugin/",
+    ".mcp.json",
     "hooks/",
     "commands/",
     "skills/",
@@ -21,17 +21,27 @@
     "README.md"
   ],
   "dependencies": {
-    "@everme/agent-sdk": "^0.1.0"
+    "@everme/agent-sdk": "^0.3.1"
   },
-  "keywords": ["evermind", "everme", "claude-code", "claude", "anthropic", "memory", "ai", "agent", "mcp"],
-  "homepage": "https://everme.ai",
+  "keywords": [
+    "evermind",
+    "everme",
+    "claude-code",
+    "claude",
+    "anthropic",
+    "memory",
+    "ai",
+    "agent",
+    "mcp"
+  ],
+  "homepage": "https://everme.evermind.ai",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/alwaysday1/everme.git",
+    "url": "git+https://github.com/EverMind-AI/EverMe-CLI.git",
     "directory": "plugins/claude-code"
   },
   "bugs": {
-    "url": "https://github.com/alwaysday1/everme/issues"
+    "url": "https://github.com/EverMind-AI/EverMe-CLI/issues"
   },
   "publishConfig": {
     "access": "public",

package/hooks/scripts/lib/source-key.js

@@ -1,54 +0,0 @@
-/**
- * Stable per-machine source key for documentKey derivation.
- *
- * The hooks pass this into `buildDocumentKey(sourceKey, logicalPath)`
- * to anchor a version chain. In evt mode the agentId (`agt_…`) is
- * unique per machine + user + platform, so it works as the source key
- * unmodified. In emk mode the user has no agentId, so the previous
- * code fell back to the literal `"agt_claude_code"` — which means
- * every user on every machine sharing the same EverMe account would
- * write into the SAME version chain, overwriting each other's runtime
- * docs.
- *
- * This module computes a stable replacement: `claude-code:<host>:<user>`,
- * SHA256-truncated to a 24-hex prefix. Same machine + user → same
- * key across processes and reboots; two machines under one account →
- * two distinct chains.
- */
-
-import { createHash } from "node:crypto";
-import { hostname, userInfo } from "node:os";
-
-let cached = null;
-
-/**
- * Returns the source key the runtime hooks should pass into
- * buildDocumentKey. Honours `cfg.agentId` (evt mode) when present —
- * agentId is already the canonical per-machine fingerprint that
- * evercli writes — and falls back to a hashed host+user string when
- * the user is on emk auth.
- */
-export function getSourceKey(cfg) {
-  if (cfg?.agentId) return cfg.agentId;
-  if (cached) return cached;
-  let host = "unknown-host";
-  let user = "unknown-user";
-  try {
-    host = hostname() || host;
-  } catch {
-    /* fall through */
-  }
-  try {
-    user = userInfo().username || user;
-  } catch {
-    /* fall through */
-  }
-  const sum = createHash("sha256").update(`claude-code:${host}:${user}`).digest("hex");
-  cached = "agt_emk_" + sum.slice(0, 24);
-  return cached;
-}
-
-/** Test seam — wipes the per-process cache. */
-export function _reset() {
-  cached = null;
-}