@echomem/mcp 1.4.6 → 1.4.8

package/dist/v1-contract.js

@@ -5,13 +5,18 @@ export const canonicalToolNames = {
     save: "save_conversation",
     timeRange: "get_memories_by_time_range",
     keywords: "search_memories_by_keywords",
+    friends: "list_friends",
+    searchUsers: "search_users",
+    sendFriendRequest: "send_friend_request",
     others: "search_others_memories",
+    publicMemory: "get_public_memory",
     report: "echomem_usage_report",
     updateStatus: "echomem_update_status",
     contextHealth: "echo_context_health",
     recompose: "echo_recompose",
     delete: "delete_memory",
     getByContext: "get_memories_by_context",
+    checkpointByContext: "get_checkpoint_by_context",
 };
 export const legacyAliasToCanonical = {
     search_memories_by_description_semantic: canonicalToolNames.search,
@@ -59,9 +64,35 @@ export const keywordsSchema = z.object({
     keywords: z.array(z.string()),
     limit: z.number().optional().default(10),
 });
+export const listFriendsSchema = z.object({
+    ...triggerMetadataSchema,
+});
+export const searchUsersSchema = z.object({
+    ...triggerMetadataSchema,
+    query: z.string().min(1),
+    limit: z.number().optional().default(10),
+});
+export const sendFriendRequestSchema = z.object({
+    ...triggerMetadataSchema,
+    targetUserId: z.string().min(1),
+});
 export const othersSchema = z.object({
     ...triggerMetadataSchema,
-    query: z.string(),
+    query: z.string().optional().default(""),
+    limit: z.number().optional().default(10),
+    target: z.string().optional(),
+    ownerUserId: z.string().optional(),
+    ownerName: z.string().optional(),
+    targetFriendIds: z.array(z.string()).optional(),
+    targetFriendNames: z.array(z.string()).optional(),
+    recordAccess: z.boolean().optional(),
+    kPerUser: z.number().optional(),
+    similarityThreshold: z.number().optional(),
+    timeFrameDays: z.number().optional(),
+});
+export const publicMemorySchema = z.object({
+    ...triggerMetadataSchema,
+    memoryId: z.string().min(1),
 });
 export const deleteMemorySchema = z.object({
     memoryId: z.string().min(1),
@@ -84,7 +115,7 @@ export function listToolSpecs(opts = {}) {
     return [
         {
             name: canonicalToolNames.search,
-            description: withMcpVersion(`Recall the user's prior decisions, preferences, constraints, and project context from EchoMem — their long-term memory across ALL their AI tools (Claude.ai, ChatGPT, other agents), not just this session.${mapSection}\nCall this when the task plausibly relates to that remembered context — a topic above, or when the user refers to past work ("what did we decide", "like before", "the usual") — so you don't re-derive or re-ask what they already settled. Skip it for self-contained tasks with no link to their history (e.g. a generic algorithm question). By default this returns only the ranked memories retrieved for recall and skips EchoMem answer generation; set includeAnswer=true only when you explicitly need EchoMem's legacy synthesized recall. Current time: ${currentTime}.${updateSection}`),
+            description: withMcpVersion(`Recall the user's prior decisions, preferences, and project context from EchoMem — their long-term memory across ALL their AI tools, not just this session. Use it instead of re-deriving or re-asking what the user already settled.${mapSection}\nReturns the ranked memories; set includeAnswer=true only if you need the legacy synthesized answer. Current time: ${currentTime}.${updateSection}`),
             inputSchema: {
                 type: "object",
                 properties: {
@@ -130,7 +161,7 @@ export function listToolSpecs(opts = {}) {
         },
         {
             name: canonicalToolNames.save,
-            description: "Save conversation into EchoMem for future retrieval. Set passthrough=true to store the text verbatim as a session capsule (no LLM extraction, no embeddings) — use this for warm-up capsules that a fresh session will reload via get_memories_by_context.",
+            description: "Save this conversation into EchoMem as long-term memory (durable memories are extracted automatically). passthrough=true stores the text verbatim as a session capsule instead — reload it later via get_memories_by_context.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -196,20 +227,121 @@ export function listToolSpecs(opts = {}) {
                 required: ["keywords"],
             },
         },
+        {
+            name: canonicalToolNames.friends,
+            description: "Friends: list accepted EchoMem friends with each friend's public memory count. Use this before asking a specific friend by name.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    triggerMessage: {
+                        type: "string",
+                        description: "Optional: the user's message that caused this friend-list lookup. EchoMem stores only a redacted analytics preview and hash.",
+                    },
+                    triggerMessageRole: { type: "string", default: "user" },
+                },
+            },
+        },
+        {
+            name: canonicalToolNames.searchUsers,
+            description: "Search EchoMem users by display name/username before sending a friend request. Results include total memories, public memories, and current relationship state.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Name or username fragment to search, e.g. Kobe.",
+                    },
+                    limit: { type: "number", default: 10 },
+                    triggerMessage: {
+                        type: "string",
+                        description: "Optional: the user's message that caused this user search. EchoMem stores only a redacted analytics preview and hash.",
+                    },
+                    triggerMessageRole: { type: "string", default: "user" },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: canonicalToolNames.sendFriendRequest,
+            description: "Send a pending EchoMem friend request to an exact user id returned by search_users. The other user must approve before friend-gated memory access is allowed.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    targetUserId: {
+                        type: "string",
+                        description: "Exact target user id from search_users.",
+                    },
+                    triggerMessage: {
+                        type: "string",
+                        description: "Optional: the user's message that caused this friend request. EchoMem stores only a redacted analytics preview and hash.",
+                    },
+                    triggerMessageRole: { type: "string", default: "user" },
+                },
+                required: ["targetUserId"],
+            },
+        },
         {
             name: canonicalToolNames.others,
-            description: "Search other users' public memories.",
+            description: "Search accepted friends' public memories. Returned memories are recorded in the existing memory_views pipeline for the memory owners.",
             inputSchema: {
                 type: "object",
                 properties: {
                     query: { type: "string" },
+                    limit: { type: "number", default: 10 },
+                    target: {
+                        type: "string",
+                        description: "Accepted-friend user id or exact display name/username. Prefer this for @Name asks.",
+                    },
+                    ownerUserId: {
+                        type: "string",
+                        description: "Optional accepted-friend user id to scope the search to one friend.",
+                    },
+                    ownerName: {
+                        type: "string",
+                        description: "Optional accepted-friend display name/username to scope the search to one friend.",
+                    },
+                    targetFriendIds: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional accepted-friend user ids to scope the search.",
+                    },
+                    targetFriendNames: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional accepted-friend display names/usernames to scope the search.",
+                    },
+                    recordAccess: {
+                        type: "boolean",
+                        description: "Defaults true. When true, returned public memories are recorded in memory_views.",
+                    },
+                    kPerUser: { type: "number", default: 5 },
+                    similarityThreshold: { type: "number", default: 0.1 },
+                    timeFrameDays: { type: "number" },
                     triggerMessage: {
                         type: "string",
                         description: "Optional: the user's message that caused this public-memory search. EchoMem stores only a redacted analytics preview and hash.",
                     },
                     triggerMessageRole: { type: "string", default: "user" },
                 },
