@gethmy/mcp 2.3.0 → 2.3.2

package/dist/lib/lifecycle-maintenance.js

@@ -1,88 +1,672 @@
-/**
- * Automatic Memory Lifecycle Maintenance
- *
- * Runs at session end to enforce decay/archival rules:
- * - Archive entities with confidence < 0.3
- * - Delete stale drafts (>30 days old with low decay score)
- * - Auto-promote eligible entities (draft→episode, episode→reference)
- *
- * All operations are non-fatal — failures are logged but never block session end.
- */
-import { evaluateLifecycle } from "@harmony/memory";
-/**
- * Run lifecycle maintenance for a workspace.
- * Called automatically at session end alongside consolidation.
- */
-export async function runLifecycleMaintenance(client, workspaceId, projectId) {
-    const result = {
-        archived: 0,
-        pruned: 0,
-        promoted: 0,
-        reviewed: 0,
-        errors: 0,
-    };
-    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: 200,
+      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 || []);
+      }
+      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 {
-        return result;
+  }
+  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;
     }
-    if (entities.length === 0)
-        return result;
-    const now = Date.now();
-    const STALE_DRAFT_MAX_AGE_DAYS = 30;
-    for (const entity of entities) {
-        try {
-            const lifecycle = evaluateLifecycle(entity);
-            // 1. Archive low-confidence entities (confidence < 0.3)
-            if (lifecycle.shouldArchive) {
-                await client.deleteMemoryEntity(entity.id);
-                result.archived++;
-                continue;
-            }
-            // 2. Prune stale drafts (>30 days old with low decay score)
-            if (entity.memory_tier === "draft") {
-                const ageDays = (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
-                if (ageDays > STALE_DRAFT_MAX_AGE_DAYS && lifecycle.decay.score < 0.3) {
-                    await client.deleteMemoryEntity(entity.id);
-                    result.pruned++;
-                    continue;
-                }
-            }
-            // 3. Auto-promote eligible entities
-            if (lifecycle.promotion.eligible && lifecycle.promotion.targetTier) {
-                await client.updateMemoryEntity(entity.id, {
-                    memory_tier: lifecycle.promotion.targetTier,
-                    metadata: {
-                        promoted_at: new Date().toISOString(),
-                        promotion_reason: lifecycle.promotion.reason,
-                        promoted_from: entity.memory_tier,
-                    },
-                });
-                result.promoted++;
-                continue;
-            }
-            // 4. Flag stale entities for review (>90 days, <3 accesses)
-            if (lifecycle.shouldFlagForReview) {
-                await client.updateMemoryEntity(entity.id, {
-                    metadata: {
-                        needs_review: true,
-                        review_reason: lifecycle.reviewReason,
-                        flagged_at: new Date().toISOString(),
-                    },
-                });
-                result.reviewed++;
-            }
+  }
+  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 {
-            result.errors++;
+      }
+      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/lifecycle-maintenance.ts
+init_dist();
+async function runLifecycleMaintenance(client2, workspaceId, projectId) {
+  const result = {
+    archived: 0,
+    pruned: 0,
+    promoted: 0,
+    reviewed: 0,
+    errors: 0
+  };
+  let entities;
+  try {
+    const listResult = await client2.listMemoryEntities({
+      workspace_id: workspaceId,
+      project_id: projectId,
+      limit: 200
+    });
+    entities = listResult.entities || [];
+  } catch {
     return result;
+  }
+  if (entities.length === 0)
+    return result;
+  const now = Date.now();
+  const STALE_DRAFT_MAX_AGE_DAYS = 30;
+  for (const entity of entities) {
+    try {
+      const lifecycle2 = evaluateLifecycle(entity);
+      if (lifecycle2.shouldArchive) {
+        await client2.deleteMemoryEntity(entity.id);
+        result.archived++;
+        continue;
+      }
+      if (entity.memory_tier === "draft") {
+        const ageDays = (now - new Date(entity.created_at).getTime()) / (1000 * 60 * 60 * 24);
+        if (ageDays > STALE_DRAFT_MAX_AGE_DAYS && lifecycle2.decay.score < 0.3) {
+          await client2.deleteMemoryEntity(entity.id);
+          result.pruned++;
+          continue;
+        }
+      }
+      if (lifecycle2.promotion.eligible && lifecycle2.promotion.targetTier) {
+        await client2.updateMemoryEntity(entity.id, {
+          memory_tier: lifecycle2.promotion.targetTier,
+          metadata: {
+            promoted_at: new Date().toISOString(),
+            promotion_reason: lifecycle2.promotion.reason,
+            promoted_from: entity.memory_tier
+          }
+        });
+        result.promoted++;
+        continue;
+      }
+      if (lifecycle2.shouldFlagForReview) {
+        await client2.updateMemoryEntity(entity.id, {
+          metadata: {
+            needs_review: true,
+            review_reason: lifecycle2.reviewReason,
+            flagged_at: new Date().toISOString()
+          }
+        });
+        result.reviewed++;
+      }
+    } catch {
+      result.errors++;
+    }
+  }
+  return result;
 }
+export {
+  runLifecycleMaintenance
+};