@gethmy/mcp 2.3.2 → 2.3.4

package/dist/lib/memory-cleanup.js

@@ -1,1361 +0,0 @@
-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 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"
-        });
-      }
-      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)`
-      };
-    }
-  }
-  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)`
-      };
-    }
-  }
-  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;
-        }
-      }
-      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) {}
-      }
-    }
-    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 {
-          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);
-          }
-        }
-        if (uniqueCluster.length >= minClusterSize) {
-          clusters.push(uniqueCluster);
-          for (const member of uniqueCluster) {
-            clustered.add(member.id);
-          }
-        }
-      }
-    }
-    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 {
-          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()
-            }
-          });
-          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: "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
-      });
-    }
-  }
-  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: "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
-      });
-    }
-  }
-  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: "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
-      });
-    }
-  }
-  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;
-}
-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 lifecycle2 = evaluateLifecycle(entity);
-    stale.push({
-      id: entity.id,
-      title: entity.title,
-      ageDays: Math.round(ageDays),
-      decayScore: Math.round(lifecycle2.decay.score * 100) / 100
-    });
-  }
-  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;
-}
-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);
-      }
-    }
-  }
-  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;
-}
-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;
-}
-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++;
-  }
-  const union = wordsA.size + wordsB.size - intersection;
-  return union > 0 ? intersection / union : 0;
-}
-function generateHealthReport(report) {
-  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("");
-    }
-  }
-  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("");
-    }
-  }
-  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("");
-    }
-  }
-  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("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.
-`);
-    }
-  }
-  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
-};