@elizaos/plugin-memory 1.1.0 → 1.1.2

package/dist/node/index.node.js

@@ -12,46 +12,16 @@ var __export = (target, all) => {
 // src/services/memory-service.ts
 import {
   Service,
-  logger as logger4,
-  ModelType as ModelType2,
-  parseKeyValueXml,
-  parseBooleanFromText
+  logger
 } from "@elizaos/core";
-import { BM25 } from "@elizaos/core";
-
-// src/types/index.ts
-var MEMORY_DIMENSION_MAP = {
-  384: "dim384",
-  512: "dim512",
-  768: "dim768",
-  1024: "dim1024",
-  1536: "dim1536",
-  3072: "dim3072"
-};
-var MemoryType;
-((MemoryType2) => {
-  MemoryType2["EPISODIC"] = "EPISODIC";
-  MemoryType2["SEMANTIC"] = "SEMANTIC";
-  MemoryType2["PROCEDURAL"] = "PROCEDURAL";
-})(MemoryType ||= {});
-var DecayFunction;
-((DecayFunction2) => {
-  DecayFunction2["EXPONENTIAL"] = "EXPONENTIAL";
-  DecayFunction2["LINEAR"] = "LINEAR";
-  DecayFunction2["NONE"] = "NONE";
-})(DecayFunction ||= {});
-
-// src/repositories/long-term-memory.ts
-import { logger } from "@elizaos/core";
-import { eq, and, desc, sql as sql3, cosineDistance, gte, or, isNull } from "drizzle-orm";
+import { eq, and, desc, sql as sql4, cosineDistance, gte } from "drizzle-orm";
 
 // src/schemas/index.ts
 var exports_schemas = {};
 __export(exports_schemas, {
-  longTermMemoryEmbeddings: () => longTermMemoryEmbeddings,
-  longTermMemories: () => longTermMemories,
-  conversationSummaryEmbeddings: () => conversationSummaryEmbeddings,
-  conversationSummaries: () => conversationSummaries
+  sessionSummaries: () => sessionSummaries,
+  memoryAccessLogs: () => memoryAccessLogs,
+  longTermMemories: () => longTermMemories
 });
 
 // src/schemas/long-term-memories.ts
@@ -64,2385 +34,1149 @@ import {
   real,
   index,
   varchar,
-  timestamp,
-  boolean,
-  vector,
-  foreignKey
+  timestamp
 } from "drizzle-orm/pg-core";
-import { VECTOR_DIMS } from "@elizaos/core";
 var longTermMemories = pgTable("long_term_memories", {
   id: varchar("id", { length: 36 }).primaryKey(),
   agentId: varchar("agent_id", { length: 36 }).notNull(),
   entityId: varchar("entity_id", { length: 36 }).notNull(),
-  roomId: varchar("room_id", { length: 36 }),
-  type: text("type").notNull(),
+  category: text("category").notNull(),
   content: text("content").notNull(),
-  embeddingContext: text("embedding_context").notNull(),
-  confidence: real("confidence").notNull().default(1),
-  decayRate: real("decay_rate").notNull().default(0.01),
-  decayFunction: text("decay_function").notNull().default("EXPONENTIAL"),
+  metadata: jsonb("metadata"),
+  embedding: real("embedding").array(),
+  confidence: real("confidence").default(1),
+  source: text("source"),
   createdAt: timestamp("created_at").default(sql`now()`).notNull(),
+  updatedAt: timestamp("updated_at").default(sql`now()`).notNull(),
   lastAccessedAt: timestamp("last_accessed_at"),
-  accessCount: integer("access_count").default(0).notNull(),
-  isActive: boolean("is_active").default(true).notNull(),
-  source: jsonb("source").notNull().default({}),
-  metadata: jsonb("metadata").notNull().default({}),
-  supersedesId: varchar("supersedes_id", { length: 36 })
+  accessCount: integer("access_count").default(0)
 }, (table) => ({
-  agentEntityIdx: index("ltm_agent_entity_idx").on(table.agentId, table.entityId),
-  typeIdx: index("ltm_type_idx").on(table.type),
-  roomIdx: index("ltm_room_idx").on(table.roomId),
-  activeIdx: index("ltm_active_idx").on(table.isActive),
-  confidenceIdx: index("ltm_confidence_idx").on(table.confidence),
-  createdAtIdx: index("ltm_created_at_idx").on(table.createdAt),
-  lastAccessedIdx: index("ltm_last_accessed_idx").on(table.lastAccessedAt),
-  agentEntityActiveConfidenceIdx: index("ltm_agent_entity_active_conf_idx").on(table.agentId, table.entityId, table.isActive, table.confidence)
+  agentEntityIdx: index("long_term_memories_agent_entity_idx").on(table.agentId, table.entityId),
+  categoryIdx: index("long_term_memories_category_idx").on(table.category),
+  confidenceIdx: index("long_term_memories_confidence_idx").on(table.confidence),
+  createdAtIdx: index("long_term_memories_created_at_idx").on(table.createdAt)
 }));
-var longTermMemoryEmbeddings = pgTable("long_term_memory_embeddings", {
-  id: varchar("id", { length: 36 }).primaryKey(),
-  memoryId: varchar("memory_id", { length: 36 }).notNull().references(() => longTermMemories.id, { onDelete: "cascade" }),
-  dim384: vector("dim_384", { dimensions: VECTOR_DIMS.SMALL }),
-  dim512: vector("dim_512", { dimensions: VECTOR_DIMS.MEDIUM }),
-  dim768: vector("dim_768", { dimensions: VECTOR_DIMS.LARGE }),
-  dim1024: vector("dim_1024", { dimensions: VECTOR_DIMS.XL }),
-  dim1536: vector("dim_1536", { dimensions: VECTOR_DIMS.XXL }),
-  dim3072: vector("dim_3072", { dimensions: VECTOR_DIMS.XXXL }),
-  createdAt: timestamp("created_at").default(sql`now()`).notNull()
-}, (table) => [
-  index("idx_ltm_embedding_memory_id").on(table.memoryId),
-  foreignKey({
-    name: "fk_ltm_embedding_memory",
-    columns: [table.memoryId],
-    foreignColumns: [longTermMemories.id]
-  }).onDelete("cascade")
-]);
-// src/schemas/conversation-summaries.ts
+// src/schemas/session-summaries.ts
 import { sql as sql2 } from "drizzle-orm";
 import {
   pgTable as pgTable2,
   text as text2,
   integer as integer2,
   jsonb as jsonb2,
+  real as real2,
   index as index2,
   varchar as varchar2,
-  timestamp as timestamp2,
-  vector as vector2,
-  foreignKey as foreignKey2
+  timestamp as timestamp2
 } from "drizzle-orm/pg-core";
-import { VECTOR_DIMS as VECTOR_DIMS2 } from "@elizaos/core";
-var conversationSummaries = pgTable2("conversation_summaries", {
+var sessionSummaries = pgTable2("session_summaries", {
   id: varchar2("id", { length: 36 }).primaryKey(),
   agentId: varchar2("agent_id", { length: 36 }).notNull(),
-  entityId: varchar2("entity_id", { length: 36 }).notNull(),
   roomId: varchar2("room_id", { length: 36 }).notNull(),
-  level: integer2("level").notNull().default(1),
-  parentSummaryId: varchar2("parent_summary_id", { length: 36 }),
-  content: text2("content").notNull(),
-  tokenCount: integer2("token_count").notNull(),
+  entityId: varchar2("entity_id", { length: 36 }),
+  summary: text2("summary").notNull(),
+  messageCount: integer2("message_count").notNull(),
+  lastMessageOffset: integer2("last_message_offset").notNull().default(0),
   startTime: timestamp2("start_time").notNull(),
   endTime: timestamp2("end_time").notNull(),
-  sourceCount: integer2("source_count").notNull(),
-  sourceIds: jsonb2("source_ids").notNull().default([]),
+  topics: jsonb2("topics"),
+  metadata: jsonb2("metadata"),
+  embedding: real2("embedding").array(),
   createdAt: timestamp2("created_at").default(sql2`now()`).notNull(),
-  lastAccessedAt: timestamp2("last_accessed_at"),
-  accessCount: integer2("access_count").default(0).notNull(),
-  metadata: jsonb2("metadata").notNull().default({})
+  updatedAt: timestamp2("updated_at").default(sql2`now()`).notNull()
 }, (table) => ({
-  agentEntityRoomIdx: index2("cs_agent_entity_room_idx").on(table.agentId, table.entityId, table.roomId),
-  levelIdx: index2("cs_level_idx").on(table.level),
-  parentIdx: index2("cs_parent_idx").on(table.parentSummaryId),
-  timeRangeIdx: index2("cs_time_range_idx").on(table.startTime, table.endTime),
-  createdAtIdx: index2("cs_created_at_idx").on(table.createdAt),
-  lastAccessedIdx: index2("cs_last_accessed_idx").on(table.lastAccessedAt),
-  entityRoomLevelTimeIdx: index2("cs_entity_room_level_time_idx").on(table.entityId, table.roomId, table.level, table.createdAt)
+  agentRoomIdx: index2("session_summaries_agent_room_idx").on(table.agentId, table.roomId),
+  entityIdx: index2("session_summaries_entity_idx").on(table.entityId),
+  startTimeIdx: index2("session_summaries_start_time_idx").on(table.startTime)
 }));
-var conversationSummaryEmbeddings = pgTable2("conversation_summary_embeddings", {
-  id: varchar2("id", { length: 36 }).primaryKey(),
-  summaryId: varchar2("summary_id", { length: 36 }).notNull().references(() => conversationSummaries.id, { onDelete: "cascade" }),
-  dim384: vector2("dim_384", { dimensions: VECTOR_DIMS2.SMALL }),
-  dim512: vector2("dim_512", { dimensions: VECTOR_DIMS2.MEDIUM }),
-  dim768: vector2("dim_768", { dimensions: VECTOR_DIMS2.LARGE }),
-  dim1024: vector2("dim_1024", { dimensions: VECTOR_DIMS2.XL }),
-  dim1536: vector2("dim_1536", { dimensions: VECTOR_DIMS2.XXL }),
-  dim3072: vector2("dim_3072", { dimensions: VECTOR_DIMS2.XXXL }),
-  createdAt: timestamp2("created_at").default(sql2`now()`).notNull()
-}, (table) => [
-  index2("idx_cs_embedding_summary_id").on(table.summaryId),
-  foreignKey2({
-    name: "fk_cs_embedding_summary",
-    columns: [table.summaryId],
-    foreignColumns: [conversationSummaries.id]
-  }).onDelete("cascade")
-]);
-// src/utils/db-mapping.ts
-function mapDbRowToLongTermMemory(row) {
-  return {
-    id: row.id,
-    agentId: row.agentId,
-    entityId: row.entityId,
-    roomId: row.roomId,
-    type: row.type,
-    content: row.content,
-    embeddingContext: row.embeddingContext,
-    embedding: row.embedding,
-    confidence: row.confidence,
-    decayRate: row.decayRate,
-    decayFunction: row.decayFunction,
-    createdAt: row.createdAt,
-    lastAccessedAt: row.lastAccessedAt,
-    accessCount: row.accessCount,
-    isActive: row.isActive,
-    source: row.source,
-    metadata: row.metadata,
-    supersedesId: row.supersedesId
-  };
-}
-function mapDbRowToConversationSummary(row) {
-  return {
-    id: row.id,
-    agentId: row.agentId,
-    entityId: row.entityId,
-    roomId: row.roomId,
-    level: row.level,
-    parentSummaryId: row.parentSummaryId,
-    content: row.content,
-    embedding: row.embedding,
-    tokenCount: row.tokenCount,
-    startTime: row.startTime,
-    endTime: row.endTime,
-    sourceCount: row.sourceCount,
-    sourceIds: row.sourceIds,
-    createdAt: row.createdAt,
-    lastAccessedAt: row.lastAccessedAt,
-    accessCount: row.accessCount,
-    metadata: row.metadata || {}
-  };
-}
-
-// src/repositories/long-term-memory.ts
-class LongTermMemoryRepository {
-  runtime;
-  embeddingDimension;
-  constructor(runtime, embeddingDimension) {
-    this.runtime = runtime;
-    this.embeddingDimension = embeddingDimension;
+// src/schemas/memory-access-logs.ts
+import { sql as sql3 } from "drizzle-orm";
+import { pgTable as pgTable3, text as text3, integer as integer3, real as real3, index as index3, varchar as varchar3, timestamp as timestamp3 } from "drizzle-orm/pg-core";
+var memoryAccessLogs = pgTable3("memory_access_logs", {
+  id: varchar3("id", { length: 36 }).primaryKey(),
+  agentId: varchar3("agent_id", { length: 36 }).notNull(),
+  memoryId: varchar3("memory_id", { length: 36 }).notNull(),
+  memoryType: text3("memory_type").notNull(),
+  accessedAt: timestamp3("accessed_at").default(sql3`now()`).notNull(),
+  roomId: varchar3("room_id", { length: 36 }),
+  relevanceScore: real3("relevance_score"),
+  wasUseful: integer3("was_useful")
+}, (table) => ({
+  memoryIdx: index3("memory_access_logs_memory_idx").on(table.memoryId),
+  agentIdx: index3("memory_access_logs_agent_idx").on(table.agentId),
+  accessedAtIdx: index3("memory_access_logs_accessed_at_idx").on(table.accessedAt)
+}));
+// src/services/memory-service.ts
+class MemoryService extends Service {
+  static serviceType = "memory";
+  sessionMessageCounts;
+  memoryConfig;
+  lastExtractionCheckpoints;
+  capabilityDescription = "Advanced memory management with short-term summarization and long-term persistent facts";
+  constructor(runtime) {
+    super(runtime);
+    this.sessionMessageCounts = new Map;
+    this.lastExtractionCheckpoints = new Map;
+    this.memoryConfig = {
+      shortTermSummarizationThreshold: 16,
+      shortTermRetainRecent: 6,
+      shortTermSummarizationInterval: 10,
+      longTermExtractionEnabled: true,
+      longTermVectorSearchEnabled: false,
+      longTermConfidenceThreshold: 0.85,
+      longTermExtractionThreshold: 30,
+      longTermExtractionInterval: 10,
+      summaryModelType: "TEXT_LARGE",
+      summaryMaxTokens: 2500,
+      summaryMaxNewMessages: 20
+    };
+  }
+  static async start(runtime) {
+    const service = new MemoryService(runtime);
+    await service.initialize(runtime);
+    return service;
+  }
+  async stop() {
+    logger.info("MemoryService stopped");
   }
-  async getDb() {
-    const adapter = this.runtime.adapter || this.runtime;
-    const db = adapter.db;
+  async initialize(runtime) {
+    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);
+    }
+    logger.debug({
+      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;
     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 isReady = await adapter.isReady();
-      if (!isReady) {
-        logger.warn("[LongTermMemoryRepository] Database not ready, attempting reconnect...");
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        const stillNotReady = await adapter.isReady();
-        if (stillNotReady === false) {
-          throw new Error("Database connection lost and could not reconnect");
-        }
-      }
+      const checkpoint = await this.runtime.getCache(key);
+      const messageCount = checkpoint ?? 0;
+      this.lastExtractionCheckpoints.set(key, messageCount);
+      return messageCount;
     } catch (error) {
-      logger.error("[LongTermMemoryRepository] Database health check failed:", error);
-      throw new Error("Database connection health check failed");
+      logger.warn({ error }, "Failed to get extraction checkpoint from cache");
+      return 0;
+    }
+  }
+  async setLastExtractionCheckpoint(entityId, roomId, messageCount) {
+    const key = this.getExtractionKey(entityId, roomId);
+    this.lastExtractionCheckpoints.set(key, messageCount);
+    try {
+      await this.runtime.setCache(key, messageCount);
+      logger.debug(`Set extraction checkpoint for ${entityId} in room ${roomId} at message count ${messageCount}`);
+    } catch (error) {
+      logger.error({ error }, "Failed to persist extraction checkpoint to cache");
     }
-    return db;
   }
-  async insert(memory, embedding) {
-    const db = await this.getDb();
+  async shouldRunExtraction(entityId, roomId, currentMessageCount) {
+    const threshold = this.memoryConfig.longTermExtractionThreshold;
+    const interval = this.memoryConfig.longTermExtractionInterval;
+    if (currentMessageCount < threshold) {
+      return false;
+    }
+    const lastCheckpoint = await this.getLastExtractionCheckpoint(entityId, roomId);
+    const currentCheckpoint = Math.floor(currentMessageCount / interval) * interval;
+    const shouldRun = currentMessageCount >= threshold && currentCheckpoint > lastCheckpoint;
+    logger.debug({
+      entityId,
+      roomId,
+      currentMessageCount,
+      threshold,
+      interval,
+      lastCheckpoint,
+      currentCheckpoint,
+      shouldRun
+    }, "Extraction check");
+    return shouldRun;
+  }
+  async storeLongTermMemory(memory) {
+    const db = this.getDb();
     const id = crypto.randomUUID();
     const now = new Date;
     const newMemory = {
       id,
       createdAt: now,
-      lastAccessedAt: null,
+      updatedAt: now,
       accessCount: 0,
-      isActive: true,
-      embedding: embedding || [],
       ...memory
     };
-    await db.transaction(async (tx) => {
-      await tx.insert(longTermMemories).values({
+    try {
+      await db.insert(longTermMemories).values({
         id: newMemory.id,
         agentId: newMemory.agentId,
         entityId: newMemory.entityId,
-        roomId: newMemory.roomId || null,
-        type: newMemory.type,
+        category: newMemory.category,
         content: newMemory.content,
-        embeddingContext: newMemory.embeddingContext,
+        metadata: newMemory.metadata || {},
+        embedding: newMemory.embedding,
         confidence: newMemory.confidence,
-        decayRate: newMemory.decayRate,
-        decayFunction: newMemory.decayFunction,
-        createdAt: now,
-        lastAccessedAt: null,
-        accessCount: 0,
-        isActive: true,
         source: newMemory.source,
-        metadata: newMemory.metadata,
-        supersedesId: newMemory.supersedesId || null
+        accessCount: newMemory.accessCount,
+        createdAt: now,
+        updatedAt: now,
+        lastAccessedAt: newMemory.lastAccessedAt
       });
-      if (embedding && this.embeddingDimension) {
-        const embeddingValues = {
-          id: crypto.randomUUID(),
-          memoryId: id,
-          createdAt: now
-        };
-        embeddingValues[this.embeddingDimension] = embedding;
-        await tx.insert(longTermMemoryEmbeddings).values(embeddingValues);
-      }
-    });
-    logger.info({
-      id: newMemory.id,
-      type: newMemory.type,
-      entityId: newMemory.entityId,
-      confidence: newMemory.confidence
-    }, "Stored new long-term memory");
-    return newMemory;
-  }
-  async findById(id) {
-    const db = await this.getDb();
-    const results = await db.select().from(longTermMemories).where(eq(longTermMemories.id, id)).limit(1);
-    if (results.length === 0) {
-      return null;
+    } catch (error) {
+      logger.error({ error }, "Failed to store long-term memory");
+      throw error;
     }
-    return mapDbRowToLongTermMemory(results[0]);
-  }
-  async update(id, updates, newEmbedding) {
-    const db = await this.getDb();
-    const updateData = {};
-    if (updates.content !== undefined)
-      updateData.content = updates.content;
-    if (updates.embeddingContext !== undefined)
-      updateData.embeddingContext = updates.embeddingContext;
-    if (updates.confidence !== undefined)
-      updateData.confidence = updates.confidence;
-    if (updates.decayRate !== undefined)
-      updateData.decayRate = updates.decayRate;
-    if (updates.decayFunction !== undefined)
-      updateData.decayFunction = updates.decayFunction;
-    if (updates.lastAccessedAt !== undefined)
-      updateData.lastAccessedAt = updates.lastAccessedAt;
-    if (updates.accessCount !== undefined)
-      updateData.accessCount = updates.accessCount;
-    if (updates.isActive !== undefined)
-      updateData.isActive = updates.isActive;
-    if (updates.source !== undefined)
-      updateData.source = updates.source;
-    if (updates.metadata !== undefined)
-      updateData.metadata = updates.metadata;
-    if (updates.supersedesId !== undefined)
-      updateData.supersedesId = updates.supersedesId;
-    await db.transaction(async (tx) => {
-      await tx.update(longTermMemories).set(updateData).where(eq(longTermMemories.id, id));
-      if (newEmbedding && this.embeddingDimension) {
-        const embeddingUpdate = {};
-        embeddingUpdate[this.embeddingDimension] = newEmbedding;
-        await tx.update(longTermMemoryEmbeddings).set(embeddingUpdate).where(eq(longTermMemoryEmbeddings.memoryId, id));
-      }
-    });
-    logger.info({ id }, "Updated long-term memory");
-  }
-  async delete(id) {
-    const db = await this.getDb();
-    await db.delete(longTermMemories).where(eq(longTermMemories.id, id));
-    logger.info({ id }, "Deleted long-term memory");
+    logger.info(`Stored long-term memory: ${newMemory.category} for entity ${newMemory.entityId}`);
+    return newMemory;
   }
-  async findByEntity(entityId, type, limit = 20, includeInactive = false) {
-    const db = await this.getDb();
+  async getLongTermMemories(entityId, category, limit = 10) {
+    const db = this.getDb();
     const conditions = [
       eq(longTermMemories.agentId, this.runtime.agentId),
       eq(longTermMemories.entityId, entityId)
     ];
-    if (!includeInactive) {
-      conditions.push(eq(longTermMemories.isActive, true));
-    }
-    if (type) {
-      conditions.push(eq(longTermMemories.type, type));
-    }
-    const results = await db.select().from(longTermMemories).where(and(...conditions)).orderBy(desc(longTermMemories.confidence), desc(longTermMemories.createdAt)).limit(limit);
-    return results.map((row) => mapDbRowToLongTermMemory(row));
-  }
-  async vectorSearch(params, queryEmbedding, similarityThreshold = 0.3) {
-    if (!this.embeddingDimension) {
-      logger.warn("Embedding dimension not set, skipping vector search");
-      return [];
+    if (category) {
+      conditions.push(eq(longTermMemories.category, category));
     }
-    const db = await this.getDb();
-    try {
-      const similarity = sql3`1 - (${cosineDistance(longTermMemoryEmbeddings[this.embeddingDimension], queryEmbedding)})`;
-      const conditions = [
-        eq(longTermMemories.agentId, this.runtime.agentId),
-        eq(longTermMemories.entityId, params.entityId),
-        sql3`${longTermMemoryEmbeddings[this.embeddingDimension]} IS NOT NULL`,
-        gte(similarity, similarityThreshold)
-      ];
-      if (params.minConfidence) {
-        conditions.push(gte(longTermMemories.confidence, params.minConfidence));
-      }
-      if (!params.includeInactive) {
-        conditions.push(eq(longTermMemories.isActive, true));
-      }
-      if (params.type) {
-        conditions.push(eq(longTermMemories.type, params.type));
-      }
-      if (params.roomId) {
-        conditions.push(or(eq(longTermMemories.roomId, params.roomId), isNull(longTermMemories.roomId)));
-      }
-      const results = await db.select({
-        memory: longTermMemories,
-        embedding: longTermMemoryEmbeddings[this.embeddingDimension],
-        similarity
-      }).from(longTermMemories).innerJoin(longTermMemoryEmbeddings, eq(longTermMemoryEmbeddings.memoryId, longTermMemories.id)).where(and(...conditions)).orderBy(desc(similarity)).limit(params.limit || 20);
-      return results.map((row) => ({
-        ...mapDbRowToLongTermMemory(row.memory),
-        embedding: row.embedding,
-        relevanceScore: row.similarity,
-        activationScore: 0,
-        finalScore: 0
-      }));
-    } catch (error) {
-      logger.error("Failed to execute vector search:", JSON.stringify(error));
-      return [];
-    }
-  }
-  async fetchAllActive() {
-    const db = await this.getDb();
-    const memories = await db.select().from(longTermMemories).where(and(eq(longTermMemories.agentId, this.runtime.agentId), eq(longTermMemories.isActive, true)));
-    return memories.map((row) => ({
+    const results = await db.select().from(longTermMemories).where(and(...conditions)).orderBy(desc(longTermMemories.confidence), desc(longTermMemories.updatedAt)).limit(limit);
+    return results.map((row) => ({
       id: row.id,
+      agentId: row.agentId,
+      entityId: row.entityId,
+      category: row.category,
       content: row.content,
-      embeddingContext: row.embeddingContext
+      metadata: row.metadata,
+      embedding: row.embedding,
+      confidence: row.confidence,
+      source: row.source,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+      lastAccessedAt: row.lastAccessedAt,
+      accessCount: row.accessCount
     }));
   }
-  async updateAccessMetadata(memoryIds) {
-    if (memoryIds.length === 0)
-      return;
-    const db = await this.getDb();
-    const now = new Date;
-    try {
-      for (const id of memoryIds) {
-        await db.update(longTermMemories).set({
-          lastAccessedAt: now,
-          accessCount: sql3`${longTermMemories.accessCount} + 1`
-        }).where(eq(longTermMemories.id, id));
-      }
-      logger.debug({ count: memoryIds.length }, "Updated access metadata");
-    } catch (error) {
-      logger.error({ error }, "Failed to update access metadata");
+  async updateLongTermMemory(id, entityId, updates) {
+    const db = this.getDb();
+    const updateData = {
+      updatedAt: new Date
+    };
+    if (updates.content !== undefined) {
+      updateData.content = updates.content;
+    }
+    if (updates.metadata !== undefined) {
+      updateData.metadata = updates.metadata;
+    }
+    if (updates.confidence !== undefined) {
+      updateData.confidence = updates.confidence;
+    }
+    if (updates.embedding !== undefined) {
+      updateData.embedding = updates.embedding;
+    }
+    if (updates.lastAccessedAt !== undefined) {
+      updateData.lastAccessedAt = updates.lastAccessedAt;
+    }
+    if (updates.accessCount !== undefined) {
+      updateData.accessCount = updates.accessCount;
     }
+    await db.update(longTermMemories).set(updateData).where(and(eq(longTermMemories.id, id), eq(longTermMemories.agentId, this.runtime.agentId), eq(longTermMemories.entityId, entityId)));
+    logger.info(`Updated long-term memory: ${id} for entity ${entityId}`);
   }
-}
-
-// src/repositories/conversation-summary.ts
-import { logger as logger2 } from "@elizaos/core";
-import { eq as eq2, and as and2, desc as desc2, sql as sql4, cosineDistance as cosineDistance2 } from "drizzle-orm";
-class ConversationSummaryRepository {
-  runtime;
-  embeddingDimension;
-  constructor(runtime, embeddingDimension) {
-    this.runtime = runtime;
-    this.embeddingDimension = embeddingDimension;
+  async deleteLongTermMemory(id, entityId) {
+    const db = this.getDb();
+    await db.delete(longTermMemories).where(and(eq(longTermMemories.id, id), eq(longTermMemories.agentId, this.runtime.agentId), eq(longTermMemories.entityId, entityId)));
+    logger.info(`Deleted long-term memory: ${id} for entity ${entityId}`);
   }
-  async getDb() {
-    const adapter = this.runtime.adapter || this.runtime;
-    const db = adapter.db;
-    if (!db) {
-      throw new Error("Database not available");
-    }
-    try {
-      const isReady = await adapter.isReady();
-      if (!isReady) {
-        logger2.warn("[ConversationSummaryRepository] Database not ready, attempting reconnect...");
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        const stillNotReady = await adapter.isReady();
-        if (stillNotReady === false) {
-          throw new Error("Database connection lost and could not reconnect");
-        }
-      }
-    } catch (error) {
-      logger2.error("[ConversationSummaryRepository] Database health check failed:", error);
-      throw new Error("Database connection health check failed");
+  async getCurrentSessionSummary(roomId) {
+    const db = this.getDb();
+    const results = await db.select().from(sessionSummaries).where(and(eq(sessionSummaries.agentId, this.runtime.agentId), eq(sessionSummaries.roomId, roomId))).orderBy(desc(sessionSummaries.updatedAt)).limit(1);
+    if (results.length === 0) {
+      return null;
     }
-    return db;
+    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
+    };
   }
-  async insert(summary, embedding) {
-    const db = await this.getDb();
+  async storeSessionSummary(summary) {
+    const db = this.getDb();
     const id = crypto.randomUUID();
     const now = new Date;
     const newSummary = {
       id,
       createdAt: now,
-      lastAccessedAt: null,
-      accessCount: 0,
-      embedding: embedding || [],
+      updatedAt: now,
       ...summary
     };
-    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);
-      }
-    });
-    logger2.info({
+    await db.insert(sessionSummaries).values({
       id: newSummary.id,
-      level: newSummary.level,
-      tokenCount: newSummary.tokenCount,
-      sourceCount: newSummary.sourceCount
-    }, "Stored conversation summary");
+      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
+    });
+    logger.info(`Stored session summary for room ${newSummary.roomId}`);
     return newSummary;
   }
-  async findByLevel(roomId, level) {
-    const db = await this.getDb();
-    const results = await db.select().from(conversationSummaries).where(and2(eq2(conversationSummaries.agentId, this.runtime.agentId), eq2(conversationSummaries.roomId, roomId), eq2(conversationSummaries.level, level))).orderBy(desc2(conversationSummaries.createdAt));
-    return results.map((r) => mapDbRowToConversationSummary(r));
+  async 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(and(eq(sessionSummaries.id, id), eq(sessionSummaries.agentId, this.runtime.agentId), eq(sessionSummaries.roomId, roomId)));
+    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(and(eq(sessionSummaries.agentId, this.runtime.agentId), eq(sessionSummaries.roomId, roomId))).orderBy(desc(sessionSummaries.updatedAt)).limit(limit);
+    return results.map((row) => ({
+      id: row.id,
+      agentId: row.agentId,
+      roomId: row.roomId,
+      entityId: row.entityId,
+      summary: row.summary,
+      messageCount: row.messageCount,
+      lastMessageOffset: row.lastMessageOffset,
+      startTime: row.startTime,
+      endTime: row.endTime,
+      topics: row.topics || [],
+      metadata: row.metadata,
+      embedding: row.embedding,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    }));
   }
-  async vectorSearch(entityId, roomId, queryEmbedding, limit = 5) {
-    if (!this.embeddingDimension) {
-      logger2.warn("Embedding dimension not set, skipping summary search");
-      return [];
+  async searchLongTermMemories(entityId, queryEmbedding, limit = 5, matchThreshold = 0.7) {
+    if (!this.memoryConfig.longTermVectorSearchEnabled) {
+      logger.warn("Vector search is not enabled, falling back to recent memories");
+      return this.getLongTermMemories(entityId, undefined, limit);
     }
-    const db = await this.getDb();
+    const db = this.getDb();
     try {
-      const similarity = sql4`1 - (${cosineDistance2(conversationSummaryEmbeddings[this.embeddingDimension], queryEmbedding)})`;
+      const cleanVector = queryEmbedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
+      const similarity = sql4`1 - (${cosineDistance(longTermMemories.embedding, cleanVector)})`;
+      const conditions = [
+        eq(longTermMemories.agentId, this.runtime.agentId),
+        eq(longTermMemories.entityId, entityId),
+        sql4`${longTermMemories.embedding} IS NOT NULL`
+      ];
+      if (matchThreshold > 0) {
+        conditions.push(gte(similarity, matchThreshold));
+      }
       const results = await db.select({
-        summary: conversationSummaries,
-        embedding: conversationSummaryEmbeddings[this.embeddingDimension],
+        memory: longTermMemories,
         similarity
-      }).from(conversationSummaries).innerJoin(conversationSummaryEmbeddings, eq2(conversationSummaryEmbeddings.summaryId, conversationSummaries.id)).where(and2(eq2(conversationSummaries.agentId, this.runtime.agentId), eq2(conversationSummaries.entityId, entityId), eq2(conversationSummaries.roomId, roomId), sql4`${conversationSummaryEmbeddings[this.embeddingDimension]} IS NOT NULL`)).orderBy(desc2(similarity)).limit(limit * 2);
-      return results.map((r) => ({
-        ...mapDbRowToConversationSummary(r.summary),
-        embedding: r.embedding
+      }).from(longTermMemories).where(and(...conditions)).orderBy(desc(similarity)).limit(limit);
+      return results.map((row) => ({
+        id: row.memory.id,
+        agentId: row.memory.agentId,
+        entityId: row.memory.entityId,
+        category: row.memory.category,
+        content: row.memory.content,
+        metadata: row.memory.metadata,
+        embedding: row.memory.embedding,
+        confidence: row.memory.confidence,
+        source: row.memory.source,
+        createdAt: row.memory.createdAt,
+        updatedAt: row.memory.updatedAt,
+        lastAccessedAt: row.memory.lastAccessedAt,
+        accessCount: row.memory.accessCount,
+        similarity: row.similarity
       }));
     } catch (error) {
-      logger2.error("Failed to search summaries:", JSON.stringify(error));
-      return [];
-    }
-  }
-  async updateAccessMetadata(summaryIds) {
-    if (summaryIds.length === 0)
-      return;
-    const db = await this.getDb();
-    const now = new Date;
-    try {
-      for (const id of summaryIds) {
-        await db.update(conversationSummaries).set({
-          lastAccessedAt: now,
-          accessCount: sql4`${conversationSummaries.accessCount} + 1`
-        }).where(eq2(conversationSummaries.id, id));
-      }
-      logger2.debug({ count: summaryIds.length }, "Updated summary access metadata");
-    } catch (error) {
-      logger2.error({ error }, "Failed to update summary access metadata");
+      logger.warn({ error }, "Vector search failed, falling back to recent memories");
+      return this.getLongTermMemories(entityId, undefined, limit);
     }
   }
-}
-
-// src/utils/embedding.ts
-import { ModelType, logger as logger3 } from "@elizaos/core";
-async function generateEmbedding(runtime, text3) {
-  try {
-    const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, text3);
-    return embedding;
-  } catch (error) {
-    logger3.error({ error }, "Failed to generate embedding");
-    return new Array(1536).fill(0);
-  }
-}
-function cleanEmbedding(embedding) {
-  return embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
-}
-
-// src/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);
+  async getFormattedLongTermMemories(entityId) {
+    const memories = await this.getLongTermMemories(entityId, undefined, 20);
+    if (memories.length === 0) {
+      return "";
     }
-  }
-  return Array.from(merged.values());
-}
-
-// src/utils/formatting.ts
-function formatMemoriesForContext(memories) {
-  if (memories.length === 0) {
-    return "";
-  }
-  const grouped = new Map;
-  for (const memory of memories) {
-    if (!grouped.has(memory.type)) {
-      grouped.set(memory.type, []);
+    const grouped = new Map;
+    for (const memory of memories) {
+      if (!grouped.has(memory.category)) {
+        grouped.set(memory.category, []);
+      }
+      grouped.get(memory.category)?.push(memory);
     }
-    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(`
+    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(`**Procedural Knowledge (Skills)**:
+      sections.push(`**${categoryName}**:
 ${items}`);
-  }
-  return sections.join(`
+    }
+    return sections.join(`
 
 `);
-}
-
-// 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;
-}
-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;
-    }
-    result.push(item);
-    currentTokens += itemTokens;
-  }
-  return result;
+
+// src/evaluators/summarization.ts
+import {
+  logger as logger2,
+  ModelType,
+  composePromptFromState
+} from "@elizaos/core";
+async function getDialogueMessageCount(runtime, roomId) {
+  const messages = await runtime.getMemories({
+    tableName: "messages",
+    roomId,
+    count: 100,
+    unique: false
+  });
+  const dialogueMessages = messages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result") && (msg.metadata?.type === "agent_response_message" || msg.metadata?.type === "user_message"));
+  return dialogueMessages.length;
 }
-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`;
-  }
+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/services/memory-service.ts
-class MemoryService extends Service {
-  static serviceType = "memory";
-  bm25Index = null;
-  embeddingDimension;
-  isInitialized = false;
-  longTermMemoryRepo;
-  conversationSummaryRepo;
-  capabilityDescription = "State-of-the-art cognitive memory system with episodic, semantic, and procedural memory";
-  static defaultConfig = {
-    consolidationThreshold: 12,
-    minConfidence: 0.7,
-    enableVectorSearch: true,
-    enableBM25: true,
-    retrievalLimit: 5,
-    tokenBudget: 1000,
-    defaultDecayRates: {
-      ["EPISODIC" /* EPISODIC */]: 0.05,
-      ["SEMANTIC" /* SEMANTIC */]: 0.01,
-      ["PROCEDURAL" /* PROCEDURAL */]: 0.02
-    },
-    enableContradictionDetection: true,
-    summarization: {
-      enabled: true,
-      messagesPerSummary: 7,
-      summariesPerLevel: 5,
-      maxDepth: 3,
-      summaryTokenBudget: 500
-    }
-  };
-  constructor(runtime) {
-    super(runtime);
-    this.config = { ...MemoryService.defaultConfig };
-  }
-  static async start(runtime) {
-    const service = new MemoryService(runtime);
-    await service.initialize(runtime);
-    return service;
-  }
-  async stop() {
-    logger4.info("MemoryService stopped");
-  }
-  async initialize(runtime) {
-    this.runtime = runtime;
-    this.loadConfiguration();
-    await this.ensureEmbeddingDimension();
-    this.longTermMemoryRepo = new LongTermMemoryRepository(runtime, this.embeddingDimension);
-    this.conversationSummaryRepo = new ConversationSummaryRepository(runtime, this.embeddingDimension);
-    logger4.info({ config: this.config }, "MemoryService initialized");
-    if (this.config.enableBM25) {
-      await this.rebuildBM25Index();
-    }
-    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");
-    logger4.debug({
-      enableVector,
-      type: typeof enableVector,
-      defaultValue: this.config.enableVectorSearch
-    }, "Loading MEMORY_ENABLE_VECTOR_SEARCH setting");
-    if (enableVector !== undefined && enableVector !== null && enableVector !== "") {
-      this.config.enableVectorSearch = enableVector === "true" || enableVector === true;
-      logger4.info({ enabled: this.config.enableVectorSearch }, "Vector search explicitly configured via environment variable");
-    } else {
-      logger4.info({ enabled: this.config.enableVectorSearch }, "Vector search using default configuration");
-    }
-    const enableBM25 = this.runtime.getSetting("MEMORY_ENABLE_BM25");
-    logger4.debug({
-      enableBM25,
-      type: typeof enableBM25,
-      defaultValue: this.config.enableBM25
-    }, "Loading MEMORY_ENABLE_BM25 setting");
-    if (enableBM25 !== undefined && enableBM25 !== null && enableBM25 !== "") {
-      this.config.enableBM25 = enableBM25 === "true" || enableBM25 === true;
-      logger4.info({ enabled: this.config.enableBM25 }, "BM25 search explicitly configured via environment variable");
-    } else {
-      logger4.info({ enabled: this.config.enableBM25 }, "BM25 search using default configuration");
-    }
-    const retrievalLimit = this.runtime.getSetting("MEMORY_RETRIEVAL_LIMIT");
-    if (retrievalLimit) {
-      this.config.retrievalLimit = parseInt(retrievalLimit, 10);
+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) {
+      return false;
     }
-    const tokenBudget = this.runtime.getSetting("MEMORY_TOKEN_BUDGET");
-    if (tokenBudget) {
-      this.config.tokenBudget = parseInt(tokenBudget, 10);
+    const memoryService = runtime.getService("memory");
+    if (!memoryService) {
+      return false;
     }
-    const summaryEnabled = this.runtime.getSetting("MEMORY_SUMMARY_ENABLED");
-    logger4.debug({
-      summaryEnabled,
-      type: typeof summaryEnabled,
-      defaultValue: this.config.summarization?.enabled
-    }, "Loading MEMORY_SUMMARY_ENABLED setting");
-    if (summaryEnabled !== undefined && summaryEnabled !== null && summaryEnabled !== "") {
-      this.config.summarization.enabled = summaryEnabled === "true" || summaryEnabled === true;
-      logger4.info({ enabled: this.config.summarization.enabled }, "Summarization explicitly configured via environment variable");
+    const config = memoryService.getConfig();
+    const currentDialogueCount = await getDialogueMessageCount(runtime, message.roomId);
+    const existingSummary = await memoryService.getCurrentSessionSummary(message.roomId);
+    if (!existingSummary) {
+      const shouldSummarize = currentDialogueCount >= config.shortTermSummarizationThreshold;
+      return shouldSummarize;
     } else {
-      logger4.info({ enabled: this.config.summarization.enabled }, "Summarization using default configuration");
-    }
-    const messagesPerSummary = this.runtime.getSetting("MEMORY_MESSAGES_PER_SUMMARY");
-    if (messagesPerSummary) {
-      this.config.summarization.messagesPerSummary = parseInt(messagesPerSummary, 10);
-    }
-    const summariesPerLevel = this.runtime.getSetting("MEMORY_SUMMARIES_PER_LEVEL");
-    if (summariesPerLevel) {
-      this.config.summarization.summariesPerLevel = parseInt(summariesPerLevel, 10);
+      const newDialogueCount = currentDialogueCount - existingSummary.lastMessageOffset;
+      const shouldUpdate = newDialogueCount >= config.shortTermSummarizationInterval;
+      return shouldUpdate;
     }
-    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);
+  },
+  handler: async (runtime, message) => {
+    const memoryService = runtime.getService("memory");
+    if (!memoryService) {
+      logger2.error("MemoryService not found");
+      return;
     }
-  }
-  async ensureEmbeddingDimension() {
+    const config = memoryService.getConfig();
+    const { roomId } = message;
     try {
-      const embeddingModel = this.runtime.getModel(ModelType2.TEXT_EMBEDDING);
-      if (!embeddingModel) {
-        logger4.warn("No TEXT_EMBEDDING model registered. Embeddings will not be generated.");
+      logger2.info(`Starting summarization for room ${roomId}`);
+      const existingSummary = await memoryService.getCurrentSessionSummary(roomId);
+      const lastOffset = existingSummary?.lastMessageOffset || 0;
+      const allMessages = await runtime.getMemories({
+        tableName: "messages",
+        roomId,
+        count: 1000,
+        unique: false
+      });
+      const allDialogueMessages = allMessages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result") && (msg.metadata?.type === "agent_response_message" || msg.metadata?.type === "user_message"));
+      const totalDialogueCount = allDialogueMessages.length;
+      const newDialogueCount = totalDialogueCount - lastOffset;
+      if (newDialogueCount === 0) {
+        logger2.debug("No new dialogue messages to summarize");
         return;
       }
-      const testEmbedding = await this.runtime.useModel(ModelType2.TEXT_EMBEDDING, {
-        text: "test"
-      });
-      if (!testEmbedding || !Array.isArray(testEmbedding)) {
-        throw new Error("Invalid embedding received from model");
+      const maxNewMessages = config.summaryMaxNewMessages || 50;
+      const messagesToProcess = Math.min(newDialogueCount, maxNewMessages);
+      if (newDialogueCount > maxNewMessages) {
+        logger2.warn(`Capping new dialogue messages at ${maxNewMessages} (${newDialogueCount} available). Oldest messages will be skipped.`);
       }
-      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(", ")}`);
+      const sortedDialogueMessages = allDialogueMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
+      const newDialogueMessages = sortedDialogueMessages.slice(lastOffset, lastOffset + messagesToProcess);
+      if (newDialogueMessages.length === 0) {
+        logger2.debug("No new dialogue messages retrieved after filtering");
+        return;
       }
-      this.embeddingDimension = dimensionColumn;
-      logger4.info(`Memory embedding dimension set to ${dimension} (${dimensionColumn})`);
-    } catch (error) {
-      logger4.error("Failed to ensure embedding dimension:", JSON.stringify(error));
-      throw error;
-    }
-  }
-  getConfig() {
-    return { ...this.config };
-  }
-  updateConfig(updates) {
-    this.config = { ...this.config, ...updates };
-    if (updates.enableBM25 !== undefined) {
-      if (updates.enableBM25 && !this.bm25Index) {
-        this.rebuildBM25Index();
-      } else if (!updates.enableBM25) {
-        this.bm25Index = null;
-      }
-    }
-  }
-  async storeLongTermMemory(memory) {
-    let embedding;
-    if (this.embeddingDimension) {
-      try {
-        const rawEmbedding = await generateEmbedding(this.runtime, memory.embeddingContext);
-        embedding = cleanEmbedding(rawEmbedding);
-      } catch (error) {
-        logger4.warn("Failed to generate embedding for long-term memory:", JSON.stringify(error));
-      }
-    }
-    const stored = await this.longTermMemoryRepo.insert(memory, embedding);
-    if (this.config.enableBM25 && this.bm25Index) {
-      await this.rebuildBM25Index();
-    }
-    return stored;
-  }
-  async getLongTermMemory(id) {
-    return this.longTermMemoryRepo.findById(id);
-  }
-  async updateLongTermMemory(id, updates) {
-    let newEmbedding;
-    if (updates.embeddingContext !== undefined && this.embeddingDimension) {
-      try {
-        const rawEmbedding = await generateEmbedding(this.runtime, updates.embeddingContext);
-        newEmbedding = cleanEmbedding(rawEmbedding);
-      } catch (error) {
-        logger4.warn("Failed to regenerate embedding:", JSON.stringify(error));
+      const formattedMessages = newDialogueMessages.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 = composePromptFromState({
+          state: {
+            ...state,
+            existingSummary: existingSummary.summary,
+            existingTopics: existingSummary.topics?.join(", ") || "None",
+            newMessages: formattedMessages
+          },
+          template
+        });
+      } else {
+        const initialMessages = sortedDialogueMessages.map((msg) => {
+          const sender = msg.entityId === runtime.agentId ? runtime.character.name : "User";
+          return `${sender}: ${msg.content.text || "[non-text message]"}`;
+        }).join(`
+`);
+        template = initialSummarizationTemplate;
+        prompt = composePromptFromState({
+          state: {
+            ...state,
+            recentMessages: initialMessages
+          },
+          template
+        });
       }
-    }
-    await this.longTermMemoryRepo.update(id, updates, newEmbedding);
-  }
-  async deleteLongTermMemory(id) {
-    await this.longTermMemoryRepo.delete(id);
-  }
-  async getLongTermMemories(entityId, type, limit = 20, includeInactive = false) {
-    return this.longTermMemoryRepo.findByEntity(entityId, type, limit, includeInactive);
-  }
-  async handleContradiction(entityId, newMemory) {
-    const searchResults = await this.searchLongTermMemories({
-      entityId,
-      query: newMemory.content,
-      type: newMemory.type,
-      limit: 5,
-      includeInactive: false
-    });
-    if (searchResults.length === 0) {
-      await this.storeLongTermMemory(newMemory);
-      return;
-    }
-    const contradictingMemory = await this.detectContradiction(newMemory, searchResults);
-    if (contradictingMemory) {
-      logger4.info({
-        oldMemoryId: contradictingMemory.id,
-        newContent: newMemory.content
-      }, "Contradiction detected, superseding old memory");
-      await this.updateLongTermMemory(contradictingMemory.id, {
-        isActive: false
-      });
-      const stored = await this.storeLongTermMemory({
-        ...newMemory,
-        supersedesId: contradictingMemory.id
-      });
-      logger4.info({ newMemoryId: stored.id }, "Stored superseding memory");
-    } else {
-      await this.storeLongTermMemory(newMemory);
-    }
-  }
-  async detectContradiction(newMemory, existingMemories) {
-    const prompt = `# TASK: Contradiction Detection
-
-You are analyzing whether a new long-term memory contradicts any existing long-term memories.
-
-## New Long-Term Memory:
-"${newMemory.content}"
-
-## Existing Long-Term Memories:
-${existingMemories.map((m, idx) => `${idx + 1}. "${m.content}" (confidence: ${m.confidence}, created: ${m.createdAt.toISOString()})`).join(`
-`)}
-
-## Instructions:
-Determine if the new long-term memory directly contradicts any of the existing long-term memories. A contradiction means the statements cannot both be true.
-
-Examples of contradictions:
-- "User likes blue" vs "User hates blue"
-- "User lives in Paris" vs "User lives in London"
-
-Examples of non-contradictions (these are compatible):
-- "User likes blue" vs "User likes blue only for clothes" (nuance, not contradiction)
-- "User was in Paris" vs "User moved to London" (state change over time)
-
-## Output Format:
-Return an XML response:
-
-<response>
-<hasContradiction>true or false</hasContradiction>
-<contradictingMemoryIndex>number or null</contradictingMemoryIndex>
-<reasoning>Explanation</reasoning>
-</response>
-
-If no contradiction is found, set hasContradiction to false and contradictingMemoryIndex to null.`;
-    try {
-      const response = await this.runtime.useModel(ModelType2.TEXT_LARGE, {
+      const response = await runtime.useModel(ModelType.TEXT_LARGE, {
         prompt,
-        temperature: 0.2
+        maxTokens: config.summaryMaxTokens || 2500
       });
-      const responseText = typeof response === "string" ? response : JSON.stringify(response);
-      const result = parseKeyValueXml(responseText);
-      if (!result) {
-        logger4.warn("Failed to parse contradiction detection XML response");
-        return null;
-      }
-      const hasContradiction = parseBooleanFromText(typeof result.hasContradiction === "boolean" ? result.hasContradiction ? "true" : "false" : result.hasContradiction);
-      let contradictingMemoryIndex = null;
-      if (result.contradictingMemoryIndex !== null && result.contradictingMemoryIndex !== "null") {
-        const parsed = parseInt(result.contradictingMemoryIndex, 10);
-        if (!isNaN(parsed)) {
-          contradictingMemoryIndex = parsed;
-        }
-      }
-      if (hasContradiction && contradictingMemoryIndex !== null) {
-        const contradictingMemory = existingMemories[contradictingMemoryIndex];
-        logger4.info({ reasoning: result.reasoning }, "Contradiction detected");
-        return contradictingMemory;
-      }
-      return null;
-    } catch (error) {
-      logger4.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;
-    logger4.debug({
-      limit,
-      tokenBudget,
-      minConfidence,
-      similarityThreshold,
-      vectorSearchEnabled: this.config.enableVectorSearch,
-      bm25Enabled: this.config.enableBM25
-    }, "Searching long-term memories");
-    let vectorResults = [];
-    if (this.config.enableVectorSearch) {
-      logger4.debug("Vector search enabled, searching...");
-      vectorResults = await this.vectorSearch(params, similarityThreshold);
-    }
-    logger4.debug({ vectorResults: vectorResults.length }, "Vector search results");
-    let bm25Results = [];
-    if (this.config.enableBM25) {
-      bm25Results = await this.bm25Search(params);
-    }
-    const mergedResults = mergeSearchResults(vectorResults, bm25Results);
-    const confidenceFiltered = mergedResults.filter((m) => m.confidence >= minConfidence);
-    const decayedResults = applyDecayScoring(confidenceFiltered);
-    const sorted = decayedResults.sort((a, b) => b.finalScore - a.finalScore);
-    const topResults = sorted.slice(0, limit);
-    const budgetedResults = trimToTokenBudget(topResults, tokenBudget, (memory) => memory.content, 15);
-    logger4.debug({
-      totalResults: sorted.length,
-      afterCountLimit: topResults.length,
-      afterTokenBudget: budgetedResults.length,
-      tokenBudget,
-      estimatedTokens: budgetedResults.reduce((sum, m) => sum + estimateTokenCount(m.content) + 15, 0)
-    }, "Applied token budget to memory retrieval");
-    await this.longTermMemoryRepo.updateAccessMetadata(budgetedResults.map((r) => r.id));
-    return budgetedResults;
-  }
-  async vectorSearch(params, similarityThreshold = 0.3) {
-    if (!this.embeddingDimension) {
-      logger4.warn("Embedding dimension not set, skipping vector search");
-      return [];
-    }
-    try {
-      const rawEmbedding = await generateEmbedding(this.runtime, params.query);
-      const queryEmbedding = cleanEmbedding(rawEmbedding);
-      if (!queryEmbedding || !Array.isArray(queryEmbedding)) {
-        logger4.warn("Failed to generate query embedding");
-        return [];
-      }
-      return await this.longTermMemoryRepo.vectorSearch(params, queryEmbedding, similarityThreshold);
-    } catch (error) {
-      logger4.error("Failed to execute vector search:", JSON.stringify(error));
-      return [];
-    }
-  }
-  async bm25Search(params) {
-    if (!this.bm25Index) {
-      return [];
-    }
-    try {
-      const bm25Results = this.bm25Index.search(params.query, params.limit || 20);
-      const memoryPromises = bm25Results.map(async (result) => {
-        const doc = this.bm25Index.documents[result.index];
-        if (!doc || !doc.id) {
-          logger4.warn({ resultIndex: result.index }, "BM25 result has no document ID");
-          return null;
-        }
-        const memory = await this.getLongTermMemory(doc.id);
-        if (!memory)
-          return null;
-        if (memory.entityId !== params.entityId)
-          return null;
-        if (!params.includeInactive && !memory.isActive)
-          return null;
-        if (params.type && memory.type !== params.type)
-          return null;
-        if (params.minConfidence && memory.confidence < params.minConfidence)
-          return null;
-        return {
-          ...memory,
-          relevanceScore: result.score,
-          activationScore: 0,
-          finalScore: 0
-        };
-      });
-      const results = await Promise.all(memoryPromises);
-      return results.filter((r) => r !== null);
-    } catch (error) {
-      logger4.error({ error }, "BM25 search failed");
-      return [];
-    }
-  }
-  async rebuildBM25Index() {
-    try {
-      const memories = await this.longTermMemoryRepo.fetchAllActive();
-      const documents = memories.map((row) => ({
-        id: row.id,
-        content: row.content,
-        embeddingContext: row.embeddingContext
-      }));
-      this.bm25Index = new BM25(documents, {
-        k1: 1.2,
-        b: 0.75,
-        stemming: true,
-        minLength: 2
-      });
-      logger4.info({ documentCount: documents.length }, "Rebuilt BM25 index");
-    } catch (error) {
-      logger4.error({ error }, "Failed to rebuild BM25 index");
-      this.bm25Index = null;
-    }
-  }
-  async getFormattedLongTermMemoriesForContext(entityId, query, roomId) {
-    const memories = await this.searchLongTermMemories({
-      entityId,
-      query,
-      roomId,
-      limit: this.config.retrievalLimit
-    });
-    return formatMemoriesForContext(memories);
-  }
-  async storeSummary(summary) {
-    let embedding;
-    if (this.embeddingDimension) {
-      try {
-        const rawEmbedding = await generateEmbedding(this.runtime, summary.content);
-        embedding = cleanEmbedding(rawEmbedding);
-      } catch (error) {
-        logger4.warn("Failed to generate embedding for summary:", JSON.stringify(error));
-      }
-    }
-    return this.conversationSummaryRepo.insert(summary, embedding);
-  }
-  async getSummariesByLevel(roomId, level) {
-    return this.conversationSummaryRepo.findByLevel(roomId, level);
-  }
-  async searchSummaries(params) {
-    if (!this.embeddingDimension) {
-      logger4.warn("Embedding dimension not set, skipping summary search");
-      return [];
-    }
-    const limit = params.limit || 5;
-    const tokenBudget = params.tokenBudget || this.config.summarization?.summaryTokenBudget || 500;
-    try {
-      const rawEmbedding = await generateEmbedding(this.runtime, params.query);
-      const queryEmbedding = cleanEmbedding(rawEmbedding);
-      if (!queryEmbedding || !Array.isArray(queryEmbedding)) {
-        logger4.warn("Failed to generate query embedding");
-        return [];
-      }
-      const summaries = await this.conversationSummaryRepo.vectorSearch(params.entityId, params.roomId, queryEmbedding, limit);
-      const budgetedSummaries = trimToTokenBudget(summaries, tokenBudget, (s) => s.content, 10);
-      await this.conversationSummaryRepo.updateAccessMetadata(budgetedSummaries.map((s) => s.id));
-      return budgetedSummaries;
-    } catch (error) {
-      logger4.error("Failed to search summaries:", JSON.stringify(error));
-      return [];
-    }
-  }
-  async getMostRecentLevel1Summary(roomId, entityId) {
-    try {
-      const summaries = await this.conversationSummaryRepo.findByLevel(roomId, 1);
-      if (summaries.length === 0) {
-        return null;
-      }
-      const entitySummaries = summaries.filter((s) => s.entityId === entityId).sort((a, b) => b.endTime.getTime() - a.endTime.getTime());
-      return entitySummaries.length > 0 ? entitySummaries[0] : null;
-    } catch (error) {
-      logger4.error("Failed to get most recent Level 1 summary:", JSON.stringify(error));
-      return null;
-    }
-  }
-}
-
-// src/evaluators/consolidation.ts
-import {
-  logger as logger5,
-  ModelType as ModelType3
-} from "@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) {
-      logger5.info({
-        roomId: message.roomId,
-        bufferSize,
-        threshold: config.consolidationThreshold
-      }, "Consolidation threshold reached");
-    }
-    return shouldConsolidate;
-  },
-  handler: async (runtime, message) => {
-    const roomId = message.roomId;
-    try {
-      const memoryService = runtime.getService("memory");
-      if (!memoryService) {
-        logger5.warn("Memory service not available for consolidation");
-        return;
-      }
-      const buffer = consolidationBuffers.get(roomId) || [];
-      if (buffer.length === 0) {
-        return;
-      }
-      logger5.info({ roomId, messageCount: buffer.length }, "Starting memory consolidation");
-      const conversationLog = buffer.map((m, idx) => {
-        const content = typeof m.content === "string" ? m.content : m.content.text || JSON.stringify(m.content);
-        return `[${idx + 1}] ${m.entityId}: ${content}`;
-      }).join(`
-`);
-      const extractionPrompt = buildExtractionPrompt(conversationLog);
-      const originalSystemPrompt = runtime.character.system;
-      try {
-        runtime.character.system = CONSOLIDATION_SYSTEM_PROMPT;
-        logger5.debug("Calling LLM for memory extraction");
-        const response = await runtime.useModel(ModelType3.TEXT_LARGE, {
-          prompt: extractionPrompt,
-          temperature: 0.3
+      const summaryResult = parseSummaryXML(response);
+      logger2.info(`${existingSummary ? "Updated" : "Generated"} summary: ${summaryResult.summary.substring(0, 100)}...`);
+      const newOffset = lastOffset + newDialogueMessages.length;
+      const firstMessage = newDialogueMessages[0];
+      const lastMessage = newDialogueMessages[newDialogueMessages.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 + newDialogueMessages.length,
+          lastMessageOffset: newOffset,
+          endTime,
+          topics: summaryResult.topics,
+          metadata: {
+            keyPoints: summaryResult.keyPoints
+          }
         });
-        const consolidationResult = parseConsolidationResult(response);
-        logger5.debug({
-          reasoning: consolidationResult.reasoningTrace,
-          extracted: consolidationResult.extractedMemories.length
-        }, "Extraction complete");
-        const config = memoryService.getConfig();
-        const validMemories = consolidationResult.extractedMemories.filter((m) => m.confidence >= config.minConfidence);
-        logger5.info({
-          total: consolidationResult.extractedMemories.length,
-          valid: validMemories.length,
-          minConfidence: config.minConfidence
-        }, "Filtered extracted memories");
-        for (const extracted of validMemories) {
-          await storeExtractedMemory(runtime, memoryService, roomId, buffer, extracted);
-        }
-        consolidationBuffers.set(roomId, []);
-        logger5.info({ roomId, stored: validMemories.length }, "Memory consolidation complete");
-      } finally {
-        runtime.character.system = originalSystemPrompt;
+        logger2.info(`Updated summary for room ${roomId}: ${newDialogueMessages.length} new dialogue 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: totalDialogueCount,
+          lastMessageOffset: totalDialogueCount,
+          startTime,
+          endTime,
+          topics: summaryResult.topics,
+          metadata: {
+            keyPoints: summaryResult.keyPoints
+          }
+        });
+        logger2.info(`Created new summary for room ${roomId}: ${totalDialogueCount} dialogue messages summarized (offset: 0 → ${totalDialogueCount})`);
       }
     } catch (error) {
-      logger5.error({ error, roomId }, "Consolidation evaluator failed");
+      logger2.error({ error }, "Error during summarization:");
     }
   },
   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) {
-          logger5.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)) {
-          logger5.warn({ type, line: trimmedLine }, "Invalid memory type");
-          continue;
-        }
-        if (!category) {
-          logger5.warn({ line: trimmedLine }, "Missing category");
-          continue;
-        }
-        const confidence = parseFloat(confidenceStr);
-        if (isNaN(confidence) || confidence < 0 || confidence > 1) {
-          logger5.warn({ confidenceStr, line: trimmedLine }, "Invalid confidence value");
-          continue;
-        }
-        const isContradiction = isContradictionStr.toLowerCase() === "true";
-        if (!content) {
-          logger5.warn({ line: trimmedLine }, "Missing content");
-          continue;
-        }
-        const metadata = {
-          category
-        };
-        extractedMemories.push({
-          type,
-          content,
-          confidence,
-          isContradiction,
-          metadata
-        });
-      }
-    }
-    return {
-      reasoningTrace,
-      transientSummary: "",
-      extractedMemories
-    };
-  } catch (error) {
-    logger5.error({ error }, "Failed to parse consolidation response");
-    return {
-      reasoningTrace: "Parse error",
-      transientSummary: "",
-      extractedMemories: []
-    };
-  }
-}
-async function storeExtractedMemory(runtime, memoryService, roomId, buffer, extracted) {
-  const entityId = buffer[0]?.entityId || runtime.agentId;
-  const embeddingContext = generateContextualString(extracted);
-  const config = memoryService.getConfig();
-  const decayRate = config.defaultDecayRates[extracted.type];
-  const memoryData = {
-    agentId: runtime.agentId,
-    entityId,
-    roomId,
-    type: extracted.type,
-    content: extracted.content,
-    embeddingContext,
-    confidence: extracted.confidence,
-    decayRate,
-    decayFunction: "EXPONENTIAL" /* EXPONENTIAL */,
-    source: {
-      sessionId: roomId,
-      messageId: extracted.sourceMessageId,
-      textSnippet: extracted.content.substring(0, 200)
-    },
-    metadata: extracted.metadata || {}
-  };
-  if (config.enableContradictionDetection && extracted.isContradiction) {
-    await memoryService.handleContradiction(entityId, memoryData);
-  } else {
-    await memoryService.storeLongTermMemory(memoryData);
-  }
-}
-function generateContextualString(extracted) {
-  const typeLabel = {
-    ["EPISODIC" /* EPISODIC */]: "Event",
-    ["SEMANTIC" /* SEMANTIC */]: "Fact",
-    ["PROCEDURAL" /* PROCEDURAL */]: "Skill"
-  }[extracted.type];
-  const category = extracted.metadata?.category || "general";
-  return `[${typeLabel} about ${category}]: ${extracted.content}`;
-}
 
-// src/evaluators/summarization.ts
+// src/evaluators/long-term-extraction.ts
 import {
-  logger as logger6,
-  ModelType as ModelType4
+  logger as logger3,
+  ModelType as ModelType2,
+  composePromptFromState as composePromptFromState2
 } from "@elizaos/core";
 
-// src/prompts/summarization.ts
-var SUMMARIZATION_SYSTEM_PROMPT = `You are "Chronos", a master summarizer.
-Your function is to condense conversation logs into concise, subject-first narrative summaries.
-
-# CORE DIRECTIVE: "Subject-First" Summarization
-You must rephrase the narrative to focus on the *topic*, not the user. This optimizes vector retrieval.
-- BAD: "User asked about Python." (Too generic)
-- GOOD: "Python programming inquiries were addressed." (Topic-focused)
-
-# COMPRESSION RULES
-1. **Be Concise**: Target 2-4 sentences. Maximum 100 words.
-2. **Be Factual**: No interpretation, no speculation. Only what actually happened.
-3. **Be Narrative**: Write as a story, not a bullet list.
-4. **Preserve Key Facts**: If the user revealed important information (preferences, identity, needs), include it.
-5. **Exclude Trivia**: Skip greetings, acknowledgments, and filler conversation.
-
-# OUTPUT FORMAT
-Phase 1: [ANALYSIS]
-- Identify key topics.
-- Draft the summary.
-- Refine wording to be subject-first.
-
-Phase 2: [RESULT]
-Format: \`SUMM|TAGS|CONTENT\`
-- TAGS: Comma-separated list of key topics (lowercase)
-- CONTENT: The narrative summary text (must be a single line, no newlines)
-`;
-function buildLevel1SummaryPrompt(formattedMessages, previousSummary) {
-  const previousContext = previousSummary ? `
-# PREVIOUS SUMMARY
-<previous_summary>
-${previousSummary}
-</previous_summary>
-
-**Note**: The above is what was discussed before. Ensure your new summary:
-- Does not duplicate information already captured in the previous summary
-- Focuses only on the NEW conversation below
-- Maintains continuity (e.g., "Conversation continued with...")
-` : "";
-  return `${previousContext}
-# INPUT DATA
-<messages>
-${formattedMessages}
-</messages>
-
-# FEW-SHOT EXAMPLES
-
-<example_1_task_oriented>
-Input:
-[Message 1] User: I need help deploying my React app to Vercel
-[Message 2] Agent: Sure! First, make sure you have the Vercel CLI installed...
-[Message 3] User: Done. What's next?
-[Message 4] Agent: Run 'vercel' in your project directory...
-[Message 5] User: It worked! Thanks!
-
-Output:
-[ANALYSIS]
-- Topic: React app deployment to Vercel.
-- Action: CLI installation and deployment.
-- Outcome: Success.
-- Draft: User requested help... -> React app deployment...
-[RESULT]
-SUMM|deployment,react,vercel,cli|React app deployment to Vercel was successfully completed following CLI installation and configuration guidance.
-</example_1_task_oriented>
-
-<example_2_identity_revelation>
-Input:
-[Message 1] User: I'm working on a side project in my spare time
-[Message 2] Agent: That's great! What kind of project?
-[Message 3] User: A machine learning app for analyzing stock data. I'm a data scientist by profession.
-[Message 4] Agent: Interesting! Are you using Python?
-[Message 5] User: Yeah, mostly PyTorch and pandas.
-
-Output:
-[ANALYSIS]
-- Identity: Data scientist.
-- Project: Stock data analysis (ML).
-- Tech Stack: Python, PyTorch, pandas.
-- Draft: User discussed... -> Stock data analysis project...
-[RESULT]
-SUMM|machine learning,data science,python,stocks|Stock data analysis project (Machine Learning) utilizing Python (PyTorch, pandas) is in development by a data scientist.
-</example_2_identity_revelation>
-
-<example_3_chitchat>
-Input:
-[Message 1] User: Hey, how's it going?
-[Message 2] Agent: I'm doing well, thanks for asking! How can I help you today?
-[Message 3] User: Just saying hi
-[Message 4] Agent: Nice to hear from you!
-
-Output:
-[ANALYSIS]
-- Content: Greetings only.
-- Substance: None.
-[RESULT]
-SUMM|greeting,casual|Casual greeting exchanged; no substantive topics discussed.
-</example_3_chitchat>
-
-Begin the [ANALYSIS] phase now.`;
-}
-var HIGHER_LEVEL_SUMMARIZATION_SYSTEM_PROMPT = `You are "Chronos", a Meta-Summarization Agent.
-Your task is to compress multiple conversation summaries into a single, higher-level summary.
-
-# MISSION
-Transform a list of conversation summaries into one concise meta-summary that captures:
-1. **Overarching themes** across the summaries
-2. **Key events or milestones** (e.g., "User onboarded", "Project completed")
-3. **Evolving context** (e.g., "User's preferences shifted from X to Y")
-
-# RULES
-- **Subject-First**: Focus on the topic, not the user.
-- **Abstract Higher**: Don't repeat specifics from each summary. Find the pattern.
-- **Chronological Flow**: Maintain temporal order if it matters.
-- **Preserve Critical Facts**: If summaries mention important identity or preferences, keep them.
-
-# OUTPUT FORMAT
-Phase 1: [ANALYSIS]
-- Identify themes and milestones.
-- Combine related points.
-- Refine to subject-first.
-
-Phase 2: [RESULT]
-Format: \`SUMM|TAGS|CONTENT\`
-- TAGS: Comma-separated list of key topics (lowercase)
-- CONTENT: The meta-summary text (must be a single line, no newlines)
-`;
-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/types/index.ts
+var LongTermMemoryCategory;
+((LongTermMemoryCategory2) => {
+  LongTermMemoryCategory2["EPISODIC"] = "episodic";
+  LongTermMemoryCategory2["SEMANTIC"] = "semantic";
+  LongTermMemoryCategory2["PROCEDURAL"] = "procedural";
+})(LongTermMemoryCategory ||= {});
+
+// src/evaluators/long-term-extraction.ts
+var extractionTemplate = `# Task: Extract Long-Term Memory (Strict Criteria)
+
+You are analyzing a conversation to extract ONLY the most critical, persistent information about the user using cognitive science memory categories.
+
+# Recent Messages
+{{recentMessages}}
+
+# Current Long-Term Memories
+{{existingMemories}}
+
+# Memory Categories (Based on Cognitive Science)
+
+## 1. EPISODIC Memory
+Personal experiences and specific events with temporal/spatial context.
+**Examples:**
+- "User completed migration project from MongoDB to PostgreSQL in Q2 2024"
+- "User encountered authentication bug in production on March 15th"
+- "User had a negative experience with Docker networking in previous job"
+
+**Requirements:**
+- Must include WHO did WHAT, WHEN/WHERE
+- Must be a specific, concrete event (not a pattern)
+- Must have significant impact or relevance to future work
+
+## 2. SEMANTIC Memory
+General facts, concepts, knowledge, and established truths about the user.
+**Examples:**
+- "User is a senior backend engineer with 8 years experience"
+- "User specializes in distributed systems and microservices architecture"
+- "User's primary programming language is TypeScript"
+- "User works at Acme Corp as technical lead"
+
+**Requirements:**
+- Must be factual, timeless information
+- Must be explicitly stated or demonstrated conclusively
+- No speculation or inference from single instances
+- Core identity, expertise, or knowledge only
+
+## 3. PROCEDURAL Memory
+Skills, workflows, methodologies, and how-to knowledge.
+**Examples:**
+- "User follows strict TDD workflow: write tests first, then implementation"
+- "User prefers git rebase over merge to maintain linear history"
+- "User's debugging process: check logs → reproduce locally → binary search"
+- "User always writes JSDoc comments before implementing functions"
+
+**Requirements:**
+- Must describe HOW user does something
+- Must be a repeated, consistent pattern (seen 3+ times or explicitly stated as standard practice)
+- Must be a workflow, methodology, or skill application
+- Not one-off preferences
+
+# ULTRA-STRICT EXTRACTION CRITERIA
+
+## ✅ DO EXTRACT (Only These):
+
+**EPISODIC:**
+- Significant completed projects or milestones
+- Important bugs, incidents, or problems encountered
+- Major decisions made with lasting impact
+- Formative experiences that shape future work
+
+**SEMANTIC:**
+- Professional identity (role, title, company)
+- Core expertise and specializations (stated explicitly or demonstrated conclusively)
+- Primary languages, frameworks, or tools (not exploratory use)
+- Established facts about their work context
+
+**PROCEDURAL:**
+- Consistent workflows demonstrated 3+ times or explicitly stated
+- Standard practices user always follows
+- Methodology preferences with clear rationale
+- Debugging, testing, or development processes
+
+## ❌ NEVER EXTRACT:
+
+- **One-time requests or tasks** (e.g., "can you generate an image", "help me debug this")
+- **Casual conversations** without lasting significance
+- **Exploratory questions** (e.g., "how does X work?")
+- **Temporary context** (current bug, today's task)
+- **Preferences from single occurrence** (e.g., user asked for code once)
+- **Social pleasantries** (thank you, greetings)
+- **Testing or experimentation** (trying out a feature)
+- **Common patterns everyone has** (likes clear explanations)
+- **Situational information** (working on feature X today)
+- **Opinions without persistence** (single complaint, isolated praise)
+- **General knowledge** (not specific to user)
+
+# Quality Gates (ALL Must Pass)
+
+1. **Significance Test**: Will this matter in 3+ months?
+2. **Specificity Test**: Is this concrete and actionable?
+3. **Evidence Test**: Is there strong evidence (3+ instances OR explicit self-identification)?
+4. **Uniqueness Test**: Is this specific to THIS user (not generic)?
+5. **Confidence Test**: Confidence must be >= 0.85 (be VERY conservative)
+6. **Non-Redundancy Test**: Does this add NEW information not in existing memories?
+
+# Confidence Scoring (Be Conservative)
+
+- **0.95-1.0**: User explicitly stated as core identity/practice AND demonstrated multiple times
+- **0.85-0.94**: User explicitly stated OR consistently demonstrated 5+ times
+- **0.75-0.84**: Strong pattern (3-4 instances) with supporting context
+- **Below 0.75**: DO NOT EXTRACT (insufficient evidence)
+
+# Critical Instructions
+
+1. **Default to NOT extracting** - When in doubt, skip it
+2. **Require overwhelming evidence** - One or two mentions is NOT enough
+3. **Focus on what's PERSISTENT** - Not what's temporary or situational
+4. **Verify against existing memories** - Don't duplicate or contradict
+5. **Maximum 2-3 extractions per run** - Quality over quantity
+
+**If there are no qualifying facts (which is common), respond with <memories></memories>**
+
+# Response Format
+
+<memories>
+  <memory>
+    <category>semantic</category>
+    <content>User is a senior TypeScript developer with 8 years of backend experience</content>
+    <confidence>0.95</confidence>
+  </memory>
+  <memory>
+    <category>procedural</category>
+    <content>User follows TDD workflow: writes tests before implementation, runs tests after each change</content>
+    <confidence>0.88</confidence>
+  </memory>
+  <memory>
+    <category>episodic</category>
+    <content>User led database migration from MongoDB to PostgreSQL for payment system in Q2 2024</content>
+    <confidence>0.92</confidence>
+  </memory>
+</memories>`;
+function parseMemoryExtractionXML(xml) {
+  const memoryMatches = xml.matchAll(/<memory>[\s\S]*?<category>(.*?)<\/category>[\s\S]*?<content>(.*?)<\/content>[\s\S]*?<confidence>(.*?)<\/confidence>[\s\S]*?<\/memory>/g);
+  const extractions = [];
+  for (const match of memoryMatches) {
+    const category = match[1].trim();
+    const content = match[2].trim();
+    const confidence = parseFloat(match[3].trim());
+    if (!Object.values(LongTermMemoryCategory).includes(category)) {
+      logger3.warn(`Invalid memory category: ${category}`);
+      continue;
+    }
+    if (content && !isNaN(confidence)) {
+      extractions.push({ category, content, confidence });
+    }
+  }
+  return extractions;
 }
-
-// src/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.",
+var longTermExtractionEvaluator = {
+  name: "LONG_TERM_MEMORY_EXTRACTION",
+  description: "Extracts long-term facts about users from conversations",
+  similes: ["MEMORY_EXTRACTION", "FACT_LEARNING", "USER_PROFILING"],
+  alwaysRun: true,
   validate: async (runtime, message) => {
+    if (message.entityId === runtime.agentId) {
+      return false;
+    }
+    if (!message.content?.text) {
+      return false;
+    }
     const memoryService = runtime.getService("memory");
     if (!memoryService) {
       return false;
     }
     const config = memoryService.getConfig();
-    if (!config.summarization?.enabled) {
-      logger6.debug("Summarization is not enabled");
+    if (!config.longTermExtractionEnabled) {
+      logger3.debug("Long-term memory extraction is disabled");
       return false;
     }
-    if (!summarizationCounters.has(message.roomId)) {
-      summarizationCounters.set(message.roomId, 0);
-    }
-    const currentCount = summarizationCounters.get(message.roomId) + 1;
-    summarizationCounters.set(message.roomId, currentCount);
-    const threshold = config.summarization.messagesPerSummary;
-    logger6.debug({
-      currentCount,
-      threshold,
-      messageId: message.id,
-      entityId: message.entityId,
-      roomId: message.roomId
-    }, "Message counted for summarization (user + agent messages)");
-    const shouldSummarize = currentCount >= threshold;
-    if (shouldSummarize) {
-      logger6.info({
-        roomId: message.roomId,
-        messageCount: currentCount,
-        threshold
-      }, "Summarization threshold reached (Level 1) - triggering summarization");
-    }
-    return shouldSummarize;
+    const currentMessageCount = await runtime.countMemories(message.roomId, false, "messages");
+    const shouldRun = await memoryService.shouldRunExtraction(message.entityId, message.roomId, currentMessageCount);
+    return shouldRun;
   },
   handler: async (runtime, message) => {
     const memoryService = runtime.getService("memory");
     if (!memoryService) {
-      logger6.warn("MemoryService not available for summarization");
+      logger3.error("MemoryService not found");
       return;
     }
     const config = memoryService.getConfig();
-    if (!config.summarization?.enabled) {
-      return;
-    }
-    const messageCount = summarizationCounters.get(message.roomId) || 0;
-    if (messageCount === 0) {
-      return;
-    }
-    logger6.info({
-      roomId: message.roomId,
-      messageCount
-    }, "Starting Level 1 summarization - pulling messages from database");
+    const { entityId, roomId } = message;
     try {
-      const previousSummary = await memoryService.getMostRecentLevel1Summary(message.roomId, message.entityId);
-      const messages = await fetchMessagesSinceLastSummary(runtime, message.roomId, previousSummary?.endTime);
-      if (messages.length === 0) {
-        logger6.warn({ roomId: message.roomId }, "No messages found for summarization");
-        return;
-      }
-      const summary = await createLevel1Summary(runtime, memoryService, messages, message.roomId, previousSummary);
-      if (summary) {
-        logger6.info({
-          summaryId: summary.id,
-          tokenCount: summary.tokenCount,
-          messageCount: messages.length,
-          startTime: summary.startTime,
-          endTime: summary.endTime
-        }, "Created Level 1 summary from database messages");
-        summarizationCounters.set(message.roomId, 0);
-        await checkAndTriggerHigherLevelSummarization(runtime, memoryService, summary.roomId, summary.level);
+      logger3.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 = composePromptFromState2({
+        state: {
+          ...state,
+          recentMessages: formattedMessages,
+          existingMemories: formattedExisting
+        },
+        template: extractionTemplate
+      });
+      const response = await runtime.useModel(ModelType2.TEXT_LARGE, {
+        prompt
+      });
+      const extractions = parseMemoryExtractionXML(response);
+      logger3.info(`Extracted ${extractions.length} long-term memories`);
+      for (const extraction of extractions) {
+        if (extraction.confidence >= Math.max(config.longTermConfidenceThreshold, 0.85)) {
+          await memoryService.storeLongTermMemory({
+            agentId: runtime.agentId,
+            entityId,
+            category: extraction.category,
+            content: extraction.content,
+            confidence: extraction.confidence,
+            source: "conversation",
+            metadata: {
+              roomId,
+              extractedAt: new Date().toISOString()
+            }
+          });
+          logger3.info(`Stored long-term memory: [${extraction.category}] ${extraction.content.substring(0, 50)}...`);
+        } else {
+          logger3.debug(`Skipped low-confidence memory: ${extraction.content} (confidence: ${extraction.confidence}, threshold: ${Math.max(config.longTermConfidenceThreshold, 0.85)})`);
+        }
       }
+      const currentMessageCount = await runtime.countMemories(roomId, false, "messages");
+      await memoryService.setLastExtractionCheckpoint(entityId, roomId, currentMessageCount);
+      logger3.debug(`Updated extraction checkpoint to ${currentMessageCount} for entity ${entityId} in room ${roomId}`);
     } catch (error) {
-      logger6.error({
-        error,
-        roomId: message.roomId
-      }, "Failed to create summary");
+      logger3.error({ error }, "Error during long-term memory extraction:");
     }
   },
   examples: []
 };
-async function fetchMessagesSinceLastSummary(runtime, roomId, lastSummaryEndTime) {
-  const allMessages = await runtime.getMemories({
-    tableName: "messages",
-    roomId,
-    count: 1000,
-    unique: false
-  });
-  const dialogueMessages = allMessages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result"));
-  let messages = dialogueMessages;
-  if (lastSummaryEndTime) {
-    messages = dialogueMessages.filter((msg) => {
-      if (!msg.createdAt)
-        return false;
-      const msgTime = new Date(msg.createdAt);
-      return msgTime > lastSummaryEndTime;
-    });
-  }
-  messages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
-  logger6.debug({
-    roomId,
-    totalMessages: allMessages.length,
-    dialogueMessages: dialogueMessages.length,
-    filteredMessages: messages.length,
-    lastSummaryEndTime: lastSummaryEndTime?.toISOString()
-  }, "Fetched messages for summarization");
-  return messages;
-}
-function parseSummarizationResult(response) {
-  try {
-    const responseText = typeof response === "string" ? response : JSON.stringify(response);
-    const analysisMatch = responseText.match(/\[ANALYSIS\](.*?)(?:\[RESULT\]|$)/s);
-    const reasoningTrace = analysisMatch ? analysisMatch[1].trim() : "";
-    const resultMatch = responseText.match(/\[RESULT\](.*?)$/s);
-    const resultText = resultMatch ? resultMatch[1].trim() : "";
-    let summary = "";
-    let keyTopics = "";
-    if (resultText) {
-      const lines = resultText.split(`
-`);
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith("SUMM|")) {
-          const parts = trimmed.split("|");
-          if (parts.length >= 3) {
-            keyTopics = parts[1].trim();
-            summary = parts.slice(2).join("|").trim();
-            break;
-          }
-        }
-      }
-    }
-    return { summary, keyTopics, reasoningTrace };
-  } catch (error) {
-    logger6.error({ error }, "Failed to parse summarization response");
-    return { summary: "", keyTopics: "", reasoningTrace: "" };
-  }
-}
-async function createLevel1Summary(runtime, memoryService, messages, roomId, previousSummary) {
-  const formattedMessages = messages.map((m, i) => {
-    const text3 = typeof m.content === "string" ? m.content : m.content.text || "";
-    const author = m.entityId === runtime.agentId ? "Agent" : "User";
-    const timestamp3 = m.createdAt ? new Date(m.createdAt).toISOString() : "Unknown time";
-    return `[${timestamp3}] ${author}: ${text3}`;
-  }).join(`
-`);
-  let prompt;
-  if (previousSummary) {
-    prompt = buildLevel1SummaryPrompt(formattedMessages, previousSummary.content);
-  } else {
-    prompt = buildLevel1SummaryPrompt(formattedMessages);
-  }
-  const originalSystemPrompt = runtime.character.system;
-  try {
-    runtime.character.system = SUMMARIZATION_SYSTEM_PROMPT;
-    logger6.debug("Calling LLM for Level 1 summarization with timestamped conversation log");
-    const response = await runtime.useModel(ModelType4.TEXT_LARGE, {
-      prompt,
-      temperature: 0.3
-    });
-    runtime.character.system = originalSystemPrompt;
-    const { summary, keyTopics, reasoningTrace } = parseSummarizationResult(response);
-    if (!summary) {
-      logger6.warn({ reasoningTrace }, "No summary extracted from LLM response");
-      return null;
-    }
-    const tokenCount = estimateTokensInSummary(summary);
-    const startTime = messages[0].createdAt ? new Date(messages[0].createdAt) : new Date;
-    const endTime = messages[messages.length - 1].createdAt ? new Date(messages[messages.length - 1].createdAt) : new Date;
-    const summaryData = {
-      agentId: runtime.agentId,
-      entityId: messages[0].entityId,
-      roomId,
-      level: 1,
-      parentSummaryId: undefined,
-      content: summary,
-      tokenCount,
-      startTime,
-      endTime,
-      sourceCount: messages.length,
-      sourceIds: messages.map((m) => m.id),
-      metadata: {
-        keyTopics,
-        hasPreviousSummary: !!previousSummary
-      }
-    };
-    return await memoryService.storeSummary(summaryData);
-  } catch (error) {
-    logger6.error({ error }, "Failed to call LLM for Level 1 summarization");
-    runtime.character.system = originalSystemPrompt;
-    return null;
-  }
-}
-async function checkAndTriggerHigherLevelSummarization(runtime, memoryService, roomId, currentLevel) {
-  const config = memoryService.getConfig();
-  if (!config.summarization) {
-    return;
-  }
-  if (currentLevel >= config.summarization.maxDepth) {
-    logger6.debug({ currentLevel, maxDepth: config.summarization.maxDepth }, "Max depth reached");
-    return;
-  }
-  const summaries = await memoryService.getSummariesByLevel(roomId, currentLevel);
-  const threshold = config.summarization.summariesPerLevel;
-  if (summaries.length < threshold) {
-    return;
-  }
-  logger6.info({
-    level: currentLevel,
-    count: summaries.length,
-    nextLevel: currentLevel + 1
-  }, `Triggering Level ${currentLevel + 1} summarization`);
-  const higherSummary = await createHigherLevelSummary(runtime, memoryService, summaries, roomId, currentLevel + 1);
-  if (higherSummary) {
-    await checkAndTriggerHigherLevelSummarization(runtime, memoryService, roomId, currentLevel + 1);
-  }
-}
-async function createHigherLevelSummary(runtime, memoryService, lowerSummaries, roomId, level) {
-  const formattedSummaries = lowerSummaries.map((s, i) => `<summary${i + 1}>${s.content}</summary${i + 1}>`).join(`
-`);
-  const prompt = buildHigherLevelSummaryPrompt(formattedSummaries);
-  const originalSystemPrompt = runtime.character.system;
-  try {
-    runtime.character.system = HIGHER_LEVEL_SUMMARIZATION_SYSTEM_PROMPT;
-    const response = await runtime.useModel(ModelType4.TEXT_LARGE, {
-      prompt,
-      temperature: 0.3
-    });
-    runtime.character.system = originalSystemPrompt;
-    const { summary, keyTopics, reasoningTrace } = parseSummarizationResult(response);
-    if (!summary) {
-      logger6.warn({ reasoningTrace }, "No higher-level summary extracted from LLM response");
-      return null;
-    }
-    const tokenCount = estimateTokensInSummary(summary);
-    const startTime = new Date(Math.min(...lowerSummaries.map((s) => s.startTime.getTime())));
-    const endTime = new Date(Math.max(...lowerSummaries.map((s) => s.endTime.getTime())));
-    const summaryData = {
-      agentId: runtime.agentId,
-      entityId: lowerSummaries[0].entityId,
-      roomId,
-      level,
-      parentSummaryId: undefined,
-      content: summary,
-      tokenCount,
-      startTime,
-      endTime,
-      sourceCount: lowerSummaries.length,
-      sourceIds: lowerSummaries.map((s) => s.id),
-      metadata: {
-        keyTopics,
-        compressedSummaries: lowerSummaries.length
-      }
-    };
-    return await memoryService.storeSummary(summaryData);
-  } catch (error) {
-    logger6.error({ error, level }, "Failed to create higher-level summary");
-    runtime.character.system = originalSystemPrompt;
-    return null;
-  }
-}
 
 // src/providers/long-term-memory.ts
 import {
-  logger as logger7,
+  logger as logger4,
   addHeader
 } from "@elizaos/core";
 var longTermMemoryProvider = {
   name: "LONG_TERM_MEMORY",
-  description: "User knowledge and facts (semantic + procedural memory)",
-  position: 80,
-  get: async (runtime, message, state) => {
+  description: "Persistent facts and preferences about the user",
+  position: 50,
+  get: async (runtime, message, _state) => {
     try {
       const memoryService = runtime.getService("memory");
       if (!memoryService) {
-        logger7.warn("Memory service not available");
         return {
-          data: {},
-          values: {},
+          data: { memories: [] },
+          values: { longTermMemories: "" },
           text: ""
         };
       }
-      const entityId = message.entityId;
-      const roomId = message.roomId;
-      const query = typeof message.content === "string" ? message.content : message.content.text || JSON.stringify(message.content);
-      logger7.debug({
-        entityId,
-        roomId,
-        queryLength: query.length
-      }, "Retrieving unified memories");
-      const config = memoryService.getConfig();
-      const [semanticMemories, proceduralMemories, episodicMemories] = await Promise.all([
-        memoryService.searchLongTermMemories({
-          entityId,
-          query,
-          roomId,
-          type: "SEMANTIC" /* SEMANTIC */,
-          limit: config.retrievalLimit,
-          minConfidence: config.minConfidence,
-          similarityThreshold: 0.15
-        }),
-        memoryService.searchLongTermMemories({
-          entityId,
-          query,
-          roomId,
-          type: "PROCEDURAL" /* PROCEDURAL */,
-          limit: Math.floor(config.retrievalLimit / 2),
-          minConfidence: config.minConfidence,
-          similarityThreshold: 0.15
-        }),
-        memoryService.searchLongTermMemories({
-          entityId,
-          query,
-          roomId,
-          type: "EPISODIC" /* EPISODIC */,
-          limit: config.retrievalLimit,
-          minConfidence: config.minConfidence,
-          similarityThreshold: 0.15
-        })
-      ]);
-      const longTermSections = [];
-      if (semanticMemories.length > 0) {
-        const items = semanticMemories.map((m) => `- ${m.content} (confidence: ${m.confidence.toFixed(2)}, strength: ${m.activationScore.toFixed(2)})`).join(`
-`);
-        longTermSections.push(addHeader("## Semantic Knowledge (Facts)", items));
+      const { entityId } = message;
+      if (entityId === runtime.agentId) {
+        return {
+          data: { memories: [] },
+          values: { longTermMemories: "" },
+          text: ""
+        };
       }
-      if (proceduralMemories.length > 0) {
-        const items = proceduralMemories.map((m) => `- ${m.content}`).join(`
-`);
-        longTermSections.push(addHeader("## Procedural Knowledge (Skills & Patterns)", items));
+      const memories = await memoryService.getLongTermMemories(entityId, undefined, 25);
+      if (memories.length === 0) {
+        return {
+          data: { memories: [] },
+          values: { longTermMemories: "" },
+          text: ""
+        };
       }
-      if (episodicMemories.length > 0) {
-        const items = episodicMemories.map((m) => `- ${m.content} (occurred: ${m.createdAt ? new Date(m.createdAt).toLocaleDateString() : "Unknown"})`).join(`
-`);
-        longTermSections.push(addHeader("## Significant Past Events", items));
+      const formattedMemories = await memoryService.getFormattedLongTermMemories(entityId);
+      const text4 = 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);
       }
-      const longTermMemoriesText = longTermSections.join(`
-
-`);
-      const data = {
-        semanticMemories,
-        proceduralMemories,
-        episodicMemories,
-        config: {
-          retrievalLimit: config.retrievalLimit,
-          tokenBudget: config.tokenBudget
-        }
-      };
-      const values = {
-        longTermMemories: longTermMemoriesText
-      };
-      const text3 = longTermMemoriesText;
-      logger7.info({
-        semanticCount: semanticMemories.length,
-        proceduralCount: proceduralMemories.length,
-        episodicCount: episodicMemories.length
-      }, "Retrieved long-term memory facts");
+      const categoryList = Array.from(categoryCounts.entries()).map(([cat, count]) => `${cat}: ${count}`).join(", ");
       return {
-        data,
-        values,
-        text: text3
+        data: {
+          memories,
+          categoryCounts: Object.fromEntries(categoryCounts)
+        },
+        values: {
+          longTermMemories: text4,
+          memoryCategories: categoryList
+        },
+        text: text4
       };
     } catch (error) {
-      logger7.error({ error }, "Failed to retrieve long-term memories");
+      logger4.error({ error }, "Error in longTermMemoryProvider:");
       return {
-        data: {},
-        values: {
-          longTermMemories: ""
-        },
+        data: { memories: [] },
+        values: { longTermMemories: "" },
         text: ""
       };
     }
   }
 };
 
-// src/providers/recent-conversation-summary.ts
+// src/providers/context-summary.ts
 import {
   addHeader as addHeader2,
-  ChannelType,
-  formatMessages,
-  formatPosts,
-  getEntityDetails,
-  logger as logger8
+  logger as logger5
 } from "@elizaos/core";
-var getProviderConfig = (runtime) => ({
-  overlapUserMessageCount: parseInt(runtime.getSetting("CONTEXT_OVERLAP_USER_MESSAGES") || "2", 10)
-});
-async function fetchConversationData(runtime, roomId) {
-  const [entities, room, allMessages] = await Promise.all([
-    getEntityDetails({ runtime, roomId }),
-    runtime.getRoom(roomId),
-    runtime.getMemories({
-      tableName: "messages",
-      roomId,
-      count: 100,
-      unique: false
-    })
-  ]);
-  return { entities, room, allMessages };
-}
-function filterAndSortDialogueMessages(allMessages) {
-  const dialogueMessages = allMessages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result"));
-  dialogueMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
-  return dialogueMessages;
-}
-async function buildCompressedHistory(runtime, message, dialogueMessages, sessionStartTime) {
-  let compressedHistoryText = "";
-  let lastSummarizedIndex = -1;
-  const memoryService = runtime.getService("memory");
-  if (!memoryService?.searchSummaries) {
-    return { compressedHistoryText, lastSummarizedIndex };
-  }
-  try {
-    const summaries = await memoryService.searchSummaries({
-      entityId: message.entityId,
-      roomId: message.roomId,
-      query: typeof message.content === "string" ? message.content : message.content.text || "",
-      limit: 3,
-      tokenBudget: 500
-    });
-    if (summaries.length === 0) {
-      return { compressedHistoryText, lastSummarizedIndex };
-    }
-    lastSummarizedIndex = findLastSummarizedMessageIndex(summaries, dialogueMessages);
-    const summaryItems = summaries.map((s) => {
-      const levelLabel = s.level === 1 ? "Recent Session" : `Overview (L${s.level})`;
-      return `**[${levelLabel}]** ${s.content}`;
-    }).join(`
-
-`);
-    const headerText = `# Conversation History (Compressed)
-**Session Started:** ${formatDateTime(sessionStartTime)}`;
-    compressedHistoryText = addHeader2(headerText, summaryItems);
-    logger8.debug({
-      summaryCount: summaries.length,
-      totalTokens: summaries.reduce((sum, s) => sum + s.tokenCount, 0),
-      lastSummarizedIndex
-    }, "Using hierarchical summaries for compressed history");
-  } catch (error) {
-    logger8.warn({ error }, "Failed to retrieve summaries");
-  }
-  return { compressedHistoryText, lastSummarizedIndex };
-}
-function findLastSummarizedMessageIndex(summaries, dialogueMessages) {
-  const level1Summaries = summaries.filter((s) => s.level === 1);
-  if (level1Summaries.length === 0) {
-    return -1;
-  }
-  const allSummarizedMessageIds = new Set;
-  level1Summaries.forEach((summary) => {
-    summary.sourceIds.forEach((id) => allSummarizedMessageIds.add(id));
-  });
-  for (let i = dialogueMessages.length - 1;i >= 0; i--) {
-    if (allSummarizedMessageIds.has(dialogueMessages[i].id)) {
-      logger8.debug({
-        lastSummarizedIndex: i,
-        totalMessages: dialogueMessages.length,
-        summarizedCount: allSummarizedMessageIds.size
-      }, "Determined last summarized message index");
-      return i;
-    }
-  }
-  return -1;
-}
-function calculateBufferMessages(runtime, dialogueMessages, lastSummarizedIndex, hasSummaries, overlapUserMessageCount) {
-  let bufferMessages;
-  if (lastSummarizedIndex >= 0 && hasSummaries) {
-    const summarizedMessages = dialogueMessages.slice(0, lastSummarizedIndex + 1);
-    const summarizedUserMessages = summarizedMessages.filter((m) => m.entityId !== runtime.agentId);
-    const overlapUserMessages = summarizedUserMessages.slice(-overlapUserMessageCount);
-    const newUnsummarizedMessages = dialogueMessages.slice(lastSummarizedIndex + 1);
-    let overlapStartIndex = lastSummarizedIndex + 1;
-    if (overlapUserMessages.length > 0) {
-      const firstOverlapUserMessageId = overlapUserMessages[0].id;
-      const foundIndex = dialogueMessages.findIndex((m) => m.id === firstOverlapUserMessageId);
-      if (foundIndex >= 0) {
-        overlapStartIndex = foundIndex;
-      }
-    }
-    bufferMessages = dialogueMessages.slice(overlapStartIndex);
-    logger8.debug({
-      lastSummarizedIndex,
-      summarizedMessageCount: summarizedMessages.length,
-      overlapStartIndex,
-      overlapSize: lastSummarizedIndex + 1 - overlapStartIndex,
-      newUnsummarizedCount: newUnsummarizedMessages.length,
-      bufferSize: bufferMessages.length,
-      totalDialogueMessages: dialogueMessages.length,
-      overlapUserMessageCount
-    }, `Dynamic buffer: [overlap: last ${overlapUserMessageCount} user msgs from summary] + [all new unsummarized messages]`);
-  } else {
-    bufferMessages = dialogueMessages;
-    logger8.debug({
-      bufferSize: bufferMessages.length,
-      totalMessages: dialogueMessages.length
-    }, "Using full conversation: no summaries yet");
-  }
-  return { bufferMessages, lastSummarizedIndex };
-}
-function formatDateTime(timestamp3) {
-  const date = new Date(timestamp3);
-  return date.toLocaleString("en-US", {
-    year: "numeric",
-    month: "short",
-    day: "numeric",
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false
-  });
-}
-function removeEntityIds(text3) {
-  return text3.replace(/\s*\[[\w\-]+\]/g, "").replace(/\s*\([^)]*'s internal thought:[^)]*\)/gi, "").split(`
-`).map((line) => line.trim()).join(`
-`).replace(/\n{3,}/g, `
-
-`);
-}
-async function formatBufferMessages(bufferMessages, entities, room, sessionStartTime) {
-  const isPostFormat = room?.type ? room.type === ChannelType.FEED || room.type === ChannelType.THREAD : false;
-  const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
-    formatMessages({
-      messages: bufferMessages,
-      entities
-    }),
-    formatPosts({
-      messages: bufferMessages,
-      entities,
-      conversationHeader: false
-    })
-  ]);
-  let recentBufferText = (isPostFormat ? formattedRecentPosts : formattedRecentMessages) || "";
-  recentBufferText = removeEntityIds(recentBufferText);
-  const firstBufferTime = bufferMessages.length > 0 ? bufferMessages[0].createdAt : null;
-  const lastBufferTime = bufferMessages.length > 0 ? bufferMessages[bufferMessages.length - 1].createdAt : null;
-  let headerText = `# Recent Messages (Last ${bufferMessages.length})`;
-  if (firstBufferTime && lastBufferTime) {
-    headerText += `
-**Time Range:** ${formatDateTime(firstBufferTime)} - ${formatDateTime(lastBufferTime)}`;
-  }
-  return recentBufferText ? addHeader2(headerText, recentBufferText) : "";
-}
-function buildReceivedMessageSection(message, entities) {
-  const metaData = message.metadata;
-  const senderName = entities.find((entity) => entity.id === message.entityId)?.names[0] || metaData?.entityName || "Unknown User";
-  const receivedMessageContent = message.content.text;
-  const hasReceivedMessage = !!receivedMessageContent?.trim();
-  const receivedMessageHeader = hasReceivedMessage ? addHeader2("# Current Message", `**From ${senderName}:** ${receivedMessageContent}`) : "";
-  const focusHeader = hasReceivedMessage ? addHeader2("# Response Focus", `Reply to **${senderName}**'s current message above. Stay relevant to their question. Don't repeat previous responses unless asked again.`) : "";
-  return { receivedMessageHeader, focusHeader };
-}
-function assembleContextSections(compressedHistoryText, recentBufferHeader, receivedMessageHeader, focusHeader) {
-  const textSections = [
-    compressedHistoryText,
-    recentBufferHeader,
-    receivedMessageHeader,
-    focusHeader
-  ].filter(Boolean);
-  return textSections.join(`
-
-`);
-}
-var recentContextProvider = {
-  name: "RECENT_CONVERSATION_SUMMARY",
-  description: "Intelligent context management combining recent messages with hierarchical summaries for optimal token efficiency",
-  position: 100,
-  get: async (runtime, message) => {
+var contextSummaryProvider = {
+  name: "SUMMARIZED_CONTEXT",
+  description: "Provides summarized context from previous conversations",
+  position: 96,
+  get: async (runtime, message, _state) => {
     try {
+      const memoryService = runtime.getService("memory");
       const { roomId } = message;
-      const config = getProviderConfig(runtime);
-      const { entities, room, allMessages } = await fetchConversationData(runtime, roomId);
-      const dialogueMessages = filterAndSortDialogueMessages(allMessages);
-      const sessionStartTime = dialogueMessages.length > 0 ? dialogueMessages[0].createdAt || Date.now() : Date.now();
-      const { compressedHistoryText, lastSummarizedIndex } = await buildCompressedHistory(runtime, message, dialogueMessages, sessionStartTime);
-      const hasSummaries = !!compressedHistoryText;
-      const { bufferMessages } = calculateBufferMessages(runtime, dialogueMessages, lastSummarizedIndex, hasSummaries, config.overlapUserMessageCount);
-      const recentBufferHeader = await formatBufferMessages(bufferMessages, entities, room, sessionStartTime);
-      const { receivedMessageHeader, focusHeader } = buildReceivedMessageSection(message, entities);
-      const text3 = assembleContextSections(compressedHistoryText, recentBufferHeader, receivedMessageHeader, focusHeader);
-      const data = {
-        dialogueMessages: bufferMessages,
-        messageCount: dialogueMessages.length,
-        lastSummarizedIndex,
-        config
-      };
-      const isPostFormat = room?.type ? room.type === ChannelType.FEED || room.type === ChannelType.THREAD : false;
-      const values = {
-        compressedHistory: compressedHistoryText,
-        recentMessages: recentBufferHeader,
-        receivedMessage: receivedMessageHeader,
-        focusInstruction: focusHeader,
-        recentPosts: isPostFormat ? recentBufferHeader : ""
-      };
-      logger8.info({
-        messageCount: dialogueMessages.length,
-        bufferSize: bufferMessages.length,
-        hasSummaries,
-        lastSummarizedIndex,
-        estimatedTokens: Math.ceil(text3.length / 4),
-        overlapUserMessageCount: config.overlapUserMessageCount
-      }, "Recent context assembled");
-      return {
-        data,
-        values,
-        text: text3
-      };
-    } catch (error) {
-      logger8.error({ error }, "Error in recentContextProvider");
-      return {
-        data: {
-          dialogueMessages: [],
-          messageCount: 0,
-          lastSummarizedIndex: -1,
-          config: getProviderConfig(runtime)
-        },
-        values: {
-          compressedHistory: "",
-          recentMessages: "",
-          receivedMessage: "",
-          focusInstruction: "",
-          recentPosts: ""
-        },
-        text: "Error retrieving context."
-      };
-    }
-  }
-};
-
-// src/providers/action-results.ts
-import { addHeader as addHeader3, logger as logger9 } from "@elizaos/core";
-var getActionResultsConfig = (runtime) => ({
-  limit: parseInt(runtime.getSetting("CONTEXT_ACTION_RESULTS_LIMIT") || "3", 10)
-});
-function formatActionResults(actionResultMessages, limit) {
-  if (actionResultMessages.length === 0) {
-    return "";
-  }
-  const groupedByRun = new Map;
-  for (const mem of actionResultMessages) {
-    const runId = String(mem.content?.runId || "unknown");
-    if (!groupedByRun.has(runId)) {
-      groupedByRun.set(runId, []);
-    }
-    groupedByRun.get(runId).push(mem);
-  }
-  const formattedActionResults = Array.from(groupedByRun.entries()).slice(-limit).map(([runId, memories]) => {
-    const sortedMemories = memories.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
-    const thought = sortedMemories[0]?.content?.planThought || "";
-    const runText = sortedMemories.map((mem) => {
-      const actionName = mem.content?.actionName || "Unknown";
-      const status = mem.content?.actionStatus || "unknown";
-      const planStep = mem.content?.planStep || "";
-      const text3 = mem.content?.text || "";
-      const error = mem.content?.error || "";
-      let memText = `  - ${actionName} (${status})`;
-      if (planStep)
-        memText += ` [${planStep}]`;
-      if (error) {
-        memText += `: Error - ${error}`;
-      } else if (text3 && text3 !== `Executed action: ${actionName}`) {
-        memText += `: ${text3}`;
+      if (!memoryService) {
+        return {
+          data: {
+            summary: null
+          },
+          values: {
+            sessionSummaries: "",
+            sessionSummariesWithTopics: ""
+          },
+          text: ""
+        };
       }
-      return memText;
-    }).join(`
-`);
-    return `**Action Run ${runId.slice(0, 8)}**${thought ? ` - "${thought}"` : ""}
-${runText}`;
-  }).join(`
-
-`);
-  return formattedActionResults ? addHeader3("# Recent Action Executions", formattedActionResults) : "";
-}
-var actionResultsProvider = {
-  name: "ACTION_RESULTS",
-  description: "Recent action executions with their outcomes (tool memory)",
-  position: 101,
-  get: async (runtime, message) => {
-    try {
-      const { roomId } = message;
-      const config = getActionResultsConfig(runtime);
-      const allMessages = await runtime.getMemories({
-        tableName: "messages",
-        roomId,
-        count: 50,
-        unique: false
-      });
-      const actionResultMessages = allMessages.filter((msg) => msg.content?.type === "action_result" && msg.metadata?.type === "action_result");
-      actionResultMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
-      const text3 = formatActionResults(actionResultMessages, config.limit);
-      logger9.debug({
-        actionResultCount: actionResultMessages.length,
-        limit: config.limit
-      }, "Action results provider assembled");
+      const currentSummary = await memoryService.getCurrentSessionSummary(roomId);
+      if (!currentSummary) {
+        return {
+          data: {
+            summary: null
+          },
+          values: {
+            sessionSummaries: "",
+            sessionSummariesWithTopics: ""
+          },
+          text: ""
+        };
+      }
+      const messageRange = `${currentSummary.messageCount} messages`;
+      const timeRange = new Date(currentSummary.startTime).toLocaleDateString();
+      let summaryOnly = `**Previous Conversation** (${messageRange}, ${timeRange})
+`;
+      summaryOnly += currentSummary.summary;
+      let summaryWithTopics = summaryOnly;
+      if (currentSummary.topics && currentSummary.topics.length > 0) {
+        summaryWithTopics += `
+*Topics: ${currentSummary.topics.join(", ")}*`;
+      }
+      const sessionSummaries2 = addHeader2("# Conversation Summary", summaryOnly);
+      const sessionSummariesWithTopics = addHeader2("# Conversation Summary", summaryWithTopics);
       return {
         data: {
-          actionResults: actionResultMessages,
-          config
+          summary: currentSummary
         },
         values: {
-          recentActionResults: text3
+          sessionSummaries: sessionSummaries2,
+          sessionSummariesWithTopics
         },
-        text: text3
+        text: sessionSummariesWithTopics
       };
     } catch (error) {
-      logger9.error({ error }, "Error in actionResultsProvider");
+      logger5.error({ error }, "Error in contextSummaryProvider:");
       return {
         data: {
-          actionResults: [],
-          config: getActionResultsConfig(runtime)
+          summary: null
         },
         values: {
-          recentActionResults: ""
+          sessionSummaries: "",
+          sessionSummariesWithTopics: ""
         },
         text: ""
       };
     }
   }
 };
+
 // src/index.ts
 var memoryPlugin = {
   name: "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",
+  description: "Advanced memory management with conversation summarization and long-term persistent memory",
   services: [MemoryService],
-  evaluators: [consolidationEvaluator, summarizationEvaluator],
-  providers: [longTermMemoryProvider, recentContextProvider, actionResultsProvider],
+  evaluators: [summarizationEvaluator, longTermExtractionEvaluator],
+  providers: [
+    longTermMemoryProvider,
+    contextSummaryProvider
+  ],
   schema: exports_schemas
 };
 var src_default = memoryPlugin;
 export {
-  trimToTokenBudget,
-  recentContextProvider,
-  mergeSearchResults,
+  sessionSummaries,
   memoryPlugin,
-  mapDbRowToLongTermMemory,
-  mapDbRowToConversationSummary,
+  memoryAccessLogs,
   longTermMemoryProvider,
-  longTermMemoryEmbeddings,
   longTermMemories,
-  generateEmbedding,
-  formatTokenCount,
-  formatMemoriesForContext,
-  estimateTokensInSummary,
-  estimateTokenCountForArray,
-  estimateTokenCount,
   src_default as default,
-  conversationSummaryEmbeddings,
-  conversationSummaries,
-  cleanEmbedding,
-  calculateDecayFactor,
-  calculateAccessBoost,
-  buildLevel1SummaryPrompt,
-  buildHigherLevelSummaryPrompt,
-  buildExtractionPrompt,
-  buildContradictionPrompt,
-  applyDecayScoring,
-  actionResultsProvider,
-  SUMMARIZATION_SYSTEM_PROMPT,
-  MemoryType,
+  contextSummaryProvider,
   MemoryService,
-  MEMORY_DIMENSION_MAP,
-  LongTermMemoryRepository,
-  HIGHER_LEVEL_SUMMARIZATION_SYSTEM_PROMPT,
-  DecayFunction,
-  ConversationSummaryRepository,
-  CONSOLIDATION_SYSTEM_PROMPT
+  LongTermMemoryCategory
 };
 
-//# debugId=925F6225A20E2D9B64756E2164756E21
+//# debugId=6798CB2FB52CC5AF64756E2164756E21