@elizaos/plugin-memory 1.0.5 → 2.0.1

package/dist/cjs/index.node.cjs

@@ -29,1244 +29,2397 @@ var __export = (target, all) => {
 // src/index.node.ts
 var exports_index_node = {};
 __export(exports_index_node, {
-  sessionSummaries: () => sessionSummaries,
+  trimToTokenBudget: () => trimToTokenBudget,
+  recentContextProvider: () => recentContextProvider,
+  mergeSearchResults: () => mergeSearchResults,
   memoryPlugin: () => memoryPlugin,
-  memoryAccessLogs: () => memoryAccessLogs,
+  mapDbRowToLongTermMemory: () => mapDbRowToLongTermMemory,
+  mapDbRowToConversationSummary: () => mapDbRowToConversationSummary,
+  longTermMemoryProvider: () => longTermMemoryProvider,
+  longTermMemoryEmbeddings: () => longTermMemoryEmbeddings,
   longTermMemories: () => longTermMemories,
+  generateEmbedding: () => generateEmbedding,
+  formatTokenCount: () => formatTokenCount,
+  formatMemoriesForContext: () => formatMemoriesForContext,
+  estimateTokensInSummary: () => estimateTokensInSummary,
+  estimateTokenCountForArray: () => estimateTokenCountForArray,
+  estimateTokenCount: () => estimateTokenCount,
   default: () => src_default,
+  conversationSummaryEmbeddings: () => conversationSummaryEmbeddings,
+  conversationSummaries: () => conversationSummaries,
+  cleanEmbedding: () => cleanEmbedding,
+  calculateDecayFactor: () => calculateDecayFactor,
+  calculateAccessBoost: () => calculateAccessBoost,
+  buildLevel1SummaryPrompt: () => buildLevel1SummaryPrompt,
+  buildHigherLevelSummaryPrompt: () => buildHigherLevelSummaryPrompt,
+  buildExtractionPrompt: () => buildExtractionPrompt,
+  buildContradictionPrompt: () => buildContradictionPrompt,
+  applyDecayScoring: () => applyDecayScoring,
+  actionResultsProvider: () => actionResultsProvider,
+  SUMMARIZATION_SYSTEM_PROMPT: () => SUMMARIZATION_SYSTEM_PROMPT,
+  MemoryType: () => MemoryType,
   MemoryService: () => MemoryService,
-  LongTermMemoryCategory: () => LongTermMemoryCategory
+  MEMORY_DIMENSION_MAP: () => MEMORY_DIMENSION_MAP,
+  LongTermMemoryRepository: () => LongTermMemoryRepository,
+  HIGHER_LEVEL_SUMMARIZATION_SYSTEM_PROMPT: () => HIGHER_LEVEL_SUMMARIZATION_SYSTEM_PROMPT,
+  DecayFunction: () => DecayFunction,
+  ConversationSummaryRepository: () => ConversationSummaryRepository,
+  CONSOLIDATION_SYSTEM_PROMPT: () => CONSOLIDATION_SYSTEM_PROMPT
 });
 module.exports = __toCommonJS(exports_index_node);
 
 // src/services/memory-service.ts
-var import_core = require("@elizaos/core");
-var import_drizzle_orm4 = require("drizzle-orm");
+var import_core6 = require("@elizaos/core");
+var import_core7 = require("@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
+var import_core3 = require("@elizaos/core");
+var import_drizzle_orm3 = require("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
 var import_drizzle_orm = require("drizzle-orm");
 var import_pg_core = require("drizzle-orm/pg-core");
+var import_core = require("@elizaos/core");
 var longTermMemories = import_pg_core.pgTable("long_term_memories", {
   id: import_pg_core.varchar("id", { length: 36 }).primaryKey(),
   agentId: import_pg_core.varchar("agent_id", { length: 36 }).notNull(),
   entityId: import_pg_core.varchar("entity_id", { length: 36 }).notNull(),
-  category: import_pg_core.text("category").notNull(),
+  roomId: import_pg_core.varchar("room_id", { length: 36 }),
+  type: import_pg_core.text("type").notNull(),
   content: import_pg_core.text("content").notNull(),
-  metadata: import_pg_core.jsonb("metadata"),
-  embedding: import_pg_core.real("embedding").array(),
-  confidence: import_pg_core.real("confidence").default(1),
-  source: import_pg_core.text("source"),
+  embeddingContext: import_pg_core.text("embedding_context").notNull(),
+  confidence: import_pg_core.real("confidence").notNull().default(1),
+  decayRate: import_pg_core.real("decay_rate").notNull().default(0.01),
+  decayFunction: import_pg_core.text("decay_function").notNull().default("EXPONENTIAL"),
   createdAt: import_pg_core.timestamp("created_at").default(import_drizzle_orm.sql`now()`).notNull(),
-  updatedAt: import_pg_core.timestamp("updated_at").default(import_drizzle_orm.sql`now()`).notNull(),
   lastAccessedAt: import_pg_core.timestamp("last_accessed_at"),
-  accessCount: import_pg_core.integer("access_count").default(0)
+  accessCount: import_pg_core.integer("access_count").default(0).notNull(),
+  isActive: import_pg_core.boolean("is_active").default(true).notNull(),
+  source: import_pg_core.jsonb("source").notNull().default({}),
+  metadata: import_pg_core.jsonb("metadata").notNull().default({}),
+  supersedesId: import_pg_core.varchar("supersedes_id", { length: 36 })
 }, (table) => ({
-  agentEntityIdx: import_pg_core.index("long_term_memories_agent_entity_idx").on(table.agentId, table.entityId),
-  categoryIdx: import_pg_core.index("long_term_memories_category_idx").on(table.category),
-  confidenceIdx: import_pg_core.index("long_term_memories_confidence_idx").on(table.confidence),
-  createdAtIdx: import_pg_core.index("long_term_memories_created_at_idx").on(table.createdAt)
+  agentEntityIdx: import_pg_core.index("ltm_agent_entity_idx").on(table.agentId, table.entityId),
+  typeIdx: import_pg_core.index("ltm_type_idx").on(table.type),
+  roomIdx: import_pg_core.index("ltm_room_idx").on(table.roomId),
+  activeIdx: import_pg_core.index("ltm_active_idx").on(table.isActive),
+  confidenceIdx: import_pg_core.index("ltm_confidence_idx").on(table.confidence),
+  createdAtIdx: import_pg_core.index("ltm_created_at_idx").on(table.createdAt),
+  lastAccessedIdx: import_pg_core.index("ltm_last_accessed_idx").on(table.lastAccessedAt),
+  agentEntityActiveConfidenceIdx: import_pg_core.index("ltm_agent_entity_active_conf_idx").on(table.agentId, table.entityId, table.isActive, table.confidence)
 }));
-// src/schemas/session-summaries.ts
+var longTermMemoryEmbeddings = import_pg_core.pgTable("long_term_memory_embeddings", {
+  id: import_pg_core.varchar("id", { length: 36 }).primaryKey(),
+  memoryId: import_pg_core.varchar("memory_id", { length: 36 }).notNull().references(() => longTermMemories.id, { onDelete: "cascade" }),
+  dim384: import_pg_core.vector("dim_384", { dimensions: import_core.VECTOR_DIMS.SMALL }),
+  dim512: import_pg_core.vector("dim_512", { dimensions: import_core.VECTOR_DIMS.MEDIUM }),
+  dim768: import_pg_core.vector("dim_768", { dimensions: import_core.VECTOR_DIMS.LARGE }),
+  dim1024: import_pg_core.vector("dim_1024", { dimensions: import_core.VECTOR_DIMS.XL }),
+  dim1536: import_pg_core.vector("dim_1536", { dimensions: import_core.VECTOR_DIMS.XXL }),
+  dim3072: import_pg_core.vector("dim_3072", { dimensions: import_core.VECTOR_DIMS.XXXL }),
+  createdAt: import_pg_core.timestamp("created_at").default(import_drizzle_orm.sql`now()`).notNull()
+}, (table) => [
+  import_pg_core.index("idx_ltm_embedding_memory_id").on(table.memoryId),
+  import_pg_core.foreignKey({
+    name: "fk_ltm_embedding_memory",
+    columns: [table.memoryId],
+    foreignColumns: [longTermMemories.id]
+  }).onDelete("cascade")
+]);
+// src/schemas/conversation-summaries.ts
 var import_drizzle_orm2 = require("drizzle-orm");
 var import_pg_core2 = require("drizzle-orm/pg-core");
-var sessionSummaries = import_pg_core2.pgTable("session_summaries", {
+var import_core2 = require("@elizaos/core");
+var conversationSummaries = import_pg_core2.pgTable("conversation_summaries", {
   id: import_pg_core2.varchar("id", { length: 36 }).primaryKey(),
   agentId: import_pg_core2.varchar("agent_id", { length: 36 }).notNull(),
+  entityId: import_pg_core2.varchar("entity_id", { length: 36 }).notNull(),
   roomId: import_pg_core2.varchar("room_id", { length: 36 }).notNull(),
-  entityId: import_pg_core2.varchar("entity_id", { length: 36 }),
-  summary: import_pg_core2.text("summary").notNull(),
-  messageCount: import_pg_core2.integer("message_count").notNull(),
-  lastMessageOffset: import_pg_core2.integer("last_message_offset").notNull().default(0),
+  level: import_pg_core2.integer("level").notNull().default(1),
+  parentSummaryId: import_pg_core2.varchar("parent_summary_id", { length: 36 }),
+  content: import_pg_core2.text("content").notNull(),
+  tokenCount: import_pg_core2.integer("token_count").notNull(),
   startTime: import_pg_core2.timestamp("start_time").notNull(),
   endTime: import_pg_core2.timestamp("end_time").notNull(),
-  topics: import_pg_core2.jsonb("topics"),
-  metadata: import_pg_core2.jsonb("metadata"),
-  embedding: import_pg_core2.real("embedding").array(),
+  sourceCount: import_pg_core2.integer("source_count").notNull(),
+  sourceIds: import_pg_core2.jsonb("source_ids").notNull().default([]),
   createdAt: import_pg_core2.timestamp("created_at").default(import_drizzle_orm2.sql`now()`).notNull(),
-  updatedAt: import_pg_core2.timestamp("updated_at").default(import_drizzle_orm2.sql`now()`).notNull()
+  lastAccessedAt: import_pg_core2.timestamp("last_accessed_at"),
+  accessCount: import_pg_core2.integer("access_count").default(0).notNull(),
+  metadata: import_pg_core2.jsonb("metadata").notNull().default({})
 }, (table) => ({
-  agentRoomIdx: import_pg_core2.index("session_summaries_agent_room_idx").on(table.agentId, table.roomId),
-  entityIdx: import_pg_core2.index("session_summaries_entity_idx").on(table.entityId),
-  startTimeIdx: import_pg_core2.index("session_summaries_start_time_idx").on(table.startTime)
+  agentEntityRoomIdx: import_pg_core2.index("cs_agent_entity_room_idx").on(table.agentId, table.entityId, table.roomId),
+  levelIdx: import_pg_core2.index("cs_level_idx").on(table.level),
+  parentIdx: import_pg_core2.index("cs_parent_idx").on(table.parentSummaryId),
+  timeRangeIdx: import_pg_core2.index("cs_time_range_idx").on(table.startTime, table.endTime),
+  createdAtIdx: import_pg_core2.index("cs_created_at_idx").on(table.createdAt),
+  lastAccessedIdx: import_pg_core2.index("cs_last_accessed_idx").on(table.lastAccessedAt),
+  entityRoomLevelTimeIdx: import_pg_core2.index("cs_entity_room_level_time_idx").on(table.entityId, table.roomId, table.level, table.createdAt)
 }));
-// src/schemas/memory-access-logs.ts
-var import_drizzle_orm3 = require("drizzle-orm");
-var import_pg_core3 = require("drizzle-orm/pg-core");
-var memoryAccessLogs = import_pg_core3.pgTable("memory_access_logs", {
-  id: import_pg_core3.varchar("id", { length: 36 }).primaryKey(),
-  agentId: import_pg_core3.varchar("agent_id", { length: 36 }).notNull(),
-  memoryId: import_pg_core3.varchar("memory_id", { length: 36 }).notNull(),
-  memoryType: import_pg_core3.text("memory_type").notNull(),
-  accessedAt: import_pg_core3.timestamp("accessed_at").default(import_drizzle_orm3.sql`now()`).notNull(),
-  roomId: import_pg_core3.varchar("room_id", { length: 36 }),
-  relevanceScore: import_pg_core3.real("relevance_score"),
-  wasUseful: import_pg_core3.integer("was_useful")
-}, (table) => ({
-  memoryIdx: import_pg_core3.index("memory_access_logs_memory_idx").on(table.memoryId),
-  agentIdx: import_pg_core3.index("memory_access_logs_agent_idx").on(table.agentId),
-  accessedAtIdx: import_pg_core3.index("memory_access_logs_accessed_at_idx").on(table.accessedAt)
-}));
-// src/services/memory-service.ts
-class MemoryService extends import_core.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: 16,
-      shortTermRetainRecent: 10,
-      shortTermSummarizationInterval: 10,
-      longTermExtractionEnabled: true,
-      longTermVectorSearchEnabled: false,
-      longTermConfidenceThreshold: 0.7,
-      longTermExtractionThreshold: 20,
-      longTermExtractionInterval: 5,
-      summaryModelType: "TEXT_LARGE",
-      summaryMaxTokens: 2500,
-      summaryMaxNewMessages: 20
-    };
-  }
-  static async start(runtime) {
-    const service = new MemoryService(runtime);
-    await service.initialize(runtime);
-    return service;
-  }
-  async stop() {
-    import_core.logger.info("MemoryService stopped");
-  }
-  async initialize(runtime) {
+var conversationSummaryEmbeddings = import_pg_core2.pgTable("conversation_summary_embeddings", {
+  id: import_pg_core2.varchar("id", { length: 36 }).primaryKey(),
+  summaryId: import_pg_core2.varchar("summary_id", { length: 36 }).notNull().references(() => conversationSummaries.id, { onDelete: "cascade" }),
+  dim384: import_pg_core2.vector("dim_384", { dimensions: import_core2.VECTOR_DIMS.SMALL }),
+  dim512: import_pg_core2.vector("dim_512", { dimensions: import_core2.VECTOR_DIMS.MEDIUM }),
+  dim768: import_pg_core2.vector("dim_768", { dimensions: import_core2.VECTOR_DIMS.LARGE }),
+  dim1024: import_pg_core2.vector("dim_1024", { dimensions: import_core2.VECTOR_DIMS.XL }),
+  dim1536: import_pg_core2.vector("dim_1536", { dimensions: import_core2.VECTOR_DIMS.XXL }),
+  dim3072: import_pg_core2.vector("dim_3072", { dimensions: import_core2.VECTOR_DIMS.XXXL }),
+  createdAt: import_pg_core2.timestamp("created_at").default(import_drizzle_orm2.sql`now()`).notNull()
+}, (table) => [
+  import_pg_core2.index("idx_cs_embedding_summary_id").on(table.summaryId),
+  import_pg_core2.foreignKey({
+    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 summarizationInterval = runtime.getSetting("MEMORY_SUMMARIZATION_INTERVAL");
-    if (summarizationInterval) {
-      this.memoryConfig.shortTermSummarizationInterval = parseInt(summarizationInterval, 10);
-    }
-    const maxNewMessages = runtime.getSetting("MEMORY_MAX_NEW_MESSAGES");
-    if (maxNewMessages) {
-      this.memoryConfig.summaryMaxNewMessages = parseInt(maxNewMessages, 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);
-    }
-    const extractionThreshold = runtime.getSetting("MEMORY_EXTRACTION_THRESHOLD");
-    if (extractionThreshold) {
-      this.memoryConfig.longTermExtractionThreshold = parseInt(extractionThreshold, 10);
-    }
-    const extractionInterval = runtime.getSetting("MEMORY_EXTRACTION_INTERVAL");
-    if (extractionInterval) {
-      this.memoryConfig.longTermExtractionInterval = parseInt(extractionInterval, 10);
-    }
-    import_core.logger.info({
-      summarizationThreshold: this.memoryConfig.shortTermSummarizationThreshold,
-      summarizationInterval: this.memoryConfig.shortTermSummarizationInterval,
-      maxNewMessages: this.memoryConfig.summaryMaxNewMessages,
-      retainRecent: this.memoryConfig.shortTermRetainRecent,
-      longTermEnabled: this.memoryConfig.longTermExtractionEnabled,
-      extractionThreshold: this.memoryConfig.longTermExtractionThreshold,
-      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) {
-      import_core.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);
-      import_core.logger.debug(`Set extraction checkpoint for ${entityId} in room ${roomId} at message count ${messageCount}`);
+      const isReady = await adapter.isReady();
+      if (!isReady) {
+        import_core3.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) {
-      import_core.logger.error({ error }, "Failed to persist extraction checkpoint to cache");
-    }
-  }
-  async shouldRunExtraction(entityId, roomId, currentMessageCount) {
-    const threshold = this.memoryConfig.longTermExtractionThreshold;
-    const interval = this.memoryConfig.longTermExtractionInterval;
-    if (currentMessageCount < threshold) {
-      import_core.logger.debug({
-        entityId,
-        roomId,
-        currentMessageCount,
-        threshold,
-        shouldRun: false
-      }, "Extraction check: below threshold");
-      return false;
+      import_core3.logger.error("[LongTermMemoryRepository] Database health check failed:", error);
+      throw new Error("Database connection health check failed");
     }
-    const lastCheckpoint = await this.getLastExtractionCheckpoint(entityId, roomId);
-    const currentCheckpoint = Math.floor(currentMessageCount / interval) * interval;
-    const shouldRun = currentMessageCount >= threshold && currentCheckpoint > lastCheckpoint;
-    import_core.logger.debug({
-      entityId,
-      roomId,
-      currentMessageCount,
-      threshold,
-      interval,
-      lastCheckpoint,
-      currentCheckpoint,
-      shouldRun
-    }, "Extraction check");
-    return shouldRun;
+    return db;
   }
-  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) {
-      import_core.logger.error({ error }, "Failed to store long-term memory");
-      throw error;
-    }
-    import_core.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);
+      }
+    });
+    import_core3.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();
-    const conditions = [
-      import_drizzle_orm4.eq(longTermMemories.agentId, this.runtime.agentId),
-      import_drizzle_orm4.eq(longTermMemories.entityId, entityId)
-    ];
-    if (category) {
-      conditions.push(import_drizzle_orm4.eq(longTermMemories.category, category));
+  async findById(id) {
+    const db = await this.getDb();
+    const results = await db.select().from(longTermMemories).where(import_drizzle_orm3.eq(longTermMemories.id, id)).limit(1);
+    if (results.length === 0) {
+      return null;
     }
-    const results = await db.select().from(longTermMemories).where(import_drizzle_orm4.and(...conditions)).orderBy(import_drizzle_orm4.desc(longTermMemories.confidence), import_drizzle_orm4.desc(longTermMemories.updatedAt)).limit(limit);
-    return results.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
-    }));
+    return mapDbRowToLongTermMemory(results[0]);
   }
-  async updateLongTermMemory(id, entityId, updates) {
-    const db = this.getDb();
-    const updateData = {
-      updatedAt: new Date
-    };
-    if (updates.content !== undefined) {
+  async update(id, updates, newEmbedding) {
+    const db = await this.getDb();
+    const updateData = {};
+    if (updates.content !== undefined)
       updateData.content = updates.content;
-    }
-    if (updates.metadata !== undefined) {
+    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(import_drizzle_orm3.eq(longTermMemories.id, id));
+      if (newEmbedding && this.embeddingDimension) {
+        const embeddingUpdate = {};
+        embeddingUpdate[this.embeddingDimension] = newEmbedding;
+        await tx.update(longTermMemoryEmbeddings).set(embeddingUpdate).where(import_drizzle_orm3.eq(longTermMemoryEmbeddings.memoryId, id));
+      }
+    });
+    import_core3.logger.info({ id }, "Updated long-term memory");
+  }
+  async delete(id) {
+    const db = await this.getDb();
+    await db.delete(longTermMemories).where(import_drizzle_orm3.eq(longTermMemories.id, id));
+    import_core3.logger.info({ id }, "Deleted long-term memory");
+  }
+  async findByEntity(entityId, type, limit = 20, includeInactive = false) {
+    const db = await this.getDb();
+    const conditions = [
+      import_drizzle_orm3.eq(longTermMemories.agentId, this.runtime.agentId),
+      import_drizzle_orm3.eq(longTermMemories.entityId, entityId)
+    ];
+    if (!includeInactive) {
+      conditions.push(import_drizzle_orm3.eq(longTermMemories.isActive, true));
     }
-    if (updates.confidence !== undefined) {
-      updateData.confidence = updates.confidence;
+    if (type) {
+      conditions.push(import_drizzle_orm3.eq(longTermMemories.type, type));
     }
-    if (updates.embedding !== undefined) {
-      updateData.embedding = updates.embedding;
+    const results = await db.select().from(longTermMemories).where(import_drizzle_orm3.and(...conditions)).orderBy(import_drizzle_orm3.desc(longTermMemories.confidence), import_drizzle_orm3.desc(longTermMemories.createdAt)).limit(limit);
+    return results.map((row) => mapDbRowToLongTermMemory(row));
+  }
+  async vectorSearch(params, queryEmbedding, similarityThreshold = 0.3) {
+    if (!this.embeddingDimension) {
+      import_core3.logger.warn("Embedding dimension not set, skipping vector search");
+      return [];
     }
-    if (updates.lastAccessedAt !== undefined) {
-      updateData.lastAccessedAt = updates.lastAccessedAt;
+    const db = await this.getDb();
+    try {
+      const similarity = import_drizzle_orm3.sql`1 - (${import_drizzle_orm3.cosineDistance(longTermMemoryEmbeddings[this.embeddingDimension], queryEmbedding)})`;
+      const conditions = [
+        import_drizzle_orm3.eq(longTermMemories.agentId, this.runtime.agentId),
+        import_drizzle_orm3.eq(longTermMemories.entityId, params.entityId),
+        import_drizzle_orm3.sql`${longTermMemoryEmbeddings[this.embeddingDimension]} IS NOT NULL`,
+        import_drizzle_orm3.gte(similarity, similarityThreshold)
+      ];
+      if (params.minConfidence) {
+        conditions.push(import_drizzle_orm3.gte(longTermMemories.confidence, params.minConfidence));
+      }
+      if (!params.includeInactive) {
+        conditions.push(import_drizzle_orm3.eq(longTermMemories.isActive, true));
+      }
+      if (params.type) {
+        conditions.push(import_drizzle_orm3.eq(longTermMemories.type, params.type));
+      }
+      if (params.roomId) {
+        conditions.push(import_drizzle_orm3.or(import_drizzle_orm3.eq(longTermMemories.roomId, params.roomId), import_drizzle_orm3.isNull(longTermMemories.roomId)));
+      }
+      const results = await db.select({
+        memory: longTermMemories,
+        embedding: longTermMemoryEmbeddings[this.embeddingDimension],
+        similarity
+      }).from(longTermMemories).innerJoin(longTermMemoryEmbeddings, import_drizzle_orm3.eq(longTermMemoryEmbeddings.memoryId, longTermMemories.id)).where(import_drizzle_orm3.and(...conditions)).orderBy(import_drizzle_orm3.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) {
+      import_core3.logger.error("Failed to execute vector search:", JSON.stringify(error));
+      return [];
     }
-    if (updates.accessCount !== undefined) {
-      updateData.accessCount = updates.accessCount;
+  }
+  async fetchAllActive() {
+    const db = await this.getDb();
+    const memories = await db.select().from(longTermMemories).where(import_drizzle_orm3.and(import_drizzle_orm3.eq(longTermMemories.agentId, this.runtime.agentId), import_drizzle_orm3.eq(longTermMemories.isActive, true)));
+    return memories.map((row) => ({
+      id: row.id,
+      content: row.content,
+      embeddingContext: row.embeddingContext
+    }));
+  }
+  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: import_drizzle_orm3.sql`${longTermMemories.accessCount} + 1`
+        }).where(import_drizzle_orm3.eq(longTermMemories.id, id));
+      }
+      import_core3.logger.debug({ count: memoryIds.length }, "Updated access metadata");
+    } catch (error) {
+      import_core3.logger.error({ error }, "Failed to update access metadata");
     }
-    await db.update(longTermMemories).set(updateData).where(import_drizzle_orm4.and(import_drizzle_orm4.eq(longTermMemories.id, id), import_drizzle_orm4.eq(longTermMemories.agentId, this.runtime.agentId), import_drizzle_orm4.eq(longTermMemories.entityId, entityId)));
-    import_core.logger.info(`Updated long-term memory: ${id} for entity ${entityId}`);
   }
-  async deleteLongTermMemory(id, entityId) {
-    const db = this.getDb();
-    await db.delete(longTermMemories).where(import_drizzle_orm4.and(import_drizzle_orm4.eq(longTermMemories.id, id), import_drizzle_orm4.eq(longTermMemories.agentId, this.runtime.agentId), import_drizzle_orm4.eq(longTermMemories.entityId, entityId)));
-    import_core.logger.info(`Deleted long-term memory: ${id} for entity ${entityId}`);
+}
+
+// src/repositories/conversation-summary.ts
+var import_core4 = require("@elizaos/core");
+var import_drizzle_orm4 = require("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(import_drizzle_orm4.and(import_drizzle_orm4.eq(sessionSummaries.agentId, this.runtime.agentId), import_drizzle_orm4.eq(sessionSummaries.roomId, roomId))).orderBy(import_drizzle_orm4.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) {
+        import_core4.logger.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) {
+      import_core4.logger.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);
+      }
     });
