@echomem/mcp 1.4.21 → 1.4.23

package/dist/v1-contract.js

@@ -10,6 +10,14 @@ export const canonicalToolNames = {
     sendFriendRequest: "send_friend_request",
     others: "search_others_memories",
     publicMemory: "get_public_memory",
+    groupContext: "get_group_context",
+    createGroup: "create_memory_group",
+    createGroupInvite: "create_group_invite",
+    joinGroup: "join_memory_group",
+    prepareGroupPublication: "prepare_group_publication",
+    completeGroupPublication: "complete_group_publication",
+    publishToGroup: "publish_memory_to_group",
+    publishBatchToGroup: "publish_memories_to_group",
     report: "echomem_usage_report",
     updateStatus: "echomem_update_status",
     contextHealth: "echo_context_health",
@@ -59,9 +67,17 @@ export const timeRangeSchema = z.object({
     endDate: z.string(),
     limit: z.number().optional().default(50),
 });
+const keywordListSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    return value
+        .split(",")
+        .map((keyword) => keyword.trim())
+        .filter(Boolean);
+}, z.array(z.string().trim().min(1)).min(1).max(50));
 export const keywordsSchema = z.object({
     ...triggerMetadataSchema,
-    keywords: z.array(z.string()),
+    keywords: keywordListSchema,
     limit: z.number().optional().default(10),
 });
 export const listFriendsSchema = z.object({
@@ -94,6 +110,56 @@ export const publicMemorySchema = z.object({
     ...triggerMetadataSchema,
     memoryId: z.string().min(1),
 });
+export const groupContextSchema = z.object({
+    ...triggerMetadataSchema,
+});
+export const createGroupSchema = z.object({
+    ...triggerMetadataSchema,
+    name: z.string().min(1).max(120),
+    description: z.string().max(1000).optional(),
+    displayName: z.string().min(1).max(120),
+    title: z.string().max(160).optional(),
+    responsibilitySummary: z.string().max(1000).optional(),
+});
+export const createGroupInviteSchema = z.object({
+    ...triggerMetadataSchema,
+    expiresInDays: z.number().int().min(1).max(30).optional(),
+    maxUses: z.number().int().min(1).max(100).optional(),
+});
+export const joinGroupSchema = z.object({
+    ...triggerMetadataSchema,
+    code: z.string().min(30),
+    displayName: z.string().min(1).max(120),
+    title: z.string().max(160).optional(),
+    responsibilitySummary: z.string().max(1000).optional(),
+});
+export const prepareGroupPublicationSchema = z.object({
+    ...triggerMetadataSchema,
+    scope: z.enum(["bootstrap", "since_last_scan", "context", "time_range"]).default("since_last_scan"),
+    contextId: z.string().min(1).optional(),
+    startAt: z.string().optional(),
+    endAt: z.string().optional(),
+    lookbackDays: z.number().int().min(1).max(365).optional(),
+    limit: z.number().int().min(1).max(50).optional(),
+    instruction: z.string().max(500).optional(),
+});
+export const completeGroupPublicationSchema = z.object({
+    ...triggerMetadataSchema,
+    scanId: z.string().min(1),
+    memoryIds: z.array(z.string().min(1)).max(50),
+    confirmed: z.literal(true),
+    selectionReason: z.string().max(500).optional(),
+});
+export const publishToGroupSchema = z.object({
+    ...triggerMetadataSchema,
+    memoryId: z.string().min(1),
+});
+export const publishBatchToGroupSchema = z.object({
+    ...triggerMetadataSchema,
+    memoryIds: z.array(z.string().min(1)).min(1).max(50),
+    contextId: z.string().min(1).optional(),
+    selectionReason: z.string().max(500).optional(),
+});
 export const deleteMemorySchema = z.object({
     memoryId: z.string().min(1),
     confirmed: z.boolean().optional().default(false),
@@ -108,7 +174,7 @@ export function listToolSpecs(opts = {}) {
     const currentTime = new Date().toISOString();
     const map = opts.map?.trim();
     const updateNotice = opts.updateNotice?.trim();
-    const recallPlanNote = "Available on every plan: Free includes 10 searches each week, Pro includes 100, and Power includes 250.";
+    const recallPlanNote = "Available on every plan: Free includes 100 searches each week, Pro includes 500, and Power includes 2,000.";
     const searchBillingReplyInstruction = "If search returns an ACTION REQUIRED subscription message, tell the user to start their trial or subscription and include the exact URL from that result verbatim. Do not respond only with \"connect\" or \"upgrade\".";
     const updateSection = updateNotice ? `\n\nUPDATE NOTICE: ${updateNotice}` : "";
     const mapSection = map
@@ -204,11 +270,27 @@ export function listToolSpecs(opts = {}) {
         },
         {
             name: canonicalToolNames.keywords,
-            description: `Search memories based on keywords in keys field. ${recallPlanNote}`,
+            description: `Search memories based on keywords in keys field. Pass keywords as valid JSON: preferably an array of quoted strings, for example {"keywords":["flow-lab","flow.html","Rive"],"limit":8}. A comma-separated JSON string is also accepted as a compatibility fallback. Never emit bare comma-separated tokens. ${recallPlanNote}`,
             inputSchema: {
                 type: "object",
                 properties: {
-                    keywords: { type: "array", items: { type: "string" } },
+                    keywords: {
+                        oneOf: [
+                            {
+                                type: "array",
+                                minItems: 1,
+                                maxItems: 50,
+                                items: { type: "string", minLength: 1 },
+                            },
+                            {
+                                type: "string",
+                                minLength: 1,
+                                description: "Compatibility form: one comma-separated JSON string, such as \"flow-lab, flow.html, Rive\".",
+                            },
+                        ],
+                        description: "Use a JSON array of quoted strings. Do not pass unquoted comma-separated tokens.",
+                        examples: [["flow-lab", "flow.html", "Rive"]],
+                    },
                     limit: { type: "number", default: 10 },
                     triggerMessage: {
                         type: "string",
@@ -274,7 +356,7 @@ export function listToolSpecs(opts = {}) {
         },
         {
             name: canonicalToolNames.others,
-            description: "Search accepted friends' public memories. Returned memories are recorded in the existing memory_views pipeline for the memory owners.",
+            description: "Search public memories from accepted friends or people who share your company group. For onboarding and division-of-work questions, call get_group_context first, then use this tool for current evidence. Returned memories are recorded in memory_views for the owners.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -282,25 +364,25 @@ export function listToolSpecs(opts = {}) {
                     limit: { type: "number", default: 10 },
                     target: {
                         type: "string",
-                        description: "Accepted-friend user id or exact display name/username. Prefer this for @Name asks.",
+                        description: "Accessible friend or group-member user id or exact display name. Prefer this for @Name asks.",
                     },
                     ownerUserId: {
                         type: "string",
-                        description: "Optional accepted-friend user id to scope the search to one friend.",
+                        description: "Optional accessible user id to scope the search to one person.",
                     },
                     ownerName: {
                         type: "string",
-                        description: "Optional accepted-friend display name/username to scope the search to one friend.",
+                        description: "Optional accessible friend or group-member display name to scope the search.",
                     },
                     targetFriendIds: {
                         type: "array",
                         items: { type: "string" },
-                        description: "Optional accepted-friend user ids to scope the search.",
+                        description: "Legacy field for optional accessible friend or group-member user ids.",
                     },
                     targetFriendNames: {
                         type: "array",
                         items: { type: "string" },
-                        description: "Optional accepted-friend display names/usernames to scope the search.",
+                        description: "Legacy field for optional accessible friend or group-member display names.",
                     },
                     recordAccess: {
                         type: "boolean",
@@ -319,7 +401,7 @@ export function listToolSpecs(opts = {}) {
         },
         {
             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.",
+            description: "Fetch one public memory by id when its owner is an accepted friend or shares your company group. If the caller is not the owner, EchoMem records the access in memory_views.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -336,6 +418,139 @@ export function listToolSpecs(opts = {}) {
                 required: ["memoryId"],
             },
         },
+        {
+            name: canonicalToolNames.groupContext,
+            description: "Get your current company group, its participant directory, declared titles and responsibilities, and published-memory coverage. Use this before answering who works on what or suggesting where a new group member could contribute. Treat declared profile fields as facts and memory-derived work as evidence or inference.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    triggerMessage: {
+                        type: "string",
+                        description: "Optional user message that caused this group-orientation lookup.",
+                    },
+                    triggerMessageRole: { type: "string", default: "user" },
+                },
+            },
+        },
+        {
+            name: canonicalToolNames.createGroup,
+            description: "Create one company memory group for the current user. The MVP allows at most one group per user. Call only after the user explicitly asks to create a group.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    description: { type: "string" },
+                    displayName: { type: "string" },
+                    title: { type: "string" },
+                    responsibilitySummary: { type: "string" },
+                },
+                required: ["name", "displayName"],
+            },
+        },
+        {
+            name: canonicalToolNames.createGroupInvite,
+            description: "Generate a secret, expiring invite code for the current group. Only the group creator may call this in the MVP. Return the code only to the user so they can share it intentionally; never log it.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    expiresInDays: { type: "number", default: 7 },
+                    maxUses: { type: "number", default: 20 },
+                },
+            },
+        },
+        {
+            name: canonicalToolNames.joinGroup,
+            description: "Join a company memory group using an invite code after the user explicitly asks to join. Joining never publishes memories; call prepare_group_publication separately.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    code: { type: "string" },
+                    displayName: { type: "string" },
+                    title: { type: "string" },
+                    responsibilitySummary: { type: "string" },
+                },
+                required: ["code", "displayName"],
+            },
+        },
+        {
+            name: canonicalToolNames.prepareGroupPublication,
+            description: "Prepare a no-write preview of up to 50 owned memories for group publication. For encrypted accounts the local bridge must be unlocked. The host agent selects exact work-related memory ids from the returned candidates and asks the user to confirm; this tool never publishes.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    scope: { type: "string", enum: ["bootstrap", "since_last_scan", "context", "time_range"], default: "since_last_scan" },
+                    contextId: { type: "string" },
+                    startAt: { type: "string" },
+                    endAt: { type: "string" },
+                    lookbackDays: { type: "number", default: 30 },
+                    limit: { type: "number", default: 50 },
+                    instruction: { type: "string", default: "work-related" },
+                },
+            },
+        },
+        {
+            name: canonicalToolNames.completeGroupPublication,
+            description: "Publish only the exact memory ids from a prepared scan after the user explicitly confirms the preview. confirmed must be true. Completing an empty selection safely advances the scan cursor without publishing.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    scanId: { type: "string" },
+                    memoryIds: { type: "array", maxItems: 50, items: { type: "string" } },
+                    confirmed: { type: "boolean", const: true },
+                    selectionReason: { type: "string" },
+                },
+                required: ["scanId", "memoryIds", "confirmed"],
+            },
+        },
+        {
+            name: canonicalToolNames.publishToGroup,
+            description: "Publish one exact memory snapshot to your current company group without changing the memory's global is_public or encryption state. Call only after the user explicitly asks to publish or push that memory. The operation is idempotent.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    memoryId: {
+                        type: "string",
+                        description: "Exact id of a memory owned by the current user.",
+                    },
+                    triggerMessage: {
+                        type: "string",
+                        description: "Optional user message that explicitly requested publication.",
+                    },
+                    triggerMessageRole: { type: "string", default: "user" },
+                },
+                required: ["memoryId"],
+            },
+        },
+        {
+            name: canonicalToolNames.publishBatchToGroup,
+            description: "Publish up to 50 exact memory snapshots to your current company group without changing global is_public or the encrypted originals. For a session request, first call get_memories_by_context, select the exact ids that match the user's instruction, then pass those ids with the same contextId. Call only after explicit group-publication intent; report what was selected when the user delegates work-related filtering.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    memoryIds: {
+                        type: "array",
+                        minItems: 1,
+                        maxItems: 50,
+                        items: { type: "string" },
+                        description: "Exact ids owned by the current user.",
+                    },
+                    contextId: {
+                        type: "string",
+                        description: "Optional session context that every supplied memory must belong to.",
+                    },
+                    selectionReason: {
+                        type: "string",
+                        description: "Short explanation to return when the agent selected a subset, such as work-related memories.",
+                    },
+                    triggerMessage: {
+                        type: "string",
+                        description: "Optional user message that explicitly requested publication.",
+                    },
+                    triggerMessageRole: { type: "string", default: "user" },
+                },
+                required: ["memoryIds"],
+            },
+        },
         {
             name: canonicalToolNames.delete,
             description: "Delete one of the user's EchoMem memories only after explicit user confirmation. First call with memoryId and confirmed omitted/false to preview the target and receive a confirmationToken; this first call never deletes. Only call again with confirmed=true and that exact confirmationToken after the user explicitly confirms deletion. Deletes the memory row only; raw source_of_truth conversation records are preserved.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@echomem/mcp",
-  "version": "1.4.21",
+  "version": "1.4.23",
   "description": "EchoMem MCP bridge: cloud-first memory tools, local context HUD, and the Agent Doctor workspace forensics report (cost ledger + 3D repo city)",
   "main": "dist/index.js",
   "type": "module",