@gethmy/mcp 2.3.4 → 2.4.1

package/dist/index.js

@@ -25823,6 +25823,353 @@ async function runLifecycleMaintenance(client3, workspaceId, projectId) {
   return result;
 }
 
+// src/memory-audit.ts
+init_dist();
+var EMBEDDINGS_MIGRATION_AT = Date.parse("2026-02-18T00:00:00Z");
+var MS_PER_DAY = 1000 * 60 * 60 * 24;
+var BATCH_SIZE = 100;
+var CONCURRENCY_LIMIT = 5;
+var BOILERPLATE_PATTERNS = [
+  /^todo:?$/i,
+  /^placeholder/i,
+  /^\.\.\.$/,
+  /^untitled/i,
+  /^(note|memo|draft)\s*\d*$/i
+];
+function isBoilerplate(title, content) {
+  const t = title.trim();
+  const c = content.trim();
+  if (c.length === 0)
+    return true;
+  for (const pat of BOILERPLATE_PATTERNS) {
+    if (pat.test(t))
+      return true;
+  }
+  return false;
+}
+function scoreEntity(entity, relationCount, archiveBelow, deleteBelow, staleDraftAgeDays) {
+  const now = Date.now();
+  const ageDays = (now - Date.parse(entity.created_at)) / MS_PER_DAY;
+  const effectiveLastAccess = entity.last_accessed_at ?? entity.created_at;
+  const lifecycle2 = evaluateLifecycle({
+    memory_tier: entity.memory_tier,
+    confidence: entity.confidence,
+    access_count: entity.access_count,
+    last_accessed_at: effectiveLastAccess,
+    created_at: entity.created_at
+  });
+  const reasons = [];
+  const legacyReasons = [];
+  const confidence = Math.max(0, Math.min(1, entity.confidence)) * 25;
+  const decay = Math.max(0, Math.min(1, lifecycle2.decay.score)) * 20;
+  if (lifecycle2.decay.score < 0.2)
+    reasons.push(`decay score ${lifecycle2.decay.score.toFixed(2)}`);
+  const hasEmbedding = entity.embedding != null;
+  const hasTags = (entity.tags?.length || 0) >= 1;
+  const hasRelations = relationCount > 0;
+  let structural = 0;
+  if (hasEmbedding)
+    structural += 6;
+  if (hasTags)
+    structural += 4;
+  if (hasRelations)
+    structural += 5;
+  if (!hasEmbedding)
+    reasons.push("no embedding");
+  if (!hasTags)
+    reasons.push("no tags");
+  if (!hasRelations)
+    reasons.push("no relations");
+  let content = 0;
+  const contentLen = entity.content?.length || 0;
+  if (contentLen >= 80)
+    content += 8;
+  const titleOk = entity.title.trim().length >= 4 && !/^(untitled|draft|note)\b/i.test(entity.title.trim());
+  if (titleOk)
+    content += 4;
+  if (!isBoilerplate(entity.title, entity.content))
+    content += 3;
+  if (contentLen < 80)
+    reasons.push(`thin content (${contentLen} chars)`);
+  if (isBoilerplate(entity.title, entity.content))
+    reasons.push("boilerplate title/content");
+  let tierAgeFit = 15;
+  if (entity.memory_tier === "draft" && ageDays > 60 && !entity.promoted_from_id) {
+    tierAgeFit = 0;
+    reasons.push("stuck draft >60d never promoted");
+  }
+  if (entity.promoted_from_id) {
+    tierAgeFit = Math.min(15, tierAgeFit + 5);
+  }
+  const access = Math.min(10, Math.log10((entity.access_count || 0) + 1) * 5);
+  if (entity.access_count === 0 && ageDays > 14)
+    reasons.push("never accessed");
+  const raw = confidence + decay + structural + content + tierAgeFit + access;
+  const score = Math.round(Math.max(0, Math.min(100, raw)));
+  let legacy = false;
+  if (entity.confidence === 1 && entity.access_count === 0 && ageDays > 30) {
+    legacy = true;
+    legacyReasons.push("default confidence never validated");
+  }
+  if (!hasEmbedding && Date.parse(entity.created_at) < EMBEDDINGS_MIGRATION_AT) {
+    legacy = true;
+    legacyReasons.push("pre-embeddings migration");
+  }
+  if (entity.memory_tier === "draft" && ageDays > 60 && !entity.promoted_from_id) {
+    legacy = true;
+    legacyReasons.push("stuck draft");
+  }
+  if (!hasTags && !hasRelations) {
+    legacy = true;
+    legacyReasons.push("no graph presence");
+  }
+  let bucket;
+  if (score < deleteBelow)
+    bucket = "delete";
+  else if (score < archiveBelow)
+    bucket = "archive";
+  else if (score < 70)
+    bucket = "review";
+  else
+    bucket = "keep";
+  const staleDraft = entity.memory_tier === "draft" && (entity.access_count || 0) === 0 && ageDays > staleDraftAgeDays;
+  return {
+    id: entity.id,
+    title: entity.title,
+    type: entity.type,
+    tier: entity.memory_tier,
+    ageDays: Math.round(ageDays),
+    score,
+    bucket,
+    reasons,
+    legacy,
+    legacyReasons,
+    staleDraft,
+    subScores: {
+      confidence: Math.round(confidence),
+      decay: Math.round(decay),
+      structural,
+      content,
+      tierAgeFit,
+      access: Math.round(access)
+    }
+  };
+}
+async function runMemoryAudit(client3, workspaceId, projectId, options) {
+  const dryRun = options?.dryRun !== false;
+  const archiveBelow = options?.archiveBelow ?? 40;
+  const deleteBelow = options?.deleteBelow ?? 20;
+  const limit = options?.limit ?? 500;
+  const staleDraftAgeDays = options?.staleDraftAgeDays ?? 7;
+  const report = {
+    success: true,
+    dryRun,
+    timestamp: new Date().toISOString(),
+    workspace: { id: workspaceId, projectId },
+    summary: {
+      totalEntities: 0,
+      scanned: 0,
+      keep: 0,
+      review: 0,
+      archive: 0,
+      delete: 0,
+      legacyCount: 0,
+      staleDraftCount: 0
+    },
+    actionsTaken: { flaggedReview: 0, archived: 0, deleted: 0 },
+    distribution: { "0-20": 0, "20-40": 0, "40-70": 0, "70-100": 0 },
+    legacyBreakdown: {
+      defaultConfidence: 0,
+      missingEmbedding: 0,
+      stuckDraft: 0,
+      noGraphPresence: 0
+    },
+    lowest: [],
+    staleDrafts: [],
+    errors: [],
+    healthReport: ""
+  };
+  const entities = [];
+  let offset = 0;
+  try {
+    while (entities.length < limit) {
+      const pageSize = Math.min(BATCH_SIZE, limit - entities.length);
+      const result = await client3.listMemoryEntities({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        limit: pageSize,
+        offset
+      });
+      const page = result.entities || [];
+      if (page.length === 0)
+        break;
+      entities.push(...page);
+      if (page.length < pageSize)
+        break;
+      offset += pageSize;
+    }
+  } catch (err) {
+    report.errors.push({
+      step: "fetch",
+      message: `Failed to fetch entities: ${err.message}`
+    });
+    report.success = false;
+    report.healthReport = renderReport(report);
+    return report;
+  }
+  report.summary.totalEntities = entities.length;
+  const relationCounts = 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 (e) => {
+      const related = await client3.getRelatedEntities(e.id);
+      const count = (related.outgoing?.length || 0) + (related.incoming?.length || 0);
+      return { id: e.id, count };
+    }));
+    for (const r of results) {
+      if (r.status === "fulfilled") {
+        relationCounts.set(r.value.id, r.value.count);
+      }
+    }
+  }
+  const audits = [];
+  for (const entity of entities) {
+    const relCount = relationCounts.get(entity.id) ?? 0;
+    const audit = scoreEntity(entity, relCount, archiveBelow, deleteBelow, staleDraftAgeDays);
+    audits.push(audit);
+    report.summary.scanned++;
+    report.summary[audit.bucket]++;
+    if (audit.legacy)
+      report.summary.legacyCount++;
+    if (audit.staleDraft)
+      report.summary.staleDraftCount++;
+    if (audit.score < 20)
+      report.distribution["0-20"]++;
+    else if (audit.score < 40)
+      report.distribution["20-40"]++;
+    else if (audit.score < 70)
+      report.distribution["40-70"]++;
+    else
+      report.distribution["70-100"]++;
+    for (const reason of audit.legacyReasons) {
+      if (reason.startsWith("default confidence"))
+        report.legacyBreakdown.defaultConfidence++;
+      else if (reason.startsWith("pre-embeddings"))
+        report.legacyBreakdown.missingEmbedding++;
+      else if (reason.startsWith("stuck draft"))
+        report.legacyBreakdown.stuckDraft++;
+      else if (reason.startsWith("no graph"))
+        report.legacyBreakdown.noGraphPresence++;
+    }
+  }
+  report.lowest = [...audits].sort((a, b) => a.score - b.score).slice(0, 10);
+  report.staleDrafts = audits.filter((a) => a.staleDraft).sort((a, b) => b.ageDays - a.ageDays);
+  if (!dryRun) {
+    for (const audit of audits) {
+      try {
+        if (audit.bucket === "delete") {
+          await client3.deleteMemoryEntity(audit.id);
+          report.actionsTaken.deleted++;
+        } else if (audit.bucket === "archive") {
+          await client3.updateMemoryEntity(audit.id, {
+            confidence: 0.25,
+            metadata: {
+              audit_archived_at: new Date().toISOString(),
+              audit_score: audit.score,
+              audit_reasons: audit.reasons
+            }
+          });
+          report.actionsTaken.archived++;
+        } else if (audit.bucket === "review") {
+          await client3.updateMemoryEntity(audit.id, {
+            metadata: {
+              needs_review: true,
+              audit_score: audit.score,
+              audit_reasons: audit.reasons,
+              audit_at: new Date().toISOString()
+            }
+          });
+          report.actionsTaken.flaggedReview++;
+        }
+      } catch (err) {
+        report.errors.push({
+          entityId: audit.id,
+          step: audit.bucket,
+          message: err.message
+        });
+      }
+    }
+  }
+  report.healthReport = renderReport(report);
+  return report;
+}
+function renderReport(report) {
+  const mode = report.dryRun ? "Dry Run (preview)" : "Executed";
+  const s = report.summary;
+  const lines = [
+    `# Memory Quality Audit
+`,
+    `**Mode:** ${mode} | **Scanned:** ${s.scanned}/${s.totalEntities} | **Legacy:** ${s.legacyCount} | **Stale drafts:** ${s.staleDraftCount}`,
+    "",
+    "## Distribution",
+    `- 70-100 (keep):    ${report.distribution["70-100"]}`,
+    `- 40-69  (review):  ${report.distribution["40-70"]}`,
+    `- 20-39  (archive): ${report.distribution["20-40"]}`,
+    `- 0-19   (delete):  ${report.distribution["0-20"]}`,
+    "",
+    "## Buckets",
+    `- **Keep:**    ${s.keep}`,
+    `- **Review:**  ${s.review}${!report.dryRun ? ` (flagged ${report.actionsTaken.flaggedReview})` : ""}`,
+    `- **Archive:** ${s.archive}${!report.dryRun ? ` (archived ${report.actionsTaken.archived})` : ""}`,
+    `- **Delete:**  ${s.delete}${!report.dryRun ? ` (deleted ${report.actionsTaken.deleted})` : ""}`,
+    ""
+  ];
+  const l = report.legacyBreakdown;
+  if (s.legacyCount > 0) {
+    lines.push("## Legacy Breakdown");
+    lines.push(`- Default confidence, never validated: ${l.defaultConfidence}`);
+    lines.push(`- Pre-embeddings migration:            ${l.missingEmbedding}`);
+    lines.push(`- Stuck drafts (>60d, no promotion):   ${l.stuckDraft}`);
+    lines.push(`- No tags + no relations:              ${l.noGraphPresence}`);
+    lines.push("");
+  }
+  if (report.staleDrafts.length > 0) {
+    lines.push("## Stale Drafts (promote-or-drop candidates)");
+    lines.push("Filter: `tier=draft AND access=0 AND age>threshold`");
+    lines.push("| Age | Score | Title |");
+    lines.push("|-----|-------|-------|");
+    for (const a of report.staleDrafts.slice(0, 20)) {
+      const titleTrunc = a.title.length > 50 ? `${a.title.slice(0, 47)}...` : a.title;
+      lines.push(`| ${a.ageDays}d | ${a.score} | ${titleTrunc} |`);
+    }
+    lines.push("");
+  }
+  if (report.lowest.length > 0) {
+    lines.push("## Lowest-Scoring (top 10)");
+    lines.push("| Score | Bucket | Tier | Age | Title | Reasons |");
+    lines.push("|-------|--------|------|-----|-------|---------|");
+    for (const a of report.lowest) {
+      const reasonStr = a.reasons.slice(0, 3).join(", ") || "—";
+      const titleTrunc = a.title.length > 40 ? `${a.title.slice(0, 37)}...` : a.title;
+      lines.push(`| ${a.score} | ${a.bucket} | ${a.tier} | ${a.ageDays}d | ${titleTrunc} | ${reasonStr} |`);
+    }
+    lines.push("");
+  }
+  if (report.errors.length > 0) {
+    lines.push("## Errors");
+    for (const e of report.errors.slice(0, 10)) {
+      lines.push(`- **${e.step}${e.entityId ? ` ${e.entityId}` : ""}:** ${e.message}`);
+    }
+    lines.push("");
+  }
+  if (report.dryRun) {
+    lines.push("---");
+    lines.push("*Run with `dryRun: false` to flag review entries, archive low-quality memories, and delete worst offenders.*");
+  }
+  return lines.join(`
+`);
+}
+
 // src/memory-cleanup.ts
 init_dist();
 var ALL_STEPS = [
@@ -25830,12 +26177,13 @@ var ALL_STEPS = [
   "consolidate",
   "orphans",
   "duplicates",
-  "backfill"
+  "backfill",
+  "audit"
 ];
-var MS_PER_DAY = 1000 * 60 * 60 * 24;
+var MS_PER_DAY2 = 1000 * 60 * 60 * 24;
 var MAX_ENTITIES_FETCH = 200;
 var DUPLICATE_SIMILARITY_THRESHOLD = 0.85;
-var CONCURRENCY_LIMIT = 5;
+var CONCURRENCY_LIMIT2 = 5;
 async function runMemoryCleanup(client3, workspaceId, projectId, options) {
   const dryRun = options?.dryRun !== false;
   const steps = options?.steps ?? ALL_STEPS;
@@ -25991,6 +26339,44 @@ async function runMemoryCleanup(client3, workspaceId, projectId, options) {
       });
     }
   }
