harmony-mcp 1.8.0 → 1.9.0

package/dist/cli.js

@@ -30366,6 +30366,62 @@ class HarmonyApiClient {
     const query = params.toString() ? `?${params.toString()}` : "";
     return this.request("GET", `/cards/${cardId}/agent-context${query}`);
   }
+  async createMemoryEntity(data) {
+    return this.request("POST", "/memory/entities", data);
+  }
+  async listMemoryEntities(options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", options.workspace_id);
+    if (options.project_id)
+      params.set("project_id", options.project_id);
+    if (options.type)
+      params.set("type", options.type);
+    if (options.scope)
+      params.set("scope", options.scope);
+    if (options.tags?.length)
+      params.set("tags", options.tags.join(","));
+    if (options.agent_identifier)
+      params.set("agent_identifier", options.agent_identifier);
+    if (options.min_confidence !== undefined)
+      params.set("min_confidence", String(options.min_confidence));
+    if (options.q)
+      params.set("q", options.q);
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    if (options.offset !== undefined)
+      params.set("offset", String(options.offset));
+    return this.request("GET", `/memory/entities?${params.toString()}`);
+  }
+  async getMemoryEntity(entityId) {
+    return this.request("GET", `/memory/entities/${entityId}`);
+  }
+  async updateMemoryEntity(entityId, updates) {
+    return this.request("PUT", `/memory/entities/${entityId}`, updates);
+  }
+  async deleteMemoryEntity(entityId) {
+    return this.request("DELETE", `/memory/entities/${entityId}`);
+  }
+  async createMemoryRelation(data) {
+    return this.request("POST", "/memory/relations", data);
+  }
+  async deleteMemoryRelation(relationId) {
+    return this.request("DELETE", `/memory/relations/${relationId}`);
+  }
+  async getRelatedEntities(entityId) {
+    return this.request("GET", `/memory/entities/${entityId}/related`);
+  }
+  async searchMemoryEntities(workspaceId, query, options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", workspaceId);
+    params.set("q", query);
+    if (options?.project_id)
+      params.set("project_id", options.project_id);
+    if (options?.type)
+      params.set("type", options.type);
+    if (options?.limit !== undefined)
+      params.set("limit", String(options.limit));
+    return this.request("GET", `/memory/search?${params.toString()}`);
+  }
   async processNLU(data) {
     return this.request("POST", "/nlu", data);
   }
@@ -30607,7 +30663,7 @@ ${lines.join(`
 `)}`;
 }
 function generatePrompt(options) {
-  const { card, column, variant, customConstraints } = options;
+  const { card, column, variant, customConstraints, memories } = options;
   const contextOpts = {
     includeTitle: true,
     includeDescription: true,
@@ -30670,6 +30726,17 @@ ${card.description}`);
   roleFraming.outputSuggestions.forEach((s) => {
     sections.push(`- ${s}`);
   });
+  if (memories && memories.length > 0) {
+    sections.push(`
+## Relevant Memories`);
+    sections.push(`*${memories.length} memories recalled from knowledge graph:*`);
+    for (const memory of memories) {
+      const tags = memory.tags.length > 0 ? ` [${memory.tags.join(", ")}]` : "";
+      sections.push(`
+### ${memory.title} (${memory.type}, confidence: ${memory.confidence})${tags}`);
+      sections.push(memory.content);
+    }
+  }
   if (customConstraints) {
     sections.push(`
 ## Additional Instructions
@@ -30690,7 +30757,8 @@ ${customConstraints}`);
       labelCount: labels.length,
       subtaskCount: subtasks.length,
       completedSubtasks: subtasks.filter((s) => s.completed).length,
-      linkedCardCount: links.length
+      linkedCardCount: links.length,
+      memoryCount: memories?.length || 0
     },
     tokenEstimate: estimateTokens(prompt)
   };
@@ -31207,6 +31275,192 @@ var TOOLS = {
       required: []
     }
   },