-    import_core.logger.info(`Stored session summary for room ${newSummary.roomId}`);
+    import_core4.logger.info({
+      id: newSummary.id,
+      level: newSummary.level,
+      tokenCount: newSummary.tokenCount,
+      sourceCount: newSummary.sourceCount
+    }, "Stored conversation summary");
     return newSummary;
   }
-  async updateSessionSummary(id, roomId, 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(import_drizzle_orm4.and(import_drizzle_orm4.eq(sessionSummaries.id, id), import_drizzle_orm4.eq(sessionSummaries.agentId, this.runtime.agentId), import_drizzle_orm4.eq(sessionSummaries.roomId, roomId)));
-    import_core.logger.info(`Updated session summary: ${id} for room ${roomId}`);
-  }
-  async getSessionSummaries(roomId, limit = 5) {
-    const db = this.getDb();
-    const results = await db.select().from(sessionSummaries).where(import_drizzle_orm4.and(import_drizzle_orm4.eq(sessionSummaries.agentId, this.runtime.agentId), import_drizzle_orm4.eq(sessionSummaries.roomId, roomId))).orderBy(import_drizzle_orm4.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(import_drizzle_orm4.and(import_drizzle_orm4.eq(conversationSummaries.agentId, this.runtime.agentId), import_drizzle_orm4.eq(conversationSummaries.roomId, roomId), import_drizzle_orm4.eq(conversationSummaries.level, level))).orderBy(import_drizzle_orm4.desc(conversationSummaries.createdAt));
+    return results.map((r) => mapDbRowToConversationSummary(r));
   }
-  async searchLongTermMemories(entityId, queryEmbedding, limit = 5, matchThreshold = 0.7) {
-    if (!this.memoryConfig.longTermVectorSearchEnabled) {
-      import_core.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) {
+      import_core4.logger.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 = import_drizzle_orm4.sql`1 - (${import_drizzle_orm4.cosineDistance(longTermMemories.embedding, cleanVector)})`;
-      const conditions = [
-        import_drizzle_orm4.eq(longTermMemories.agentId, this.runtime.agentId),
-        import_drizzle_orm4.eq(longTermMemories.entityId, entityId),
-        import_drizzle_orm4.sql`${longTermMemories.embedding} IS NOT NULL`
-      ];
-      if (matchThreshold > 0) {
-        conditions.push(import_drizzle_orm4.gte(similarity, matchThreshold));
-      }
+      const similarity = import_drizzle_orm4.sql`1 - (${import_drizzle_orm4.cosineDistance(conversationSummaryEmbeddings[this.embeddingDimension], queryEmbedding)})`;
       const results = await db.select({
-        memory: longTermMemories,
+        summary: conversationSummaries,
+        embedding: conversationSummaryEmbeddings[this.embeddingDimension],
         similarity
-      }).from(longTermMemories).where(import_drizzle_orm4.and(...conditions)).orderBy(import_drizzle_orm4.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, import_drizzle_orm4.eq(conversationSummaryEmbeddings.summaryId, conversationSummaries.id)).where(import_drizzle_orm4.and(import_drizzle_orm4.eq(conversationSummaries.agentId, this.runtime.agentId), import_drizzle_orm4.eq(conversationSummaries.entityId, entityId), import_drizzle_orm4.eq(conversationSummaries.roomId, roomId), import_drizzle_orm4.sql`${conversationSummaryEmbeddings[this.embeddingDimension]} IS NOT NULL`)).orderBy(import_drizzle_orm4.desc(similarity)).limit(limit * 2);
+      return results.map((r) => ({
+        ...mapDbRowToConversationSummary(r.summary),
+        embedding: r.embedding
       }));
     } catch (error) {
-      import_core.logger.warn({ error }, "Vector search failed, falling back to recent memories");
-      return this.getLongTermMemories(entityId, undefined, limit);
+      import_core4.logger.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: import_drizzle_orm4.sql`${conversationSummaries.accessCount} + 1`
+        }).where(import_drizzle_orm4.eq(conversationSummaries.id, id));
       }
