@elizaos/plugin-memory 1.0.4 → 1.1.0

package/dist/node/index.node.js

@@ -12,16 +12,46 @@ var __export = (target, all) => {
 // src/services/memory-service.ts
 import {
   Service,
-  logger
+  logger as logger4,
+  ModelType as ModelType2,
+  parseKeyValueXml,
+  parseBooleanFromText
 } from "@elizaos/core";
-import { eq, and, desc, sql as sql4, cosineDistance, gte } from "drizzle-orm";
+import { BM25 } from "@elizaos/core";
+
+// src/types/index.ts
+var MEMORY_DIMENSION_MAP = {
+  384: "dim384",
+  512: "dim512",
+  768: "dim768",
+  1024: "dim1024",
+  1536: "dim1536",
+  3072: "dim3072"
+};
+var MemoryType;
+((MemoryType2) => {
+  MemoryType2["EPISODIC"] = "EPISODIC";
+  MemoryType2["SEMANTIC"] = "SEMANTIC";
+  MemoryType2["PROCEDURAL"] = "PROCEDURAL";
+})(MemoryType ||= {});
+var DecayFunction;
+((DecayFunction2) => {
+  DecayFunction2["EXPONENTIAL"] = "EXPONENTIAL";
+  DecayFunction2["LINEAR"] = "LINEAR";
+  DecayFunction2["NONE"] = "NONE";
+})(DecayFunction ||= {});
+
+// src/repositories/long-term-memory.ts
+import { logger } from "@elizaos/core";
+import { eq, and, desc, sql as sql3, cosineDistance, gte, or, isNull } from "drizzle-orm";
 
 // src/schemas/index.ts
 var exports_schemas = {};
 __export(exports_schemas, {
-  sessionSummaries: () => sessionSummaries,
-  memoryAccessLogs: () => memoryAccessLogs,
-  longTermMemories: () => longTermMemories
+  longTermMemoryEmbeddings: () => longTermMemoryEmbeddings,
+  longTermMemories: () => longTermMemories,
+  conversationSummaryEmbeddings: () => conversationSummaryEmbeddings,
+  conversationSummaries: () => conversationSummaries
 });
 
 // src/schemas/long-term-memories.ts
@@ -34,1167 +64,2385 @@ import {
   real,
   index,
   varchar,
-  timestamp
+  timestamp,
+  boolean,
+  vector,
+  foreignKey
 } from "drizzle-orm/pg-core";
+import { VECTOR_DIMS } from "@elizaos/core";
 var longTermMemories = pgTable("long_term_memories", {
   id: varchar("id", { length: 36 }).primaryKey(),
   agentId: varchar("agent_id", { length: 36 }).notNull(),
   entityId: varchar("entity_id", { length: 36 }).notNull(),
-  category: text("category").notNull(),
+  roomId: varchar("room_id", { length: 36 }),
+  type: text("type").notNull(),
   content: text("content").notNull(),
-  metadata: jsonb("metadata"),
-  embedding: real("embedding").array(),
-  confidence: real("confidence").default(1),
-  source: text("source"),
+  embeddingContext: text("embedding_context").notNull(),
+  confidence: real("confidence").notNull().default(1),
+  decayRate: real("decay_rate").notNull().default(0.01),
+  decayFunction: text("decay_function").notNull().default("EXPONENTIAL"),
   createdAt: timestamp("created_at").default(sql`now()`).notNull(),
-  updatedAt: timestamp("updated_at").default(sql`now()`).notNull(),
   lastAccessedAt: timestamp("last_accessed_at"),
-  accessCount: integer("access_count").default(0)
+  accessCount: integer("access_count").default(0).notNull(),
+  isActive: boolean("is_active").default(true).notNull(),
+  source: jsonb("source").notNull().default({}),
+  metadata: jsonb("metadata").notNull().default({}),
+  supersedesId: varchar("supersedes_id", { length: 36 })
 }, (table) => ({
-  agentEntityIdx: index("long_term_memories_agent_entity_idx").on(table.agentId, table.entityId),
-  categoryIdx: index("long_term_memories_category_idx").on(table.category),
-  confidenceIdx: index("long_term_memories_confidence_idx").on(table.confidence),
-  createdAtIdx: index("long_term_memories_created_at_idx").on(table.createdAt)
+  agentEntityIdx: index("ltm_agent_entity_idx").on(table.agentId, table.entityId),
+  typeIdx: index("ltm_type_idx").on(table.type),
+  roomIdx: index("ltm_room_idx").on(table.roomId),
+  activeIdx: index("ltm_active_idx").on(table.isActive),
+  confidenceIdx: index("ltm_confidence_idx").on(table.confidence),
+  createdAtIdx: index("ltm_created_at_idx").on(table.createdAt),
+  lastAccessedIdx: index("ltm_last_accessed_idx").on(table.lastAccessedAt),
+  agentEntityActiveConfidenceIdx: index("ltm_agent_entity_active_conf_idx").on(table.agentId, table.entityId, table.isActive, table.confidence)
 }));
-// src/schemas/session-summaries.ts
+var longTermMemoryEmbeddings = pgTable("long_term_memory_embeddings", {
+  id: varchar("id", { length: 36 }).primaryKey(),
+  memoryId: varchar("memory_id", { length: 36 }).notNull().references(() => longTermMemories.id, { onDelete: "cascade" }),
+  dim384: vector("dim_384", { dimensions: VECTOR_DIMS.SMALL }),
+  dim512: vector("dim_512", { dimensions: VECTOR_DIMS.MEDIUM }),
+  dim768: vector("dim_768", { dimensions: VECTOR_DIMS.LARGE }),
+  dim1024: vector("dim_1024", { dimensions: VECTOR_DIMS.XL }),
+  dim1536: vector("dim_1536", { dimensions: VECTOR_DIMS.XXL }),
+  dim3072: vector("dim_3072", { dimensions: VECTOR_DIMS.XXXL }),
+  createdAt: timestamp("created_at").default(sql`now()`).notNull()
+}, (table) => [
+  index("idx_ltm_embedding_memory_id").on(table.memoryId),
+  foreignKey({
+    name: "fk_ltm_embedding_memory",
+    columns: [table.memoryId],
+    foreignColumns: [longTermMemories.id]
+  }).onDelete("cascade")
+]);
+// src/schemas/conversation-summaries.ts
 import { sql as sql2 } from "drizzle-orm";
 import {
   pgTable as pgTable2,
   text as text2,
   integer as integer2,
   jsonb as jsonb2,
-  real as real2,
   index as index2,
   varchar as varchar2,
-  timestamp as timestamp2
+  timestamp as timestamp2,
+  vector as vector2,
+  foreignKey as foreignKey2
 } from "drizzle-orm/pg-core";
-var sessionSummaries = pgTable2("session_summaries", {
+import { VECTOR_DIMS as VECTOR_DIMS2 } from "@elizaos/core";
+var conversationSummaries = pgTable2("conversation_summaries", {
   id: varchar2("id", { length: 36 }).primaryKey(),
   agentId: varchar2("agent_id", { length: 36 }).notNull(),
+  entityId: varchar2("entity_id", { length: 36 }).notNull(),
   roomId: varchar2("room_id", { length: 36 }).notNull(),
-  entityId: varchar2("entity_id", { length: 36 }),
-  summary: text2("summary").notNull(),
-  messageCount: integer2("message_count").notNull(),
-  lastMessageOffset: integer2("last_message_offset").notNull().default(0),
+  level: integer2("level").notNull().default(1),
+  parentSummaryId: varchar2("parent_summary_id", { length: 36 }),
+  content: text2("content").notNull(),
+  tokenCount: integer2("token_count").notNull(),
   startTime: timestamp2("start_time").notNull(),
   endTime: timestamp2("end_time").notNull(),
-  topics: jsonb2("topics"),
-  metadata: jsonb2("metadata"),
-  embedding: real2("embedding").array(),
+  sourceCount: integer2("source_count").notNull(),
+  sourceIds: jsonb2("source_ids").notNull().default([]),
   createdAt: timestamp2("created_at").default(sql2`now()`).notNull(),
-  updatedAt: timestamp2("updated_at").default(sql2`now()`).notNull()
-}, (table) => ({
-  agentRoomIdx: index2("session_summaries_agent_room_idx").on(table.agentId, table.roomId),
-  entityIdx: index2("session_summaries_entity_idx").on(table.entityId),
-  startTimeIdx: index2("session_summaries_start_time_idx").on(table.startTime)
-}));
-// src/schemas/memory-access-logs.ts
-import { sql as sql3 } from "drizzle-orm";
-import { pgTable as pgTable3, text as text3, integer as integer3, real as real3, index as index3, varchar as varchar3, timestamp as timestamp3 } from "drizzle-orm/pg-core";
-var memoryAccessLogs = pgTable3("memory_access_logs", {
-  id: varchar3("id", { length: 36 }).primaryKey(),
-  agentId: varchar3("agent_id", { length: 36 }).notNull(),
-  memoryId: varchar3("memory_id", { length: 36 }).notNull(),
-  memoryType: text3("memory_type").notNull(),
-  accessedAt: timestamp3("accessed_at").default(sql3`now()`).notNull(),
-  roomId: varchar3("room_id", { length: 36 }),
-  relevanceScore: real3("relevance_score"),
-  wasUseful: integer3("was_useful")
+  lastAccessedAt: timestamp2("last_accessed_at"),
+  accessCount: integer2("access_count").default(0).notNull(),
+  metadata: jsonb2("metadata").notNull().default({})
 }, (table) => ({
-  memoryIdx: index3("memory_access_logs_memory_idx").on(table.memoryId),
-  agentIdx: index3("memory_access_logs_agent_idx").on(table.agentId),
-  accessedAtIdx: index3("memory_access_logs_accessed_at_idx").on(table.accessedAt)
+  agentEntityRoomIdx: index2("cs_agent_entity_room_idx").on(table.agentId, table.entityId, table.roomId),
+  levelIdx: index2("cs_level_idx").on(table.level),
+  parentIdx: index2("cs_parent_idx").on(table.parentSummaryId),
+  timeRangeIdx: index2("cs_time_range_idx").on(table.startTime, table.endTime),
+  createdAtIdx: index2("cs_created_at_idx").on(table.createdAt),
+  lastAccessedIdx: index2("cs_last_accessed_idx").on(table.lastAccessedAt),
+  entityRoomLevelTimeIdx: index2("cs_entity_room_level_time_idx").on(table.entityId, table.roomId, table.level, table.createdAt)
 }));
-// src/services/memory-service.ts
-class MemoryService extends Service {
-  static serviceType = "memory";
-  sessionMessageCounts;
-  memoryConfig;
-  lastExtractionCheckpoints;
-  capabilityDescription = "Advanced memory management with short-term summarization and long-term persistent facts";
-  constructor(runtime) {
-    super(runtime);
-    this.sessionMessageCounts = new Map;
-    this.lastExtractionCheckpoints = new Map;
-    this.memoryConfig = {
-      shortTermSummarizationThreshold: 5,
-      shortTermRetainRecent: 10,
-      longTermExtractionEnabled: true,
-      longTermVectorSearchEnabled: false,
-      longTermConfidenceThreshold: 0.7,
-      longTermExtractionInterval: 5,
-      summaryModelType: "TEXT_LARGE",
-      summaryMaxTokens: 2500
-    };
-  }
-  static async start(runtime) {
-    const service = new MemoryService(runtime);
-    await service.initialize(runtime);
-    return service;
-  }
-  async stop() {
-    logger.info("MemoryService stopped");
-  }
-  async initialize(runtime) {
+var conversationSummaryEmbeddings = pgTable2("conversation_summary_embeddings", {
+  id: varchar2("id", { length: 36 }).primaryKey(),
+  summaryId: varchar2("summary_id", { length: 36 }).notNull().references(() => conversationSummaries.id, { onDelete: "cascade" }),
+  dim384: vector2("dim_384", { dimensions: VECTOR_DIMS2.SMALL }),
+  dim512: vector2("dim_512", { dimensions: VECTOR_DIMS2.MEDIUM }),
+  dim768: vector2("dim_768", { dimensions: VECTOR_DIMS2.LARGE }),
+  dim1024: vector2("dim_1024", { dimensions: VECTOR_DIMS2.XL }),
+  dim1536: vector2("dim_1536", { dimensions: VECTOR_DIMS2.XXL }),
+  dim3072: vector2("dim_3072", { dimensions: VECTOR_DIMS2.XXXL }),
+  createdAt: timestamp2("created_at").default(sql2`now()`).notNull()
+}, (table) => [
+  index2("idx_cs_embedding_summary_id").on(table.summaryId),
+  foreignKey2({
+    name: "fk_cs_embedding_summary",
+    columns: [table.summaryId],
+    foreignColumns: [conversationSummaries.id]
+  }).onDelete("cascade")
+]);
+// src/utils/db-mapping.ts
+function mapDbRowToLongTermMemory(row) {
+  return {
+    id: row.id,
+    agentId: row.agentId,
+    entityId: row.entityId,
+    roomId: row.roomId,
+    type: row.type,
+    content: row.content,
+    embeddingContext: row.embeddingContext,
+    embedding: row.embedding,
+    confidence: row.confidence,
+    decayRate: row.decayRate,
+    decayFunction: row.decayFunction,
+    createdAt: row.createdAt,
+    lastAccessedAt: row.lastAccessedAt,
+    accessCount: row.accessCount,
+    isActive: row.isActive,
+    source: row.source,
+    metadata: row.metadata,
+    supersedesId: row.supersedesId
+  };
+}
+function mapDbRowToConversationSummary(row) {
+  return {
+    id: row.id,
+    agentId: row.agentId,
+    entityId: row.entityId,
+    roomId: row.roomId,
+    level: row.level,
+    parentSummaryId: row.parentSummaryId,
+    content: row.content,
+    embedding: row.embedding,
+    tokenCount: row.tokenCount,
+    startTime: row.startTime,
+    endTime: row.endTime,
+    sourceCount: row.sourceCount,
+    sourceIds: row.sourceIds,
+    createdAt: row.createdAt,
+    lastAccessedAt: row.lastAccessedAt,
+    accessCount: row.accessCount,
+    metadata: row.metadata || {}
+  };
+}
+
+// src/repositories/long-term-memory.ts
+class LongTermMemoryRepository {
+  runtime;
+  embeddingDimension;
+  constructor(runtime, embeddingDimension) {
     this.runtime = runtime;
-    const threshold = runtime.getSetting("MEMORY_SUMMARIZATION_THRESHOLD");
-    if (threshold) {
-      this.memoryConfig.shortTermSummarizationThreshold = parseInt(threshold, 10);
-    }
-    const retainRecent = runtime.getSetting("MEMORY_RETAIN_RECENT");
-    if (retainRecent) {
-      this.memoryConfig.shortTermRetainRecent = parseInt(retainRecent, 10);
-    }
-    const longTermEnabled = runtime.getSetting("MEMORY_LONG_TERM_ENABLED");
-    if (longTermEnabled === "false") {
-      this.memoryConfig.longTermExtractionEnabled = false;
-    } else if (longTermEnabled === "true") {
-      this.memoryConfig.longTermExtractionEnabled = true;
-    }
-    const confidenceThreshold = runtime.getSetting("MEMORY_CONFIDENCE_THRESHOLD");
-    if (confidenceThreshold) {
-      this.memoryConfig.longTermConfidenceThreshold = parseFloat(confidenceThreshold);
-    }
-    logger.info({
-      summarizationThreshold: this.memoryConfig.shortTermSummarizationThreshold,
-      retainRecent: this.memoryConfig.shortTermRetainRecent,
-      longTermEnabled: this.memoryConfig.longTermExtractionEnabled,
-      extractionInterval: this.memoryConfig.longTermExtractionInterval,
-      confidenceThreshold: this.memoryConfig.longTermConfidenceThreshold
-    }, "MemoryService initialized");
-  }
-  getDb() {
-    const db = this.runtime.db;
+    this.embeddingDimension = embeddingDimension;
+  }
+  async getDb() {
+    const adapter = this.runtime.adapter || this.runtime;
+    const db = adapter.db;
     if (!db) {
       throw new Error("Database not available");
     }
-    return db;
-  }
-  getConfig() {
-    return { ...this.memoryConfig };
-  }
-  updateConfig(updates) {
-    this.memoryConfig = { ...this.memoryConfig, ...updates };
-  }
-  incrementMessageCount(roomId) {
-    const current = this.sessionMessageCounts.get(roomId) || 0;
-    const newCount = current + 1;
-    this.sessionMessageCounts.set(roomId, newCount);
-    return newCount;
-  }
-  resetMessageCount(roomId) {
-    this.sessionMessageCounts.set(roomId, 0);
-  }
-  async shouldSummarize(roomId) {
-    const count = await this.runtime.countMemories(roomId, false, "messages");
-    return count >= this.memoryConfig.shortTermSummarizationThreshold;
-  }
-  getExtractionKey(entityId, roomId) {
-    return `memory:extraction:${entityId}:${roomId}`;
-  }
-  async getLastExtractionCheckpoint(entityId, roomId) {
-    const key = this.getExtractionKey(entityId, roomId);
-    const cached = this.lastExtractionCheckpoints.get(key);
-    if (cached !== undefined) {
-      return cached;
-    }
-    try {
-      const checkpoint = await this.runtime.getCache(key);
-      const messageCount = checkpoint ?? 0;
-      this.lastExtractionCheckpoints.set(key, messageCount);
-      return messageCount;
-    } catch (error) {
-      logger.warn({ error }, "Failed to get extraction checkpoint from cache");
-      return 0;
-    }
-  }
-  async setLastExtractionCheckpoint(entityId, roomId, messageCount) {
-    const key = this.getExtractionKey(entityId, roomId);
-    this.lastExtractionCheckpoints.set(key, messageCount);
     try {
-      await this.runtime.setCache(key, messageCount);
-      logger.debug(`Set extraction checkpoint for ${entityId} in room ${roomId} at message count ${messageCount}`);
+      const isReady = await adapter.isReady();
+      if (!isReady) {
+        logger.warn("[LongTermMemoryRepository] Database not ready, attempting reconnect...");
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const stillNotReady = await adapter.isReady();
+        if (stillNotReady === false) {
+          throw new Error("Database connection lost and could not reconnect");
+        }
+      }
     } catch (error) {
-      logger.error({ error }, "Failed to persist extraction checkpoint to cache");
+      logger.error("[LongTermMemoryRepository] Database health check failed:", error);
+      throw new Error("Database connection health check failed");
     }
+    return db;
   }
-  async shouldRunExtraction(entityId, roomId, currentMessageCount) {
-    const interval = this.memoryConfig.longTermExtractionInterval;
-    const lastCheckpoint = await this.getLastExtractionCheckpoint(entityId, roomId);
-    const currentCheckpoint = Math.floor(currentMessageCount / interval) * interval;
-    const shouldRun = currentMessageCount >= interval && currentCheckpoint > lastCheckpoint;
-    logger.debug({
-      entityId,
-      roomId,
-      currentMessageCount,
-      interval,
-      lastCheckpoint,
-      currentCheckpoint,
-      shouldRun
-    }, "Extraction check");
-    return shouldRun;
-  }
-  async storeLongTermMemory(memory) {
-    const db = this.getDb();
+  async insert(memory, embedding) {
+    const db = await this.getDb();
     const id = crypto.randomUUID();
     const now = new Date;
     const newMemory = {
       id,
       createdAt: now,
-      updatedAt: now,
+      lastAccessedAt: null,
       accessCount: 0,
+      isActive: true,
+      embedding: embedding || [],
       ...memory
     };
-    try {
-      await db.insert(longTermMemories).values({
+    await db.transaction(async (tx) => {
+      await tx.insert(longTermMemories).values({
         id: newMemory.id,
         agentId: newMemory.agentId,
         entityId: newMemory.entityId,
-        category: newMemory.category,
+        roomId: newMemory.roomId || null,
+        type: newMemory.type,
         content: newMemory.content,
-        metadata: newMemory.metadata || {},
-        embedding: newMemory.embedding,
+        embeddingContext: newMemory.embeddingContext,
         confidence: newMemory.confidence,
-        source: newMemory.source,
-        accessCount: newMemory.accessCount,
+        decayRate: newMemory.decayRate,
+        decayFunction: newMemory.decayFunction,
         createdAt: now,
-        updatedAt: now,
-        lastAccessedAt: newMemory.lastAccessedAt
+        lastAccessedAt: null,
+        accessCount: 0,
+        isActive: true,
+        source: newMemory.source,
+        metadata: newMemory.metadata,
+        supersedesId: newMemory.supersedesId || null
       });
-    } catch (error) {
-      logger.error({ error }, "Failed to store long-term memory");
-      throw error;
-    }
-    logger.info(`Stored long-term memory: ${newMemory.category} for entity ${newMemory.entityId}`);
+      if (embedding && this.embeddingDimension) {
+        const embeddingValues = {
+          id: crypto.randomUUID(),
+          memoryId: id,
+          createdAt: now
+        };
+        embeddingValues[this.embeddingDimension] = embedding;
+        await tx.insert(longTermMemoryEmbeddings).values(embeddingValues);
+      }
+    });
+    logger.info({
+      id: newMemory.id,
+      type: newMemory.type,
+      entityId: newMemory.entityId,
+      confidence: newMemory.confidence
+    }, "Stored new long-term memory");
     return newMemory;
   }
-  async getLongTermMemories(entityId, category, limit = 10) {
-    const db = this.getDb();
+  async findById(id) {
+    const db = await this.getDb();
+    const results = await db.select().from(longTermMemories).where(eq(longTermMemories.id, id)).limit(1);
+    if (results.length === 0) {
+      return null;
+    }
+    return mapDbRowToLongTermMemory(results[0]);
+  }
+  async update(id, updates, newEmbedding) {
+    const db = await this.getDb();
+    const updateData = {};
+    if (updates.content !== undefined)
+      updateData.content = updates.content;
+    if (updates.embeddingContext !== undefined)
+      updateData.embeddingContext = updates.embeddingContext;
+    if (updates.confidence !== undefined)
+      updateData.confidence = updates.confidence;
+    if (updates.decayRate !== undefined)
+      updateData.decayRate = updates.decayRate;
+    if (updates.decayFunction !== undefined)
+      updateData.decayFunction = updates.decayFunction;
+    if (updates.lastAccessedAt !== undefined)
+      updateData.lastAccessedAt = updates.lastAccessedAt;
+    if (updates.accessCount !== undefined)
+      updateData.accessCount = updates.accessCount;
+    if (updates.isActive !== undefined)
+      updateData.isActive = updates.isActive;
+    if (updates.source !== undefined)
+      updateData.source = updates.source;
+    if (updates.metadata !== undefined)
+      updateData.metadata = updates.metadata;
+    if (updates.supersedesId !== undefined)
+      updateData.supersedesId = updates.supersedesId;
+    await db.transaction(async (tx) => {
+      await tx.update(longTermMemories).set(updateData).where(eq(longTermMemories.id, id));
+      if (newEmbedding && this.embeddingDimension) {
+        const embeddingUpdate = {};
+        embeddingUpdate[this.embeddingDimension] = newEmbedding;
+        await tx.update(longTermMemoryEmbeddings).set(embeddingUpdate).where(eq(longTermMemoryEmbeddings.memoryId, id));
+      }
+    });
+    logger.info({ id }, "Updated long-term memory");
+  }
+  async delete(id) {
+    const db = await this.getDb();
+    await db.delete(longTermMemories).where(eq(longTermMemories.id, id));
+    logger.info({ id }, "Deleted long-term memory");
+  }
+  async findByEntity(entityId, type, limit = 20, includeInactive = false) {
+    const db = await this.getDb();
     const conditions = [
       eq(longTermMemories.agentId, this.runtime.agentId),
       eq(longTermMemories.entityId, entityId)
     ];
-    if (category) {
-      conditions.push(eq(longTermMemories.category, category));
+    if (!includeInactive) {
+      conditions.push(eq(longTermMemories.isActive, true));
+    }
+    if (type) {
+      conditions.push(eq(longTermMemories.type, type));
+    }
+    const results = await db.select().from(longTermMemories).where(and(...conditions)).orderBy(desc(longTermMemories.confidence), desc(longTermMemories.createdAt)).limit(limit);
+    return results.map((row) => mapDbRowToLongTermMemory(row));
+  }
+  async vectorSearch(params, queryEmbedding, similarityThreshold = 0.3) {
+    if (!this.embeddingDimension) {
+      logger.warn("Embedding dimension not set, skipping vector search");
+      return [];
+    }
+    const db = await this.getDb();
+    try {
+      const similarity = sql3`1 - (${cosineDistance(longTermMemoryEmbeddings[this.embeddingDimension], queryEmbedding)})`;
+      const conditions = [
+        eq(longTermMemories.agentId, this.runtime.agentId),
+        eq(longTermMemories.entityId, params.entityId),
+        sql3`${longTermMemoryEmbeddings[this.embeddingDimension]} IS NOT NULL`,
+        gte(similarity, similarityThreshold)
+      ];
+      if (params.minConfidence) {
+        conditions.push(gte(longTermMemories.confidence, params.minConfidence));
+      }
+      if (!params.includeInactive) {
+        conditions.push(eq(longTermMemories.isActive, true));
+      }
+      if (params.type) {
+        conditions.push(eq(longTermMemories.type, params.type));
+      }
+      if (params.roomId) {
+        conditions.push(or(eq(longTermMemories.roomId, params.roomId), isNull(longTermMemories.roomId)));
+      }
+      const results = await db.select({
+        memory: longTermMemories,
+        embedding: longTermMemoryEmbeddings[this.embeddingDimension],
+        similarity
+      }).from(longTermMemories).innerJoin(longTermMemoryEmbeddings, eq(longTermMemoryEmbeddings.memoryId, longTermMemories.id)).where(and(...conditions)).orderBy(desc(similarity)).limit(params.limit || 20);
+      return results.map((row) => ({
+        ...mapDbRowToLongTermMemory(row.memory),
+        embedding: row.embedding,
+        relevanceScore: row.similarity,
+        activationScore: 0,
+        finalScore: 0
+      }));
+    } catch (error) {
+      logger.error("Failed to execute vector search:", JSON.stringify(error));
+      return [];
     }
-    const results = await db.select().from(longTermMemories).where(and(...conditions)).orderBy(desc(longTermMemories.confidence), desc(longTermMemories.updatedAt)).limit(limit);
-    return results.map((row) => ({
+  }
+  async fetchAllActive() {
+    const db = await this.getDb();
+    const memories = await db.select().from(longTermMemories).where(and(eq(longTermMemories.agentId, this.runtime.agentId), eq(longTermMemories.isActive, true)));
+    return memories.map((row) => ({
       id: row.id,
-      agentId: row.agentId,
-      entityId: row.entityId,
-      category: row.category,
       content: row.content,
-      metadata: row.metadata,
-      embedding: row.embedding,
-      confidence: row.confidence,
-      source: row.source,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
-      lastAccessedAt: row.lastAccessedAt,
-      accessCount: row.accessCount
+      embeddingContext: row.embeddingContext
     }));
   }
-  async updateLongTermMemory(id, updates) {
-    const db = this.getDb();
-    const updateData = {
-      updatedAt: new Date
-    };
-    if (updates.content !== undefined) {
-      updateData.content = updates.content;
-    }
-    if (updates.metadata !== undefined) {
-      updateData.metadata = updates.metadata;
-    }
-    if (updates.confidence !== undefined) {
-      updateData.confidence = updates.confidence;
-    }
-    if (updates.embedding !== undefined) {
-      updateData.embedding = updates.embedding;
-    }
-    if (updates.lastAccessedAt !== undefined) {
-      updateData.lastAccessedAt = updates.lastAccessedAt;
-    }
-    if (updates.accessCount !== undefined) {
-      updateData.accessCount = updates.accessCount;
+  async updateAccessMetadata(memoryIds) {
+    if (memoryIds.length === 0)
+      return;
+    const db = await this.getDb();
+    const now = new Date;
+    try {
+      for (const id of memoryIds) {
+        await db.update(longTermMemories).set({
+          lastAccessedAt: now,
+          accessCount: sql3`${longTermMemories.accessCount} + 1`
+        }).where(eq(longTermMemories.id, id));
+      }
+      logger.debug({ count: memoryIds.length }, "Updated access metadata");
+    } catch (error) {
+      logger.error({ error }, "Failed to update access metadata");
     }
-    await db.update(longTermMemories).set(updateData).where(eq(longTermMemories.id, id));
-    logger.info(`Updated long-term memory: ${id}`);
   }
-  async deleteLongTermMemory(id) {
-    const db = this.getDb();
-    await db.delete(longTermMemories).where(eq(longTermMemories.id, id));
-    logger.info(`Deleted long-term memory: ${id}`);
+}
+
+// src/repositories/conversation-summary.ts
+import { logger as logger2 } from "@elizaos/core";
+import { eq as eq2, and as and2, desc as desc2, sql as sql4, cosineDistance as cosineDistance2 } from "drizzle-orm";
+class ConversationSummaryRepository {
+  runtime;
+  embeddingDimension;
+  constructor(runtime, embeddingDimension) {
+    this.runtime = runtime;
+    this.embeddingDimension = embeddingDimension;
   }
-  async getCurrentSessionSummary(roomId) {
-    const db = this.getDb();
-    const results = await db.select().from(sessionSummaries).where(and(eq(sessionSummaries.agentId, this.runtime.agentId), eq(sessionSummaries.roomId, roomId))).orderBy(desc(sessionSummaries.updatedAt)).limit(1);
-    if (results.length === 0) {
-      return null;
+  async getDb() {
+    const adapter = this.runtime.adapter || this.runtime;
+    const db = adapter.db;
+    if (!db) {
+      throw new Error("Database not available");
     }
-    const row = results[0];
-    return {
-      id: row.id,
-      agentId: row.agentId,
-      roomId: row.roomId,
-      entityId: row.entityId,
-      summary: row.summary,
-      messageCount: row.messageCount,
-      lastMessageOffset: row.lastMessageOffset,
-      startTime: row.startTime,
-      endTime: row.endTime,
-      topics: row.topics || [],
-      metadata: row.metadata,
-      embedding: row.embedding,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt
-    };
+    try {
+      const isReady = await adapter.isReady();
+      if (!isReady) {
+        logger2.warn("[ConversationSummaryRepository] Database not ready, attempting reconnect...");
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const stillNotReady = await adapter.isReady();
+        if (stillNotReady === false) {
+          throw new Error("Database connection lost and could not reconnect");
+        }
+      }
+    } catch (error) {
+      logger2.error("[ConversationSummaryRepository] Database health check failed:", error);
+      throw new Error("Database connection health check failed");
+    }
+    return db;
   }
-  async storeSessionSummary(summary) {
-    const db = this.getDb();
+  async insert(summary, embedding) {
+    const db = await this.getDb();
     const id = crypto.randomUUID();
     const now = new Date;
     const newSummary = {
       id,
       createdAt: now,
-      updatedAt: now,
+      lastAccessedAt: null,
+      accessCount: 0,
+      embedding: embedding || [],
       ...summary
     };
-    await db.insert(sessionSummaries).values({
-      id: newSummary.id,
-      agentId: newSummary.agentId,
-      roomId: newSummary.roomId,
-      entityId: newSummary.entityId || null,
-      summary: newSummary.summary,
-      messageCount: newSummary.messageCount,
-      lastMessageOffset: newSummary.lastMessageOffset,
-      startTime: newSummary.startTime,
-      endTime: newSummary.endTime,
-      topics: newSummary.topics || [],
-      metadata: newSummary.metadata || {},
-      embedding: newSummary.embedding,
-      createdAt: now,
-      updatedAt: now
+    await db.transaction(async (tx) => {
+      await tx.insert(conversationSummaries).values({
+        id: newSummary.id,
+        agentId: newSummary.agentId,
+        entityId: newSummary.entityId,
+        roomId: newSummary.roomId,
+        level: newSummary.level,
+        parentSummaryId: newSummary.parentSummaryId || null,
+        content: newSummary.content,
+        tokenCount: newSummary.tokenCount,
+        startTime: newSummary.startTime,
+        endTime: newSummary.endTime,
+        sourceCount: newSummary.sourceCount,
+        sourceIds: newSummary.sourceIds,
+        createdAt: now,
+        lastAccessedAt: null,
+        accessCount: 0,
+        metadata: newSummary.metadata
+      });
+      if (embedding && this.embeddingDimension) {
+        const embeddingValues = {
+          id: crypto.randomUUID(),
+          summaryId: id,
+          createdAt: now
+        };
+        embeddingValues[this.embeddingDimension] = embedding;
+        await tx.insert(conversationSummaryEmbeddings).values(embeddingValues);
+      }
     });
-    logger.info(`Stored session summary for room ${newSummary.roomId}`);
+    logger2.info({
+      id: newSummary.id,
+      level: newSummary.level,
+      tokenCount: newSummary.tokenCount,
+      sourceCount: newSummary.sourceCount
+    }, "Stored conversation summary");
     return newSummary;
   }
-  async updateSessionSummary(id, updates) {
-    const db = this.getDb();
-    const updateData = {
-      updatedAt: new Date
-    };
-    if (updates.summary !== undefined) {
-      updateData.summary = updates.summary;
-    }
-    if (updates.messageCount !== undefined) {
-      updateData.messageCount = updates.messageCount;
-    }
-    if (updates.lastMessageOffset !== undefined) {
-      updateData.lastMessageOffset = updates.lastMessageOffset;
-    }
-    if (updates.endTime !== undefined) {
-      updateData.endTime = updates.endTime;
-    }
-    if (updates.topics !== undefined) {
-      updateData.topics = updates.topics;
-    }
-    if (updates.metadata !== undefined) {
-      updateData.metadata = updates.metadata;
-    }
-    if (updates.embedding !== undefined) {
-      updateData.embedding = updates.embedding;
-    }
-    await db.update(sessionSummaries).set(updateData).where(eq(sessionSummaries.id, id));
-    logger.info(`Updated session summary: ${id}`);
-  }
-  async getSessionSummaries(roomId, limit = 5) {
-    const db = this.getDb();
-    const results = await db.select().from(sessionSummaries).where(and(eq(sessionSummaries.agentId, this.runtime.agentId), eq(sessionSummaries.roomId, roomId))).orderBy(desc(sessionSummaries.updatedAt)).limit(limit);
-    return results.map((row) => ({
-      id: row.id,
-      agentId: row.agentId,
-      roomId: row.roomId,
-      entityId: row.entityId,
-      summary: row.summary,
-      messageCount: row.messageCount,
-      lastMessageOffset: row.lastMessageOffset,
-      startTime: row.startTime,
-      endTime: row.endTime,
-      topics: row.topics || [],
-      metadata: row.metadata,
-      embedding: row.embedding,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt
-    }));
+  async findByLevel(roomId, level) {
+    const db = await this.getDb();
+    const results = await db.select().from(conversationSummaries).where(and2(eq2(conversationSummaries.agentId, this.runtime.agentId), eq2(conversationSummaries.roomId, roomId), eq2(conversationSummaries.level, level))).orderBy(desc2(conversationSummaries.createdAt));
+    return results.map((r) => mapDbRowToConversationSummary(r));
   }
-  async searchLongTermMemories(entityId, queryEmbedding, limit = 5, matchThreshold = 0.7) {
-    if (!this.memoryConfig.longTermVectorSearchEnabled) {
-      logger.warn("Vector search is not enabled, falling back to recent memories");
-      return this.getLongTermMemories(entityId, undefined, limit);
+  async vectorSearch(entityId, roomId, queryEmbedding, limit = 5) {
+    if (!this.embeddingDimension) {
+      logger2.warn("Embedding dimension not set, skipping summary search");
+      return [];
     }
-    const db = this.getDb();
+    const db = await this.getDb();
     try {
-      const cleanVector = queryEmbedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
-      const similarity = sql4`1 - (${cosineDistance(longTermMemories.embedding, cleanVector)})`;
-      const conditions = [
-        eq(longTermMemories.agentId, this.runtime.agentId),
-        eq(longTermMemories.entityId, entityId),
-        sql4`${longTermMemories.embedding} IS NOT NULL`
-      ];
-      if (matchThreshold > 0) {
-        conditions.push(gte(similarity, matchThreshold));
-      }
+      const similarity = sql4`1 - (${cosineDistance2(conversationSummaryEmbeddings[this.embeddingDimension], queryEmbedding)})`;
       const results = await db.select({
-        memory: longTermMemories,
+        summary: conversationSummaries,
+        embedding: conversationSummaryEmbeddings[this.embeddingDimension],
         similarity
-      }).from(longTermMemories).where(and(...conditions)).orderBy(desc(similarity)).limit(limit);
-      return results.map((row) => ({
-        id: row.memory.id,
-        agentId: row.memory.agentId,
-        entityId: row.memory.entityId,
-        category: row.memory.category,
-        content: row.memory.content,
-        metadata: row.memory.metadata,
-        embedding: row.memory.embedding,
-        confidence: row.memory.confidence,
-        source: row.memory.source,
-        createdAt: row.memory.createdAt,
-        updatedAt: row.memory.updatedAt,
-        lastAccessedAt: row.memory.lastAccessedAt,
-        accessCount: row.memory.accessCount,
-        similarity: row.similarity
+      }).from(conversationSummaries).innerJoin(conversationSummaryEmbeddings, eq2(conversationSummaryEmbeddings.summaryId, conversationSummaries.id)).where(and2(eq2(conversationSummaries.agentId, this.runtime.agentId), eq2(conversationSummaries.entityId, entityId), eq2(conversationSummaries.roomId, roomId), sql4`${conversationSummaryEmbeddings[this.embeddingDimension]} IS NOT NULL`)).orderBy(desc2(similarity)).limit(limit * 2);
+      return results.map((r) => ({
+        ...mapDbRowToConversationSummary(r.summary),
+        embedding: r.embedding
       }));
     } catch (error) {
-      logger.warn({ error }, "Vector search failed, falling back to recent memories");
-      return this.getLongTermMemories(entityId, undefined, limit);
+      logger2.error("Failed to search summaries:", JSON.stringify(error));
+      return [];
     }
   }
-  async getFormattedLongTermMemories(entityId) {
-    const memories = await this.getLongTermMemories(entityId, undefined, 20);
-    if (memories.length === 0) {
-      return "";
-    }
-    const grouped = new Map;
-    for (const memory of memories) {
-      if (!grouped.has(memory.category)) {
-        grouped.set(memory.category, []);
+  async updateAccessMetadata(summaryIds) {
+    if (summaryIds.length === 0)
+      return;
+    const db = await this.getDb();
+    const now = new Date;
+    try {
+      for (const id of summaryIds) {
+        await db.update(conversationSummaries).set({
+          lastAccessedAt: now,
+          accessCount: sql4`${conversationSummaries.accessCount} + 1`
+        }).where(eq2(conversationSummaries.id, id));
       }
-      grouped.get(memory.category)?.push(memory);
-    }
-    const sections = [];
-    for (const [category, categoryMemories] of grouped.entries()) {
-      const categoryName = category.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-      const items = categoryMemories.map((m) => `- ${m.content}`).join(`
-`);
-      sections.push(`**${categoryName}**:
-${items}`);
+      logger2.debug({ count: summaryIds.length }, "Updated summary access metadata");
+    } catch (error) {
+      logger2.error({ error }, "Failed to update summary access metadata");
     }
-    return sections.join(`
+  }
+}
 
-`);
+// src/utils/embedding.ts
+import { ModelType, logger as logger3 } from "@elizaos/core";
+async function generateEmbedding(runtime, text3) {
+  try {
+    const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, text3);
+    return embedding;
+  } catch (error) {
+    logger3.error({ error }, "Failed to generate embedding");
+    return new Array(1536).fill(0);
   }
 }
+function cleanEmbedding(embedding) {
+  return embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
+}
 
-// src/evaluators/summarization.ts
-import {
-  logger as logger2,
-  ModelType,
-  composePromptFromState
-} from "@elizaos/core";
-var initialSummarizationTemplate = `# Task: Summarize Conversation
-
-You are analyzing a conversation to create a concise summary that captures the key points, topics, and important details.
-
-# Recent Messages
-{{recentMessages}}
-
-# Instructions
-Generate a summary that:
-1. Captures the main topics discussed
-2. Highlights key information shared
-3. Notes any decisions made or questions asked
-4. Maintains context for future reference
-5. Is concise but comprehensive
-
-**IMPORTANT**: Keep the summary under 2500 tokens. Be comprehensive but concise.
-
-Also extract:
-- **Topics**: List of main topics discussed (comma-separated)
-- **Key Points**: Important facts or decisions (bullet points)
-
-Respond in this XML format:
-<summary>
-  <text>Your comprehensive summary here</text>
-  <topics>topic1, topic2, topic3</topics>
-  <keyPoints>
-    <point>First key point</point>
-    <point>Second key point</point>
-  </keyPoints>
-</summary>`;
-var updateSummarizationTemplate = `# Task: Update and Condense Conversation Summary
-
-You are updating an existing conversation summary with new messages, while keeping the total summary concise.
-
-# Existing Summary
-{{existingSummary}}
-
-# Existing Topics
-{{existingTopics}}
-
-# New Messages Since Last Summary
-{{newMessages}}
-
-# Instructions
-Update the summary by:
-1. Merging the existing summary with insights from the new messages
-2. Removing redundant or less important details to stay under the token limit
-3. Keeping the most important context and decisions
-4. Adding new topics if they emerge
-5. **CRITICAL**: Keep the ENTIRE updated summary under 2500 tokens
-
-The goal is a rolling summary that captures the essence of the conversation without growing indefinitely.
-
-Respond in this XML format:
-<summary>
-  <text>Your updated and condensed summary here</text>
-  <topics>topic1, topic2, topic3</topics>
-  <keyPoints>
-    <point>First key point</point>
-    <point>Second key point</point>
-  </keyPoints>
-</summary>`;
-function parseSummaryXML(xml) {
-  const summaryMatch = xml.match(/<text>([\s\S]*?)<\/text>/);
-  const topicsMatch = xml.match(/<topics>([\s\S]*?)<\/topics>/);
-  const keyPointsMatches = xml.matchAll(/<point>([\s\S]*?)<\/point>/g);
-  const summary = summaryMatch ? summaryMatch[1].trim() : "Summary not available";
-  const topics = topicsMatch ? topicsMatch[1].split(",").map((t) => t.trim()).filter(Boolean) : [];
-  const keyPoints = Array.from(keyPointsMatches).map((match) => match[1].trim());
-  return { summary, topics, keyPoints };
+// src/utils/decay-scoring.ts
+function calculateDecayFactor(decayFunction, decayRate, timeDeltaDays) {
+  switch (decayFunction) {
+    case "EXPONENTIAL" /* EXPONENTIAL */:
+      return Math.exp(-decayRate * timeDeltaDays);
+    case "LINEAR" /* LINEAR */:
+      return Math.max(0, 1 - decayRate * timeDeltaDays);
+    case "NONE" /* NONE */:
+      return 1;
+    default:
+      return 1;
+  }
 }
-var summarizationEvaluator = {
-  name: "MEMORY_SUMMARIZATION",
-  description: "Automatically summarizes conversations to optimize context usage",
-  similes: ["CONVERSATION_SUMMARY", "CONTEXT_COMPRESSION", "MEMORY_OPTIMIZATION"],
-  alwaysRun: true,
-  validate: async (runtime, message) => {
-    if (!message.content?.text) {
-      logger2.debug("Skipping summarization: no message text");
-      return false;
-    }
-    const memoryService = runtime.getService("memory");
-    if (!memoryService) {
-      logger2.debug("Skipping summarization: memory service not available");
-      return false;
+function calculateAccessBoost(accessCount) {
+  return 1 + Math.log(1 + accessCount) * 0.1;
+}
+function applyDecayScoring(memories) {
+  const now = Date.now();
+  return memories.map((memory) => {
+    const lastAccessed = memory.lastAccessedAt?.getTime() || memory.createdAt.getTime();
+    const timeDeltaDays = (now - lastAccessed) / (1000 * 60 * 60 * 24);
+    const decayFactor = calculateDecayFactor(memory.decayFunction, memory.decayRate, timeDeltaDays);
+    const accessBoost = calculateAccessBoost(memory.accessCount);
+    const activationScore = memory.confidence * decayFactor * accessBoost;
+    const finalScore = memory.relevanceScore * activationScore;
+    return {
+      ...memory,
+      activationScore,
+      finalScore
+    };
+  });
+}
+
+// src/utils/search-merging.ts
+function mergeSearchResults(vectorResults, bm25Results) {
+  const merged = new Map;
+  for (const result of vectorResults) {
+    merged.set(result.id, result);
+  }
+  for (const result of bm25Results) {
+    if (merged.has(result.id)) {
+      const existing = merged.get(result.id);
+      existing.relevanceScore = (existing.relevanceScore + result.relevanceScore) / 2;
+    } else {
+      merged.set(result.id, result);
     }
-    const config = memoryService.getConfig();
-    const currentMessageCount = await runtime.countMemories(message.roomId, false, "messages");
-    const shouldSummarize = currentMessageCount >= config.shortTermSummarizationThreshold;
-    logger2.debug({
-      roomId: message.roomId,
-      currentMessageCount,
-      threshold: config.shortTermSummarizationThreshold,
-      shouldSummarize
-    }, "Summarization validation check");
-    return shouldSummarize;
-  },
-  handler: async (runtime, message) => {
-    const memoryService = runtime.getService("memory");
-    if (!memoryService) {
-      logger2.error("MemoryService not found");
-      return;
+  }
+  return Array.from(merged.values());
+}
+
+// src/utils/formatting.ts
+function formatMemoriesForContext(memories) {
+  if (memories.length === 0) {
+    return "";
+  }
+  const grouped = new Map;
+  for (const memory of memories) {
+    if (!grouped.has(memory.type)) {
+      grouped.set(memory.type, []);
     }
-    const config = memoryService.getConfig();
-    const { roomId } = message;
-    try {
-      logger2.info(`Starting summarization for room ${roomId}`);
-      const existingSummary = await memoryService.getCurrentSessionSummary(roomId);
-      const lastOffset = existingSummary?.lastMessageOffset || 0;
-      const totalMessageCount = await runtime.countMemories(roomId, false, "messages");
-      const newMessages = await runtime.getMemories({
-        tableName: "messages",
-        roomId,
-        count: config.shortTermSummarizationThreshold,
-        unique: false,
-        start: lastOffset
-      });
-      if (newMessages.length === 0) {
-        logger2.debug("No new messages to summarize");
-        return;
-      }
-      const sortedMessages = newMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
-      const formattedMessages = sortedMessages.map((msg) => {
-        const sender = msg.entityId === runtime.agentId ? runtime.character.name : "User";
-        return `${sender}: ${msg.content.text || "[non-text message]"}`;
-      }).join(`
+    grouped.get(memory.type).push(memory);
+  }
+  const sections = [];
+  if (grouped.has("SEMANTIC" /* SEMANTIC */)) {
+    const facts = grouped.get("SEMANTIC" /* SEMANTIC */);
+    const items = facts.map((m) => `- ${m.content} (confidence: ${m.confidence.toFixed(2)})`).join(`
 `);
-      const state = await runtime.composeState(message);
-      let prompt;
-      let template;
-      if (existingSummary) {
-        template = updateSummarizationTemplate;
-        prompt = composePromptFromState({
-          state: {
-            ...state,
-            existingSummary: existingSummary.summary,
-            existingTopics: existingSummary.topics?.join(", ") || "None",
-            newMessages: formattedMessages
-          },
-          template
-        });
-      } else {
-        template = initialSummarizationTemplate;
-        prompt = composePromptFromState({
-          state: {
-            ...state,
-            recentMessages: formattedMessages
-          },
-          template
-        });
-      }
-      const response = await runtime.useModel(ModelType.TEXT_LARGE, {
-        prompt,
-        maxTokens: config.summaryMaxTokens || 2500
-      });
-      const summaryResult = parseSummaryXML(response);
-      logger2.info(`${existingSummary ? "Updated" : "Generated"} summary: ${summaryResult.summary.substring(0, 100)}...`);
-      const newOffset = totalMessageCount;
-      const firstMessage = sortedMessages[0];
-      const lastMessage = sortedMessages[sortedMessages.length - 1];
-      const startTime = existingSummary ? existingSummary.startTime : firstMessage?.createdAt && firstMessage.createdAt > 0 ? new Date(firstMessage.createdAt) : new Date;
-      const endTime = lastMessage?.createdAt && lastMessage.createdAt > 0 ? new Date(lastMessage.createdAt) : new Date;
-      if (existingSummary) {
-        await memoryService.updateSessionSummary(existingSummary.id, {
-          summary: summaryResult.summary,
-          messageCount: existingSummary.messageCount + sortedMessages.length,
-          lastMessageOffset: newOffset,
-          endTime,
-          topics: summaryResult.topics,
-          metadata: {
-            keyPoints: summaryResult.keyPoints
-          }
-        });
-        logger2.info(`Updated summary for room ${roomId}: ${sortedMessages.length} new messages processed (offset: ${lastOffset} → ${newOffset})`);
-      } else {
-        await memoryService.storeSessionSummary({
-          agentId: runtime.agentId,
-          roomId,
-          entityId: message.entityId !== runtime.agentId ? message.entityId : undefined,
-          summary: summaryResult.summary,
-          messageCount: sortedMessages.length,
-          lastMessageOffset: newOffset,
-          startTime,
-          endTime,
-          topics: summaryResult.topics,
-          metadata: {
-            keyPoints: summaryResult.keyPoints
-          }
-        });
-        logger2.info(`Created new summary for room ${roomId}: ${sortedMessages.length} messages summarized (offset: 0 → ${newOffset})`);
-      }
-    } catch (error) {
-      logger2.error({ error }, "Error during summarization:");
-    }
-  },
-  examples: []
-};
+    sections.push(`**Semantic Knowledge (Facts)**:
+${items}`);
+  }
+  if (grouped.has("EPISODIC" /* EPISODIC */)) {
+    const episodes = grouped.get("EPISODIC" /* EPISODIC */);
+    const items = episodes.map((m) => `- ${m.content} (${m.createdAt.toLocaleDateString()})`).join(`
+`);
+    sections.push(`**Episodic Memory (Events)**:
+${items}`);
+  }
+  if (grouped.has("PROCEDURAL" /* PROCEDURAL */)) {
+    const skills = grouped.get("PROCEDURAL" /* PROCEDURAL */);
+    const items = skills.map((m) => `- ${m.content}`).join(`
+`);
+    sections.push(`**Procedural Knowledge (Skills)**:
+${items}`);
+  }
+  return sections.join(`
 
-// src/evaluators/long-term-extraction.ts
-import {
-  logger as logger3,
-  ModelType as ModelType2,
-  composePromptFromState as composePromptFromState2
-} from "@elizaos/core";
+`);
+}
 
-// src/types/index.ts
-var LongTermMemoryCategory;
-((LongTermMemoryCategory2) => {
-  LongTermMemoryCategory2["IDENTITY"] = "identity";
-  LongTermMemoryCategory2["EXPERTISE"] = "expertise";
-  LongTermMemoryCategory2["PROJECTS"] = "projects";
-  LongTermMemoryCategory2["PREFERENCES"] = "preferences";
-  LongTermMemoryCategory2["DATA_SOURCES"] = "data_sources";
-  LongTermMemoryCategory2["GOALS"] = "goals";
-  LongTermMemoryCategory2["CONSTRAINTS"] = "constraints";
-  LongTermMemoryCategory2["DEFINITIONS"] = "definitions";
-  LongTermMemoryCategory2["BEHAVIORAL_PATTERNS"] = "behavioral_patterns";
-})(LongTermMemoryCategory ||= {});
-
-// src/evaluators/long-term-extraction.ts
-var extractionTemplate = `# Task: Extract Long-Term Memory
-
-You are analyzing a conversation to extract facts that should be remembered long-term about the user.
-
-# Recent Messages
-{{recentMessages}}
-
-# Current Long-Term Memories
-{{existingMemories}}
-
-# Memory Categories
-1. **identity**: User's name, role, identity (e.g., "I'm a data scientist")
-2. **expertise**: User's skills, knowledge domains, or unfamiliarity with topics
-3. **projects**: Ongoing projects, past interactions, recurring topics
-4. **preferences**: Communication style, format preferences, verbosity, etc.
-5. **data_sources**: Frequently used files, databases, APIs
-6. **goals**: Broader intentions (e.g., "preparing for interview")
-7. **constraints**: User-defined rules or limitations
-8. **definitions**: Custom terms, acronyms, glossaries
-9. **behavioral_patterns**: How the user tends to interact
-
-# Instructions
-Extract any NEW information that should be remembered long-term. For each item:
-- Determine which category it belongs to
-- Write a clear, factual statement
-- Assess confidence (0.0 to 1.0)
-- Only include information explicitly stated or strongly implied
-
-If there are no new long-term facts to extract, respond with <memories></memories>
-
-Respond in this XML format:
-<memories>
-  <memory>
-    <category>identity</category>
-    <content>User is a software engineer specializing in backend development</content>
-    <confidence>0.95</confidence>
-  </memory>
-  <memory>
-    <category>preferences</category>
-    <content>Prefers code examples over lengthy explanations</content>
-    <confidence>0.85</confidence>
-  </memory>
-</memories>`;
-function parseMemoryExtractionXML(xml) {
-  const memoryMatches = xml.matchAll(/<memory>[\s\S]*?<category>(.*?)<\/category>[\s\S]*?<content>(.*?)<\/content>[\s\S]*?<confidence>(.*?)<\/confidence>[\s\S]*?<\/memory>/g);
-  const extractions = [];
-  for (const match of memoryMatches) {
-    const category = match[1].trim();
-    const content = match[2].trim();
-    const confidence = parseFloat(match[3].trim());
-    if (!Object.values(LongTermMemoryCategory).includes(category)) {
-      logger3.warn(`Invalid memory category: ${category}`);
-      continue;
-    }
-    if (content && !isNaN(confidence)) {
-      extractions.push({ category, content, confidence });
-    }
-  }
-  return extractions;
+// src/utils/token-counter.ts
+function estimateTokenCount(text3) {
+  if (!text3 || text3.length === 0) {
+    return 0;
+  }
+  const charCount = text3.length;
+  const estimatedTokens = Math.ceil(charCount / 4);
+  return estimatedTokens;
 }
-var longTermExtractionEvaluator = {
-  name: "LONG_TERM_MEMORY_EXTRACTION",
-  description: "Extracts long-term facts about users from conversations",
-  similes: ["MEMORY_EXTRACTION", "FACT_LEARNING", "USER_PROFILING"],
-  alwaysRun: true,
-  validate: async (runtime, message) => {
-    logger3.debug(`Validating long-term memory extraction for message: ${message.content?.text}`);
-    if (message.entityId === runtime.agentId) {
-      logger3.debug("Skipping long-term memory extraction for agent's own message");
-      return false;
+function estimateTokenCountForArray(texts) {
+  return texts.reduce((total, text3) => total + estimateTokenCount(text3), 0);
+}
+function trimToTokenBudget(items, budget, getText, includeOverhead = 10) {
+  const result = [];
+  let currentTokens = 0;
+  for (const item of items) {
+    const itemText = getText(item);
+    const itemTokens = estimateTokenCount(itemText) + includeOverhead;
+    if (currentTokens + itemTokens > budget) {
+      break;
     }
-    if (!message.content?.text) {
-      logger3.debug("Skipping long-term memory extraction for message without text");
-      return false;
+    result.push(item);
+    currentTokens += itemTokens;
+  }
+  return result;
+}
+function formatTokenCount(count) {
+  if (count < 1000) {
+    return `${count} tokens`;
+  } else if (count < 1e6) {
+    return `${(count / 1000).toFixed(1)}K tokens`;
+  } else {
+    return `${(count / 1e6).toFixed(1)}M tokens`;
+  }
+}
+
+// src/services/memory-service.ts
+class MemoryService extends Service {
+  static serviceType = "memory";
+  bm25Index = null;
+  embeddingDimension;
+  isInitialized = false;
+  longTermMemoryRepo;
+  conversationSummaryRepo;
+  capabilityDescription = "State-of-the-art cognitive memory system with episodic, semantic, and procedural memory";
+  static defaultConfig = {
+    consolidationThreshold: 12,
+    minConfidence: 0.7,
+    enableVectorSearch: true,
+    enableBM25: true,
+    retrievalLimit: 5,
+    tokenBudget: 1000,
+    defaultDecayRates: {
+      ["EPISODIC" /* EPISODIC */]: 0.05,
+      ["SEMANTIC" /* SEMANTIC */]: 0.01,
+      ["PROCEDURAL" /* PROCEDURAL */]: 0.02
+    },
+    enableContradictionDetection: true,
+    summarization: {
+      enabled: true,
+      messagesPerSummary: 7,
+      summariesPerLevel: 5,
+      maxDepth: 3,
+      summaryTokenBudget: 500
     }
-    const memoryService = runtime.getService("memory");
-    if (!memoryService) {
-      logger3.debug("MemoryService not found");
-      return false;
+  };
+  constructor(runtime) {
+    super(runtime);
+    this.config = { ...MemoryService.defaultConfig };
+  }
+  static async start(runtime) {
+    const service = new MemoryService(runtime);
+    await service.initialize(runtime);
+    return service;
+  }
+  async stop() {
+    logger4.info("MemoryService stopped");
+  }
+  async initialize(runtime) {
+    this.runtime = runtime;
+    this.loadConfiguration();
+    await this.ensureEmbeddingDimension();
+    this.longTermMemoryRepo = new LongTermMemoryRepository(runtime, this.embeddingDimension);
+    this.conversationSummaryRepo = new ConversationSummaryRepository(runtime, this.embeddingDimension);
+    logger4.info({ config: this.config }, "MemoryService initialized");
+    if (this.config.enableBM25) {
+      await this.rebuildBM25Index();
     }
-    const config = memoryService.getConfig();
-    if (!config.longTermExtractionEnabled) {
-      logger3.debug("Long-term memory extraction is disabled");
-      return false;
+    this.isInitialized = true;
+  }
+  loadConfiguration() {
+    const threshold = this.runtime.getSetting("MEMORY_CONSOLIDATION_THRESHOLD");
+    if (threshold) {
+      this.config.consolidationThreshold = parseInt(threshold, 10);
     }
-    const currentMessageCount = await runtime.countMemories(message.roomId, false, "messages");
-    const shouldRun = await memoryService.shouldRunExtraction(message.entityId, message.roomId, currentMessageCount);
-    logger3.debug(`Should run extraction: ${shouldRun}`);
-    return shouldRun;
-  },
-  handler: async (runtime, message) => {
-    const memoryService = runtime.getService("memory");
-    if (!memoryService) {
-      logger3.error("MemoryService not found");
-      return;
+    const minConfidence = this.runtime.getSetting("MEMORY_MIN_CONFIDENCE");
+    if (minConfidence) {
+      this.config.minConfidence = parseFloat(minConfidence);
     }
-    const config = memoryService.getConfig();
-    const { entityId, roomId } = message;
+    const enableVector = this.runtime.getSetting("MEMORY_ENABLE_VECTOR_SEARCH");
+    logger4.debug({
+      enableVector,
+      type: typeof enableVector,
+      defaultValue: this.config.enableVectorSearch
+    }, "Loading MEMORY_ENABLE_VECTOR_SEARCH setting");
+    if (enableVector !== undefined && enableVector !== null && enableVector !== "") {
+      this.config.enableVectorSearch = enableVector === "true" || enableVector === true;
+      logger4.info({ enabled: this.config.enableVectorSearch }, "Vector search explicitly configured via environment variable");
+    } else {
+      logger4.info({ enabled: this.config.enableVectorSearch }, "Vector search using default configuration");
+    }
+    const enableBM25 = this.runtime.getSetting("MEMORY_ENABLE_BM25");
+    logger4.debug({
+      enableBM25,
+      type: typeof enableBM25,
+      defaultValue: this.config.enableBM25
+    }, "Loading MEMORY_ENABLE_BM25 setting");
+    if (enableBM25 !== undefined && enableBM25 !== null && enableBM25 !== "") {
+      this.config.enableBM25 = enableBM25 === "true" || enableBM25 === true;
+      logger4.info({ enabled: this.config.enableBM25 }, "BM25 search explicitly configured via environment variable");
+    } else {
+      logger4.info({ enabled: this.config.enableBM25 }, "BM25 search using default configuration");
+    }
+    const retrievalLimit = this.runtime.getSetting("MEMORY_RETRIEVAL_LIMIT");
+    if (retrievalLimit) {
+      this.config.retrievalLimit = parseInt(retrievalLimit, 10);
+    }
+    const tokenBudget = this.runtime.getSetting("MEMORY_TOKEN_BUDGET");
+    if (tokenBudget) {
+      this.config.tokenBudget = parseInt(tokenBudget, 10);
+    }
+    const summaryEnabled = this.runtime.getSetting("MEMORY_SUMMARY_ENABLED");
+    logger4.debug({
+      summaryEnabled,
+      type: typeof summaryEnabled,
+      defaultValue: this.config.summarization?.enabled
+    }, "Loading MEMORY_SUMMARY_ENABLED setting");
+    if (summaryEnabled !== undefined && summaryEnabled !== null && summaryEnabled !== "") {
+      this.config.summarization.enabled = summaryEnabled === "true" || summaryEnabled === true;
+      logger4.info({ enabled: this.config.summarization.enabled }, "Summarization explicitly configured via environment variable");
+    } else {
+      logger4.info({ enabled: this.config.summarization.enabled }, "Summarization using default configuration");
+    }
+    const messagesPerSummary = this.runtime.getSetting("MEMORY_MESSAGES_PER_SUMMARY");
+    if (messagesPerSummary) {
+      this.config.summarization.messagesPerSummary = parseInt(messagesPerSummary, 10);
+    }
+    const summariesPerLevel = this.runtime.getSetting("MEMORY_SUMMARIES_PER_LEVEL");
+    if (summariesPerLevel) {
+      this.config.summarization.summariesPerLevel = parseInt(summariesPerLevel, 10);
+    }
+    const maxDepth = this.runtime.getSetting("MEMORY_SUMMARY_MAX_DEPTH");
+    if (maxDepth) {
+      this.config.summarization.maxDepth = parseInt(maxDepth, 10);
+    }
+    const summaryTokenBudget = this.runtime.getSetting("MEMORY_SUMMARY_TOKEN_BUDGET");
+    if (summaryTokenBudget) {
+      this.config.summarization.summaryTokenBudget = parseInt(summaryTokenBudget, 10);
+    }
+  }
+  async ensureEmbeddingDimension() {
     try {
-      logger3.info(`Extracting long-term memories for entity ${entityId}`);
-      const recentMessages = await runtime.getMemories({
-        tableName: "messages",
-        roomId,
-        count: 20,
-        unique: false
+      const embeddingModel = this.runtime.getModel(ModelType2.TEXT_EMBEDDING);
+      if (!embeddingModel) {
+        logger4.warn("No TEXT_EMBEDDING model registered. Embeddings will not be generated.");
+        return;
+      }
+      const testEmbedding = await this.runtime.useModel(ModelType2.TEXT_EMBEDDING, {
+        text: "test"
       });
-      const formattedMessages = recentMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0)).map((msg) => {
-        const sender = msg.entityId === runtime.agentId ? runtime.character.name : "User";
-        return `${sender}: ${msg.content.text || "[non-text message]"}`;
-      }).join(`
-`);
-      const existingMemories = await memoryService.getLongTermMemories(entityId, undefined, 30);
-      const formattedExisting = existingMemories.length > 0 ? existingMemories.map((m) => `[${m.category}] ${m.content} (confidence: ${m.confidence})`).join(`
-`) : "None yet";
-      const state = await runtime.composeState(message);
-      const prompt = composePromptFromState2({
-        state: {
-          ...state,
-          recentMessages: formattedMessages,
-          existingMemories: formattedExisting
-        },
-        template: extractionTemplate
+      if (!testEmbedding || !Array.isArray(testEmbedding)) {
+        throw new Error("Invalid embedding received from model");
+      }
+      const dimension = testEmbedding.length;
+      const dimensionColumn = MEMORY_DIMENSION_MAP[dimension];
+      if (!dimensionColumn) {
+        throw new Error(`Unsupported embedding dimension: ${dimension}. Supported dimensions: ${Object.keys(MEMORY_DIMENSION_MAP).join(", ")}`);
+      }
+      this.embeddingDimension = dimensionColumn;
+      logger4.info(`Memory embedding dimension set to ${dimension} (${dimensionColumn})`);
+    } catch (error) {
+      logger4.error("Failed to ensure embedding dimension:", JSON.stringify(error));
+      throw error;
+    }
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+    if (updates.enableBM25 !== undefined) {
+      if (updates.enableBM25 && !this.bm25Index) {
+        this.rebuildBM25Index();
+      } else if (!updates.enableBM25) {
+        this.bm25Index = null;
+      }
+    }
+  }
+  async storeLongTermMemory(memory) {
+    let embedding;
+    if (this.embeddingDimension) {
+      try {
+        const rawEmbedding = await generateEmbedding(this.runtime, memory.embeddingContext);
+        embedding = cleanEmbedding(rawEmbedding);
+      } catch (error) {
+        logger4.warn("Failed to generate embedding for long-term memory:", JSON.stringify(error));
+      }
+    }
+    const stored = await this.longTermMemoryRepo.insert(memory, embedding);
+    if (this.config.enableBM25 && this.bm25Index) {
+      await this.rebuildBM25Index();
+    }
+    return stored;
+  }
+  async getLongTermMemory(id) {
+    return this.longTermMemoryRepo.findById(id);
+  }
+  async updateLongTermMemory(id, updates) {
+    let newEmbedding;
+    if (updates.embeddingContext !== undefined && this.embeddingDimension) {
+      try {
+        const rawEmbedding = await generateEmbedding(this.runtime, updates.embeddingContext);
+        newEmbedding = cleanEmbedding(rawEmbedding);
+      } catch (error) {
+        logger4.warn("Failed to regenerate embedding:", JSON.stringify(error));
+      }
+    }
+    await this.longTermMemoryRepo.update(id, updates, newEmbedding);
+  }
+  async deleteLongTermMemory(id) {
+    await this.longTermMemoryRepo.delete(id);
+  }
+  async getLongTermMemories(entityId, type, limit = 20, includeInactive = false) {
+    return this.longTermMemoryRepo.findByEntity(entityId, type, limit, includeInactive);
+  }
+  async handleContradiction(entityId, newMemory) {
+    const searchResults = await this.searchLongTermMemories({
+      entityId,
+      query: newMemory.content,
+      type: newMemory.type,
+      limit: 5,
+      includeInactive: false
+    });
+    if (searchResults.length === 0) {
+      await this.storeLongTermMemory(newMemory);
+      return;
+    }
+    const contradictingMemory = await this.detectContradiction(newMemory, searchResults);
+    if (contradictingMemory) {
+      logger4.info({
+        oldMemoryId: contradictingMemory.id,
+        newContent: newMemory.content
+      }, "Contradiction detected, superseding old memory");
+      await this.updateLongTermMemory(contradictingMemory.id, {
+        isActive: false
       });
-      const response = await runtime.useModel(ModelType2.TEXT_LARGE, {
-        prompt
+      const stored = await this.storeLongTermMemory({
+        ...newMemory,
+        supersedesId: contradictingMemory.id
       });
-      const extractions = parseMemoryExtractionXML(response);
-      logger3.info(`Extracted ${extractions.length} long-term memories`);
-      for (const extraction of extractions) {
-        if (extraction.confidence >= config.longTermConfidenceThreshold) {
-          await memoryService.storeLongTermMemory({
-            agentId: runtime.agentId,
-            entityId,
-            category: extraction.category,
-            content: extraction.content,
-            confidence: extraction.confidence,
-            source: "conversation",
-            metadata: {
-              roomId,
-              extractedAt: new Date().toISOString()
-            }
-          });
-          logger3.info(`Stored long-term memory: [${extraction.category}] ${extraction.content.substring(0, 50)}...`);
-        } else {
-          logger3.debug(`Skipped low-confidence memory: ${extraction.content} (confidence: ${extraction.confidence})`);
+      logger4.info({ newMemoryId: stored.id }, "Stored superseding memory");
+    } else {
+      await this.storeLongTermMemory(newMemory);
+    }
+  }
+  async detectContradiction(newMemory, existingMemories) {
+    const prompt = `# TASK: Contradiction Detection
+
+You are analyzing whether a new long-term memory contradicts any existing long-term memories.
+
+## New Long-Term Memory:
+"${newMemory.content}"
+
+## Existing Long-Term Memories:
+${existingMemories.map((m, idx) => `${idx + 1}. "${m.content}" (confidence: ${m.confidence}, created: ${m.createdAt.toISOString()})`).join(`
+`)}
+
+## Instructions:
+Determine if the new long-term memory directly contradicts any of the existing long-term memories. A contradiction means the statements cannot both be true.
+
+Examples of contradictions:
+- "User likes blue" vs "User hates blue"
+- "User lives in Paris" vs "User lives in London"
+
+Examples of non-contradictions (these are compatible):
+- "User likes blue" vs "User likes blue only for clothes" (nuance, not contradiction)
+- "User was in Paris" vs "User moved to London" (state change over time)
+
+## Output Format:
+Return an XML response:
+
+<response>
+<hasContradiction>true or false</hasContradiction>
+<contradictingMemoryIndex>number or null</contradictingMemoryIndex>
+<reasoning>Explanation</reasoning>
+</response>
+
+If no contradiction is found, set hasContradiction to false and contradictingMemoryIndex to null.`;
+    try {
+      const response = await this.runtime.useModel(ModelType2.TEXT_LARGE, {
+        prompt,
+        temperature: 0.2
+      });
+      const responseText = typeof response === "string" ? response : JSON.stringify(response);
+      const result = parseKeyValueXml(responseText);
+      if (!result) {
+        logger4.warn("Failed to parse contradiction detection XML response");
+        return null;
+      }
+      const hasContradiction = parseBooleanFromText(typeof result.hasContradiction === "boolean" ? result.hasContradiction ? "true" : "false" : result.hasContradiction);
+      let contradictingMemoryIndex = null;
+      if (result.contradictingMemoryIndex !== null && result.contradictingMemoryIndex !== "null") {
+        const parsed = parseInt(result.contradictingMemoryIndex, 10);
+        if (!isNaN(parsed)) {
+          contradictingMemoryIndex = parsed;
         }
       }
-      const currentMessageCount = await runtime.countMemories(roomId, false, "messages");
-      await memoryService.setLastExtractionCheckpoint(entityId, roomId, currentMessageCount);
-      logger3.debug(`Updated extraction checkpoint to ${currentMessageCount} for entity ${entityId} in room ${roomId}`);
+      if (hasContradiction && contradictingMemoryIndex !== null) {
+        const contradictingMemory = existingMemories[contradictingMemoryIndex];
+        logger4.info({ reasoning: result.reasoning }, "Contradiction detected");
+        return contradictingMemory;
+      }
+      return null;
     } catch (error) {
-      logger3.error({ error }, "Error during long-term memory extraction:");
+      logger4.error({ error }, "Failed to detect contradiction");
+      return null;
     }
-  },
-  examples: []
-};
+  }
+  async searchLongTermMemories(params) {
+    const limit = params.limit || this.config.retrievalLimit;
+    const tokenBudget = params.tokenBudget || this.config.tokenBudget;
+    const minConfidence = params.minConfidence !== undefined ? params.minConfidence : this.config.minConfidence;
+    const similarityThreshold = params.similarityThreshold !== undefined ? params.similarityThreshold : 0.3;
+    logger4.debug({
+      limit,
+      tokenBudget,
+      minConfidence,
+      similarityThreshold,
+      vectorSearchEnabled: this.config.enableVectorSearch,
+      bm25Enabled: this.config.enableBM25
+    }, "Searching long-term memories");
+    let vectorResults = [];
+    if (this.config.enableVectorSearch) {
+      logger4.debug("Vector search enabled, searching...");
+      vectorResults = await this.vectorSearch(params, similarityThreshold);
+    }
+    logger4.debug({ vectorResults: vectorResults.length }, "Vector search results");
+    let bm25Results = [];
+    if (this.config.enableBM25) {
+      bm25Results = await this.bm25Search(params);
+    }
+    const mergedResults = mergeSearchResults(vectorResults, bm25Results);
+    const confidenceFiltered = mergedResults.filter((m) => m.confidence >= minConfidence);
+    const decayedResults = applyDecayScoring(confidenceFiltered);
+    const sorted = decayedResults.sort((a, b) => b.finalScore - a.finalScore);
+    const topResults = sorted.slice(0, limit);
+    const budgetedResults = trimToTokenBudget(topResults, tokenBudget, (memory) => memory.content, 15);
+    logger4.debug({
+      totalResults: sorted.length,
+      afterCountLimit: topResults.length,
+      afterTokenBudget: budgetedResults.length,
+      tokenBudget,
+      estimatedTokens: budgetedResults.reduce((sum, m) => sum + estimateTokenCount(m.content) + 15, 0)
+    }, "Applied token budget to memory retrieval");
+    await this.longTermMemoryRepo.updateAccessMetadata(budgetedResults.map((r) => r.id));
+    return budgetedResults;
+  }
+  async vectorSearch(params, similarityThreshold = 0.3) {
+    if (!this.embeddingDimension) {
+      logger4.warn("Embedding dimension not set, skipping vector search");
+      return [];
+    }
+    try {
+      const rawEmbedding = await generateEmbedding(this.runtime, params.query);
+      const queryEmbedding = cleanEmbedding(rawEmbedding);
+      if (!queryEmbedding || !Array.isArray(queryEmbedding)) {
+        logger4.warn("Failed to generate query embedding");
+        return [];
+      }
+      return await this.longTermMemoryRepo.vectorSearch(params, queryEmbedding, similarityThreshold);
+    } catch (error) {
+      logger4.error("Failed to execute vector search:", JSON.stringify(error));
+      return [];
+    }
+  }
+  async bm25Search(params) {
+    if (!this.bm25Index) {
+      return [];
+    }
+    try {
+      const bm25Results = this.bm25Index.search(params.query, params.limit || 20);
+      const memoryPromises = bm25Results.map(async (result) => {
+        const doc = this.bm25Index.documents[result.index];
+        if (!doc || !doc.id) {
+          logger4.warn({ resultIndex: result.index }, "BM25 result has no document ID");
+          return null;
+        }
+        const memory = await this.getLongTermMemory(doc.id);
+        if (!memory)
+          return null;
+        if (memory.entityId !== params.entityId)
+          return null;
+        if (!params.includeInactive && !memory.isActive)
+          return null;
+        if (params.type && memory.type !== params.type)
+          return null;
+        if (params.minConfidence && memory.confidence < params.minConfidence)
+          return null;
+        return {
+          ...memory,
+          relevanceScore: result.score,
+          activationScore: 0,
+          finalScore: 0
+        };
+      });
+      const results = await Promise.all(memoryPromises);
+      return results.filter((r) => r !== null);
+    } catch (error) {
+      logger4.error({ error }, "BM25 search failed");
+      return [];
+    }
+  }
+  async rebuildBM25Index() {
+    try {
+      const memories = await this.longTermMemoryRepo.fetchAllActive();
+      const documents = memories.map((row) => ({
+        id: row.id,
+        content: row.content,
+        embeddingContext: row.embeddingContext
+      }));
+      this.bm25Index = new BM25(documents, {
+        k1: 1.2,
+        b: 0.75,
+        stemming: true,
+        minLength: 2
+      });
+      logger4.info({ documentCount: documents.length }, "Rebuilt BM25 index");
+    } catch (error) {
+      logger4.error({ error }, "Failed to rebuild BM25 index");
+      this.bm25Index = null;
+    }
+  }
+  async getFormattedLongTermMemoriesForContext(entityId, query, roomId) {
+    const memories = await this.searchLongTermMemories({
+      entityId,
+      query,
+      roomId,
+      limit: this.config.retrievalLimit
+    });
+    return formatMemoriesForContext(memories);
+  }
+  async storeSummary(summary) {
+    let embedding;
+    if (this.embeddingDimension) {
+      try {
+        const rawEmbedding = await generateEmbedding(this.runtime, summary.content);
+        embedding = cleanEmbedding(rawEmbedding);
+      } catch (error) {
+        logger4.warn("Failed to generate embedding for summary:", JSON.stringify(error));
+      }
+    }
+    return this.conversationSummaryRepo.insert(summary, embedding);
+  }
+  async getSummariesByLevel(roomId, level) {
+    return this.conversationSummaryRepo.findByLevel(roomId, level);
+  }
+  async searchSummaries(params) {
+    if (!this.embeddingDimension) {
+      logger4.warn("Embedding dimension not set, skipping summary search");
+      return [];
+    }
+    const limit = params.limit || 5;
+    const tokenBudget = params.tokenBudget || this.config.summarization?.summaryTokenBudget || 500;
+    try {
+      const rawEmbedding = await generateEmbedding(this.runtime, params.query);
+      const queryEmbedding = cleanEmbedding(rawEmbedding);
+      if (!queryEmbedding || !Array.isArray(queryEmbedding)) {
+        logger4.warn("Failed to generate query embedding");
+        return [];
+      }
+      const summaries = await this.conversationSummaryRepo.vectorSearch(params.entityId, params.roomId, queryEmbedding, limit);
+      const budgetedSummaries = trimToTokenBudget(summaries, tokenBudget, (s) => s.content, 10);
+      await this.conversationSummaryRepo.updateAccessMetadata(budgetedSummaries.map((s) => s.id));
+      return budgetedSummaries;
+    } catch (error) {
+      logger4.error("Failed to search summaries:", JSON.stringify(error));
+      return [];
+    }
+  }
+  async getMostRecentLevel1Summary(roomId, entityId) {
+    try {
+      const summaries = await this.conversationSummaryRepo.findByLevel(roomId, 1);
+      if (summaries.length === 0) {
+        return null;
+      }
+      const entitySummaries = summaries.filter((s) => s.entityId === entityId).sort((a, b) => b.endTime.getTime() - a.endTime.getTime());
+      return entitySummaries.length > 0 ? entitySummaries[0] : null;
+    } catch (error) {
+      logger4.error("Failed to get most recent Level 1 summary:", JSON.stringify(error));
+      return null;
+    }
+  }
+}
 
-// src/providers/short-term-memory.ts
+// src/evaluators/consolidation.ts
 import {
-  addHeader,
-  ChannelType,
-  formatMessages,
-  formatPosts,
-  getEntityDetails,
-  logger as logger4
+  logger as logger5,
+  ModelType as ModelType3
 } from "@elizaos/core";
-var shortTermMemoryProvider = {
-  name: "SHORT_TERM_MEMORY",
-  description: "Adaptive conversation context with smart summarization",
-  position: 95,
-  get: async (runtime, message, _state) => {
+
+// src/prompts/consolidation.ts
+var CONSOLIDATION_SYSTEM_PROMPT = `You are the "Cortex" — an advanced Memory Extraction Engine.
+Your function is to parse conversation logs and extract persistent facts into a structured database format.
+
+# CORE DIRECTIVE: "Subject-First" Extraction
+You must rephrase memories to focus on the *topic*, not the user. This optimizes vector retrieval.
+- BAD: "User likes to trade Bitcoin." (Too generic)
+- GOOD: "Bitcoin (BTC) is a preferred trading asset." (Topic-focused)
+
+# COMPRESSION RULES (CRITICAL)
+1. **Aggressive Filtering**: Most user chatter is noise. If it won't be relevant in 30 days, DO NOT extract it.
+2. **Merge & Dedupe**: Do not create three separate memories for one topic. Combine them.
+   - *Input:* "I like Red. I also like Blue. And Green."
+   - *Output:* "Red, Blue, and Green are the preferred colors."
+3. **Conflict Resolution**: If a new fact contradicts an old one, mark 'isContradiction' as true.
+
+# OUTPUT FORMAT
+Phase 1: [ANALYSIS]
+- List extracted points.
+- MARK items as [TRANSIENT] (Ignore) or [MERGE] (Combine).
+- Refine the final wording.
+
+Phase 2: [MEMORIES]
+Format: \`MEM|TYPE|CATEGORY|CONFIDENCE|IS_CONTRADICTION|CONTENT\`
+
+Types: EPISODIC, SEMANTIC, PROCEDURAL
+Categories: bio, health, finance, preferences, relationships, skills, work
+`;
+function buildExtractionPrompt(conversationLog) {
+  const refDate = new Date().toISOString();
+  return `# INPUT DATA
+**Reference Date:** ${refDate} (Use this to resolve relative dates like "yesterday" or "next Friday")
+
+<conversation_log>
+${conversationLog}
+</conversation_log>
+
+# FEW-SHOT EXAMPLES (DENSE INPUTS)
+
+<example_1_finance_consolidation>
+Input: "Okay, market is looking bad. I'm closing my ETH long. Too risky. Also, can you check the weather in Tokyo? I might fly there. Actually, cancel all my limit orders on Solana too, I want to go all cash for the weekend."
+Output:
+[ANALYSIS]
+- "Market looking bad" -> Context, not memory.
+- "Closing ETH long" -> Actionable preference change.
+- "Check weather" -> [TRANSIENT] Ignore.
+- "Fly to Tokyo" -> [TRANSIENT] "Might" implies uncertainty. Ignore until confirmed.
+- "Cancel SOL orders" -> Actionable strategy.
+- "Go all cash" -> High-level strategy.
+- MERGE: Combine ETH close, SOL cancel, and Cash strategy into one record.
+[MEMORIES]
+MEM|PROCEDURAL|finance|0.95|true|Portfolio Strategy: All positions (ETH, SOL) liquidated; Cash-only stance adopted for weekend.
+</example_1_finance_consolidation>
+
+<example_2_companion_emotional>
+Input: "I had a huge fight with my sister, Jenny. She's so controlling. I don't want to talk about her anymore. Let's play a game. Maybe chess? Actually no, I hate chess, it's boring. Let's do a quiz."
+Output:
+[ANALYSIS]
+- "Fight with sister Jenny" -> Relationship dynamic.
+- "She's controlling" -> Character attribute.
+- "Don't want to talk about her" -> Boundary/Preference.
+- "Play a game" -> [TRANSIENT] Immediate desire.
+- "Hate chess" -> Negative Preference.
+- "Do a quiz" -> [TRANSIENT] Immediate desire.
+- MERGE: Combine Jenny details. Separate Chess preference.
+[MEMORIES]
+MEM|EPISODIC|relationships|0.9|false|Jenny (sister) is characterized as controlling; currently a sensitive topic to be avoided.
+MEM|SEMANTIC|preferences|0.95|false|Chess is a disliked activity (described as boring).
+</example_2_companion_emotional>
+
+<example_3_coding_stack>
+Input: "This node_modules folder is huge. I'm done with NPM. From now on we only use Bun for all projects. It's faster. Also, help me debug this loop. It's printing 'undefined'."
+Output:
+[ANALYSIS]
+- "node_modules huge" -> Rationale.
+- "Done with NPM" -> Deprecation.
+- "Use Bun" -> New Standard.
+- "Debug this loop" -> [TRANSIENT] Immediate task.
+- MERGE: Bun adoption and NPM rejection.
+[MEMORIES]
+MEM|PROCEDURAL|skills|0.95|true|Bun is the mandated package manager; NPM usage is deprecated/forbidden.
+</example_3_coding_stack>
+
+<example_4_health_routine>
+Input: "I ate a burger today, felt kinda heavy. I think I'm going to start intermittent fasting. 16/8 window. Start eating at 12pm, stop at 8pm. Remind me to drink water."
+Output:
+[ANALYSIS]
+- "Ate a burger" -> [TRANSIENT] One-off meal.
+- "Felt heavy" -> [TRANSIENT] Temporary sensation.
+- "Start intermittent fasting" -> New Health Protocol.
+- "16/8 window, 12-8" -> Specific details of protocol.
+- "Remind me to drink water" -> [TRANSIENT] Command.
+- MERGE: All fasting details into one concise protocol.
+[MEMORIES]
+MEM|PROCEDURAL|health|0.9|false|Intermittent Fasting (16/8 protocol) adopted: Eating window restricted to 12pm-8pm.
+</example_4_health_routine>
+
+<example_5_work_milestones>
+Input: "Meeting went well. The client, Apex Corp, agreed to the $50k budget. But they want the deadline moved to March 1st. Can you write a thank you note? Oh, and I need to update my resume."
+Output:
+[ANALYSIS]
+- "Meeting went well" -> [TRANSIENT] Sentiment.
+- "Apex Corp" -> Client Entity.
+- "$50k budget" -> Financial Fact.
+- "Deadline March 1st" -> Project Constraint.
+- "Write note" -> [TRANSIENT] Task.
+- "Update resume" -> [TRANSIENT] Generic task unless specific details given.
+- MERGE: Client details, budget, and deadline.
+[MEMORIES]
+MEM|SEMANTIC|work|1.0|false|Apex Corp project secured: $50k budget with March 1st deadline.
+</example_5_work_milestones>
+
+# EXTRACTION CHECKLIST
+1. **Search for STATE CHANGES**: Did the user move, change jobs, break up, or alter a portfolio? These are high-value.
+2. **Search for HARD CONSTRAINTS**: Look for phrases like "Never do X", "Always use Y", "I hate Z".
+3. **COMPRESSION**:
+   - You have received a long conversation.
+   - **MERGE** related details into single, dense records.
+   - **IGNORE** all small talk, greetings, and transient requests.
+4. **QUALITY CONTROL**: If a fact feels temporary or weak, **DO NOT** extract it. Silence is better than noise.
+
+Begin the [ANALYSIS] phase now.`;
+}
+function buildContradictionPrompt(newMemoryContent, existingMemories) {
+  return `Does this new memory contradict any existing memories?
+
+New: "${newMemoryContent}"
+
+Existing:
+${existingMemories.map((m, idx) => `${idx + 1}. "${m.content}" (confidence: ${m.confidence})`).join(`
+`)}
+
+A contradiction means both statements cannot be true simultaneously.
+
+TRUE contradictions:
+- "User likes blue" vs "User hates blue"
+- "User lives in Paris" vs "User lives in London"
+- "User is vegetarian" vs "User eats meat"
+
+NOT contradictions:
+- "User likes blue" vs "User likes blue for clothes" (nuance)
+- "User was in Paris" vs "User moved to London" (time change)
+- "User likes Python" vs "User likes JavaScript" (not exclusive)
+
+<response>
+<hasContradiction>true or false</hasContradiction>
+<contradictingIndex>number or null</contradictingIndex>
+<reasoning>Brief explanation</reasoning>
+</response>`;
+}
+
+// src/evaluators/consolidation.ts
+var consolidationBuffers = new Map;
+var consolidationEvaluator = {
+  name: "CONSOLIDATION",
+  similes: ["MEMORY_CONSOLIDATION", "EXTRACT_FACTS", "MEMORY_BUFFER"],
+  description: "Buffers conversation messages and performs periodic consolidation to extract persistent facts " + "using LLM analysis. Distinguishes transient intents from long-term knowledge.",
+  validate: async (runtime, message) => {
+    if (!consolidationBuffers.has(message.roomId)) {
+      consolidationBuffers.set(message.roomId, []);
+    }
+    consolidationBuffers.get(message.roomId).push(message);
+    const memoryService = runtime.getService("memory");
+    if (!memoryService) {
+      return false;
+    }
+    const config = memoryService.getConfig();
+    const bufferSize = consolidationBuffers.get(message.roomId).length;
+    const shouldConsolidate = bufferSize >= config.consolidationThreshold;
+    if (shouldConsolidate) {
+      logger5.info({
+        roomId: message.roomId,
+        bufferSize,
+        threshold: config.consolidationThreshold
+      }, "Consolidation threshold reached");
+    }
+    return shouldConsolidate;
+  },
+  handler: async (runtime, message) => {
+    const roomId = message.roomId;
     try {
       const memoryService = runtime.getService("memory");
       if (!memoryService) {
-        return {
-          data: { summaries: [], recentMessages: [], mode: "disabled" },
-          values: {},
-          text: ""
-        };
+        logger5.warn("Memory service not available for consolidation");
+        return;
       }
-      const { roomId } = message;
-      const config = memoryService.getConfig();
-      const totalMessageCount = await runtime.countMemories(roomId, false, "messages");
-      if (totalMessageCount < config.shortTermSummarizationThreshold) {
-        const conversationLength = runtime.getConversationLength();
-        const [entitiesData, room, recentMessagesData] = await Promise.all([
-          getEntityDetails({ runtime, roomId }),
-          runtime.getRoom(roomId),
-          runtime.getMemories({
-            tableName: "messages",
-            roomId,
-            count: conversationLength,
-            unique: false
-          })
-        ]);
-        const actionResultMessages = recentMessagesData.filter((msg) => msg.content?.type === "action_result" && msg.metadata?.type === "action_result");
-        const dialogueMessages = recentMessagesData.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result"));
-        const isPostFormat = room?.type ? room.type === ChannelType.FEED || room.type === ChannelType.THREAD : false;
-        const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
-          formatMessages({
-            messages: dialogueMessages,
-            entities: entitiesData
-          }),
-          formatPosts({
-            messages: dialogueMessages,
-            entities: entitiesData,
-            conversationHeader: false
-          })
-        ]);
-        let actionResultsText = "";
-        if (actionResultMessages.length > 0) {
-          const groupedByRun = new Map;
-          for (const mem of actionResultMessages) {
-            const runId = String(mem.content?.runId || "unknown");
-            if (!groupedByRun.has(runId)) {
-              groupedByRun.set(runId, []);
-            }
-            groupedByRun.get(runId)?.push(mem);
-          }
-          const formattedActionResults = Array.from(groupedByRun.entries()).slice(-3).map(([runId, memories]) => {
-            const sortedMemories = memories.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
-            const thought = sortedMemories[0]?.content?.planThought || "";
-            const runText = sortedMemories.map((mem) => {
-              const actionName = mem.content?.actionName || "Unknown";
-              const status = mem.content?.actionStatus || "unknown";
-              const planStep = mem.content?.planStep || "";
-              const text5 = mem.content?.text || "";
-              const error = mem.content?.error || "";
-              let memText = `  - ${actionName} (${status})`;
-              if (planStep)
-                memText += ` [${planStep}]`;
-              if (error) {
-                memText += `: Error - ${error}`;
-              } else if (text5 && text5 !== `Executed action: ${actionName}`) {
-                memText += `: ${text5}`;
-              }
-              return memText;
-            }).join(`
+      const buffer = consolidationBuffers.get(roomId) || [];
+      if (buffer.length === 0) {
+        return;
+      }
+      logger5.info({ roomId, messageCount: buffer.length }, "Starting memory consolidation");
+      const conversationLog = buffer.map((m, idx) => {
+        const content = typeof m.content === "string" ? m.content : m.content.text || JSON.stringify(m.content);
+        return `[${idx + 1}] ${m.entityId}: ${content}`;
+      }).join(`
 `);
-            return `**Action Run ${runId.slice(0, 8)}**${thought ? ` - "${thought}"` : ""}
-${runText}`;
-          }).join(`
-
+      const extractionPrompt = buildExtractionPrompt(conversationLog);
+      const originalSystemPrompt = runtime.character.system;
+      try {
+        runtime.character.system = CONSOLIDATION_SYSTEM_PROMPT;
+        logger5.debug("Calling LLM for memory extraction");
+        const response = await runtime.useModel(ModelType3.TEXT_LARGE, {
+          prompt: extractionPrompt,
+          temperature: 0.3
+        });
+        const consolidationResult = parseConsolidationResult(response);
+        logger5.debug({
+          reasoning: consolidationResult.reasoningTrace,
+          extracted: consolidationResult.extractedMemories.length
+        }, "Extraction complete");
+        const config = memoryService.getConfig();
+        const validMemories = consolidationResult.extractedMemories.filter((m) => m.confidence >= config.minConfidence);
+        logger5.info({
+          total: consolidationResult.extractedMemories.length,
+          valid: validMemories.length,
+          minConfidence: config.minConfidence
+        }, "Filtered extracted memories");
+        for (const extracted of validMemories) {
+          await storeExtractedMemory(runtime, memoryService, roomId, buffer, extracted);
+        }
+        consolidationBuffers.set(roomId, []);
+        logger5.info({ roomId, stored: validMemories.length }, "Memory consolidation complete");
+      } finally {
+        runtime.character.system = originalSystemPrompt;
+      }
+    } catch (error) {
+      logger5.error({ error, roomId }, "Consolidation evaluator failed");
+    }
+  },
+  examples: []
+};
+function parseConsolidationResult(response) {
+  try {
+    const responseText = typeof response === "string" ? response : JSON.stringify(response);
+    const analysisMatch = responseText.match(/\[ANALYSIS\](.*?)(?:\[MEMORIES\]|$)/s);
+    const reasoningTrace = analysisMatch ? analysisMatch[1].trim() : "";
+    const memoriesMatch = responseText.match(/\[MEMORIES\](.*?)$/s);
+    const memoriesText = memoriesMatch ? memoriesMatch[1].trim() : "";
+    const extractedMemories = [];
+    if (memoriesText) {
+      const lines = memoriesText.split(`
 `);
-          actionResultsText = formattedActionResults ? addHeader("# Recent Action Executions", formattedActionResults) : "";
+      for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || !trimmedLine.startsWith("MEM|")) {
+          continue;
         }
-        const recentPosts = formattedRecentPosts && formattedRecentPosts.length > 0 ? addHeader("# Posts in Thread", formattedRecentPosts) : "";
-        const recentMessages = formattedRecentMessages && formattedRecentMessages.length > 0 ? addHeader("# Conversation Messages", formattedRecentMessages) : "";
-        if (!recentPosts && !recentMessages && dialogueMessages.length === 0 && !message.content.text) {
-          return {
-            data: {
-              summaries: [],
-              recentMessages: [],
-              actionResults: [],
-              mode: "full_conversation"
-            },
-            values: {
-              recentMessage: "No recent message available."
-            },
-            text: "No recent messages available"
-          };
+        const parts = trimmedLine.split("|");
+        if (parts.length < 6) {
+          logger5.warn({ line: trimmedLine }, "Skipping malformed memory line (insufficient fields)");
+          continue;
         }
-        let recentMessage = "No recent message available.";
-        if (dialogueMessages.length > 0) {
-          const mostRecentMessage = [...dialogueMessages].sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0))[0];
-          const formattedSingleMessage = formatMessages({
-            messages: [mostRecentMessage],
-            entities: entitiesData
-          });
-          if (formattedSingleMessage) {
-            recentMessage = formattedSingleMessage;
-          }
+        const type = parts[1].trim();
+        const category = parts[2].trim();
+        const confidenceStr = parts[3].trim();
+        const isContradictionStr = parts[4].trim();
+        const content = parts.slice(5).join("|").trim();
+        if (!["EPISODIC", "SEMANTIC", "PROCEDURAL"].includes(type)) {
+          logger5.warn({ type, line: trimmedLine }, "Invalid memory type");
+          continue;
         }
-        const metaData = message.metadata;
-        const senderName = entitiesData.find((entity) => entity.id === message.entityId)?.names[0] || metaData?.entityName || "Unknown User";
-        const receivedMessageContent = message.content.text;
-        const hasReceivedMessage = !!receivedMessageContent?.trim();
-        const receivedMessageHeader = hasReceivedMessage ? addHeader("# Received Message", `${senderName}: ${receivedMessageContent}`) : "";
-        const focusHeader = hasReceivedMessage ? addHeader("# Focus your response", `You are replying to the above message from **${senderName}**. Keep your answer relevant to that message. Do not repeat earlier replies unless the sender asks again.`) : "";
-        const text4 = [
-          isPostFormat ? recentPosts : recentMessages,
-          actionResultsText,
-          recentMessages || recentPosts || message.content.text ? receivedMessageHeader : "",
-          recentMessages || recentPosts || message.content.text ? focusHeader : ""
-        ].filter(Boolean).join(`
-
-`);
-        return {
-          data: {
-            summaries: [],
-            recentMessages: dialogueMessages,
-            actionResults: actionResultMessages,
-            mode: "full_conversation"
-          },
-          values: {
-            ...(isPostFormat ? recentPosts : recentMessages) && {
-              recentMessages: isPostFormat ? recentPosts : recentMessages
-            },
-            ...recentPosts && { recentPosts },
-            ...actionResultsText && { recentActionResults: actionResultsText },
-            ...recentMessage && { recentMessage },
-            ...receivedMessageHeader && { receivedMessageHeader },
-            ...focusHeader && { focusHeader }
-          },
-          text: text4
+        if (!category) {
+          logger5.warn({ line: trimmedLine }, "Missing category");
+          continue;
+        }
+        const confidence = parseFloat(confidenceStr);
+        if (isNaN(confidence) || confidence < 0 || confidence > 1) {
+          logger5.warn({ confidenceStr, line: trimmedLine }, "Invalid confidence value");
+          continue;
+        }
+        const isContradiction = isContradictionStr.toLowerCase() === "true";
+        if (!content) {
+          logger5.warn({ line: trimmedLine }, "Missing content");
+          continue;
+        }
+        const metadata = {
+          category
         };
-      } else {
-        const currentSummary = await memoryService.getCurrentSessionSummary(roomId);
-        const lastOffset = currentSummary?.lastMessageOffset || 0;
-        const unsummarizedMessages = await runtime.getMemories({
-          tableName: "messages",
-          roomId,
-          count: config.shortTermRetainRecent,
-          unique: false,
-          start: lastOffset
+        extractedMemories.push({
+          type,
+          content,
+          confidence,
+          isContradiction,
+          metadata
         });
-        const entitiesData = await getEntityDetails({ runtime, roomId });
-        const room = await runtime.getRoom(roomId);
-        const isPostFormat = room?.type ? room.type === ChannelType.FEED || room.type === ChannelType.THREAD : false;
-        let recentMessagesText = "";
-        if (unsummarizedMessages.length > 0) {
-          const dialogueMessages = unsummarizedMessages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result"));
-          if (isPostFormat) {
-            recentMessagesText = formatPosts({
-              messages: dialogueMessages,
-              entities: entitiesData,
-              conversationHeader: false
-            });
-          } else {
-            recentMessagesText = formatMessages({
-              messages: dialogueMessages,
-              entities: entitiesData
-            });
-          }
-          if (recentMessagesText) {
-            recentMessagesText = addHeader("# Recent Messages", recentMessagesText);
-          }
-        }
-        let summaryText = "";
-        if (currentSummary) {
-          const messageRange = `${currentSummary.messageCount} messages`;
-          const timeRange = new Date(currentSummary.startTime).toLocaleDateString();
-          summaryText = `**Previous Conversation** (${messageRange}, ${timeRange})
+      }
+    }
+    return {
+      reasoningTrace,
+      transientSummary: "",
+      extractedMemories
+    };
+  } catch (error) {
+    logger5.error({ error }, "Failed to parse consolidation response");
+    return {
+      reasoningTrace: "Parse error",
+      transientSummary: "",
+      extractedMemories: []
+    };
+  }
+}
+async function storeExtractedMemory(runtime, memoryService, roomId, buffer, extracted) {
+  const entityId = buffer[0]?.entityId || runtime.agentId;
+  const embeddingContext = generateContextualString(extracted);
+  const config = memoryService.getConfig();
+  const decayRate = config.defaultDecayRates[extracted.type];
+  const memoryData = {
+    agentId: runtime.agentId,
+    entityId,
+    roomId,
+    type: extracted.type,
+    content: extracted.content,
+    embeddingContext,
+    confidence: extracted.confidence,
+    decayRate,
+    decayFunction: "EXPONENTIAL" /* EXPONENTIAL */,
+    source: {
+      sessionId: roomId,
+      messageId: extracted.sourceMessageId,
+      textSnippet: extracted.content.substring(0, 200)
+    },
+    metadata: extracted.metadata || {}
+  };
+  if (config.enableContradictionDetection && extracted.isContradiction) {
+    await memoryService.handleContradiction(entityId, memoryData);
+  } else {
+    await memoryService.storeLongTermMemory(memoryData);
+  }
+}
+function generateContextualString(extracted) {
+  const typeLabel = {
+    ["EPISODIC" /* EPISODIC */]: "Event",
+    ["SEMANTIC" /* SEMANTIC */]: "Fact",
+    ["PROCEDURAL" /* PROCEDURAL */]: "Skill"
+  }[extracted.type];
+  const category = extracted.metadata?.category || "general";
+  return `[${typeLabel} about ${category}]: ${extracted.content}`;
+}
+
+// src/evaluators/summarization.ts
+import {
+  logger as logger6,
+  ModelType as ModelType4
+} from "@elizaos/core";
+
+// src/prompts/summarization.ts
+var SUMMARIZATION_SYSTEM_PROMPT = `You are "Chronos", a master summarizer.
+Your function is to condense conversation logs into concise, subject-first narrative summaries.
+
+# CORE DIRECTIVE: "Subject-First" Summarization
+You must rephrase the narrative to focus on the *topic*, not the user. This optimizes vector retrieval.
+- BAD: "User asked about Python." (Too generic)
+- GOOD: "Python programming inquiries were addressed." (Topic-focused)
+
+# COMPRESSION RULES
+1. **Be Concise**: Target 2-4 sentences. Maximum 100 words.
+2. **Be Factual**: No interpretation, no speculation. Only what actually happened.
+3. **Be Narrative**: Write as a story, not a bullet list.
+4. **Preserve Key Facts**: If the user revealed important information (preferences, identity, needs), include it.
+5. **Exclude Trivia**: Skip greetings, acknowledgments, and filler conversation.
+
+# OUTPUT FORMAT
+Phase 1: [ANALYSIS]
+- Identify key topics.
+- Draft the summary.
+- Refine wording to be subject-first.
+
+Phase 2: [RESULT]
+Format: \`SUMM|TAGS|CONTENT\`
+- TAGS: Comma-separated list of key topics (lowercase)
+- CONTENT: The narrative summary text (must be a single line, no newlines)
+`;
+function buildLevel1SummaryPrompt(formattedMessages, previousSummary) {
+  const previousContext = previousSummary ? `
+# PREVIOUS SUMMARY
+<previous_summary>
+${previousSummary}
+</previous_summary>
+
+**Note**: The above is what was discussed before. Ensure your new summary:
+- Does not duplicate information already captured in the previous summary
+- Focuses only on the NEW conversation below
+- Maintains continuity (e.g., "Conversation continued with...")
+` : "";
+  return `${previousContext}
+# INPUT DATA
+<messages>
+${formattedMessages}
+</messages>
+
+# FEW-SHOT EXAMPLES
+
+<example_1_task_oriented>
+Input:
+[Message 1] User: I need help deploying my React app to Vercel
+[Message 2] Agent: Sure! First, make sure you have the Vercel CLI installed...
+[Message 3] User: Done. What's next?
+[Message 4] Agent: Run 'vercel' in your project directory...
+[Message 5] User: It worked! Thanks!
+
+Output:
+[ANALYSIS]
+- Topic: React app deployment to Vercel.
+- Action: CLI installation and deployment.
+- Outcome: Success.
+- Draft: User requested help... -> React app deployment...
+[RESULT]
+SUMM|deployment,react,vercel,cli|React app deployment to Vercel was successfully completed following CLI installation and configuration guidance.
+</example_1_task_oriented>
+
+<example_2_identity_revelation>
+Input:
+[Message 1] User: I'm working on a side project in my spare time
+[Message 2] Agent: That's great! What kind of project?
+[Message 3] User: A machine learning app for analyzing stock data. I'm a data scientist by profession.
+[Message 4] Agent: Interesting! Are you using Python?
+[Message 5] User: Yeah, mostly PyTorch and pandas.
+
+Output:
+[ANALYSIS]
+- Identity: Data scientist.
+- Project: Stock data analysis (ML).
+- Tech Stack: Python, PyTorch, pandas.
+- Draft: User discussed... -> Stock data analysis project...
+[RESULT]
+SUMM|machine learning,data science,python,stocks|Stock data analysis project (Machine Learning) utilizing Python (PyTorch, pandas) is in development by a data scientist.
+</example_2_identity_revelation>
+
+<example_3_chitchat>
+Input:
+[Message 1] User: Hey, how's it going?
+[Message 2] Agent: I'm doing well, thanks for asking! How can I help you today?
+[Message 3] User: Just saying hi
+[Message 4] Agent: Nice to hear from you!
+
+Output:
+[ANALYSIS]
+- Content: Greetings only.
+- Substance: None.
+[RESULT]
+SUMM|greeting,casual|Casual greeting exchanged; no substantive topics discussed.
+</example_3_chitchat>
+
+Begin the [ANALYSIS] phase now.`;
+}
+var HIGHER_LEVEL_SUMMARIZATION_SYSTEM_PROMPT = `You are "Chronos", a Meta-Summarization Agent.
+Your task is to compress multiple conversation summaries into a single, higher-level summary.
+
+# MISSION
+Transform a list of conversation summaries into one concise meta-summary that captures:
+1. **Overarching themes** across the summaries
+2. **Key events or milestones** (e.g., "User onboarded", "Project completed")
+3. **Evolving context** (e.g., "User's preferences shifted from X to Y")
+
+# RULES
+- **Subject-First**: Focus on the topic, not the user.
+- **Abstract Higher**: Don't repeat specifics from each summary. Find the pattern.
+- **Chronological Flow**: Maintain temporal order if it matters.
+- **Preserve Critical Facts**: If summaries mention important identity or preferences, keep them.
+
+# OUTPUT FORMAT
+Phase 1: [ANALYSIS]
+- Identify themes and milestones.
+- Combine related points.
+- Refine to subject-first.
+
+Phase 2: [RESULT]
+Format: \`SUMM|TAGS|CONTENT\`
+- TAGS: Comma-separated list of key topics (lowercase)
+- CONTENT: The meta-summary text (must be a single line, no newlines)
 `;
-          summaryText += currentSummary.summary;
-          if (currentSummary.topics && currentSummary.topics.length > 0) {
-            summaryText += `
-*Topics: ${currentSummary.topics.join(", ")}*`;
+function buildHigherLevelSummaryPrompt(formattedSummaries) {
+  return `# INPUT DATA
+<summaries>
+${formattedSummaries}
+</summaries>
+
+# FEW-SHOT EXAMPLES
+
+<example_1_meta_summary>
+Input:
+<summary1>Stock data analysis project (Machine Learning) utilizing Python (PyTorch, pandas) is in development by a data scientist.</summary1>
+<summary2>Flask and Vercel were suggested for ML model deployment to a web app.</summary2>
+<summary3>CORS configuration issues were resolved, leading to successful deployment.</summary3>
+
+Output:
+[ANALYSIS]
+- Theme: ML App Development & Deployment.
+- Flow: Development -> Stack Choice -> Deployment -> Troubleshooting -> Success.
+- Draft: User, a data scientist... -> Machine learning stock analysis app...
+[RESULT]
+SUMM|data science,machine learning,python,deployment,flask,vercel|Machine learning stock analysis app (Python/PyTorch) was developed and successfully deployed to Vercel using Flask after resolving CORS configuration issues.
+</example_1_meta_summary>
+
+Begin the [ANALYSIS] phase now.`;
+}
+function estimateTokensInSummary(text3) {
+  return Math.ceil(text3.length / 4);
+}
+
+// src/evaluators/summarization.ts
+var summarizationCounters = new Map;
+var summarizationEvaluator = {
+  name: "SUMMARIZATION",
+  similes: ["HIERARCHICAL_SUMMARIZATION", "EPISODIC_COMPRESSION", "CONVERSATION_SUMMARY"],
+  description: "Hierarchical conversation summarization that compresses message history into multi-level narrative summaries " + "for token-efficient long-term episodic memory.",
+  validate: async (runtime, message) => {
+    const memoryService = runtime.getService("memory");
+    if (!memoryService) {
+      return false;
+    }
+    const config = memoryService.getConfig();
+    if (!config.summarization?.enabled) {
+      logger6.debug("Summarization is not enabled");
+      return false;
+    }
+    if (!summarizationCounters.has(message.roomId)) {
+      summarizationCounters.set(message.roomId, 0);
+    }
+    const currentCount = summarizationCounters.get(message.roomId) + 1;
+    summarizationCounters.set(message.roomId, currentCount);
+    const threshold = config.summarization.messagesPerSummary;
+    logger6.debug({
+      currentCount,
+      threshold,
+      messageId: message.id,
+      entityId: message.entityId,
+      roomId: message.roomId
+    }, "Message counted for summarization (user + agent messages)");
+    const shouldSummarize = currentCount >= threshold;
+    if (shouldSummarize) {
+      logger6.info({
+        roomId: message.roomId,
+        messageCount: currentCount,
+        threshold
+      }, "Summarization threshold reached (Level 1) - triggering summarization");
+    }
+    return shouldSummarize;
+  },
+  handler: async (runtime, message) => {
+    const memoryService = runtime.getService("memory");
+    if (!memoryService) {
+      logger6.warn("MemoryService not available for summarization");
+      return;
+    }
+    const config = memoryService.getConfig();
+    if (!config.summarization?.enabled) {
+      return;
+    }
+    const messageCount = summarizationCounters.get(message.roomId) || 0;
+    if (messageCount === 0) {
+      return;
+    }
+    logger6.info({
+      roomId: message.roomId,
+      messageCount
+    }, "Starting Level 1 summarization - pulling messages from database");
+    try {
+      const previousSummary = await memoryService.getMostRecentLevel1Summary(message.roomId, message.entityId);
+      const messages = await fetchMessagesSinceLastSummary(runtime, message.roomId, previousSummary?.endTime);
+      if (messages.length === 0) {
+        logger6.warn({ roomId: message.roomId }, "No messages found for summarization");
+        return;
+      }
+      const summary = await createLevel1Summary(runtime, memoryService, messages, message.roomId, previousSummary);
+      if (summary) {
+        logger6.info({
+          summaryId: summary.id,
+          tokenCount: summary.tokenCount,
+          messageCount: messages.length,
+          startTime: summary.startTime,
+          endTime: summary.endTime
+        }, "Created Level 1 summary from database messages");
+        summarizationCounters.set(message.roomId, 0);
+        await checkAndTriggerHigherLevelSummarization(runtime, memoryService, summary.roomId, summary.level);
+      }
+    } catch (error) {
+      logger6.error({
+        error,
+        roomId: message.roomId
+      }, "Failed to create summary");
+    }
+  },
+  examples: []
+};
+async function fetchMessagesSinceLastSummary(runtime, roomId, lastSummaryEndTime) {
+  const allMessages = await runtime.getMemories({
+    tableName: "messages",
+    roomId,
+    count: 1000,
+    unique: false
+  });
+  const dialogueMessages = allMessages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result"));
+  let messages = dialogueMessages;
+  if (lastSummaryEndTime) {
+    messages = dialogueMessages.filter((msg) => {
+      if (!msg.createdAt)
+        return false;
+      const msgTime = new Date(msg.createdAt);
+      return msgTime > lastSummaryEndTime;
+    });
+  }
+  messages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
+  logger6.debug({
+    roomId,
+    totalMessages: allMessages.length,
+    dialogueMessages: dialogueMessages.length,
+    filteredMessages: messages.length,
+    lastSummaryEndTime: lastSummaryEndTime?.toISOString()
+  }, "Fetched messages for summarization");
+  return messages;
+}
+function parseSummarizationResult(response) {
+  try {
+    const responseText = typeof response === "string" ? response : JSON.stringify(response);
+    const analysisMatch = responseText.match(/\[ANALYSIS\](.*?)(?:\[RESULT\]|$)/s);
+    const reasoningTrace = analysisMatch ? analysisMatch[1].trim() : "";
+    const resultMatch = responseText.match(/\[RESULT\](.*?)$/s);
+    const resultText = resultMatch ? resultMatch[1].trim() : "";
+    let summary = "";
+    let keyTopics = "";
+    if (resultText) {
+      const lines = resultText.split(`
+`);
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("SUMM|")) {
+          const parts = trimmed.split("|");
+          if (parts.length >= 3) {
+            keyTopics = parts[1].trim();
+            summary = parts.slice(2).join("|").trim();
+            break;
           }
-          summaryText = addHeader("# Conversation Summary", summaryText);
         }
-        const metaData = message.metadata;
-        const senderName = entitiesData.find((entity) => entity.id === message.entityId)?.names[0] || metaData?.entityName || "Unknown User";
-        const receivedMessageContent = message.content.text;
-        const hasReceivedMessage = !!receivedMessageContent?.trim();
-        const receivedMessageHeader = hasReceivedMessage ? addHeader("# Received Message", `${senderName}: ${receivedMessageContent}`) : "";
-        const focusHeader = hasReceivedMessage ? addHeader("# Focus your response", `You are replying to the above message from **${senderName}**. Keep your answer relevant to that message.`) : "";
-        const text4 = [
-          summaryText,
-          recentMessagesText,
-          hasReceivedMessage ? receivedMessageHeader : "",
-          hasReceivedMessage ? focusHeader : ""
-        ].filter(Boolean).join(`
-
+      }
+    }
+    return { summary, keyTopics, reasoningTrace };
+  } catch (error) {
+    logger6.error({ error }, "Failed to parse summarization response");
+    return { summary: "", keyTopics: "", reasoningTrace: "" };
+  }
+}
+async function createLevel1Summary(runtime, memoryService, messages, roomId, previousSummary) {
+  const formattedMessages = messages.map((m, i) => {
+    const text3 = typeof m.content === "string" ? m.content : m.content.text || "";
+    const author = m.entityId === runtime.agentId ? "Agent" : "User";
+    const timestamp3 = m.createdAt ? new Date(m.createdAt).toISOString() : "Unknown time";
+    return `[${timestamp3}] ${author}: ${text3}`;
+  }).join(`
 `);
-        return {
-          data: {
-            summaries: currentSummary ? [currentSummary] : [],
-            recentMessages: unsummarizedMessages,
-            mode: "summarized"
-          },
-          values: {
-            ...summaryText && { sessionSummaries: summaryText },
-            ...recentMessagesText && { recentMessages: recentMessagesText },
-            ...receivedMessageHeader && { receivedMessageHeader },
-            ...focusHeader && { focusHeader }
-          },
-          text: text4
-        };
+  let prompt;
+  if (previousSummary) {
+    prompt = buildLevel1SummaryPrompt(formattedMessages, previousSummary.content);
+  } else {
+    prompt = buildLevel1SummaryPrompt(formattedMessages);
+  }
+  const originalSystemPrompt = runtime.character.system;
+  try {
+    runtime.character.system = SUMMARIZATION_SYSTEM_PROMPT;
+    logger6.debug("Calling LLM for Level 1 summarization with timestamped conversation log");
+    const response = await runtime.useModel(ModelType4.TEXT_LARGE, {
+      prompt,
+      temperature: 0.3
+    });
+    runtime.character.system = originalSystemPrompt;
+    const { summary, keyTopics, reasoningTrace } = parseSummarizationResult(response);
+    if (!summary) {
+      logger6.warn({ reasoningTrace }, "No summary extracted from LLM response");
+      return null;
+    }
+    const tokenCount = estimateTokensInSummary(summary);
+    const startTime = messages[0].createdAt ? new Date(messages[0].createdAt) : new Date;
+    const endTime = messages[messages.length - 1].createdAt ? new Date(messages[messages.length - 1].createdAt) : new Date;
+    const summaryData = {
+      agentId: runtime.agentId,
+      entityId: messages[0].entityId,
+      roomId,
+      level: 1,
+      parentSummaryId: undefined,
+      content: summary,
+      tokenCount,
+      startTime,
+      endTime,
+      sourceCount: messages.length,
+      sourceIds: messages.map((m) => m.id),
+      metadata: {
+        keyTopics,
+        hasPreviousSummary: !!previousSummary
       }
-    } catch (error) {
-      logger4.error({ error }, "Error in shortTermMemoryProvider:");
-      return {
-        data: { summaries: [], recentMessages: [], mode: "error" },
-        values: {},
-        text: "Error retrieving conversation context."
-      };
+    };
+    return await memoryService.storeSummary(summaryData);
+  } catch (error) {
+    logger6.error({ error }, "Failed to call LLM for Level 1 summarization");
+    runtime.character.system = originalSystemPrompt;
+    return null;
+  }
+}
+async function checkAndTriggerHigherLevelSummarization(runtime, memoryService, roomId, currentLevel) {
+  const config = memoryService.getConfig();
+  if (!config.summarization) {
+    return;
+  }
+  if (currentLevel >= config.summarization.maxDepth) {
+    logger6.debug({ currentLevel, maxDepth: config.summarization.maxDepth }, "Max depth reached");
+    return;
+  }
+  const summaries = await memoryService.getSummariesByLevel(roomId, currentLevel);
+  const threshold = config.summarization.summariesPerLevel;
+  if (summaries.length < threshold) {
+    return;
+  }
+  logger6.info({
+    level: currentLevel,
+    count: summaries.length,
+    nextLevel: currentLevel + 1
+  }, `Triggering Level ${currentLevel + 1} summarization`);
+  const higherSummary = await createHigherLevelSummary(runtime, memoryService, summaries, roomId, currentLevel + 1);
+  if (higherSummary) {
+    await checkAndTriggerHigherLevelSummarization(runtime, memoryService, roomId, currentLevel + 1);
+  }
+}
+async function createHigherLevelSummary(runtime, memoryService, lowerSummaries, roomId, level) {
+  const formattedSummaries = lowerSummaries.map((s, i) => `<summary${i + 1}>${s.content}</summary${i + 1}>`).join(`
+`);
+  const prompt = buildHigherLevelSummaryPrompt(formattedSummaries);
+  const originalSystemPrompt = runtime.character.system;
+  try {
+    runtime.character.system = HIGHER_LEVEL_SUMMARIZATION_SYSTEM_PROMPT;
+    const response = await runtime.useModel(ModelType4.TEXT_LARGE, {
+      prompt,
+      temperature: 0.3
+    });
+    runtime.character.system = originalSystemPrompt;
+    const { summary, keyTopics, reasoningTrace } = parseSummarizationResult(response);
+    if (!summary) {
+      logger6.warn({ reasoningTrace }, "No higher-level summary extracted from LLM response");
+      return null;
     }
+    const tokenCount = estimateTokensInSummary(summary);
+    const startTime = new Date(Math.min(...lowerSummaries.map((s) => s.startTime.getTime())));
+    const endTime = new Date(Math.max(...lowerSummaries.map((s) => s.endTime.getTime())));
+    const summaryData = {
+      agentId: runtime.agentId,
+      entityId: lowerSummaries[0].entityId,
+      roomId,
+      level,
+      parentSummaryId: undefined,
+      content: summary,
+      tokenCount,
+      startTime,
+      endTime,
+      sourceCount: lowerSummaries.length,
+      sourceIds: lowerSummaries.map((s) => s.id),
+      metadata: {
+        keyTopics,
+        compressedSummaries: lowerSummaries.length
+      }
+    };
+    return await memoryService.storeSummary(summaryData);
+  } catch (error) {
+    logger6.error({ error, level }, "Failed to create higher-level summary");
+    runtime.character.system = originalSystemPrompt;
+    return null;
   }
-};
+}
 
 // src/providers/long-term-memory.ts
 import {
-  logger as logger5,
-  addHeader as addHeader2
+  logger as logger7,
+  addHeader
 } from "@elizaos/core";
 var longTermMemoryProvider = {
   name: "LONG_TERM_MEMORY",
-  description: "Persistent facts and preferences about the user",
-  position: 50,
-  get: async (runtime, message, _state) => {
+  description: "User knowledge and facts (semantic + procedural memory)",
+  position: 80,
+  get: async (runtime, message, state) => {
     try {
       const memoryService = runtime.getService("memory");
       if (!memoryService) {
+        logger7.warn("Memory service not available");
         return {
-          data: { memories: [] },
-          values: { longTermMemories: "" },
+          data: {},
+          values: {},
           text: ""
         };
       }
-      const { entityId } = message;
-      if (entityId === runtime.agentId) {
-        return {
-          data: { memories: [] },
-          values: { longTermMemories: "" },
-          text: ""
-        };
+      const entityId = message.entityId;
+      const roomId = message.roomId;
+      const query = typeof message.content === "string" ? message.content : message.content.text || JSON.stringify(message.content);
+      logger7.debug({
+        entityId,
+        roomId,
+        queryLength: query.length
+      }, "Retrieving unified memories");
+      const config = memoryService.getConfig();
+      const [semanticMemories, proceduralMemories, episodicMemories] = await Promise.all([
+        memoryService.searchLongTermMemories({
+          entityId,
+          query,
+          roomId,
+          type: "SEMANTIC" /* SEMANTIC */,
+          limit: config.retrievalLimit,
+          minConfidence: config.minConfidence,
+          similarityThreshold: 0.15
+        }),
+        memoryService.searchLongTermMemories({
+          entityId,
+          query,
+          roomId,
+          type: "PROCEDURAL" /* PROCEDURAL */,
+          limit: Math.floor(config.retrievalLimit / 2),
+          minConfidence: config.minConfidence,
+          similarityThreshold: 0.15
+        }),
+        memoryService.searchLongTermMemories({
+          entityId,
+          query,
+          roomId,
+          type: "EPISODIC" /* EPISODIC */,
+          limit: config.retrievalLimit,
+          minConfidence: config.minConfidence,
+          similarityThreshold: 0.15
+        })
+      ]);
+      const longTermSections = [];
+      if (semanticMemories.length > 0) {
+        const items = semanticMemories.map((m) => `- ${m.content} (confidence: ${m.confidence.toFixed(2)}, strength: ${m.activationScore.toFixed(2)})`).join(`
+`);
+        longTermSections.push(addHeader("## Semantic Knowledge (Facts)", items));
       }
-      const memories = await memoryService.getLongTermMemories(entityId, undefined, 25);
-      if (memories.length === 0) {
-        return {
-          data: { memories: [] },
-          values: { longTermMemories: "" },
-          text: ""
-        };
+      if (proceduralMemories.length > 0) {
+        const items = proceduralMemories.map((m) => `- ${m.content}`).join(`
+`);
+        longTermSections.push(addHeader("## Procedural Knowledge (Skills & Patterns)", items));
+      }
+      if (episodicMemories.length > 0) {
+        const items = episodicMemories.map((m) => `- ${m.content} (occurred: ${m.createdAt ? new Date(m.createdAt).toLocaleDateString() : "Unknown"})`).join(`
+`);
+        longTermSections.push(addHeader("## Significant Past Events", items));
+      }
+      const longTermMemoriesText = longTermSections.join(`
+
+`);
+      const data = {
+        semanticMemories,
+        proceduralMemories,
+        episodicMemories,
+        config: {
+          retrievalLimit: config.retrievalLimit,
+          tokenBudget: config.tokenBudget
+        }
+      };
+      const values = {
+        longTermMemories: longTermMemoriesText
+      };
+      const text3 = longTermMemoriesText;
+      logger7.info({
+        semanticCount: semanticMemories.length,
+        proceduralCount: proceduralMemories.length,
+        episodicCount: episodicMemories.length
+      }, "Retrieved long-term memory facts");
+      return {
+        data,
+        values,
+        text: text3
+      };
+    } catch (error) {
+      logger7.error({ error }, "Failed to retrieve long-term memories");
+      return {
+        data: {},
+        values: {
+          longTermMemories: ""
+        },
+        text: ""
+      };
+    }
+  }
+};
+
+// src/providers/recent-conversation-summary.ts
+import {
+  addHeader as addHeader2,
+  ChannelType,
+  formatMessages,
+  formatPosts,
+  getEntityDetails,
+  logger as logger8
+} from "@elizaos/core";
+var getProviderConfig = (runtime) => ({
+  overlapUserMessageCount: parseInt(runtime.getSetting("CONTEXT_OVERLAP_USER_MESSAGES") || "2", 10)
+});
+async function fetchConversationData(runtime, roomId) {
+  const [entities, room, allMessages] = await Promise.all([
+    getEntityDetails({ runtime, roomId }),
+    runtime.getRoom(roomId),
+    runtime.getMemories({
+      tableName: "messages",
+      roomId,
+      count: 100,
+      unique: false
+    })
+  ]);
+  return { entities, room, allMessages };
+}
+function filterAndSortDialogueMessages(allMessages) {
+  const dialogueMessages = allMessages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result"));
+  dialogueMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
+  return dialogueMessages;
+}
+async function buildCompressedHistory(runtime, message, dialogueMessages, sessionStartTime) {
+  let compressedHistoryText = "";
+  let lastSummarizedIndex = -1;
+  const memoryService = runtime.getService("memory");
+  if (!memoryService?.searchSummaries) {
+    return { compressedHistoryText, lastSummarizedIndex };
+  }
+  try {
+    const summaries = await memoryService.searchSummaries({
+      entityId: message.entityId,
+      roomId: message.roomId,
+      query: typeof message.content === "string" ? message.content : message.content.text || "",
+      limit: 3,
+      tokenBudget: 500
+    });
+    if (summaries.length === 0) {
+      return { compressedHistoryText, lastSummarizedIndex };
+    }
+    lastSummarizedIndex = findLastSummarizedMessageIndex(summaries, dialogueMessages);
+    const summaryItems = summaries.map((s) => {
+      const levelLabel = s.level === 1 ? "Recent Session" : `Overview (L${s.level})`;
+      return `**[${levelLabel}]** ${s.content}`;
+    }).join(`
+
+`);
+    const headerText = `# Conversation History (Compressed)
+**Session Started:** ${formatDateTime(sessionStartTime)}`;
+    compressedHistoryText = addHeader2(headerText, summaryItems);
+    logger8.debug({
+      summaryCount: summaries.length,
+      totalTokens: summaries.reduce((sum, s) => sum + s.tokenCount, 0),
+      lastSummarizedIndex
+    }, "Using hierarchical summaries for compressed history");
+  } catch (error) {
+    logger8.warn({ error }, "Failed to retrieve summaries");
+  }
+  return { compressedHistoryText, lastSummarizedIndex };
+}
+function findLastSummarizedMessageIndex(summaries, dialogueMessages) {
+  const level1Summaries = summaries.filter((s) => s.level === 1);
+  if (level1Summaries.length === 0) {
+    return -1;
+  }
+  const allSummarizedMessageIds = new Set;
+  level1Summaries.forEach((summary) => {
+    summary.sourceIds.forEach((id) => allSummarizedMessageIds.add(id));
+  });
+  for (let i = dialogueMessages.length - 1;i >= 0; i--) {
+    if (allSummarizedMessageIds.has(dialogueMessages[i].id)) {
+      logger8.debug({
+        lastSummarizedIndex: i,
+        totalMessages: dialogueMessages.length,
+        summarizedCount: allSummarizedMessageIds.size
+      }, "Determined last summarized message index");
+      return i;
+    }
+  }
+  return -1;
+}
+function calculateBufferMessages(runtime, dialogueMessages, lastSummarizedIndex, hasSummaries, overlapUserMessageCount) {
+  let bufferMessages;
+  if (lastSummarizedIndex >= 0 && hasSummaries) {
+    const summarizedMessages = dialogueMessages.slice(0, lastSummarizedIndex + 1);
+    const summarizedUserMessages = summarizedMessages.filter((m) => m.entityId !== runtime.agentId);
+    const overlapUserMessages = summarizedUserMessages.slice(-overlapUserMessageCount);
+    const newUnsummarizedMessages = dialogueMessages.slice(lastSummarizedIndex + 1);
+    let overlapStartIndex = lastSummarizedIndex + 1;
+    if (overlapUserMessages.length > 0) {
+      const firstOverlapUserMessageId = overlapUserMessages[0].id;
+      const foundIndex = dialogueMessages.findIndex((m) => m.id === firstOverlapUserMessageId);
+      if (foundIndex >= 0) {
+        overlapStartIndex = foundIndex;
       }
-      const formattedMemories = await memoryService.getFormattedLongTermMemories(entityId);
-      const text4 = addHeader2("# What I Know About You", formattedMemories);
-      const categoryCounts = new Map;
-      for (const memory of memories) {
-        const count = categoryCounts.get(memory.category) || 0;
-        categoryCounts.set(memory.category, count + 1);
+    }
+    bufferMessages = dialogueMessages.slice(overlapStartIndex);
+    logger8.debug({
+      lastSummarizedIndex,
+      summarizedMessageCount: summarizedMessages.length,
+      overlapStartIndex,
+      overlapSize: lastSummarizedIndex + 1 - overlapStartIndex,
+      newUnsummarizedCount: newUnsummarizedMessages.length,
+      bufferSize: bufferMessages.length,
+      totalDialogueMessages: dialogueMessages.length,
+      overlapUserMessageCount
+    }, `Dynamic buffer: [overlap: last ${overlapUserMessageCount} user msgs from summary] + [all new unsummarized messages]`);
+  } else {
+    bufferMessages = dialogueMessages;
+    logger8.debug({
+      bufferSize: bufferMessages.length,
+      totalMessages: dialogueMessages.length
+    }, "Using full conversation: no summaries yet");
+  }
+  return { bufferMessages, lastSummarizedIndex };
+}
+function formatDateTime(timestamp3) {
+  const date = new Date(timestamp3);
+  return date.toLocaleString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+}
+function removeEntityIds(text3) {
+  return text3.replace(/\s*\[[\w\-]+\]/g, "").replace(/\s*\([^)]*'s internal thought:[^)]*\)/gi, "").split(`
+`).map((line) => line.trim()).join(`
+`).replace(/\n{3,}/g, `
+
+`);
+}
+async function formatBufferMessages(bufferMessages, entities, room, sessionStartTime) {
+  const isPostFormat = room?.type ? room.type === ChannelType.FEED || room.type === ChannelType.THREAD : false;
+  const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
+    formatMessages({
+      messages: bufferMessages,
+      entities
+    }),
+    formatPosts({
+      messages: bufferMessages,
+      entities,
+      conversationHeader: false
+    })
+  ]);
+  let recentBufferText = (isPostFormat ? formattedRecentPosts : formattedRecentMessages) || "";
+  recentBufferText = removeEntityIds(recentBufferText);
+  const firstBufferTime = bufferMessages.length > 0 ? bufferMessages[0].createdAt : null;
+  const lastBufferTime = bufferMessages.length > 0 ? bufferMessages[bufferMessages.length - 1].createdAt : null;
+  let headerText = `# Recent Messages (Last ${bufferMessages.length})`;
+  if (firstBufferTime && lastBufferTime) {
+    headerText += `
+**Time Range:** ${formatDateTime(firstBufferTime)} - ${formatDateTime(lastBufferTime)}`;
+  }
+  return recentBufferText ? addHeader2(headerText, recentBufferText) : "";
+}
+function buildReceivedMessageSection(message, entities) {
+  const metaData = message.metadata;
+  const senderName = entities.find((entity) => entity.id === message.entityId)?.names[0] || metaData?.entityName || "Unknown User";
+  const receivedMessageContent = message.content.text;
+  const hasReceivedMessage = !!receivedMessageContent?.trim();
+  const receivedMessageHeader = hasReceivedMessage ? addHeader2("# Current Message", `**From ${senderName}:** ${receivedMessageContent}`) : "";
+  const focusHeader = hasReceivedMessage ? addHeader2("# Response Focus", `Reply to **${senderName}**'s current message above. Stay relevant to their question. Don't repeat previous responses unless asked again.`) : "";
+  return { receivedMessageHeader, focusHeader };
+}
+function assembleContextSections(compressedHistoryText, recentBufferHeader, receivedMessageHeader, focusHeader) {
+  const textSections = [
+    compressedHistoryText,
+    recentBufferHeader,
+    receivedMessageHeader,
+    focusHeader
+  ].filter(Boolean);
+  return textSections.join(`
+
+`);
+}
+var recentContextProvider = {
+  name: "RECENT_CONVERSATION_SUMMARY",
+  description: "Intelligent context management combining recent messages with hierarchical summaries for optimal token efficiency",
+  position: 100,
+  get: async (runtime, message) => {
+    try {
+      const { roomId } = message;
+      const config = getProviderConfig(runtime);
+      const { entities, room, allMessages } = await fetchConversationData(runtime, roomId);
+      const dialogueMessages = filterAndSortDialogueMessages(allMessages);
+      const sessionStartTime = dialogueMessages.length > 0 ? dialogueMessages[0].createdAt || Date.now() : Date.now();
+      const { compressedHistoryText, lastSummarizedIndex } = await buildCompressedHistory(runtime, message, dialogueMessages, sessionStartTime);
+      const hasSummaries = !!compressedHistoryText;
+      const { bufferMessages } = calculateBufferMessages(runtime, dialogueMessages, lastSummarizedIndex, hasSummaries, config.overlapUserMessageCount);
+      const recentBufferHeader = await formatBufferMessages(bufferMessages, entities, room, sessionStartTime);
+      const { receivedMessageHeader, focusHeader } = buildReceivedMessageSection(message, entities);
+      const text3 = assembleContextSections(compressedHistoryText, recentBufferHeader, receivedMessageHeader, focusHeader);
+      const data = {
+        dialogueMessages: bufferMessages,
+        messageCount: dialogueMessages.length,
+        lastSummarizedIndex,
+        config
+      };
+      const isPostFormat = room?.type ? room.type === ChannelType.FEED || room.type === ChannelType.THREAD : false;
+      const values = {
+        compressedHistory: compressedHistoryText,
+        recentMessages: recentBufferHeader,
+        receivedMessage: receivedMessageHeader,
+        focusInstruction: focusHeader,
+        recentPosts: isPostFormat ? recentBufferHeader : ""
+      };
+      logger8.info({
+        messageCount: dialogueMessages.length,
+        bufferSize: bufferMessages.length,
+        hasSummaries,
+        lastSummarizedIndex,
+        estimatedTokens: Math.ceil(text3.length / 4),
+        overlapUserMessageCount: config.overlapUserMessageCount
+      }, "Recent context assembled");
+      return {
+        data,
+        values,
+        text: text3
+      };
+    } catch (error) {
+      logger8.error({ error }, "Error in recentContextProvider");
+      return {
+        data: {
+          dialogueMessages: [],
+          messageCount: 0,
+          lastSummarizedIndex: -1,
+          config: getProviderConfig(runtime)
+        },
+        values: {
+          compressedHistory: "",
+          recentMessages: "",
+          receivedMessage: "",
+          focusInstruction: "",
+          recentPosts: ""
+        },
+        text: "Error retrieving context."
+      };
+    }
+  }
+};
+
+// src/providers/action-results.ts
+import { addHeader as addHeader3, logger as logger9 } from "@elizaos/core";
+var getActionResultsConfig = (runtime) => ({
+  limit: parseInt(runtime.getSetting("CONTEXT_ACTION_RESULTS_LIMIT") || "3", 10)
+});
+function formatActionResults(actionResultMessages, limit) {
+  if (actionResultMessages.length === 0) {
+    return "";
+  }
+  const groupedByRun = new Map;
+  for (const mem of actionResultMessages) {
+    const runId = String(mem.content?.runId || "unknown");
+    if (!groupedByRun.has(runId)) {
+      groupedByRun.set(runId, []);
+    }
+    groupedByRun.get(runId).push(mem);
+  }
+  const formattedActionResults = Array.from(groupedByRun.entries()).slice(-limit).map(([runId, memories]) => {
+    const sortedMemories = memories.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
+    const thought = sortedMemories[0]?.content?.planThought || "";
+    const runText = sortedMemories.map((mem) => {
+      const actionName = mem.content?.actionName || "Unknown";
+      const status = mem.content?.actionStatus || "unknown";
+      const planStep = mem.content?.planStep || "";
+      const text3 = mem.content?.text || "";
+      const error = mem.content?.error || "";
+      let memText = `  - ${actionName} (${status})`;
+      if (planStep)
+        memText += ` [${planStep}]`;
+      if (error) {
+        memText += `: Error - ${error}`;
+      } else if (text3 && text3 !== `Executed action: ${actionName}`) {
+        memText += `: ${text3}`;
       }
-      const categoryList = Array.from(categoryCounts.entries()).map(([cat, count]) => `${cat}: ${count}`).join(", ");
+      return memText;
+    }).join(`
+`);
+    return `**Action Run ${runId.slice(0, 8)}**${thought ? ` - "${thought}"` : ""}
+${runText}`;
+  }).join(`
+
+`);
+  return formattedActionResults ? addHeader3("# Recent Action Executions", formattedActionResults) : "";
+}
+var actionResultsProvider = {
+  name: "ACTION_RESULTS",
+  description: "Recent action executions with their outcomes (tool memory)",
+  position: 101,
+  get: async (runtime, message) => {
+    try {
+      const { roomId } = message;
+      const config = getActionResultsConfig(runtime);
+      const allMessages = await runtime.getMemories({
+        tableName: "messages",
+        roomId,
+        count: 50,
+        unique: false
+      });
+      const actionResultMessages = allMessages.filter((msg) => msg.content?.type === "action_result" && msg.metadata?.type === "action_result");
+      actionResultMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
+      const text3 = formatActionResults(actionResultMessages, config.limit);
+      logger9.debug({
+        actionResultCount: actionResultMessages.length,
+        limit: config.limit
+      }, "Action results provider assembled");
       return {
         data: {
-          memories,
-          categoryCounts: Object.fromEntries(categoryCounts)
+          actionResults: actionResultMessages,
+          config
         },
         values: {
-          longTermMemories: text4,
-          memoryCategories: categoryList
+          recentActionResults: text3
         },
-        text: text4
+        text: text3
       };
     } catch (error) {
-      logger5.error({ error }, "Error in longTermMemoryProvider:");
+      logger9.error({ error }, "Error in actionResultsProvider");
       return {
-        data: { memories: [] },
-        values: { longTermMemories: "" },
+        data: {
+          actionResults: [],
+          config: getActionResultsConfig(runtime)
+        },
+        values: {
+          recentActionResults: ""
+        },
         text: ""
       };
     }
   }
 };
-
 // src/index.ts
 var memoryPlugin = {
   name: "memory",
-  description: "Advanced memory management with conversation summarization and long-term persistent memory",
+  description: "State-of-the-art cognitive memory system with episodic, semantic, and procedural memory, " + "featuring hybrid retrieval (Vector + BM25 + Graph), exponential decay, contextual embeddings, " + "and contradiction detection",
   services: [MemoryService],
-  evaluators: [summarizationEvaluator, longTermExtractionEvaluator],
-  providers: [longTermMemoryProvider, shortTermMemoryProvider],
+  evaluators: [consolidationEvaluator, summarizationEvaluator],
+  providers: [longTermMemoryProvider, recentContextProvider, actionResultsProvider],
   schema: exports_schemas
 };
 var src_default = memoryPlugin;
 export {
-  sessionSummaries,
+  trimToTokenBudget,
+  recentContextProvider,
+  mergeSearchResults,
   memoryPlugin,
-  memoryAccessLogs,
+  mapDbRowToLongTermMemory,
+  mapDbRowToConversationSummary,
+  longTermMemoryProvider,
+  longTermMemoryEmbeddings,
   longTermMemories,
+  generateEmbedding,
+  formatTokenCount,
+  formatMemoriesForContext,
+  estimateTokensInSummary,
+  estimateTokenCountForArray,
+  estimateTokenCount,
   src_default as default,
+  conversationSummaryEmbeddings,
+  conversationSummaries,
+  cleanEmbedding,
+  calculateDecayFactor,
+  calculateAccessBoost,
+  buildLevel1SummaryPrompt,
+  buildHigherLevelSummaryPrompt,
+  buildExtractionPrompt,
+  buildContradictionPrompt,
+  applyDecayScoring,
+  actionResultsProvider,
+  SUMMARIZATION_SYSTEM_PROMPT,
+  MemoryType,
   MemoryService,
-  LongTermMemoryCategory
+  MEMORY_DIMENSION_MAP,
+  LongTermMemoryRepository,
+  HIGHER_LEVEL_SUMMARIZATION_SYSTEM_PROMPT,
+  DecayFunction,
+  ConversationSummaryRepository,
+  CONSOLIDATION_SYSTEM_PROMPT
 };
 
-//# debugId=C168790F41A1B4EE64756E2164756E21
+//# debugId=925F6225A20E2D9B64756E2164756E21