@gethmy/mcp 2.3.1 → 2.3.2

package/dist/lib/memory-cleanup.js

@@ -1,455 +1,1361 @@
-/**
- * Unified Memory Cleanup
- *
- * Orchestrates a 5-stage cleanup pipeline: prune stale drafts, consolidate
- * similar memories, detect orphans, detect duplicates, and backfill embeddings.
- *
- * All stages are non-fatal — individual failures are collected but never block
- * the remaining stages. Defaults to dry-run mode (preview only).
- */
-import { evaluateLifecycle } from "@harmony/memory";
-import { consolidateMemories, } from "./consolidation.js";
-import { findSimilarEntities } from "./graph-expansion.js";
-const ALL_STEPS = [
-    "prune",
-    "consolidate",
-    "orphans",
-    "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
-// ---------------------------------------------------------------------------
-export async function runMemoryCleanup(client, workspaceId, projectId, options) {
-    const dryRun = options?.dryRun !== false;
-    const steps = options?.steps ?? ALL_STEPS;
-    const maxAgeDays = options?.maxAgeDays ?? 30;
-    const minClusterSize = options?.minClusterSize ?? 3;
-    const orphanAgeDays = options?.orphanAgeDays ?? 14;
-    const report = {
-        success: true,
-        dryRun,
-        timestamp: new Date().toISOString(),
-        workspace: { id: workspaceId, projectId },
-        summary: { totalEntities: 0, issuesFound: 0, actionsTaken: 0 },
-        steps: {},
-        errors: [],
-        healthReport: "",
-    };
-    // Fetch all entities once (shared across steps)
-    let entities = [];
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../memory/dist/schema.js
+var init_schema = () => {};
+
+// ../memory/dist/constraints.js
+var init_constraints = __esm(() => {
+  init_schema();
+});
+// ../memory/dist/client.js
+var init_client = __esm(() => {
+  init_constraints();
+});
+
+// ../memory/dist/graph-walk.js
+async function discoverRelatedContext(client, startIds, maxDepth = 2, maxEntities = 20, minConfidence = 0.5) {
+  const visited = new Set;
+  const collectedEntities = [];
+  const collectedRelations = [];
+  let truncated = false;
+  const queue = startIds.map((id) => [id, 0]);
+  for (const id of startIds) {
+    visited.add(id);
+  }
+  while (queue.length > 0) {
+    const [entityId, depth] = queue.shift();
+    if (collectedEntities.length >= maxEntities) {
+      truncated = true;
+      break;
+    }
+    if (depth > maxDepth)
+      continue;
     try {
-        const listResult = await client.listMemoryEntities({
-            workspace_id: workspaceId,
-            project_id: projectId,
-            limit: MAX_ENTITIES_FETCH,
+      const entityResult = await client.getMemoryEntity(entityId);
+      const entity = entityResult.entity;
+      if (entity) {
+        collectedEntities.push({
+          id: entity.id,
+          type: entity.type,
+          title: entity.title,
+          confidence: entity.confidence ?? 1,
+          memory_tier: entity.memory_tier || "reference"
         });
-        entities = (listResult.entities || []);
-        report.summary.totalEntities = entities.length;
+      }
+      if (depth >= maxDepth)
+        continue;
+      const related = await client.getRelatedEntities(entityId);
+      for (const raw of related.outgoing || []) {
+        const rel = raw;
+        const relConfidence = rel.confidence ?? 1;
+        if (relConfidence < minConfidence)
+          continue;
+        const target = rel.target;
+        const targetId = target?.id ?? rel.target_id;
+        if (targetId && !visited.has(targetId)) {
+          visited.add(targetId);
+          queue.push([targetId, depth + 1]);
+          collectedRelations.push({
+            id: rel.id,
+            source_id: entityId,
+            target_id: targetId,
+            relation_type: rel.relation_type,
+            confidence: relConfidence
+          });
+        }
+      }
+      for (const raw of related.incoming || []) {
+        const rel = raw;
+        const relConfidence = rel.confidence ?? 1;
+        if (relConfidence < minConfidence)
+          continue;
+        const source = rel.source;
+        const sourceId = source?.id ?? rel.source_id;
+        if (sourceId && !visited.has(sourceId)) {
+          visited.add(sourceId);
+          queue.push([sourceId, depth + 1]);
+          collectedRelations.push({
+            id: rel.id,
+            source_id: sourceId,
+            target_id: entityId,
+            relation_type: rel.relation_type,
+            confidence: relConfidence
+          });
+        }
+      }
+    } catch {}
+  }
+  return {
+    entities: collectedEntities,
+    relations: collectedRelations,
+    depth: maxDepth,
+    truncated
+  };
+}
+
+// ../memory/dist/lifecycle.js
+function computeDecayScore(tier, lastAccessedAt, accessCount) {
+  const halfLife = DECAY_HALF_LIVES[tier];
+  const now = Date.now();
+  let daysSinceAccess = 0;
+  if (lastAccessedAt) {
+    daysSinceAccess = (now - new Date(lastAccessedAt).getTime()) / (1000 * 60 * 60 * 24);
+  }
+  const timeDecay = 0.5 ** (daysSinceAccess / halfLife);
+  const accessBonus = Math.log10(accessCount + 1) * 0.1;
+  const score = Math.min(timeDecay + accessBonus, 1);
+  return { score, daysSinceAccess, halfLife, accessBonus };
+}
+function checkPromotion(currentTier, accessCount, confidence, createdAt) {
+  const ageDays = (Date.now() - new Date(createdAt).getTime()) / (1000 * 60 * 60 * 24);
+  const base = {
+    eligible: false,
+    targetTier: null,
+    reason: null,
+    currentTier,
+    accessCount,
+    confidence,
+    ageDays
+  };
+  if (currentTier === "draft") {
+    const rules = PROMOTION_RULES.draftToEpisode;
+    if (accessCount >= rules.minAccessCount && confidence >= rules.minConfidence && ageDays >= rules.minAgeDays) {
+      return {
+        ...base,
+        eligible: true,
+        targetTier: "episode",
+        reason: `Accessed ${accessCount} times (≥${rules.minAccessCount}), confidence ${confidence} (≥${rules.minConfidence}), age ${Math.round(ageDays)}d (≥${rules.minAgeDays}d)`
+      };
     }
-    catch (err) {
-        report.errors.push({
-            step: "init",
-            message: `Failed to fetch entities: ${err.message}`,
-        });
-        report.success = false;
-        report.healthReport = generateHealthReport(report);
-        return report;
+  }
+  if (currentTier === "episode") {
+    const rules = PROMOTION_RULES.episodeToReference;
+    if (accessCount >= rules.minAccessCount && confidence >= rules.minConfidence && ageDays >= rules.minAgeDays) {
+      return {
+        ...base,
+        eligible: true,
+        targetTier: "reference",
+        reason: `Accessed ${accessCount} times (≥${rules.minAccessCount}), confidence ${confidence} (≥${rules.minConfidence}), age ${Math.round(ageDays)}d (≥${rules.minAgeDays}d)`
+      };
     }
-    // Stage 1: Prune stale drafts
-    if (steps.includes("prune")) {
-        try {
-            report.steps.prune = runPruneStep(entities, maxAgeDays);
-            if (!dryRun) {
-                for (const item of report.steps.prune.items) {
-                    try {
-                        await client.deleteMemoryEntity(item.id);
-                        report.steps.prune.pruned++;
-                    }
-                    catch (err) {
-                        report.errors.push({
-                            step: "prune",
-                            message: `Failed to delete ${item.id}: ${err.message}`,
-                        });
-                    }
-                }
-                report.summary.actionsTaken += report.steps.prune.pruned;
-            }
-            report.summary.issuesFound += report.steps.prune.staleDraftsFound;
+  }
+  return base;
+}
+function evaluateLifecycle(entity) {
+  const decay = computeDecayScore(entity.memory_tier, entity.last_accessed_at, entity.access_count);
+  const promotion = checkPromotion(entity.memory_tier, entity.access_count, entity.confidence, entity.created_at);
+  const shouldArchive = entity.confidence < ARCHIVE_THRESHOLD;
+  const archiveReason = shouldArchive ? `Confidence ${entity.confidence} below threshold ${ARCHIVE_THRESHOLD}` : undefined;
+  const shouldFlagForReview = decay.daysSinceAccess >= STALE_DAYS && entity.access_count < STALE_MIN_ACCESS;
+  const reviewReason = shouldFlagForReview ? `Not accessed in ${Math.round(decay.daysSinceAccess)} days with only ${entity.access_count} accesses` : undefined;
+  return {
+    decay,
+    promotion,
+    shouldArchive,
+    shouldFlagForReview,
+    archiveReason,
+    reviewReason
+  };
+}
+var DECAY_HALF_LIVES, PROMOTION_RULES, ARCHIVE_THRESHOLD = 0.3, STALE_DAYS = 90, STALE_MIN_ACCESS = 3;
+var init_lifecycle = __esm(() => {
+  DECAY_HALF_LIVES = {
+    draft: 7,
+    episode: 30,
+    reference: 180
+  };
+  PROMOTION_RULES = {
+    draftToEpisode: {
+      minAccessCount: 5,
+      minConfidence: 0.8,
+      minAgeDays: 1
+    },
+    episodeToReference: {
+      minAccessCount: 10,
+      minConfidence: 0.9,
+      minAgeDays: 7
+    }
+  };
+});
+
+// ../memory/dist/sync-storage.js
+function parseSyncMarkdown(markdown) {
+  const trimmed = markdown.trim();
+  let frontmatter = {
+    type: "context",
+    scope: "project",
+    tier: "reference",
+    confidence: 1,
+    tags: []
+  };
+  let body = trimmed;
+  const fmMatch = trimmed.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (fmMatch) {
+    frontmatter = parseSyncYamlFrontmatter(fmMatch[1]);
+    body = fmMatch[2].trim();
+  }
+  let title = "";
+  const titleMatch = body.match(/^#\s+(.+)/m);
+  if (titleMatch) {
+    title = titleMatch[1].trim();
+    body = body.replace(/^#\s+.+\n?/, "").trim();
+  }
+  return { frontmatter, title, content: body };
+}
+function serializeSyncMarkdown(entity) {
+  const lines = ["---"];
+  lines.push(`id: ${entity.id}`);
+  lines.push(`workspace_id: ${entity.workspace_id}`);
+  if (entity.project_id) {
+    lines.push(`project_id: ${entity.project_id}`);
+  }
+  lines.push(`type: ${entity.type}`);
+  lines.push(`scope: ${entity.scope}`);
+  lines.push(`tier: ${entity.memory_tier || "reference"}`);
+  lines.push(`confidence: ${entity.confidence}`);
+  if (entity.tags.length > 0) {
+    lines.push(`tags: [${entity.tags.join(", ")}]`);
+  } else {
+    lines.push("tags: []");
+  }
+  if (entity.agent_identifier) {
+    lines.push(`agent: ${entity.agent_identifier}`);
+  }
+  lines.push(`created_at: ${entity.created_at}`);
+  lines.push(`updated_at: ${entity.updated_at}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${entity.title}`);
+  lines.push("");
+  lines.push(entity.content);
+  return lines.join(`
+`);
+}
+function parseSyncYamlFrontmatter(yaml) {
+  const result = {
+    type: "context",
+    scope: "project",
+    tier: "reference",
+    confidence: 1,
+    tags: []
+  };
+  for (const line of yaml.split(`
+`)) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    switch (key) {
+      case "id":
+        result.id = value;
+        break;
+      case "workspace_id":
+        result.workspace_id = value;
+        break;
+      case "project_id":
+        result.project_id = value;
+        break;
+      case "type":
+        result.type = value;
+        break;
+      case "scope":
+        result.scope = value;
+        break;
+      case "tier":
+        result.tier = value;
+        break;
+      case "confidence":
+        result.confidence = parseFloat(value) || 1;
+        break;
+      case "tags":
+        result.tags = parseYamlArray(value);
+        break;
+      case "related":
+        result.related = parseYamlArray(value);
+        break;
+      case "agent":
+        result.agent = value;
+        break;
+      case "created_at":
+        result.created_at = value;
+        break;
+      case "updated_at":
+        result.updated_at = value;
+        break;
+    }
+  }
+  return result;
+}
+function parseYamlArray(value) {
+  const match = value.match(/^\[(.*)]\s*$/);
+  if (!match)
+    return [];
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+
+// ../memory/dist/sync.js
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+function computeFileHash(content) {
+  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+function slugifyTitle(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+function entityToFilename(entity) {
+  const slug = slugifyTitle(entity.title);
+  const shortId = entity.id.slice(0, 8);
+  return `${entity.type}--${slug}--${shortId}.md`;
+}
+function entityToDirectoryPath(entity, memoryDir) {
+  const wsDir = join(memoryDir, entity.workspace_id);
+  if (entity.scope === "private") {
+    return join(wsDir, "_private");
+  }
+  if (entity.scope === "workspace" || !entity.project_id) {
+    return join(wsDir, "_workspace");
+  }
+  return join(wsDir, entity.project_id);
+}
+function emptySyncState() {
+  return { version: 1, lastPullAt: null, entities: {} };
+}
+function loadSyncState(memoryDir) {
+  const statePath = join(memoryDir, ".sync-state.json");
+  if (!existsSync(statePath))
+    return emptySyncState();
+  try {
+    return JSON.parse(readFileSync(statePath, "utf-8"));
+  } catch {
+    return emptySyncState();
+  }
+}
+function saveSyncState(memoryDir, state) {
+  if (!existsSync(memoryDir)) {
+    mkdirSync(memoryDir, { recursive: true });
+  }
+  writeFileSync(join(memoryDir, ".sync-state.json"), JSON.stringify(state, null, 2));
+}
+function writeEntityFile(entity, memoryDir) {
+  const dir = entityToDirectoryPath(entity, memoryDir);
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+  const filename = entityToFilename(entity);
+  const filePath = join(dir, filename);
+  const markdown = serializeSyncMarkdown(entity);
+  writeFileSync(filePath, markdown);
+  return relative(memoryDir, filePath);
+}
+function deleteEntityFile(relPath, memoryDir) {
+  const absPath = join(memoryDir, relPath);
+  if (existsSync(absPath)) {
+    rmSync(absPath);
+  }
+}
+function findMarkdownFiles(dir) {
+  const results = [];
+  if (!existsSync(dir))
+    return results;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findMarkdownFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+async function syncPull(client, config, workspaceId, projectId) {
+  const { memoryDir } = config;
+  const state = loadSyncState(memoryDir);
+  const result = {
+    pulled: 0,
+    pushed: 0,
+    deleted: 0,
+    conflicts: 0,
+    errors: []
+  };
+  const allEntities = [];
+  let offset = 0;
+  const batchSize = 100;
+  while (true) {
+    try {
+      const resp = await client.listMemoryEntities({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        limit: batchSize,
+        offset
+      });
+      const batch = resp.entities;
+      allEntities.push(...batch);
+      if (batch.length < batchSize)
+        break;
+      offset += batchSize;
+    } catch (err) {
+      result.errors.push(`Failed to fetch entities: ${err}`);
+      return result;
+    }
+  }
+  const remoteIds = new Set(allEntities.map((e) => e.id));
+  for (const entity of allEntities) {
+    const existing = state.entities[entity.id];
+    const markdown = serializeSyncMarkdown(entity);
+    const hash = computeFileHash(markdown);
+    if (!existing) {
+      const relPath = writeEntityFile(entity, memoryDir);
+      state.entities[entity.id] = {
+        filePath: relPath,
+        remoteUpdatedAt: entity.updated_at,
+        lastSyncedHash: hash
+      };
+      result.pulled++;
+    } else {
+      const remoteChanged = entity.updated_at > existing.remoteUpdatedAt;
+      if (!remoteChanged)
+        continue;
+      const absPath = join(memoryDir, existing.filePath);
+      let localChanged = false;
+      if (existsSync(absPath)) {
+        const localContent = readFileSync(absPath, "utf-8");
+        const localHash = computeFileHash(localContent);
+        localChanged = localHash !== existing.lastSyncedHash;
+      }
+      if (localChanged) {
+        result.conflicts++;
+      }
+      const newRelPath = writeEntityFile(entity, memoryDir);
+      if (existing.filePath !== newRelPath) {
+        deleteEntityFile(existing.filePath, memoryDir);
+      }
+      state.entities[entity.id] = {
+        filePath: newRelPath,
+        remoteUpdatedAt: entity.updated_at,
+        lastSyncedHash: hash
+      };
+      result.pulled++;
+    }
+  }
+  for (const [entityId, entry] of Object.entries(state.entities)) {
+    if (!remoteIds.has(entityId)) {
+      deleteEntityFile(entry.filePath, memoryDir);
+      delete state.entities[entityId];
+      result.deleted++;
+    }
+  }
+  state.lastPullAt = new Date().toISOString();
+  saveSyncState(memoryDir, state);
+  return result;
+}
+async function syncPush(client, config, workspaceId) {
+  const { memoryDir } = config;
+  const state = loadSyncState(memoryDir);
+  const result = {
+    pulled: 0,
+    pushed: 0,
+    deleted: 0,
+    conflicts: 0,
+    errors: []
+  };
+  const mdFiles = findMarkdownFiles(memoryDir);
+  for (const absPath of mdFiles) {
+    const content = readFileSync(absPath, "utf-8");
+    const hash = computeFileHash(content);
+    const parsed = parseSyncMarkdown(content);
+    if (parsed.frontmatter.id) {
+      const entityId = parsed.frontmatter.id;
+      const existing = state.entities[entityId];
+      if (existing && hash === existing.lastSyncedHash)
+        continue;
+      try {
+        const resp = await client.updateMemoryEntity(entityId, {
+          title: parsed.title || "Untitled",
+          content: parsed.content,
+          type: parsed.frontmatter.type,
+          scope: parsed.frontmatter.scope,
+          confidence: parsed.frontmatter.confidence,
+          tags: parsed.frontmatter.tags
+        });
+        const updated = resp.entity;
+        const newMarkdown = serializeSyncMarkdown(updated);
+        writeFileSync(absPath, newMarkdown);
+        const relPath = relative(memoryDir, absPath);
+        state.entities[entityId] = {
+          filePath: relPath,
+          remoteUpdatedAt: updated.updated_at,
+          lastSyncedHash: computeFileHash(newMarkdown)
+        };
+        result.pushed++;
+      } catch (err) {
+        result.errors.push(`Failed to update ${entityId}: ${err}`);
+      }
+    } else {
+      const relPath = relative(memoryDir, absPath);
+      const parts = relPath.split(sep);
+      const fileWorkspaceId = parts.length >= 2 ? parts[0] : workspaceId;
+      let fileProjectId;
+      if (parts.length >= 3) {
+        const scopeDir = parts[1];
+        if (scopeDir !== "_workspace" && scopeDir !== "_private") {
+          fileProjectId = scopeDir;
         }
-        catch (err) {
-            report.errors.push({
-                step: "prune",
-                message: err.message,
-            });
+      }
+      let scope = parsed.frontmatter.scope || "project";
+      if (parts.length >= 3) {
+        const scopeDir = parts[1];
+        if (scopeDir === "_private")
+          scope = "private";
+        else if (scopeDir === "_workspace")
+          scope = "workspace";
+      }
+      try {
+        const resp = await client.createMemoryEntity({
+          workspace_id: fileWorkspaceId,
+          project_id: fileProjectId,
+          type: parsed.frontmatter.type,
+          scope,
+          title: parsed.title || "Untitled",
+          content: parsed.content,
+          confidence: parsed.frontmatter.confidence,
+          tags: parsed.frontmatter.tags,
+          agent_identifier: parsed.frontmatter.agent
+        });
+        const created = resp.entity;
+        const dir = entityToDirectoryPath(created, memoryDir);
+        if (!existsSync(dir))
+          mkdirSync(dir, { recursive: true });
+        const newFilename = entityToFilename(created);
+        const newAbsPath = join(dir, newFilename);
+        const newMarkdown = serializeSyncMarkdown(created);
+        writeFileSync(newAbsPath, newMarkdown);
+        if (absPath !== newAbsPath && existsSync(absPath)) {
+          rmSync(absPath);
         }
+        const newRelPath = relative(memoryDir, newAbsPath);
+        state.entities[created.id] = {
+          filePath: newRelPath,
+          remoteUpdatedAt: created.updated_at,
+          lastSyncedHash: computeFileHash(newMarkdown)
+        };
+        result.pushed++;
+      } catch (err) {
+        result.errors.push(`Failed to create entity from ${relPath}: ${err}`);
+      }
+    }
+  }
+  saveSyncState(memoryDir, state);
+  return result;
+}
+async function syncFull(client, config, workspaceId, projectId) {
+  const pullResult = await syncPull(client, config, workspaceId, projectId);
+  const pushResult = await syncPush(client, config, workspaceId);
+  return {
+    pulled: pullResult.pulled,
+    pushed: pushResult.pushed,
+    deleted: pullResult.deleted,
+    conflicts: pullResult.conflicts,
+    errors: [...pullResult.errors, ...pushResult.errors]
+  };
+}
+var init_sync = () => {};
+
+// ../memory/dist/index.js
+var init_dist = __esm(() => {
+  init_client();
+  init_constraints();
+  init_lifecycle();
+  init_schema();
+  init_sync();
+});
+
+// src/graph-expansion.ts
+async function autoExpandGraph(client, entityId, title, content, _tags, workspaceId, projectId, maxRelations = 5) {
+  try {
+    const contentSnippet = content.slice(0, 200).trim();
+    const query = [title, contentSnippet].filter(Boolean).join(" ");
+    let candidates = [];
+    const { entities } = await client.searchMemoryEntities(workspaceId, query, {
+      project_id: projectId,
+      limit: 20
+    });
+    candidates = entities.filter((e) => e.id !== entityId).slice(0, maxRelations);
+    if (candidates.length === 0) {
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      const retry = await client.searchMemoryEntities(workspaceId, query, {
+        project_id: projectId,
+        limit: 20
+      });
+      candidates = retry.entities.filter((e) => e.id !== entityId).slice(0, maxRelations);
+    }
+    let relationsCreated = 0;
+    for (const candidate of candidates) {
+      try {
+        await client.createMemoryRelation({
+          source_id: entityId,
+          target_id: candidate.id,
+          relation_type: "relates_to",
+          confidence: 0.6
+        });
+        relationsCreated++;
+      } catch (err) {
+        const status = err?.status;
+        if (status !== 409) {}
+      }
     }
-    // Stage 2: Consolidate similar memories
-    if (steps.includes("consolidate")) {
+    return { relationsCreated };
+  } catch {
+    return { relationsCreated: 0 };
+  }
+}
+async function findSimilarEntities(client, title, content, workspaceId, options) {
+  const contentSnippet = content.slice(0, 200).trim();
+  const query = [title, contentSnippet].filter(Boolean).join(" ");
+  try {
+    const { entities } = await client.searchMemoryEntities(workspaceId, query, {
+      project_id: options?.projectId,
+      limit: options?.limit ?? 20,
+      type: options?.type
+    });
+    const minScore = options?.minRrfScore ?? 0;
+    const excludeSet = new Set(options?.excludeIds || []);
+    return entities.filter((e) => {
+      if (excludeSet.has(e.id))
+        return false;
+      if (minScore > 0 && (e.rrf_score ?? 0) < minScore)
+        return false;
+      return true;
+    });
+  } catch {
+    return [];
+  }
+}
+var CAUSAL_LOOKUP = [
+  {
+    sourceType: "error",
+    targetType: "solution",
+    relation: "resolved_by",
+    direction: "forward"
+  },
+  {
+    sourceType: "solution",
+    targetType: "error",
+    relation: "resolved_by",
+    direction: "reverse"
+  },
+  {
+    sourceType: "lesson",
+    targetType: "error",
+    relation: "learned_from",
+    direction: "forward"
+  }
+];
+async function linkCrossTypeNeighbors(client, entityId, entityType, title, content, workspaceId, projectId) {
+  const rules = CAUSAL_LOOKUP.filter((r) => r.sourceType === entityType);
+  if (rules.length === 0)
+    return { relationsCreated: 0 };
+  let relationsCreated = 0;
+  for (const rule of rules) {
+    try {
+      const matches = await findSimilarEntities(client, title, content, workspaceId, {
+        projectId,
+        limit: 10,
+        minRrfScore: 0.04,
+        excludeIds: [entityId],
+        type: rule.targetType
+      });
+      for (const match of matches.slice(0, 3)) {
+        const sourceId = rule.direction === "forward" ? entityId : match.id;
+        const targetId = rule.direction === "forward" ? match.id : entityId;
         try {
-            const result = await consolidateMemories(client, workspaceId, projectId, {
-                dryRun,
-                minClusterSize,
-            });
-            report.steps.consolidate = {
-                clustersFound: result.clustersFound,
-                entitiesProcessed: result.entitiesProcessed,
-                consolidated: result.consolidated,
-                details: result.details,
-            };
-            report.summary.issuesFound += result.clustersFound;
-            if (!dryRun)
-                report.summary.actionsTaken += result.consolidated;
+          await client.createMemoryRelation({
+            source_id: sourceId,
+            target_id: targetId,
+            relation_type: rule.relation,
+            confidence: 0.65
+          });
+          relationsCreated++;
+        } catch {}
+      }
+    } catch {}
+  }
+  return { relationsCreated };
+}
+
+// src/consolidation.ts
+async function consolidateMemories(client, workspaceId, projectId, options) {
+  const dryRun = options?.dryRun !== false;
+  const minClusterSize = options?.minClusterSize ?? 3;
+  const result = {
+    consolidated: 0,
+    clustersFound: 0,
+    entitiesProcessed: 0,
+    details: []
+  };
+  const listResult = await client.listMemoryEntities({
+    workspace_id: workspaceId,
+    project_id: projectId,
+    limit: 100
+  });
+  const allEntities = (listResult.entities || []).filter((e) => e.memory_tier === "draft" || e.memory_tier === "episode");
+  result.entitiesProcessed = allEntities.length;
+  if (allEntities.length < minClusterSize)
+    return result;
+  const typeGroups = new Map;
+  for (const entity of allEntities) {
+    const group = typeGroups.get(entity.type) || [];
+    group.push(entity);
+    typeGroups.set(entity.type, group);
+  }
+  for (const [type, entities] of typeGroups) {
+    if (entities.length < minClusterSize)
+      continue;
+    const clustered = new Set;
+    const clusters = [];
+    for (const entity of entities) {
+      if (clustered.has(entity.id))
+        continue;
+      const similar = await findSimilarEntities(client, entity.title, entity.content, workspaceId, {
+        projectId,
+        limit: 20,
+        minRrfScore: 0.01,
+        excludeIds: [...clustered]
+      });
+      const entityIdSet = new Set(entities.map((e) => e.id));
+      const clusterMembers = similar.filter((s) => entityIdSet.has(s.id) && !clustered.has(s.id) && s.id !== entity.id && s.type === type);
+      if (clusterMembers.length >= minClusterSize - 1) {
+        const cluster = [
+          entity,
+          ...clusterMembers.slice(0, 5).map((s) => {
+            return entities.find((e) => e.id === s.id) || entity;
+          })
+        ];
+        const uniqueCluster = [];
+        const seen = new Set;
+        for (const member of cluster) {
+          if (!seen.has(member.id)) {
+            seen.add(member.id);
+            uniqueCluster.push(member);
+          }
         }
-        catch (err) {
-            report.errors.push({
-                step: "consolidate",
-                message: err.message,
-            });
+        if (uniqueCluster.length >= minClusterSize) {
+          clusters.push(uniqueCluster);
+          for (const member of uniqueCluster) {
+            clustered.add(member.id);
+          }
         }
+      }
     }
-    // Stage 3: Detect orphans
-    if (steps.includes("orphans")) {
+    for (const cluster of clusters) {
+      result.clustersFound++;
+      const mergedTitle = deriveClusterTitle(cluster, type);
+      const memberTitles = cluster.map((e) => e.title);
+      const mergedContent = synthesizeClusterContent(cluster, type);
+      const maxConfidence = Math.max(...cluster.map((e) => e.confidence));
+      const allTags = [...new Set(cluster.flatMap((e) => e.tags || []))];
+      const detail = {
+        clusterSize: cluster.length,
+        mergedTitle,
+        memberTitles
+      };
+      if (!dryRun) {
         try {
-            report.steps.orphans = await runOrphanStep(client, entities, orphanAgeDays);
-            if (!dryRun) {
-                for (const item of report.steps.orphans.items) {
-                    try {
-                        await client.deleteMemoryEntity(item.id);
-                        report.steps.orphans.removed++;
-                    }
-                    catch (err) {
-                        report.errors.push({
-                            step: "orphans",
-                            message: `Failed to delete ${item.id}: ${err.message}`,
-                        });
-                    }
-                }
-                report.summary.actionsTaken += report.steps.orphans.removed;
+          const createResult = await client.createMemoryEntity({
+            workspace_id: workspaceId,
+            project_id: projectId,
+            type,
+            scope: "project",
+            memory_tier: "reference",
+            title: mergedTitle,
+            content: mergedContent,
+            confidence: maxConfidence,
+            tags: [...allTags.slice(0, 15), "consolidated"],
+            metadata: {
+              source: "consolidation",
+              member_ids: cluster.map((e) => e.id),
+              consolidated_at: new Date().toISOString()
             }
-            report.summary.issuesFound += report.steps.orphans.orphansFound;
-        }
-        catch (err) {
+          });
+          const newEntity = createResult.entity;
+          if (newEntity?.id) {
+            detail.entityId = newEntity.id;
+            for (const member of cluster) {
+              try {
+                await client.createMemoryRelation({
+                  source_id: member.id,
+                  target_id: newEntity.id,
+                  relation_type: "part_of",
+                  confidence: 0.8
+                });
+              } catch {}
+            }
+            for (const member of cluster) {
+              try {
+                const newConf = Math.max(member.confidence - 0.3, 0.1);
+                await client.updateMemoryEntity(member.id, {
+                  confidence: newConf,
+                  metadata: {
+                    consolidated_into: newEntity.id,
+                    original_confidence: member.confidence
+                  }
+                });
+              } catch {}
+            }
+            result.consolidated++;
+          }
+        } catch {}
+      } else {
+        result.consolidated++;
+      }
+      result.details.push(detail);
+    }
+  }
+  return result;
+}
+function synthesizeClusterContent(cluster, type) {
+  const SKIP_PATTERNS = [
+    /^##\s/,
+    /^Agent:/,
+    /^Duration:/,
+    /^Labels:/,
+    /^Progress:/,
+    /^Session status:/,
+    /^Completed at/,
+    /^Final state:/,
+    /^Related:/,
+    /^When working on:/,
+    /^\d+\.\s+.+\(\d+%,\s*\+\d+%\)/,
+    /^Last updated:/,
+    /^Recurring pattern:/,
+    /^Consolidated from/
+  ];
+  const seenLines = new Set;
+  const knowledgeLines = [];
+  for (const entity of cluster) {
+    const lines = entity.content.split(`
+`).map((l) => l.trim());
+    for (const line of lines) {
+      if (!line || line.length < 20)
+        continue;
+      if (SKIP_PATTERNS.some((p) => p.test(line)))
+        continue;
+      const normalized = line.toLowerCase().replace(/[*_`#[\]]/g, "").trim();
+      if (seenLines.has(normalized))
+        continue;
+      seenLines.add(normalized);
+      knowledgeLines.push(line);
+    }
+  }
+  if (knowledgeLines.length === 0) {
+    return `${cluster.length} related ${type} entities consolidated. Original titles:
+${cluster.map((e) => `- ${e.title}`).join(`
+`)}`;
+  }
+  const MAX_CHARS = 1600;
+  const result = [
+    `Consolidated knowledge from ${cluster.length} ${type} entities:
+`
+  ];
+  let charCount = result[0].length;
+  for (const line of knowledgeLines) {
+    if (charCount + line.length + 3 > MAX_CHARS)
+      break;
+    result.push(`- ${line}`);
+    charCount += line.length + 3;
+  }
+  return result.join(`
+`);
+}
+function deriveClusterTitle(cluster, type) {
+  const stopWords = new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "shall",
+    "would",
+    "should",
+    "may",
+    "might",
+    "can",
+    "could",
+    "of",
+    "in",
+    "to",
+    "for",
+    "with",
+    "on",
+    "at",
+    "from",
+    "by",
+    "and",
+    "or",
+    "but",
+    "not",
+    "session",
+    "blocker",
+    "pattern",
+    "solution",
+    "error",
+    "task",
+    "mid-session"
+  ]);
+  const wordCounts = new Map;
+  for (const entity of cluster) {
+    const words = entity.title.toLowerCase().split(/\W+/).filter((w) => w.length > 2 && !stopWords.has(w));
+    for (const word of words) {
+      wordCounts.set(word, (wordCounts.get(word) || 0) + 1);
+    }
+  }
+  const topWords = [...wordCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 4).map(([word]) => word[0].toUpperCase() + word.slice(1));
+  const suffix = topWords.length > 0 ? topWords.join(" / ") : "Various";
+  return `${type[0].toUpperCase() + type.slice(1)}: ${suffix}`;
+}
+
+// src/memory-cleanup.ts
+init_dist();
+var ALL_STEPS = [
+  "prune",
+  "consolidate",
+  "orphans",
+  "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(client2, workspaceId, projectId, options) {
+  const dryRun = options?.dryRun !== false;
+  const steps = options?.steps ?? ALL_STEPS;
+  const maxAgeDays = options?.maxAgeDays ?? 30;
+  const minClusterSize = options?.minClusterSize ?? 3;
+  const orphanAgeDays = options?.orphanAgeDays ?? 14;
+  const report = {
+    success: true,
+    dryRun,
+    timestamp: new Date().toISOString(),
+    workspace: { id: workspaceId, projectId },
+    summary: { totalEntities: 0, issuesFound: 0, actionsTaken: 0 },
+    steps: {},
+    errors: [],
+    healthReport: ""
+  };
+  let entities = [];
+  try {
+    const listResult = await client2.listMemoryEntities({
+      workspace_id: workspaceId,
+      project_id: projectId,
+      limit: MAX_ENTITIES_FETCH
+    });
+    entities = listResult.entities || [];
+    report.summary.totalEntities = entities.length;
+  } catch (err) {
+    report.errors.push({
+      step: "init",
+      message: `Failed to fetch entities: ${err.message}`
+    });
+    report.success = false;
+    report.healthReport = generateHealthReport(report);
+    return report;
+  }
+  if (steps.includes("prune")) {
+    try {
+      report.steps.prune = runPruneStep(entities, maxAgeDays);
+      if (!dryRun) {
+        for (const item of report.steps.prune.items) {
+          try {
+            await client2.deleteMemoryEntity(item.id);
+            report.steps.prune.pruned++;
+          } catch (err) {
             report.errors.push({
-                step: "orphans",
-                message: err.message,
+              step: "prune",
+              message: `Failed to delete ${item.id}: ${err.message}`
             });
+          }
         }
+        report.summary.actionsTaken += report.steps.prune.pruned;
+      }
+      report.summary.issuesFound += report.steps.prune.staleDraftsFound;
+    } catch (err) {
+      report.errors.push({
+        step: "prune",
+        message: err.message
+      });
     }
-    // Stage 4: Detect duplicates
-    if (steps.includes("duplicates")) {
-        try {
-            report.steps.duplicates = await runDuplicateStep(client, entities, workspaceId, projectId);
-            if (!dryRun) {
-                for (const pair of report.steps.duplicates.pairs) {
-                    try {
-                        await client.deleteMemoryEntity(pair.removeId);
-                        report.steps.duplicates.resolved++;
-                    }
-                    catch (err) {
-                        report.errors.push({
-                            step: "duplicates",
-                            message: `Failed to delete ${pair.removeId}: ${err.message}`,
-                        });
-                    }
-                }
-                report.summary.actionsTaken += report.steps.duplicates.resolved;
-            }
-            report.summary.issuesFound += report.steps.duplicates.duplicatePairsFound;
-        }
-        catch (err) {
+  }
+  if (steps.includes("consolidate")) {
+    try {
+      const result = await consolidateMemories(client2, workspaceId, projectId, {
+        dryRun,
+        minClusterSize
+      });
+      report.steps.consolidate = {
+        clustersFound: result.clustersFound,
+        entitiesProcessed: result.entitiesProcessed,
+        consolidated: result.consolidated,
+        details: result.details
+      };
+      report.summary.issuesFound += result.clustersFound;
+      if (!dryRun)
+        report.summary.actionsTaken += result.consolidated;
+    } catch (err) {
+      report.errors.push({
+        step: "consolidate",
+        message: err.message
+      });
+    }
+  }
+  if (steps.includes("orphans")) {
+    try {
+      report.steps.orphans = await runOrphanStep(client2, entities, orphanAgeDays);
+      if (!dryRun) {
+        for (const item of report.steps.orphans.items) {
+          try {
+            await client2.deleteMemoryEntity(item.id);
+            report.steps.orphans.removed++;
+          } catch (err) {
             report.errors.push({
-                step: "duplicates",
-                message: err.message,
+              step: "orphans",
+              message: `Failed to delete ${item.id}: ${err.message}`
             });
+          }
         }
+        report.summary.actionsTaken += report.steps.orphans.removed;
+      }
+      report.summary.issuesFound += report.steps.orphans.orphansFound;
+    } catch (err) {
+      report.errors.push({
+        step: "orphans",
+        message: err.message
+      });
     }
-    // Stage 5: Backfill embeddings
-    if (steps.includes("backfill")) {
-        try {
-            if (dryRun) {
-                // In dry-run, just report that backfill would run
-                report.steps.backfill = {
-                    processed: 0,
-                    remaining: -1,
-                    errors: [],
-                };
-            }
-            else {
-                const result = await client.backfillEmbeddings(workspaceId);
-                report.steps.backfill = {
-                    processed: result.processed,
-                    remaining: result.remaining,
-                    errors: result.errors || [],
-                };
-                report.summary.actionsTaken += result.processed;
-            }
-        }
-        catch (err) {
+  }
+  if (steps.includes("duplicates")) {
+    try {
+      report.steps.duplicates = await runDuplicateStep(client2, entities, workspaceId, projectId);
+      if (!dryRun) {
+        for (const pair of report.steps.duplicates.pairs) {
+          try {
+            await client2.deleteMemoryEntity(pair.removeId);
+            report.steps.duplicates.resolved++;
+          } catch (err) {
             report.errors.push({
-                step: "backfill",
-                message: err.message,
+              step: "duplicates",
+              message: `Failed to delete ${pair.removeId}: ${err.message}`
             });
+          }
         }
+        report.summary.actionsTaken += report.steps.duplicates.resolved;
+      }
+      report.summary.issuesFound += report.steps.duplicates.duplicatePairsFound;
+    } catch (err) {
+      report.errors.push({
+        step: "duplicates",
+        message: err.message
+      });
     }
-    report.healthReport = generateHealthReport(report);
-    return report;
+  }
+  if (steps.includes("backfill")) {
+    try {
+      if (dryRun) {
+        report.steps.backfill = {
+          processed: 0,
+          remaining: -1,
+          errors: []
+        };
+      } else {
+        const result = await client2.backfillEmbeddings(workspaceId);
+        report.steps.backfill = {
+          processed: result.processed,
+          remaining: result.remaining,
+          errors: result.errors || []
+        };
+        report.summary.actionsTaken += result.processed;
+      }
+    } catch (err) {
+      report.errors.push({
+        step: "backfill",
+        message: err.message
+      });
+    }
+  }
+  report.healthReport = generateHealthReport(report);
+  return report;
 }
-// ---------------------------------------------------------------------------
-// Step implementations
-// ---------------------------------------------------------------------------
 function runPruneStep(entities, maxAgeDays) {
-    const now = Date.now();
-    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;
-        if (ageDays < maxAgeDays)
-            continue;
-        const lifecycle = evaluateLifecycle(entity);
-        stale.push({
-            id: entity.id,
-            title: entity.title,
-            ageDays: Math.round(ageDays),
-            decayScore: Math.round(lifecycle.decay.score * 100) / 100,
-        });
-    }
-    return { staleDraftsFound: stale.length, pruned: 0, items: stale };
-}
-async function runOrphanStep(client, entities, orphanAgeDays) {
-    const now = Date.now();
-    const result = { orphansFound: 0, removed: 0, items: [] };
-    // Pre-filter: only check entities that look like orphan candidates
-    const candidates = entities.filter((e) => {
-        if (e.memory_tier === "reference")
-            return false;
-        if (e.access_count >= 2)
-            return false;
-        const ageDays = (now - new Date(e.created_at).getTime()) / MS_PER_DAY;
-        return ageDays >= orphanAgeDays;
+  const now = Date.now();
+  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;
+    if (ageDays < maxAgeDays)
+      continue;
+    const lifecycle2 = evaluateLifecycle(entity);
+    stale.push({
+      id: entity.id,
+      title: entity.title,
+      ageDays: Math.round(ageDays),
+      decayScore: Math.round(lifecycle2.decay.score * 100) / 100
     });
-    // 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++;
-            }
-        }
+  }
+  return { staleDraftsFound: stale.length, pruned: 0, items: stale };
+}
+async function runOrphanStep(client2, entities, orphanAgeDays) {
+  const now = Date.now();
+  const result = { orphansFound: 0, removed: 0, items: [] };
+  const candidates = entities.filter((e) => {
+    if (e.memory_tier === "reference")
+      return false;
+    if (e.access_count >= 2)
+      return false;
+    const ageDays = (now - new Date(e.created_at).getTime()) / MS_PER_DAY;
+    return ageDays >= orphanAgeDays;
+  });
+  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 client2.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++;
+      }
     }
-    return result;
+  }
+  return result;
 }
-async function runDuplicateStep(client, entities, workspaceId, projectId) {
-    const result = {
-        duplicatePairsFound: 0,
-        resolved: 0,
-        pairs: [],
-    };
-    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);
-            }
-        }
+async function runDuplicateStep(client2, entities, workspaceId, projectId) {
+  const result = {
+    duplicatePairsFound: 0,
+    resolved: 0,
+    pairs: []
+  };
+  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(client2, 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;
-        const similar = similarityMap.get(entity.id) || [];
-        for (const match of similar) {
-            if (flaggedForRemoval.has(match.id))
-                continue;
-            const pairKey = [entity.id, match.id].sort().join(":");
-            if (seenPairs.has(pairKey))
-                continue;
-            seenPairs.add(pairKey);
-            const sim = titleSimilarity(entity.title, match.title);
-            if (sim < DUPLICATE_SIMILARITY_THRESHOLD)
-                continue;
-            // Keep the one with higher confidence, more accesses, or higher tier
-            const entityScore = entityQualityScore(entity);
-            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);
-            result.pairs.push({
-                keepId: keep.id,
-                keepTitle: keep.title,
-                removeId: remove.id,
-                removeTitle: remove.title,
-                similarity: Math.round(sim * 100) / 100,
-            });
-            result.duplicatePairsFound++;
-        }
+  }
+  for (const entity of entities) {
+    if (flaggedForRemoval.has(entity.id))
+      continue;
+    const similar = similarityMap.get(entity.id) || [];
+    for (const match of similar) {
+      if (flaggedForRemoval.has(match.id))
+        continue;
+      const pairKey = [entity.id, match.id].sort().join(":");
+      if (seenPairs.has(pairKey))
+        continue;
+      seenPairs.add(pairKey);
+      const sim = titleSimilarity(entity.title, match.title);
+      if (sim < DUPLICATE_SIMILARITY_THRESHOLD)
+        continue;
+      const entityScore = entityQualityScore(entity);
+      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);
+      result.pairs.push({
+        keepId: keep.id,
+        keepTitle: keep.title,
+        removeId: remove.id,
+        removeTitle: remove.title,
+        similarity: Math.round(sim * 100) / 100
+      });
+      result.duplicatePairsFound++;
     }
-    return result;
+  }
+  return result;
 }
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-const TIER_WEIGHTS = {
-    reference: 3,
-    episode: 2,
-    draft: 1,
+var TIER_WEIGHTS = {
+  reference: 3,
+  episode: 2,
+  draft: 1
 };
 function entityQualityScore(entity) {
-    return (entity.confidence +
-        (TIER_WEIGHTS[entity.memory_tier] || 0) +
-        Math.min(entity.access_count, 10) * 0.1);
+  return entity.confidence + (TIER_WEIGHTS[entity.memory_tier] || 0) + Math.min(entity.access_count, 10) * 0.1;
 }
 function titleSimilarity(a, b) {
-    const na = a.toLowerCase().trim();
-    const nb = b.toLowerCase().trim();
-    if (na === nb)
-        return 1;
-    const wordsA = new Set(na.split(/\W+/).filter(Boolean));
-    const wordsB = new Set(nb.split(/\W+/).filter(Boolean));
-    if (wordsA.size === 0 || wordsB.size === 0)
-        return 0;
-    let intersection = 0;
-    for (const w of wordsA) {
-        if (wordsB.has(w))
-            intersection++;
-    }
-    // Jaccard similarity
-    const union = wordsA.size + wordsB.size - intersection;
-    return union > 0 ? intersection / union : 0;
+  const na = a.toLowerCase().trim();
+  const nb = b.toLowerCase().trim();
+  if (na === nb)
+    return 1;
+  const wordsA = new Set(na.split(/\W+/).filter(Boolean));
+  const wordsB = new Set(nb.split(/\W+/).filter(Boolean));
+  if (wordsA.size === 0 || wordsB.size === 0)
+    return 0;
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w))
+      intersection++;
+  }
+  const union = wordsA.size + wordsB.size - intersection;
+  return union > 0 ? intersection / union : 0;
 }
-// ---------------------------------------------------------------------------
-// Health report renderer
-// ---------------------------------------------------------------------------
 function generateHealthReport(report) {
-    const mode = report.dryRun ? "Dry Run (preview)" : "Executed";
-    const lines = [
-        "# Memory Health Report\n",
-        `**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;
-        lines.push("## Stale Drafts");
-        if (p.staleDraftsFound === 0) {
-            lines.push("No stale drafts found.\n");
-        }
-        else {
-            lines.push(`Found **${p.staleDraftsFound}** stale drafts${!report.dryRun ? ` (pruned ${p.pruned})` : ""}:`);
-            lines.push("| Title | Age | Decay |");
-            lines.push("|-------|-----|-------|");
-            for (const item of p.items.slice(0, 20)) {
-                lines.push(`| ${item.title} | ${item.ageDays}d | ${item.decayScore} |`);
-            }
-            lines.push("");
-        }
-    }
-    // Consolidate
-    if (report.steps.consolidate) {
-        const c = report.steps.consolidate;
-        lines.push("## Consolidation");
-        if (c.clustersFound === 0) {
-            lines.push(`Scanned ${c.entitiesProcessed} draft/episode entities — no clusters found.\n`);
-        }
-        else {
-            lines.push(`Found **${c.clustersFound}** clusters across ${c.entitiesProcessed} entities:`);
-            for (const d of c.details.slice(0, 10)) {
-                lines.push(`- **${d.mergedTitle}** — ${d.clusterSize} entities`);
-            }
-            lines.push("");
-        }
-    }
-    // Orphans
-    if (report.steps.orphans) {
-        const o = report.steps.orphans;
-        lines.push("## Orphaned Entities");
-        if (o.orphansFound === 0) {
-            lines.push("No orphans found.\n");
-        }
-        else {
-            lines.push(`Found **${o.orphansFound}** orphans${!report.dryRun ? ` (removed ${o.removed})` : ""}:`);
-            lines.push("| Title | Type | Tier | Age | Accesses |");
-            lines.push("|-------|------|------|-----|----------|");
-            for (const item of o.items.slice(0, 20)) {
-                lines.push(`| ${item.title} | ${item.type} | ${item.tier} | ${item.ageDays}d | ${item.accessCount} |`);
-            }
-            lines.push("");
-        }
+  const mode = report.dryRun ? "Dry Run (preview)" : "Executed";
+  const lines = [
+    `# Memory Health 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");
+    if (p.staleDraftsFound === 0) {
+      lines.push(`No stale drafts found.
+`);
+    } else {
+      lines.push(`Found **${p.staleDraftsFound}** stale drafts${!report.dryRun ? ` (pruned ${p.pruned})` : ""}:`);
+      lines.push("| Title | Age | Decay |");
+      lines.push("|-------|-----|-------|");
+      for (const item of p.items.slice(0, 20)) {
+        lines.push(`| ${item.title} | ${item.ageDays}d | ${item.decayScore} |`);
+      }
+      lines.push("");
     }
-    // Duplicates
-    if (report.steps.duplicates) {
-        const d = report.steps.duplicates;
-        lines.push("## Near-Duplicates");
-        if (d.duplicatePairsFound === 0) {
-            lines.push("No duplicates found.\n");
-        }
-        else {
-            lines.push(`Found **${d.duplicatePairsFound}** duplicate pairs${!report.dryRun ? ` (resolved ${d.resolved})` : ""}:`);
-            for (const pair of d.pairs.slice(0, 20)) {
-                lines.push(`- "${pair.keepTitle}" ~ "${pair.removeTitle}" (${Math.round(pair.similarity * 100)}% similar, keep first)`);
-            }
-            lines.push("");
-        }
+  }
+  if (report.steps.consolidate) {
+    const c = report.steps.consolidate;
+    lines.push("## Consolidation");
+    if (c.clustersFound === 0) {
+      lines.push(`Scanned ${c.entitiesProcessed} draft/episode entities — no clusters found.
+`);
+    } else {
+      lines.push(`Found **${c.clustersFound}** clusters across ${c.entitiesProcessed} entities:`);
+      for (const d of c.details.slice(0, 10)) {
+        lines.push(`- **${d.mergedTitle}** — ${d.clusterSize} entities`);
+      }
+      lines.push("");
     }
-    // Backfill
-    if (report.steps.backfill) {
-        const b = report.steps.backfill;
-        lines.push("## Embedding Coverage");
-        if (report.dryRun) {
-            lines.push("Backfill will run when executed with `dryRun: false`.\n");
-        }
-        else if (b.remaining === 0) {
-            lines.push(`All embeddings up to date (processed ${b.processed}).\n`);
-        }
-        else {
-            lines.push(`Processed ${b.processed} entities. ${b.remaining} still need embeddings.\n`);
-        }
+  }
+  if (report.steps.orphans) {
+    const o = report.steps.orphans;
+    lines.push("## Orphaned Entities");
+    if (o.orphansFound === 0) {
+      lines.push(`No orphans found.
+`);
+    } else {
+      lines.push(`Found **${o.orphansFound}** orphans${!report.dryRun ? ` (removed ${o.removed})` : ""}:`);
+      lines.push("| Title | Type | Tier | Age | Accesses |");
+      lines.push("|-------|------|------|-----|----------|");
+      for (const item of o.items.slice(0, 20)) {
+        lines.push(`| ${item.title} | ${item.type} | ${item.tier} | ${item.ageDays}d | ${item.accessCount} |`);
+      }
+      lines.push("");
     }
-    // Errors
-    if (report.errors.length > 0) {
-        lines.push("## Errors");
-        for (const e of report.errors) {
-            lines.push(`- **${e.step}:** ${e.message}`);
-        }
-        lines.push("");
+  }
+  if (report.steps.duplicates) {
+    const d = report.steps.duplicates;
+    lines.push("## Near-Duplicates");
+    if (d.duplicatePairsFound === 0) {
+      lines.push(`No duplicates found.
+`);
+    } else {
+      lines.push(`Found **${d.duplicatePairsFound}** duplicate pairs${!report.dryRun ? ` (resolved ${d.resolved})` : ""}:`);
+      for (const pair of d.pairs.slice(0, 20)) {
+        lines.push(`- "${pair.keepTitle}" ~ "${pair.removeTitle}" (${Math.round(pair.similarity * 100)}% similar, keep first)`);
+      }
+      lines.push("");
     }
+  }
+  if (report.steps.backfill) {
+    const b = report.steps.backfill;
+    lines.push("## Embedding Coverage");
     if (report.dryRun) {
-        lines.push("---\n*Run with `dryRun: false` to execute cleanup.*");
+      lines.push("Backfill will run when executed with `dryRun: false`.\n");
+    } else if (b.remaining === 0) {
+      lines.push(`All embeddings up to date (processed ${b.processed}).
+`);
+    } else {
+      lines.push(`Processed ${b.processed} entities. ${b.remaining} still need embeddings.
+`);
     }
-    return lines.join("\n");
+  }
+  if (report.errors.length > 0) {
+    lines.push("## Errors");
+    for (const e of report.errors) {
+      lines.push(`- **${e.step}:** ${e.message}`);
+    }
+    lines.push("");
+  }
+  if (report.dryRun) {
+    lines.push("---\n*Run with `dryRun: false` to execute cleanup.*");
+  }
+  return lines.join(`
+`);
 }
+export {
+  runMemoryCleanup
+};