@gethmy/mcp 2.3.0 → 2.3.1

package/dist/cli.js

@@ -27273,6 +27273,12 @@ class HarmonyApiClient {
   async endAgentSession(cardId, data) {
     return this.request("DELETE", `/cards/${cardId}/agent-context`, data);
   }
+  async flushActivityLog(cardId, data) {
+    return this.request("POST", `/cards/${cardId}/agent-activity-log`, data);
+  }
+  async getActivityLog(cardId, sessionId) {
+    return this.request("GET", `/cards/${cardId}/agent-activity-log?sessionId=${sessionId}`);
+  }
   async getAgentSession(cardId, options) {
     const params = new URLSearchParams;
     if (options?.includeEnded)
@@ -28066,6 +28072,10 @@ var ALL_STEPS = [
   "duplicates",
   "backfill"
 ];
+var MS_PER_DAY = 1000 * 60 * 60 * 24;
+var MAX_ENTITIES_FETCH = 200;
+var DUPLICATE_SIMILARITY_THRESHOLD = 0.85;
+var CONCURRENCY_LIMIT = 5;
 async function runMemoryCleanup(client3, workspaceId, projectId, options) {
   const dryRun = options?.dryRun !== false;
   const steps = options?.steps ?? ALL_STEPS;
@@ -28087,7 +28097,7 @@ async function runMemoryCleanup(client3, workspaceId, projectId, options) {
     const listResult = await client3.listMemoryEntities({
       workspace_id: workspaceId,
       project_id: projectId,
-      limit: 200
+      limit: MAX_ENTITIES_FETCH
     });
     entities = listResult.entities || [];
     report.summary.totalEntities = entities.length;
@@ -28108,7 +28118,12 @@ async function runMemoryCleanup(client3, workspaceId, projectId, options) {
           try {
             await client3.deleteMemoryEntity(item.id);
             report.steps.prune.pruned++;
-          } catch {}
+          } catch (err) {
+            report.errors.push({
+              step: "prune",
+              message: `Failed to delete ${item.id}: ${err.message}`
+            });
+          }
         }
         report.summary.actionsTaken += report.steps.prune.pruned;
       }
@@ -28150,7 +28165,12 @@ async function runMemoryCleanup(client3, workspaceId, projectId, options) {
           try {
             await client3.deleteMemoryEntity(item.id);
             report.steps.orphans.removed++;
-          } catch {}
+          } catch (err) {
+            report.errors.push({
+              step: "orphans",
+              message: `Failed to delete ${item.id}: ${err.message}`
+            });
+          }
         }
         report.summary.actionsTaken += report.steps.orphans.removed;
       }
@@ -28170,7 +28190,12 @@ async function runMemoryCleanup(client3, workspaceId, projectId, options) {
           try {
             await client3.deleteMemoryEntity(pair.removeId);
             report.steps.duplicates.resolved++;
-          } catch {}
+          } catch (err) {
+            report.errors.push({
+              step: "duplicates",
+              message: `Failed to delete ${pair.removeId}: ${err.message}`
+            });
+          }
         }
         report.summary.actionsTaken += report.steps.duplicates.resolved;
       }