-      grouped.get(memory.category)?.push(memory);
+      import_core4.logger.debug({ count: summaryIds.length }, "Updated summary access metadata");
+    } catch (error) {
+      import_core4.logger.error({ error }, "Failed to update summary access metadata");
     }
-    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}`);
+  }
+}
+
+// src/utils/embedding.ts
+var import_core5 = require("@elizaos/core");
+async function generateEmbedding(runtime, text3) {
+  try {
+    const embedding = await runtime.useModel(import_core5.ModelType.TEXT_EMBEDDING, text3);
+    return embedding;
+  } catch (error) {
+    import_core5.logger.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/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;
+  }
+}
+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);
     }
-    return sections.join(`
+  }
+  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, []);
+    }
+    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(`
+`);
+    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/summarization.ts
-var import_core2 = require("@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/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 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) {
-      import_core2.logger.debug("Skipping summarization: no message text");
-      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;
     }
-    const memoryService = runtime.getService("memory");
-    if (!memoryService) {
-      import_core2.logger.debug("Skipping summarization: memory service not available");
-      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 import_core6.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 config = memoryService.getConfig();
-    const currentMessageCount = await runtime.countMemories(message.roomId, false, "messages");
-    const existingSummary = await memoryService.getCurrentSessionSummary(message.roomId);
-    if (!existingSummary) {
-      const shouldSummarize = currentMessageCount >= config.shortTermSummarizationThreshold;
-      import_core2.logger.debug({
-        roomId: message.roomId,
-        currentMessageCount,
-        threshold: config.shortTermSummarizationThreshold,
-        shouldSummarize,
-        reason: "initial_summary_check"
-      }, "Summarization validation check");
-      return shouldSummarize;
+  };
+  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() {
+    import_core6.logger.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);
+    import_core6.logger.info({ config: this.config }, "MemoryService initialized");
+    if (this.config.enableBM25) {
+      await this.rebuildBM25Index();
+    }
+    this.isInitialized = true;
+  }
+  loadConfiguration() {
+    const threshold = this.runtime.getSetting("MEMORY_CONSOLIDATION_THRESHOLD");
+    if (threshold) {
+      this.config.consolidationThreshold = parseInt(threshold, 10);
+    }
+    const minConfidence = this.runtime.getSetting("MEMORY_MIN_CONFIDENCE");
+    if (minConfidence) {
+      this.config.minConfidence = parseFloat(minConfidence);
+    }
+    const enableVector = this.runtime.getSetting("MEMORY_ENABLE_VECTOR_SEARCH");
+    import_core6.logger.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;
+      import_core6.logger.info({ enabled: this.config.enableVectorSearch }, "Vector search explicitly configured via environment variable");
     } else {
-      const newMessageCount = currentMessageCount - existingSummary.lastMessageOffset;
-      const shouldUpdate = newMessageCount >= config.shortTermSummarizationInterval;
-      import_core2.logger.debug({
-        roomId: message.roomId,
-        currentMessageCount,
-        lastOffset: existingSummary.lastMessageOffset,
-        newMessageCount,
-        interval: config.shortTermSummarizationInterval,
-        shouldUpdate,
-        reason: "summary_update_check"
-      }, "Summarization validation check");
-      return shouldUpdate;
+      import_core6.logger.info({ enabled: this.config.enableVectorSearch }, "Vector search using default configuration");
     }
