@smyslenny/agent-memory 5.0.2 → 5.1.0

package/dist/mcp/server.js

@@ -99,6 +99,11 @@ function migrateDatabase(db, from, to) {
       v = 7;
       continue;
     }
+    if (v === 7) {
+      migrateV7ToV8(db);
+      v = 8;
+      continue;
+    }
     throw new Error(`Unsupported schema migration path: v${from} \u2192 v${to} (stuck at v${v})`);
   }
 }
@@ -186,6 +191,8 @@ function inferSchemaVersion(db) {
   const hasFeedbackEvents = tableExists(db, "feedback_events");
   const hasEmotionTag = tableHasColumn(db, "memories", "emotion_tag");
   const hasProvenance = tableHasColumn(db, "memories", "source_session") && tableHasColumn(db, "memories", "source_context") && tableHasColumn(db, "memories", "observed_at");
+  const hasMemoryArchive = tableExists(db, "memory_archive");
+  if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents && hasEmotionTag && hasProvenance && hasMemoryArchive) return 8;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents && hasEmotionTag && hasProvenance) return 7;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents && hasEmotionTag) return 6;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents) return 5;
@@ -227,6 +234,11 @@ function ensureIndexes(db) {
       db.exec("CREATE INDEX IF NOT EXISTS idx_feedback_events_agent_source ON feedback_events(agent_id, source, created_at DESC);");
     }
   }
+  if (tableExists(db, "memory_archive")) {
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memory_archive_agent ON memory_archive(agent_id);");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memory_archive_type ON memory_archive(type);");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memory_archive_archived_at ON memory_archive(archived_at);");
+  }
 }
 function ensureFeedbackEventSchema(db) {
   if (!tableExists(db, "feedback_events")) return;
@@ -402,11 +414,55 @@ function migrateV6ToV7(db) {
     throw e;
   }
 }