+  if (steps.includes("audit")) {
+    try {
+      const auditReport = await runMemoryAudit(client3, workspaceId, projectId, {
+        dryRun,
+        archiveBelow: options?.auditArchiveBelow,
+        deleteBelow: options?.auditDeleteBelow
+      });
+      const low = auditReport.lowest.length > 0 ? auditReport.lowest[0].score : null;
+      report.steps.audit = {
+        scanned: auditReport.summary.scanned,
+        legacyCount: auditReport.summary.legacyCount,
+        buckets: {
+          keep: auditReport.summary.keep,
+          review: auditReport.summary.review,
+          archive: auditReport.summary.archive,
+          delete: auditReport.summary.delete
+        },
+        actions: auditReport.actionsTaken,
+        lowestScore: low,
+        report: auditReport
+      };
+      report.summary.issuesFound += auditReport.summary.review + auditReport.summary.archive + auditReport.summary.delete;
+      if (!dryRun) {
+        report.summary.actionsTaken += auditReport.actionsTaken.flaggedReview + auditReport.actionsTaken.archived + auditReport.actionsTaken.deleted;
+      }
+      for (const err of auditReport.errors) {
+        report.errors.push({
+          step: `audit:${err.step}`,
+          message: err.entityId ? `${err.entityId}: ${err.message}` : err.message
+        });
+      }
+    } catch (err) {
+      report.errors.push({
+        step: "audit",
+        message: err.message
+      });
+    }
+  }
   report.healthReport = generateHealthReport(report);
   return report;
 }