-  },
-  handler: async (runtime, message) => {
-    const memoryService = runtime.getService("memory");
-    if (!memoryService) {
-      import_core2.logger.error("MemoryService not found");
-      return;
+    const enableBM25 = this.runtime.getSetting("MEMORY_ENABLE_BM25");
+    import_core6.logger.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;
+      import_core6.logger.info({ enabled: this.config.enableBM25 }, "BM25 search explicitly configured via environment variable");
+    } else {
+      import_core6.logger.info({ enabled: this.config.enableBM25 }, "BM25 search using default configuration");
     }
-    const config = memoryService.getConfig();
-    const { roomId } = message;
+    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");
+    import_core6.logger.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;
+      import_core6.logger.info({ enabled: this.config.summarization.enabled }, "Summarization explicitly configured via environment variable");
+    } else {
+      import_core6.logger.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 {
-      import_core2.logger.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 newMessageCount = totalMessageCount - lastOffset;
-      const maxNewMessages = config.summaryMaxNewMessages || 50;
-      const messagesToFetch = Math.min(newMessageCount, maxNewMessages);
-      if (messagesToFetch === 0) {
-        import_core2.logger.debug("No new messages to summarize");
+      const embeddingModel = this.runtime.getModel(import_core6.ModelType.TEXT_EMBEDDING);
+      if (!embeddingModel) {
+        import_core6.logger.warn("No TEXT_EMBEDDING model registered. Embeddings will not be generated.");
         return;
       }
-      if (newMessageCount > maxNewMessages) {
-        import_core2.logger.warn(`Capping new messages at ${maxNewMessages} (${newMessageCount} available). Oldest messages will be skipped.`);
-      }
-      const newMessages = await runtime.getMemories({
-        tableName: "messages",
-        roomId,
-        count: messagesToFetch,
-        unique: false,
-        start: lastOffset
+      const testEmbedding = await this.runtime.useModel(import_core6.ModelType.TEXT_EMBEDDING, {
+        text: "test"
       });
-      if (newMessages.length === 0) {
-        import_core2.logger.debug("No new messages retrieved");
-        return;
+      if (!testEmbedding || !Array.isArray(testEmbedding)) {
+        throw new Error("Invalid embedding received from model");
       }
-      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(`
-`);
-      const state = await runtime.composeState(message);
-      let prompt;
-      let template;
-      if (existingSummary) {
-        template = updateSummarizationTemplate;
-        prompt = import_core2.composePromptFromState({
-          state: {
-            ...state,
-            existingSummary: existingSummary.summary,
-            existingTopics: existingSummary.topics?.join(", ") || "None",
-            newMessages: formattedMessages
-          },
-          template
-        });
-      } else {
-        template = initialSummarizationTemplate;
-        prompt = import_core2.composePromptFromState({
-          state: {
-            ...state,
-            recentMessages: formattedMessages
-          },
-          template
-        });
+      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;
+      import_core6.logger.info(`Memory embedding dimension set to ${dimension} (${dimensionColumn})`);
+    } catch (error) {
+      import_core6.logger.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) {
+        import_core6.logger.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) {
+        import_core6.logger.warn("Failed to regenerate embedding:", JSON.stringify(error));
       }
-      const response = await runtime.useModel(import_core2.ModelType.TEXT_LARGE, {
+    }
+    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) {
+      import_core6.logger.info({
+        oldMemoryId: contradictingMemory.id,
+        newContent: newMemory.content
+      }, "Contradiction detected, superseding old memory");
+      await this.updateLongTermMemory(contradictingMemory.id, {
+        isActive: false
+      });
+      const stored = await this.storeLongTermMemory({
+        ...newMemory,
+        supersedesId: contradictingMemory.id
+      });
+      import_core6.logger.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(import_core6.ModelType.TEXT_LARGE, {
         prompt,
-        maxTokens: config.summaryMaxTokens || 2500
+        temperature: 0.2
       });
-      const summaryResult = parseSummaryXML(response);
-      import_core2.logger.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, roomId, {
-          summary: summaryResult.summary,
-          messageCount: existingSummary.messageCount + sortedMessages.length,
-          lastMessageOffset: newOffset,
-          endTime,
-          topics: summaryResult.topics,
-          metadata: {
-            keyPoints: summaryResult.keyPoints
-          }
-        });
-        import_core2.logger.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
-          }
+      const responseText = typeof response === "string" ? response : JSON.stringify(response);
+      const result = import_core6.parseKeyValueXml(responseText);
+      if (!result) {
+        import_core6.logger.warn("Failed to parse contradiction detection XML response");
+        return null;
+      }
+      const hasContradiction = import_core6.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;
+        }
+      }
+      if (hasContradiction && contradictingMemoryIndex !== null) {
+        const contradictingMemory = existingMemories[contradictingMemoryIndex];
+        import_core6.logger.info({ reasoning: result.reasoning }, "Contradiction detected");
+        return contradictingMemory;
+      }
+      return null;
+    } catch (error) {
+      import_core6.logger.error({ error }, "Failed to detect contradiction");
+      return null;
+    }
+  }
+  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;
+    import_core6.logger.debug({
+      limit,
+      tokenBudget,
+      minConfidence,
+      similarityThreshold,
+      vectorSearchEnabled: this.config.enableVectorSearch,
+      bm25Enabled: this.config.enableBM25
+    }, "Searching long-term memories");
+    let vectorResults = [];
+    if (this.config.enableVectorSearch) {
+      import_core6.logger.debug("Vector search enabled, searching...");
+      vectorResults = await this.vectorSearch(params, similarityThreshold);
+    }
+    import_core6.logger.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);
+    import_core6.logger.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) {
+      import_core6.logger.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)) {
+        import_core6.logger.warn("Failed to generate query embedding");
+        return [];
+      }
+      return await this.longTermMemoryRepo.vectorSearch(params, queryEmbedding, similarityThreshold);
+    } catch (error) {
+      import_core6.logger.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) {
+          import_core6.logger.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) {
+      import_core6.logger.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 import_core7.BM25(documents, {
+        k1: 1.2,
+        b: 0.75,
+        stemming: true,
+        minLength: 2
+      });
+      import_core6.logger.info({ documentCount: documents.length }, "Rebuilt BM25 index");
+    } catch (error) {
+      import_core6.logger.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) {
+        import_core6.logger.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) {
+      import_core6.logger.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)) {
+        import_core6.logger.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) {
+      import_core6.logger.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) {
+      import_core6.logger.error("Failed to get most recent Level 1 summary:", JSON.stringify(error));
+      return null;
+    }
+  }
+}
+
+// src/evaluators/consolidation.ts
+var import_core8 = require("@elizaos/core");
+
+// 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) {
+      import_core8.logger.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) {
+        import_core8.logger.warn("Memory service not available for consolidation");
+        return;
+      }
+      const buffer = consolidationBuffers.get(roomId) || [];
+      if (buffer.length === 0) {
+        return;
+      }
+      import_core8.logger.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(`
+`);
+      const extractionPrompt = buildExtractionPrompt(conversationLog);
+      const originalSystemPrompt = runtime.character.system;
+      try {
+        runtime.character.system = CONSOLIDATION_SYSTEM_PROMPT;
+        import_core8.logger.debug("Calling LLM for memory extraction");
+        const response = await runtime.useModel(import_core8.ModelType.TEXT_LARGE, {
+          prompt: extractionPrompt,
+          temperature: 0.3
         });
-        import_core2.logger.info(`Created new summary for room ${roomId}: ${sortedMessages.length} messages summarized (offset: 0 → ${newOffset})`);
+        const consolidationResult = parseConsolidationResult(response);
+        import_core8.logger.debug({
+          reasoning: consolidationResult.reasoningTrace,
+          extracted: consolidationResult.extractedMemories.length
+        }, "Extraction complete");
+        const config = memoryService.getConfig();
+        const validMemories = consolidationResult.extractedMemories.filter((m) => m.confidence >= config.minConfidence);
+        import_core8.logger.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, []);
+        import_core8.logger.info({ roomId, stored: validMemories.length }, "Memory consolidation complete");
+      } finally {
+        runtime.character.system = originalSystemPrompt;
       }
     } catch (error) {
-      import_core2.logger.error({ error }, "Error during summarization:");
+      import_core8.logger.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(`
+`);
+      for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || !trimmedLine.startsWith("MEM|")) {
+          continue;
+        }
+        const parts = trimmedLine.split("|");
+        if (parts.length < 6) {
+          import_core8.logger.warn({ line: trimmedLine }, "Skipping malformed memory line (insufficient fields)");
+          continue;
+        }
+        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)) {
+          import_core8.logger.warn({ type, line: trimmedLine }, "Invalid memory type");
+          continue;
+        }
+        if (!category) {
+          import_core8.logger.warn({ line: trimmedLine }, "Missing category");
+          continue;
+        }
+        const confidence = parseFloat(confidenceStr);
+        if (isNaN(confidence) || confidence < 0 || confidence > 1) {
+          import_core8.logger.warn({ confidenceStr, line: trimmedLine }, "Invalid confidence value");
+          continue;
+        }
+        const isContradiction = isContradictionStr.toLowerCase() === "true";
+        if (!content) {
+          import_core8.logger.warn({ line: trimmedLine }, "Missing content");
+          continue;
+        }
+        const metadata = {
+          category
+        };
+        extractedMemories.push({
+          type,
+          content,
+          confidence,
+          isContradiction,
+          metadata
+        });
+      }
+    }
+    return {
+      reasoningTrace,
+      transientSummary: "",
+      extractedMemories
+    };
+  } catch (error) {
+    import_core8.logger.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/long-term-extraction.ts
-var import_core3 = require("@elizaos/core");
+// src/evaluators/summarization.ts
+var import_core9 = require("@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 ONLY the most important, persistent facts about the user that should be remembered long-term.
-
-# 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
-
-# STRICT EXTRACTION CRITERIA
-
-**DO EXTRACT** - Facts that are:
-- Explicitly stated personal information (name, role, profession)
-- Repeated patterns across multiple conversations (3+ occurrences)
-- Core preferences stated with clear emphasis ("I always prefer...", "I never want...")
-- Important ongoing projects or goals mentioned multiple times
-- Persistent technical constraints or requirements
-- Domain expertise demonstrated consistently
-- Custom terminology the user defines and uses repeatedly
-
-**DO NOT EXTRACT** - Facts that are:
-- One-time requests or isolated tasks (e.g., "generate an image or similar")
-- Single interactions without pattern repetition
-- Casual preferences from single occurrences
-- Testing or exploratory questions
-- Temporary context or transient information
-- General courtesy or social patterns (greetings, thank yous)
-- Random or playful requests that don't indicate lasting preference
-- Information that could change or is situational
-
-# Quality Standards
-- **Confidence threshold**: Only extract if confidence >= 0.8
-- **Persistence required**: Must see evidence across multiple messages or strong explicit statement
-- **Meaningful value**: Would this fact improve future interactions weeks from now?
-- **Not redundant**: Avoid if existing memories already cover this information
-
-# Instructions
-Extract ONLY truly important NEW information that meets the strict criteria above. For each item:
-- Determine which category it belongs to
-- Write a clear, factual statement
-- Assess confidence (0.0 to 1.0) - BE CONSERVATIVE
-- Require strong evidence before extraction
-
-**When in doubt, DO NOT extract.** It's better to miss temporary information than to clutter long-term memory.
-
-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)) {
-      import_core3.logger.warn(`Invalid memory category: ${category}`);
-      continue;
-    }
-    if (content && !isNaN(confidence)) {
-      extractions.push({ category, content, confidence });
-    }
-  }
-  return extractions;
+// 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 longTermExtractionEvaluator = {
-  name: "LONG_TERM_MEMORY_EXTRACTION",
-  description: "Extracts long-term facts about users from conversations",
-  similes: ["MEMORY_EXTRACTION", "FACT_LEARNING", "USER_PROFILING"],
-  alwaysRun: true,
+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)
+`;
+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) => {
-    import_core3.logger.debug(`Validating long-term memory extraction for message: ${message.content?.text}`);
-    if (message.entityId === runtime.agentId) {
-      import_core3.logger.debug("Skipping long-term memory extraction for agent's own message");
-      return false;
-    }
-    if (!message.content?.text) {
-      import_core3.logger.debug("Skipping long-term memory extraction for message without text");
-      return false;
-    }
     const memoryService = runtime.getService("memory");
     if (!memoryService) {
-      import_core3.logger.debug("MemoryService not found");
       return false;
     }
     const config = memoryService.getConfig();
-    if (!config.longTermExtractionEnabled) {
-      import_core3.logger.debug("Long-term memory extraction is disabled");
+    if (!config.summarization?.enabled) {
+      import_core9.logger.debug("Summarization is not enabled");
       return false;
     }
-    const currentMessageCount = await runtime.countMemories(message.roomId, false, "messages");
-    const shouldRun = await memoryService.shouldRunExtraction(message.entityId, message.roomId, currentMessageCount);
-    import_core3.logger.debug(`Should run extraction: ${shouldRun}`);
-    return shouldRun;
+    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;
+    import_core9.logger.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) {
+      import_core9.logger.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) {
-      import_core3.logger.error("MemoryService not found");
+      import_core9.logger.warn("MemoryService not available for summarization");
       return;
     }
     const config = memoryService.getConfig();
-    const { entityId, roomId } = message;
+    if (!config.summarization?.enabled) {
+      return;
+    }
+    const messageCount = summarizationCounters.get(message.roomId) || 0;
+    if (messageCount === 0) {
+      return;
+    }
+    import_core9.logger.info({
+      roomId: message.roomId,
+      messageCount
+    }, "Starting Level 1 summarization - pulling messages from database");
     try {
-      import_core3.logger.info(`Extracting long-term memories for entity ${entityId}`);
-      const recentMessages = await runtime.getMemories({
-        tableName: "messages",
-        roomId,
-        count: 20,
-        unique: false
-      });
-      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 = import_core3.composePromptFromState({
-        state: {
-          ...state,
-          recentMessages: formattedMessages,
-          existingMemories: formattedExisting
-        },
-        template: extractionTemplate
-      });
-      const response = await runtime.useModel(import_core3.ModelType.TEXT_LARGE, {
-        prompt
-      });
-      const extractions = parseMemoryExtractionXML(response);
-      import_core3.logger.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()
-            }
-          });
-          import_core3.logger.info(`Stored long-term memory: [${extraction.category}] ${extraction.content.substring(0, 50)}...`);
-        } else {
-          import_core3.logger.debug(`Skipped low-confidence memory: ${extraction.content} (confidence: ${extraction.confidence})`);
-        }
+      const previousSummary = await memoryService.getMostRecentLevel1Summary(message.roomId, message.entityId);
+      const messages = await fetchMessagesSinceLastSummary(runtime, message.roomId, previousSummary?.endTime);
+      if (messages.length === 0) {
+        import_core9.logger.warn({ roomId: message.roomId }, "No messages found for summarization");
+        return;
+      }
+      const summary = await createLevel1Summary(runtime, memoryService, messages, message.roomId, previousSummary);
+      if (summary) {
+        import_core9.logger.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);
       }
-      const currentMessageCount = await runtime.countMemories(roomId, false, "messages");
-      await memoryService.setLastExtractionCheckpoint(entityId, roomId, currentMessageCount);
-      import_core3.logger.debug(`Updated extraction checkpoint to ${currentMessageCount} for entity ${entityId} in room ${roomId}`);
     } catch (error) {
-      import_core3.logger.error({ error }, "Error during long-term memory extraction:");
+      import_core9.logger.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));
+  import_core9.logger.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;
+          }
+        }
+      }
+    }
+    return { summary, keyTopics, reasoningTrace };
+  } catch (error) {
+    import_core9.logger.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(`
+`);
+  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;
+    import_core9.logger.debug("Calling LLM for Level 1 summarization with timestamped conversation log");
+    const response = await runtime.useModel(import_core9.ModelType.TEXT_LARGE, {
+      prompt,
+      temperature: 0.3
+    });
+    runtime.character.system = originalSystemPrompt;
+    const { summary, keyTopics, reasoningTrace } = parseSummarizationResult(response);
+    if (!summary) {
+      import_core9.logger.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
+      }
+    };
+    return await memoryService.storeSummary(summaryData);
+  } catch (error) {
+    import_core9.logger.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) {
+    import_core9.logger.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;
+  }
+  import_core9.logger.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(import_core9.ModelType.TEXT_LARGE, {
+      prompt,
+      temperature: 0.3
+    });
+    runtime.character.system = originalSystemPrompt;
+    const { summary, keyTopics, reasoningTrace } = parseSummarizationResult(response);
+    if (!summary) {
+      import_core9.logger.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) {
+    import_core9.logger.error({ error, level }, "Failed to create higher-level summary");
+    runtime.character.system = originalSystemPrompt;
+    return null;
+  }
+}
 
-// src/providers/short-term-memory.ts
-var import_core4 = require("@elizaos/core");
-var shortTermMemoryProvider = {
-  name: "SHORT_TERM_MEMORY",
-  description: "Adaptive conversation context with smart summarization",
-  position: 95,
-  get: async (runtime, message, _state) => {
+// src/providers/long-term-memory.ts
+var import_core10 = require("@elizaos/core");
+var longTermMemoryProvider = {
+  name: "LONG_TERM_MEMORY",
+  description: "User knowledge and facts (semantic + procedural memory)",
+  position: 80,
+  get: async (runtime, message, state) => {
     try {
       const memoryService = runtime.getService("memory");
       if (!memoryService) {
+        import_core10.logger.warn("Memory service not available");
         return {
-          data: { summaries: [], recentMessages: [], mode: "disabled" },
+          data: {},
           values: {},
           text: ""
         };
       }
-      const { roomId } = message;
+      const entityId = message.entityId;
+      const roomId = message.roomId;
+      const query = typeof message.content === "string" ? message.content : message.content.text || JSON.stringify(message.content);
+      import_core10.logger.debug({
+        entityId,
+        roomId,
+        queryLength: query.length
+      }, "Retrieving unified memories");
       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([
-          import_core4.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 === import_core4.ChannelType.FEED || room.type === import_core4.ChannelType.THREAD : false;
-        const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
-          import_core4.formatMessages({
-            messages: dialogueMessages,
-            entities: entitiesData
-          }),
-          import_core4.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 [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(`
 `);
-            return `**Action Run ${runId.slice(0, 8)}**${thought ? ` - "${thought}"` : ""}
-${runText}`;
-          }).join(`
-
+        longTermSections.push(import_core10.addHeader("## Semantic Knowledge (Facts)", items));
+      }
+      if (proceduralMemories.length > 0) {
+        const items = proceduralMemories.map((m) => `- ${m.content}`).join(`
 `);
-          actionResultsText = formattedActionResults ? import_core4.addHeader("# Recent Action Executions", formattedActionResults) : "";
-        }
-        const recentPosts = formattedRecentPosts && formattedRecentPosts.length > 0 ? import_core4.addHeader("# Posts in Thread", formattedRecentPosts) : "";
-        const recentMessages = formattedRecentMessages && formattedRecentMessages.length > 0 ? import_core4.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"
-          };
-        }
-        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 = import_core4.formatMessages({
-            messages: [mostRecentMessage],
-            entities: entitiesData
-          });
-          if (formattedSingleMessage) {
-            recentMessage = formattedSingleMessage;
-          }
-        }
-        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 ? import_core4.addHeader("# Received Message", `${senderName}: ${receivedMessageContent}`) : "";
-        const focusHeader = hasReceivedMessage ? import_core4.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(`
+        longTermSections.push(import_core10.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(import_core10.addHeader("## Significant Past Events", items));
+      }
+      const longTermMemoriesText = longTermSections.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
-        };
-      } 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
-        });
-        const entitiesData = await import_core4.getEntityDetails({ runtime, roomId });
-        const room = await runtime.getRoom(roomId);
-        const isPostFormat = room?.type ? room.type === import_core4.ChannelType.FEED || room.type === import_core4.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 = import_core4.formatPosts({
-              messages: dialogueMessages,
-              entities: entitiesData,
-              conversationHeader: false
-            });
-          } else {
-            recentMessagesText = import_core4.formatMessages({
-              messages: dialogueMessages,
-              entities: entitiesData
-            });
-          }
-          if (recentMessagesText) {
-            recentMessagesText = import_core4.addHeader("# Recent Messages", recentMessagesText);
-          }
+      const data = {
+        semanticMemories,
+        proceduralMemories,
+        episodicMemories,
+        config: {
+          retrievalLimit: config.retrievalLimit,
+          tokenBudget: config.tokenBudget
         }
-        let summaryText = "";
-        if (currentSummary) {
-          const messageRange = `${currentSummary.messageCount} messages`;
-          const timeRange = new Date(currentSummary.startTime).toLocaleDateString();
-          summaryText = `**Previous Conversation** (${messageRange}, ${timeRange})
-`;
-          summaryText += currentSummary.summary;
-          if (currentSummary.topics && currentSummary.topics.length > 0) {
-            summaryText += `
-*Topics: ${currentSummary.topics.join(", ")}*`;
-          }
-          summaryText = import_core4.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 ? import_core4.addHeader("# Received Message", `${senderName}: ${receivedMessageContent}`) : "";
-        const focusHeader = hasReceivedMessage ? import_core4.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(`
+      };
+      const values = {
+        longTermMemories: longTermMemoriesText
+      };
+      const text3 = longTermMemoriesText;
+      import_core10.logger.info({
+        semanticCount: semanticMemories.length,
+        proceduralCount: proceduralMemories.length,
+        episodicCount: episodicMemories.length
+      }, "Retrieved long-term memory facts");
+      return {
+        data,
+        values,
+        text: text3
+      };
+    } catch (error) {
+      import_core10.logger.error({ error }, "Failed to retrieve long-term memories");
+      return {
+        data: {},
+        values: {
+          longTermMemories: ""
+        },
+        text: ""
+      };
+    }
+  }
+};
+
+// src/providers/recent-conversation-summary.ts
+var import_core11 = require("@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([
+    import_core11.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(`
 
 `);
-        return {
-          data: {
-            summaries: currentSummary ? [currentSummary] : [],
-            recentMessages: unsummarizedMessages,
-            mode: "summarized"
-          },
-          values: {
-            ...summaryText && { sessionSummaries: summaryText },
-            ...recentMessagesText && { recentMessages: recentMessagesText },
-            ...receivedMessageHeader && { receivedMessageHeader },
-            ...focusHeader && { focusHeader }
-          },
-          text: text4
-        };
+    const headerText = `# Conversation History (Compressed)
+**Session Started:** ${formatDateTime(sessionStartTime)}`;
+    compressedHistoryText = import_core11.addHeader(headerText, summaryItems);
+    import_core11.logger.debug({
+      summaryCount: summaries.length,
+      totalTokens: summaries.reduce((sum, s) => sum + s.tokenCount, 0),
+      lastSummarizedIndex
+    }, "Using hierarchical summaries for compressed history");
+  } catch (error) {
+    import_core11.logger.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)) {
+      import_core11.logger.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;
       }