-                required: ["query"],
+            },
+        },
+        {
+            name: canonicalToolNames.publicMemory,
+            description: "Fetch one accepted friend's public memory by id. If the caller is not the owner, EchoMem records the access in the existing memory_views pipeline.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    memoryId: {
+                        type: "string",
+                        description: "The public memory id to fetch.",
+                    },
+                    triggerMessage: {
+                        type: "string",
+                        description: "Optional: the user's message that caused this public-memory fetch. EchoMem stores only a redacted analytics preview and hash.",
+                    },
+                    triggerMessageRole: { type: "string", default: "user" },
+                },
+                required: ["memoryId"],
             },
         },
         {
@@ -252,6 +384,23 @@ export function listToolSpecs(opts = {}) {
                 required: ["contextId"],
             },
         },
+        {
+            name: canonicalToolNames.checkpointByContext,
+            description: withMcpVersion(`Rebuild a clean-context checkpoint / decision log from one EchoMem contextId. Use this when the user or EchoMem HUD gives you a contextId for a renewed coding session and you need the session handoff, not a raw memory dump. It deterministically fetches that context and formats it as orientation state: decisions, carryover, constraints, and checkpoints. Current time: ${currentTime}.`),
+            inputSchema: {
+                type: "object",
+                properties: {
+                    contextId: { type: "string", description: "The EchoMem contextId shown by the HUD or returned by save_conversation / Renew session." },
+                    limit: { type: "number", default: 100 },
+                    triggerMessage: {
+                        type: "string",
+                        description: "Optional: the user's message that caused this lookup. EchoMem stores only a redacted analytics preview and hash.",
+                    },
+                    triggerMessageRole: { type: "string", default: "user" },
+                },
+                required: ["contextId"],
+            },
+        },
         {
             name: canonicalToolNames.report,
             description: "Show the user a one-screen audit of THEIR OWN AI coding usage — computed locally from their Codex/Claude Code logs ($0, nothing uploaded): how many tokens their agents spent, how much was re-reading context, reads vs memory recalls, and what changes with EchoMem. Call this when the user asks about their usage, token spend, cost, how much they're wasting, or wants a summary of their agent activity — and you may offer it once right after EchoMem is first connected. Returns formatted text to show the user verbatim. Needs no login.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@echomem/mcp",
-  "version": "1.4.6",
+  "version": "1.4.8",
   "description": "EchoMem Cloud-First MCP Server",
   "main": "dist/index.js",
   "type": "module",
@@ -20,7 +20,8 @@
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts",
     "smoke": "node smoke.mjs",
-    "test": "npm run build && node test/crypto.test.mjs && node test/integration.test.mjs && node test/no-restart.test.mjs && node test/report.test.mjs && node test/tools.test.mjs && node test/update-check.test.mjs && node test/delete.test.mjs && node test/migrate.test.mjs && node test/hud.test.mjs",
+    "preview:extraction": "npm run build && node scripts/preview-extraction.mjs",
+    "test": "npm run build && node test/crypto.test.mjs && node test/integration.test.mjs && node test/no-restart.test.mjs && node test/report.test.mjs && node test/tools.test.mjs && node test/update-check.test.mjs && node test/delete.test.mjs && node test/low-touch-tools.test.mjs && node test/migrate.test.mjs && node test/hud.test.mjs",
     "prepack": "npm run build && node scripts/bundle-city.mjs"
   },
   "dependencies": {