@@ -25999,7 +26385,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()) / MS_PER_DAY;
+    const ageDays = (now - new Date(entity.created_at).getTime()) / MS_PER_DAY2;
     if (ageDays < maxAgeDays)
       continue;
     const lifecycle2 = evaluateLifecycle(entity);
@@ -26020,17 +26406,17 @@ async function runOrphanStep(client3, entities, orphanAgeDays) {
       return false;
     if (e.access_count >= 2)
       return false;
-    const ageDays = (now - new Date(e.created_at).getTime()) / MS_PER_DAY;
+    const ageDays = (now - new Date(e.created_at).getTime()) / MS_PER_DAY2;
     return ageDays >= orphanAgeDays;
   });
-  for (let i = 0;i < candidates.length; i += CONCURRENCY_LIMIT) {
-    const batch = candidates.slice(i, i + CONCURRENCY_LIMIT);
+  for (let i = 0;i < candidates.length; i += CONCURRENCY_LIMIT2) {
+    const batch = candidates.slice(i, i + CONCURRENCY_LIMIT2);
     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)
         return null;
-      const ageDays = (now - new Date(entity.created_at).getTime()) / MS_PER_DAY;
+      const ageDays = (now - new Date(entity.created_at).getTime()) / MS_PER_DAY2;
       return {
         id: entity.id,
         title: entity.title,
@@ -26059,8 +26445,8 @@ async function runDuplicateStep(client3, entities, workspaceId, projectId) {
   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);
+  for (let i = 0;i < entities.length; i += CONCURRENCY_LIMIT2) {
+    const batch = entities.slice(i, i + CONCURRENCY_LIMIT2);
     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 };
@@ -26212,6 +26598,20 @@ function generateHealthReport(report) {
 `);
     }
   }
+  if (report.steps.audit) {
+    const a = report.steps.audit;
+    lines.push("## Quality Audit");
+    lines.push(`Scanned ${a.scanned} entities. Legacy signals on ${a.legacyCount}.`);
+    lines.push(`Buckets — keep: ${a.buckets.keep}, review: ${a.buckets.review}, archive: ${a.buckets.archive}, delete: ${a.buckets.delete}.`);
+    if (!report.dryRun) {
+      lines.push(`Actions — flagged: ${a.actions.flaggedReview}, archived: ${a.actions.archived}, deleted: ${a.actions.deleted}.`);
+    }
+    if (a.report.lowest.length > 0) {
+      const worst = a.report.lowest[0];
+      lines.push(`Lowest score: **${worst.score}** — "${worst.title}" (${worst.reasons.slice(0, 2).join(", ") || "—"}).`);
+    }
+    lines.push("");
+  }
   if (report.errors.length > 0) {
     lines.push("## Errors");
     for (const e of report.errors) {
@@ -26256,7 +26656,7 @@ async function purgeMemories(client3, workspaceId, projectId, options) {
         continue;
       if (filters.olderThanDays !== undefined) {
         const ref = entity.last_accessed_at || entity.created_at;
-        const ageDays = (now - new Date(ref).getTime()) / MS_PER_DAY;
+        const ageDays = (now - new Date(ref).getTime()) / MS_PER_DAY2;
         if (ageDays < filters.olderThanDays)
           continue;
       }
@@ -26272,13 +26672,13 @@ async function purgeMemories(client3, workspaceId, projectId, options) {
     type: e.type,
     tier: e.memory_tier,
     confidence: e.confidence,
-    ageDays: Math.round((now - new Date(e.last_accessed_at || e.created_at).getTime()) / MS_PER_DAY)
+    ageDays: Math.round((now - new Date(e.last_accessed_at || e.created_at).getTime()) / MS_PER_DAY2)
   }));
   const errors3 = [];
   let purged = 0;
   if (!dryRun) {
-    for (let i = 0;i < allMatches.length; i += CONCURRENCY_LIMIT) {
-      const batch = allMatches.slice(i, i + CONCURRENCY_LIMIT);
+    for (let i = 0;i < allMatches.length; i += CONCURRENCY_LIMIT2) {
+      const batch = allMatches.slice(i, i + CONCURRENCY_LIMIT2);
       const results = await Promise.allSettled(batch.map((e) => client3.deleteMemoryEntity(e.id)));
       for (let j = 0;j < results.length; j++) {
         if (results[j].status === "fulfilled") {
@@ -27755,7 +28155,7 @@ var TOOLS = {
     }
   },
   harmony_cleanup_memories: {
-    description: "Run a unified memory cleanup: prune stale drafts, consolidate similar memories, detect orphans and duplicates, and backfill embeddings. Returns a health report. Dry-run by default — run with dryRun=false to execute.",
+    description: "Run a unified memory cleanup: prune stale drafts, consolidate similar memories, detect orphans and duplicates, backfill embeddings, and optionally run a quality audit. Returns a health report. Dry-run by default — run with dryRun=false to execute.",
     inputSchema: {
       type: "object",
       properties: {
@@ -27775,9 +28175,16 @@ var TOOLS = {
           type: "array",
           items: {
             type: "string",
-            enum: ["prune", "consolidate", "orphans", "duplicates", "backfill"]
+            enum: [
+              "prune",
+              "consolidate",
+              "orphans",
+              "duplicates",
+              "backfill",
+              "audit"
+            ]
           },
-          description: "Which cleanup steps to run (default: all). Options: prune, consolidate, orphans, duplicates, backfill."
+          description: "Which cleanup steps to run (default: all). Options: prune, consolidate, orphans, duplicates, backfill, audit."
         },
         maxAgeDays: {
           type: "number",
@@ -27790,6 +28197,51 @@ var TOOLS = {
         orphanAgeDays: {
           type: "number",
           description: "Min age in days for orphan detection (default: 14)"
+        },
+        auditArchiveBelow: {
+          type: "number",
+          description: "Audit: archive entities scoring below this (default: 40)"
+        },
+        auditDeleteBelow: {
+          type: "number",
+          description: "Audit: delete entities scoring below this (default: 20)"
+        }
+      },
+      required: []
+    }
+  },
+  harmony_audit_memories: {
+    description: "Rate every memory against state-of-the-art quality standards (confidence, decay, structural completeness, content, tier-age fit, access). Flags legacy entities from before recent optimizations (default confidence, missing embeddings, stuck drafts). Buckets: keep (≥70), review (40-69), archive (20-39), delete (<20). Dry-run by default.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (optional)"
+        },
+        dryRun: {
+          type: "boolean",
+          description: "Preview audit without flagging/archiving/deleting (default: true)"
+        },
+        archiveBelow: {
+          type: "number",
+          description: "Score threshold below which entities are archived (confidence set to 0.25). Default: 40"
+        },
+        deleteBelow: {
+          type: "number",
+          description: "Score threshold below which entities are hard-deleted. Default: 20. Set to 0 to never delete."
+        },
+        limit: {
+          type: "number",
+          description: "Max number of entities to audit (default: 500). Paginated fetch."
+        },
+        staleDraftAgeDays: {
+          type: "number",
+          description: "Age threshold (days) for the stale-draft filter: flags drafts with 0 accesses older than this. Reported separately from bucket scoring — surfaces promote-or-drop candidates the thresholds miss. Default: 7."
         }
       },
       required: []
@@ -29359,6 +29811,32 @@ async function handleToolCall(name, args, deps) {
         message: `Processed ${entitiesProcessed} entities, created ${relationsCreated} new relations.`
       };
     }
+    case "harmony_audit_memories": {
+      const workspaceId = args.workspaceId || deps.getActiveWorkspaceId();
+      if (!workspaceId) {
+        throw new Error("No workspace specified. Use harmony_set_workspace_context or provide workspaceId.");
+      }
+      const projectId = args.projectId || deps.getActiveProjectId() || undefined;
+      const report = await runMemoryAudit(client3, workspaceId, projectId, {
+        dryRun: args.dryRun,
+        archiveBelow: args.archiveBelow,
+        deleteBelow: args.deleteBelow,
+        limit: args.limit,
+        staleDraftAgeDays: args.staleDraftAgeDays
+      });
+      return {
+        success: report.success,
+        dryRun: report.dryRun,
+        summary: report.summary,
+        distribution: report.distribution,
+        legacyBreakdown: report.legacyBreakdown,
+        actionsTaken: report.actionsTaken,
+        lowest: report.lowest,
+        staleDrafts: report.staleDrafts,
+        errors: report.errors,
+        healthReport: report.healthReport
+      };
+    }
     case "harmony_cleanup_memories": {
       const workspaceId = args.workspaceId || deps.getActiveWorkspaceId();
       if (!workspaceId) {
@@ -29370,7 +29848,8 @@ async function handleToolCall(name, args, deps) {
         "consolidate",
         "orphans",
         "duplicates",
-        "backfill"
+        "backfill",
+        "audit"
       ];
       const rawSteps = args.steps;
       const steps = rawSteps?.filter((s) => validSteps.includes(s));
@@ -29383,7 +29862,9 @@ async function handleToolCall(name, args, deps) {
         steps,
         maxAgeDays: args.maxAgeDays,
         minClusterSize: args.minClusterSize,
-        orphanAgeDays: args.orphanAgeDays
+        orphanAgeDays: args.orphanAgeDays,
+        auditArchiveBelow: args.auditArchiveBelow,
+        auditDeleteBelow: args.auditDeleteBelow
       });
       return {
         success: report.success,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethmy/mcp",
-  "version": "2.3.4",
+  "version": "2.4.1",
   "description": "MCP server for Harmony Kanban board - enables AI coding agents to manage your boards",
   "publishConfig": {
     "access": "public"
@@ -59,7 +59,7 @@
     "serve:remote": "bun src/remote.ts",
     "dev": "bun --watch src/index.ts",
     "test": "bun run test:unit && bun run test:integration",
-    "test:unit": "bun test src/__tests__/active-learning.test.ts src/__tests__/context-assembly.test.ts src/__tests__/prompt-builder.test.ts",
+    "test:unit": "bun test src/__tests__/active-learning.test.ts src/__tests__/context-assembly.test.ts src/__tests__/prompt-builder.test.ts src/__tests__/memory-audit.test.ts",
     "test:integration": "bun test src/__tests__/integration-memory-system.test.ts src/__tests__/integration-memory-crud.test.ts",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "bun run build"