+    }
+    bufferMessages = dialogueMessages.slice(overlapStartIndex);
+    import_core11.logger.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;
+    import_core11.logger.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 === import_core11.ChannelType.FEED || room.type === import_core11.ChannelType.THREAD : false;
+  const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
+    import_core11.formatMessages({
+      messages: bufferMessages,
+      entities
+    }),
+    import_core11.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 ? import_core11.addHeader(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 ? import_core11.addHeader("# Current Message", `**From ${senderName}:** ${receivedMessageContent}`) : "";
+  const focusHeader = hasReceivedMessage ? import_core11.addHeader("# 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 === import_core11.ChannelType.FEED || room.type === import_core11.ChannelType.THREAD : false;
+      const values = {
+        compressedHistory: compressedHistoryText,
+        recentMessages: recentBufferHeader,
+        receivedMessage: receivedMessageHeader,
+        focusInstruction: focusHeader,
+        recentPosts: isPostFormat ? recentBufferHeader : ""
+      };
+      import_core11.logger.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) {
-      import_core4.logger.error({ error }, "Error in shortTermMemoryProvider:");
+      import_core11.logger.error({ error }, "Error in recentContextProvider");
       return {
-        data: { summaries: [], recentMessages: [], mode: "error" },
-        values: {},
-        text: "Error retrieving conversation context."
+        data: {
+          dialogueMessages: [],
+          messageCount: 0,
+          lastSummarizedIndex: -1,
+          config: getProviderConfig(runtime)
+        },
+        values: {
+          compressedHistory: "",
+          recentMessages: "",
+          receivedMessage: "",
+          focusInstruction: "",
+          recentPosts: ""
+        },
+        text: "Error retrieving context."
       };
     }
   }
 };
 