+function migrateV7ToV8(db) {
+  if (tableExists(db, "memory_archive")) {
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(8));
+    return;
+  }
+  try {
+    db.exec("BEGIN");
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS memory_archive (
+        id             TEXT PRIMARY KEY,
+        content        TEXT NOT NULL,
+        type           TEXT NOT NULL,
+        priority       INTEGER NOT NULL,
+        emotion_val    REAL NOT NULL DEFAULT 0.0,
+        vitality       REAL NOT NULL DEFAULT 0.0,
+        stability      REAL NOT NULL DEFAULT 1.0,
+        access_count   INTEGER NOT NULL DEFAULT 0,
+        last_accessed  TEXT,
+        created_at     TEXT NOT NULL,
+        updated_at     TEXT NOT NULL,
+        archived_at    TEXT NOT NULL,
+        archive_reason TEXT NOT NULL DEFAULT 'eviction',
+        source         TEXT,
+        agent_id       TEXT NOT NULL DEFAULT 'default',
+        hash           TEXT,
+        emotion_tag    TEXT,
+        source_session TEXT,
+        source_context TEXT,
+        observed_at    TEXT
+      );
+    `);
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memory_archive_agent ON memory_archive(agent_id);");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memory_archive_type ON memory_archive(type);");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memory_archive_archived_at ON memory_archive(archived_at);");
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(8));
+    db.exec("COMMIT");
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  }
+}
 var SCHEMA_VERSION, SCHEMA_SQL;
 var init_db = __esm({
   "src/core/db.ts"() {
     "use strict";
-    SCHEMA_VERSION = 7;
+    SCHEMA_VERSION = 8;
     SCHEMA_SQL = `
 -- Memory entries
 CREATE TABLE IF NOT EXISTS memories (
@@ -512,6 +568,30 @@ CREATE TABLE IF NOT EXISTS schema_meta (
   value TEXT NOT NULL
 );
 
+-- Memory archive (eviction archive)
+CREATE TABLE IF NOT EXISTS memory_archive (
+  id             TEXT PRIMARY KEY,
+  content        TEXT NOT NULL,
+  type           TEXT NOT NULL,
+  priority       INTEGER NOT NULL,
+  emotion_val    REAL NOT NULL DEFAULT 0.0,
+  vitality       REAL NOT NULL DEFAULT 0.0,
+  stability      REAL NOT NULL DEFAULT 1.0,
+  access_count   INTEGER NOT NULL DEFAULT 0,
+  last_accessed  TEXT,
+  created_at     TEXT NOT NULL,
+  updated_at     TEXT NOT NULL,
+  archived_at    TEXT NOT NULL,
+  archive_reason TEXT NOT NULL DEFAULT 'eviction',
+  source         TEXT,
+  agent_id       TEXT NOT NULL DEFAULT 'default',
+  hash           TEXT,
+  emotion_tag    TEXT,
+  source_session TEXT,
+  source_context TEXT,
+  observed_at    TEXT
+);
+
 -- Indexes for common queries
 CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
 CREATE INDEX IF NOT EXISTS idx_memories_priority ON memories(priority);
@@ -522,6 +602,9 @@ CREATE INDEX IF NOT EXISTS idx_paths_memory ON paths(memory_id);
 CREATE INDEX IF NOT EXISTS idx_paths_domain ON paths(domain);
 CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_phase_status ON maintenance_jobs(phase, status, started_at DESC);
 CREATE INDEX IF NOT EXISTS idx_feedback_events_memory ON feedback_events(memory_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_memory_archive_agent ON memory_archive(agent_id);
+CREATE INDEX IF NOT EXISTS idx_memory_archive_type ON memory_archive(type);
+CREATE INDEX IF NOT EXISTS idx_memory_archive_archived_at ON memory_archive(archived_at);
 `;
   }
 });
@@ -1037,13 +1120,17 @@ var init_vector = __esm({
 // src/core/memory.ts
 var memory_exports = {};
 __export(memory_exports, {
+  archiveMemory: () => archiveMemory,
   contentHash: () => contentHash,
   countMemories: () => countMemories,
   createMemory: () => createMemory,
   deleteMemory: () => deleteMemory,
   getMemory: () => getMemory,
+  listArchivedMemories: () => listArchivedMemories,
   listMemories: () => listMemories,
+  purgeArchive: () => purgeArchive,
   recordAccess: () => recordAccess,
+  restoreMemory: () => restoreMemory,
   updateMemory: () => updateMemory
 });
 import { createHash as createHash2 } from "crypto";
@@ -1162,9 +1249,118 @@ function updateMemory(db, id, input) {
 }
 function deleteMemory(db, id) {
   db.prepare("DELETE FROM memories_fts WHERE id = ?").run(id);
+  try {
+    db.prepare("DELETE FROM embeddings WHERE memory_id = ?").run(id);
+  } catch {
+  }
   const result = db.prepare("DELETE FROM memories WHERE id = ?").run(id);
   return result.changes > 0;
 }
+function archiveMemory(db, id, reason, opts) {
+  const mem = getMemory(db, id);
+  if (!mem) return false;
+  const minVitality = opts?.minVitality ?? 0.1;
+  if (mem.vitality < minVitality) {
+    deleteMemory(db, id);
+    return "deleted";
+  }
+  const archivedAt = now();
+  const archiveReason = reason ?? "eviction";
+  db.prepare(
+    `INSERT OR REPLACE INTO memory_archive
+     (id, content, type, priority, emotion_val, vitality, stability, access_count,
+      last_accessed, created_at, updated_at, archived_at, archive_reason,
+      source, agent_id, hash, emotion_tag, source_session, source_context, observed_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    mem.id,
+    mem.content,
+    mem.type,
+    mem.priority,
+    mem.emotion_val,
+    mem.vitality,
+    mem.stability,
+    mem.access_count,
+    mem.last_accessed,
+    mem.created_at,
+    mem.updated_at,
+    archivedAt,
+    archiveReason,
+    mem.source,
+    mem.agent_id,
+    mem.hash,
+    mem.emotion_tag,
+    mem.source_session,
+    mem.source_context,
+    mem.observed_at
+  );
+  deleteMemory(db, id);
+  return "archived";
+}
+function restoreMemory(db, id) {
+  const archived = db.prepare("SELECT * FROM memory_archive WHERE id = ?").get(id);
+  if (!archived) return null;
+  db.prepare(
+    `INSERT INTO memories
+     (id, content, type, priority, emotion_val, vitality, stability, access_count,
+      last_accessed, created_at, updated_at, source, agent_id, hash, emotion_tag,
+      source_session, source_context, observed_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    archived.id,
+    archived.content,
+    archived.type,
+    archived.priority,
+    archived.emotion_val,
+    archived.vitality,
+    archived.stability,
+    archived.access_count,
+    archived.last_accessed,
+    archived.created_at,
+    now(),
+    // updated_at = restore time
+    archived.source,
+    archived.agent_id,
+    archived.hash,
+    archived.emotion_tag,
+    archived.source_session,
+    archived.source_context,
+    archived.observed_at
+  );
+  db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(
+    archived.id,
+    tokenizeForIndex(archived.content)
+  );
+  if (archived.hash) {
+    const providerId = getConfiguredEmbeddingProviderId();
+    if (providerId) {
+      try {
+        markMemoryEmbeddingPending(db, archived.id, providerId, archived.hash);
+      } catch {
+      }
+    }
+  }
+  db.prepare("DELETE FROM memory_archive WHERE id = ?").run(id);
+  return getMemory(db, archived.id);
+}
+function listArchivedMemories(db, opts) {
+  const agentId = opts?.agent_id;
+  const limit = opts?.limit ?? 20;
+  if (agentId) {
+    return db.prepare(
+      "SELECT * FROM memory_archive WHERE agent_id = ? ORDER BY archived_at DESC LIMIT ?"
+    ).all(agentId, limit);
+  }
+  return db.prepare(
+    "SELECT * FROM memory_archive ORDER BY archived_at DESC LIMIT ?"
+  ).all(limit);
+}
+function purgeArchive(db, opts) {
+  if (opts?.agent_id) {
+    return db.prepare("DELETE FROM memory_archive WHERE agent_id = ?").run(opts.agent_id).changes;
+  }
+  return db.prepare("DELETE FROM memory_archive").run().changes;
+}
 function listMemories(db, opts) {
   const conditions = [];
   const params = [];
@@ -3158,13 +3354,31 @@ function rankEvictionCandidates(db, opts) {
     return left.memory.priority - right.memory.priority;
   });
 }
+function parseEnvInt(envKey) {
+  const raw = process.env[envKey];
+  if (raw === void 0 || raw === "") return null;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+function getTieredCapacity(opts) {
+  const envMax = parseEnvInt("AGENT_MEMORY_MAX_MEMORIES");
+  return {
+    identity: parseEnvInt("AGENT_MEMORY_MAX_IDENTITY"),
+    // default: null (unlimited)
+    emotion: parseEnvInt("AGENT_MEMORY_MAX_EMOTION") ?? 50,
+    knowledge: parseEnvInt("AGENT_MEMORY_MAX_KNOWLEDGE") ?? 250,
+    event: parseEnvInt("AGENT_MEMORY_MAX_EVENT") ?? 50,
+    total: opts?.maxMemories ?? (envMax ?? 350)
+  };
+}
 function runGovern(db, opts) {
   const agentId = opts?.agent_id;
-  const envMax = Number.parseInt(process.env.AGENT_MEMORY_MAX_MEMORIES ?? "", 10);
-  const maxMemories = opts?.maxMemories ?? (Number.isFinite(envMax) && envMax > 0 ? envMax : 200);
+  const capacity = getTieredCapacity(opts);
   let orphanPaths = 0;
   let emptyMemories = 0;
   let evicted = 0;
+  let archived = 0;
+  const evictedByType = {};
   const transaction = db.transaction(() => {
     const pathResult = agentId ? db.prepare(
       `DELETE FROM paths
@@ -3174,17 +3388,48 @@ function runGovern(db, opts) {
     orphanPaths = pathResult.changes;
     const emptyResult = agentId ? db.prepare("DELETE FROM memories WHERE agent_id = ? AND TRIM(content) = ''").run(agentId) : db.prepare("DELETE FROM memories WHERE TRIM(content) = ''").run();
     emptyMemories = emptyResult.changes;
+    const typeLimits = [
+      { type: "identity", limit: capacity.identity },
+      { type: "emotion", limit: capacity.emotion },
+      { type: "knowledge", limit: capacity.knowledge },
+      { type: "event", limit: capacity.event }
+    ];
+    const allCandidates = rankEvictionCandidates(db, { agent_id: agentId });
+    const evictedIds = /* @__PURE__ */ new Set();
+    for (const { type, limit } of typeLimits) {
+      if (limit === null) continue;
+      const typeCount = db.prepare(
+        agentId ? "SELECT COUNT(*) as c FROM memories WHERE agent_id = ? AND type = ?" : "SELECT COUNT(*) as c FROM memories WHERE type = ?"
+      ).get(...agentId ? [agentId, type] : [type]).c;
+      const excess = Math.max(0, typeCount - limit);
+      if (excess <= 0) continue;
+      const typeCandidates = allCandidates.filter((c) => c.memory.type === type && !evictedIds.has(c.memory.id));
+      const toEvict = typeCandidates.slice(0, excess);
+      for (const candidate of toEvict) {
+        const result = archiveMemory(db, candidate.memory.id, "eviction");
+        evictedIds.add(candidate.memory.id);
+        evicted += 1;
+        if (result === "archived") archived += 1;
+        evictedByType[type] = (evictedByType[type] ?? 0) + 1;
+      }
+    }
     const total = db.prepare(agentId ? "SELECT COUNT(*) as c FROM memories WHERE agent_id = ?" : "SELECT COUNT(*) as c FROM memories").get(...agentId ? [agentId] : []).c;
-    const excess = Math.max(0, total - maxMemories);
-    if (excess <= 0) return;
-    const candidates = rankEvictionCandidates(db, { agent_id: agentId }).slice(0, excess);
-    for (const candidate of candidates) {
-      deleteMemory(db, candidate.memory.id);
-      evicted += 1;
+    const globalExcess = Math.max(0, total - capacity.total);
+    if (globalExcess > 0) {
+      const globalCandidates = allCandidates.filter((c) => !evictedIds.has(c.memory.id));
+      const toEvict = globalCandidates.slice(0, globalExcess);
+      for (const candidate of toEvict) {
+        const result = archiveMemory(db, candidate.memory.id, "eviction");
+        evictedIds.add(candidate.memory.id);
+        evicted += 1;
+        if (result === "archived") archived += 1;
+        const t = candidate.memory.type;
+        evictedByType[t] = (evictedByType[t] ?? 0) + 1;
+      }
     }
   });
   transaction();
-  return { orphanPaths, emptyMemories, evicted };
+  return { orphanPaths, emptyMemories, evicted, archived, evictedByType };
 }
 
 // src/sleep/jobs.ts
@@ -3427,12 +3672,21 @@ function getMemoryStatus(db, input) {
   const feedbackEvents = db.prepare(
     "SELECT COUNT(*) as c FROM feedback_events WHERE agent_id = ?"
   ).get(agentId);
+  const tiered = getTieredCapacity();
+  const capacity = {
+    identity: { count: stats.by_type.identity ?? 0, limit: tiered.identity },
+    emotion: { count: stats.by_type.emotion ?? 0, limit: tiered.emotion },
+    knowledge: { count: stats.by_type.knowledge ?? 0, limit: tiered.knowledge },
+    event: { count: stats.by_type.event ?? 0, limit: tiered.event },
+    total: { count: stats.total, limit: tiered.total }
+  };
   return {
     ...stats,
     paths: totalPaths.c,
     low_vitality: lowVitality.c,
     feedback_events: feedbackEvents.c,
-    agent_id: agentId
+    agent_id: agentId,
+    capacity
   };
 }
 
@@ -3617,7 +3871,7 @@ function createMcpServer(dbPath, agentId) {
   const aid = agentId ?? AGENT_ID;
   const server = new McpServer({
     name: "agent-memory",
-    version: "5.0.0"
+    version: "5.1.0"
   });
   server.tool(
     "remember",
@@ -3768,8 +4022,8 @@ function createMcpServer(dbPath, agentId) {
         return { content: [{ type: "text", text: '{"error": "Memory not found"}' }] };
       }
       if (hard) {
-        const { deleteMemory: deleteMemory2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
-        deleteMemory2(db, id);
+        const { deleteMemory: deleteMemory3 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
+        deleteMemory3(db, id);
         return { content: [{ type: "text", text: JSON.stringify({ action: "deleted", id }) }] };
       }
       updateMemory(db, id, { vitality: Math.max(0, memory.vitality * 0.1) });
@@ -3929,6 +4183,74 @@ function createMcpServer(dbPath, agentId) {
       };
     }
   );
+  server.tool(
+    "archive",
+    "Manage archived memories (evicted by governance). List, restore, or purge archived memories.",
+    {
+      action: z.enum(["list", "restore", "purge"]).describe("list: view archived memories; restore: recover one by id; purge: permanently delete all archived"),
+      id: z.string().optional().describe("Memory ID to restore (required for restore action)"),
+      agent_id: z.string().optional().describe("Override agent scope (defaults to current agent)"),
+      limit: z.number().min(1).max(100).default(20).optional().describe("Max results for list (default 20)")
+    },
+    async ({ action, id, agent_id, limit }) => {
+      const effectiveAgentId = agent_id ?? aid;
+      if (action === "list") {
+        const archived = listArchivedMemories(db, { agent_id: effectiveAgentId, limit: limit ?? 20 });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              action: "list",
+              count: archived.length,
+              memories: archived.map((m) => ({
+                id: m.id,
+                content: m.content.slice(0, 200),
+                type: m.type,
+                priority: m.priority,
+                vitality: m.vitality,
+                archived_at: m.archived_at,
+                archive_reason: m.archive_reason
+              }))
+            }, null, 2)
+          }]
+        };
+      }
+      if (action === "restore") {
+        if (!id) {
+          return { content: [{ type: "text", text: '{"error": "id is required for restore action"}' }] };
+        }
+        const restored = restoreMemory(db, id);
+        if (!restored) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: "Archived memory not found", id }) }] };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              action: "restored",
+              memory: {
+                id: restored.id,
+                content: restored.content,
+                type: restored.type,
+                priority: restored.priority,
+                vitality: restored.vitality
+              }
+            }, null, 2)
+          }]
+        };
+      }
+      if (action === "purge") {
+        const purged = purgeArchive(db, { agent_id: effectiveAgentId });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ action: "purged", deleted: purged }, null, 2)
+          }]
+        };
+      }
+      return { content: [{ type: "text", text: '{"error": "Unknown action"}' }] };
+    }
+  );
   return { server, db };
 }
 async function main() {