+  harmony_remember: {
+    description: "Store a memory entity (knowledge, pattern, decision, error/solution pair, etc.) for persistence across sessions. Accepts markdown with YAML frontmatter or structured fields.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Memory title" },
+        content: {
+          type: "string",
+          description: "Memory content (markdown body)"
+        },
+        type: {
+          type: "string",
+          enum: [
+            "agent",
+            "task",
+            "decision",
+            "context",
+            "pattern",
+            "error",
+            "solution",
+            "preference"
+          ],
+          description: "Entity type (default: context)"
+        },
+        scope: {
+          type: "string",
+          enum: ["private", "project", "workspace", "global"],
+          description: "Visibility scope (default: project). Private = only creator can see."
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for categorization and filtering"
+        },
+        confidence: {
+          type: "number",
+          description: "Confidence score 0-1 (default: 1.0)"
+        },
+        metadata: {
+          type: "object",
+          description: "Additional structured metadata"
+        },
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (optional, required if scope is 'project')"
+        }
+      },
+      required: ["title", "content"]
+    }
+  },
+  harmony_recall: {
+    description: "Retrieve memories by type, tags, scope, or text query. Returns matching knowledge entities.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: [
+            "agent",
+            "task",
+            "decision",
+            "context",
+            "pattern",
+            "error",
+            "solution",
+            "preference"
+          ],
+          description: "Filter by entity type"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Filter by tags (matches any)"
+        },
+        scope: {
+          type: "string",
+          enum: ["private", "project", "workspace", "global"],
+          description: "Filter by scope"
+        },
+        query: {
+          type: "string",
+          description: "Text query to filter by title"
+        },
+        minConfidence: {
+          type: "number",
+          description: "Minimum confidence threshold (0-1)"
+        },
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (optional)"
+        },
+        limit: { type: "number", description: "Max results (default: 20)" }
+      }
+    }
+  },
+  harmony_forget: {
+    description: "Archive or delete a memory entity by ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        entityId: {
+          type: "string",
+          description: "Memory entity UUID to delete"
+        }
+      },
+      required: ["entityId"]
+    }
+  },
+  harmony_relate: {
+    description: "Create a typed relationship between two memory entities. Relation types: learned_from, resolved_by, contradicts, supports, depends_on, part_of, caused_by.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sourceId: {
+          type: "string",
+          description: "Source entity UUID"
+        },
+        targetId: {
+          type: "string",
+          description: "Target entity UUID"
+        },
+        relationType: {
+          type: "string",
+          enum: [
+            "learned_from",
+            "resolved_by",
+            "contradicts",
+            "supports",
+            "depends_on",
+            "part_of",
+            "caused_by"
+          ],
+          description: "Type of relationship between entities"
+        },
+        confidence: {
+          type: "number",
+          description: "Relation confidence 0-1 (default: 1.0)"
+        }
+      },
+      required: ["sourceId", "targetId", "relationType"]
+    }
+  },
+  harmony_memory_search: {
+    description: "Full-text search across the knowledge base. Returns entities matching the query, ranked by confidence.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query (full-text search)"
+        },
+        type: {
+          type: "string",
+          enum: [
+            "agent",
+            "task",
+            "decision",
+            "context",
+            "pattern",
+            "error",
+            "solution",
+            "preference"
+          ],
+          description: "Filter results by entity type"
+        },
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (optional)"
+        },
+        limit: { type: "number", description: "Max results (default: 20)" }
+      },
+      required: ["query"]
+    }
+  },
   harmony_create_plan: {
     description: "Create a new project plan. Use this to upload implementation plans created during planning. Returns a URL where the plan can be viewed and edited in Harmony.",
     inputSchema: {
@@ -31716,12 +31970,36 @@ class HarmonyMCPServer {
         if (args.includeDescription !== undefined) {
           contextOptions.includeDescription = args.includeDescription === true || args.includeDescription === "true";
         }
+        let memories;
+        try {
+          const workspaceId = getActiveWorkspaceId();
+          if (workspaceId && cardData.title) {
+            const memoryResult = await client2.searchMemoryEntities(workspaceId, cardData.title, {
+              project_id: getActiveProjectId() || undefined,
+              limit: 5
+            });
+            if (memoryResult.entities?.length > 0) {
+              memories = memoryResult.entities.map((e) => {
+                const entity = e;
+                return {
+                  id: entity.id,
+                  type: entity.type,
+                  title: entity.title,
+                  content: entity.content,
+                  confidence: entity.confidence,
+                  tags: entity.tags || []
+                };
+              });
+            }
+          }
+        } catch {}
         const result = generatePrompt({
           card: cardData,
           column: columnData,
           variant,
           contextOptions,
-          customConstraints: args.customConstraints
+          customConstraints: args.customConstraints,
+          memories
         });
         return {
           success: true,
@@ -31731,6 +32009,82 @@ class HarmonyMCPServer {
           ...result
         };
       }
+      case "harmony_remember": {
+        const title = exports_external.string().min(1).parse(args.title);
+        const content = exports_external.string().min(1).parse(args.content);
+        const workspaceId = args.workspaceId || getActiveWorkspaceId();
+        if (!workspaceId) {
+          throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+        }
+        const result = await client2.createMemoryEntity({
+          workspace_id: workspaceId,
+          project_id: args.projectId || getActiveProjectId() || undefined,
+          type: args.type || "context",
+          scope: args.scope || "project",
+          title,
+          content,
+          metadata: args.metadata,
+          confidence: args.confidence,
+          tags: args.tags,
+          agent_identifier: "claude-code"
+        });
+        return { success: true, ...result };
+      }
+      case "harmony_recall": {
+        const workspaceId = args.workspaceId || getActiveWorkspaceId();
+        if (!workspaceId) {
+          throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+        }
+        const result = await client2.listMemoryEntities({
+          workspace_id: workspaceId,
+          project_id: args.projectId || getActiveProjectId() || undefined,
+          type: args.type,
+          scope: args.scope,
+          tags: args.tags,
+          min_confidence: args.minConfidence,
+          q: args.query,
+          limit: args.limit
+        });
+        return { success: true, ...result };
+      }
+      case "harmony_forget": {
+        const entityId = exports_external.string().uuid().parse(args.entityId);
+        await client2.deleteMemoryEntity(entityId);
+        return { success: true };
+      }
+      case "harmony_relate": {
+        const sourceId = exports_external.string().uuid().parse(args.sourceId);
+        const targetId = exports_external.string().uuid().parse(args.targetId);
+        const relationType = exports_external.enum([
+          "learned_from",
+          "resolved_by",
+          "contradicts",
+          "supports",
+          "depends_on",
+          "part_of",
+          "caused_by"
+        ]).parse(args.relationType);
+        const result = await client2.createMemoryRelation({
+          source_id: sourceId,
+          target_id: targetId,
+          relation_type: relationType,
+          confidence: args.confidence
+        });
+        return { success: true, ...result };
+      }
+      case "harmony_memory_search": {
+        const query = exports_external.string().min(1).parse(args.query);
+        const workspaceId = args.workspaceId || getActiveWorkspaceId();
+        if (!workspaceId) {
+          throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+        }
+        const result = await client2.searchMemoryEntities(workspaceId, query, {
+          project_id: args.projectId || getActiveProjectId() || undefined,
+          type: args.type,
+          limit: args.limit
+        });
+        return { success: true, ...result };
+      }
       case "harmony_create_plan": {
         const title = exports_external.string().min(1).parse(args.title);
         const projectId = args.projectId || getProjectId();

package/dist/index.js

@@ -28126,6 +28126,62 @@ class HarmonyApiClient {
     const query = params.toString() ? `?${params.toString()}` : "";
     return this.request("GET", `/cards/${cardId}/agent-context${query}`);
   }
+  async createMemoryEntity(data) {
+    return this.request("POST", "/memory/entities", data);
+  }
+  async listMemoryEntities(options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", options.workspace_id);
+    if (options.project_id)
+      params.set("project_id", options.project_id);
+    if (options.type)
+      params.set("type", options.type);
+    if (options.scope)
+      params.set("scope", options.scope);
+    if (options.tags?.length)
+      params.set("tags", options.tags.join(","));
+    if (options.agent_identifier)
+      params.set("agent_identifier", options.agent_identifier);
+    if (options.min_confidence !== undefined)
+      params.set("min_confidence", String(options.min_confidence));
+    if (options.q)
+      params.set("q", options.q);
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    if (options.offset !== undefined)
+      params.set("offset", String(options.offset));
+    return this.request("GET", `/memory/entities?${params.toString()}`);
+  }
+  async getMemoryEntity(entityId) {
+    return this.request("GET", `/memory/entities/${entityId}`);
+  }
+  async updateMemoryEntity(entityId, updates) {
+    return this.request("PUT", `/memory/entities/${entityId}`, updates);
+  }
+  async deleteMemoryEntity(entityId) {
+    return this.request("DELETE", `/memory/entities/${entityId}`);
+  }
+  async createMemoryRelation(data) {
+    return this.request("POST", "/memory/relations", data);
+  }
+  async deleteMemoryRelation(relationId) {
+    return this.request("DELETE", `/memory/relations/${relationId}`);
+  }
+  async getRelatedEntities(entityId) {
+    return this.request("GET", `/memory/entities/${entityId}/related`);
+  }
+  async searchMemoryEntities(workspaceId, query, options) {
+    const params = new URLSearchParams;
+    params.set("workspace_id", workspaceId);
+    params.set("q", query);
+    if (options?.project_id)
+      params.set("project_id", options.project_id);
+    if (options?.type)
+      params.set("type", options.type);
+    if (options?.limit !== undefined)
+      params.set("limit", String(options.limit));
+    return this.request("GET", `/memory/search?${params.toString()}`);
+  }
   async processNLU(data) {
     return this.request("POST", "/nlu", data);
   }
@@ -28367,7 +28423,7 @@ ${lines.join(`
 `)}`;
 }
 function generatePrompt(options) {
-  const { card, column, variant, customConstraints } = options;
+  const { card, column, variant, customConstraints, memories } = options;
   const contextOpts = {
     includeTitle: true,
     includeDescription: true,
@@ -28430,6 +28486,17 @@ ${card.description}`);
   roleFraming.outputSuggestions.forEach((s) => {
     sections.push(`- ${s}`);
   });
+  if (memories && memories.length > 0) {
+    sections.push(`
+## Relevant Memories`);
+    sections.push(`*${memories.length} memories recalled from knowledge graph:*`);
+    for (const memory of memories) {
+      const tags = memory.tags.length > 0 ? ` [${memory.tags.join(", ")}]` : "";
+      sections.push(`
+### ${memory.title} (${memory.type}, confidence: ${memory.confidence})${tags}`);
+      sections.push(memory.content);
+    }
+  }
   if (customConstraints) {
     sections.push(`
 ## Additional Instructions
@@ -28450,7 +28517,8 @@ ${customConstraints}`);
       labelCount: labels.length,
       subtaskCount: subtasks.length,
       completedSubtasks: subtasks.filter((s) => s.completed).length,
-      linkedCardCount: links.length
+      linkedCardCount: links.length,
+      memoryCount: memories?.length || 0
     },
     tokenEstimate: estimateTokens(prompt)
   };
@@ -28967,6 +29035,192 @@ var TOOLS = {
       required: []
     }
   },
+  harmony_remember: {
+    description: "Store a memory entity (knowledge, pattern, decision, error/solution pair, etc.) for persistence across sessions. Accepts markdown with YAML frontmatter or structured fields.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Memory title" },
+        content: {
+          type: "string",
+          description: "Memory content (markdown body)"
+        },
+        type: {
+          type: "string",
+          enum: [
+            "agent",
+            "task",
+            "decision",
+            "context",
+            "pattern",
+            "error",
+            "solution",
+            "preference"
+          ],
+          description: "Entity type (default: context)"
+        },
+        scope: {
+          type: "string",
+          enum: ["private", "project", "workspace", "global"],
+          description: "Visibility scope (default: project). Private = only creator can see."
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for categorization and filtering"
+        },
+        confidence: {
+          type: "number",
+          description: "Confidence score 0-1 (default: 1.0)"
+        },
+        metadata: {
+          type: "object",
+          description: "Additional structured metadata"
+        },
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (optional, required if scope is 'project')"
+        }
+      },
+      required: ["title", "content"]
+    }
+  },
+  harmony_recall: {
+    description: "Retrieve memories by type, tags, scope, or text query. Returns matching knowledge entities.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: [
+            "agent",
+            "task",
+            "decision",
+            "context",
+            "pattern",
+            "error",
+            "solution",
+            "preference"
+          ],
+          description: "Filter by entity type"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Filter by tags (matches any)"
+        },
+        scope: {
+          type: "string",
+          enum: ["private", "project", "workspace", "global"],
+          description: "Filter by scope"
+        },
+        query: {
+          type: "string",
+          description: "Text query to filter by title"
+        },
+        minConfidence: {
+          type: "number",
+          description: "Minimum confidence threshold (0-1)"
+        },
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (optional)"
+        },
+        limit: { type: "number", description: "Max results (default: 20)" }
+      }
+    }
+  },
+  harmony_forget: {
+    description: "Archive or delete a memory entity by ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        entityId: {
+          type: "string",
+          description: "Memory entity UUID to delete"
+        }
+      },
+      required: ["entityId"]
+    }
+  },
+  harmony_relate: {
+    description: "Create a typed relationship between two memory entities. Relation types: learned_from, resolved_by, contradicts, supports, depends_on, part_of, caused_by.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sourceId: {
+          type: "string",
+          description: "Source entity UUID"
+        },
+        targetId: {
+          type: "string",
+          description: "Target entity UUID"
+        },
+        relationType: {
+          type: "string",
+          enum: [
+            "learned_from",
+            "resolved_by",
+            "contradicts",
+            "supports",
+            "depends_on",
+            "part_of",
+            "caused_by"
+          ],
+          description: "Type of relationship between entities"
+        },
+        confidence: {
+          type: "number",
+          description: "Relation confidence 0-1 (default: 1.0)"
+        }
+      },
+      required: ["sourceId", "targetId", "relationType"]
+    }
+  },
+  harmony_memory_search: {
+    description: "Full-text search across the knowledge base. Returns entities matching the query, ranked by confidence.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query (full-text search)"
+        },
+        type: {
+          type: "string",
+          enum: [
+            "agent",
+            "task",
+            "decision",
+            "context",
+            "pattern",
+            "error",
+            "solution",
+            "preference"
+          ],
+          description: "Filter results by entity type"
+        },
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (optional)"
+        },
+        limit: { type: "number", description: "Max results (default: 20)" }
+      },
+      required: ["query"]
+    }
+  },
   harmony_create_plan: {
     description: "Create a new project plan. Use this to upload implementation plans created during planning. Returns a URL where the plan can be viewed and edited in Harmony.",
     inputSchema: {
@@ -29476,12 +29730,36 @@ class HarmonyMCPServer {
         if (args.includeDescription !== undefined) {
           contextOptions.includeDescription = args.includeDescription === true || args.includeDescription === "true";
         }
+        let memories;
+        try {
+          const workspaceId = getActiveWorkspaceId();
+          if (workspaceId && cardData.title) {
+            const memoryResult = await client2.searchMemoryEntities(workspaceId, cardData.title, {
+              project_id: getActiveProjectId() || undefined,
+              limit: 5
+            });
+            if (memoryResult.entities?.length > 0) {
+              memories = memoryResult.entities.map((e) => {
+                const entity = e;
+                return {
+                  id: entity.id,
+                  type: entity.type,
+                  title: entity.title,
+                  content: entity.content,
+                  confidence: entity.confidence,
+                  tags: entity.tags || []
+                };
+              });
+            }
+          }
+        } catch {}
         const result = generatePrompt({
           card: cardData,
           column: columnData,
           variant,
           contextOptions,
-          customConstraints: args.customConstraints
+          customConstraints: args.customConstraints,
+          memories
         });
         return {
           success: true,
@@ -29491,6 +29769,82 @@ class HarmonyMCPServer {
           ...result
         };
       }
+      case "harmony_remember": {
+        const title = exports_external.string().min(1).parse(args.title);
+        const content = exports_external.string().min(1).parse(args.content);
+        const workspaceId = args.workspaceId || getActiveWorkspaceId();
+        if (!workspaceId) {
+          throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+        }
+        const result = await client2.createMemoryEntity({
+          workspace_id: workspaceId,
+          project_id: args.projectId || getActiveProjectId() || undefined,
+          type: args.type || "context",
+          scope: args.scope || "project",
+          title,
+          content,
+          metadata: args.metadata,
+          confidence: args.confidence,
+          tags: args.tags,
+          agent_identifier: "claude-code"
+        });
+        return { success: true, ...result };
+      }
+      case "harmony_recall": {
+        const workspaceId = args.workspaceId || getActiveWorkspaceId();
+        if (!workspaceId) {
+          throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+        }
+        const result = await client2.listMemoryEntities({
+          workspace_id: workspaceId,
+          project_id: args.projectId || getActiveProjectId() || undefined,
+          type: args.type,
+          scope: args.scope,
+          tags: args.tags,
+          min_confidence: args.minConfidence,
+          q: args.query,
+          limit: args.limit
+        });
+        return { success: true, ...result };
+      }
+      case "harmony_forget": {
+        const entityId = exports_external.string().uuid().parse(args.entityId);
+        await client2.deleteMemoryEntity(entityId);
+        return { success: true };
+      }
+      case "harmony_relate": {
+        const sourceId = exports_external.string().uuid().parse(args.sourceId);
+        const targetId = exports_external.string().uuid().parse(args.targetId);
+        const relationType = exports_external.enum([
+          "learned_from",
+          "resolved_by",
+          "contradicts",
+          "supports",
+          "depends_on",
+          "part_of",
+          "caused_by"
+        ]).parse(args.relationType);
+        const result = await client2.createMemoryRelation({
+          source_id: sourceId,
+          target_id: targetId,
+          relation_type: relationType,
+          confidence: args.confidence
+        });
+        return { success: true, ...result };
+      }
+      case "harmony_memory_search": {
+        const query = exports_external.string().min(1).parse(args.query);
+        const workspaceId = args.workspaceId || getActiveWorkspaceId();
+        if (!workspaceId) {
+          throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+        }
+        const result = await client2.searchMemoryEntities(workspaceId, query, {
+          project_id: args.projectId || getActiveProjectId() || undefined,
+          type: args.type,
+          limit: args.limit
+        });
+        return { success: true, ...result };
+      }
       case "harmony_create_plan": {
         const title = exports_external.string().min(1).parse(args.title);
         const projectId = args.projectId || getProjectId();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harmony-mcp",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "MCP server for Harmony Kanban board - enables AI coding agents to manage your boards",
   "publishConfig": {
     "access": "public"