-// src/providers/long-term-memory.ts
-var import_core5 = require("@elizaos/core");
-var longTermMemoryProvider = {
-  name: "LONG_TERM_MEMORY",
-  description: "Persistent facts and preferences about the user",
-  position: 50,
-  get: async (runtime, message, _state) => {
-    try {
-      const memoryService = runtime.getService("memory");
-      if (!memoryService) {
-        return {
-          data: { memories: [] },
-          values: { longTermMemories: "" },
-          text: ""
-        };
-      }
-      const { entityId } = message;
-      if (entityId === runtime.agentId) {
-        return {
-          data: { memories: [] },
-          values: { longTermMemories: "" },
-          text: ""
-        };
-      }
-      const memories = await memoryService.getLongTermMemories(entityId, undefined, 25);
-      if (memories.length === 0) {
-        return {
-          data: { memories: [] },
-          values: { longTermMemories: "" },
-          text: ""
-        };
-      }
-      const formattedMemories = await memoryService.getFormattedLongTermMemories(entityId);
-      const text4 = import_core5.addHeader("# 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);
+// src/providers/action-results.ts
+var import_core12 = require("@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 ? import_core12.addHeader("# 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);
+      import_core12.logger.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) {
-      import_core5.logger.error({ error }, "Error in longTermMemoryProvider:");
+      import_core12.logger.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;
 
-//# debugId=3C20A9F0BA14039464756E2164756E21
+//# debugId=CCBB98EF3F397EB764756E2164756E21