@gethmy/mcp 2.3.3 → 2.4.0

package/dist/index.js

@@ -25823,6 +25823,334 @@ 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) {
+  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";
+  return {
+    id: entity.id,
+    title: entity.title,
+    type: entity.type,
+    tier: entity.memory_tier,
+    ageDays: Math.round(ageDays),
+    score,
+    bucket,
+    reasons,
+    legacy,
+    legacyReasons,
+    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 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
+    },
+    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: [],
+    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);
+    audits.push(audit);
+    report.summary.scanned++;
+    report.summary[audit.bucket]++;
+    if (audit.legacy)
+      report.summary.legacyCount++;
+    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);
+  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}`,
+    "",
+    "## 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.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 +26158,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 +26320,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 +26366,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 +26387,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 +26426,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 +26579,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) {
@@ -26225,6 +26606,85 @@ function generateHealthReport(report) {
   return lines.join(`
 `);
 }
+async function purgeMemories(client3, workspaceId, projectId, options) {
+  const dryRun = options.dryRun !== false;
+  const { filters } = options;
+  const hasFilter = filters.tier || filters.scope || filters.type || filters.olderThanDays !== undefined || filters.maxConfidence !== undefined || filters.tags && filters.tags.length > 0;
+  if (!hasFilter) {
+    throw new Error("At least one narrowing filter (tier, scope, type, olderThanDays, maxConfidence, tags) is required.");
+  }
+  const allMatches = [];
+  let offset = 0;
+  const pageSize = 100;
+  const now = Date.now();
+  while (true) {
+    const result = await client3.listMemoryEntities({
+      workspace_id: workspaceId,
+      project_id: projectId,
+      type: filters.type,
+      scope: filters.scope,
+      tags: filters.tags,
+      limit: pageSize,
+      offset
+    });
+    const entities = result.entities || [];
+    if (entities.length === 0)
+      break;
+    for (const entity of entities) {
+      if (filters.tier && entity.memory_tier !== filters.tier)
+        continue;
+      if (filters.maxConfidence !== undefined && entity.confidence > filters.maxConfidence)
+        continue;
+      if (filters.olderThanDays !== undefined) {
+        const ref = entity.last_accessed_at || entity.created_at;
+        const ageDays = (now - new Date(ref).getTime()) / MS_PER_DAY2;
+        if (ageDays < filters.olderThanDays)
+          continue;
+      }
+      allMatches.push(entity);
+    }
+    if (entities.length < pageSize)
+      break;
+    offset += pageSize;
+  }
+  const items = allMatches.map((e) => ({
+    id: e.id,
+    title: e.title,
+    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_DAY2)
+  }));
+  const errors3 = [];
+  let purged = 0;
+  if (!dryRun) {
+    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") {
+          purged++;
+        } else {
+          errors3.push({
+            entityId: batch[j].id,
+            message: results[j].status === "rejected" ? String(results[j].reason) : "Unknown error"
+          });
+        }
+      }
+    }
+  }
+  return {
+    success: errors3.length === 0,
+    dryRun,
+    timestamp: new Date().toISOString(),
+    workspace: { id: workspaceId, projectId },
+    filters,
+    matched: allMatches.length,
+    purged: dryRun ? 0 : purged,
+    items,
+    errors: errors3
+  };
+}
 
 // src/onboard.ts
 async function onboardNewUser(params) {
@@ -26820,6 +27280,20 @@ var TOOLS = {
         estimatedMinutesRemaining: {
           type: "number",
           description: "Updated time estimate"
+        },
+        actions: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              description: {
+                type: "string",
+                description: "What was done, e.g. 'Edited CardDetailSheet.tsx — added done toggle'"
+              }
+            },
+            required: ["description"]
+          },
+          description: "Actions performed since last update. Each becomes a visible activity log entry."
         }
       },
       required: ["cardId", "agentIdentifier", "agentName"]
@@ -27662,7 +28136,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: {
@@ -27682,9 +28156,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",
@@ -27697,6 +28178,94 @@ 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."
+        }
+      },
+      required: []
+    }
+  },
+  harmony_purge_memories: {
+    description: "Bulk-delete memory entities matching filters within a project. Requires at least one narrowing filter (tier, scope, type, olderThanDays, maxConfidence, tags). Dry-run by default — preview what would be deleted before executing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID (required — purge is project-scoped). Falls back to active project context."
+        },
+        dryRun: {
+          type: "boolean",
+          description: "Preview what would be deleted without executing (default: true)"
+        },
+        tier: {
+          type: "string",
+          enum: ["draft", "episode", "reference"],
+          description: 'Filter by memory tier (e.g. "draft")'
+        },
+        scope: {
+          type: "string",
+          description: 'Filter by scope (e.g. "private", "project", "workspace")'
+        },
+        type: {
+          type: "string",
+          description: 'Filter by entity type (e.g. "error", "pattern", "lesson", "decision")'
+        },
+        olderThanDays: {
+          type: "number",
+          description: "Only include entities not accessed in at least this many days"
+        },
+        maxConfidence: {
+          type: "number",
+          description: "Only include entities with confidence at or below this value (e.g. 0.3 for low-confidence junk)"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Only include entities matching these tags"
         }
       },
       required: []
@@ -28330,12 +28899,20 @@ async function handleToolCall(name, args, deps) {
       const agentIdentifier = exports_external.string().min(1).max(100).parse(args.agentIdentifier);
       const agentName = exports_external.string().min(1).max(100).parse(args.agentName);
       const progressPercent = args.progressPercent !== undefined ? exports_external.number().min(0).max(100).parse(args.progressPercent) : undefined;
-      const callerRecentActions = args.recentActions;
+      const callerActions = args.actions;
+      const now = new Date().toISOString();
+      const callerRecentActions = [
+        ...args.recentActions || [],
+        ...(callerActions || []).map((a) => ({
+          action: a.description,
+          ts: now
+        }))
+      ];
       const memSession = getMemorySession(cardId);
       let mergedRecentActions;
       if (memSession?.dirty) {
-        mergedRecentActions = mergeMemoryActionsInto(cardId, callerRecentActions || []);
-      } else if (callerRecentActions) {
+        mergedRecentActions = mergeMemoryActionsInto(cardId, callerRecentActions);
+      } else if (callerRecentActions.length > 0) {
         mergedRecentActions = callerRecentActions;
       }
       const result = await client3.updateAgentProgress(cardId, {
@@ -29211,6 +29788,30 @@ 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
+      });
+      return {
+        success: report.success,
+        dryRun: report.dryRun,
+        summary: report.summary,
+        distribution: report.distribution,
+        legacyBreakdown: report.legacyBreakdown,
+        actionsTaken: report.actionsTaken,
+        lowest: report.lowest,
+        errors: report.errors,
+        healthReport: report.healthReport
+      };
+    }
     case "harmony_cleanup_memories": {
       const workspaceId = args.workspaceId || deps.getActiveWorkspaceId();
       if (!workspaceId) {
@@ -29222,7 +29823,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));
@@ -29235,7 +29837,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,
@@ -29245,6 +29849,42 @@ async function handleToolCall(name, args, deps) {
         healthReport: report.healthReport
       };
     }
+    case "harmony_purge_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();
+      if (!projectId) {
+        throw new Error("No project specified. Purge requires a project scope. Use harmony_set_project_context or provide projectId.");
+      }
+      const filters = {};
+      if (args.tier)
+        filters.tier = args.tier;
+      if (args.scope)
+        filters.scope = args.scope;
+      if (args.type)
+        filters.type = args.type;
+      if (args.olderThanDays !== undefined)
+        filters.olderThanDays = args.olderThanDays;
+      if (args.maxConfidence !== undefined)
+        filters.maxConfidence = args.maxConfidence;
+      if (args.tags)
+        filters.tags = args.tags;
+      const report = await purgeMemories(client3, workspaceId, projectId, {
+        dryRun: args.dryRun,
+        filters
+      });
+      return {
+        success: report.success,
+        dryRun: report.dryRun,
+        matched: report.matched,
+        purged: report.purged,
+        items: report.items,
+        errors: report.errors,
+        message: report.dryRun ? `Found ${report.matched} entities matching filters. Run with dryRun=false to delete.` : `Purged ${report.purged} of ${report.matched} matching entities.`
+      };
+    }
     default:
       throw new Error(`Unknown tool: ${name}`);
   }
@@ -29282,15 +29922,26 @@ class HarmonyMCPServer {
       const cv = this.server.getClientVersion();
       return cv ? { name: cv.name, version: cv.version } : null;
     });
+    let exitCode = 0;
     const handleShutdown = async () => {
       try {
         await shutdownAllSessions();
       } catch {}
       destroyAutoSession();
-      process.exit(0);
+      process.exit(exitCode);
     };
     process.on("SIGINT", handleShutdown);
     process.on("SIGTERM", handleShutdown);
+    process.on("uncaughtException", (err) => {
+      console.error("MCP server uncaught exception:", err);
+      exitCode = 1;
+      handleShutdown();
+    });
+    process.on("unhandledRejection", (reason) => {
+      console.error("MCP server unhandled rejection:", reason);
+      exitCode = 1;
+      handleShutdown();
+    });
     try {
       if (isConfigured()) {
         const workspaceId = getActiveWorkspaceId();