@gethmy/mcp 2.5.7 → 2.6.0

package/dist/cli.js

@@ -1479,6 +1479,51 @@ class HarmonyApiClient {
   async updateMemoryEntity(entityId, updates) {
     return this.request("PUT", `/memory/entities/${entityId}`, updates);
   }
+  async harmonyRecall(options) {
+    const fetchLimit = Math.max(options.topK ?? 3, 50);
+    let entities = [];
+    if (options.query) {
+      const search = await this.searchMemoryEntities(options.workspaceId, options.query, {
+        project_id: options.projectId,
+        type: options.type?.length === 1 ? options.type[0] : undefined,
+        limit: fetchLimit
+      });
+      entities = search.entities ?? [];
+    } else {
+      const list = await this.listMemoryEntities({
+        workspace_id: options.workspaceId,
+        project_id: options.projectId,
+        scope: options.scope,
+        type: options.type?.length === 1 ? options.type[0] : undefined,
+        tags: options.tags,
+        min_confidence: options.minConfidence,
+        limit: fetchLimit
+      });
+      entities = list.entities ?? [];
+    }
+    if (options.type && options.type.length > 1) {
+      const allowed = new Set(options.type);
+      entities = entities.filter((e) => allowed.has(e.type));
+    }
+    if (options.memory_tier) {
+      entities = entities.filter((e) => e.memory_tier === options.memory_tier);
+    }
+    if (options.scope) {
+      entities = entities.filter((e) => e.scope === options.scope);
+    }
+    if (options.tags?.length) {
+      const wanted = new Set(options.tags);
+      entities = entities.filter((e) => (e.tags ?? []).some((t) => wanted.has(t)));
+    }
+    if (typeof options.minConfidence === "number") {
+      const threshold = options.minConfidence;
+      entities = entities.filter((e) => typeof e.confidence === "number" && e.confidence >= threshold);
+    }
+    if (options.topK !== undefined) {
+      entities = entities.slice(0, options.topK);
+    }
+    return { entities };
+  }
   async deleteMemoryEntity(entityId) {
     return this.request("DELETE", `/memory/entities/${entityId}`);
   }
@@ -1785,11 +1830,8 @@ function resolveAgentIdentity(info) {
 var AUTO_START_TRIGGERS = new Set([
   "harmony_generate_prompt",
   "harmony_update_card",
-  "harmony_move_card",
   "harmony_create_subtask",
-  "harmony_toggle_subtask",
-  "harmony_add_label_to_card",
-  "harmony_remove_label_from_card"
+  "harmony_toggle_subtask"
 ]);
 var INACTIVITY_TIMEOUT_MS = 10 * 60 * 1000;
 var CHECK_INTERVAL_MS = 60 * 1000;

package/dist/index.js

@@ -1475,6 +1475,51 @@ class HarmonyApiClient {
   async updateMemoryEntity(entityId, updates) {
     return this.request("PUT", `/memory/entities/${entityId}`, updates);
   }
+  async harmonyRecall(options) {
+    const fetchLimit = Math.max(options.topK ?? 3, 50);
+    let entities = [];
+    if (options.query) {
+      const search = await this.searchMemoryEntities(options.workspaceId, options.query, {
+        project_id: options.projectId,
+        type: options.type?.length === 1 ? options.type[0] : undefined,
+        limit: fetchLimit
+      });
+      entities = search.entities ?? [];
+    } else {
+      const list = await this.listMemoryEntities({
+        workspace_id: options.workspaceId,
+        project_id: options.projectId,
+        scope: options.scope,
+        type: options.type?.length === 1 ? options.type[0] : undefined,
+        tags: options.tags,
+        min_confidence: options.minConfidence,
+        limit: fetchLimit
+      });
+      entities = list.entities ?? [];
+    }
+    if (options.type && options.type.length > 1) {
+      const allowed = new Set(options.type);
+      entities = entities.filter((e) => allowed.has(e.type));
+    }
+    if (options.memory_tier) {
+      entities = entities.filter((e) => e.memory_tier === options.memory_tier);
+    }
+    if (options.scope) {
+      entities = entities.filter((e) => e.scope === options.scope);
+    }
+    if (options.tags?.length) {
+      const wanted = new Set(options.tags);
+      entities = entities.filter((e) => (e.tags ?? []).some((t) => wanted.has(t)));
+    }
+    if (typeof options.minConfidence === "number") {
+      const threshold = options.minConfidence;
+      entities = entities.filter((e) => typeof e.confidence === "number" && e.confidence >= threshold);
+    }
+    if (options.topK !== undefined) {
+      entities = entities.slice(0, options.topK);
+    }
+    return { entities };
+  }
   async deleteMemoryEntity(entityId) {
     return this.request("DELETE", `/memory/entities/${entityId}`);
   }
@@ -1781,11 +1826,8 @@ function resolveAgentIdentity(info) {
 var AUTO_START_TRIGGERS = new Set([
   "harmony_generate_prompt",
   "harmony_update_card",
-  "harmony_move_card",
   "harmony_create_subtask",
-  "harmony_toggle_subtask",
-  "harmony_add_label_to_card",
-  "harmony_remove_label_from_card"
+  "harmony_toggle_subtask"
 ]);
 var INACTIVITY_TIMEOUT_MS = 10 * 60 * 1000;
 var CHECK_INTERVAL_MS = 60 * 1000;

package/dist/lib/api-client.js

@@ -1082,6 +1082,51 @@ class HarmonyApiClient {
   async updateMemoryEntity(entityId, updates) {
     return this.request("PUT", `/memory/entities/${entityId}`, updates);
   }
+  async harmonyRecall(options) {
+    const fetchLimit = Math.max(options.topK ?? 3, 50);
+    let entities = [];
+    if (options.query) {
+      const search = await this.searchMemoryEntities(options.workspaceId, options.query, {
+        project_id: options.projectId,
+        type: options.type?.length === 1 ? options.type[0] : undefined,
+        limit: fetchLimit
+      });
+      entities = search.entities ?? [];
+    } else {
+      const list = await this.listMemoryEntities({
+        workspace_id: options.workspaceId,
+        project_id: options.projectId,
+        scope: options.scope,
+        type: options.type?.length === 1 ? options.type[0] : undefined,
+        tags: options.tags,
+        min_confidence: options.minConfidence,
+        limit: fetchLimit
+      });
+      entities = list.entities ?? [];
+    }
+    if (options.type && options.type.length > 1) {
+      const allowed = new Set(options.type);
+      entities = entities.filter((e) => allowed.has(e.type));
+    }
+    if (options.memory_tier) {
+      entities = entities.filter((e) => e.memory_tier === options.memory_tier);
+    }
+    if (options.scope) {
+      entities = entities.filter((e) => e.scope === options.scope);
+    }
+    if (options.tags?.length) {
+      const wanted = new Set(options.tags);
+      entities = entities.filter((e) => (e.tags ?? []).some((t) => wanted.has(t)));
+    }
+    if (typeof options.minConfidence === "number") {
+      const threshold = options.minConfidence;
+      entities = entities.filter((e) => typeof e.confidence === "number" && e.confidence >= threshold);
+    }
+    if (options.topK !== undefined) {
+      entities = entities.slice(0, options.topK);
+    }
+    return { entities };
+  }
   async deleteMemoryEntity(entityId) {
     return this.request("DELETE", `/memory/entities/${entityId}`);
   }

package/package.json

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

package/src/api-client.ts

@@ -743,15 +743,101 @@ export class HarmonyApiClient {
       scope?: string;
       type?: string;
       memory_tier?: string;
-      // AGP lifecycle fields. Backend may not yet whitelist these — extra keys
-      // are dropped server-side, leaving the call as a no-op for those fields.
+      // Supersede semantics — used by Phase 1.5 review-reject back-fill to
+      // tombstone the original implement episode without hard-deleting it.
+      // The backend sets superseded_at automatically when superseded_by lands.
       superseded_by?: string | null;
+      superseded_at?: string | null;
       version?: number;
     },
   ): Promise<{ entity: unknown; warnings?: string[] }> {
     return this.request("PUT", `/memory/entities/${entityId}`, updates);
   }
 
+  /**
+   * Retrieve memories filtered by type/tier/scope, optionally ranked by a
+   * free-text query. Wraps `searchMemoryEntities` (when a query is given)
+   * or `listMemoryEntities` and applies client-side filters that the REST
+   * surface doesn't natively expose (multi-type, memory_tier).
+   *
+   * Used by the agent daemon's read hook to surface similar past episodes
+   * before building a new task prompt (Phase 1.5).
+   */
+  async harmonyRecall(options: {
+    workspaceId: string;
+    projectId?: string;
+    query?: string;
+    type?: string[];
+    memory_tier?: string;
+    scope?: string;
+    tags?: string[];
+    minConfidence?: number;
+    topK?: number;
+  }): Promise<{ entities: unknown[] }> {
+    // Over-fetch beyond topK so client-side filters (multi-type, memory_tier,
+    // tags) have headroom — matches the MCP server's recall path (server.ts).
+    const fetchLimit = Math.max(options.topK ?? 3, 50);
+    let entities: Array<Record<string, unknown>> = [];
+
+    if (options.query) {
+      // searchMemoryEntities accepts a single type — refine client-side
+      // when the caller passed multiple.
+      const search = await this.searchMemoryEntities(
+        options.workspaceId,
+        options.query,
+        {
+          project_id: options.projectId,
+          type: options.type?.length === 1 ? options.type[0] : undefined,
+          limit: fetchLimit,
+        },
+      );
+      entities = (search.entities ?? []) as Array<Record<string, unknown>>;
+    } else {
+      const list = await this.listMemoryEntities({
+        workspace_id: options.workspaceId,
+        project_id: options.projectId,
+        scope: options.scope,
+        type: options.type?.length === 1 ? options.type[0] : undefined,
+        tags: options.tags,
+        min_confidence: options.minConfidence,
+        limit: fetchLimit,
+      });
+      entities = (list.entities ?? []) as Array<Record<string, unknown>>;
+    }
+
+    // Client-side filters: REST surface lacks multi-type and memory_tier.
+    if (options.type && options.type.length > 1) {
+      const allowed = new Set(options.type);
+      entities = entities.filter((e) => allowed.has(e.type as string));
+    }
+    if (options.memory_tier) {
+      entities = entities.filter((e) => e.memory_tier === options.memory_tier);
+    }
+    if (options.scope) {
+      entities = entities.filter((e) => e.scope === options.scope);
+    }
+    if (options.tags?.length) {
+      const wanted = new Set(options.tags);
+      entities = entities.filter((e) =>
+        ((e.tags as string[]) ?? []).some((t) => wanted.has(t)),
+      );
+    }
+    if (typeof options.minConfidence === "number") {
+      const threshold = options.minConfidence;
+      entities = entities.filter(
+        (e) =>
+          typeof e.confidence === "number" &&
+          (e.confidence as number) >= threshold,
+      );
+    }
+
+    if (options.topK !== undefined) {
+      entities = entities.slice(0, options.topK);
+    }
+
+    return { entities };
+  }
+
   async deleteMemoryEntity(entityId: string): Promise<{ success: boolean }> {
     return this.request("DELETE", `/memory/entities/${entityId}`);
   }

package/src/auto-session.ts

@@ -65,15 +65,19 @@ export function resolveAgentIdentity(info: ClientInfo | null): {
   return { agentIdentifier: key, agentName: displayName };
 }
 
-/** Tools that trigger auto-start of a session */
+/**
+ * Tools that trigger auto-start of a session.
+ *
+ * Restricted to tools that signal real work on a card. Board-management ops
+ * (move, label add/remove) are excluded — they're routinely used for triage
+ * and would create false-positive sessions whose side effect (the auto-added
+ * `agent` label on the card) confuses both UI and humans.
+ */
 export const AUTO_START_TRIGGERS = new Set([
   "harmony_generate_prompt",
   "harmony_update_card",
-  "harmony_move_card",
   "harmony_create_subtask",
   "harmony_toggle_subtask",
-  "harmony_add_label_to_card",
-  "harmony_remove_label_from_card",
 ]);
 
 export const INACTIVITY_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes