@elizaos/plugin-sql 2.0.0-alpha.19 → 2.0.0-alpha.20

package/dist/node/index.node.js

@@ -41,14 +41,14 @@ var init_agent = __esm(() => {
 });
 
 // schema/server.ts
-import { sql as sql17 } from "drizzle-orm";
-import { pgTable as pgTable19, timestamp as timestamp17, uuid as uuid17 } from "drizzle-orm/pg-core";
+import { sql as sql22 } from "drizzle-orm";
+import { pgTable as pgTable29, timestamp as timestamp21, uuid as uuid21 } from "drizzle-orm/pg-core";
 var serverTable;
 var init_server = __esm(() => {
-  serverTable = pgTable19("servers", {
-    id: uuid17("id").primaryKey(),
-    createdAt: timestamp17("created_at", { withTimezone: true }).default(sql17`now()`).notNull(),
-    updatedAt: timestamp17("updated_at", { withTimezone: true }).default(sql17`now()`).notNull()
+  serverTable = pgTable29("servers", {
+    id: uuid21("id").primaryKey(),
+    createdAt: timestamp21("created_at", { withTimezone: true }).default(sql22`now()`).notNull(),
+    updatedAt: timestamp21("updated_at", { withTimezone: true }).default(sql22`now()`).notNull()
   });
 });
 
@@ -56,27 +56,27 @@ var init_server = __esm(() => {
 function getDb(adapter) {
   return adapter.db;
 }
-function getRow(result, index7 = 0) {
-  return result.rows[index7];
+function getRow(result, index18 = 0) {
+  return result.rows[index18];
 }
 
 // migrations.ts
 import { logger } from "@elizaos/core";
-import { sql as sql19 } from "drizzle-orm";
+import { sql as sql25 } from "drizzle-orm";
 function getRows(result) {
   return result.rows;
 }
 async function migrateToEntityRLS(adapter) {
   const db = getDb(adapter);
   try {
-    await db.execute(sql19`SELECT 1 FROM pg_tables LIMIT 1`);
+    await db.execute(sql25`SELECT 1 FROM pg_tables LIMIT 1`);
   } catch {
     logger.debug("[Migration] ⊘ Not PostgreSQL, skipping PostgreSQL-specific migrations");
     return;
   }
   let schemaAlreadyMigrated = false;
   try {
-    const migrationCheck = await db.execute(sql19`
+    const migrationCheck = await db.execute(sql25`
       SELECT column_name FROM information_schema.columns
       WHERE table_schema = 'public'
         AND table_name = 'rooms'
@@ -98,7 +98,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Schema migrated but RLS disabled, cleaning up...");
     try {
-      const tablesWithRls = await db.execute(sql19`
+      const tablesWithRls = await db.execute(sql25`
         SELECT c.relname as tablename
         FROM pg_class c
         JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -111,7 +111,7 @@ async function migrateToEntityRLS(adapter) {
         for (const row of tablesWithRls.rows) {
           const tableName = row.tablename;
           try {
-            await db.execute(sql19.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
+            await db.execute(sql25.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
           } catch {}
         }
         logger.debug(`[Migration] ✓ RLS cleanup completed (${tablesWithRls.rows.length} tables)`);
@@ -127,14 +127,14 @@ async function migrateToEntityRLS(adapter) {
   try {
     logger.debug("[Migration] → Clearing RuntimeMigrator snapshot cache...");
     try {
-      await db.execute(sql19`DELETE FROM migrations._snapshots WHERE plugin_name = '@elizaos/plugin-sql'`);
+      await db.execute(sql25`DELETE FROM migrations._snapshots WHERE plugin_name = '@elizaos/plugin-sql'`);
       logger.debug("[Migration] ✓ Snapshot cache cleared");
     } catch (_error) {
       logger.debug("[Migration] ⊘ No snapshot cache to clear (migrations schema not yet created)");
     }
     logger.debug("[Migration] → Checking for Row Level Security to disable...");
     try {
-      const tablesWithRls = await db.execute(sql19`
+      const tablesWithRls = await db.execute(sql25`
         SELECT c.relname as tablename
         FROM pg_class c
         JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -147,7 +147,7 @@ async function migrateToEntityRLS(adapter) {
         for (const row of tablesWithRls.rows) {
           const tableName = row.tablename;
           try {
-            await db.execute(sql19.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
+            await db.execute(sql25.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
             logger.debug(`[Migration] ✓ Disabled RLS on ${tableName}`);
           } catch (_error) {
             logger.debug(`[Migration] ⊘ Could not disable RLS on ${tableName}`);
@@ -163,7 +163,7 @@ async function migrateToEntityRLS(adapter) {
     const tablesToMigrate = ["channels", "worlds", "rooms"];
     for (const tableName of tablesToMigrate) {
       try {
-        const columnsResult = await db.execute(sql19`
+        const columnsResult = await db.execute(sql25`
           SELECT column_name, data_type, is_nullable
           FROM information_schema.columns
           WHERE table_schema = 'public'
@@ -179,19 +179,19 @@ async function migrateToEntityRLS(adapter) {
         const oldColumnName = serverIdSnake ? "server_id" : "serverId";
         if (serverId && !messageServerId) {
           logger.debug(`[Migration] → Renaming ${tableName}.${oldColumnName} to message_server_id...`);
-          await db.execute(sql19.raw(`ALTER TABLE "${tableName}" RENAME COLUMN "${oldColumnName}" TO "message_server_id"`));
+          await db.execute(sql25.raw(`ALTER TABLE "${tableName}" RENAME COLUMN "${oldColumnName}" TO "message_server_id"`));
           logger.debug(`[Migration] ✓ Renamed ${tableName}.${oldColumnName} → message_server_id`);
           if (serverId.data_type === "text") {
             try {
               logger.debug(`[Migration] → Dropping DEFAULT constraint on ${tableName}.message_server_id...`);
-              await db.execute(sql19.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
+              await db.execute(sql25.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
               logger.debug(`[Migration] ✓ Dropped DEFAULT constraint`);
             } catch {
               logger.debug(`[Migration] ⊘ No DEFAULT constraint to drop on ${tableName}.message_server_id`);
             }
             try {
               logger.debug(`[Migration] → Converting ${tableName}.message_server_id from text to uuid...`);
-              await db.execute(sql19.raw(`
+              await db.execute(sql25.raw(`
                   ALTER TABLE "${tableName}"
                   ALTER COLUMN "message_server_id" TYPE uuid
                   USING CASE
@@ -208,29 +208,29 @@ async function migrateToEntityRLS(adapter) {
             }
           }
           if (tableName === "channels") {
-            const nullCountResult = await db.execute(sql19.raw(`SELECT COUNT(*) as count FROM "${tableName}" WHERE "message_server_id" IS NULL`));
+            const nullCountResult = await db.execute(sql25.raw(`SELECT COUNT(*) as count FROM "${tableName}" WHERE "message_server_id" IS NULL`));
             const nullCount = nullCountResult.rows?.[0]?.count;
             if (nullCount && parseInt(nullCount, 10) > 0) {
               logger.warn(`[Migration] ⚠️ ${tableName} has ${nullCount} rows with NULL message_server_id - these will be deleted`);
-              await db.execute(sql19.raw(`DELETE FROM "${tableName}" WHERE "message_server_id" IS NULL`));
+              await db.execute(sql25.raw(`DELETE FROM "${tableName}" WHERE "message_server_id" IS NULL`));
               logger.debug(`[Migration] ✓ Deleted ${nullCount} rows with NULL message_server_id from ${tableName}`);
             }
             logger.debug(`[Migration] → Making ${tableName}.message_server_id NOT NULL...`);
-            await db.execute(sql19.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" SET NOT NULL`));
+            await db.execute(sql25.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" SET NOT NULL`));
             logger.debug(`[Migration] ✓ Set ${tableName}.message_server_id NOT NULL`);
           }
         } else if (serverId && messageServerId) {
           logger.debug(`[Migration] → ${tableName} has both columns, dropping ${oldColumnName}...`);
-          await db.execute(sql19.raw(`ALTER TABLE "${tableName}" DROP COLUMN "${oldColumnName}" CASCADE`));
+          await db.execute(sql25.raw(`ALTER TABLE "${tableName}" DROP COLUMN "${oldColumnName}" CASCADE`));
           logger.debug(`[Migration] ✓ Dropped ${tableName}.${oldColumnName}`);
         } else if (!serverId && messageServerId) {
           if (messageServerId.data_type === "text") {
             logger.debug(`[Migration] → ${tableName}.message_server_id exists but is TEXT, needs UUID conversion...`);
             logger.debug(`[Migration] → Dropping DEFAULT constraint on ${tableName}.message_server_id...`);
-            await db.execute(sql19.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
+            await db.execute(sql25.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
             logger.debug(`[Migration] ✓ Dropped DEFAULT constraint`);
             logger.debug(`[Migration] → Converting ${tableName}.message_server_id from text to uuid (generating UUIDs from text)...`);
-            await db.execute(sql19.raw(`
+            await db.execute(sql25.raw(`
               ALTER TABLE "${tableName}"
               ALTER COLUMN "message_server_id" TYPE uuid
               USING CASE
@@ -252,7 +252,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Dropping all remaining RLS-managed server_id columns...");
     try {
-      const serverIdColumnsResult = await db.execute(sql19`
+      const serverIdColumnsResult = await db.execute(sql25`
         SELECT table_name
         FROM information_schema.columns
         WHERE table_schema = 'public'
@@ -274,7 +274,7 @@ async function migrateToEntityRLS(adapter) {
       for (const row of tablesToClean) {
         const tableName = row.table_name;
         try {
-          await db.execute(sql19.raw(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS server_id CASCADE`));
+          await db.execute(sql25.raw(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS server_id CASCADE`));
           logger.debug(`[Migration] ✓ Dropped server_id from ${tableName}`);
         } catch (_error) {
           logger.debug(`[Migration] ⊘ Could not drop server_id from ${tableName}`);
@@ -285,7 +285,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Checking agents.owner_id → server_id rename...");
     try {
-      const agentsColumnsResult = await db.execute(sql19`
+      const agentsColumnsResult = await db.execute(sql25`
         SELECT column_name
         FROM information_schema.columns
         WHERE table_schema = 'public'
@@ -298,11 +298,11 @@ async function migrateToEntityRLS(adapter) {
       const hasServerId = agentsColumns.some((c) => c.column_name === "server_id");
       if (hasOwnerId && !hasServerId) {
         logger.debug("[Migration] → Renaming agents.owner_id to server_id...");
-        await db.execute(sql19.raw(`ALTER TABLE "agents" RENAME COLUMN "owner_id" TO "server_id"`));
+        await db.execute(sql25.raw(`ALTER TABLE "agents" RENAME COLUMN "owner_id" TO "server_id"`));
         logger.debug("[Migration] ✓ Renamed agents.owner_id → server_id");
       } else if (hasOwnerId && hasServerId) {
         logger.debug("[Migration] → Both owner_id and server_id exist, dropping owner_id...");
-        await db.execute(sql19.raw(`ALTER TABLE "agents" DROP COLUMN "owner_id" CASCADE`));
+        await db.execute(sql25.raw(`ALTER TABLE "agents" DROP COLUMN "owner_id" CASCADE`));
         logger.debug("[Migration] ✓ Dropped agents.owner_id");
       } else {
         logger.debug("[Migration] ⊘ agents table already has server_id (or no owner_id), skipping");
@@ -312,7 +312,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Checking for owners → servers data migration...");
     try {
-      const ownersTableResult = await db.execute(sql19`
+      const ownersTableResult = await db.execute(sql25`
         SELECT table_name
         FROM information_schema.tables
         WHERE table_schema = 'public'
@@ -320,7 +320,7 @@ async function migrateToEntityRLS(adapter) {
       `);
       if (ownersTableResult.rows && ownersTableResult.rows.length > 0) {
         logger.debug("[Migration] → Ensuring servers table exists...");
-        await db.execute(sql19.raw(`
+        await db.execute(sql25.raw(`
           CREATE TABLE IF NOT EXISTS "servers" (
             "id" uuid PRIMARY KEY,
             "created_at" timestamp with time zone DEFAULT now() NOT NULL,
@@ -328,7 +328,7 @@ async function migrateToEntityRLS(adapter) {
           )
         `));
         logger.debug("[Migration] → Migrating owners data to servers...");
-        await db.execute(sql19.raw(`
+        await db.execute(sql25.raw(`
           INSERT INTO "servers" ("id", "created_at", "updated_at")
           SELECT "id", COALESCE("created_at", now()), COALESCE("updated_at", now())
           FROM "owners"
@@ -336,7 +336,7 @@ async function migrateToEntityRLS(adapter) {
         `));
         logger.debug("[Migration] ✓ Migrated owners data to servers");
         logger.debug("[Migration] → Dropping obsolete owners table...");
-        await db.execute(sql19.raw(`DROP TABLE IF EXISTS "owners" CASCADE`));
+        await db.execute(sql25.raw(`DROP TABLE IF EXISTS "owners" CASCADE`));
         logger.debug("[Migration] ✓ Dropped obsolete owners table");
       } else {
         logger.debug("[Migration] ⊘ owners table not found, skipping");
@@ -346,7 +346,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Checking server_agents table rename...");
     try {
-      const tablesResult = await db.execute(sql19`
+      const tablesResult = await db.execute(sql25`
         SELECT table_name
         FROM information_schema.tables
         WHERE table_schema = 'public'
@@ -358,16 +358,16 @@ async function migrateToEntityRLS(adapter) {
       const hasMessageServerAgents = tables.some((t) => t.table_name === "message_server_agents");
       if (hasServerAgents && !hasMessageServerAgents) {
         logger.debug("[Migration] → Renaming server_agents to message_server_agents...");
-        await db.execute(sql19.raw(`ALTER TABLE "server_agents" RENAME TO "message_server_agents"`));
+        await db.execute(sql25.raw(`ALTER TABLE "server_agents" RENAME TO "message_server_agents"`));
         logger.debug("[Migration] ✓ Renamed server_agents → message_server_agents");
         logger.debug("[Migration] → Renaming message_server_agents.server_id to message_server_id...");
-        await db.execute(sql19.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
+        await db.execute(sql25.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
         logger.debug("[Migration] ✓ Renamed message_server_agents.server_id → message_server_id");
       } else if (!hasServerAgents && !hasMessageServerAgents) {
         logger.debug("[Migration] ⊘ No server_agents table to migrate");
       } else if (hasMessageServerAgents) {
         logger.debug("[Migration] → Checking message_server_agents columns...");
-        const columnsResult = await db.execute(sql19`
+        const columnsResult = await db.execute(sql25`
           SELECT column_name
           FROM information_schema.columns
           WHERE table_schema = 'public'
@@ -380,11 +380,11 @@ async function migrateToEntityRLS(adapter) {
         const hasMessageServerId = columns.some((c) => c.column_name === "message_server_id");
         if (hasServerId && !hasMessageServerId) {
           logger.debug("[Migration] → Renaming message_server_agents.server_id to message_server_id...");
-          await db.execute(sql19.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
+          await db.execute(sql25.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
           logger.debug("[Migration] ✓ Renamed message_server_agents.server_id → message_server_id");
         } else if (!hasServerId && !hasMessageServerId) {
           logger.debug("[Migration] → message_server_agents exists without required columns, truncating...");
-          await db.execute(sql19`TRUNCATE TABLE message_server_agents CASCADE`);
+          await db.execute(sql25`TRUNCATE TABLE message_server_agents CASCADE`);
           logger.debug("[Migration] ✓ Truncated message_server_agents");
         } else {
           logger.debug("[Migration] ⊘ message_server_agents already has correct schema");
@@ -395,7 +395,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Checking channel_participants table...");
     try {
-      const columnsResult = await db.execute(sql19`
+      const columnsResult = await db.execute(sql25`
         SELECT column_name
         FROM information_schema.columns
         WHERE table_schema = 'public'
@@ -410,11 +410,11 @@ async function migrateToEntityRLS(adapter) {
       const hasEntityId = columns.some((c) => c.column_name === "entity_id");
       if (hasUserId && !hasEntityId) {
         logger.debug("[Migration] → Renaming channel_participants.user_id to entity_id...");
-        await db.execute(sql19.raw(`ALTER TABLE "channel_participants" RENAME COLUMN "user_id" TO "entity_id"`));
+        await db.execute(sql25.raw(`ALTER TABLE "channel_participants" RENAME COLUMN "user_id" TO "entity_id"`));
         logger.debug("[Migration] ✓ Renamed channel_participants.user_id → entity_id");
       } else if (!hasUserId && !hasEntityId) {
         logger.debug("[Migration] → channel_participants exists without entity_id or user_id, truncating...");
-        await db.execute(sql19`TRUNCATE TABLE channel_participants CASCADE`);
+        await db.execute(sql25`TRUNCATE TABLE channel_participants CASCADE`);
         logger.debug("[Migration] ✓ Truncated channel_participants");
       } else {
         logger.debug("[Migration] ⊘ channel_participants already has entity_id column");
@@ -424,7 +424,7 @@ async function migrateToEntityRLS(adapter) {
     }
     logger.debug("[Migration] → Discovering and dropping all regular indexes...");
     try {
-      const indexesResult = await db.execute(sql19`
+      const indexesResult = await db.execute(sql25`
         SELECT i.relname AS index_name
         FROM pg_index idx
         JOIN pg_class i ON i.oid = idx.indexrelid
@@ -441,7 +441,7 @@ async function migrateToEntityRLS(adapter) {
       for (const row of indexesToDrop) {
         const indexName = row.index_name;
         try {
-          await db.execute(sql19.raw(`DROP INDEX IF EXISTS "${indexName}"`));
+          await db.execute(sql25.raw(`DROP INDEX IF EXISTS "${indexName}"`));
           logger.debug(`[Migration] ✓ Dropped index ${indexName}`);
         } catch (_error) {
           logger.debug(`[Migration] ⊘ Could not drop index ${indexName}`);
@@ -506,14 +506,14 @@ async function migrateToEntityRLS(adapter) {
     ];
     for (const rename of columnRenames) {
       try {
-        const tableExistsResult = await db.execute(sql19`
+        const tableExistsResult = await db.execute(sql25`
           SELECT 1 FROM information_schema.tables
           WHERE table_schema = 'public' AND table_name = ${rename.table}
         `);
         if (!tableExistsResult.rows || tableExistsResult.rows.length === 0) {
           continue;
         }
-        const columnsResult = await db.execute(sql19`
+        const columnsResult = await db.execute(sql25`
           SELECT column_name
           FROM information_schema.columns
           WHERE table_schema = 'public'
@@ -526,11 +526,11 @@ async function migrateToEntityRLS(adapter) {
         const hasNewColumn = columns.some((c) => c.column_name === rename.to);
         if (hasOldColumn && !hasNewColumn) {
           logger.debug(`[Migration] → Renaming ${rename.table}.${rename.from} to ${rename.to}...`);
-          await db.execute(sql19.raw(`ALTER TABLE "${rename.table}" RENAME COLUMN "${rename.from}" TO "${rename.to}"`));
+          await db.execute(sql25.raw(`ALTER TABLE "${rename.table}" RENAME COLUMN "${rename.from}" TO "${rename.to}"`));
           logger.debug(`[Migration] ✓ Renamed ${rename.table}.${rename.from} → ${rename.to}`);
         } else if (hasOldColumn && hasNewColumn) {
           logger.debug(`[Migration] → Both columns exist, dropping ${rename.table}.${rename.from}...`);
-          await db.execute(sql19.raw(`ALTER TABLE "${rename.table}" DROP COLUMN "${rename.from}" CASCADE`));
+          await db.execute(sql25.raw(`ALTER TABLE "${rename.table}" DROP COLUMN "${rename.from}" CASCADE`));
           logger.debug(`[Migration] ✓ Dropped ${rename.table}.${rename.from}`);
         }
       } catch (error) {
@@ -548,17 +548,17 @@ var init_migrations = () => {};
 
 // rls.ts
 import { logger as logger2, validateUuid } from "@elizaos/core";
-import { eq, sql as sql20 } from "drizzle-orm";
+import { eq, sql as sql26 } from "drizzle-orm";
 async function installRLSFunctions(adapter) {
   const db = getDb(adapter);
-  await db.execute(sql20`
+  await db.execute(sql26`
     CREATE TABLE IF NOT EXISTS servers (
       id UUID PRIMARY KEY,
       created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
       updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
     )
   `);
-  await db.execute(sql20`
+  await db.execute(sql26`
     CREATE OR REPLACE FUNCTION current_server_id() RETURNS UUID AS $$
     DECLARE
       app_name TEXT;
@@ -573,7 +573,7 @@ async function installRLSFunctions(adapter) {
     END;
     $$ LANGUAGE plpgsql STABLE;
   `);
-  await db.execute(sql20`
+  await db.execute(sql26`
     CREATE OR REPLACE FUNCTION add_server_isolation(
       schema_name text,
       table_name text
@@ -617,7 +617,7 @@ async function installRLSFunctions(adapter) {
     END;
     $$ LANGUAGE plpgsql;
   `);
-  await db.execute(sql20`
+  await db.execute(sql26`
     CREATE OR REPLACE FUNCTION apply_rls_to_all_tables() RETURNS void AS $$
     DECLARE
       tbl record;
@@ -690,7 +690,7 @@ async function assignAgentToServer(adapter, agentId, serverId) {
 async function applyRLSToNewTables(adapter) {
   const db = getDb(adapter);
   try {
-    await db.execute(sql20`SELECT apply_rls_to_all_tables()`);
+    await db.execute(sql26`SELECT apply_rls_to_all_tables()`);
     logger2.info({ src: "plugin:sql" }, "RLS applied to all tables");
   } catch (error) {
     logger2.warn({ src: "plugin:sql", error: String(error) }, "Failed to apply RLS to some tables");
@@ -699,7 +699,7 @@ async function applyRLSToNewTables(adapter) {
 async function uninstallRLS(adapter) {
   const db = getDb(adapter);
   try {
-    const checkResult = await db.execute(sql20`
+    const checkResult = await db.execute(sql26`
       SELECT EXISTS (
         SELECT FROM pg_tables
         WHERE schemaname = 'public' AND tablename = 'servers'
@@ -716,7 +716,7 @@ async function uninstallRLS(adapter) {
     } catch (_entityRlsError) {
       logger2.debug({ src: "plugin:sql" }, "Entity RLS cleanup skipped (not installed or already cleaned)");
     }
-    await db.execute(sql20`
+    await db.execute(sql26`
       CREATE OR REPLACE FUNCTION _temp_disable_rls_on_table(
         p_schema_name text,
         p_table_name text
@@ -740,7 +740,7 @@ async function uninstallRLS(adapter) {
       END;
       $$ LANGUAGE plpgsql;
     `);
-    const tablesResult = await db.execute(sql20`
+    const tablesResult = await db.execute(sql26`
       SELECT schemaname, tablename
       FROM pg_tables
       WHERE schemaname = 'public'
@@ -750,19 +750,19 @@ async function uninstallRLS(adapter) {
       const schemaName = row.schemaname;
       const tableName = row.tablename;
       try {
-        await db.execute(sql20`SELECT _temp_disable_rls_on_table(${schemaName}, ${tableName})`);
+        await db.execute(sql26`SELECT _temp_disable_rls_on_table(${schemaName}, ${tableName})`);
         logger2.debug({ src: "plugin:sql", schemaName, tableName }, "Disabled RLS on table");
       } catch (error) {
         logger2.warn({ src: "plugin:sql", schemaName, tableName, error: String(error) }, "Failed to disable RLS on table");
       }
     }
-    await db.execute(sql20`DROP FUNCTION IF EXISTS _temp_disable_rls_on_table(text, text)`);
+    await db.execute(sql26`DROP FUNCTION IF EXISTS _temp_disable_rls_on_table(text, text)`);
     logger2.info({ src: "plugin:sql" }, "Keeping server_id values intact (prevents data theft on re-enable)");
     logger2.info({ src: "plugin:sql" }, "Clearing servers table...");
-    await db.execute(sql20`TRUNCATE TABLE servers`);
-    await db.execute(sql20`DROP FUNCTION IF EXISTS apply_rls_to_all_tables() CASCADE`);
-    await db.execute(sql20`DROP FUNCTION IF EXISTS add_server_isolation(text, text) CASCADE`);
-    await db.execute(sql20`DROP FUNCTION IF EXISTS current_server_id() CASCADE`);
+    await db.execute(sql26`TRUNCATE TABLE servers`);
+    await db.execute(sql26`DROP FUNCTION IF EXISTS apply_rls_to_all_tables() CASCADE`);
+    await db.execute(sql26`DROP FUNCTION IF EXISTS add_server_isolation(text, text) CASCADE`);
+    await db.execute(sql26`DROP FUNCTION IF EXISTS current_server_id() CASCADE`);
     logger2.info({ src: "plugin:sql" }, "Dropped all RLS functions");
     logger2.info({ src: "plugin:sql" }, "RLS disabled successfully (server_id columns preserved)");
   } catch (error) {
@@ -773,7 +773,7 @@ async function uninstallRLS(adapter) {
 async function installEntityRLS(adapter) {
   const db = getDb(adapter);
   logger2.info("[Entity RLS] Installing entity RLS functions and policies...");
-  await db.execute(sql20`
+  await db.execute(sql26`
     CREATE OR REPLACE FUNCTION current_entity_id()
     RETURNS UUID AS $$
     DECLARE
@@ -795,7 +795,7 @@ async function installEntityRLS(adapter) {
     $$ LANGUAGE plpgsql STABLE;
   `);
   logger2.info("[Entity RLS] Created current_entity_id() function");
-  await db.execute(sql20`
+  await db.execute(sql26`
     CREATE OR REPLACE FUNCTION add_entity_isolation(
       schema_name text,
       table_name text,
@@ -952,7 +952,7 @@ async function installEntityRLS(adapter) {
     $$ LANGUAGE plpgsql;
   `);
   logger2.info("[Entity RLS] Created add_entity_isolation() function");
-  await db.execute(sql20`
+  await db.execute(sql26`
     CREATE OR REPLACE FUNCTION apply_entity_rls_to_all_tables() RETURNS void AS $$
     DECLARE
       tbl record;
@@ -996,7 +996,7 @@ async function installEntityRLS(adapter) {
 async function applyEntityRLSToAllTables(adapter) {
   const db = getDb(adapter);
   try {
-    await db.execute(sql20`SELECT apply_entity_rls_to_all_tables()`);
+    await db.execute(sql26`SELECT apply_entity_rls_to_all_tables()`);
     logger2.info("[Entity RLS] Applied entity RLS to all eligible tables");
   } catch (error) {
     logger2.warn("[Entity RLS] Failed to apply entity RLS to some tables:", String(error));
@@ -1006,7 +1006,7 @@ async function uninstallEntityRLS(adapter) {
   const db = getDb(adapter);
   logger2.info("[Entity RLS] Removing entity RLS policies and functions...");
   try {
-    const tablesResult = await db.execute(sql20`
+    const tablesResult = await db.execute(sql26`
       SELECT schemaname, tablename
       FROM pg_tables
       WHERE schemaname = 'public'
@@ -1016,15 +1016,15 @@ async function uninstallEntityRLS(adapter) {
       const schemaName = row.schemaname;
       const tableName = row.tablename;
       try {
-        await db.execute(sql20.raw(`DROP POLICY IF EXISTS entity_isolation_policy ON "${schemaName}"."${tableName}"`));
+        await db.execute(sql26.raw(`DROP POLICY IF EXISTS entity_isolation_policy ON "${schemaName}"."${tableName}"`));
         logger2.debug(`[Entity RLS] Dropped entity_isolation_policy from ${schemaName}.${tableName}`);
       } catch (_error) {
         logger2.debug(`[Entity RLS] No entity policy on ${schemaName}.${tableName}`);
       }
     }
-    await db.execute(sql20`DROP FUNCTION IF EXISTS apply_entity_rls_to_all_tables() CASCADE`);
-    await db.execute(sql20`DROP FUNCTION IF EXISTS add_entity_isolation(text, text) CASCADE`);
-    await db.execute(sql20`DROP FUNCTION IF EXISTS current_entity_id() CASCADE`);
+    await db.execute(sql26`DROP FUNCTION IF EXISTS apply_entity_rls_to_all_tables() CASCADE`);
+    await db.execute(sql26`DROP FUNCTION IF EXISTS add_entity_isolation(text, text) CASCADE`);
+    await db.execute(sql26`DROP FUNCTION IF EXISTS current_entity_id() CASCADE`);
     logger2.info("[Entity RLS] Entity RLS functions and policies removed successfully");
   } catch (error) {
     logger2.error("[Entity RLS] Failed to remove entity RLS:", String(error));
@@ -1062,9 +1062,53 @@ function stringToBigInt(str) {
   return lockId;
 }
 
-// runtime-migrator/drizzle-adapters/database-introspector.ts
+// runtime-migrator/schema-transformer.ts
 import { logger as logger3 } from "@elizaos/core";
-import { sql as sql21 } from "drizzle-orm";
+import { getTableConfig, pgSchema } from "drizzle-orm/pg-core";
+function deriveSchemaName(pluginName) {
+  let schemaName = pluginName.replace(/^@[^/]+\//, "").replace(/^plugin-/, "").toLowerCase();
+  schemaName = normalizeSchemaName(schemaName);
+  const reserved = ["public", "pg_catalog", "information_schema", "migrations"];
+  if (!schemaName || reserved.includes(schemaName)) {
+    schemaName = `plugin_${normalizeSchemaName(pluginName.toLowerCase())}`;
+  }
+  if (!/^[a-z]/.test(schemaName)) {
+    schemaName = `p_${schemaName}`;
+  }
+  if (schemaName.length > 63) {
+    schemaName = schemaName.substring(0, 63);
+  }
+  return schemaName;
+}
+function normalizeSchemaName(input) {
+  const chars = [];
+  let prevWasUnderscore = false;
+  for (let i = 0;i < input.length; i++) {
+    const char = input[i];
+    if (/[a-z0-9]/.test(char)) {
+      chars.push(char);
+      prevWasUnderscore = false;
+    } else if (!prevWasUnderscore) {
+      chars.push("_");
+      prevWasUnderscore = true;
+    }
+  }
+  const result = chars.join("");
+  let start = 0;
+  let end = result.length;
+  while (start < end && result[start] === "_") {
+    start++;
+  }
+  while (end > start && result[end - 1] === "_") {
+    end--;
+  }
+  return result.slice(start, end);
+}
+var init_schema_transformer = () => {};
+
+// runtime-migrator/drizzle-adapters/database-introspector.ts
+import { logger as logger4 } from "@elizaos/core";
+import { sql as sql27 } from "drizzle-orm";
 function getRows2(result) {
   return result.rows;
 }
@@ -1075,7 +1119,7 @@ class DatabaseIntrospector {
     this.db = db;
   }
   async introspectSchema(schemaName = "public") {
-    logger3.info({ src: "plugin:sql", schemaName }, "Starting database introspection");
+    logger4.info({ src: "plugin:sql", schemaName }, "Starting database introspection");
     const tables = {};
     const schemas = {};
     const enums = {};
@@ -1083,7 +1127,7 @@ class DatabaseIntrospector {
     for (const tableInfo of allTables) {
       const tableName = tableInfo.table_name;
       const tableSchema = tableInfo.table_schema || "public";
-      logger3.debug({ src: "plugin:sql", tableSchema, tableName }, "Introspecting table");
+      logger4.debug({ src: "plugin:sql", tableSchema, tableName }, "Introspecting table");
       const columns = await this.getColumns(tableSchema, tableName);
       const columnsObject = {};
       const uniqueConstraintObject = {};
@@ -1178,7 +1222,7 @@ class DatabaseIntrospector {
       }
       enums[key].values.push(enumInfo.value);
     }
-    logger3.info({ src: "plugin:sql", tableCount: Object.keys(tables).length }, "Database introspection complete");
+    logger4.info({ src: "plugin:sql", tableCount: Object.keys(tables).length }, "Database introspection complete");
     return {
       version: "7",
       dialect: "postgresql",
@@ -1193,7 +1237,7 @@ class DatabaseIntrospector {
     };
   }
   async getTables(schemaName) {
-    const result = await this.db.execute(sql21`SELECT 
+    const result = await this.db.execute(sql27`SELECT 
             table_schema,
             table_name
           FROM information_schema.tables
@@ -1203,7 +1247,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getColumns(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
+    const result = await this.db.execute(sql27`SELECT 
             a.attname AS column_name,
             CASE 
               WHEN a.attnotnull THEN 'NO'
@@ -1246,7 +1290,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getIndexes(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
+    const result = await this.db.execute(sql27`SELECT 
             i.relname AS name,
             idx.indisunique AS is_unique,
             idx.indisprimary AS is_primary,
@@ -1270,7 +1314,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getForeignKeys(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT
+    const result = await this.db.execute(sql27`SELECT
             con.conname AS name,
             att.attname AS column_name,
             fnsp.nspname AS foreign_table_schema,
@@ -1305,7 +1349,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getPrimaryKeys(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
+    const result = await this.db.execute(sql27`SELECT 
             con.conname AS name,
             ARRAY(
               SELECT a.attname
@@ -1323,7 +1367,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getUniqueConstraints(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
+    const result = await this.db.execute(sql27`SELECT 
             con.conname AS name,
             ARRAY(
               SELECT a.attname
@@ -1341,7 +1385,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getCheckConstraints(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
+    const result = await this.db.execute(sql27`SELECT 
             con.conname AS name,
             pg_get_constraintdef(con.oid) AS definition
           FROM pg_constraint con
@@ -1353,7 +1397,7 @@ class DatabaseIntrospector {
     return getRows2(result);
   }
   async getEnums(schemaName) {
-    const result = await this.db.execute(sql21`SELECT 
+    const result = await this.db.execute(sql27`SELECT 
             n.nspname AS schema,
             t.typname AS name,
             e.enumlabel AS value,
@@ -1384,8 +1428,8 @@ class DatabaseIntrospector {
     return defaultValue;
   }
   async hasExistingTables(pluginName) {
-    const schemaName = pluginName === "@elizaos/plugin-sql" ? "public" : this.deriveSchemaName(pluginName);
-    const result = await this.db.execute(sql21`SELECT COUNT(*) AS count
+    const schemaName = pluginName === "@elizaos/plugin-sql" ? "public" : deriveSchemaName(pluginName);
+    const result = await this.db.execute(sql27`SELECT COUNT(*) AS count
           FROM information_schema.tables
           WHERE table_schema = ${schemaName}
             AND table_type = 'BASE TABLE'`);
@@ -1393,11 +1437,10 @@ class DatabaseIntrospector {
     const count = parseInt(firstRow && firstRow.count || "0", 10);
     return count > 0;
   }
-  deriveSchemaName(pluginName) {
-    return pluginName.replace("@", "").replace("/", "_").replace(/-/g, "_").toLowerCase();
-  }
 }
-var init_database_introspector = () => {};
+var init_database_introspector = __esm(() => {
+  init_schema_transformer();
+});
 
 // runtime-migrator/drizzle-adapters/diff-calculator.ts
 var exports_diff_calculator = {};
@@ -1732,7 +1775,7 @@ function hasDiffChanges(diff) {
 
 // runtime-migrator/drizzle-adapters/snapshot-generator.ts
 import { is, SQL } from "drizzle-orm";
-import { getTableConfig, PgDialect, PgTable } from "drizzle-orm/pg-core";
+import { getTableConfig as getTableConfig2, PgDialect, PgTable } from "drizzle-orm/pg-core";
 function escapeSingleQuotes(str) {
   return str.replace(/'/g, "''");
 }
@@ -1780,7 +1823,7 @@ async function generateSnapshot(schema) {
   const enums = {};
   const pgTables = extractTablesFromSchema(schema);
   for (const table of pgTables) {
-    const config = getTableConfig(table);
+    const config = getTableConfig2(table);
     const {
       name: tableName,
       columns,
@@ -1836,7 +1879,7 @@ async function generateSnapshot(schema) {
       }
       const columnWithConfig = column;
       const columnConfig = columnWithConfig.config;
-      if (columnWithConfig.isUnique && columnConfig && columnConfig.uniqueName) {
+      if (columnWithConfig.isUnique && columnConfig?.uniqueName) {
         uniqueConstraintObject[columnConfig.uniqueName] = {
           name: columnConfig.uniqueName,
           columns: [name],
@@ -1866,8 +1909,8 @@ async function generateSnapshot(schema) {
       const reference = fk.reference();
       const columnsFrom = reference.columns.map((it) => it.name);
       const columnsTo = reference.foreignColumns.map((it) => it.name);
-      const tableTo = getTableConfig(reference.foreignTable).name;
-      const schemaTo = getTableConfig(reference.foreignTable).schema || "public";
+      const tableTo = getTableConfig2(reference.foreignTable).name;
+      const schemaTo = getTableConfig2(reference.foreignTable).schema || "public";
       const name = fk.getName();
       foreignKeysObject[name] = {
         name,
@@ -1958,7 +2001,7 @@ function hasChanges(previousSnapshot, currentSnapshot) {
   const currHash = hashSnapshot(currentSnapshot);
   return prevHash !== currHash;
 }
-var sqlToStr = (sql22, _casing) => {
+var sqlToStr = (sql28, _casing) => {
   const config = {
     escapeName: () => {
       throw new Error("we don't support params for `sql` default values");
@@ -1971,12 +2014,12 @@ var sqlToStr = (sql22, _casing) => {
     },
     casing: undefined
   };
-  return sql22.toQuery(config).sql;
+  return sql28.toQuery(config).sql;
 };
 var init_snapshot_generator = () => {};
 
 // runtime-migrator/drizzle-adapters/sql-generator.ts
-import { logger as logger4 } from "@elizaos/core";
+import { logger as logger5 } from "@elizaos/core";
 function checkForDataLoss(diff) {
   const result = {
     hasDataLoss: false,
@@ -2106,7 +2149,7 @@ async function generateMigrationSQL(previousSnapshot, currentSnapshot, diff) {
   }
   const dataLossCheck = checkForDataLoss(diff);
   if (dataLossCheck.warnings.length > 0) {
-    logger4.warn({ src: "plugin:sql", warnings: dataLossCheck.warnings }, "Schema changes may cause data loss");
+    logger5.warn({ src: "plugin:sql", warnings: dataLossCheck.warnings }, "Schema changes may cause data loss");
   }
   const schemasToCreate = new Set;
   for (const tableName of diff.tables.created) {
@@ -2161,14 +2204,14 @@ async function generateMigrationSQL(previousSnapshot, currentSnapshot, diff) {
     const alterStatements = generateAlterColumnSQL(modified.table, modified.column, modified.changes);
     statements.push(...alterStatements);
   }
-  for (const index7 of diff.indexes.deleted) {
-    statements.push(generateDropIndexSQL(index7));
+  for (const index18 of diff.indexes.deleted) {
+    statements.push(generateDropIndexSQL(index18));
   }
   for (const alteredIndex of diff.indexes.altered) {
     statements.push(generateDropIndexSQL(alteredIndex.old));
   }
-  for (const index7 of diff.indexes.created) {
-    statements.push(generateCreateIndexSQL(index7));
+  for (const index18 of diff.indexes.created) {
+    statements.push(generateCreateIndexSQL(index18));
   }
   for (const alteredIndex of diff.indexes.altered) {
     statements.push(generateCreateIndexSQL(alteredIndex.new));
@@ -2270,18 +2313,18 @@ function generateCreateTableSQL(fullTableName, table) {
   return { tableSQL, fkSQLs };
 }
 function generateColumnDefinition(name, def) {
-  let sql22 = `"${name}" ${def.type}`;
+  let sql28 = `"${name}" ${def.type}`;
   if (def.primaryKey && !def.type.includes("SERIAL")) {
-    sql22 += " PRIMARY KEY";
+    sql28 += " PRIMARY KEY";
   }
   if (def.notNull) {
-    sql22 += " NOT NULL";
+    sql28 += " NOT NULL";
   }
   if (def.default !== undefined) {
     const defaultValue = formatDefaultValue(def.default, def.type);
-    sql22 += ` DEFAULT ${defaultValue}`;
+    sql28 += ` DEFAULT ${defaultValue}`;
   }
-  return sql22;
+  return sql28;
 }
 function generateAddColumnSQL(table, column, definition) {
   const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
@@ -2417,28 +2460,28 @@ function formatDefaultValue(value, type) {
   }
   return String(value);
 }
-function generateCreateIndexSQL(index7) {
-  const unique3 = index7.isUnique ? "UNIQUE " : "";
-  const method = index7.method || "btree";
-  const columns = index7.columns.map((c) => {
+function generateCreateIndexSQL(index18) {
+  const unique4 = index18.isUnique ? "UNIQUE " : "";
+  const method = index18.method || "btree";
+  const columns = index18.columns.map((c) => {
     if (c.isExpression) {
       return c.expression;
     }
     return `"${c.expression}"${c.asc === false ? " DESC" : ""}`;
   }).join(", ");
-  const indexName = index7.name.includes(".") ? index7.name.split(".")[1] : index7.name;
+  const indexName = index18.name.includes(".") ? index18.name.split(".")[1] : index18.name;
   let tableRef;
-  const indexTable = index7.table;
+  const indexTable = index18.table;
   if (indexTable?.includes(".")) {
     const [schema, table] = indexTable.split(".");
     tableRef = `"${schema}"."${table}"`;
   } else {
     tableRef = `"${indexTable || ""}"`;
   }
-  return `CREATE ${unique3}INDEX "${indexName}" ON ${tableRef} USING ${method} (${columns});`;
+  return `CREATE ${unique4}INDEX IF NOT EXISTS "${indexName}" ON ${tableRef} USING ${method} (${columns});`;
 }
-function generateDropIndexSQL(index7) {
-  const indexNameFull = typeof index7 === "string" ? index7 : index7.name;
+function generateDropIndexSQL(index18) {
+  const indexNameFull = typeof index18 === "string" ? index18 : index18.name;
   const indexName = indexNameFull.includes(".") ? indexNameFull.split(".")[1] : indexNameFull;
   return `DROP INDEX IF EXISTS "${indexName}";`;
 }
@@ -2454,12 +2497,12 @@ function generateCreateUniqueConstraintSQL(constraint) {
   const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
   const name = constraint.name;
   const columns = constraint.columns.map((c) => `"${c}"`).join(", ");
-  let sql22 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
+  let sql28 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
   if (constraint.nullsNotDistinct) {
-    sql22 += ` NULLS NOT DISTINCT`;
+    sql28 += ` NULLS NOT DISTINCT`;
   }
-  sql22 += ` (${columns});`;
-  return sql22;
+  sql28 += ` (${columns});`;
+  return sql28;
 }
 function generateDropUniqueConstraintSQL(constraint) {
   const table = constraint.table || "";
@@ -2484,14 +2527,14 @@ function buildCreateForeignKeyBodySQL(fk) {
   const tableFrom = fk.tableFrom;
   const columnsFrom = fk.columnsFrom.map((c) => `"${c}"`).join(", ");
   const columnsTo = fk.columnsTo.map((c) => `"${c}"`).join(", ");
-  let sql22 = `ALTER TABLE "${schemaFrom}"."${tableFrom}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${columnsFrom}) REFERENCES "${schemaTo}"."${fk.tableTo}" (${columnsTo})`;
+  let sql28 = `ALTER TABLE "${schemaFrom}"."${tableFrom}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${columnsFrom}) REFERENCES "${schemaTo}"."${fk.tableTo}" (${columnsTo})`;
   if (fk.onDelete) {
-    sql22 += ` ON DELETE ${fk.onDelete}`;
+    sql28 += ` ON DELETE ${fk.onDelete}`;
   }
   if (fk.onUpdate) {
-    sql22 += ` ON UPDATE ${fk.onUpdate}`;
+    sql28 += ` ON UPDATE ${fk.onUpdate}`;
   }
-  return sql22;
+  return sql28;
 }
 function wrapConstraintCreationGuard(constraintName, statement) {
   const escapedConstraintName = constraintName.replace(/'/g, "''");
@@ -2500,8 +2543,8 @@ function wrapConstraintCreationGuard(constraintName, statement) {
 var init_sql_generator = () => {};
 
 // runtime-migrator/extension-manager.ts
-import { logger as logger5 } from "@elizaos/core";
-import { sql as sql22 } from "drizzle-orm";
+import { logger as logger6 } from "@elizaos/core";
+import { sql as sql28 } from "drizzle-orm";
 
 class ExtensionManager {
   db;
@@ -2512,66 +2555,22 @@ class ExtensionManager {
     for (const extension of extensions) {
       try {
         if (!/^[a-zA-Z0-9_-]+$/.test(extension)) {
-          logger5.warn({ src: "plugin:sql", extension }, "Invalid extension name - contains invalid characters");
+          logger6.warn({ src: "plugin:sql", extension }, "Invalid extension name - contains invalid characters");
           continue;
         }
-        await this.db.execute(sql22`CREATE EXTENSION IF NOT EXISTS ${sql22.identifier(extension)}`);
-        logger5.debug({ src: "plugin:sql", extension }, "Extension installed");
+        await this.db.execute(sql28`CREATE EXTENSION IF NOT EXISTS ${sql28.identifier(extension)}`);
+        logger6.debug({ src: "plugin:sql", extension }, "Extension installed");
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logger5.warn({ src: "plugin:sql", extension, error: errorMessage }, "Could not install extension");
+        logger6.warn({ src: "plugin:sql", extension, error: errorMessage }, "Could not install extension");
       }
     }
   }
 }
 var init_extension_manager = () => {};
 
-// runtime-migrator/schema-transformer.ts
-import { logger as logger6 } from "@elizaos/core";
-import { getTableConfig as getTableConfig2, pgSchema } from "drizzle-orm/pg-core";
-function deriveSchemaName(pluginName) {
-  let schemaName = pluginName.replace(/^@[^/]+\//, "").replace(/^plugin-/, "").toLowerCase();
-  schemaName = normalizeSchemaName(schemaName);
-  const reserved = ["public", "pg_catalog", "information_schema", "migrations"];
-  if (!schemaName || reserved.includes(schemaName)) {
-    schemaName = `plugin_${normalizeSchemaName(pluginName.toLowerCase())}`;
-  }
-  if (!/^[a-z]/.test(schemaName)) {
-    schemaName = `p_${schemaName}`;
-  }
-  if (schemaName.length > 63) {
-    schemaName = schemaName.substring(0, 63);
-  }
-  return schemaName;
-}
-function normalizeSchemaName(input) {
-  const chars = [];
-  let prevWasUnderscore = false;
-  for (let i = 0;i < input.length; i++) {
-    const char = input[i];
-    if (/[a-z0-9]/.test(char)) {
-      chars.push(char);
-      prevWasUnderscore = false;
-    } else if (!prevWasUnderscore) {
-      chars.push("_");
-      prevWasUnderscore = true;
-    }
-  }
-  const result = chars.join("");
-  let start = 0;
-  let end = result.length;
-  while (start < end && result[start] === "_") {
-    start++;
-  }
-  while (end > start && result[end - 1] === "_") {
-    end--;
-  }
-  return result.slice(start, end);
-}
-var init_schema_transformer = () => {};
-
 // runtime-migrator/storage/journal-storage.ts
-import { sql as sql23 } from "drizzle-orm";
+import { sql as sql29 } from "drizzle-orm";
 
 class JournalStorage {
   db;
@@ -2579,7 +2578,7 @@ class JournalStorage {
     this.db = db;
   }
   async loadJournal(pluginName) {
-    const result = await this.db.execute(sql23`SELECT version, dialect, entries 
+    const result = await this.db.execute(sql29`SELECT version, dialect, entries 
           FROM migrations._journal 
           WHERE plugin_name = ${pluginName}`);
     if (result.rows.length === 0) {
@@ -2596,7 +2595,7 @@ class JournalStorage {
     };
   }
   async saveJournal(pluginName, journal) {
-    await this.db.execute(sql23`INSERT INTO migrations._journal (plugin_name, version, dialect, entries)
+    await this.db.execute(sql29`INSERT INTO migrations._journal (plugin_name, version, dialect, entries)
           VALUES (${pluginName}, ${journal.version}, ${journal.dialect}, ${JSON.stringify(journal.entries)}::jsonb)
           ON CONFLICT (plugin_name) 
           DO UPDATE SET 
@@ -2638,7 +2637,7 @@ class JournalStorage {
 var init_journal_storage = () => {};
 
 // runtime-migrator/storage/migration-tracker.ts
-import { sql as sql24 } from "drizzle-orm";
+import { sql as sql30 } from "drizzle-orm";
 
 class MigrationTracker {
   db;
@@ -2646,11 +2645,11 @@ class MigrationTracker {
     this.db = db;
   }
   async ensureSchema() {
-    await this.db.execute(sql24`CREATE SCHEMA IF NOT EXISTS migrations`);
+    await this.db.execute(sql30`CREATE SCHEMA IF NOT EXISTS migrations`);
   }
   async ensureTables() {
     await this.ensureSchema();
-    await this.db.execute(sql24`
+    await this.db.execute(sql30`
       CREATE TABLE IF NOT EXISTS migrations._migrations (
         id SERIAL PRIMARY KEY,
         plugin_name TEXT NOT NULL,
@@ -2658,7 +2657,7 @@ class MigrationTracker {
         created_at BIGINT NOT NULL
       )
     `);
-    await this.db.execute(sql24`
+    await this.db.execute(sql30`
       CREATE TABLE IF NOT EXISTS migrations._journal (
         plugin_name TEXT PRIMARY KEY,
         version TEXT NOT NULL,
@@ -2666,7 +2665,7 @@ class MigrationTracker {
         entries JSONB NOT NULL DEFAULT '[]'
       )
     `);
-    await this.db.execute(sql24`
+    await this.db.execute(sql30`
       CREATE TABLE IF NOT EXISTS migrations._snapshots (
         id SERIAL PRIMARY KEY,
         plugin_name TEXT NOT NULL,
@@ -2678,7 +2677,7 @@ class MigrationTracker {
     `);
   }
   async getLastMigration(pluginName) {
-    const result = await this.db.execute(sql24`SELECT id, hash, created_at
+    const result = await this.db.execute(sql30`SELECT id, hash, created_at
           FROM migrations._migrations
           WHERE plugin_name = ${pluginName}
           ORDER BY created_at DESC
@@ -2686,14 +2685,14 @@ class MigrationTracker {
     return getRow(result) || null;
   }
   async recordMigration(pluginName, hash, createdAt) {
-    await this.db.execute(sql24`INSERT INTO migrations._migrations (plugin_name, hash, created_at) 
+    await this.db.execute(sql30`INSERT INTO migrations._migrations (plugin_name, hash, created_at) 
           VALUES (${pluginName}, ${hash}, ${createdAt})`);
   }
 }
 var init_migration_tracker = () => {};
 
 // runtime-migrator/storage/snapshot-storage.ts
-import { sql as sql25 } from "drizzle-orm";
+import { sql as sql31 } from "drizzle-orm";
 
 class SnapshotStorage {
   db;
@@ -2701,7 +2700,7 @@ class SnapshotStorage {
     this.db = db;
   }
   async saveSnapshot(pluginName, idx, snapshot) {
-    await this.db.execute(sql25`INSERT INTO migrations._snapshots (plugin_name, idx, snapshot)
+    await this.db.execute(sql31`INSERT INTO migrations._snapshots (plugin_name, idx, snapshot)
           VALUES (${pluginName}, ${idx}, ${JSON.stringify(snapshot)}::jsonb)
           ON CONFLICT (plugin_name, idx) 
           DO UPDATE SET 
@@ -2709,7 +2708,7 @@ class SnapshotStorage {
             created_at = NOW()`);
   }
   async loadSnapshot(pluginName, idx) {
-    const result = await this.db.execute(sql25`SELECT snapshot 
+    const result = await this.db.execute(sql31`SELECT snapshot 
           FROM migrations._snapshots 
           WHERE plugin_name = ${pluginName} AND idx = ${idx}`);
     if (result.rows.length === 0) {
@@ -2718,7 +2717,7 @@ class SnapshotStorage {
     return result.rows[0].snapshot;
   }
   async getLatestSnapshot(pluginName) {
-    const result = await this.db.execute(sql25`SELECT snapshot 
+    const result = await this.db.execute(sql31`SELECT snapshot 
           FROM migrations._snapshots 
           WHERE plugin_name = ${pluginName}
           ORDER BY idx DESC
@@ -2729,7 +2728,7 @@ class SnapshotStorage {
     return result.rows[0].snapshot;
   }
   async getAllSnapshots(pluginName) {
-    const result = await this.db.execute(sql25`SELECT snapshot 
+    const result = await this.db.execute(sql31`SELECT snapshot 
           FROM migrations._snapshots 
           WHERE plugin_name = ${pluginName}
           ORDER BY idx ASC`);
@@ -2740,7 +2739,7 @@ var init_snapshot_storage = () => {};
 
 // runtime-migrator/runtime-migrator.ts
 import { logger as logger7 } from "@elizaos/core";
-import { sql as sql26 } from "drizzle-orm";
+import { sql as sql32 } from "drizzle-orm";
 
 class RuntimeMigrator {
   db;
@@ -2778,7 +2777,7 @@ class RuntimeMigrator {
     }
     for (const schemaName of schemasToCreate) {
       logger7.debug({ src: "plugin:sql", schemaName }, "Ensuring schema exists");
-      await this.db.execute(sql26.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
+      await this.db.execute(sql32.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
     }
   }
   validateSchemaUsage(pluginName, snapshot) {
@@ -2932,11 +2931,11 @@ class RuntimeMigrator {
         try {
           logger7.debug({ src: "plugin:sql", pluginName }, "Using PostgreSQL advisory locks");
           const lockIdStr = lockId.toString();
-          const lockResult = await this.db.execute(sql26`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
+          const lockResult = await this.db.execute(sql32`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
           lockAcquired = getRow(lockResult)?.acquired === true;
           if (!lockAcquired) {
             logger7.info({ src: "plugin:sql", pluginName }, "Migration already in progress, waiting for lock");
-            await this.db.execute(sql26`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
+            await this.db.execute(sql32`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
             lockAcquired = true;
             logger7.info({ src: "plugin:sql", pluginName }, "Lock acquired");
           } else {
@@ -3067,7 +3066,7 @@ class RuntimeMigrator {
       if (lockAcquired && isRealPostgres) {
         try {
           const lockIdStr = lockId.toString();
-          await this.db.execute(sql26`SELECT pg_advisory_unlock(CAST(${lockIdStr} AS bigint))`);
+          await this.db.execute(sql32`SELECT pg_advisory_unlock(CAST(${lockIdStr} AS bigint))`);
           logger7.debug({ src: "plugin:sql", pluginName }, "Advisory lock released");
         } catch (unlockError) {
           logger7.warn({
@@ -3082,23 +3081,23 @@ class RuntimeMigrator {
   async executeMigration(pluginName, snapshot, hash, sqlStatements) {
     let transactionStarted = false;
     try {
-      await this.db.execute(sql26`BEGIN`);
+      await this.db.execute(sql32`BEGIN`);
       transactionStarted = true;
       for (const stmt of sqlStatements) {
         logger7.debug({ src: "plugin:sql", statement: stmt }, "Executing SQL statement");
-        await this.db.execute(sql26.raw(stmt));
+        await this.db.execute(sql32.raw(stmt));
       }
       const idx = await this.journalStorage.getNextIdx(pluginName);
       await this.migrationTracker.recordMigration(pluginName, hash, Date.now());
       const tag = this.generateMigrationTag(idx, pluginName);
       await this.journalStorage.updateJournal(pluginName, idx, tag, true);
       await this.snapshotStorage.saveSnapshot(pluginName, idx, snapshot);
-      await this.db.execute(sql26`COMMIT`);
+      await this.db.execute(sql32`COMMIT`);
       logger7.info({ src: "plugin:sql", pluginName, tag }, "Recorded migration");
     } catch (error) {
       if (transactionStarted) {
         try {
-          await this.db.execute(sql26`ROLLBACK`);
+          await this.db.execute(sql32`ROLLBACK`);
           logger7.error({
             src: "plugin:sql",
             error: error instanceof Error ? error.message : String(error)
@@ -3115,8 +3114,8 @@ class RuntimeMigrator {
   }
   generateMigrationTag(idx, pluginName) {
     const prefix = idx.toString().padStart(4, "0");
-    const timestamp19 = Date.now().toString(36);
-    return `${prefix}_${pluginName}_${timestamp19}`;
+    const timestamp24 = Date.now().toString(36);
+    return `${prefix}_${pluginName}_${timestamp24}`;
   }
   async getStatus(pluginName) {
     const lastMigration = await this.migrationTracker.getLastMigration(pluginName);
@@ -3131,9 +3130,9 @@ class RuntimeMigrator {
   }
   async reset(pluginName) {
     logger7.warn({ src: "plugin:sql", pluginName }, "Resetting migrations");
-    await this.db.execute(sql26`DELETE FROM migrations._migrations WHERE plugin_name = ${pluginName}`);
-    await this.db.execute(sql26`DELETE FROM migrations._journal WHERE plugin_name = ${pluginName}`);
-    await this.db.execute(sql26`DELETE FROM migrations._snapshots WHERE plugin_name = ${pluginName}`);
+    await this.db.execute(sql32`DELETE FROM migrations._migrations WHERE plugin_name = ${pluginName}`);
+    await this.db.execute(sql32`DELETE FROM migrations._journal WHERE plugin_name = ${pluginName}`);
+    await this.db.execute(sql32`DELETE FROM migrations._snapshots WHERE plugin_name = ${pluginName}`);
     logger7.warn({ src: "plugin:sql", pluginName }, "Reset complete");
   }
   async checkMigration(pluginName, schema) {
@@ -3289,8 +3288,8 @@ var init_migration_service = __esm(() => {
 });
 
 // index.ts
-import { mkdirSync as mkdirSync2 } from "node:fs";
-import { logger as logger14, stringToUuid } from "@elizaos/core";
+import { mkdirSync } from "node:fs";
+import { logger as logger14 } from "@elizaos/core";
 
 // pg/adapter.ts
 import {
@@ -3314,12 +3313,10 @@ import {
   lt,
   lte,
   or,
-  sql as sql27
+  sql as sql33
 } from "drizzle-orm";
-import { v4 } from "uuid";
 
 // schema/embedding.ts
-import { VECTOR_DIMS } from "@elizaos/core";
 import { relations, sql as sql5 } from "drizzle-orm";
 import { check as check2, foreignKey as foreignKey2, index as index2, pgTable as pgTable5, timestamp as timestamp5, uuid as uuid5, vector } from "drizzle-orm/pg-core";
 
@@ -3432,6 +3429,14 @@ var memoryTable = pgTable4("memories", {
 ]);
 
 // schema/embedding.ts
+var VECTOR_DIMS = {
+  SMALL: 384,
+  MEDIUM: 512,
+  LARGE: 768,
+  XL: 1024,
+  XXL: 1536,
+  XXXL: 3072
+};
 var DIMENSION_MAP = {
   [VECTOR_DIMS.SMALL]: "dim384",
   [VECTOR_DIMS.MEDIUM]: "dim512",
@@ -3471,6 +3476,7 @@ var exports_schema = {};
 __export(exports_schema, {
   worldTable: () => worldTable,
   taskTable: () => taskTable,
+  sessionSummaries: () => sessionSummaries,
   serverTable: () => serverTable,
   roomTable: () => roomTable,
   relationshipTable: () => relationshipTable,
@@ -3481,203 +3487,484 @@ __export(exports_schema, {
   messageServerTable: () => messageServerTable,
   messageServerAgentsTable: () => messageServerAgentsTable,
   memoryTable: () => memoryTable,
+  memoryAccessLogs: () => memoryAccessLogs,
+  longTermMemories: () => longTermMemories,
   logTable: () => logTable,
+  factCandidateTable: () => factCandidateTable,
   entityTable: () => entityTable,
+  entityMergeCandidateTable: () => entityMergeCandidateTable,
+  entityIdentityTable: () => entityIdentityTable,
   embeddingTable: () => embeddingTable,
   componentTable: () => componentTable,
   channelTable: () => channelTable,
   channelParticipantsTable: () => channelParticipantsTable,
   cacheTable: () => cacheTable,
+  authSessionTable: () => authSessionTable,
+  authOwnerLoginTokenTable: () => authOwnerLoginTokenTable,
+  authOwnerBindingTable: () => authOwnerBindingTable,
+  authIdentityTable: () => authIdentityTable,
+  authIdentityCreatedAtDefault: () => authIdentityCreatedAtDefault,
+  authBootstrapJtiSeenTable: () => authBootstrapJtiSeenTable,
+  authAuditEventTable: () => authAuditEventTable,
+  approvalRequestTable: () => approvalRequestTable,
   agentTable: () => agentTable
 });
 
-// schema/cache.ts
+// schema/approvalRequests.ts
 init_agent();
 import { sql as sql6 } from "drizzle-orm";
-import { jsonb as jsonb5, pgTable as pgTable6, primaryKey, text as text5, timestamp as timestamp6, uuid as uuid6 } from "drizzle-orm/pg-core";
-var cacheTable = pgTable6("cache", {
-  key: text5("key").notNull(),
+import { index as index3, jsonb as jsonb5, pgTable as pgTable6, text as text5, timestamp as timestamp6, uuid as uuid6 } from "drizzle-orm/pg-core";
+var approvalRequestTable = pgTable6("approval_requests", {
+  id: uuid6("id").primaryKey().defaultRandom(),
+  state: text5("state").notNull(),
+  requestedBy: text5("requested_by").notNull(),
+  subjectUserId: text5("subject_user_id").notNull(),
+  action: text5("action").notNull(),
+  payload: jsonb5("payload").notNull(),
+  channel: text5("channel").notNull(),
+  reason: text5("reason").notNull(),
+  expiresAt: timestamp6("expires_at", { withTimezone: true }).notNull(),
+  resolvedAt: timestamp6("resolved_at", { withTimezone: true }),
+  resolvedBy: text5("resolved_by"),
+  resolutionReason: text5("resolution_reason"),
   agentId: uuid6("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  value: jsonb5("value").notNull(),
   createdAt: timestamp6("created_at", { withTimezone: true }).default(sql6`now()`).notNull(),
-  expiresAt: timestamp6("expires_at", { withTimezone: true })
+  updatedAt: timestamp6("updated_at", { withTimezone: true }).default(sql6`now()`).notNull()
+}, (table) => [
+  index3("approval_requests_subject_state_idx").on(table.subjectUserId, table.state),
+  index3("approval_requests_agent_state_idx").on(table.agentId, table.state),
+  index3("approval_requests_state_expires_idx").on(table.state, table.expiresAt)
+]);
+// schema/authAuditEvent.ts
+import { bigint, index as index4, jsonb as jsonb6, pgTable as pgTable7, text as text6 } from "drizzle-orm/pg-core";
+var authAuditEventTable = pgTable7("auth_audit_events", {
+  id: text6("id").primaryKey(),
+  ts: bigint("ts", { mode: "number" }).notNull(),
+  actorIdentityId: text6("actor_identity_id"),
+  ip: text6("ip"),
+  userAgent: text6("user_agent"),
+  action: text6("action").notNull(),
+  outcome: text6("outcome").notNull(),
+  metadata: jsonb6("metadata").$type().notNull()
+}, (table) => [
+  index4("auth_audit_events_action_idx").on(table.action),
+  index4("auth_audit_events_ts_idx").on(table.ts),
+  index4("auth_audit_events_actor_idx").on(table.actorIdentityId)
+]);
+// schema/authBootstrapJti.ts
+import { bigint as bigint2, index as index5, pgTable as pgTable8, text as text7 } from "drizzle-orm/pg-core";
+var authBootstrapJtiSeenTable = pgTable8("auth_bootstrap_jti_seen", {
+  jti: text7("jti").primaryKey(),
+  seenAt: bigint2("seen_at", { mode: "number" }).notNull()
+}, (table) => [index5("auth_bootstrap_jti_seen_at_idx").on(table.seenAt)]);
+// schema/authIdentity.ts
+import { sql as sql7 } from "drizzle-orm";
+import { bigint as bigint3, index as index6, pgTable as pgTable9, text as text8 } from "drizzle-orm/pg-core";
+var authIdentityTable = pgTable9("auth_identities", {
+  id: text8("id").primaryKey(),
+  kind: text8("kind").notNull(),
+  displayName: text8("display_name").notNull(),
+  createdAt: bigint3("created_at", { mode: "number" }).notNull(),
+  passwordHash: text8("password_hash"),
+  cloudUserId: text8("cloud_user_id")
+}, (table) => [
+  index6("auth_identities_kind_idx").on(table.kind),
+  index6("auth_identities_cloud_user_idx").on(table.cloudUserId)
+]);
+var authIdentityCreatedAtDefault = sql7`(extract(epoch from now()) * 1000)::bigint`;
+// schema/authOwnerBinding.ts
+import { bigint as bigint4, foreignKey as foreignKey3, index as index7, pgTable as pgTable10, text as text9, uniqueIndex } from "drizzle-orm/pg-core";
+var authOwnerBindingTable = pgTable10("auth_owner_bindings", {
+  id: text9("id").primaryKey(),
+  identityId: text9("identity_id").notNull().references(() => authIdentityTable.id, { onDelete: "cascade" }),
+  connector: text9("connector").notNull(),
+  externalId: text9("external_id").notNull(),
+  displayHandle: text9("display_handle").notNull(),
+  instanceId: text9("instance_id").notNull(),
+  verifiedAt: bigint4("verified_at", { mode: "number" }).notNull(),
+  pendingCodeHash: text9("pending_code_hash"),
+  pendingExpiresAt: bigint4("pending_expires_at", { mode: "number" })
+}, (table) => [
+  index7("auth_owner_bindings_identity_idx").on(table.identityId),
+  index7("auth_owner_bindings_connector_idx").on(table.connector),
+  uniqueIndex("auth_owner_bindings_connector_external_instance_uniq").on(table.connector, table.externalId, table.instanceId),
+  foreignKey3({
+    name: "fk_auth_owner_bindings_identity",
+    columns: [table.identityId],
+    foreignColumns: [authIdentityTable.id]
+  }).onDelete("cascade")
+]);
+// schema/authOwnerLoginToken.ts
+import { bigint as bigint5, foreignKey as foreignKey4, index as index8, pgTable as pgTable11, text as text10 } from "drizzle-orm/pg-core";
+var authOwnerLoginTokenTable = pgTable11("auth_owner_login_tokens", {
+  tokenHash: text10("token_hash").primaryKey(),
+  identityId: text10("identity_id").notNull().references(() => authIdentityTable.id, { onDelete: "cascade" }),
+  bindingId: text10("binding_id").notNull().references(() => authOwnerBindingTable.id, { onDelete: "cascade" }),
+  issuedAt: bigint5("issued_at", { mode: "number" }).notNull(),
+  expiresAt: bigint5("expires_at", { mode: "number" }).notNull(),
+  consumedAt: bigint5("consumed_at", { mode: "number" })
+}, (table) => [
+  index8("auth_owner_login_tokens_identity_idx").on(table.identityId),
+  index8("auth_owner_login_tokens_binding_idx").on(table.bindingId),
+  index8("auth_owner_login_tokens_expires_idx").on(table.expiresAt),
+  foreignKey4({
+    name: "fk_auth_owner_login_tokens_identity",
+    columns: [table.identityId],
+    foreignColumns: [authIdentityTable.id]
+  }).onDelete("cascade"),
+  foreignKey4({
+    name: "fk_auth_owner_login_tokens_binding",
+    columns: [table.bindingId],
+    foreignColumns: [authOwnerBindingTable.id]
+  }).onDelete("cascade")
+]);
+// schema/authSession.ts
+import { bigint as bigint6, boolean as boolean3, foreignKey as foreignKey5, index as index9, jsonb as jsonb7, pgTable as pgTable12, text as text11 } from "drizzle-orm/pg-core";
+var authSessionTable = pgTable12("auth_sessions", {
+  id: text11("id").primaryKey(),
+  identityId: text11("identity_id").notNull().references(() => authIdentityTable.id, { onDelete: "cascade" }),
+  kind: text11("kind").notNull(),
+  createdAt: bigint6("created_at", { mode: "number" }).notNull(),
+  lastSeenAt: bigint6("last_seen_at", { mode: "number" }).notNull(),
+  expiresAt: bigint6("expires_at", { mode: "number" }).notNull(),
+  rememberDevice: boolean3("remember_device").notNull().default(false),
+  csrfSecret: text11("csrf_secret").notNull(),
+  ip: text11("ip"),
+  userAgent: text11("user_agent"),
+  scopes: jsonb7("scopes").$type().notNull(),
+  revokedAt: bigint6("revoked_at", { mode: "number" })
+}, (table) => [
+  index9("auth_sessions_identity_idx").on(table.identityId),
+  index9("auth_sessions_expires_idx").on(table.expiresAt),
+  foreignKey5({
+    name: "fk_auth_sessions_identity",
+    columns: [table.identityId],
+    foreignColumns: [authIdentityTable.id]
+  }).onDelete("cascade")
+]);
+// schema/cache.ts
+init_agent();
+import { sql as sql8 } from "drizzle-orm";
+import { jsonb as jsonb8, pgTable as pgTable13, primaryKey, text as text12, timestamp as timestamp7, uuid as uuid7 } from "drizzle-orm/pg-core";
+var cacheTable = pgTable13("cache", {
+  key: text12("key").notNull(),
+  agentId: uuid7("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  value: jsonb8("value").notNull(),
+  createdAt: timestamp7("created_at", { withTimezone: true }).default(sql8`now()`).notNull(),
+  expiresAt: timestamp7("expires_at", { withTimezone: true })
 }, (table) => [primaryKey({ columns: [table.key, table.agentId] })]);
 // schema/channel.ts
-import { sql as sql8 } from "drizzle-orm";
-import { jsonb as jsonb7, pgTable as pgTable8, text as text7, timestamp as timestamp8, uuid as uuid8 } from "drizzle-orm/pg-core";
+import { sql as sql10 } from "drizzle-orm";
+import { jsonb as jsonb10, pgTable as pgTable15, text as text14, timestamp as timestamp9, uuid as uuid9 } from "drizzle-orm/pg-core";
 
 // schema/messageServer.ts
-import { sql as sql7 } from "drizzle-orm";
-import { jsonb as jsonb6, pgTable as pgTable7, text as text6, timestamp as timestamp7, uuid as uuid7 } from "drizzle-orm/pg-core";
-var messageServerTable = pgTable7("message_servers", {
-  id: uuid7("id").primaryKey(),
-  name: text6("name").notNull(),
-  sourceType: text6("source_type").notNull(),
-  sourceId: text6("source_id"),
-  metadata: jsonb6("metadata"),
-  createdAt: timestamp7("created_at", { mode: "date" }).default(sql7`CURRENT_TIMESTAMP`).notNull(),
-  updatedAt: timestamp7("updated_at", { mode: "date" }).default(sql7`CURRENT_TIMESTAMP`).notNull()
+import { sql as sql9 } from "drizzle-orm";
+import { jsonb as jsonb9, pgTable as pgTable14, text as text13, timestamp as timestamp8, uuid as uuid8 } from "drizzle-orm/pg-core";
+var messageServerTable = pgTable14("message_servers", {
+  id: uuid8("id").primaryKey(),
+  name: text13("name").notNull(),
+  sourceType: text13("source_type").notNull(),
+  sourceId: text13("source_id"),
+  metadata: jsonb9("metadata"),
+  createdAt: timestamp8("created_at", { mode: "date" }).default(sql9`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp8("updated_at", { mode: "date" }).default(sql9`CURRENT_TIMESTAMP`).notNull()
 });
 
 // schema/channel.ts
-var channelTable = pgTable8("channels", {
-  id: text7("id").primaryKey(),
-  messageServerId: uuid8("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
-  name: text7("name").notNull(),
-  type: text7("type").notNull(),
-  sourceType: text7("source_type"),
-  sourceId: text7("source_id"),
-  topic: text7("topic"),
-  metadata: jsonb7("metadata"),
-  createdAt: timestamp8("created_at", { mode: "date" }).default(sql8`CURRENT_TIMESTAMP`).notNull(),
-  updatedAt: timestamp8("updated_at", { mode: "date" }).default(sql8`CURRENT_TIMESTAMP`).notNull()
+var channelTable = pgTable15("channels", {
+  id: text14("id").primaryKey(),
+  messageServerId: uuid9("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+  name: text14("name").notNull(),
+  type: text14("type").notNull(),
+  sourceType: text14("source_type"),
+  sourceId: text14("source_id"),
+  topic: text14("topic"),
+  metadata: jsonb10("metadata"),
+  createdAt: timestamp9("created_at", { mode: "date" }).default(sql10`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp9("updated_at", { mode: "date" }).default(sql10`CURRENT_TIMESTAMP`).notNull()
 });
 // schema/channelParticipant.ts
-import { pgTable as pgTable9, primaryKey as primaryKey2, text as text8 } from "drizzle-orm/pg-core";
-var channelParticipantsTable = pgTable9("channel_participants", {
-  channelId: text8("channel_id").notNull().references(() => channelTable.id, { onDelete: "cascade" }),
-  entityId: text8("entity_id").notNull()
+import { pgTable as pgTable16, primaryKey as primaryKey2, text as text15 } from "drizzle-orm/pg-core";
+var channelParticipantsTable = pgTable16("channel_participants", {
+  channelId: text15("channel_id").notNull().references(() => channelTable.id, { onDelete: "cascade" }),
+  entityId: text15("entity_id").notNull()
 }, (table) => [primaryKey2({ columns: [table.channelId, table.entityId] })]);
 // schema/component.ts
 init_agent();
-import { sql as sql10 } from "drizzle-orm";
-import { jsonb as jsonb9, pgTable as pgTable11, text as text10, timestamp as timestamp10, uuid as uuid10 } from "drizzle-orm/pg-core";
+import { sql as sql12 } from "drizzle-orm";
+import { jsonb as jsonb12, pgTable as pgTable18, text as text17, timestamp as timestamp11, uuid as uuid11 } from "drizzle-orm/pg-core";
 
 // schema/world.ts
 init_agent();
-import { sql as sql9 } from "drizzle-orm";
-import { jsonb as jsonb8, pgTable as pgTable10, text as text9, timestamp as timestamp9, uuid as uuid9 } from "drizzle-orm/pg-core";
-var worldTable = pgTable10("worlds", {
-  id: uuid9("id").notNull().primaryKey().default(sql9`gen_random_uuid()`),
-  agentId: uuid9("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  name: text9("name").notNull(),
-  metadata: jsonb8("metadata"),
-  messageServerId: uuid9("message_server_id"),
-  createdAt: timestamp9("created_at").default(sql9`now()`).notNull()
+import { sql as sql11 } from "drizzle-orm";
+import { jsonb as jsonb11, pgTable as pgTable17, text as text16, timestamp as timestamp10, uuid as uuid10 } from "drizzle-orm/pg-core";
+var worldTable = pgTable17("worlds", {
+  id: uuid10("id").notNull().primaryKey().default(sql11`gen_random_uuid()`),
+  agentId: uuid10("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  name: text16("name").notNull(),
+  metadata: jsonb11("metadata"),
+  messageServerId: uuid10("message_server_id"),
+  createdAt: timestamp10("created_at").default(sql11`now()`).notNull()
 });
 
 // schema/component.ts
-var componentTable = pgTable11("components", {
-  id: uuid10("id").primaryKey().default(sql10`gen_random_uuid()`).notNull(),
-  entityId: uuid10("entity_id").references(() => entityTable.id, { onDelete: "cascade" }).notNull(),
-  agentId: uuid10("agent_id").references(() => agentTable.id, { onDelete: "cascade" }).notNull(),
-  roomId: uuid10("room_id").references(() => roomTable.id, { onDelete: "cascade" }).notNull(),
-  worldId: uuid10("world_id").references(() => worldTable.id, {
+var componentTable = pgTable18("components", {
+  id: uuid11("id").primaryKey().default(sql12`gen_random_uuid()`).notNull(),
+  entityId: uuid11("entity_id").references(() => entityTable.id, { onDelete: "cascade" }).notNull(),
+  agentId: uuid11("agent_id").references(() => agentTable.id, { onDelete: "cascade" }).notNull(),
+  roomId: uuid11("room_id").references(() => roomTable.id, { onDelete: "cascade" }).notNull(),
+  worldId: uuid11("world_id").references(() => worldTable.id, {
     onDelete: "cascade"
   }),
-  sourceEntityId: uuid10("source_entity_id").references(() => entityTable.id, {
+  sourceEntityId: uuid11("source_entity_id").references(() => entityTable.id, {
     onDelete: "cascade"
   }),
-  type: text10("type").notNull(),
-  data: jsonb9("data").default(sql10`'{}'::jsonb`),
-  createdAt: timestamp10("created_at").default(sql10`now()`).notNull()
+  type: text17("type").notNull(),
+  data: jsonb12("data").default(sql12`'{}'::jsonb`),
+  createdAt: timestamp11("created_at").default(sql12`now()`).notNull()
 });
+// schema/entityIdentity.ts
+init_agent();
+import { sql as sql13 } from "drizzle-orm";
+import {
+  boolean as boolean4,
+  foreignKey as foreignKey6,
+  index as index10,
+  jsonb as jsonb13,
+  pgTable as pgTable19,
+  real,
+  text as text18,
+  timestamp as timestamp12,
+  unique as unique2,
+  uuid as uuid12
+} from "drizzle-orm/pg-core";
+var entityIdentityTable = pgTable19("entity_identities", {
+  id: uuid12("id").notNull().primaryKey().default(sql13`gen_random_uuid()`),
+  entityId: uuid12("entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  agentId: uuid12("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  platform: text18("platform").notNull(),
+  handle: text18("handle").notNull(),
+  verified: boolean4("verified").notNull().default(false),
+  confidence: real("confidence").notNull().default(0),
+  source: text18("source"),
+  firstSeen: timestamp12("first_seen", { withTimezone: true }).notNull().default(sql13`now()`),
+  lastSeen: timestamp12("last_seen", { withTimezone: true }).notNull().default(sql13`now()`),
+  evidenceMessageIds: jsonb13("evidence_message_ids").$type(),
+  createdAt: timestamp12("created_at", { withTimezone: true }).notNull().default(sql13`now()`)
+}, (table) => [
+  index10("idx_entity_identities_entity").on(table.entityId),
+  index10("idx_entity_identities_platform_handle").on(table.platform, table.handle),
+  unique2("unique_entity_identity").on(table.entityId, table.platform, table.handle, table.agentId),
+  foreignKey6({
+    name: "fk_entity_identities_entity",
+    columns: [table.entityId],
+    foreignColumns: [entityTable.id]
+  }).onDelete("cascade"),
+  foreignKey6({
+    name: "fk_entity_identities_agent",
+    columns: [table.agentId],
+    foreignColumns: [agentTable.id]
+  }).onDelete("cascade")
+]);
+var entityMergeCandidateTable = pgTable19("entity_merge_candidates", {
+  id: uuid12("id").notNull().primaryKey().default(sql13`gen_random_uuid()`),
+  agentId: uuid12("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  entityA: uuid12("entity_a").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  entityB: uuid12("entity_b").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  confidence: real("confidence").notNull().default(0),
+  evidence: jsonb13("evidence"),
+  status: text18("status").notNull().default("pending"),
+  proposedAt: timestamp12("proposed_at", { withTimezone: true }).notNull().default(sql13`now()`),
+  resolvedAt: timestamp12("resolved_at", { withTimezone: true })
+}, (table) => [
+  index10("idx_entity_merge_candidates_status").on(table.status),
+  index10("idx_entity_merge_candidates_pair").on(table.entityA, table.entityB),
+  foreignKey6({
+    name: "fk_entity_merge_candidates_a",
+    columns: [table.entityA],
+    foreignColumns: [entityTable.id]
+  }).onDelete("cascade"),
+  foreignKey6({
+    name: "fk_entity_merge_candidates_b",
+    columns: [table.entityB],
+    foreignColumns: [entityTable.id]
+  }).onDelete("cascade"),
+  foreignKey6({
+    name: "fk_entity_merge_candidates_agent",
+    columns: [table.agentId],
+    foreignColumns: [agentTable.id]
+  }).onDelete("cascade")
+]);
+var factCandidateTable = pgTable19("fact_candidates", {
+  id: uuid12("id").notNull().primaryKey().default(sql13`gen_random_uuid()`),
+  agentId: uuid12("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  entityId: uuid12("entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  kind: text18("kind").notNull(),
+  existingFactId: uuid12("existing_fact_id"),
+  proposedText: text18("proposed_text").notNull(),
+  confidence: real("confidence").notNull().default(0),
+  evidence: jsonb13("evidence"),
+  status: text18("status").notNull().default("pending"),
+  proposedAt: timestamp12("proposed_at", { withTimezone: true }).notNull().default(sql13`now()`),
+  resolvedAt: timestamp12("resolved_at", { withTimezone: true })
+}, (table) => [
+  index10("idx_fact_candidates_status").on(table.status),
+  index10("idx_fact_candidates_entity").on(table.entityId),
+  foreignKey6({
+    name: "fk_fact_candidates_entity",
+    columns: [table.entityId],
+    foreignColumns: [entityTable.id]
+  }).onDelete("cascade"),
+  foreignKey6({
+    name: "fk_fact_candidates_agent",
+    columns: [table.agentId],
+    foreignColumns: [agentTable.id]
+  }).onDelete("cascade")
+]);
 // schema/log.ts
-import { sql as sql11 } from "drizzle-orm";
-import { foreignKey as foreignKey3, jsonb as jsonb10, pgTable as pgTable12, text as text11, timestamp as timestamp11, uuid as uuid11 } from "drizzle-orm/pg-core";
-var logTable = pgTable12("logs", {
-  id: uuid11("id").defaultRandom().notNull(),
-  createdAt: timestamp11("created_at", { withTimezone: true }).default(sql11`now()`).notNull(),
-  entityId: uuid11("entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  body: jsonb10("body").notNull(),
-  type: text11("type").notNull(),
-  roomId: uuid11("room_id").notNull().references(() => roomTable.id, { onDelete: "cascade" })
+import { sql as sql14 } from "drizzle-orm";
+import { foreignKey as foreignKey7, jsonb as jsonb14, pgTable as pgTable20, text as text19, timestamp as timestamp13, uuid as uuid13 } from "drizzle-orm/pg-core";
+var logTable = pgTable20("logs", {
+  id: uuid13("id").defaultRandom().notNull(),
+  createdAt: timestamp13("created_at", { withTimezone: true }).default(sql14`now()`).notNull(),
+  entityId: uuid13("entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  body: jsonb14("body").notNull(),
+  type: text19("type").notNull(),
+  roomId: uuid13("room_id").notNull().references(() => roomTable.id, { onDelete: "cascade" })
 }, (table) => [
-  foreignKey3({
+  foreignKey7({
     name: "fk_room",
     columns: [table.roomId],
     foreignColumns: [roomTable.id]
   }).onDelete("cascade"),
-  foreignKey3({
+  foreignKey7({
     name: "fk_user",
     columns: [table.entityId],
     foreignColumns: [entityTable.id]
   }).onDelete("cascade")
 ]);
+// schema/longTermMemories.ts
+import { sql as sql15 } from "drizzle-orm";
+import { index as index11, integer, jsonb as jsonb15, pgTable as pgTable21, real as real2, text as text20, timestamp as timestamp14, uuid as uuid14 } from "drizzle-orm/pg-core";
+var longTermMemories = pgTable21("long_term_memories", {
+  id: uuid14("id").primaryKey().notNull(),
+  agentId: uuid14("agent_id").notNull(),
+  entityId: uuid14("entity_id").notNull(),
+  category: text20("category").notNull(),
+  content: text20("content").notNull(),
+  metadata: jsonb15("metadata"),
+  embedding: real2("embedding").array(),
+  confidence: real2("confidence").default(1),
+  source: text20("source"),
+  createdAt: timestamp14("created_at").default(sql15`now()`).notNull(),
+  updatedAt: timestamp14("updated_at").default(sql15`now()`).notNull(),
+  lastAccessedAt: timestamp14("last_accessed_at"),
+  accessCount: integer("access_count").default(0)
+}, (table) => [
+  index11("long_term_memories_agent_entity_idx").on(table.agentId, table.entityId),
+  index11("long_term_memories_category_idx").on(table.category),
+  index11("long_term_memories_confidence_idx").on(table.confidence),
+  index11("long_term_memories_created_at_idx").on(table.createdAt)
+]);
+// schema/memoryAccessLogs.ts
+import { sql as sql16 } from "drizzle-orm";
+import { index as index12, pgTable as pgTable22, text as text21, timestamp as timestamp15, uuid as uuid15 } from "drizzle-orm/pg-core";
+var memoryAccessLogs = pgTable22("memory_access_logs", {
+  id: uuid15("id").primaryKey().notNull(),
+  memoryId: uuid15("memory_id").notNull(),
+  memoryType: text21("memory_type").notNull(),
+  agentId: uuid15("agent_id").notNull(),
+  accessType: text21("access_type").notNull(),
+  accessedAt: timestamp15("accessed_at").default(sql16`now()`).notNull()
+}, (table) => [
+  index12("memory_access_logs_memory_id_idx").on(table.memoryId),
+  index12("memory_access_logs_agent_id_idx").on(table.agentId),
+  index12("memory_access_logs_accessed_at_idx").on(table.accessedAt)
+]);
 // schema/message.ts
-import { sql as sql12 } from "drizzle-orm";
-import { jsonb as jsonb11, pgTable as pgTable13, text as text12, timestamp as timestamp12 } from "drizzle-orm/pg-core";
-var messageTable = pgTable13("central_messages", {
-  id: text12("id").primaryKey(),
-  channelId: text12("channel_id").notNull().references(() => channelTable.id, { onDelete: "cascade" }),
-  authorId: text12("author_id").notNull(),
-  content: text12("content").notNull(),
-  rawMessage: jsonb11("raw_message"),
-  inReplyToRootMessageId: text12("in_reply_to_root_message_id").references(() => messageTable.id, {
+import { sql as sql17 } from "drizzle-orm";
+import { jsonb as jsonb16, pgTable as pgTable23, text as text22, timestamp as timestamp16 } from "drizzle-orm/pg-core";
+var messageTable = pgTable23("central_messages", {
+  id: text22("id").primaryKey(),
+  channelId: text22("channel_id").notNull().references(() => channelTable.id, { onDelete: "cascade" }),
+  authorId: text22("author_id").notNull(),
+  content: text22("content").notNull(),
+  rawMessage: jsonb16("raw_message"),
+  inReplyToRootMessageId: text22("in_reply_to_root_message_id").references(() => messageTable.id, {
     onDelete: "set null"
   }),
-  sourceType: text12("source_type"),
-  sourceId: text12("source_id"),
-  metadata: jsonb11("metadata"),
-  createdAt: timestamp12("created_at", { mode: "date" }).default(sql12`CURRENT_TIMESTAMP`).notNull(),
-  updatedAt: timestamp12("updated_at", { mode: "date" }).default(sql12`CURRENT_TIMESTAMP`).notNull()
+  sourceType: text22("source_type"),
+  sourceId: text22("source_id"),
+  metadata: jsonb16("metadata"),
+  createdAt: timestamp16("created_at", { mode: "date" }).default(sql17`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp16("updated_at", { mode: "date" }).default(sql17`CURRENT_TIMESTAMP`).notNull()
 });
 // schema/messageServerAgent.ts
 init_agent();
-import { pgTable as pgTable14, primaryKey as primaryKey3, uuid as uuid12 } from "drizzle-orm/pg-core";
-var messageServerAgentsTable = pgTable14("message_server_agents", {
-  messageServerId: uuid12("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
-  agentId: uuid12("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
+import { pgTable as pgTable24, primaryKey as primaryKey3, uuid as uuid16 } from "drizzle-orm/pg-core";
+var messageServerAgentsTable = pgTable24("message_server_agents", {
+  messageServerId: uuid16("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+  agentId: uuid16("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
 }, (table) => [primaryKey3({ columns: [table.messageServerId, table.agentId] })]);
 // schema/pairingAllowlist.ts
 init_agent();
-import { sql as sql13 } from "drizzle-orm";
-import { index as index3, jsonb as jsonb12, pgTable as pgTable15, text as text13, timestamp as timestamp13, uniqueIndex, uuid as uuid13 } from "drizzle-orm/pg-core";
-var pairingAllowlistTable = pgTable15("pairing_allowlist", {
-  id: uuid13("id").primaryKey().defaultRandom(),
-  channel: text13("channel").notNull(),
-  senderId: text13("sender_id").notNull(),
-  createdAt: timestamp13("created_at", { withTimezone: true }).default(sql13`now()`).notNull(),
-  metadata: jsonb12("metadata").default(sql13`'{}'::jsonb`),
-  agentId: uuid13("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
+import { sql as sql18 } from "drizzle-orm";
+import { index as index13, jsonb as jsonb17, pgTable as pgTable25, text as text23, timestamp as timestamp17, uniqueIndex as uniqueIndex2, uuid as uuid17 } from "drizzle-orm/pg-core";
+var pairingAllowlistTable = pgTable25("pairing_allowlist", {
+  id: uuid17("id").primaryKey().defaultRandom(),
+  channel: text23("channel").notNull(),
+  senderId: text23("sender_id").notNull(),
+  createdAt: timestamp17("created_at", { withTimezone: true }).default(sql18`now()`).notNull(),
+  metadata: jsonb17("metadata").default(sql18`'{}'::jsonb`),
+  agentId: uuid17("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
 }, (table) => [
-  index3("pairing_allowlist_channel_agent_idx").on(table.channel, table.agentId),
-  uniqueIndex("pairing_allowlist_sender_channel_agent_idx").on(table.senderId, table.channel, table.agentId)
+  index13("pairing_allowlist_channel_agent_idx").on(table.channel, table.agentId),
+  uniqueIndex2("pairing_allowlist_sender_channel_agent_idx").on(table.senderId, table.channel, table.agentId)
 ]);
 // schema/pairingRequest.ts
 init_agent();
-import { sql as sql14 } from "drizzle-orm";
-import { index as index4, jsonb as jsonb13, pgTable as pgTable16, text as text14, timestamp as timestamp14, uniqueIndex as uniqueIndex2, uuid as uuid14 } from "drizzle-orm/pg-core";
-var pairingRequestTable = pgTable16("pairing_requests", {
-  id: uuid14("id").primaryKey().defaultRandom(),
-  channel: text14("channel").notNull(),
-  senderId: text14("sender_id").notNull(),
-  code: text14("code").notNull(),
-  createdAt: timestamp14("created_at", { withTimezone: true }).default(sql14`now()`).notNull(),
-  lastSeenAt: timestamp14("last_seen_at", { withTimezone: true }).default(sql14`now()`).notNull(),
-  metadata: jsonb13("metadata").default(sql14`'{}'::jsonb`),
-  agentId: uuid14("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
+import { sql as sql19 } from "drizzle-orm";
+import { index as index14, jsonb as jsonb18, pgTable as pgTable26, text as text24, timestamp as timestamp18, uniqueIndex as uniqueIndex3, uuid as uuid18 } from "drizzle-orm/pg-core";
+var pairingRequestTable = pgTable26("pairing_requests", {
+  id: uuid18("id").primaryKey().defaultRandom(),
+  channel: text24("channel").notNull(),
+  senderId: text24("sender_id").notNull(),
+  code: text24("code").notNull(),
+  createdAt: timestamp18("created_at", { withTimezone: true }).default(sql19`now()`).notNull(),
+  lastSeenAt: timestamp18("last_seen_at", { withTimezone: true }).default(sql19`now()`).notNull(),
+  metadata: jsonb18("metadata").default(sql19`'{}'::jsonb`),
+  agentId: uuid18("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
 }, (table) => [
-  index4("pairing_requests_channel_agent_idx").on(table.channel, table.agentId),
-  uniqueIndex2("pairing_requests_code_channel_agent_idx").on(table.code, table.channel, table.agentId),
-  uniqueIndex2("pairing_requests_sender_channel_agent_idx").on(table.senderId, table.channel, table.agentId)
+  index14("pairing_requests_channel_agent_idx").on(table.channel, table.agentId),
+  uniqueIndex3("pairing_requests_code_channel_agent_idx").on(table.code, table.channel, table.agentId),
+  uniqueIndex3("pairing_requests_sender_channel_agent_idx").on(table.senderId, table.channel, table.agentId)
 ]);
 // schema/participant.ts
 init_agent();
-import { sql as sql15 } from "drizzle-orm";
-import { foreignKey as foreignKey4, index as index5, pgTable as pgTable17, text as text15, timestamp as timestamp15, uuid as uuid15 } from "drizzle-orm/pg-core";
-var participantTable = pgTable17("participants", {
-  id: uuid15("id").notNull().primaryKey().default(sql15`gen_random_uuid()`),
-  createdAt: timestamp15("created_at", { withTimezone: true }).default(sql15`now()`).notNull(),
-  entityId: uuid15("entity_id").references(() => entityTable.id, {
+import { sql as sql20 } from "drizzle-orm";
+import { foreignKey as foreignKey8, index as index15, pgTable as pgTable27, text as text25, timestamp as timestamp19, uuid as uuid19 } from "drizzle-orm/pg-core";
+var participantTable = pgTable27("participants", {
+  id: uuid19("id").notNull().primaryKey().default(sql20`gen_random_uuid()`),
+  createdAt: timestamp19("created_at", { withTimezone: true }).default(sql20`now()`).notNull(),
+  entityId: uuid19("entity_id").references(() => entityTable.id, {
     onDelete: "cascade"
   }),
-  roomId: uuid15("room_id").references(() => roomTable.id, {
+  roomId: uuid19("room_id").references(() => roomTable.id, {
     onDelete: "cascade"
   }),
-  agentId: uuid15("agent_id").references(() => agentTable.id, {
+  agentId: uuid19("agent_id").references(() => agentTable.id, {
     onDelete: "cascade"
   }),
-  roomState: text15("room_state")
+  roomState: text25("room_state")
 }, (table) => [
-  index5("idx_participants_user").on(table.entityId),
-  index5("idx_participants_room").on(table.roomId),
-  foreignKey4({
+  index15("idx_participants_user").on(table.entityId),
+  index15("idx_participants_room").on(table.roomId),
+  foreignKey8({
     name: "fk_room",
     columns: [table.roomId],
     foreignColumns: [roomTable.id]
   }).onDelete("cascade"),
-  foreignKey4({
+  foreignKey8({
     name: "fk_user",
     columns: [table.entityId],
     foreignColumns: [entityTable.id]
@@ -3685,34 +3972,34 @@ var participantTable = pgTable17("participants", {
 ]);
 // schema/relationship.ts
 init_agent();
-import { sql as sql16 } from "drizzle-orm";
+import { sql as sql21 } from "drizzle-orm";
 import {
-  foreignKey as foreignKey5,
-  index as index6,
-  jsonb as jsonb14,
-  pgTable as pgTable18,
-  text as text16,
-  timestamp as timestamp16,
-  unique as unique2,
-  uuid as uuid16
+  foreignKey as foreignKey9,
+  index as index16,
+  jsonb as jsonb19,
+  pgTable as pgTable28,
+  text as text26,
+  timestamp as timestamp20,
+  unique as unique3,
+  uuid as uuid20
 } from "drizzle-orm/pg-core";
-var relationshipTable = pgTable18("relationships", {
-  id: uuid16("id").notNull().primaryKey().default(sql16`gen_random_uuid()`),
-  createdAt: timestamp16("created_at", { withTimezone: true }).default(sql16`now()`).notNull(),
-  sourceEntityId: uuid16("source_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  targetEntityId: uuid16("target_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  agentId: uuid16("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  tags: text16("tags").array(),
-  metadata: jsonb14("metadata")
+var relationshipTable = pgTable28("relationships", {
+  id: uuid20("id").notNull().primaryKey().default(sql21`gen_random_uuid()`),
+  createdAt: timestamp20("created_at", { withTimezone: true }).default(sql21`now()`).notNull(),
+  sourceEntityId: uuid20("source_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  targetEntityId: uuid20("target_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  agentId: uuid20("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  tags: text26("tags").array(),
+  metadata: jsonb19("metadata")
 }, (table) => [
-  index6("idx_relationships_users").on(table.sourceEntityId, table.targetEntityId),
-  unique2("unique_relationship").on(table.sourceEntityId, table.targetEntityId, table.agentId),
-  foreignKey5({
+  index16("idx_relationships_users").on(table.sourceEntityId, table.targetEntityId),
+  unique3("unique_relationship").on(table.sourceEntityId, table.targetEntityId, table.agentId),
+  foreignKey9({
     name: "fk_user_a",
     columns: [table.sourceEntityId],
     foreignColumns: [entityTable.id]
   }).onDelete("cascade"),
-  foreignKey5({
+  foreignKey9({
     name: "fk_user_b",
     columns: [table.targetEntityId],
     foreignColumns: [entityTable.id]
@@ -3722,24 +4009,58 @@ var relationshipTable = pgTable18("relationships", {
 // schema/index.ts
 init_server();
 
+// schema/sessionSummaries.ts
+import { sql as sql23 } from "drizzle-orm";
+import { index as index17, integer as integer2, jsonb as jsonb20, pgTable as pgTable30, real as real3, text as text27, timestamp as timestamp22, uuid as uuid22 } from "drizzle-orm/pg-core";
+var sessionSummaries = pgTable30("session_summaries", {
+  id: uuid22("id").primaryKey().notNull(),
+  agentId: uuid22("agent_id").notNull(),
+  roomId: uuid22("room_id").notNull(),
+  entityId: uuid22("entity_id"),
+  summary: text27("summary").notNull(),
+  messageCount: integer2("message_count").notNull(),
+  lastMessageOffset: integer2("last_message_offset").default(0).notNull(),
+  startTime: timestamp22("start_time").notNull(),
+  endTime: timestamp22("end_time").notNull(),
+  topics: jsonb20("topics").$type(),
+  metadata: jsonb20("metadata"),
+  embedding: real3("embedding").array(),
+  createdAt: timestamp22("created_at").default(sql23`now()`).notNull(),
+  updatedAt: timestamp22("updated_at").default(sql23`now()`).notNull()
+}, (table) => [
+  index17("session_summaries_agent_room_idx").on(table.agentId, table.roomId),
+  index17("session_summaries_entity_idx").on(table.entityId),
+  index17("session_summaries_start_time_idx").on(table.startTime)
+]);
 // schema/tasks.ts
 init_agent();
-import { sql as sql18 } from "drizzle-orm";
-import { jsonb as jsonb15, pgTable as pgTable20, text as text17, timestamp as timestamp18, uuid as uuid18 } from "drizzle-orm/pg-core";
-var taskTable = pgTable20("tasks", {
-  id: uuid18("id").primaryKey().defaultRandom(),
-  name: text17("name").notNull(),
-  description: text17("description"),
-  roomId: uuid18("room_id"),
-  worldId: uuid18("world_id"),
-  entityId: uuid18("entity_id"),
-  agentId: uuid18("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  tags: text17("tags").array().default(sql18`'{}'::text[]`),
-  metadata: jsonb15("metadata").default(sql18`'{}'::jsonb`),
-  createdAt: timestamp18("created_at", { withTimezone: true }).defaultNow(),
-  updatedAt: timestamp18("updated_at", { withTimezone: true }).defaultNow()
+import { sql as sql24 } from "drizzle-orm";
+import { jsonb as jsonb21, pgTable as pgTable31, text as text28, timestamp as timestamp23, uuid as uuid23 } from "drizzle-orm/pg-core";
+var taskTable = pgTable31("tasks", {
+  id: uuid23("id").primaryKey().defaultRandom(),
+  name: text28("name").notNull(),
+  description: text28("description"),
+  roomId: uuid23("room_id"),
+  worldId: uuid23("world_id"),
+  entityId: uuid23("entity_id"),
+  agentId: uuid23("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  tags: text28("tags").array().default(sql24`'{}'::text[]`),
+  metadata: jsonb21("metadata").default(sql24`'{}'::jsonb`),
+  createdAt: timestamp23("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp23("updated_at", { withTimezone: true }).defaultNow()
 });
 // base.ts
+function asRawMessage(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return;
+}
+function asMetadata(value) {
+  return value ?? undefined;
+}
+var v4 = () => crypto.randomUUID();
+
 class BaseDrizzleAdapter extends DatabaseAdapter {
   maxRetries = 3;
   baseDelay = 1000;
@@ -3784,8 +4105,11 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     if (names instanceof Set) {
       return Array.from(names).map(String);
     }
-    if (typeof names === "object" && typeof names[Symbol.iterator] === "function") {
-      return Array.from(names).map(String);
+    if (typeof names === "object") {
+      const iterableNames = names;
+      if (typeof iterableNames[Symbol.iterator] === "function") {
+        return Array.from(names).map(String);
+      }
     }
     return [String(names)];
   }
@@ -3856,13 +4180,12 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       }
       const resolvedDimension = DIMENSION_MAP[dimension];
       if (!resolvedDimension) {
-        const fallbackDimension = this.embeddingDimension ?? DIMENSION_MAP[384];
-        this.embeddingDimension = fallbackDimension;
         logger9.warn({
           src: "plugin:sql",
+          agentId: this.agentId,
           requestedDimension: dimension,
-          fallbackDimension
-        }, "Unsupported embedding dimension requested; keeping fallback embedding column");
+          fallbackDimension: this.embeddingDimension
+        }, "Unsupported embedding dimension requested; keeping current embedding column");
         return;
       }
       this.embeddingDimension = resolvedDimension;
@@ -4209,15 +4532,17 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         return await this.db.transaction(async (tx) => {
           const normalizedEntities = entities.map((entity) => {
             const { names, metadata, ...normalizedEntity } = entity;
+            const id = entity.id || v4();
             return {
               ...normalizedEntity,
+              id,
               agentId: this.agentId,
               names: this.normalizeEntityNames(names),
               metadata: metadata || {}
             };
           });
           await tx.insert(entityTable).values(normalizedEntities);
-          return true;
+          return normalizedEntities.map((entity) => entity.id);
         });
       } catch (error) {
         logger9.error({
@@ -4225,7 +4550,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           entityId: entities[0]?.id,
           error: error instanceof Error ? error.message : String(error)
         }, "Failed to create entities");
-        return false;
+        return [];
       }
     });
   }
@@ -4236,8 +4561,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     }
     try {
       const existingEntities = await this.getEntitiesByIds([entity.id]);
-      if (!existingEntities || !existingEntities.length) {
-        return await this.createEntities([entity]);
+      if (!existingEntities?.length) {
+        return (await this.createEntities([entity])).length > 0;
       }
       return true;
     } catch (error) {
@@ -4274,11 +4599,11 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async getEntitiesByNames(params) {
     return this.withDatabase(async () => {
       const { names, agentId } = params;
-      const nameConditions = names.map((name) => sql27`${name} = ANY(${entityTable.names})`);
-      const query = sql27`
+      const nameConditions = names.map((name) => sql33`${name} = ANY(${entityTable.names})`);
+      const query = sql33`
         SELECT * FROM ${entityTable}
         WHERE ${entityTable.agentId} = ${agentId}
-        AND (${sql27.join(nameConditions, sql27` OR `)})
+        AND (${sql33.join(nameConditions, sql33` OR `)})
       `;
       const result = await this.db.execute(query);
       return result.rows.map((row) => ({
@@ -4301,7 +4626,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           metadata: row.metadata || {}
         }));
       }
-      const searchQuery = sql27`
+      const searchQuery = sql33`
         SELECT * FROM ${entityTable}
         WHERE ${entityTable.agentId} = ${agentId}
         AND EXISTS (
@@ -4409,9 +4734,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     });
   }
   async getMemories(params) {
-    const { entityId, agentId, roomId, worldId, tableName, unique: unique3, start, end, offset } = params;
-    if (!tableName)
-      throw new Error("tableName is required");
+    const { entityId, agentId, roomId, worldId, unique: unique4, start, end, offset } = params;
+    const tableName = params.tableName ?? "messages";
     if (offset !== undefined && offset < 0) {
       throw new Error("offset must be a non-negative number");
     }
@@ -4429,7 +4753,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       if (end !== undefined) {
         conditions.push(lte(memoryTable.createdAt, new Date(end)));
       }
-      if (unique3) {
+      if (unique4) {
         conditions.push(eq2(memoryTable.unique, true));
       }
       if (agentId) {
@@ -4557,7 +4881,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async getCachedEmbeddings(opts) {
     return this.withDatabase(async () => {
       try {
-        const results = await this.db.execute(sql27`
+        const results = await this.db.execute(sql33`
                     WITH content_text AS (
                         SELECT
                             m.id,
@@ -4586,9 +4910,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
                     )
                     SELECT
                         embedding,
-                        levenshtein(${opts.query_input}, content_text) as levenshtein_score
+                        levenshtein(CAST(${opts.query_input} AS text), content_text) as levenshtein_score
                     FROM embedded_text
-                    WHERE levenshtein(${opts.query_input}, content_text) <= ${opts.query_threshold}
+                    WHERE levenshtein(CAST(${opts.query_input} AS text), content_text) <= ${opts.query_threshold}
                     ORDER BY levenshtein_score
                     LIMIT ${opts.query_match_count}
                 `);
@@ -4617,7 +4941,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         const jsonString = JSON.stringify(sanitizedBody);
         await this.withEntityContext(params.entityId, async (tx) => {
           await tx.insert(logTable).values({
-            body: sql27`${jsonString}::jsonb`,
+            body: sql33`${jsonString}::jsonb`,
             entityId: params.entityId,
             roomId: params.roomId,
             type: params.type
@@ -4631,7 +4955,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           entityId: params.entityId,
           error: error instanceof Error ? error.message : String(error)
         }, "Failed to create log entry");
-        throw error;
+        return;
       }
     });
   }
@@ -4691,7 +5015,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const runMap = new Map;
       const conditions = [
         eq2(logTable.type, "run_event"),
-        sql27`${logTable.body} ? 'runId'`,
+        sql33`${logTable.body} ? 'runId'`,
         eq2(roomTable.agentId, this.agentId)
       ];
       if (params.roomId) {
@@ -4706,9 +5030,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const whereClause = and(...conditions);
       const eventLimit = Math.max(limit * 20, 200);
       const runEventRows = await tx.select({
-        runId: sql27`(${logTable.body} ->> 'runId')`,
-        status: sql27`(${logTable.body} ->> 'status')`,
-        messageId: sql27`(${logTable.body} ->> 'messageId')`,
+        runId: sql33`(${logTable.body} ->> 'runId')`,
+        status: sql33`(${logTable.body} ->> 'status')`,
+        messageId: sql33`(${logTable.body} ->> 'messageId')`,
         rawBody: logTable.body,
         createdAt: logTable.createdAt,
         roomId: logTable.roomId,
@@ -4755,18 +5079,18 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           }
         }
         const createdAt = row.createdAt instanceof Date ? row.createdAt : new Date(row.createdAt);
-        const timestamp19 = createdAt.getTime();
+        const timestamp24 = createdAt.getTime();
         const bodyStatus = body?.status;
         const eventStatus = row.status ?? bodyStatus;
         if (eventStatus === "started") {
           const currentStartedAt = summary.startedAt === null ? null : typeof summary.startedAt === "bigint" ? Number(summary.startedAt) : summary.startedAt;
-          summary.startedAt = currentStartedAt === null ? timestamp19 : Math.min(currentStartedAt, timestamp19);
+          summary.startedAt = currentStartedAt === null ? timestamp24 : Math.min(currentStartedAt, timestamp24);
         } else if (eventStatus === "completed" || eventStatus === "timeout" || eventStatus === "error") {
           summary.status = eventStatus;
-          summary.endedAt = timestamp19;
+          summary.endedAt = timestamp24;
           if (summary.startedAt !== null) {
             const startedAtNum = typeof summary.startedAt === "bigint" ? Number(summary.startedAt) : summary.startedAt;
-            summary.durationMs = Math.max(timestamp19 - startedAtNum, 0);
+            summary.durationMs = Math.max(timestamp24 - startedAtNum, 0);
           }
         }
         runMap.set(runId, summary);
@@ -4794,8 +5118,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       }
       const runIds = limitedRuns.map((run) => run.runId).filter(Boolean);
       if (runIds.length > 0) {
-        const runIdArray = sql27`array[${sql27.join(runIds.map((id) => sql27`${id}`), sql27`, `)}]::text[]`;
-        const actionSummary = await this.db.execute(sql27`
+        const runIdArray = sql33`array[${sql33.join(runIds.map((id) => sql33`${id}`), sql33`, `)}]::text[]`;
+        const actionSummary = await this.db.execute(sql33`
           SELECT
             body->>'runId' as "runId",
             COUNT(*)::int as "actions",
@@ -4815,7 +5139,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           counts.errors += Number(row.errors ?? 0);
           counts.modelCalls += Number(row.modelCalls ?? 0);
         }
-        const evaluatorSummary = await this.db.execute(sql27`
+        const evaluatorSummary = await this.db.execute(sql33`
           SELECT
             body->>'runId' as "runId",
             COUNT(*)::int as "evaluators"
@@ -4831,7 +5155,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             continue;
           counts.evaluators += Number(row.evaluators ?? 0);
         }
-        const genericSummary = await this.db.execute(sql27`
+        const genericSummary = await this.db.execute(sql33`
           SELECT
             body->>'runId' as "runId",
             COUNT(*) FILTER (WHERE type LIKE 'useModel:%')::int as "modelLogs",
@@ -4879,13 +5203,13 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       worldId: params.worldId,
       entityId: params.entityId,
       unique: params.unique,
-      tableName: params.tableName
+      tableName: params.tableName ?? "messages"
     });
   }
   async searchMemoriesByEmbedding(embedding, params) {
     return this.withDatabase(async () => {
       const cleanVector = embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
-      const similarity = sql27`1 - (${cosineDistance(embeddingTable[this.embeddingDimension], cleanVector)})`;
+      const similarity = sql33`1 - (${cosineDistance(embeddingTable[this.embeddingDimension], cleanVector)})`;
       const conditions = [eq2(memoryTable.type, params.tableName)];
       if (params.unique) {
         conditions.push(eq2(memoryTable.unique, true));
@@ -4951,8 +5275,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         {
           id: memoryId,
           type: tableName,
-          content: sql27`${contentToInsert}::jsonb`,
-          metadata: sql27`${metadataToInsert}::jsonb`,
+          content: sql33`${contentToInsert}::jsonb`,
+          metadata: sql33`${metadataToInsert}::jsonb`,
           entityId: memory.entityId,
           roomId: memory.roomId,
           worldId: memory.worldId,
@@ -4982,15 +5306,15 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             const contentToUpdate = typeof memory.content === "string" ? memory.content : JSON.stringify(memory.content ?? {});
             const metadataToUpdate = typeof memory.metadata === "string" ? memory.metadata : JSON.stringify(memory.metadata ?? {});
             await tx.update(memoryTable).set({
-              content: sql27`${contentToUpdate}::jsonb`,
+              content: sql33`${contentToUpdate}::jsonb`,
               ...memory.metadata && {
-                metadata: sql27`${metadataToUpdate}::jsonb`
+                metadata: sql33`${metadataToUpdate}::jsonb`
               }
             }).where(eq2(memoryTable.id, memory.id));
           } else if (memory.metadata) {
             const metadataToUpdate = typeof memory.metadata === "string" ? memory.metadata : JSON.stringify(memory.metadata ?? {});
             await tx.update(memoryTable).set({
-              metadata: sql27`${metadataToUpdate}::jsonb`
+              metadata: sql33`${metadataToUpdate}::jsonb`
             }).where(eq2(memoryTable.id, memory.id));
           }
           if (memory.embedding && Array.isArray(memory.embedding)) {
@@ -5057,15 +5381,19 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     }
   }
   async getMemoryFragments(tx, documentId) {
-    const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq2(memoryTable.agentId, this.agentId), sql27`${memoryTable.metadata}->>'documentId' = ${documentId}`));
+    const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq2(memoryTable.agentId, this.agentId), sql33`${memoryTable.metadata}->>'documentId' = ${documentId}`));
     return fragments.map((f) => ({ id: f.id }));
   }
-  async deleteAllMemories(roomId, tableName) {
+  async deleteAllMemories(roomIdsOrRoomId, tableName) {
     return this.withDatabase(async () => {
+      const roomIds = Array.isArray(roomIdsOrRoomId) ? roomIdsOrRoomId : [roomIdsOrRoomId];
+      if (roomIds.length === 0) {
+        return;
+      }
       await this.db.transaction(async (tx) => {
-        const rows = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq2(memoryTable.roomId, roomId), eq2(memoryTable.type, tableName)));
+        const rows = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(inArray(memoryTable.roomId, roomIds), eq2(memoryTable.type, tableName), eq2(memoryTable.agentId, this.agentId)));
         const ids = rows.map((r) => r.id);
-        logger9.debug({ src: "plugin:sql", roomId, tableName, memoryCount: ids.length }, "Deleting all memories");
+        logger9.debug({ src: "plugin:sql", roomIds, tableName, memoryCount: ids.length }, "Deleting all memories");
         if (ids.length === 0) {
           return;
         }
@@ -5073,19 +5401,36 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           await this.deleteMemoryFragments(tx, memoryId);
           await tx.delete(embeddingTable).where(eq2(embeddingTable.memoryId, memoryId));
         }));
-        await tx.delete(memoryTable).where(and(eq2(memoryTable.roomId, roomId), eq2(memoryTable.type, tableName)));
+        await tx.delete(memoryTable).where(and(inArray(memoryTable.roomId, roomIds), eq2(memoryTable.type, tableName), eq2(memoryTable.agentId, this.agentId)));
       });
     });
   }
-  async countMemories(roomId, unique3 = true, tableName = "") {
-    if (!tableName)
-      throw new Error("tableName is required");
+  async countMemories(paramsOrRoomId, unique4 = true, tableName) {
+    const params = typeof paramsOrRoomId === "string" ? {
+      roomIds: [paramsOrRoomId],
+      unique: unique4,
+      tableName: tableName ?? "messages"
+    } : {
+      ...paramsOrRoomId,
+      tableName: paramsOrRoomId.tableName ?? "messages",
+      unique: paramsOrRoomId.unique ?? false
+    };
     return this.withDatabase(async () => {
-      const conditions = [eq2(memoryTable.roomId, roomId), eq2(memoryTable.type, tableName)];
-      if (unique3) {
+      const tableName2 = params.tableName ?? "messages";
+      const conditions = [eq2(memoryTable.type, tableName2)];
+      if (params.roomIds && params.roomIds.length > 0) {
+        conditions.push(inArray(memoryTable.roomId, params.roomIds));
+      }
+      if (params.entityId) {
+        conditions.push(eq2(memoryTable.entityId, params.entityId));
+      }
+      if (params.agentId) {
+        conditions.push(eq2(memoryTable.agentId, params.agentId));
+      }
+      if (params.unique) {
         conditions.push(eq2(memoryTable.unique, true));
       }
-      const result = await this.db.select({ count: sql27`count(*)` }).from(memoryTable).where(and(...conditions));
+      const result = await this.db.select({ count: sql33`count(*)` }).from(memoryTable).where(and(...conditions));
       const result0 = result[0];
       return Number(result0?.count ?? 0);
     });
@@ -5250,7 +5595,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         roomId: participantTable.roomId
       }).from(participantTable).where(eq2(participantTable.entityId, entityId));
       const entities = await this.getEntitiesByIds([entityId]);
-      if (!entities || !entities.length) {
+      if (!entities?.length) {
         return [];
       }
       return result.map((row) => ({
@@ -5365,22 +5710,22 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       if (entityIds.length === 0) {
         return [];
       }
-      const entityFilter = sql27.join(entityIds.map((id) => sql27`(${relationshipTable.sourceEntityId} = ${id} OR ${relationshipTable.targetEntityId} = ${id})`), sql27` OR `);
-      let query = sql27`
+      const entityFilter = sql33.join(entityIds.map((id) => sql33`(${relationshipTable.sourceEntityId} = ${id} OR ${relationshipTable.targetEntityId} = ${id})`), sql33` OR `);
+      let query = sql33`
         SELECT * FROM ${relationshipTable}
         WHERE (${entityFilter})
       `;
       if (tags && tags.length > 0) {
-        query = sql27`
+        query = sql33`
           ${query}
-          AND ${relationshipTable.tags} && CAST(ARRAY[${sql27.join(tags, sql27`, `)}] AS text[])
+          AND ${relationshipTable.tags} && CAST(ARRAY[${sql33.join(tags, sql33`, `)}] AS text[])
         `;
       }
       if (typeof limit === "number") {
-        query = sql27`${query} LIMIT ${limit}`;
+        query = sql33`${query} LIMIT ${limit}`;
       }
       if (typeof offset === "number" && offset > 0) {
-        query = sql27`${query} OFFSET ${offset}`;
+        query = sql33`${query} OFFSET ${offset}`;
       }
       const result = await this.db.execute(query);
       return result.rows.map((relationship) => ({
@@ -5498,7 +5843,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         const now = new Date;
         const metadata = task.metadata || {};
         const values = {
-          id: task.id,
+          ...task.id ? { id: task.id } : {},
           name: task.name,
           description: task.description,
           roomId: task.roomId,
@@ -5518,7 +5863,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withRetry(async () => {
       return this.withDatabase(async () => {
         const result = await this.db.select().from(taskTable).where(and(eq2(taskTable.agentId, this.agentId), ...params.roomId ? [eq2(taskTable.roomId, params.roomId)] : [], ...params.tags && params.tags.length > 0 ? [
-          sql27`${taskTable.tags} @> ARRAY[${sql27.join(params.tags.map((t) => sql27`${t}`), sql27`, `)}]::text[]`
+          sql33`${taskTable.tags} @> ARRAY[${sql33.join(params.tags.map((t) => sql33`${t}`), sql33`, `)}]::text[]`
         ] : []));
         return result.map((row) => ({
           id: row.id,
@@ -5708,7 +6053,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getMessageServerByRlsServerId(rlsServerId) {
     return this.withDatabase(async () => {
-      const results = await this.db.execute(sql27`
+      const results = await this.db.execute(sql33`
         SELECT id, name, source_type, source_id, metadata, created_at, updated_at
         FROM message_servers
         WHERE server_id = ${rlsServerId}
@@ -5821,7 +6166,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         channelId: row.channelId,
         authorId: row.authorId,
         content: row.content,
-        rawMessage: row.rawMessage || undefined,
+        rawMessage: asRawMessage(row.rawMessage),
         sourceType: row.sourceType || undefined,
         sourceId: row.sourceId || undefined,
         metadata: row.metadata || undefined,
@@ -5866,10 +6211,10 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         channelId: r.channelId,
         authorId: r.authorId,
         content: r.content,
-        rawMessage: r.rawMessage || undefined,
+        rawMessage: asRawMessage(r.rawMessage),
         sourceType: r.sourceType || undefined,
         sourceId: r.sourceId || undefined,
-        metadata: r.metadata || undefined,
+        metadata: asMetadata(r.metadata),
         inReplyToRootMessageId: r.inReplyToRootMessageId,
         createdAt: r.createdAt,
         updatedAt: r.updatedAt
@@ -5987,18 +6332,27 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       }, ids);
     });
   }
-  async getPairingRequests(channel, agentId) {
+  async getPairingRequests(queries) {
     return this.withDatabase(async () => {
-      const results = await this.db.select().from(pairingRequestTable).where(and(eq2(pairingRequestTable.channel, channel), eq2(pairingRequestTable.agentId, agentId))).orderBy(pairingRequestTable.createdAt);
-      return results.map((row) => ({
-        id: row.id,
-        channel: row.channel,
-        senderId: row.senderId,
-        code: row.code,
-        createdAt: row.createdAt,
-        lastSeenAt: row.lastSeenAt,
-        metadata: row.metadata || undefined,
-        agentId: row.agentId
+      if (queries.length === 0) {
+        return [];
+      }
+      return Promise.all(queries.map(async ({ channel, agentId }) => {
+        const results = await this.db.select().from(pairingRequestTable).where(and(eq2(pairingRequestTable.channel, channel), eq2(pairingRequestTable.agentId, agentId))).orderBy(pairingRequestTable.createdAt);
+        return {
+          channel,
+          agentId,
+          requests: results.map((row) => ({
+            id: row.id,
+            channel: row.channel,
+            senderId: row.senderId,
+            code: row.code,
+            createdAt: row.createdAt,
+            lastSeenAt: row.lastSeenAt,
+            metadata: row.metadata || undefined,
+            agentId: row.agentId
+          }))
+        };
       }));
     });
   }
@@ -6065,7 +6419,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async isReady() {
     try {
-      await this.db.execute(sql27`SELECT 1`);
+      await this.db.execute(sql33`SELECT 1`);
       return true;
     } catch {
       return false;
@@ -6168,8 +6522,12 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async patchComponents(_updates, _options) {}
   async upsertEntities(entities) {
     for (const entity of entities) {
+      if (!entity.id) {
+        await this.createEntities([entity]);
+        continue;
+      }
       const existing = await this.getEntitiesByIds([entity.id]);
-      if (existing && existing.length > 0) {
+      if (existing.length > 0) {
         await this.updateEntity(entity);
       } else {
         await this.createEntities([entity]);
@@ -6186,11 +6544,17 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       if (params.agentId) {
         conditions.push(eq2(entityTable.agentId, params.agentId));
       }
-      if (params.componentType) {
-        const subquery = sql27`EXISTS (
+      if (params.componentType || params.worldId) {
+        const subConditions = [sql33`${componentTable.entityId} = ${entityTable.id}`];
+        if (params.componentType) {
+          subConditions.push(sql33`${componentTable.type} = ${params.componentType}`);
+        }
+        if (params.worldId) {
+          subConditions.push(sql33`${componentTable.worldId} = ${params.worldId}`);
+        }
+        const subquery = sql33`EXISTS (
           SELECT 1 FROM ${componentTable}
-          WHERE ${componentTable.entityId} = ${entityTable.id}
-          AND ${componentTable.type} = ${params.componentType}
+          WHERE ${sql33.join(subConditions, sql33` AND `)}
         )`;
         conditions.push(subquery);
       }
@@ -6202,13 +6566,27 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         query = query.offset(params.offset);
       }
       const result = await query;
-      return result.map((row) => ({
+      const entities = result.map((row) => ({
         ...row,
         id: row.id,
         agentId: row.agentId,
         names: row.names || [],
         metadata: row.metadata || {}
       }));
+      if (params.includeAllComponents && entities.length > 0) {
+        const entityIds = entities.flatMap((entity) => entity.id ? [entity.id] : []);
+        const components = await this.getComponentsForEntities(entityIds, params.worldId);
+        const componentsByEntity = new Map;
+        for (const comp of components) {
+          const list = componentsByEntity.get(comp.entityId) ?? [];
+          list.push(comp);
+          componentsByEntity.set(comp.entityId, list);
+        }
+        for (const entity of entities) {
+          entity.components = entity.id ? componentsByEntity.get(entity.id) ?? [] : [];
+        }
+      }
+      return entities;
     });
   }
   async updateEntities(entities) {
@@ -6273,8 +6651,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async createMemories(memories) {
     const ids = [];
-    for (const { memory, tableName, unique: unique3 } of memories) {
-      const memoryWithUnique = unique3 !== undefined ? { ...memory, unique: unique3 } : memory;
+    for (const { memory, tableName, unique: unique4 } of memories) {
+      const memoryWithUnique = unique4 !== undefined ? { ...memory, unique: unique4 } : memory;
       const id = await this.createMemory(memoryWithUnique, tableName);
       ids.push(id);
     }
@@ -6716,7 +7094,7 @@ class PgDatabaseAdapter extends BaseDrizzleAdapter {
 
 // pg/manager.ts
 import { logger as logger11, validateUuid as validateUuid2 } from "@elizaos/core";
-import { sql as sql28 } from "drizzle-orm";
+import { sql as sql34 } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { Pool } from "pg";
 
@@ -6778,7 +7156,7 @@ class PostgresConnectionManager {
           throw new Error(`Invalid UUID format for entity context: ${entityId}`);
         }
         try {
-          await tx.execute(sql28.raw(`SET LOCAL app.entity_id = '${entityId}'`));
+          await tx.execute(sql34.raw(`SET LOCAL app.entity_id = '${entityId}'`));
           logger11.debug(`[Entity Context] Set app.entity_id = ${entityId}`);
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
@@ -6805,7 +7183,8 @@ class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
   constructor(agentId, manager) {
     super(agentId);
     this.manager = manager;
-    this.db = drizzle2(this.manager.getConnection());
+    const drizzleAny = drizzle2;
+    this.db = drizzleAny(this.manager.getConnection());
   }
   async withEntityContext(_entityId, callback) {
     return this.db.transaction(callback);
@@ -6840,7 +7219,14 @@ class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
   async withDatabase(operation) {
     if (this.manager.isShuttingDown()) {
       const error = new Error("Database is shutting down - operation rejected");
-      logger12.warn({ src: "plugin:sql", error: error.message }, "Database operation rejected during shutdown");
+      logger12.info({ src: "plugin:sql", error: error.message }, "Database operation rejected during shutdown");
+      throw error;
+    }
+    const managerWithInit = this.manager;
+    await managerWithInit.initialize?.();
+    if (this.manager.isShuttingDown()) {
+      const error = new Error("Database is shutting down - operation rejected");
+      logger12.info({ src: "plugin:sql", error: error.message }, "Database operation rejected during shutdown");
       throw error;
     }
     return operation();
@@ -6851,7 +7237,8 @@ class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
     logger12.debug({ src: "plugin:sql" }, "PGliteDatabaseAdapter initialized");
   }
   async isReady() {
-    return !this.manager.isShuttingDown();
+    const managerWithState = this.manager;
+    return !this.manager.isShuttingDown() && managerWithState.isInitialized?.() === true;
   }
   async close() {
     await this.manager.close();
@@ -6867,12 +7254,60 @@ class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
 }
 
 // pglite/manager.ts
-import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { PGlite } from "@electric-sql/pglite";
 import { fuzzystrmatch } from "@electric-sql/pglite/contrib/fuzzystrmatch";
 import { vector as vector2 } from "@electric-sql/pglite/vector";
 import { logger as logger13 } from "@elizaos/core";
 
+// pglite/errors.ts
+var PGLITE_ERROR_CODES = {
+  ACTIVE_LOCK: "ELIZA_PGLITE_DATA_DIR_IN_USE",
+  CORRUPT_DATA: "ELIZA_PGLITE_CORRUPT_DATA",
+  MANUAL_RESET_REQUIRED: "ELIZA_PGLITE_MANUAL_RESET_REQUIRED"
+};
+
+class PgliteInitError extends Error {
+  code;
+  dataDir;
+  constructor(code, message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "PgliteInitError";
+    this.code = code;
+    this.dataDir = options?.dataDir;
+  }
+}
+function createPgliteInitError(code, message, options) {
+  return new PgliteInitError(code, message, options);
+}
+function getPgliteErrorCode(err) {
+  const seen = new Set;
+  let current = err;
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    if (typeof current === "object" && current !== null && "code" in current && typeof current.code === "string") {
+      const code = current.code;
+      if (code === PGLITE_ERROR_CODES.ACTIVE_LOCK || code === PGLITE_ERROR_CODES.CORRUPT_DATA || code === PGLITE_ERROR_CODES.MANUAL_RESET_REQUIRED) {
+        return code;
+      }
+    }
+    if (current instanceof Error) {
+      current = current.cause;
+      continue;
+    }
+    if (typeof current === "object" && current !== null && "cause" in current) {
+      current = current.cause;
+      continue;
+    }
+    break;
+  }
+  return null;
+}
+function isFatalPgliteErrorCode(code) {
+  return code === PGLITE_ERROR_CODES.ACTIVE_LOCK || code === PGLITE_ERROR_CODES.CORRUPT_DATA || code === PGLITE_ERROR_CODES.MANUAL_RESET_REQUIRED;
+}
+
+// pglite/manager.ts
 class PGliteClientManager {
   client;
   options;
@@ -6890,6 +7325,9 @@ class PGliteClientManager {
   isShuttingDown() {
     return this.shuttingDown;
   }
+  isInitialized() {
+    return this.initialized;
+  }
   async initialize() {
     if (this.initialized) {
       return;
@@ -6943,44 +7381,608 @@ class PGliteClientManager {
     }
     return String(error);
   }
+  reconcilePglitePidFile(dataDir) {
+    const pidPath = `${dataDir}/postmaster.pid`;
+    if (!existsSync(pidPath)) {
+      return "missing";
+    }
+    try {
+      const content = readFileSync(pidPath, "utf-8");
+      const firstLine = content.split(`
+`)[0]?.trim();
+      const pid = parseInt(firstLine, 10);
+      if (Number.isNaN(pid) || pid <= 0) {
+        unlinkSync(pidPath);
+        logger13.info({ src: "plugin:sql", dataDir, pidPath }, "Removed malformed PGlite postmaster.pid");
+        return "cleared-malformed";
+      }
+      try {
+        process.kill(pid, 0);
+        logger13.warn({ src: "plugin:sql", dataDir, pid }, "PGlite data dir is already in use by another process");
+        return "active";
+      } catch (killErr) {
+        const code = killErr.code;
+        if (code === "ESRCH") {
+          unlinkSync(pidPath);
+          logger13.info({ src: "plugin:sql", dataDir, pid }, "Removed stale PGlite postmaster.pid");
+          return "cleared-stale";
+        }
+        logger13.warn({ src: "plugin:sql", dataDir, pid, code }, "Cannot confirm PGlite postmaster.pid ownership");
+        return "active-unconfirmed";
+      }
+    } catch (err) {
+      logger13.warn({
+        src: "plugin:sql",
+        dataDir,
+        error: this.getErrorText(err)
+      }, "Failed to inspect PGlite postmaster.pid");
+      return "check-failed";
+    }
+  }
+  createActiveLockError(dataDir, cause) {
+    return createPgliteInitError(PGLITE_ERROR_CODES.ACTIVE_LOCK, `PGlite data dir is already in use at ${dataDir}. Close the other Eliza process, or point PGLITE_DATA_DIR at a different directory before retrying.`, { cause, dataDir });
+  }
+  createManualResetRequiredError(dataDir, cause) {
+    const errorText = this.getErrorText(cause);
+    const corruptCause = createPgliteInitError(PGLITE_ERROR_CODES.CORRUPT_DATA, `PGlite data dir at ${dataDir} appears corrupt or unreadable: ${errorText}`, { cause, dataDir });
+    return createPgliteInitError(PGLITE_ERROR_CODES.MANUAL_RESET_REQUIRED, `PGlite initialization failed for ${dataDir}: ${errorText}. Stop Eliza, then rename or delete only this directory before retrying: ${dataDir}`, { cause: corruptCause, dataDir });
+  }
+  async queryMigrationsSchema() {
+    await this.client.query("CREATE SCHEMA IF NOT EXISTS migrations");
+    this.initialized = true;
+  }
   async initializeInternal() {
     try {
-      await this.client.query("CREATE SCHEMA IF NOT EXISTS migrations");
-      this.initialized = true;
+      await this.queryMigrationsSchema();
       return;
     } catch (initialError) {
       const dataDir = this.getDataDir();
       if (!this.isFileBackedDataDir(dataDir)) {
         throw initialError;
       }
-      const errorText = this.getErrorText(initialError);
-      const backupDir = `${dataDir}.corrupt-${Date.now()}`;
-      logger13.error({
-        src: "plugin:sql",
-        dataDir,
-        backupDir,
-        error: errorText
-      }, "PGlite initialization failed; attempting recovery with a clean data directory");
-      try {
-        await this.client.close();
-      } catch {}
-      if (existsSync(dataDir)) {
-        renameSync(dataDir, backupDir);
+      const pidStatus = this.reconcilePglitePidFile(dataDir);
+      if (pidStatus === "active" || pidStatus === "active-unconfirmed" || pidStatus === "check-failed") {
+        throw this.createActiveLockError(dataDir, initialError);
       }
-      mkdirSync(dataDir, { recursive: true });
-      this.client = this.createClient(this.options);
-      try {
-        await this.client.query("CREATE SCHEMA IF NOT EXISTS migrations");
-        this.initialized = true;
+      if (pidStatus === "cleared-stale" || pidStatus === "cleared-malformed") {
         logger13.warn({
           src: "plugin:sql",
           dataDir,
-          backupDir
-        }, "Recovered from corrupted PGlite database directory");
-      } catch (recoveryError) {
-        throw new Error(`PGlite recovery failed for ${dataDir}: ${this.getErrorText(recoveryError)}`);
+          error: this.getErrorText(initialError)
+        }, "Retrying PGlite initialization after clearing postmaster.pid");
+        try {
+          await this.client.close();
+        } catch {}
+        this.client = this.createClient(this.options);
+        try {
+          await this.queryMigrationsSchema();
+          return;
+        } catch (retryError) {
+          logger13.error({
+            src: "plugin:sql",
+            dataDir,
+            error: this.getErrorText(retryError)
+          }, "PGlite initialization still failed after clearing postmaster.pid");
+          throw this.createManualResetRequiredError(dataDir, retryError);
+        }
+      }
+      logger13.error({
+        src: "plugin:sql",
+        dataDir,
+        error: this.getErrorText(initialError)
+      }, "PGlite initialization failed; manual reset required");
+      throw this.createManualResetRequiredError(dataDir, initialError);
+    }
+  }
+}
+
+// services/advanced-memory-storage.ts
+import {
+  ChannelType as ChannelType2,
+  Service
+} from "@elizaos/core";
+
+// utils/string-to-uuid.ts
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function hashSegment(input, seed) {
+  let hash = seed >>> 0;
+  for (let index18 = 0;index18 < input.length; index18 += 1) {
+    hash ^= input.charCodeAt(index18);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function stringToUuid(target) {
+  const value = typeof target === "number" ? target.toString() : target;
+  if (typeof value !== "string") {
+    throw new TypeError("Value must be string");
+  }
+  if (UUID_PATTERN.test(value)) {
+    return value;
+  }
+  const input = encodeURIComponent(value);
+  const hex = [
+    hashSegment(input, 2166136261),
+    hashSegment(input, 2654435761),
+    hashSegment(input, 2246822507),
+    hashSegment(input, 3266489909)
+  ].map((part) => part.toString(16).padStart(8, "0")).join("").slice(0, 32).split("");
+  hex[12] = "0";
+  hex[16] = (Number.parseInt(hex[16] ?? "0", 16) & 3 | 8).toString(16);
+  return `${hex.slice(0, 8).join("")}-${hex.slice(8, 12).join("")}-${hex.slice(12, 16).join("")}-${hex.slice(16, 20).join("")}-${hex.slice(20, 32).join("")}`;
+}
+
+// services/advanced-memory-storage.ts
+var ENTITY_RESOLUTION_SERVICE = "entity_resolution";
+var LONG_TERM_MEMORY_TABLE = "long_term_memories";
+var SESSION_SUMMARY_TABLE = "session_summaries";
+var ADVANCED_MEMORY_SOURCE = "advanced-memory";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord(value) ? value : null;
+}
+function toJsonValue(value) {
+  if (value === null)
+    return null;
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => toJsonValue(entry)).filter((entry) => entry !== undefined);
+  }
+  if (isRecord(value)) {
+    const entries = Object.entries(value).map(([key, entry]) => {
+      const jsonValue = toJsonValue(entry);
+      return jsonValue === undefined ? null : [key, jsonValue];
+    }).filter((entry) => entry !== null);
+    return Object.fromEntries(entries);
+  }
+  return;
+}
+function toJsonRecord(value) {
+  const jsonValue = toJsonValue(value);
+  return isRecord(jsonValue) ? jsonValue : undefined;
+}
+function buildCustomMemoryMetadata(params) {
+  const metadata = {
+    ...params.existing ?? {},
+    type: "custom",
+    scope: params.scope,
+    timestamp: params.timestamp,
+    advancedMemory: params.advancedMemory
+  };
+  if (params.source) {
+    metadata.source = params.source;
+  }
+  return metadata;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value))
+    return;
+  const values = value.filter((entry) => typeof entry === "string");
+  return values.length > 0 ? values : undefined;
+}
+function toDate(value, fallback) {
+  if (value instanceof Date && Number.isFinite(value.getTime())) {
+    return value;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const parsed = new Date(value);
+    if (Number.isFinite(parsed.getTime()))
+      return parsed;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = new Date(value);
+    if (Number.isFinite(parsed.getTime()))
+      return parsed;
+  }
+  return fallback ?? new Date;
+}
+function getMemoryText(memory) {
+  return typeof memory.content?.text === "string" ? memory.content.text : "";
+}
+function getAdvancedMemoryEnvelope(memory) {
+  const metadata = asRecord(memory.metadata);
+  const advancedMemory = asRecord(metadata?.advancedMemory);
+  if (!advancedMemory) {
+    return null;
+  }
+  const kind = asString(advancedMemory.kind);
+  if (kind !== "long_term_memory" && kind !== "session_summary") {
+    return null;
+  }
+  return {
+    kind,
+    originalEntityId: asString(advancedMemory.originalEntityId),
+    anchorEntityId: asString(advancedMemory.anchorEntityId),
+    category: asString(advancedMemory.category),
+    confidence: asNumber(advancedMemory.confidence),
+    source: asString(advancedMemory.source),
+    semanticMetadata: toJsonRecord(advancedMemory.semanticMetadata),
+    messageCount: asNumber(advancedMemory.messageCount),
+    lastMessageOffset: asNumber(advancedMemory.lastMessageOffset),
+    startTime: asString(advancedMemory.startTime),
+    endTime: asString(advancedMemory.endTime),
+    topics: asStringArray(advancedMemory.topics),
+    summaryMetadata: toJsonRecord(advancedMemory.summaryMetadata),
+    updatedAt: asString(advancedMemory.updatedAt),
+    lastAccessedAt: asString(advancedMemory.lastAccessedAt),
+    accessCount: asNumber(advancedMemory.accessCount)
+  };
+}
+
+class AdvancedMemoryStorageService extends Service {
+  static serviceType = "memoryStorage";
+  capabilityDescription = "Persistent advanced-memory storage backed by SQL memory tables";
+  static async start(runtime) {
+    const service = new AdvancedMemoryStorageService;
+    await service.initialize(runtime);
+    return service;
+  }
+  async initialize(runtime) {
+    this.runtime = runtime;
+  }
+  async stop() {}
+  getMemoryWorldId() {
+    return stringToUuid(`advanced-memory:world:${this.runtime.agentId}`);
+  }
+  getLongTermRoomId(entityId) {
+    return stringToUuid(`advanced-memory:long-term:${this.runtime.agentId}:${entityId}`);
+  }
+  async ensureMemoryWorld() {
+    const worldId = this.getMemoryWorldId();
+    const world = {
+      id: worldId,
+      agentId: this.runtime.agentId,
+      name: "Advanced Memory",
+      metadata: {
+        purpose: ADVANCED_MEMORY_SOURCE
+      },
+      createdAt: new Date
+    };
+    await this.runtime.ensureWorldExists(world);
+    return worldId;
+  }
+  async ensureLongTermRoom(entityId, worldId) {
+    const roomId = this.getLongTermRoomId(entityId);
+    const room = {
+      id: roomId,
+      agentId: this.runtime.agentId,
+      worldId,
+      source: ADVANCED_MEMORY_SOURCE,
+      type: ChannelType2.SELF,
+      name: `Advanced Memory ${entityId.slice(0, 8)}`,
+      metadata: {
+        purpose: "long_term_memory",
+        entityId
+      },
+      createdAt: new Date
+    };
+    await this.runtime.ensureRoomExists(room);
+    return roomId;
+  }
+  async getEntityResolutionService() {
+    const existing = this.runtime.getService(ENTITY_RESOLUTION_SERVICE);
+    if (existing) {
+      return existing;
+    }
+    if (!this.runtime.hasService(ENTITY_RESOLUTION_SERVICE)) {
+      return null;
+    }
+    try {
+      return await this.runtime.getServiceLoadPromise(ENTITY_RESOLUTION_SERVICE);
+    } catch {
+      return null;
+    }
+  }
+  async getIdentityGroup(entityId) {
+    const resolution = await this.getEntityResolutionService();
+    if (!resolution) {
+      return new Set([entityId]);
+    }
+    const group = new Set([entityId]);
+    const queue = [entityId];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const links = await resolution.getConfirmedLinks(current);
+      for (const link of links) {
+        const other = link.entityA === current ? link.entityB : link.entityA;
+        if (!group.has(other)) {
+          group.add(other);
+          queue.push(other);
+        }
       }
     }
+    return group;
+  }
+  async getAnchorEntityId(entityId) {
+    const group = await this.getIdentityGroup(entityId);
+    return Array.from(group).sort()[0];
+  }
+  parseLongTermMemory(memory) {
+    const envelope = getAdvancedMemoryEnvelope(memory);
+    if (!envelope || envelope.kind !== "long_term_memory" || !memory.id || !memory.agentId) {
+      return null;
+    }
+    return {
+      id: memory.id,
+      agentId: memory.agentId,
+      entityId: envelope.originalEntityId ?? envelope.anchorEntityId ?? memory.entityId,
+      category: envelope.category ?? "semantic",
+      content: getMemoryText(memory),
+      metadata: envelope.semanticMetadata,
+      embedding: Array.isArray(memory.embedding) ? memory.embedding : undefined,
+      confidence: envelope.confidence,
+      source: envelope.source,
+      createdAt: toDate(memory.createdAt),
+      updatedAt: toDate(envelope.updatedAt, toDate(memory.createdAt)),
+      lastAccessedAt: envelope.lastAccessedAt ? toDate(envelope.lastAccessedAt) : undefined,
+      accessCount: envelope.accessCount ?? 0
+    };
+  }
+  parseSessionSummary(memory) {
+    const envelope = getAdvancedMemoryEnvelope(memory);
+    if (!envelope || envelope.kind !== "session_summary" || !memory.id || !memory.agentId || !memory.roomId) {
+      return null;
+    }
+    return {
+      id: memory.id,
+      agentId: memory.agentId,
+      roomId: memory.roomId,
+      entityId: envelope.originalEntityId ?? memory.entityId,
+      summary: getMemoryText(memory),
+      messageCount: envelope.messageCount ?? 0,
+      lastMessageOffset: envelope.lastMessageOffset ?? 0,
+      startTime: toDate(envelope.startTime, toDate(memory.createdAt)),
+      endTime: toDate(envelope.endTime, toDate(memory.createdAt)),
+      topics: envelope.topics,
+      metadata: envelope.summaryMetadata,
+      embedding: Array.isArray(memory.embedding) ? memory.embedding : undefined,
+      createdAt: toDate(memory.createdAt),
+      updatedAt: toDate(envelope.updatedAt, toDate(memory.createdAt))
+    };
+  }
+  sortLongTermMemories(memories) {
+    return [...memories].sort((left, right) => {
+      const leftUpdated = left.updatedAt.getTime();
+      const rightUpdated = right.updatedAt.getTime();
+      if (rightUpdated !== leftUpdated) {
+        return rightUpdated - leftUpdated;
+      }
+      const leftConfidence = left.confidence ?? 0;
+      const rightConfidence = right.confidence ?? 0;
+      if (rightConfidence !== leftConfidence) {
+        return rightConfidence - leftConfidence;
+      }
+      return right.createdAt.getTime() - left.createdAt.getTime();
+    });
+  }
+  sortSessionSummaries(summaries) {
+    return [...summaries].sort((left, right) => {
+      const leftUpdated = left.updatedAt.getTime();
+      const rightUpdated = right.updatedAt.getTime();
+      if (rightUpdated !== leftUpdated) {
+        return rightUpdated - leftUpdated;
+      }
+      return right.createdAt.getTime() - left.createdAt.getTime();
+    });
+  }
+  async storeLongTermMemory(memory) {
+    const now = new Date;
+    const anchorEntityId = await this.getAnchorEntityId(memory.entityId);
+    const worldId = await this.ensureMemoryWorld();
+    const roomId = await this.ensureLongTermRoom(anchorEntityId, worldId);
+    const advancedMemory = toJsonRecord({
+      kind: "long_term_memory",
+      originalEntityId: memory.entityId,
+      anchorEntityId,
+      category: memory.category,
+      confidence: memory.confidence,
+      source: memory.source,
+      semanticMetadata: memory.metadata,
+      updatedAt: now.toISOString(),
+      accessCount: 0
+    });
+    if (!advancedMemory) {
+      throw new Error("Long-term memory metadata is not JSON-serializable");
+    }
+    const id = await this.runtime.createMemory({
+      agentId: this.runtime.agentId,
+      entityId: anchorEntityId,
+      roomId,
+      worldId,
+      content: { text: memory.content },
+      metadata: buildCustomMemoryMetadata({
+        scope: "shared",
+        timestamp: now.getTime(),
+        source: memory.source,
+        advancedMemory
+      }),
+      embedding: memory.embedding,
+      createdAt: now.getTime(),
+      unique: false
+    }, LONG_TERM_MEMORY_TABLE, false);
+    const stored = await this.runtime.getMemoryById(id);
+    const parsed = stored ? this.parseLongTermMemory(stored) : null;
+    if (!parsed) {
+      throw new Error("Failed to persist long-term memory");
+    }
+    return parsed;
+  }
+  async getLongTermMemories(agentId, entityId, opts) {
+    const group = await this.getIdentityGroup(entityId);
+    const roomIds = Array.from(group).map((memberEntityId) => this.getLongTermRoomId(memberEntityId));
+    if (roomIds.length === 0) {
+      return [];
+    }
+    const memories = await this.runtime.getMemoriesByRoomIds({
+      tableName: LONG_TERM_MEMORY_TABLE,
+      roomIds,
+      limit: Math.max((opts?.limit ?? 20) * roomIds.length * 4, 80)
+    });
+    const filtered = memories.filter((memory) => memory.agentId === agentId).map((memory) => this.parseLongTermMemory(memory)).filter((memory) => memory !== null).filter((memory) => opts?.category ? memory.category === opts.category : true);
+    return this.sortLongTermMemories(filtered).slice(0, opts?.limit ?? 20);
+  }
+  async updateLongTermMemory(id, agentId, entityId, updates) {
+    const existing = await this.runtime.getMemoryById(id);
+    const parsed = existing ? this.parseLongTermMemory(existing) : null;
+    if (!existing || !parsed || existing.agentId !== agentId) {
+      throw new Error(`Long-term memory ${id} not found`);
+    }
+    const allowedGroup = await this.getIdentityGroup(entityId);
+    if (!allowedGroup.has(parsed.entityId)) {
+      throw new Error(`Long-term memory ${id} does not belong to entity ${entityId}`);
+    }
+    const currentEnvelope = getAdvancedMemoryEnvelope(existing);
+    const updatedAt = new Date;
+    const advancedMemory = toJsonRecord({
+      ...currentEnvelope ?? {},
+      kind: "long_term_memory",
+      originalEntityId: currentEnvelope?.originalEntityId ?? entityId,
+      anchorEntityId: parsed.entityId,
+      category: updates.category ?? parsed.category,
+      confidence: updates.confidence ?? parsed.confidence,
+      source: updates.source ?? parsed.source,
+      semanticMetadata: updates.metadata ?? parsed.metadata,
+      updatedAt: updatedAt.toISOString(),
+      lastAccessedAt: updates.lastAccessedAt?.toISOString(),
+      accessCount: updates.accessCount ?? parsed.accessCount ?? 0
+    });
+    if (!advancedMemory) {
+      throw new Error("Updated long-term memory metadata is not JSON-serializable");
+    }
+    await this.runtime.updateMemory({
+      id,
+      content: {
+        text: updates.content ?? parsed.content
+      },
+      metadata: buildCustomMemoryMetadata({
+        existing: asRecord(existing.metadata),
+        scope: "shared",
+        timestamp: updatedAt.getTime(),
+        source: updates.source ?? parsed.source,
+        advancedMemory
+      }),
+      ...updates.embedding ? { embedding: updates.embedding } : {}
+    });
+  }
+  async deleteLongTermMemory(id, agentId, entityId) {
+    const existing = await this.runtime.getMemoryById(id);
+    const parsed = existing ? this.parseLongTermMemory(existing) : null;
+    if (!existing || !parsed || existing.agentId !== agentId) {
+      throw new Error(`Long-term memory ${id} not found`);
+    }
+    const allowedGroup = await this.getIdentityGroup(entityId);
+    if (!allowedGroup.has(parsed.entityId)) {
+      throw new Error(`Long-term memory ${id} does not belong to entity ${entityId}`);
+    }
+    await this.runtime.deleteMemory(id);
+  }
+  async storeSessionSummary(summary) {
+    const now = new Date;
+    const advancedMemory = toJsonRecord({
+      kind: "session_summary",
+      originalEntityId: summary.entityId,
+      messageCount: summary.messageCount,
+      lastMessageOffset: summary.lastMessageOffset,
+      startTime: summary.startTime.toISOString(),
+      endTime: summary.endTime.toISOString(),
+      topics: summary.topics,
+      summaryMetadata: summary.metadata,
+      updatedAt: now.toISOString()
+    });
+    if (!advancedMemory) {
+      throw new Error("Session summary metadata is not JSON-serializable");
+    }
+    const id = await this.runtime.createMemory({
+      agentId: this.runtime.agentId,
+      entityId: summary.entityId ?? this.runtime.agentId,
+      roomId: summary.roomId,
+      worldId: this.getMemoryWorldId(),
+      content: { text: summary.summary },
+      metadata: buildCustomMemoryMetadata({
+        scope: "room",
+        timestamp: now.getTime(),
+        advancedMemory
+      }),
+      embedding: summary.embedding,
+      createdAt: now.getTime(),
+      unique: false
+    }, SESSION_SUMMARY_TABLE, false);
+    const stored = await this.runtime.getMemoryById(id);
+    const parsed = stored ? this.parseSessionSummary(stored) : null;
+    if (!parsed) {
+      throw new Error("Failed to persist session summary");
+    }
+    return parsed;
+  }
+  async getCurrentSessionSummary(agentId, roomId) {
+    const summaries = await this.getSessionSummaries(agentId, roomId, 1);
+    return summaries[0] ?? null;
+  }
+  async updateSessionSummary(id, agentId, roomId, updates) {
+    const existing = await this.runtime.getMemoryById(id);
+    const parsed = existing ? this.parseSessionSummary(existing) : null;
+    if (!existing || !parsed || existing.agentId !== agentId || existing.roomId !== roomId) {
+      throw new Error(`Session summary ${id} not found`);
+    }
+    const currentEnvelope = getAdvancedMemoryEnvelope(existing);
+    const updatedAt = new Date;
+    const advancedMemory = toJsonRecord({
+      ...currentEnvelope ?? {},
+      kind: "session_summary",
+      originalEntityId: currentEnvelope?.originalEntityId ?? parsed.entityId,
+      messageCount: updates.messageCount ?? parsed.messageCount,
+      lastMessageOffset: updates.lastMessageOffset ?? parsed.lastMessageOffset,
+      startTime: (updates.startTime ?? parsed.startTime).toISOString(),
+      endTime: (updates.endTime ?? parsed.endTime).toISOString(),
+      topics: updates.topics ?? parsed.topics,
+      summaryMetadata: updates.metadata ?? parsed.metadata,
+      updatedAt: updatedAt.toISOString()
+    });
+    if (!advancedMemory) {
+      throw new Error("Updated session summary metadata is not JSON-serializable");
+    }
+    await this.runtime.updateMemory({
+      id,
+      content: {
+        text: updates.summary ?? parsed.summary
+      },
+      metadata: buildCustomMemoryMetadata({
+        existing: asRecord(existing.metadata),
+        scope: "room",
+        timestamp: updatedAt.getTime(),
+        advancedMemory
+      }),
+      ...updates.embedding ? { embedding: updates.embedding } : {}
+    });
+  }
+  async getSessionSummaries(agentId, roomId, limit = 5) {
+    if (limit <= 0) {
+      return [];
+    }
+    const memories = await this.runtime.getMemories({
+      agentId,
+      roomId,
+      tableName: SESSION_SUMMARY_TABLE,
+      count: Math.max(limit * 4, 20),
+      unique: false
+    });
+    return this.sortSessionSummaries(memories.map((memory) => this.parseSessionSummary(memory)).filter((memory) => memory !== null)).slice(0, limit);
   }
 }
 
@@ -7065,21 +8067,26 @@ function createDatabaseAdapter(config, agentId) {
   }
   const dataDir = resolvePgliteDir(config.dataDir);
   if (dataDir && !dataDir.includes("://")) {
-    mkdirSync2(dataDir, { recursive: true });
+    mkdirSync(dataDir, { recursive: true });
   }
   if (!shouldReusePgliteManager(globalSingletons.pgLiteClientManager)) {
     globalSingletons.pgLiteClientManager = new PGliteClientManager({ dataDir });
   }
-  return new PgliteDatabaseAdapter(agentId, globalSingletons.pgLiteClientManager);
+  const manager = globalSingletons.pgLiteClientManager;
+  if (!manager) {
+    throw new Error("[plugin-sql] pgLiteClientManager not initialized before adapter creation");
+  }
+  return new PgliteDatabaseAdapter(agentId, manager);
 }
 var plugin = {
   name: "@elizaos/plugin-sql",
   description: "A plugin for SQL database access with dynamic schema migrations",
   priority: 0,
   schema: exports_schema,
+  services: [AdvancedMemoryStorageService],
   init: async (_, runtime) => {
-    runtime.logger.info({ src: "plugin:sql", agentId: runtime.agentId }, "plugin-sql init starting");
     const runtimeWithAdapter = runtime;
+    runtime.logger.info({ src: "plugin:sql", agentId: runtime.agentId }, "plugin-sql init starting");
     const adapterRegistered = typeof runtimeWithAdapter.hasDatabaseAdapter === "function" ? runtimeWithAdapter.hasDatabaseAdapter() : (() => {
       try {
         const existing = runtimeWithAdapter.getDatabaseAdapter?.() ?? runtimeWithAdapter.databaseAdapter ?? runtimeWithAdapter.adapter;
@@ -7099,24 +8106,67 @@ var plugin = {
       dataDir: typeof dataDir === "string" ? dataDir : undefined,
       postgresUrl: typeof postgresUrl === "string" ? postgresUrl : undefined
     }, runtime.agentId);
-    runtime.registerDatabaseAdapter(dbAdapter);
+    runtimeWithAdapter.registerDatabaseAdapter(dbAdapter);
+    await dbAdapter.initialize();
     runtime.logger.info({ src: "plugin:sql", agentId: runtime.agentId }, "Database adapter created and registered");
   }
 };
 var typescript_default = plugin;
 export {
+  worldTable,
   uninstallRLS,
+  taskTable,
   setServerContext,
+  sessionSummaries,
+  serverTable,
   exports_schema as schema,
+  roomTable,
+  relationshipTable,
   plugin,
+  participantTable,
+  pairingRequestTable,
+  pairingAllowlistTable,
+  messageTable,
+  messageServerTable,
+  messageServerAgentsTable,
+  memoryTable,
+  memoryAccessLogs,
+  longTermMemories,
+  logTable,
+  isFatalPgliteErrorCode,
   installRLSFunctions,
+  getRow,
+  getPgliteErrorCode,
   getOrCreateRlsServer,
+  getDb,
+  factCandidateTable,
+  entityTable,
+  entityMergeCandidateTable,
+  entityIdentityTable,
+  embeddingTable,
   typescript_default as default,
+  createPgliteInitError,
   createDatabaseAdapter,
+  componentTable,
+  channelTable,
+  channelParticipantsTable,
+  cacheTable,
+  authSessionTable,
+  authOwnerLoginTokenTable,
+  authOwnerBindingTable,
+  authIdentityTable,
+  authIdentityCreatedAtDefault,
+  authBootstrapJtiSeenTable,
+  authAuditEventTable,
   assignAgentToServer,
+  approvalRequestTable,
   applyRLSToNewTables,
-  DatabaseMigrationService
+  agentTable,
+  PgliteInitError,
+  PGLITE_ERROR_CODES,
+  DatabaseMigrationService,
+  AdvancedMemoryStorageService
 };
 
-//# debugId=606A9AD08C7E6C2364756E2164756E21
+//# debugId=064AB64C70B2F55A64756E2164756E21
 //# sourceMappingURL=index.node.js.map