@@ -28214,7 +28239,7 @@ function runPruneStep(entities, maxAgeDays) {
   const drafts = entities.filter((e) => e.memory_tier === "draft");
   const stale = [];
   for (const entity of drafts) {
-    const ageDays = (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
+    const ageDays = (now - new Date(entity.created_at).getTime()) / MS_PER_DAY;
     if (ageDays < maxAgeDays)
       continue;
     const lifecycle2 = evaluateLifecycle(entity);
@@ -28235,26 +28260,32 @@ async function runOrphanStep(client3, entities, orphanAgeDays) {
       return false;
     if (e.access_count >= 2)
       return false;
-    const ageDays = (now - new Date(e.created_at).getTime()) / (1000 * 60 * 60 * 24);
+    const ageDays = (now - new Date(e.created_at).getTime()) / MS_PER_DAY;
     return ageDays >= orphanAgeDays;
   });
-  for (const entity of candidates) {
-    try {
+  for (let i = 0;i < candidates.length; i += CONCURRENCY_LIMIT) {
+    const batch = candidates.slice(i, i + CONCURRENCY_LIMIT);
+    const results = await Promise.allSettled(batch.map(async (entity) => {
       const related = await client3.getRelatedEntities(entity.id);
       const totalRelations = (related.outgoing?.length || 0) + (related.incoming?.length || 0);
       if (totalRelations > 0)
-        continue;
-      const ageDays = (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
-      result.items.push({
+        return null;
+      const ageDays = (now - new Date(entity.created_at).getTime()) / MS_PER_DAY;
+      return {
         id: entity.id,
         title: entity.title,
         type: entity.type,
         tier: entity.memory_tier,
         ageDays: Math.round(ageDays),
         accessCount: entity.access_count
-      });
-      result.orphansFound++;
-    } catch {}
+      };
+    }));
+    for (const r of results) {
+      if (r.status === "fulfilled" && r.value) {
+        result.items.push(r.value);
+        result.orphansFound++;
+      }
+    }
   }
   return result;
 }
@@ -28266,15 +28297,24 @@ async function runDuplicateStep(client3, entities, workspaceId, projectId) {
   };
   const seenPairs = new Set;
   const flaggedForRemoval = new Set;
+  const entityMap = new Map(entities.map((e) => [e.id, e]));
+  const similarityMap = new Map;
+  for (let i = 0;i < entities.length; i += CONCURRENCY_LIMIT) {
+    const batch = entities.slice(i, i + CONCURRENCY_LIMIT);
+    const results = await Promise.allSettled(batch.map(async (entity) => {
+      const similar = await findSimilarEntities(client3, entity.title, entity.content, workspaceId, { projectId, limit: 5, minRrfScore: 0.05, excludeIds: [entity.id] });
+      return { entityId: entity.id, similar };
+    }));
+    for (const r of results) {
+      if (r.status === "fulfilled") {
+        similarityMap.set(r.value.entityId, r.value.similar);
+      }
+    }
+  }
   for (const entity of entities) {
     if (flaggedForRemoval.has(entity.id))
       continue;
-    let similar;
-    try {
-      similar = await findSimilarEntities(client3, entity.title, entity.content, workspaceId, { projectId, limit: 5, minRrfScore: 0.05, excludeIds: [entity.id] });
-    } catch {
-      continue;
-    }
+    const similar = similarityMap.get(entity.id) || [];
     for (const match of similar) {
       if (flaggedForRemoval.has(match.id))
         continue;
@@ -28283,10 +28323,10 @@ async function runDuplicateStep(client3, entities, workspaceId, projectId) {
         continue;
       seenPairs.add(pairKey);
       const sim = titleSimilarity(entity.title, match.title);
-      if (sim < 0.85)
+      if (sim < DUPLICATE_SIMILARITY_THRESHOLD)
         continue;
       const entityScore = entityQualityScore(entity);
-      const matchEntity = entities.find((e) => e.id === match.id);
+      const matchEntity = entityMap.get(match.id);
       const matchScore = matchEntity ? entityQualityScore(matchEntity) : match.confidence;
       const [keep, remove] = entityScore >= matchScore ? [entity, { id: match.id, title: match.title }] : [{ id: match.id, title: match.title }, entity];
       flaggedForRemoval.add(remove.id);
@@ -28335,6 +28375,10 @@ function generateHealthReport(report) {
     `**Mode:** ${mode} | **Entities:** ${report.summary.totalEntities} | **Issues:** ${report.summary.issuesFound} | **Actions:** ${report.summary.actionsTaken}`,
     ""
   ];
+  if (report.summary.totalEntities >= MAX_ENTITIES_FETCH) {
+    lines.push(`> **Note:** Entity count hit the ${MAX_ENTITIES_FETCH} fetch limit. Some entities may not have been analyzed.
+`);
+  }
   if (report.steps.prune) {
     const p = report.steps.prune;
     lines.push("## Stale Drafts");
@@ -31413,9 +31457,22 @@ async function handleToolCall(name, args, deps) {
         throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
       }
       const projectId = args.projectId || deps.getActiveProjectId() || undefined;
+      const validSteps = [
+        "prune",
+        "consolidate",
+        "orphans",
+        "duplicates",
+        "backfill"
+      ];
+      const rawSteps = args.steps;
+      const steps = rawSteps?.filter((s) => validSteps.includes(s));
+      if (rawSteps && steps && steps.length < rawSteps.length) {
+        const invalid = rawSteps.filter((s) => !validSteps.includes(s));
+        console.warn(`Unknown cleanup steps ignored: ${invalid.join(", ")}`);
+      }
       const report = await runMemoryCleanup(client3, workspaceId, projectId, {
         dryRun: args.dryRun,
-        steps: args.steps,
+        steps,
         maxAgeDays: args.maxAgeDays,
         minClusterSize: args.minClusterSize,
         orphanAgeDays: args.orphanAgeDays

package/dist/index.js

@@ -25033,6 +25033,12 @@ class HarmonyApiClient {
   async endAgentSession(cardId, data) {
     return this.request("DELETE", `/cards/${cardId}/agent-context`, data);
   }
+  async flushActivityLog(cardId, data) {
+    return this.request("POST", `/cards/${cardId}/agent-activity-log`, data);
+  }
+  async getActivityLog(cardId, sessionId) {
+    return this.request("GET", `/cards/${cardId}/agent-activity-log?sessionId=${sessionId}`);
+  }
   async getAgentSession(cardId, options) {
     const params = new URLSearchParams;
     if (options?.includeEnded)
@@ -25826,6 +25832,10 @@ var ALL_STEPS = [
   "duplicates",
   "backfill"
 ];
+var MS_PER_DAY = 1000 * 60 * 60 * 24;
+var MAX_ENTITIES_FETCH = 200;
+var DUPLICATE_SIMILARITY_THRESHOLD = 0.85;
+var CONCURRENCY_LIMIT = 5;
 async function runMemoryCleanup(client3, workspaceId, projectId, options) {
   const dryRun = options?.dryRun !== false;
   const steps = options?.steps ?? ALL_STEPS;
@@ -25847,7 +25857,7 @@ async function runMemoryCleanup(client3, workspaceId, projectId, options) {
     const listResult = await client3.listMemoryEntities({
       workspace_id: workspaceId,
       project_id: projectId,
-      limit: 200
+      limit: MAX_ENTITIES_FETCH
     });
     entities = listResult.entities || [];
     report.summary.totalEntities = entities.length;
@@ -25868,7 +25878,12 @@ async function runMemoryCleanup(client3, workspaceId, projectId, options) {
           try {
             await client3.deleteMemoryEntity(item.id);
             report.steps.prune.pruned++;
-          } catch {}
+          } catch (err) {
+            report.errors.push({
+              step: "prune",
+              message: `Failed to delete ${item.id}: ${err.message}`
+            });
+          }
         }
         report.summary.actionsTaken += report.steps.prune.pruned;
       }
@@ -25910,7 +25925,12 @@ async function runMemoryCleanup(client3, workspaceId, projectId, options) {
           try {
             await client3.deleteMemoryEntity(item.id);
             report.steps.orphans.removed++;
-          } catch {}
+          } catch (err) {
+            report.errors.push({
+              step: "orphans",
+              message: `Failed to delete ${item.id}: ${err.message}`
+            });
+          }
         }
         report.summary.actionsTaken += report.steps.orphans.removed;
       }
@@ -25930,7 +25950,12 @@ async function runMemoryCleanup(client3, workspaceId, projectId, options) {
           try {
             await client3.deleteMemoryEntity(pair.removeId);
             report.steps.duplicates.resolved++;
-          } catch {}
+          } catch (err) {
+            report.errors.push({
+              step: "duplicates",
+              message: `Failed to delete ${pair.removeId}: ${err.message}`
+            });
+          }
         }
         report.summary.actionsTaken += report.steps.duplicates.resolved;
       }
@@ -25974,7 +25999,7 @@ function runPruneStep(entities, maxAgeDays) {
   const drafts = entities.filter((e) => e.memory_tier === "draft");
   const stale = [];
   for (const entity of drafts) {
-    const ageDays = (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
+    const ageDays = (now - new Date(entity.created_at).getTime()) / MS_PER_DAY;
     if (ageDays < maxAgeDays)
       continue;
     const lifecycle2 = evaluateLifecycle(entity);
@@ -25995,26 +26020,32 @@ async function runOrphanStep(client3, entities, orphanAgeDays) {
       return false;
     if (e.access_count >= 2)
       return false;
-    const ageDays = (now - new Date(e.created_at).getTime()) / (1000 * 60 * 60 * 24);
+    const ageDays = (now - new Date(e.created_at).getTime()) / MS_PER_DAY;
     return ageDays >= orphanAgeDays;
   });
-  for (const entity of candidates) {
-    try {
+  for (let i = 0;i < candidates.length; i += CONCURRENCY_LIMIT) {
+    const batch = candidates.slice(i, i + CONCURRENCY_LIMIT);
+    const results = await Promise.allSettled(batch.map(async (entity) => {
       const related = await client3.getRelatedEntities(entity.id);
       const totalRelations = (related.outgoing?.length || 0) + (related.incoming?.length || 0);
       if (totalRelations > 0)
-        continue;
-      const ageDays = (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
-      result.items.push({
+        return null;
+      const ageDays = (now - new Date(entity.created_at).getTime()) / MS_PER_DAY;
+      return {
         id: entity.id,
         title: entity.title,
         type: entity.type,
         tier: entity.memory_tier,
         ageDays: Math.round(ageDays),
         accessCount: entity.access_count
-      });
-      result.orphansFound++;
-    } catch {}
+      };
+    }));
+    for (const r of results) {
+      if (r.status === "fulfilled" && r.value) {
+        result.items.push(r.value);
+        result.orphansFound++;
+      }
+    }
   }
   return result;
 }
@@ -26026,15 +26057,24 @@ async function runDuplicateStep(client3, entities, workspaceId, projectId) {
   };
   const seenPairs = new Set;
   const flaggedForRemoval = new Set;
+  const entityMap = new Map(entities.map((e) => [e.id, e]));
+  const similarityMap = new Map;
+  for (let i = 0;i < entities.length; i += CONCURRENCY_LIMIT) {
+    const batch = entities.slice(i, i + CONCURRENCY_LIMIT);
+    const results = await Promise.allSettled(batch.map(async (entity) => {
+      const similar = await findSimilarEntities(client3, entity.title, entity.content, workspaceId, { projectId, limit: 5, minRrfScore: 0.05, excludeIds: [entity.id] });
+      return { entityId: entity.id, similar };
+    }));
+    for (const r of results) {
+      if (r.status === "fulfilled") {
+        similarityMap.set(r.value.entityId, r.value.similar);
+      }
+    }
+  }
   for (const entity of entities) {
     if (flaggedForRemoval.has(entity.id))
       continue;
-    let similar;
-    try {
-      similar = await findSimilarEntities(client3, entity.title, entity.content, workspaceId, { projectId, limit: 5, minRrfScore: 0.05, excludeIds: [entity.id] });
-    } catch {
-      continue;
-    }
+    const similar = similarityMap.get(entity.id) || [];
     for (const match of similar) {
       if (flaggedForRemoval.has(match.id))
         continue;
@@ -26043,10 +26083,10 @@ async function runDuplicateStep(client3, entities, workspaceId, projectId) {
         continue;
       seenPairs.add(pairKey);
       const sim = titleSimilarity(entity.title, match.title);
-      if (sim < 0.85)
+      if (sim < DUPLICATE_SIMILARITY_THRESHOLD)
         continue;
       const entityScore = entityQualityScore(entity);
-      const matchEntity = entities.find((e) => e.id === match.id);
+      const matchEntity = entityMap.get(match.id);
       const matchScore = matchEntity ? entityQualityScore(matchEntity) : match.confidence;
       const [keep, remove] = entityScore >= matchScore ? [entity, { id: match.id, title: match.title }] : [{ id: match.id, title: match.title }, entity];
       flaggedForRemoval.add(remove.id);
@@ -26095,6 +26135,10 @@ function generateHealthReport(report) {
     `**Mode:** ${mode} | **Entities:** ${report.summary.totalEntities} | **Issues:** ${report.summary.issuesFound} | **Actions:** ${report.summary.actionsTaken}`,
     ""
   ];
+  if (report.summary.totalEntities >= MAX_ENTITIES_FETCH) {
+    lines.push(`> **Note:** Entity count hit the ${MAX_ENTITIES_FETCH} fetch limit. Some entities may not have been analyzed.
+`);
+  }
   if (report.steps.prune) {
     const p = report.steps.prune;
     lines.push("## Stale Drafts");
@@ -29173,9 +29217,22 @@ async function handleToolCall(name, args, deps) {
         throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
       }
       const projectId = args.projectId || deps.getActiveProjectId() || undefined;
+      const validSteps = [
+        "prune",
+        "consolidate",
+        "orphans",
+        "duplicates",
+        "backfill"
+      ];
+      const rawSteps = args.steps;
+      const steps = rawSteps?.filter((s) => validSteps.includes(s));
+      if (rawSteps && steps && steps.length < rawSteps.length) {
+        const invalid = rawSteps.filter((s) => !validSteps.includes(s));
+        console.warn(`Unknown cleanup steps ignored: ${invalid.join(", ")}`);
+      }
       const report = await runMemoryCleanup(client3, workspaceId, projectId, {
         dryRun: args.dryRun,
-        steps: args.steps,
+        steps,
         maxAgeDays: args.maxAgeDays,
         minClusterSize: args.minClusterSize,
         orphanAgeDays: args.orphanAgeDays

package/dist/lib/api-client.js

@@ -314,6 +314,12 @@ export class HarmonyApiClient {
     async endAgentSession(cardId, data) {
         return this.request("DELETE", `/cards/${cardId}/agent-context`, data);
     }
+    async flushActivityLog(cardId, data) {
+        return this.request("POST", `/cards/${cardId}/agent-activity-log`, data);
+    }
+    async getActivityLog(cardId, sessionId) {
+        return this.request("GET", `/cards/${cardId}/agent-activity-log?sessionId=${sessionId}`);
+    }
     async getAgentSession(cardId, options) {
         const params = new URLSearchParams();
         if (options?.includeEnded)

package/dist/lib/memory-cleanup.js

@@ -17,6 +17,10 @@ const ALL_STEPS = [
     "duplicates",
     "backfill",
 ];
+const MS_PER_DAY = 1000 * 60 * 60 * 24;
+const MAX_ENTITIES_FETCH = 200;
+const DUPLICATE_SIMILARITY_THRESHOLD = 0.85;
+const CONCURRENCY_LIMIT = 5;
 // ---------------------------------------------------------------------------
 // Main orchestrator
 // ---------------------------------------------------------------------------
@@ -42,7 +46,7 @@ export async function runMemoryCleanup(client, workspaceId, projectId, options)
         const listResult = await client.listMemoryEntities({
             workspace_id: workspaceId,
             project_id: projectId,
-            limit: 200,
+            limit: MAX_ENTITIES_FETCH,
         });
         entities = (listResult.entities || []);
         report.summary.totalEntities = entities.length;
@@ -66,8 +70,11 @@ export async function runMemoryCleanup(client, workspaceId, projectId, options)
                         await client.deleteMemoryEntity(item.id);
                         report.steps.prune.pruned++;
                     }
-                    catch {
-                        // Non-fatal
+                    catch (err) {
+                        report.errors.push({
+                            step: "prune",
+                            message: `Failed to delete ${item.id}: ${err.message}`,
+                        });
                     }
                 }
                 report.summary.actionsTaken += report.steps.prune.pruned;
@@ -115,8 +122,11 @@ export async function runMemoryCleanup(client, workspaceId, projectId, options)
                         await client.deleteMemoryEntity(item.id);
                         report.steps.orphans.removed++;
                     }
-                    catch {
-                        // Non-fatal
+                    catch (err) {
+                        report.errors.push({
+                            step: "orphans",
+                            message: `Failed to delete ${item.id}: ${err.message}`,
+                        });
                     }
                 }
                 report.summary.actionsTaken += report.steps.orphans.removed;
@@ -140,8 +150,11 @@ export async function runMemoryCleanup(client, workspaceId, projectId, options)
                         await client.deleteMemoryEntity(pair.removeId);
                         report.steps.duplicates.resolved++;
                     }
-                    catch {
-                        // Non-fatal
+                    catch (err) {
+                        report.errors.push({
+                            step: "duplicates",
+                            message: `Failed to delete ${pair.removeId}: ${err.message}`,
+                        });
                     }
                 }
                 report.summary.actionsTaken += report.steps.duplicates.resolved;
@@ -194,7 +207,7 @@ function runPruneStep(entities, maxAgeDays) {
     const drafts = entities.filter((e) => e.memory_tier === "draft");
     const stale = [];
     for (const entity of drafts) {
-        const ageDays = (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
+        const ageDays = (now - new Date(entity.created_at).getTime()) / MS_PER_DAY;
         if (ageDays < maxAgeDays)
             continue;
         const lifecycle = evaluateLifecycle(entity);
@@ -216,28 +229,32 @@ async function runOrphanStep(client, entities, orphanAgeDays) {
             return false;
         if (e.access_count >= 2)
             return false;
-        const ageDays = (now - new Date(e.created_at).getTime()) / (1000 * 60 * 60 * 24);
+        const ageDays = (now - new Date(e.created_at).getTime()) / MS_PER_DAY;
         return ageDays >= orphanAgeDays;
     });
-    for (const entity of candidates) {
-        try {
+    // Check relations in concurrent batches
+    for (let i = 0; i < candidates.length; i += CONCURRENCY_LIMIT) {
+        const batch = candidates.slice(i, i + CONCURRENCY_LIMIT);
+        const results = await Promise.allSettled(batch.map(async (entity) => {
             const related = await client.getRelatedEntities(entity.id);
             const totalRelations = (related.outgoing?.length || 0) + (related.incoming?.length || 0);
             if (totalRelations > 0)
-                continue;
-            const ageDays = (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
-            result.items.push({
+                return null;
+            const ageDays = (now - new Date(entity.created_at).getTime()) / MS_PER_DAY;
+            return {
                 id: entity.id,
                 title: entity.title,
                 type: entity.type,
                 tier: entity.memory_tier,
                 ageDays: Math.round(ageDays),
                 accessCount: entity.access_count,
-            });
-            result.orphansFound++;
-        }
-        catch {
-            // Non-fatal: skip this entity
+            };
+        }));
+        for (const r of results) {
+            if (r.status === "fulfilled" && r.value) {
+                result.items.push(r.value);
+                result.orphansFound++;
+            }
         }
     }
     return result;
@@ -250,16 +267,25 @@ async function runDuplicateStep(client, entities, workspaceId, projectId) {
     };
     const seenPairs = new Set();
     const flaggedForRemoval = new Set();
+    const entityMap = new Map(entities.map((e) => [e.id, e]));
+    const similarityMap = new Map();
+    for (let i = 0; i < entities.length; i += CONCURRENCY_LIMIT) {
+        const batch = entities.slice(i, i + CONCURRENCY_LIMIT);
+        const results = await Promise.allSettled(batch.map(async (entity) => {
+            const similar = await findSimilarEntities(client, entity.title, entity.content, workspaceId, { projectId, limit: 5, minRrfScore: 0.05, excludeIds: [entity.id] });
+            return { entityId: entity.id, similar };
+        }));
+        for (const r of results) {
+            if (r.status === "fulfilled") {
+                similarityMap.set(r.value.entityId, r.value.similar);
+            }
+        }
+    }
+    // Process pairs sequentially (flaggedForRemoval creates dependencies)
     for (const entity of entities) {
         if (flaggedForRemoval.has(entity.id))
             continue;
-        let similar;
-        try {
-            similar = await findSimilarEntities(client, entity.title, entity.content, workspaceId, { projectId, limit: 5, minRrfScore: 0.05, excludeIds: [entity.id] });
-        }
-        catch {
-            continue;
-        }
+        const similar = similarityMap.get(entity.id) || [];
         for (const match of similar) {
             if (flaggedForRemoval.has(match.id))
                 continue;
@@ -268,11 +294,11 @@ async function runDuplicateStep(client, entities, workspaceId, projectId) {
                 continue;
             seenPairs.add(pairKey);
             const sim = titleSimilarity(entity.title, match.title);
-            if (sim < 0.85)
+            if (sim < DUPLICATE_SIMILARITY_THRESHOLD)
                 continue;
             // Keep the one with higher confidence, more accesses, or higher tier
             const entityScore = entityQualityScore(entity);
-            const matchEntity = entities.find((e) => e.id === match.id);
+            const matchEntity = entityMap.get(match.id);
             const matchScore = matchEntity
                 ? entityQualityScore(matchEntity)
                 : match.confidence;
@@ -333,6 +359,9 @@ function generateHealthReport(report) {
         `**Mode:** ${mode} | **Entities:** ${report.summary.totalEntities} | **Issues:** ${report.summary.issuesFound} | **Actions:** ${report.summary.actionsTaken}`,
         "",
     ];
+    if (report.summary.totalEntities >= MAX_ENTITIES_FETCH) {
+        lines.push(`> **Note:** Entity count hit the ${MAX_ENTITIES_FETCH} fetch limit. Some entities may not have been analyzed.\n`);
+    }
     // Prune
     if (report.steps.prune) {
         const p = report.steps.prune;

package/dist/lib/server.js

@@ -3263,9 +3263,23 @@ async function handleToolCall(name, args, deps) {
                 throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
             }
             const projectId = args.projectId || deps.getActiveProjectId() || undefined;
+            const validSteps = [
+                "prune",
+                "consolidate",
+                "orphans",
+                "duplicates",
+                "backfill",
+            ];
+            const rawSteps = args.steps;
+            const steps = rawSteps?.filter((s) => validSteps.includes(s));
+            if (rawSteps && steps && steps.length < rawSteps.length) {
+                const invalid = rawSteps.filter((s) => !validSteps.includes(s));
+                // Will appear in report.errors via the healthReport
+                console.warn(`Unknown cleanup steps ignored: ${invalid.join(", ")}`);
+            }
             const report = await runMemoryCleanup(client, workspaceId, projectId, {
                 dryRun: args.dryRun,
-                steps: args.steps,
+                steps,
                 maxAgeDays: args.maxAgeDays,
                 minClusterSize: args.minClusterSize,
                 orphanAgeDays: args.orphanAgeDays,

package/package.json

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

package/src/api-client.ts

@@ -502,7 +502,6 @@ export class HarmonyApiClient {
       phase?: string;
       filesChanged?: number;
       costCents?: number;
-      recentActions?: { action: string; ts: string }[];
     },
   ): Promise<{ session: unknown; created: boolean }> {
     return this.request("POST", `/cards/${cardId}/agent-context`, data);
@@ -518,6 +517,43 @@ export class HarmonyApiClient {
     return this.request("DELETE", `/cards/${cardId}/agent-context`, data);
   }
 
+  async flushActivityLog(
+    cardId: string,
+    data: {
+      sessionId: string;
+      entries: {
+        phase?: string;
+        eventType: string;
+        toolName?: string;
+        description: string;
+        metadata?: Record<string, unknown>;
+        createdAt?: string;
+      }[];
+    },
+  ): Promise<{ inserted: number }> {
+    return this.request("POST", `/cards/${cardId}/agent-activity-log`, data);
+  }
+
+  async getActivityLog(
+    cardId: string,
+    sessionId: string,
+  ): Promise<{
+    entries: {
+      id: string;
+      phase: string | null;
+      eventType: string;
+      toolName: string | null;
+      description: string;
+      metadata: Record<string, unknown>;
+      createdAt: string;
+    }[];
+  }> {
+    return this.request(
+      "GET",
+      `/cards/${cardId}/agent-activity-log?sessionId=${sessionId}`,
+    );
+  }
+
   async getAgentSession(
     cardId: string,
     options?: { includeEnded?: boolean },

package/src/memory-cleanup.ts

@@ -130,6 +130,11 @@ const ALL_STEPS: CleanupStep[] = [
   "backfill",
 ];
 
+const MS_PER_DAY = 1000 * 60 * 60 * 24;
+const MAX_ENTITIES_FETCH = 200;
+const DUPLICATE_SIMILARITY_THRESHOLD = 0.85;
+const CONCURRENCY_LIMIT = 5;
+
 // ---------------------------------------------------------------------------
 // Main orchestrator
 // ---------------------------------------------------------------------------
@@ -163,7 +168,7 @@ export async function runMemoryCleanup(
     const listResult = await client.listMemoryEntities({
       workspace_id: workspaceId,
       project_id: projectId,
-      limit: 200,
+      limit: MAX_ENTITIES_FETCH,
     });
     entities = (listResult.entities || []) as MemoryEntity[];
     report.summary.totalEntities = entities.length;
@@ -186,8 +191,11 @@ export async function runMemoryCleanup(
           try {
             await client.deleteMemoryEntity(item.id);
             report.steps.prune.pruned++;
-          } catch {
-            // Non-fatal
+          } catch (err) {
+            report.errors.push({
+              step: "prune",
+              message: `Failed to delete ${item.id}: ${(err as Error).message}`,
+            });
           }
         }
         report.summary.actionsTaken += report.steps.prune.pruned;
@@ -237,8 +245,11 @@ export async function runMemoryCleanup(
           try {
             await client.deleteMemoryEntity(item.id);
             report.steps.orphans.removed++;
-          } catch {
-            // Non-fatal
+          } catch (err) {
+            report.errors.push({
+              step: "orphans",
+              message: `Failed to delete ${item.id}: ${(err as Error).message}`,
+            });
           }
         }
         report.summary.actionsTaken += report.steps.orphans.removed;
@@ -266,8 +277,11 @@ export async function runMemoryCleanup(
           try {
             await client.deleteMemoryEntity(pair.removeId);
             report.steps.duplicates.resolved++;
-          } catch {
-            // Non-fatal
+          } catch (err) {
+            report.errors.push({
+              step: "duplicates",
+              message: `Failed to delete ${pair.removeId}: ${(err as Error).message}`,
+            });
           }
         }
         report.summary.actionsTaken += report.steps.duplicates.resolved;
@@ -326,7 +340,7 @@ function runPruneStep(
 
   for (const entity of drafts) {
     const ageDays =
-      (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
+      (now - new Date(entity.created_at).getTime()) / MS_PER_DAY;
     if (ageDays < maxAgeDays) continue;
 
     const lifecycle = evaluateLifecycle(entity);
@@ -354,30 +368,38 @@ async function runOrphanStep(
     if (e.memory_tier === "reference") return false;
     if (e.access_count >= 2) return false;
     const ageDays =
-      (now - new Date(e.created_at).getTime()) / (1000 * 60 * 60 * 24);
+      (now - new Date(e.created_at).getTime()) / MS_PER_DAY;
     return ageDays >= orphanAgeDays;
   });
 
-  for (const entity of candidates) {
-    try {
-      const related = await client.getRelatedEntities(entity.id);
-      const totalRelations =
-        (related.outgoing?.length || 0) + (related.incoming?.length || 0);
-      if (totalRelations > 0) continue;
-
-      const ageDays =
-        (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
-      result.items.push({
-        id: entity.id,
-        title: entity.title,
-        type: entity.type,
-        tier: entity.memory_tier,
-        ageDays: Math.round(ageDays),
-        accessCount: entity.access_count,
-      });
-      result.orphansFound++;
-    } catch {
-      // Non-fatal: skip this entity
+  // Check relations in concurrent batches
+  for (let i = 0; i < candidates.length; i += CONCURRENCY_LIMIT) {
+    const batch = candidates.slice(i, i + CONCURRENCY_LIMIT);
+    const results = await Promise.allSettled(
+      batch.map(async (entity) => {
+        const related = await client.getRelatedEntities(entity.id);
+        const totalRelations =
+          (related.outgoing?.length || 0) + (related.incoming?.length || 0);
+        if (totalRelations > 0) return null;
+
+        const ageDays =
+          (now - new Date(entity.created_at).getTime()) / MS_PER_DAY;
+        return {
+          id: entity.id,
+          title: entity.title,
+          type: entity.type,
+          tier: entity.memory_tier,
+          ageDays: Math.round(ageDays),
+          accessCount: entity.access_count,
+        };
+      }),
+    );
+
+    for (const r of results) {
+      if (r.status === "fulfilled" && r.value) {
+        result.items.push(r.value);
+        result.orphansFound++;
+      }
     }
   }
 
@@ -398,28 +420,42 @@ async function runDuplicateStep(
 
   const seenPairs = new Set<string>();
   const flaggedForRemoval = new Set<string>();
+  const entityMap = new Map(entities.map((e) => [e.id, e]));
 
+  // Pre-fetch similarities in concurrent batches
+  type SimilarMatch = {
+    id: string;
+    type: string;
+    title: string;
+    content: string;
+    confidence: number;
+  };
+  const similarityMap = new Map<string, SimilarMatch[]>();
+  for (let i = 0; i < entities.length; i += CONCURRENCY_LIMIT) {
+    const batch = entities.slice(i, i + CONCURRENCY_LIMIT);
+    const results = await Promise.allSettled(
+      batch.map(async (entity) => {
+        const similar = await findSimilarEntities(
+          client,
+          entity.title,
+          entity.content,
+          workspaceId,
+          { projectId, limit: 5, minRrfScore: 0.05, excludeIds: [entity.id] },
+        );
+        return { entityId: entity.id, similar };
+      }),
+    );
+    for (const r of results) {
+      if (r.status === "fulfilled") {
+        similarityMap.set(r.value.entityId, r.value.similar);
+      }
+    }
+  }
+
+  // Process pairs sequentially (flaggedForRemoval creates dependencies)
   for (const entity of entities) {
     if (flaggedForRemoval.has(entity.id)) continue;
-
-    let similar: Array<{
-      id: string;
-      type: string;
-      title: string;
-      content: string;
-      confidence: number;
-    }>;
-    try {
-      similar = await findSimilarEntities(
-        client,
-        entity.title,
-        entity.content,
-        workspaceId,
-        { projectId, limit: 5, minRrfScore: 0.05, excludeIds: [entity.id] },
-      );
-    } catch {
-      continue;
-    }
+    const similar = similarityMap.get(entity.id) || [];
 
     for (const match of similar) {
       if (flaggedForRemoval.has(match.id)) continue;
@@ -429,11 +465,11 @@ async function runDuplicateStep(
       seenPairs.add(pairKey);
 
       const sim = titleSimilarity(entity.title, match.title);
-      if (sim < 0.85) continue;
+      if (sim < DUPLICATE_SIMILARITY_THRESHOLD) continue;
 
       // Keep the one with higher confidence, more accesses, or higher tier
       const entityScore = entityQualityScore(entity);
-      const matchEntity = entities.find((e) => e.id === match.id);
+      const matchEntity = entityMap.get(match.id);
       const matchScore = matchEntity
         ? entityQualityScore(matchEntity)
         : match.confidence;
@@ -506,6 +542,12 @@ function generateHealthReport(report: CleanupReport): string {
     "",
   ];
 
+  if (report.summary.totalEntities >= MAX_ENTITIES_FETCH) {
+    lines.push(
+      `> **Note:** Entity count hit the ${MAX_ENTITIES_FETCH} fetch limit. Some entities may not have been analyzed.\n`,
+    );
+  }
+
   // Prune
   if (report.steps.prune) {
     const p = report.steps.prune;

package/src/server.ts

@@ -4024,9 +4024,24 @@ async function handleToolCall(
       const projectId =
         (args.projectId as string) || deps.getActiveProjectId() || undefined;
 
+      const validSteps = [
+        "prune",
+        "consolidate",
+        "orphans",
+        "duplicates",
+        "backfill",
+      ];
+      const rawSteps = args.steps as string[] | undefined;
+      const steps = rawSteps?.filter((s) => validSteps.includes(s));
+      if (rawSteps && steps && steps.length < rawSteps.length) {
+        const invalid = rawSteps.filter((s) => !validSteps.includes(s));
+        // Will appear in report.errors via the healthReport
+        console.warn(`Unknown cleanup steps ignored: ${invalid.join(", ")}`);
+      }
+
       const report = await runMemoryCleanup(client, workspaceId, projectId, {
         dryRun: args.dryRun as boolean | undefined,
-        steps: args.steps as string[] | undefined,
+        steps,
         maxAgeDays: args.maxAgeDays as number | undefined,
         minClusterSize: args.minClusterSize as number | undefined,
         orphanAgeDays: args.orphanAgeDays as number | undefined,