@gethmy/mcp 2.8.5 → 2.8.6

package/dist/cli.js

@@ -1720,6 +1720,10 @@ class HarmonyApiClient {
       params.set("type", options.type);
     if (options?.limit !== undefined)
       params.set("limit", String(options.limit));
+    for (const tag of options?.tags ?? [])
+      params.append("tags", tag);
+    if (options?.include_superseded)
+      params.set("include_superseded", "true");
     return this.request("GET", `/memory/search?${params.toString()}`);
   }
   async getVaultIndex(options) {
@@ -5329,23 +5333,21 @@ async function handleToolCall(name, args, deps) {
       let entities;
       let relevanceMap;
       if (queryText) {
+        const requestedTags = args.tags;
         const searchResult = await client3.searchMemoryEntities(workspaceId, queryText, {
           project_id: projectId,
           type: args.type,
-          limit: fetchLimit
+          limit: fetchLimit,
+          tags: requestedTags && requestedTags.length > 0 ? requestedTags : undefined,
+          include_superseded: includeSuperseded
         });
         entities = searchResult.entities ?? [];
-        const requestedTags = args.tags;
         const minConfidence = args.minConfidence;
         if (userScopeFilter) {
           entities = entities.filter((e) => e?.scope === userScopeFilter);
         } else if (excludeSessionFromLongTerm) {
           entities = entities.filter((e) => !isSessionScope(e?.scope));
         }
-        if (requestedTags && requestedTags.length > 0) {
-          const wanted = new Set(requestedTags);
-          entities = entities.filter((e) => (e?.tags ?? []).some((t) => wanted.has(t)));
-        }
         entities = filterByMinConfidence(entities, minConfidence);
         if (!includeSuperseded) {
           entities = entities.filter((e) => !e?.superseded_at);

package/dist/index.js

@@ -1716,6 +1716,10 @@ class HarmonyApiClient {
       params.set("type", options.type);
     if (options?.limit !== undefined)
       params.set("limit", String(options.limit));
+    for (const tag of options?.tags ?? [])
+      params.append("tags", tag);
+    if (options?.include_superseded)
+      params.set("include_superseded", "true");
     return this.request("GET", `/memory/search?${params.toString()}`);
   }
   async getVaultIndex(options) {
@@ -5325,23 +5329,21 @@ async function handleToolCall(name, args, deps) {
       let entities;
       let relevanceMap;
       if (queryText) {
+        const requestedTags = args.tags;
         const searchResult = await client3.searchMemoryEntities(workspaceId, queryText, {
           project_id: projectId,
           type: args.type,
-          limit: fetchLimit
+          limit: fetchLimit,
+          tags: requestedTags && requestedTags.length > 0 ? requestedTags : undefined,
+          include_superseded: includeSuperseded
         });
         entities = searchResult.entities ?? [];
-        const requestedTags = args.tags;
         const minConfidence = args.minConfidence;
         if (userScopeFilter) {
           entities = entities.filter((e) => e?.scope === userScopeFilter);
         } else if (excludeSessionFromLongTerm) {
           entities = entities.filter((e) => !isSessionScope(e?.scope));
         }
-        if (requestedTags && requestedTags.length > 0) {
-          const wanted = new Set(requestedTags);
-          entities = entities.filter((e) => (e?.tags ?? []).some((t) => wanted.has(t)));
-        }
         entities = filterByMinConfidence(entities, minConfidence);
         if (!includeSuperseded) {
           entities = entities.filter((e) => !e?.superseded_at);

package/dist/lib/api-client.js

@@ -1323,6 +1323,10 @@ class HarmonyApiClient {
       params.set("type", options.type);
     if (options?.limit !== undefined)
       params.set("limit", String(options.limit));
+    for (const tag of options?.tags ?? [])
+      params.append("tags", tag);
+    if (options?.include_superseded)
+      params.set("include_superseded", "true");
     return this.request("GET", `/memory/search?${params.toString()}`);
   }
   async getVaultIndex(options) {

package/package.json

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

package/src/api-client.ts

@@ -1003,6 +1003,8 @@ export class HarmonyApiClient {
       project_id?: string;
       type?: string;
       limit?: number;
+      tags?: string[];
+      include_superseded?: boolean;
     },
   ): Promise<{ entities: unknown[]; count: number }> {
     const params = new URLSearchParams();
@@ -1012,6 +1014,10 @@ export class HarmonyApiClient {
     if (options?.type) params.set("type", options.type);
     if (options?.limit !== undefined)
       params.set("limit", String(options.limit));
+    // Repeated `tags` params — the search endpoint reads them via getAll and
+    // matches against the canonical `tags_normalized` column (#299).
+    for (const tag of options?.tags ?? []) params.append("tags", tag);
+    if (options?.include_superseded) params.set("include_superseded", "true");
     return this.request("GET", `/memory/search?${params.toString()}`);
   }
 

package/src/graph-expansion.ts

@@ -264,13 +264,11 @@ export async function findSupersedeCandidates(
         if (options?.scope && (e as { scope?: string }).scope !== undefined) {
           if ((e as { scope?: string }).scope !== options.scope) return false;
         }
-        // Skip already-superseded rows when the field is present. NOTE: the
-        // hybrid-search RPC does not return `superseded_at`, so this only fires
-        // on the FTS-fallback path; on the embedding path an already-retired row
-        // can still surface as a *candidate*. That is non-destructive — the
-        // `similar` list is advisory and the caller decides explicitly whether
-        // to supersede. A complete fix needs the RPC to return/filter the column
-        // (migration + deploy); tracked in docs/memory.md.
+        // Skip already-superseded rows. The hybrid-search RPC now both returns
+        // `superseded_at` and excludes tombstoned rows by default (#298), so
+        // retired rows no longer surface as candidates on the embedding path.
+        // Kept as belt-and-suspenders for the FTS fallback and any caller that
+        // opts into include_superseded.
         if ((e as { superseded_at?: string | null }).superseded_at) {
           return false;
         }

package/src/server.ts

@@ -3080,6 +3080,12 @@ async function handleToolCall(
       let relevanceMap: Map<string, number>;
 
       if (queryText) {
+        const requestedTags = args.tags as string[] | undefined;
+        // Tag + superseded filtering is now authoritative in the hybrid_search
+        // RPC (#298/#299): tags match the canonical `tags_normalized` column at
+        // the DB level (no client-side fetch-then-filter completeness gap), and
+        // tombstoned rows are excluded unless include_superseded is set. Tags
+        // are normalized server-side; we pass them through verbatim.
         const searchResult = await client.searchMemoryEntities(
           workspaceId,
           queryText,
@@ -3087,14 +3093,18 @@ async function handleToolCall(
             project_id: projectId,
             type: args.type as string | undefined,
             limit: fetchLimit,
+            tags:
+              requestedTags && requestedTags.length > 0
+                ? requestedTags
+                : undefined,
+            include_superseded: includeSuperseded,
           },
         );
         entities = (searchResult.entities ?? []) as any[];
 
-        // Post-filter the rest of the params client-side. Hybrid search RPC
-        // exposes only project_id + type; tags / scope / minConfidence /
-        // include_superseded are applied here on the rank-ordered set.
-        const requestedTags = args.tags as string[] | undefined;
+        // Post-filter the params the RPC does not handle. Scope + minConfidence
+        // are applied here on the rank-ordered set. (Tags + include_superseded
+        // are handled server-side above.)
         const minConfidence = args.minConfidence as number | undefined;
         if (userScopeFilter) {
           entities = entities.filter((e) => e?.scope === userScopeFilter);
@@ -3103,13 +3113,9 @@ async function handleToolCall(
           // out of the long-term mix so the same row never shows twice.
           entities = entities.filter((e) => !isSessionScope(e?.scope));
         }
-        if (requestedTags && requestedTags.length > 0) {
-          const wanted = new Set(requestedTags);
-          entities = entities.filter((e) =>
-            (e?.tags ?? []).some((t: string) => wanted.has(t)),
-          );
-        }
         entities = filterByMinConfidence(entities, minConfidence);
+        // Belt-and-suspenders: the RPC already excludes tombstoned rows; this
+        // also drops any if a stale/FTS path slipped one through.
         if (!includeSuperseded) {
           entities = entities.filter((e) => !e?.superseded_at);
         }